Funktions-Closures (anonyme Funktionen) in der Sprache Go
Die Sprache Go unterstützt anonyme Funktionen, die als Closures verwendet werden können. Eine anonyme Funktion ist eine "inline"-Anweisung oder ein Ausdruck. Der Vorteil anonymer Funktionen besteht darin, dass sie direkt Variablen innerhalb der Funktion verwenden können, ohne sie deklarieren zu müssen.
Eine anonyme Funktion ist eine Funktion ohne Funktionsnamen, die typischerweise verwendet wird, um Funktionen innerhalb anderer Funktionen zu definieren oder als Funktionsparameter übergeben zu werden.
Im folgenden Beispiel erstellen wir die Funktion getSequence(), die eine weitere Funktion zurückgibt. Der Zweck dieser Funktion besteht darin, die Variable i innerhalb eines Closures zu inkrementieren, wie im folgenden Code gezeigt:
Beispiel
import "fmt"
func getSequence() func() int {
i:=0
return func() int {
i+=1
return i
}
}
func main(){
/* nextNumber ist eine Funktion, wobei i mit 0 initialisiert wird */
nextNumber := getSequence()
/* Rufen Sie die Funktion nextNumber auf, die Variable i wird um 1 erhöht und zurückgegeben */
fmt.Println(nextNumber())
fmt.Println(nextNumber())
fmt.Println(nextNumber())
/* Erstellen Sie eine neue Funktion nextNumber1 und überprüfen Sie das Ergebnis */
nextNumber1 := getSequence()
fmt.Println(nextNumber1())
fmt.Println(nextNumber1())
}
Das Ausführungsergebnis des obigen Codes ist:
1 2 3 1 2
In den folgenden Beispielen definieren wir mehrere anonyme Funktionen und zeigen, wie man anonyme Funktionen Variablen zuweist, anonyme Funktionen innerhalb anderer Funktionen verwendet und anonyme Funktionen als Argumente an andere Funktionen übergibt.
Beispiel
import "fmt"
func main() {
// Definieren Sie eine anonyme Funktion und weisen Sie sie der Variablen add zu
add := func(a, b int) int {
return a + b
}
// Rufen Sie die anonyme Funktion auf
result := add(3, 5)
fmt.Println("3 + 5 =", result)
// Eine anonyme Funktion innerhalb einer Funktion verwenden
multiply := func(x, y int) int {
return x * y
}
product := multiply(4, 6)
fmt.Println("4 * 6 =", product)
// Eine anonyme Funktion als Argument an andere Funktionen übergeben
calculate := func(operation func(int, int) int, x, y int) int {
return operation(x, y)
}
sum := calculate(add, 2, 8)
fmt.Println("2 + 8 =", sum)
// Du kannst eine anonyme Funktion auch direkt in einem Funktionsaufruf definieren
difference := calculate(func(a, b int) int {
return a - b
}, 10, 4)
fmt.Println("10 - 4 =", difference)
}
Das Ausführungsergebnis des obigen Codes ist:
3 + 5 = 8 4 * 6 = 24 2 + 8 = 10 10 - 4 = 6
Die Verwendung anonymer Funktionen in Go ist sehr flexibel und kann helfen, die Codestruktur zu vereinfachen und die Lesbarkeit des Codes zu verbessern.
Weitere Erweiterungen