Déclarer et appeler des fonctions (paramètres, retours multiples)

Blocs de construction du code : Pourquoi utiliser des fonctions ?

Au fur et à mesure que les programmes informatiques deviennent plus complexes, il est essentiel de les structurer de manière logique et gérable. Les fonctions sont le principal mécanisme d'organisation et de réutilisation du code en Go. Une fonction est un bloc de code nommé et autonome qui accomplit une tâche spécifique. En décomposant un programme complexe en fonctions plus petites et ciblées, on améliore sa lisibilité, sa maintenabilité et sa testabilité.

Imaginez une recette de cuisine : plutôt que d'avoir une longue liste ininterrompue d'instructions, la recette est souvent divisée en étapes claires comme "Préparer les ingrédients", "Mélanger les éléments secs", "Cuire au four". Chaque étape peut être vue comme une fonction. Cela rend la recette plus facile à suivre et permet de réutiliser certaines étapes (fonctions) dans d'autres recettes.

Ce sous-chapitre vous guidera à travers la déclaration de vos propres fonctions en Go, comment leur passer des informations (paramètres) et comment elles peuvent renvoyer des résultats (valeurs de retour), y compris la fonctionnalité notable des retours multiples propre à Go.

Déclarer une fonction : La syntaxe `func`

La déclaration d'une fonction en Go commence toujours par le mot-clé `func`, suivi du nom de la fonction, d'une liste de paramètres entre parenthèses `()`, éventuellement d'un ou plusieurs types de retour, et enfin du corps de la fonction délimité par des accolades `{}`.

La forme la plus simple est une fonction qui ne prend aucun paramètre et ne retourne aucune valeur :

package main

import "fmt"

// Déclaration de la fonction 'saluer'
func saluer() {
    fmt.Println("Bonjour depuis la fonction saluer !")
}

// Fonction principale (point d'entrée)
func main() {
    fmt.Println("Début du programme principal.")
    // Appel de la fonction saluer
    saluer()
    fmt.Println("Fin du programme principal.")
}

Dans cet exemple :

• `func saluer()` : Déclare une fonction nommée `saluer`.
• `()` : Indique qu'elle ne prend aucun paramètre.
• Absence de type de retour après les parenthèses : signifie qu'elle ne retourne aucune valeur (similaire au `void` dans d'autres langages).
• `{ ... }` : Contient le code qui sera exécuté lorsque la fonction sera appelée.

Appeler une fonction

Déclarer une fonction ne l'exécute pas. Pour exécuter le code contenu dans une fonction, vous devez l'appeler. L'appel se fait simplement en utilisant le nom de la fonction suivi de parenthèses `()`. Si la fonction attend des paramètres (arguments), vous les fournissez à l'intérieur des parenthèses.

Dans l'exemple précédent, la ligne `saluer()` à l'intérieur de la fonction `main` est l'appel à la fonction `saluer`. Lorsque cette ligne est atteinte, le flux d'exécution saute au début du corps de la fonction `saluer`, exécute les instructions qu'il contient (`fmt.Println(...)`), puis revient à l'instruction qui suit immédiatement l'appel dans `main`.

Vous pouvez appeler une fonction autant de fois que nécessaire depuis différents endroits de votre code, ce qui illustre la réutilisabilité. Chaque appel exécute le même bloc de code défini dans la fonction.

Passer des informations : Les paramètres de fonction

Les fonctions deviennent beaucoup plus utiles lorsqu'elles peuvent recevoir des données sur lesquelles travailler. Ces données sont passées via des paramètres, définis dans la signature de la fonction (entre les parenthèses). Chaque paramètre a un nom et un type.

Syntaxe : `func nomFonction(param1 type1, param2 type2, ...) { ... }`

package main

import "fmt"

// Fonction qui prend un nom (string) en paramètre
func saluerPersonne(nom string) {
    fmt.Printf("Bonjour, %s !\n", nom)
}

