Les fonctions variadiques
Qu'est ce que c'est une fonction variadique?
Une fonction variadique est une fonction qui accepte un nombre variable d'arguments.
Syntaxe
Si le dernier paramètre d'une fonction est indiqué par …T, alors la fonction accepte un nombre variable d'arguments de type T pour le dernier paramètre.
Le fonctionnement d'une fonction variadique
la fonction append est une fonction variadique.
func append(slice []Type, elems ...Type) []Type
dans l'exemple ci-dessus, elemns est un paramètre variadique. Par conséquent, append peut accepter un nombre variable d'arguments.
Voici un programme qui vérifie si un entier existe dans une liste d'entiers entrée.
package main
import (
"fmt"
)
func find(num int, nums ...int) {
fmt.Printf("type de nums est %T\n", nums)
found := false
for i, v := range nums {
if v == num {
fmt.Println(num, "trouvé à l'indice", i, "dans", nums)
found = true
}
}
if !found {
fmt.Println(num, "non trouvé dans ", nums)
}
fmt.Printf("\n")
}
func main() {
find(89, 89, 90, 95)
find(45, 56, 67, 45, 90, 109)
find(78, 38, 56, 98)
find(87)
}
**Le nombre variable d'arguments passé est converti à une nouvelle tranche du type du paramètre variolique. Par exemple, le nombre variable d'arguments passé à la fonction fin sont 89, 90, 95. La fonction fin s'attend un argument variadique int. Par conséquent, le compilateur va convertir ces trois arguments en une tranche de type int []int{89, 90, 95} qui va être passée à la fonction find **
La sortie du programme est:
type de nums est []int
89 trouvé à l'indice 0 dans [89 90 95]
type de nums est []int
45 trouvé à l'indice 2 dans [56 67 45 90 109]
type de nums est []int
78 non trouvé dans [38 56 98]
type de nums est []int
87 non trouvé dans []
Le passage d'un tranche à une fonction variadique
On passe une tranche à une fonction variadique :
package main
import (
"fmt"
)
func find(num int, nums ...int) {
fmt.Printf("type de nums est %T\n", nums)
found := false
for i, v := range nums {
if v == num {
fmt.Println(num, "trouvé à l'indice", i, "in", nums)
found = true
}
}
if !found {
fmt.Println(num, "non trouvé dans", nums)
}
fmt.Printf("\n")
}
func main() {
nums := []int{89, 90, 95}
find(89, nums)
}
on va passer une tranche à une fonction qui accepte un nombre variable d'arguments, une erreur de compilation va être lancée main.go:23: cannot use nums (type []int) as type int in argument to find.
Selon la définition d'une fonction variadique, nums …int veut dire qu'elle accepte un nombre variable d'arguments de type int.
nums est passé à la fonction find comme argument variadique. Dans ce cas, nums est déjà une tranche de type int ,pourtant une nouvelle tranche de type int est tentée d'être créée, le compilateur essaie de faire ceci:
find(89, []int{nums})
Ce qui engendre une erreur vu que nums est []int et non pas un int
Pour passer une tranche à une fonction, il faut ajouter le suffixe … à la tranche.
Dans le programme ci-dessus, si vous remplacez find(89, nums) avec find(89, nums…), le programme va être compilé normalement, la sortie serait comme suivante:
type of nums is []int
89 found at index 0 in [89 90 95]
Gotcha
Il faut être prudent quand vous modifiez une tranche dans une fonction variadique.
Exemple:
package main
import (
"fmt"
)
func change(s ...string) {
s[0] = "Go"
}
func main() {
welcome := []string{"hello", "world"}
change(welcome...)
fmt.Println(welcome)
}
Dans le programme ci-dessus, on a passé une tranche comme argument variadique à la fonction change.
Dans la fonction change, le premier élément de la tranche est changé en Go. Par conséquent la sortie du programme serait:
[Go world]
Voici un dernier programme pour mieux comprendre les tranches.
package main
import (
"fmt"
)
func change(s ...string) {
s[0] = "Go"
s = append(s, "playground")
fmt.Println(s)
}
func main() {
welcome := []string{"hello", "world"}
change(welcome...)
fmt.Println(welcome)
}
Posted on Utopian.io - Rewarding Open Source Contributors