Fonctions anonymes en Golang

Introduction

Dans les laboratoires précédents, vous avez appris à écrire et à utiliser des fonctions nommées, à organiser le code en modules et à améliorer la lisibilité du code en divisant la logique en fonctions distinctes. Dans ce laboratoire, nous allons explorer les fonctions anonymes, un type spécial de fonction qui n'a pas de nom. Les fonctions anonymes sont utiles lorsque vous souhaitez définir un petit morceau de logique "sur place" sans avoir à déclarer une fonction nommée distincte. Elles sont particulièrement utiles pour les opérations courtes et autonomes, ou lorsque vous devez passer une fonction en tant qu'argument à une autre fonction (comme dans les callbacks). En utilisant des fonctions anonymes, vous pouvez écrire un code plus concis et expressif.

Principaux sujets :

Qu'est-ce que sont les fonctions anonymes et comment les définir
Pourquoi et quand utiliser des fonctions anonymes
Appeler des fonctions anonymes sans les assigner à un nom
Passer des paramètres aux fonctions anonymes et retourner des valeurs
Utiliser des fonctions anonymes comme fonctions de rappel (callbacks) pour un code plus flexible

Comprendre les fonctions anonymes

Une fonction anonyme en Go est définie de la même manière qu'une fonction normale, sauf qu'elle n'a pas de nom. Au lieu de cela, vous pouvez l'affecter à une variable, la passer en tant qu'argument ou l'exécuter immédiatement après sa définition. Cela les rend bien adaptées pour les opérations courtes et ponctuelles, ou pour passer des fonctions en tant qu'arguments à d'autres fonctions. Les fonctions anonymes sont particulièrement utiles lorsqu'une fonction n'est nécessaire qu'une seule fois et ne justifie pas une fonction nommée distincte. Elles peuvent aider à rendre votre code plus lisible en gardant la logique proche de l'endroit où elle est utilisée.

Syntaxe d'une fonction anonyme :

func(input parameters)(return parameters) {
    // code block
}

Cela ressemble à la définition d'une fonction régulière, mais sans le nom de la fonction.

En la comparant à une déclaration de fonction régulière :

// Regular function declaration
func functionName(parameters...)(return values...) {
    code block
}

Pourquoi utiliser des fonctions anonymes?

Concision : Elles vous permettent de définir de petits morceaux de logique sans avoir à créer une fonction nommée distincte, rendant le code plus concis.
Portée locale : La portée des fonctions anonymes est à l'intérieur de la fonction environnante, limitant ainsi la pollution de l'espace de noms.
Flexibilité : Elles peuvent être passées en tant qu'arguments à d'autres fonctions ou définies et exécutées immédiatement.

Quand utiliser des fonctions anonymes?

