Fonctions en Golang

Introduction

À mesure que les projets deviennent plus complexes, il est courant de diviser le code en plusieurs fonctions. Cette approche améliore la lisibilité du code, facilite la collaboration et vous permet de réutiliser rapidement la logique sans dupliquer le code. Dans ce laboratoire (LabEx), vous apprendrez les bases de la création et de l'utilisation de fonctions en Go. Vous verrez comment définir vos propres fonctions, comprendrez comment Go gère les paramètres et les valeurs de retour, et apprendrez à utiliser les fonctions init et les paramètres variadiques.

Principaux sujets :

• Comprendre ce que sont les fonctions et comment elles fonctionnent
• Déclarer des fonctions en Go
• Passer des paramètres par valeur et par référence
• Retourner plusieurs valeurs depuis une fonction
• Utiliser la fonction init pour configurer votre environnement
• Travailler avec des paramètres variadiques pour gérer les entrées de manière flexible

Skills Graph

Création et exécution d'un programme de base

Tout d'abord, accédez à votre répertoire de projet et créez un fichier Go :

cd ~/project
touch func.go

Utilisez un éditeur de texte pour ouvrir le fichier func.go et ajoutez le code suivant :

package main

import "fmt"

func main() {
    a1, b1 := 12, 4
    a2, b2 := 12, 0

    // Pour la première paire
    if b1 == 0 {
        fmt.Println("Le diviseur ne peut pas être égal à 0")
    } else {
        fmt.Println(a1 / b1)
    }

    // Pour la deuxième paire
    if b2 == 0 {
        fmt.Println("Le diviseur ne peut pas être égal à 0")
    } else {
        fmt.Println(a2 / b2)
    }
}

Ce code tente deux opérations de division et vérifie si le diviseur est égal à zéro avant la division. Si le diviseur est zéro, il affiche un message d'erreur.

Exécutez le programme :

go run func.go

Vous devriez voir :

3
Le diviseur ne peut pas être égal à 0

Déclaration de fonction

Dans les laboratoires (LabEx) précédents, que le programme soit simple ou complexe, nous n'avons utilisé que la fonction main pour les opérations.

Un programme ne peut avoir qu'une seule fonction main, qui est le point d'entrée du programme. Lorsque nous exécutons le programme, les autres fonctions sont appelées et exécutées directement ou indirectement au sein de la fonction main.

Maintenant, examinons la syntaxe des fonctions :

func functionName(parameters...)(returnValues...){
    code block
}

Ici, le nom de la fonction est utilisé pour identifier la fonction. Les règles suivantes s'appliquent au nom de la fonction :

• Il peut être composé de lettres, de chiffres et de caractères de soulignement. Cependant, la première lettre du nom de la fonction ne peut pas être un chiffre. Par exemple, func 3ab(){} n'est pas valide.
• Lorsque la première lettre est en majuscule, la fonction peut être référencée par le code dans des packages externes. Lorsque la première lettre est en minuscule, elle ne peut être utilisée qu'au sein du package. Cela est similaire aux fonctions publiques et privées.

La liste de paramètres déclare le nombre et le type des paramètres passés à la fonction :

• La liste de paramètres peut être vide ou contenir plusieurs paramètres.

• Chaque paramètre est composé d'un nom de paramètre et d'un type de paramètre. Par exemple, dans la liste de paramètres ci-dessous, nous déclarons deux variables de type int.

  func test(a, b int) (res int){}

La liste des valeurs de retour est utilisée pour renvoyer les valeurs nécessaires après l'exécution de la fonction :

• La liste des valeurs de retour est similaire à la liste de paramètres. Le nombre de paramètres peut être quelconque.

• Généralement, la liste de retour est composée de noms de variables et de types de variables, et le nom de la variable est facultatif.

• Si seule une variable est renvoyée et que seul le type de variable est déclaré, les parenthèses peuvent être omises. Par exemple :

  func test(a int, b string) int{}

Lorsque les types de paramètres sont les mêmes, nous pouvons utiliser le mode d'écriture abrégée. Les deux fonctions ci-dessous ont la même fonctionnalité :

func test(a, b int, c, d string)(res1, res2 int, res3 string){}