// Fonction qui prend deux entiers en paramètres
func additionner(a int, b int) {
    resultat := a + b
    fmt.Printf("%d + %d = %d\n", a, b, resultat)
}

func main() {
    saluerPersonne("Alice") // Appel avec l'argument "Alice"
    saluerPersonne("Bob")   // Appel avec l'argument "Bob"

    additionner(5, 3)      // Appel avec les arguments 5 et 3
}

Lorsqu'on appelle une fonction avec des paramètres, les valeurs fournies (appelées arguments, par exemple "Alice" ou 5) sont copiées dans les variables de paramètres correspondantes (`nom`, `a`, `b`) à l'intérieur de la fonction. En Go, par défaut, les arguments sont passés par valeur. Cela signifie que la fonction travaille sur une copie des données originales. Si la fonction modifie la valeur d'un paramètre, cela n'affecte pas la variable originale en dehors de la fonction (sauf si on utilise des pointeurs ou des types référence comme les slices ou les maps, ce qui sera vu plus tard).

Renvoyer des résultats : Les valeurs de retour

Les fonctions peuvent non seulement recevoir des données, mais aussi renvoyer des résultats à l'endroit où elles ont été appelées. Pour cela, on spécifie le type de la valeur de retour après la liste des paramètres. L'instruction `return` est utilisée à l'intérieur de la fonction pour spécifier la valeur à renvoyer.

Syntaxe pour un retour unique : `func nomFonction(params...) typeRetour { ...; return valeur; }`

package main

import "fmt"

// Fonction qui prend deux entiers et retourne leur somme (un entier)
func addition(a int, b int) int {
    somme := a + b
    return somme // Renvoie la valeur de la variable somme
}

func main() {
    // Appel de la fonction et stockage du résultat dans une variable
    resultatAddition := addition(10, 7)
    fmt.Printf("Le résultat de l'addition est : %d\n", resultatAddition)

    // On peut aussi utiliser le résultat directement
    fmt.Printf("Autre addition : %d\n", addition(3, 4))
}

Lorsque l'instruction `return` est exécutée, la fonction termine immédiatement son exécution et la valeur spécifiée est renvoyée au code appelant. Le code appelant peut alors utiliser cette valeur, par exemple en l'assignant à une variable (`resultatAddition := ...`) ou en l'utilisant directement dans une autre expression (`fmt.Printf("...", addition(3, 4))`). Une fonction qui déclare un type de retour doit obligatoirement se terminer par une instruction `return` qui renvoie une valeur du type attendu sur tous les chemins d'exécution possibles.

Idiome Go : Les retours multiples

Une caractéristique distinctive et très utilisée de Go est la capacité des fonctions à retourner plusieurs valeurs simultanément. C'est particulièrement utile pour renvoyer un résultat principal et une information secondaire, comme un indicateur de succès ou une erreur.

La syntaxe consiste à lister les types de retour entre parenthèses, séparés par des virgules : `func nomFonction(params...) (typeRetour1, typeRetour2, ...) { ...; return val1, val2, ...; }`

Le cas d'usage le plus fréquent est de retourner une valeur et une erreur. Par convention, l'erreur est la dernière valeur retournée. Si l'opération réussit, l'erreur retournée est `nil`. Si elle échoue, une valeur d'erreur non-nulle est retournée.

Exemple : une fonction de division qui retourne le résultat et une erreur si le diviseur est zéro.

package main

import (
    "fmt"
    "errors" // Paquet pour créer des erreurs simples
)

// Retourne (float64, error)
func diviser(dividende, diviseur float64) (float64, error) {
    if diviseur == 0 {
        // Retourne 0 pour le résultat et une nouvelle erreur
        return 0, errors.New("division par zéro impossible")
    }
    // Retourne le résultat et 'nil' pour indiquer l'absence d'erreur
    return dividende / diviseur, nil
}

