TOC

Comment définir et appeler des fonctions dans Go

introduction

Une fonction est une section de code qui, une fois définie, peut être réutilisée. Les fonctions sont utilisées pour rendre votre code plus facile à comprendre en le divisant en petites tâches compréhensibles pouvant être utilisées plusieurs fois au cours de votre programme.

Naviguez avec une puissante bibliothèque standard dotée de nombreuses fonctions prédéfinies. Ceux que vous connaissez probablement déjà à partir du paquet fmt sont les suivants:

  • + fmt.Println () + qui imprimera des objets en sortie standard (très probablement votre terminal).

  • + fmt.Printf () + qui vous permettra de formater votre sortie imprimée.

Les noms de fonction incluent des parenthèses et peuvent inclure des paramètres.

Dans ce didacticiel, nous verrons comment définir vos propres fonctions à utiliser dans vos projets de codage.

Définir une fonction

Commençons par transformer le programme classique "hello, World! ” En une fonction.

Nous allons créer un nouveau fichier texte dans l’éditeur de texte de votre choix et appeler le programme + hello.go +. Ensuite, nous définirons la fonction.

Une fonction est définie en utilisant le mot-clé + func +. Ceci est ensuite suivi du nom de votre choix et d’un ensemble de parenthèses contenant tous les paramètres que la fonction prendra (ils peuvent être vides). Les lignes du code de fonction sont placées entre accolades + {} +.

Dans ce cas, nous définirons une fonction nommée + hello () +:

bonjour.go

func hello() {}

Ceci configure la déclaration initiale pour créer une fonction.

À partir de là, nous ajouterons une deuxième ligne pour fournir des instructions sur le fonctionnement de la fonction. Dans ce cas, nous allons imprimer + Hello, World! + Sur la console:

bonjour.go

func hello() {
   fmt.Println("Hello, World!")
}

Notre fonction est maintenant complètement définie, mais si nous exécutons le programme à ce stade, rien ne se passera car nous n’avons pas appelé la fonction.

Dans notre bloc fonction + main () +, appelons donc la fonction avec + hello () +:

bonjour.go

package main

import "fmt"

func main() {
   hello()
}

func hello() {
   fmt.Println("Hello, World!")
}

Lançons maintenant le programme:

go run hello.go

Vous recevrez le résultat suivant:

OutputHello, World!

Notez que nous avons également introduit une fonction appelée + main () +. La fonction + main () + est une fonction spéciale qui indique au compilateur que c’est à cet endroit que le programme devrait * démarrer *. Pour tout programme que vous voulez être executable (un programme qui peut être exécuté à partir de la ligne de commande), vous aurez besoin d’une fonction + main () +. La fonction + main () + ne doit apparaître qu’une seule fois, être dans le + main () + package, et ne recevoir ni retourner d’argument. Cela permet d’utiliser programme dans n’importe quel programme Go. Selon l’exemple suivant:

main.go

package main

import "fmt"

func main() {
   fmt.Println("this is the main section of the program")
}

Les fonctions peuvent être plus compliquées que la fonction + hello () + que nous avons définie. Nous pouvons utiliser https://www.digitalocean.com/community/tutorials/how-to-construct-for-loops-in-go [+ pour + boucles], https://www.digitalocean.com/community/ tutoriels / comment-écrire-conditions-conditionnelles-in-go [instructions conditionnelles], et plus dans notre bloc de fonction.

Par exemple, la fonction suivante utilise une instruction conditionnelle pour vérifier si l’entrée de la variable + nom + contient une voyelle, puis utilise une boucle + pour + pour parcourir les lettres de la chaîne + nom +.

noms.go

package main

import (
   "fmt"
   "strings"
)

func main() {
   names()
}

func names() {
   fmt.Println("Enter your name:")

   var name string
   fmt.Scanln(&name)
   // Check whether name has a vowel
   for _, v := range strings.ToLower(name) {
       if v == 'a' || v == 'e' || v == 'i' || v == 'o' || v == 'u' {
           fmt.Println("Your name contains a vowel.")
           return
       }
   }
   fmt.Println("Your name does not contain a vowel.")
}

La fonction + names () + que nous définissons ici configure une variable + name avec input, puis configure une instruction conditionnelle dans une boucle` + for`. Cela montre comment le code peut être organisé dans une définition de fonction. Toutefois, en fonction de ce que nous souhaitons avec notre programme et de la manière dont nous souhaitons configurer notre code, nous pouvons définir l’instruction conditionnelle et la boucle + pour + comme deux fonctions distinctes.

La définition de fonctions dans un programme rend notre code modulaire et réutilisable, de sorte que nous puissions appeler les mêmes fonctions sans les réécrire.

Travailler avec des paramètres

Jusqu’à présent, nous avons examiné les fonctions avec des parenthèses vides qui ne prennent pas d’arguments, mais nous pouvons définir des paramètres dans les définitions de fonctions entre parenthèses.

Un paramètre est une entité nommée dans une définition de fonction, spécifiant un argument que la fonction peut accepter. Dans Go, vous devez spécifier le type data pour chaque paramètre.

Créons un programme qui répète un mot un nombre de fois spécifié. Il faudra un paramètre + string + appelé + word + et un paramètre + int + appelé + reps + pour le nombre de répétitions du mot.

répéter.go

package main

import "fmt"

func main() {
   repeat("Sammy", 5)
}

func repeat(word string, reps int) {
   for i := 0; i < reps; i++ {
       fmt.Print(word)
   }
}

Nous avons passé la valeur + Sammy + pour le paramètre + word +, et + 5 + pour le paramètre + reps +. Ces valeurs correspondent à chaque paramètre dans l’ordre dans lequel elles ont été données. La fonction + repeat + a une boucle + pour + qui itérera le nombre de fois spécifié par le paramètre + reps +. Pour chaque itération, la valeur du paramètre + mot + est imprimée.

Voici le résultat du programme:

OutputSammySammySammySammySammy

Si vous avez un ensemble de paramètres ayant la même valeur, vous pouvez omettre de spécifier le type à chaque fois. Créons un petit programme qui prend en compte les paramètres + x +, '+ y + et + z + qui sont tous des valeurs + int + `. Nous allons créer une fonction qui additionne les paramètres dans différentes configurations. Les sommes de celles-ci seront imprimées par la fonction. Ensuite, nous appelons la fonction et lui passons des chiffres.

add_numbers.go

package main

import "fmt"

func main() {
   addNumbers(1, 2, 3)
}

func addNumbers(x, y, z int) {
   a := x + y
   b := x + z
   c := y + z
   fmt.Println(a, b, c)
}

Lorsque nous avons créé la signature de fonction pour + addNumbers +, nous n’avions pas besoin de spécifier le type à chaque fois, mais seulement à la fin.

Nous avons passé le nombre + 1 + pour le paramètre + x +, + 2 + pour le paramètre + y + et + 3 + pour le paramètre + z +. Ces valeurs correspondent à chaque paramètre dans l’ordre dans lequel elles sont données.

Le programme effectue les calculs suivants en fonction des valeurs que nous avons transmises aux paramètres:

a = 1 + 2
b = 1 + 3
c = 2 + 3

La fonction affiche aussi + a +, + b + et + c +, et sur la base de ce calcul, nous nous attendrions à ce que + a + soit égal à + ​​3 +, + b + soit + 4 + `, et + c + être + 5 + `. Lançons le programme:

go run add_numbers.go
Output3 4 5

Lorsque nous transmettons les paramètres + 1 +, '+ 2 + et + + 3 + à la fonction + addNumbers () +, nous obtenons le résultat attendu.

Les paramètres sont des arguments généralement définis en tant que variables dans les définitions de fonction. Vous pouvez leur attribuer des valeurs lorsque vous exécutez la méthode en transmettant les arguments à la fonction.

Renvoyer une valeur

Vous pouvez transmettre une valeur de paramètre à une fonction et une fonction peut également générer une valeur.

Une fonction peut produire une valeur avec l’instruction + return +, qui permet de quitter une fonction et de transmettre éventuellement une expression à l’appelant. Le type de données de retour doit également être spécifié.

Jusqu’ici, nous avons utilisé l’instruction + fmt.Println () + au lieu de l’instruction + return + dans nos fonctions. Créons un programme qui, au lieu d’imprimer, renverra une variable.

Dans un nouveau fichier texte appelé + double.go +, nous allons créer un programme qui double le paramètre + x + et renvoie la variable + y +. Nous émettons un appel pour imprimer la variable + résultat +, qui est formée en exécutant la fonction + double () + avec `` + 3 + `passé dans celle-ci:

double.go

package main

import "fmt"

func main() {
   result := double(3)
   fmt.Println(result)
}

func double(x int) int {
   y := x * 2
   return y
}

Nous pouvons exécuter le programme et voir le résultat:

go run double.go
Output6

L’entier + 6 + est renvoyé en sortie, ce à quoi nous nous attendions en multipliant + 3 + par '+ 2 + `.