// Mode d'écriture abrégée
func test(a, b int, c, d string)(res1, res2 int, res3 string){}

Remplacez le contenu du fichier func.go par le code suivant :

package main

import "fmt"

func check(divisor int) bool {
    if divisor == 0 {
        fmt.Println("Le diviseur ne peut pas être égal à 0")
        return false
    }
    return true
}

func main() {
    a1, b1 := 12, 4
    a2, b2 := 12, 0

    // Utilisez la fonction check avant la division
    if check(b1) {
        fmt.Println(a1 / b1)
    }
    if check(b2) {
        fmt.Println(a2 / b2)
    }
}

Exécutez le programme à nouveau :

go run func.go

Vous devriez voir la même sortie :

3
Le diviseur ne peut pas être égal à 0

Cette fois, la logique de vérification est encapsulée dans la fonction check, rendant le code plus propre et plus réutilisable.

Utilisation de la fonction init

Go prend en charge une fonction init qui s'exécute avant la fonction main. Cela est souvent utilisé pour configurer les conditions de l'environnement ou initialiser des variables avant l'exécution principale.

Remplacez le contenu du fichier func.go par :

package main

import "fmt"

func init() {
    fmt.Println("init statement")
}

func main() {
    fmt.Println("main statement")
}

Exécutez le programme :

go run func.go

Vous devriez voir :

init statement
main statement

En Go, la fonction init présente les caractéristiques suivantes :

• Elle n'a aucun paramètre d'entrée ni de valeur de retour.
• Elle ne peut pas être appelée par d'autres fonctions.

Il peut y avoir plusieurs fonctions init dans le même fichier de code ou le même package. L'ordre d'exécution est le suivant :

• La fonction init qui apparaît en premier dans le même fichier de code sera exécutée en premier.
• Les fichiers dont le nom est plus tôt dans l'ordre alphabétique dans le même package seront exécutés en premier. Par exemple, si le même package contient les fichiers suivants avec des fonctions init :

a1.go
a2.go
b1.go

L'ordre d'exécution sera a1.go, a2.go, b1.go, car a < b et 1 < 2.

Retour de plusieurs valeurs depuis une fonction

Go permet aux fonctions de retourner plusieurs valeurs. Cela est utile pour effectuer plusieurs calculs liés en une seule fois.

Remplacez le contenu du fichier func.go par :

package main

import "fmt"

func cal(a, b int) (int, int, int, int) {
    return a + b, a - b, a * b, a % b
}

func main() {
    add, sub, mul, rem := cal(90, 12)
    fmt.Println(add, sub, mul, rem)
}

Exécutez le programme :

go run func.go

Vous devriez voir :

102 78 1080 6

Ici, la fonction cal retourne quatre valeurs en une seule fois, illustrant comment le retour de plusieurs valeurs peut simplifier certaines tâches.

Utilisation de paramètres variadiques

Les paramètres variadiques permettent à une fonction d'accepter un nombre variable d'arguments. Cela peut simplifier les scénarios où la taille de l'entrée n'est pas fixe.

Remplacez le contenu du fichier func.go par :

package main

import "fmt"

func printX(values...string) {
    for _, v := range values {
        fmt.Println(v)
    }
}

func main() {
    printX("labex", "labs", "courses")
}

Exécutez le programme :

go run func.go

Vous devriez voir :

labex
labs
courses

La fonction printX peut gérer n'importe quel nombre d'arguments de type chaîne de caractères, ce qui la rend flexible et facile à utiliser.

Résumé

Dans ce laboratoire (LabEx), vous avez appris à définir et à utiliser des fonctions en Go, notamment à retourner plusieurs valeurs et à accepter un nombre variable de paramètres. Vous avez également vu comment la fonction init s'exécute avant la fonction main. En structurant votre code en fonctions, vous pouvez rendre vos programmes plus faciles à comprendre, à maintenir et à réutiliser.

Ces compétences sont fondamentales pour la création d'applications Go modulaires et évolutives. Au fur et à mesure que vos projets grandiront, l'utilisation de fonctions pour organiser le code et la logique deviendra de plus en plus importante.