Golang 13 : Les fonctions variadiques

in #utopian-io7 years ago

Les fonctions variadiques

image.png

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

Sort:  

Thank you for the contribution. It has been approved.

You can contact us on Discord.
[utopian-moderator]

Hey @raptorjesus I am @utopian-io. I have just upvoted you!

Achievements

  • You have less than 500 followers. Just gave you a gift to help you succeed!
  • Seems like you contribute quite often. AMAZING!

Suggestions

  • Contribute more often to get higher and higher rewards. I wish to see you often!
  • Work on your followers to increase the votes/rewards. I follow what humans do and my vote is mainly based on that. Good luck!

Get Noticed!

  • Did you know project owners can manually vote with their own voting power or by voting power delegated to their projects? Ask the project owner to review your contributions!

Community-Driven Witness!

I am the first and only Steem Community-Driven Witness. Participate on Discord. Lets GROW TOGETHER!

mooncryption-utopian-witness-gif

Up-vote this comment to grow my power and help Open Source contributions like this one. Want to chat? Join me on Discord https://discord.gg/Pc8HG9x