Comment fonctionnent les fonctions et les retours multiples en Go ?

Question

Accepted Answer

Les fonctions Go sont déclarées avec `func`, et une caractéristique distinctive est **les retours multiples** — une fonction peut retourner plusieurs valeurs à la fois. C'est utilisé de façon omniprésente, notamment l'idiome `(result, error)` qui définit la gestion des erreurs en Go.

## Fonction basique

```go
func add(a int, b int) int {     // params with types, then the return type
    return a + b
}

func greet(name string) string {
    return "Hello, " + name
}
// shorthand for same-typed params: func add(a, b int) int
```

## Retours multiples — la caractéristique définissante

```go
func divide(a, b int) (int, error) {     // returns BOTH a result AND an error
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil    // nil error = success
}

// callers handle both — the ubiquitous Go error pattern
result, err := divide(10, 2)
if err != nil {
    log.Fatal(err)       // handle the error
}
fmt.Println(result)
```

Retourner `(value, error)` est L'idiome pour la gestion des erreurs en Go — au lieu d'exceptions, les fonctions retournent les erreurs comme des valeurs que les appelants vérifient explicitement. Cela rend la gestion des erreurs visible et impossible à ignorer silencieusement.

## Le pattern comma-ok

```go
// many built-ins return (value, ok) — a boolean for "did it work?"
value, ok := myMap["key"]   // ok = false if the key is missing
if ok { ... }

v, ok := someInterface.(string)   // type assertion with ok
```

## Retours nommés

```go
func split(sum int) (x, y int) {   // named returns
    x = sum * 4 / 9
    y = sum - x
    return   // "naked return" — returns the named values
}
```

## Fonctions variadiques

```go
func sum(nums ...int) int {     // accepts any number of ints
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3)          // 6
sum(nums...)          // spread a slice into args
```

## Les fonctions sont de première classe

```go
var op func(int, int) int = add   // assign functions to variables
func apply(fn func(int) int, x int) int { return fn(x) }  // pass as arguments
```

## Pourquoi c'est important

Les fonctions Go sont centrales, et **les retours multiples** sont l'une des caractéristiques définissantes du langage — ils permettent l'idiome `(result, error)` qui *est* l'approche Go de la gestion des erreurs (vérification explicite des erreurs en tant que valeurs plutôt que les exceptions).

Ce pattern, utilisé dans pratiquement tous les programmes Go, rend la gestion des erreurs visible et délibérée.

L'idiome comma-ok associé (`value, ok :=`) apparaît partout (accès aux maps, assertions de type, réceptions de channel).

Comprendre les retours multiples, le pattern d'erreur, les retours nommés, les fonctions variadiques et les fonctions de première classe est essentiel pour lire et écrire du Go idiomatique — et la philosophie error-as-value est l'une des différences conceptuelles les plus importantes entre Go et les langages basés sur les exceptions.