Valeurs de retour multiples en Golang : (value, error), résultats nommés

Renvoyer plus d'une valeur

Listez les types des résultats entre parenthèses. Renvoyez les valeurs séparées par des virgules, et recevez-les de la même façon.

package main

import "fmt"

func minMax(xs []int) (int, int) {
	lo, hi := xs[0], xs[0]
	for _, x := range xs[1:] {
		lo = min(lo, x)
		hi = max(hi, x)
	}
	return lo, hi
}

func main() {
	lo, hi := minMax([]int{4, 9, 1, 7})
	fmt.Println("min:", lo, "max:", hi)
}

Les fonctions intégrées min et max existent depuis Go 1.21. L'appelant doit recevoir tous les résultats : x := minMax(nums) ne compile pas et donne assignment mismatch: 1 variable but minMax returns 2 values.

La convention (value, error)

La raison la plus courante de renvoyer deux valeurs est de signaler un échec. Par convention, l'erreur vient en dernier, et quand elle n'est pas nil, les autres résultats doivent être considérés comme sans signification.

package main

import (
	"errors"
	"fmt"
	"strconv"
)

func parsePort(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("port %q: %w", s, err)
	}
	if n < 1 || n > 65535 {
		return 0, errors.New("port out of range")
	}
	return n, nil
}

func main() {
	for _, in := range []string{"8080", "http", "70000"} {
		port, err := parsePort(in)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("port:", port)
	}
}

Sortie :

port: 8080
error: port "http": strconv.Atoi: parsing "http": invalid syntax
error: port out of range

En cas d'échec, renvoyez la valeur zéro pour tous les autres résultats (0, "", nil). Le motif complet, avec l'enveloppement et la vérification, est sur la page gestion des erreurs.

L'idiome comma-ok

Plusieurs opérations intégrées renvoient un second bool facultatif qui indique si la première valeur est réelle. La variable s'appelle par convention ok.

package main

import "fmt"

func main() {
	ages := map[string]int{"ana": 31}

	age, ok := ages["bob"]
	fmt.Println(age, ok) // 0 false: missing key, not a zero age

	var v any = "hello"
	s, ok := v.(string)
	fmt.Println(s, ok)

	ch := make(chan int, 1)
	ch <- 5
	close(ch)
	x, ok := <-ch
	fmt.Println(x, ok) // 5 true: a buffered value is still delivered
	x, ok = <-ch
	fmt.Println(x, ok) // 0 false: closed and drained
}

Ces trois formes (recherche dans une map, assertion de type, réception sur un channel) sont spéciales : elles renvoient une ou deux valeurs selon le nombre de variables auxquelles vous affectez. Vos propres fonctions ne le peuvent pas. Une fonction déclarée avec deux résultats en renvoie toujours deux.

L'identifiant blanc

_ reçoit une valeur et la jette. Utilisez-le pour les résultats dont vous n'avez pas besoin :

_, err := fmt.Sscan(input, &n)
key, _ := parseLine(line)

Ignorer une erreur avec _ compile, donc ne le faites que si vous savez que l'appel ne peut pas échouer ou que l'échec n'a pas d'importance. strings.Builder.WriteString renvoie toujours une erreur nil, par exemple ; la fermeture d'un fichier après écriture, non.

Résultats nommés

Les paramètres de résultat peuvent avoir des noms. Ils sont déclarés au début de la fonction, initialisés à leur valeur zéro, et un return sans valeurs renvoie ce qu'ils contiennent.

package main

import "fmt"

func split(total int) (quotient, remainder int) {
	quotient = total / 7
	remainder = total % 7
	return
}

func main() {
	weeks, days := split(45)
	fmt.Println(weeks, "weeks and", days, "days")
}

Les noms apparaissent dans la sortie de go doc, ce qui aide quand deux résultats partagent un type : (quotient, remainder int) en dit plus que (int, int).

Un return nu dans une longue fonction est difficile à lire, parce que le lecteur doit remonter pour voir ce que contiennent les résultats. Le conseil habituel : nommez les résultats quand les noms documentent quelque chose, et écrivez quand même return quotient, remainder explicitement, sauf si la fonction fait quelques lignes.

Résultats nommés et defer

Une fonction différée s'exécute après que l'instruction return a défini les résultats et avant que l'appelant ne les reçoive. Avec des résultats nommés, la fonction différée peut les lire et les modifier. C'est ainsi qu'on ajoute du contexte à toute erreur renvoyée par une fonction, ou qu'on transforme un panic en erreur.

package main

import (
	"errors"
	"fmt"
)

func load(name string) (err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("load %s: %w", name, err)
		}
	}()
	if name == "" {
		return errors.New("empty name")
	}
	return nil
}

func main() {
	fmt.Println(load(""))
	fmt.Println(load("config.json"))
}

Ce code affiche load : empty name puis <nil>. return errors.New(...) affecte d'abord err, puis la fonction différée l'enveloppe. Plus de détails dans defer.

Masquer un résultat nommé

Les résultats nommés vivent dans la portée la plus externe de la fonction. Un := dans un bloc imbriqué crée une nouvelle variable du même nom, et un return nu renvoie alors la variable externe.

func find() (n int, err error) {
	if true {
		n, err := compute() // new n and err, shadowing the results
		_ = n
		_ = err
	}
	return // returns 0, nil
}

Le compilateur détecte le pire cas : un return nu dans le bloc où un résultat est masqué échoue avec result parameter err not in scope at return. Il ne détecte pas la version ci-dessus, où le return se trouve hors du bloc. Utilisez = au lieu de := quand vous visez les variables de résultat.

Erreurs courantes

• Utiliser la valeur quand err n'est pas nil. Vérifiez d'abord err. Une fonction a le droit de renvoyer n'importe quoi avec une erreur.
• Renvoyer un pointeur nil typé comme erreur. var e *MyErr; return e renvoie une error non nil. Renvoyez un nil littéral en cas de succès.
• Trop de résultats. Trois résultats ou plus de sens différents sont difficiles à utiliser. Renvoyez plutôt une struct.