Fermetures de fonctions (fonctions anonymes) du langage Go
Le langage Go prend en charge les fonctions anonymes, qui peuvent être utilisées comme fermetures. Une fonction anonyme est une instruction ou une expression « inline ». L'avantage des fonctions anonymes est qu'elles peuvent utiliser directement les variables à l'intérieur de la fonction sans avoir besoin de les déclarer.
Une fonction anonyme est une fonction sans nom de fonction, généralement utilisée pour définir des fonctions à l'intérieur d'autres fonctions, ou pour être passée comme paramètre de fonction.
Dans l'exemple suivant, nous créons la fonction getSequence(), qui renvoie une autre fonction. Le but de cette fonction est d'incrémenter la variable i dans une fermeture, comme montré dans le code ci-dessous :
Exemple
import "fmt"
func getSequence() func() int {
i:=0
return func() int {
i+=1
return i
}
}
func main(){
/* nextNumber est une fonction, avec i initialisé à 0 */
nextNumber := getSequence()
/* Appeler la fonction nextNumber, la variable i est incrémentée de 1 et renvoyée */
fmt.Println(nextNumber())
fmt.Println(nextNumber())
fmt.Println(nextNumber())
/* Créer une nouvelle fonction nextNumber1 et vérifier le résultat */
nextNumber1 := getSequence()
fmt.Println(nextNumber1())
fmt.Println(nextNumber1())
}
Le résultat d'exécution du code ci-dessus est :
1 2 3 1 2
Dans les exemples suivants, nous définissons plusieurs fonctions anonymes et montrons comment affecter des fonctions anonymes à des variables, utiliser des fonctions anonymes à l'intérieur d'autres fonctions et passer des fonctions anonymes comme arguments à d'autres fonctions.
Exemple
import "fmt"
func main() {
// Définir une fonction anonyme et l'affecter à la variable add
add := func(a, b int) int {
return a + b
}
// Appeler la fonction anonyme
result := add(3, 5)
fmt.Println("3 + 5 =", result)
// Utiliser une fonction anonyme à l'intérieur d'une fonction
multiply := func(x, y int) int {
return x * y
}
product := multiply(4, 6)
fmt.Println("4 * 6 =", product)
// Passer une fonction anonyme comme argument à d'autres fonctions
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)
// Vous pouvez également définir une fonction anonyme directement dans un appel de fonction
difference := calculate(func(a, b int) int {
return a - b
}, 10, 4)
fmt.Println("10 - 4 =", difference)
}
Le résultat d'exécution du code ci-dessus est :
3 + 5 = 8 4 * 6 = 24 2 + 8 = 10 10 - 4 = 6
L'utilisation de fonctions anonymes en Go est très flexible et peut aider à simplifier la structure du code et améliorer sa lisibilité.
autres extensions