Go Academy · Leçon

Valeurs de retour multiples

Renvoyer des tuples et appliquer le modèle d’erreur

Valeurs de retour multiples est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Pourquoi plusieurs valeurs de retour ?

Les fonctions de Go peuvent renvoyer plusieurs valeurs, ce qui évite d’avoir recours à des paramètres de sortie ou à des exceptions. Le schéma le plus courant consiste à renvoyer un résultat et une erreur :

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

Gérer plusieurs valeurs de retour

Les appelants reçoivent toutes les valeurs de retour sous forme de tuple. Utilisez _ pour ignorer les valeurs dont vous n’avez pas besoin :

result, err := divide(10, 3)
if err != nil {
    log.Fatal(err)
}
fmt.Println(result)

value, _ := divide(8, 2) // discard error

Valeurs de retour nommées

Les valeurs de retour peuvent être nommées et deviennent alors des variables au sein de la fonction :

func minMax(nums []int) (min, max int) {
    min, max = nums[0], nums[0]
    for _, n := range nums[1:] {
        if n < min { min = n }
        if n > max { max = n }
    }
    return // naked return
}

Retours nus

Un return sans arguments renvoie les variables de retour nommées. Utilisez-le avec parcimonie — uniquement dans les fonctions courtes dont les noms sont explicites :

Fonctions courtes : acceptable
Fonctions longues : nuit à la lisibilité — préférez les retours explicites

Le modèle (valeur, erreur)

Le modèle canonique de gestion des erreurs en Go :

func readConfig(path string) (Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return Config{}, fmt.Errorf("read config: %w", err)
    }
    var cfg Config
    return cfg, json.Unmarshal(data, &cfg)
}

N’ignorez jamais les erreurs

Ignorer les erreurs avec _ est dangereux. Bonnes pratiques :

Vérifiez chaque erreur, sauf si vous avez une raison précise de ne pas le faire
Entourez les erreurs d’un contexte avec fmt.Errorf("op: %w", err)
Utilisez log.Fatal ou panic uniquement aux limites du programme, et non au cœur des bibliothèques

Retours à trois valeurs

Certaines fonctions renvoient trois valeurs, bien que cela soit moins courant :

func parseIPPort(s string) (ip string, port int, err error) {
    // ... parsing logic
    return
}

Retourner des structures plutôt que plusieurs valeurs

Quand retourner une structure plutôt que plusieurs valeurs :

2 ou 3 valeurs fortement liées : les retours multiples conviennent
4 valeurs ou plus, ou des champs facultatifs : utilisez une structure
Le modèle (valeur, erreur) : utilisez toujours plusieurs valeurs

Affecter des variables existantes

Utilisez = (et non :=) pour affecter des variables déjà déclarées en dehors de l’appel :

var cfg Config
var err error
cfg, err = loadConfig()
if err != nil { ... }

Retours multiples dans l’enchaînement de méthodes

Go ne prend pas directement en charge l’enchaînement de méthodes sur des valeurs de retour multiples (contrairement à Rust et à Result.map). Utilisez des variables intermédiaires pour gérer les erreurs à chaque étape :

data, err := fetchData(url)
if err != nil { return err }
parsed, err := parseData(data)
if err != nil { return err }
return save(parsed)

Vérification rapide

Que fait un retour nu en Go ?

Récapitulatif : valeurs de retour multiples

Les retours multiples constituent un idiome fondamental de Go :

Les fonctions peuvent renvoyer plusieurs valeurs dans une liste entre parenthèses
Le modèle (valeur, erreur) est omniprésent — vérifiez toujours l’erreur
Les variables de retour nommées permettent les retours nus (à utiliser avec parcimonie)
Utilisez _ pour ignorer les valeurs dont vous n’avez pas besoin
Préférez les retours multiples aux paramètres de sortie pour obtenir des API plus claires

Ensuite : les fonctions variadiques.

Questions Fréquemment Posées

La leçon « Valeurs de retour multiples » est-elle gratuite ?

Oui — le texte complet de « Valeurs de retour multiples » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Valeurs de retour multiples » ?

Renvoyer des tuples et appliquer le modèle d’erreur Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Valeurs de retour multiples » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy