Go Academy · Leçon

L’interface error

Renvoyer et vérifier les erreurs de manière idiomatique

L’interface error est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

La philosophie des erreurs en Go

Go gère les erreurs comme des valeurs, et non comme des exceptions. Les fonctions retournent une error comme dernière valeur de retour. L'appelant doit la vérifier explicitement :

package main
import ("fmt"; "strconv")

func main() {
    n, err := strconv.Atoi("abc")
    if err != nil {
        fmt.Println("error:", err)  // handle it
        return
    }
    fmt.Println(n)
}

L'interface error

L'interface intégrée error est simple :

// Built into Go — no import needed
type error interface {
    Error() string
}

// Any type with Error() string satisfies it
// nil means no error

Retourner des erreurs

Les fonctions susceptibles d'échouer retournent (value, error). Retournez nil lorsqu'il n'y a pas d'erreur :

package main
import ("fmt"; "errors")

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

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Println(result)
}

Le modèle if err != nil

La vérification if err != nil est l'idiome Go le plus courant. Gérez toujours les erreurs — ne les ignorez pas :

package main
import ("fmt"; "os")

func main() {
    f, err := os.Open("config.json")
    if err != nil {
        fmt.Println("open error:", err)
        return
    }
    defer f.Close()
    // use f...
    _ = f
}

errors.New — valeurs d'erreur simples

errors.New crée une erreur simple avec un message fixe :

package main
import ("fmt"; "errors")

var ErrNotFound = errors.New("not found")

func findByID(id int) (string, error) {
    data := map[int]string{1: "Alice"}
    v, ok := data[id]
    if !ok {
        return "", ErrNotFound
    }
    return v, nil
}

func main() {
    _, err := findByID(99)
    fmt.Println(err) // not found
}

fmt.Errorf — messages d'erreur formatés

fmt.Errorf crée des erreurs avec un contexte provenant de chaînes formatées :

package main
import "fmt"

func openConfig(path string) error {
    // Add context to the error message
    return fmt.Errorf("openConfig %s: file not found", path)
}

func main() {
    err := openConfig("/etc/app/config.yaml")
    fmt.Println(err)
    // openConfig /etc/app/config.yaml: file not found
}

Erreurs sentinelles

Les erreurs sentinelles sont des valeurs d'erreur définies au niveau du paquet et utilisées pour comparer l'identité :

package main
import ("fmt"; "errors")

var (
    ErrTimeout    = errors.New("timeout")
    ErrPermission = errors.New("permission denied")
)

func doRequest() error { return ErrTimeout }

func main() {
    err := doRequest()
    if errors.Is(err, ErrTimeout) {
        fmt.Println("request timed out — retrying")
    }
}

Ignorer les erreurs est un bogue

Go vous impose d'utiliser chaque variable déclarée — mais ignorer les erreurs avec _ compile correctement et constitue une erreur courante à éviter :

package main
import "os"

func bad() {
    os.Remove("temp.txt") // silently ignores error — bad practice
}

func good() error {
    if err := os.Remove("temp.txt"); err != nil {
        return err  // propagate
    }
    return nil
}

Contexte des erreurs : ajouter des informations

Lorsque vous propagez des erreurs dans la pile d'appels, ajoutez un contexte décrivant l'opération qui a échoué :

package main
import "fmt"

func readConfig(path string) ([]byte, error) {
    return nil, fmt.Errorf("readConfig: %w", fmt.Errorf("file %s not found", path))
}

func setup() error {
    _, err := readConfig("/etc/app.cfg")
    if err != nil {
        return fmt.Errorf("setup: %w", err) // wrap with context
    }
    return nil
}

func main() {
    err := setup()
    fmt.Println(err) // setup: readConfig: file /etc/app.cfg not found
}

Retours d'erreurs multiples

Les fonctions peuvent retourner des erreurs provenant de plusieurs points d'échec. Vérifiez chacun d'eux :

package main
import ("fmt"; "strconv")

func parseRange(minStr, maxStr string) (int, int, error) {
    min, err := strconv.Atoi(minStr)
    if err != nil { return 0, 0, fmt.Errorf("min: %w", err) }
    max, err := strconv.Atoi(maxStr)
    if err != nil { return 0, 0, fmt.Errorf("max: %w", err) }
    if min > max { return 0, 0, fmt.Errorf("min %d > max %d", min, max) }
    return min, max, nil
}

func main() {
    lo, hi, err := parseRange("1", "10")
    if err != nil { fmt.Println(err); return }
    fmt.Println(lo, hi)
}

Vérification rapide

Que signifie une valeur de retour d'erreur nil en Go ?

Récapitulatif : l'interface error

Concepts essentiels de la gestion des erreurs :

Error est une interface intégrée : Error() string
Retournez (value, error) — nil signifie que l'opération a réussi
errors.New pour les erreurs simples, fmt.Errorf pour les erreurs formatées
Vérifiez toujours if err != nil
Ajoutez un contexte lorsque vous propagez les erreurs dans la pile
N'ignorez jamais les erreurs silencieusement

Questions Fréquemment Posées

La leçon « L’interface error » est-elle gratuite ?

Oui — le texte complet de « L’interface error » 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 « L’interface error » ?

Renvoyer et vérifier les erreurs de manière idiomatique 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 1 sur 4.

Combien de temps prend la leçon « L’interface error » ?

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