Valeurs de retour multiples en

À propos de Valeurs de retour multiples

Les fonctions et méthodes en Go peuvent renvoyer plusieurs valeurs :

func GetCard() (Card, error) { ... }

Chaque valeur de retour doit être affectée dans l'ordre et séparée par des virgules :

card, err := GetCard()

L'identificateur blanc

Chaque position dans l'affectation déclare une variable. En Go, déclarer une variable sans l'utiliser n'est pas permis. Utilise l'identificateur blanc _ à la place d'un nom de variable pour ignorer cette valeur de retour.

card, _ := GetCard() // error intentionally ignored
_, err := GetCard()  // card ignored, only checking for error

La gestion des erreurs

error est une interface intégrée. Une erreur nil signifie qu'aucune erreur ne s'est produite ; toute valeur qui n'est pas nil signifie que quelque chose s'est mal passé. Par convention, les fonctions qui peuvent échouer doivent renvoyer une valeur de type error en dernière position. L'appelant doit la vérifier avant d'utiliser les autres valeurs de retour :

card, err := GetCard()
if err != nil {
    // unsafe to use card here
    return err
}
// safe to use card here

L'idiome « comma ok »

Le motif d'affectation à deux valeurs apparaît aussi ailleurs que dans la gestion des erreurs. Les accès aux maps, les assertions de type et les réceptions sur un canal utilisent tous une seconde valeur booléenne, appelée ok par convention, pour indiquer que l'opération a réussi ou qu'une donnée est présente :

m := map[string]int{"a": 1}
v, ok := m["a"] // ok is true
v, ok = m["z"]  // ok is false

var i interface{} = "hello"
v, ok := i.(string) // ok is true
v, ok = i.(int)     // ok is false

v, ok := <-ch // ok is false if ch is closed and empty

Les valeurs de retour nommées

Les valeurs de retour peuvent aussi recevoir un nom dans la signature de la fonction. Ces variables sont alors accessibles dans le corps de la fonction.

func divide(a, b int) (quotient, remainder int) {
    quotient = a / b
    remainder = a % b
    return quotient, remainder
}

Les valeurs de retour nommées documentent la signification de chaque position de retour. Elles peuvent aussi s'utiliser avec un retour nu, c'est-à-dire un return écrit sans valeurs. Les retours nus renvoient implicitement les valeurs actuelles des variables nommées :

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}

Dans les fonctions plus longues, les retours nus nuisent souvent à la lisibilité, car on ne voit pas clairement ce qui est renvoyé. Préfère les valeurs de retour explicites, sauf si la fonction est assez courte pour que sa signature reste toujours visible.

Pour en savoir plus, consulte Go by Example: Multiple Return Values, Effective Go: Multiple Returns ou le Tour of Go.