Funktions-Closures (anonyme Funktionen) in der Sprache Go

Go-Funktionen

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

package main

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

package main

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.

Go-Funktionen

Weitere Erweiterungen