func main() {
    resultat1, err1 := diviser(10.0, 2.0)
    if err1 != nil {
        fmt.Printf("Erreur lors de la division 1 : %v\n", err1)
    } else {
        fmt.Printf("Résultat 1 : %.2f\n", resultat1)
    }

    resultat2, err2 := diviser(5.0, 0.0)
    if err2 != nil {
        fmt.Printf("Erreur lors de la division 2 : %v\n", err2)
    } else {
        fmt.Printf("Résultat 2 : %.2f\n", resultat2)
    }
}

Lors de l'appel d'une fonction à retours multiples, vous devez assigner chaque valeur retournée à une variable. Si vous n'êtes pas intéressé par l'une des valeurs retournées, vous pouvez l'ignorer en utilisant l'identifiant vide `_` à sa place.

resultatSeul, _ := diviser(12.0, 3.0) // Ignore l'erreur (à utiliser avec prudence !)
fmt.Printf("Résultat seul : %.2f\n", resultatSeul)

_, errSeule := diviser(8.0, 0.0)      // Ignore le résultat, ne vérifie que l'erreur
if errSeule != nil {
    fmt.Println("Une erreur s'est produite (résultat ignoré).")
}

Optionnel : Paramètres et retours nommés

Go permet de donner des noms aux valeurs de retour directement dans la signature de la fonction. Ces noms agissent comme des variables locales pré-déclarées dans la fonction, initialisées à leur valeur zéro. Elles peuvent être assignées directement, et une instruction `return` sans arguments (un "return nu") renverra les valeurs actuelles de ces variables nommées.

Syntaxe : `func nomFonction(params...) (nomRetour1 type1, nomRetour2 type2) { ...; return; // Retourne les valeurs actuelles de nomRetour1, nomRetour2 }`

Exemple avec retours nommés :

package main

import "fmt"

// Fonction avec retours nommés
func diviserEtReste(dividende, diviseur int) (quotient int, reste int) {
    if diviseur == 0 {
        // On pourrait assigner des valeurs d'erreur ou paniquer
        // Ici, on laisse les valeurs zéro (0, 0) par défaut
        return // Retourne quotient=0, reste=0
    }
    quotient = dividende / diviseur
    reste = dividende % diviseur
    return // Retourne les valeurs assignées à quotient et reste
}

func main() {
    q, r := diviserEtReste(10, 3)
    fmt.Printf("10 / 3 = Quotient %d, Reste %d\n", q, r)

    q0, r0 := diviserEtReste(5, 0)
    fmt.Printf("5 / 0 = Quotient %d, Reste %d\n", q0, r0)
}

L'avantage principal des retours nommés est qu'ils peuvent améliorer la lisibilité et servir de documentation implicite sur la signification des valeurs retournées. Cependant, l'utilisation du `return` nu peut parfois rendre le code moins clair, car il n'est pas immédiatement évident quelles valeurs sont retournées à ce point précis. Il est souvent recommandé d'utiliser le `return` nu avec parcimonie, principalement dans les fonctions courtes et simples où son comportement est évident.

Conclusion : L'importance des fonctions bien conçues

Les fonctions sont absolument fondamentales en Go, comme dans la plupart des langages de programmation. Elles permettent de découper la complexité, de favoriser la réutilisation du code et d'améliorer la structure générale de vos applications.

En maîtrisant la déclaration, l'appel, l'utilisation des paramètres et la gestion efficace des valeurs de retour (notamment les retours multiples pour la gestion des erreurs), vous disposez des outils essentiels pour écrire du code Go modulaire, lisible et maintenable.

Adoptez de bonnes pratiques : écrivez des fonctions courtes qui font une seule chose bien, donnez-leur des noms clairs et descriptifs, et utilisez le pattern de retour `(valeur, erreur)` de manière idiomatique pour signaler les succès et les échecs. Ces principes vous aideront à construire des applications robustes et évolutives.