Fonctions en langage Go comme arguments
En Go, les fonctions sont des citoyens de première classe ; elles peuvent être assignées, passées et utilisées comme des variables ordinaires. Passer une fonction comme argument à une autre fonction est un modèle de programmation courant en Go, souvent utilisé dans des scénarios tels que les rappels et les patrons de stratégie.
Fonction assignée à une variable
Une fonction peut être assignée à une variable, et la fonction peut être appelée via cette variable :
Exemple
import (
"fmt"
"math"
)
func main() {
/* Affecter la fonction anonyme à la variable getSquareRoot */
getSquareRoot := func(x float64) float64 {
return math.Sqrt(x)
}
/* Appeler la fonction via la variable */
fmt.Println(getSquareRoot(9)) // Sortie : 3
fmt.Println(getSquareRoot(16)) // Sortie : 4
}
Le résultat d'exécution du code ci-dessus est :
3 4
Passer des fonctions en arguments
Lorsqu'on passe une fonction comme argument à une autre fonction, le récepteur doit déclarer un paramètre de type fonction correspondant. L'exemple suivant définit uneapplyfonction qui prend une fonction d'opération et deux opérandes, effectuant toute opération spécifiée sur les deux nombres :
Exemple
import (
"fmt"
"math"
)
/* Définir une fonction qui prend un paramètre op de type fonction */
/* le type de op est func(float64, float64) float64, ce qui signifie qu'il accepte deux paramètres float64 et renvoie un float64 */
func apply(op func(float64, float64) float64, a, b float64) float64 {
return op(a, b)
}
func main() {
/* Définir la fonction d'addition */
add := func(a, b float64) float64 {
return a + b
}
/* Définir la fonction de multiplication */
multiply := func(a, b float64) float64 {
return a * b
}
/* Passer la fonction add comme argument effectif à apply */
fmt.Println(apply(add, 3, 4)) // Sortie : 7
/* Passer la fonction multiply comme argument effectif à apply */
fmt.Println(apply(multiply, 3, 4)) // Sortie : 12
/* Vous pouvez également passer directement une fonction anonyme */
fmt.Println(apply(func(a, b float64) float64 {
return math.Pow(a, b) // a élevé à la puissance b
}, 2, 10)) // Sortie : 1024
}
Le résultat d'exécution du code ci-dessus est :
7 12 1024
Application pratique : règles de tri personnalisées
L'une des applications les plus courantes des fonctions comme arguments est la personnalisation des règles de tri. La bibliothèque standard de Gosort.SliceElle prend une fonction de comparaison en paramètre :
Exemple
import (
"fmt"
"sort"
)
func main() {
nums := []int{5, 2, 8, 1, 9, 3}
/* Passer la fonction de comparaison comme argument réel à sort.Slice pour trier du plus petit au plus grand */
sort.Slice(nums, func(i, j int) bool {
return nums[i] < nums[j]
})
fmt.Println("Ascending:", nums) // Sortie : Ascending: [1 2 3 5 8 9]
/* Passer une fonction de comparaison différente pour trier du plus grand au plus petit */
sort.Slice(nums, func(i, j int) bool {
return nums[i] > nums[j]
})
fmt.Println(Descending:, nums) // Sortie : descending: [9 8 5 3 2 1]
}
Le résultat d'exécution du code ci-dessus est :
升序：[1 2 3 5 8 9] 降序：[9 8 5 3 2 1]
En passant différentes fonctions comme arguments, le mêmesort.Slicepeut obtenir une logique de tri complètement différente. C'est précisément la valeur fondamentale des fonctions en tant qu'arguments —le paramétrage du comportement, ce qui rend le code plus flexible et réutilisable.。