Was sind die Anforderungen an formale Golang-Parameter?

Die Parameter von Funktionen in der Go-Sprache sind formale Parameter, bei denen es sich um lokale Variablen handelt, und ihre Werte werden vom Parameteraufrufer bereitgestellt. Wenn die Typen benachbarter formaler Parameter gleich sind, können die Typen der ersten paar Parameter identisch sein weggelassen werden und einfach schreiben Der Typ des letzten Parameters reicht aus, die Syntax „func funcName(formaler Parameter 1, formaler Parameter 2 Parametertyp 1, formaler Parameter 3, formaler Parameter 4 Parametertyp 2, ...) (Rückgabewertliste ) { //Anweisung ausführen. ..Rückgabewertliste}".

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Funktionsparameter der Go-Sprache

Die Parameter der Funktion in der Go-Sprache sind formale Parameter, das heißt, wenn wir einen Wert übergeben, sind die übergebenen Parameter tatsächlich eine Kopie der tatsächlichen Parameter, nicht die echten tatsächliche Parameter. Formale Parameter sind lokale Variablen, deren Werte vom Aufrufer des Parameters bereitgestellt werden.

Wenn in der Go-Sprache mehrere benachbarte Funktionsparameter denselben Typ haben, können wir die Typen der ersten paar Parameter weglassen und müssen nur den Typ des letzten Parameters schreiben.

func funcName(param1, param2 paramType1, param3, param4 paramType2, ...)(returnVal returnType){	// 执行语句...
	return 返回值列表
}

Erklärung

• Die Parameter param1 und Parameter param2 haben den gleichen Typ, dann können wir den Parametertyp nach param1 weglassen und den Typ direkt nach param2 schreiben.

• Die Parameter param3 und Parameter param4 haben den gleichen Typ, dann können wir den Parametertyp nach param3 weglassen und den Typ direkt nach param4 schreiben.

• returnVal returnType ist die Rückgabewertliste, die den Variablennamen und den Typ des Funktionsrückgabewerts beschreibt. Wenn die Funktion eine unbenannte Variable oder keinen Rückgabewert zurückgibt, können die Klammern in der Rückgabewertliste weggelassen werden.

Fall

Verwenden Sie eine Funktion, um den größten gemeinsamen Teiler zweier Zahlen zu finden

package main
import (
	"fmt"
)
func gcdNormal(x, y int) int {
	var n int
	if x > y {
		n = y
	} else {
		n = x
	}
	for i := n; i >= 1; i-- {
		if x%i == 0 && y%i == 0 {
			return i
		}
	}
	return 1
}
func main() {
	//用函数，实现计算两个数的最大公约数
	gcd := gcdNormal(10,20)
	fmt.Println("Gcd =", gcd)
}

Nachdem das Programm ausgeführt wurde, lautet die Konsolenausgabe wie folgt:

Wir haben a definiert Funktion gcdNormal, Übergabe von zwei Parametern vom Typ int a und b, und die Funktion gibt eine Variable vom Typ int zurück. Diese Funktion verwendet die erschöpfende Methode, um die Logik zum Ermitteln des größten gemeinsamen Teilers von Parameter a und Parameter b zu implementieren. Da die Typen von Parameter a und Parameter b beide int-Typen sind, lassen wir den Typ nach Parameter a weg und schreiben ihn direkt in Parameter b. später.

In der Funktion main() haben wir die Funktion gcdNormal aufgerufen und die beiden Parameter 10 und 20 übergeben, die Variable gcd verwendet, um den von der Funktion gcdNormal zurückgegebenen Wert zu akzeptieren, und schließlich die Funktion Println() verwendet, um das Finale zu drucken Ergebnis.

Funktionsparameter sind formale Parameter

Die Funktionsparameter der Go-Sprache sind formale Parameter, und Änderungen an den Funktionsparametern haben keinen Einfluss auf die tatsächlichen Parameter

package main
import (
"fmt"
)
func change(a int) {
a += 100
}
func main() {
//Go语言的函数参数是函数参数，对函数参数的修改不会影响实参
a := 10
change(a)
fmt.Println("a =", a)
}

Nachdem das Programm ausgeführt wurde, lautet die Konsolenausgabe wie folgt:

Wir definieren eine Funktion change() und übergeben einen Parameter a vom Typ int. Fügen Sie im Funktionskörper 100 zum Parameter der Funktion hinzu.

In der Funktion main() rufen Sie diese Funktion auf und übergeben die Variable a. Nach der Ausführung der Funktion change() geben wir den Wert der Variablen a erneut aus und stellen fest, dass der Wert von a immer noch 10 und nicht 110 ist 100 addieren.

Da in der Go-Sprache die Parameter der Funktion formale Parameter sind, also Kopien der tatsächlichen Parameter, werden also nicht die tatsächlichen Parameter geändert, sodass sich der Wert von a nicht ändert.

Aktuelle Parameter durch Funktionsparameter ändern

Um tatsächliche Parameter durch Funktionsparameter in Go-Sprachfunktionen zu ändern, müssen Sie Zeigertypen verwenden

package main
import (
	"fmt"
)
func change(a *int) {
	*a += 100
}
func main() {
	//Go语言的函数要通过函数参数修改实参，必须要使用指针类型
	a := 10
	change(&a)
	fmt.Println("a =", a)
}

Wir definieren eine Funktion change() und übergeben einen Parameter vom Typ int-Zeiger a implementiert im Funktionskörper die Operation des Addierens von 100 zu den Parametern der Funktion.

In der Funktion main() rufen Sie diese Funktion auf und übergeben die Adresse der Variablen a. Nach der Ausführung der Funktion change() drucken wir den Wert der Variablen a erneut und stellen fest, dass der Wert von a um 100 erhöht wurde 110.

Die Funktion change() übergibt hier die Adresse von a. Dann verwenden wir den Zeigeroperator in der Funktion change(), um die Variable abzurufen, auf die die Adresse von a zeigt, und ändern dann ihren Wert Geändert ist die Variable a ihr eigener Wert.

Zusammenfassung der Funktionsparameter der Go-Sprache

Die Parameter von Funktionen in der Go-Sprache sind formale Parameter, das heißt, wenn wir einen Wert übergeben, sind die übergebenen Parameter tatsächlich eine Kopie der tatsächlichen Parameter, nicht die tatsächlichen Parameter.

Wenn in der Go-Sprache mehrere benachbarte Funktionsparameter denselben Typ haben, können wir die Typen der ersten paar Parameter weglassen und müssen nur den Typ des letzten Parameters schreiben.

Weitere Kenntnisse zum Thema Programmierung finden Sie unter: Programmiervideos! !

Das obige ist der detaillierte Inhalt vonWas sind die Anforderungen an formale Golang-Parameter?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!