Si une fonction spécifie un retour, vous devez fournir un retour dans le code. Si vous ne le faites pas, vous recevrez une erreur de compilation.

Nous pouvons le démontrer en commentant la ligne avec l’instruction return:

double.go

package main

import "fmt"

func main() {
   result := double(3)
   fmt.Println(result)
}

func double(x int) int {
   y := x * 2
   // return y
}

Maintenant, relançons le programme:

go run double.go
Output./double.go:13:1: missing return at end of function

Sans utiliser l’instruction + return + ici, le programme ne peut pas compiler.

Les fonctions se terminent immédiatement lorsqu’elles atteignent une instruction + return +, même si elles ne sont pas à la fin de la fonction:

return_loop.go

package main

import "fmt"

func main() {
   loopFive()
}

func loopFive() {
   for i := 0; i < 25; i++ {
       fmt.Print(i)
       if i == 5 {
           // Stop function at i == 5
           return
       }
   }
   fmt.Println("This line will not execute.")
}

Ici, nous parcourons une boucle + pour + et disons à la boucle de lancer des itérations + 25 +. Toutefois, dans la boucle + for, nous avons une instruction conditionnelle` + if` qui vérifie si la valeur de + i + est égale à + ​​5 +. Si c’est le cas, nous émettons une déclaration + return +. Parce que nous sommes dans la fonction + loop Five, et` + return` en tout point de la fonction quittera la fonction. Par conséquent, nous n’allons jamais jusqu’à la dernière ligne de cette fonction pour imprimer l’instruction + Cette ligne ne s’exécutera pas. +.

L’utilisation de l’instruction + return dans la boucle` + for` termine la fonction, ainsi la ligne située en dehors de la boucle ne sera pas exécutée. Si, au lieu de cela, nous avions utilisé une https://www.digitalocean.com/community/tutorials/how-to-use-break-and-continue-statements-when-working-with-loops-in-go#break- statement [+ break + statement], seule la boucle se serait terminée à ce moment-là et la dernière ligne + fmt.Println () + serait exécutée.

L’instruction + return + quitte une fonction et peut renvoyer une valeur si elle est spécifiée dans la signature de la fonction.

Renvoi de plusieurs valeurs

Plusieurs valeurs de retour peuvent être spécifiées pour une fonction. Examinons le programme + repeat.go + et lui renvoyons deux valeurs. Le premier sera la valeur répétée et le second sera une erreur si le paramètre + reps + n’est pas une valeur supérieure à + ​​0 +:

répéter.go

package main

import "fmt"

func main() {
   val, err := repeat("Sammy", -1)
   if err != nil {
       fmt.Println(err)
       return
   }
   fmt.Println(val)
}

func repeat(word string, reps int) (string, error) {
   if reps <= 0 {
       return "", fmt.Errorf("invalid value of %d provided for reps. value must be greater than 0.", reps)
   }
   var value string
   for i := 0; i < reps; i++ {
       value = value + word
   }
   return value, nil
}

La fonction + repeat + commence par vérifier si l’argument + reps + est une valeur valide. Toute valeur non supérieure à + ​​0 + provoquera une erreur. Puisque nous avons passé la valeur + -1 +, cette branche de code sera exécutée. Notez que lorsque nous revenons de la fonction, nous devons fournir les valeurs de retour + string + et + error +. Comme les arguments fournis ont généré une erreur, nous allons renvoyer une chaîne vide pour la première valeur de retour et l’erreur pour la seconde valeur de retour.

Dans la fonction + main () +, nous pouvons recevoir les deux valeurs de retour en déclarant deux nouvelles variables, + value + et + + err +. Comme il peut y avoir une erreur dans la déclaration, nous voulons vérifier si nous avons reçu une erreur avant de poursuivre notre programme. Dans cet exemple, nous avons reçu une erreur. Nous imprimons l’erreur et + return + hors de la fonction + main () + pour quitter le programme.

S’il n’y avait pas d’erreur, nous afficherions la valeur de retour de la fonction.

L’exécution du programme produira le résultat suivant:

Outputinvalid value of -1 provided for reps. value must be greater than 0.

Dans cette section, nous avons examiné comment utiliser l’instruction + return + pour renvoyer plusieurs valeurs d’une fonction.

Conclusion

Les fonctions sont des blocs de code d’instructions qui effectuent des actions dans un programme, contribuant à rendre notre code réutilisable et modulaire.

Pour en savoir plus sur la manière de rendre votre code plus modulaire, vous pouvez consulter notre guide à l’adresse Comment écrire des paquets dans Go .

Related