Erreurs : le motif `if err != nil`

Dans Go, les erreurs sont des valeurs, pas des exceptions. Une fonction qui peut fail renvoie l'erreur comme dernière valeur et l'appelant la vérifie explicitement. C'est explicite, prévisible, facile à tester — le prix est un peu plus de verbosité.

L'interface error

error est une petite interface intégrée au langage :

type error interface {
    Error() string
}

Tout type qui implémente Error() string est un error.

Le modèle fondamental

v, err := operazione()
if err != nil {
    // gestisci o propaga
    return err
}
// usa v

Vous le verrez des milliers de fois : c'est le code idiomatique de chaque appel faillible. Ne vous sentez pas coupable de la répétition - c'est une caractéristique, pas un bug.

Erreurs de construction : errors.New et fmt.Errorf

import (
    "errors"
    "fmt"
)

err1 := errors.New("file mancante")
err2 := fmt.Errorf("apertura %q fallita: permesso negato", path)

fmt.Errorf est parfait lorsque vous souhaitez inclure des variables dans le message.

Emballage avec %w

Pour propager une erreur en ajoutant du contexte SANS perdre l'original :

f, err := os.Open(path)
if err != nil {
    return fmt.Errorf("config: %w", err)
}

%w "enveloppe" l'erreur d'origine, récupérable ultérieurement avec errors.Is (égalité pour les sentinelles) ou errors.As (pour le type béton) :

if errors.Is(err, os.ErrNotExist) {
    // file inesistente, gestione speciale
}

Erreurs Sentinelle

Il s'agit d'erreurs exportées sous forme de variables, utilisées pour les comparaisons avec errors.Is :

var ErrNotFound = errors.New("non trovato")

func find(id int) (Item, error) {
    // ...
    return Item{}, ErrNotFound
}

// chiamante:
if errors.Is(err, ErrNotFound) { ... }

panic et recover (aperçu)

panic existe dans Go mais est réservé aux erreurs irrécupérables (ex. bugs, invariants violés), pas pour le flux de contrôle normal. Nous approfondirons le module Fonctions avec defer/recover. Pour l'instant : ne l'utilisez pas sur place du modèle if err != nil.

Essayez-le

v, err := f()
// poi?

Récapitulatif

• error est une interface avec une seule méthode Error() string.
• Modèle canonique : v, err := f(); if err != nil { return err }.
• Générez des erreurs avec errors.New(msg) ou fmt.Errorf("ctx: %w", err).
• Utiliser %w pour l'emballage et errors.Is / errors.As pour inspecter la chaîne.
• panic uniquement pour les erreurs irrécupérables, PAS pour le flux de contrôle normal.