Lorsque vous avez besoin d'une fonction courte qui ne sera pas réutilisée ailleurs.
En tant que fonctions de rappel (callbacks) (nous verrons cela plus tard).
Lorsque vous souhaitez exécuter une fonction immédiatement (souvent pour l'initialisation).

Création d'une fonction anonyme sans paramètres

Commençons par un exemple simple qui affiche "hello world" en utilisant une fonction anonyme. Tout d'abord, créez un fichier nommé anonymous.go dans le répertoire du projet :

cd ~/project
touch anonymous.go

Ouvrez le fichier anonymous.go et ajoutez le code suivant :

package main

import "fmt"

func main() {
    // Define an anonymous function and assign it to a variable f
    f := func() {
        fmt.Println("hello world")
    }

    // Call the anonymous function via the variable f
    f()
}

Exécutez le programme :

go run anonymous.go

Sortie attendue :

hello world

Ici, nous avons défini une fonction anonyme en utilisant la syntaxe func() {... }. Cette fonction ne prend aucun paramètre et ne renvoie aucune valeur. Nous avons assigné cette fonction anonyme à la variable f. Ensuite, nous appelons la fonction en utilisant f(). Cela exécute la fonction anonyme et affiche "hello world".

Utilisation de paramètres dans les fonctions anonymes

Les fonctions anonymes peuvent accepter des paramètres tout comme les fonctions régulières. Modifions notre code pour passer une chaîne de caractères en tant que paramètre.

Remplacez le contenu de anonymous.go par :

package main

import "fmt"

func main() {
    f := func(s string) {
        fmt.Println(s)
    }
    f("hello world")
}

Exécutez le programme :

go run anonymous.go

Sortie attendue :

hello world

Cette fois, notre fonction anonyme prend un paramètre de type chaîne de caractères s. La partie func(s string) définit que la fonction anonyme prend un paramètre nommé s de type chaîne de caractères. Lorsque nous appelons f("hello world"), la chaîne de caractères "hello world" est passée à la fonction, qui l'affiche ensuite dans la console. Cela montre comment vous pouvez passer des valeurs dans des fonctions anonymes pour les rendre plus polyvalentes.

Retourner des valeurs à partir de fonctions anonymes

Les fonctions anonymes peuvent également retourner des valeurs. Créons une fonction anonyme qui prend deux entiers en paramètres et retourne leur somme.

Remplacez le contenu de anonymous.go par :

package main

import "fmt"

func main() {
    f := func(a, b int) int {
        return a + b
    }
    result := f(3, 5)
    fmt.Println(result)
}

Exécutez le programme :

go run anonymous.go

Sortie attendue :

Maintenant, la signature de la fonction anonyme est func(a, b int) int. Cela signifie qu'elle prend deux entiers (a et b) en entrée et retourne un entier en sortie. Le corps de la fonction, return a + b, calcule et retourne leur somme. Lorsque nous appelons f(3, 5), cela exécute la fonction anonyme avec les arguments 3 et 5, et le résultat 8 est retourné. Nous stockons ensuite ce résultat dans la variable result et l'affichons dans la console.

Déclaration et appel immédiat de fonctions anonymes

Vous pouvez définir et appeler une fonction anonyme en une seule fois, sans l'affecter à une variable. Cela peut être pratique pour des opérations rapides et ponctuelles.

Mettez à jour le fichier anonymous.go :

package main

import "fmt"

func main() {
    res := func(a, b int) int {
        return a + b
    }(3, 5) // Call the anonymous function directly here
    fmt.Println(res)
}

Exécutez le programme :

go run anonymous.go

Sortie attendue :

Ici, nous avons défini la fonction anonyme func(a, b int) int { return a + b } et l'avons immédiatement invoquée en ajoutant (3, 5) après la déclaration de la fonction. Cette syntaxe func(...) {...}(...) vous permet de définir et d'appeler une fonction dans une seule expression. Les arguments entre parenthèses sont passés immédiatement à la fonction. Dans ce cas, elle retourne la somme de 3 et 5, qui est ensuite affectée à la variable res. C'est une pratique courante pour les fonctions simples à exécution immédiate, et est utile pour l'initialisation ou les calculs courts.

Utilisation de fonctions anonymes comme fonctions de rappel

Les fonctions anonymes peuvent également être utilisées comme fonctions de rappel (callbacks), ce qui signifie que nous pouvons les passer en tant qu'arguments à d'autres fonctions. Cela est utile lorsque vous souhaitez personnaliser le comportement d'une fonction sans créer de fonction nommée.

Qu'est-ce qu'une fonction de rappel (callback)?

Une fonction de rappel (callback) est une fonction qui est passée en tant qu'argument à une autre fonction et qui est exécutée après que la première fonction ait terminé sa tâche. Cela permet à l'appelant de personnaliser le comportement de la fonction appelée, offrant plus de flexibilité et de modularité. En essence, la fonction recevant un callback appellera la fonction de rappel "en retour" à un certain moment.

Pourquoi utiliser des fonctions anonymes comme callbacks?

Les fonctions anonymes fonctionnent exceptionnellement bien comme fonctions de rappel (callbacks) car elles représentent souvent des comportements courts et spécifiques qui ne sont utilisés que dans un contexte particulier. Utiliser une fonction anonyme comme callback rend le code plus concis et évite de devoir définir une fonction nommée distincte.

Remplacez le contenu de anonymous.go par le code suivant :

package main

import (
    "fmt"
    "math"
)

// 'visit' takes a slice and a function. It applies the function to each element in the slice.
func visit(lst []float64, f func(float64)) {
    for _, value := range lst {
        f(value)
    }
}

func main() {
    arr := []float64{1, 2, 3, 4, 5, 6, 7, 8, 9}

    // Use an anonymous function to sum each element with itself
    visit(arr, func(v float64) {
        fmt.Printf("Sum:%.0f ", v+v)
    })
    fmt.Println()

    // Use an anonymous function to multiply each element by itself
    visit(arr, func(v float64) {
        fmt.Printf("Product:%.0f ", v*v)
    })
    fmt.Println()

    // Use an anonymous function to square each element using math.Pow
    visit(arr, func(v float64) {
        v = math.Pow(v, 2)
        fmt.Printf("Square:%.0f ", v)
    })
    fmt.Println()
}

Exécutez le programme :

go run anonymous.go

Sortie attendue :

Sum:2 Sum:4 Sum:6 Sum:8 Sum:10 Sum:12 Sum:14 Sum:16 Sum:18
Product:1 Product:4 Product:9 Product:16 Product:25 Product:36 Product:49 Product:64 Product:81
Square:1 Square:4 Square:9 Square:16 Square:25 Square:36 Square:49 Square:64 Square:81

Dans ce programme, nous créons d'abord une fonction visit qui prend un tableau (lst) de float64 et une fonction (f) de type func(float64). La fonction visit itère sur le tableau et appelle la fonction f fournie pour chaque élément. Ce modèle de conception permet à la fonction visit d'exécuter une logique différente en fonction de la fonction de rappel (callback) f fournie.

À l'intérieur de la fonction main, nous appelons visit trois fois avec différentes fonctions anonymes pour démontrer comment les callbacks offrent de la flexibilité.

La première fonction anonyme calcule la somme de chaque élément avec lui-même.
La deuxième fonction anonyme calcule le produit de chaque élément avec lui-même.
La troisième fonction anonyme élève chaque élément au carré en utilisant math.Pow.

Cela illustre comment une fonction anonyme peut être passée comme callback et comment la fonction visit peut effectuer différentes actions en fonction de la fonction de rappel (callback) passée en tant que paramètre. Cela rend votre code plus réutilisable et modulaire.

Résumé

Dans ce laboratoire, vous avez appris à connaître les fonctions anonymes en Go. Les fonctions anonymes n'ont pas de nom et sont souvent utilisées pour des morceaux de logique courts et jetables. Elles peuvent :

Être assignées à des variables et appelées plus tard.
Prendre des paramètres et retourner des valeurs.
Être définies et appelées immédiatement.
Servir de fonctions de rappel (callbacks) lorsqu'elles sont passées en tant qu'arguments à d'autres fonctions, permettant un comportement hautement flexible et personnalisable.

Les fonctions anonymes vous offrent flexibilité et commodité, surtout lorsque vous avez besoin de logique personnalisée "sur le moment" sans encombrer votre base de code avec trop de fonctions nommées. En les utilisant efficacement, vous pouvez créer des programmes Go plus expressifs, concis et modulaires. Elles sont un outil puissant pour écrire un code plus propre, plus lisible et plus flexible.