Fonctions en Go

Qu'est-ce qu'une fonction ?

Les fonctions sont des segments de code qui peuvent être réutilisés à plusieurs endroits d'un programme. Pour les définir, on utilise le mot-clé func, suivi du nom de la fonction, des paramètres, et du type de retour.

Syntaxe des fonctions

La syntaxe pour créer une fonction en Go est la suivante :

func nomDeLaFonction(typeDuParametre)(typeDeRetour) {
    return valeur
}

Il est important de noter que les noms des paramètres et des valeurs de retour doivent être entièrement présents ou complètement absents. En passant des paramètres, Go fait une copie de leur valeur (passage par valeur). Si l'on souhaite modifier le paramètre dans la fonction, il faut le déclarer comme un type pointeur.

Exemples de fonctions en Go

Voici quelques exemples de définition de fonctions :

package main
import "fmt"

// Exemple sans parenthèses autour du type de retour car il n'y a qu'un seul paramètre
func DireBonjour(prenom string) string {
    return "Bonjour, " + prenom
}

func SommeEtDifference(a int64, b int64) (int64, int64) {
    return a + b, a - b
}

func afficherResultat(f func(int64, int64) (int64, int64), a int64, b int64) {
    c, d := f(a, b)
    fmt.Println(c, d)
}

func main() {
    fmt.Println(DireBonjour("Alice"))
    afficherResultat(SommeEtDifference, 10, 5)
}

Ce code affichera :

Bonjour, Alice
15 5

Fonctions anonymes

Les fonctions anonymes, également connues sous le nom de littérales de fonction, sont des fonctions sans nom. Elles peuvent être appelées immédiatement après leur création et peuvent également être passées comme paramètres à d'autres fonctions.

Exemple de fonction anonyme :

package main
import "fmt"

func main() {
    func() {
        fmt.Println("Ceci est une fonction anonyme.")
    }()
}

Ce code affichera :

Ceci est une fonction anonyme.

Paramètres variadiques

Une fonction peut avoir un maximum d'un paramètre variadique (ex : cles ...int). Cela signifie qu'elle peut accepter un nombre variable d'arguments. Les paramètres variadiques sont toujours de type slice.

Voici un exemple :

package main
import "fmt"

func afficherCles(cles ...int) {
    for _, cle := range cles {
        fmt.Println(cle)
    }
}

func main() {
    afficherCles(1, 2, 3, 4, 5)
}

Cela affichera :

1
2
3
4
5

Méthodes

Une fonction devient une méthode lorsqu'elle est définie avec un récepteur, qui est un paramètre avant le nom de la fonction. Le type du récepteur peut être n'importe quel type, y compris un type struct. Si le récepteur est un pointeur, la fonction peut modifier la valeur à laquelle il pointe.

Exemple de méthodes :

package main
import (
    "fmt"
)

type Etudiant struct {
    nom  string
    email string
}

func (e Etudiant) changerNom(nom string) {
    e.nom = nom
}

func (e *Etudiant) changerEmail(email string) {
    e.email = email
}
}

func main() {
    etud := Etudiant{nom: "Paul", email: "paul@exemple.com"}
    fmt.Println("Avant changement:", etud)
    etud.changerNom("Pierre")
    fmt.Println("Après changement nom:", etud)
    etud.changerEmail("pierre@exemple.com")
    fmt.Println("Après changement email:", etud)
}

Ce code produit l'affichage :

Avant changement: {Paul paul@exemple.com}
Après changement nom: {Paul paul@exemple.com}
Après changement email: {Paul pierre@exemple.com}