Comment gérer efficacement les erreurs dans Go ?

Gérer les erreurs dans Go : approches standard

Dans le développement Go, la journalisation des erreurs est une préoccupation cruciale. Cet article explore plusieurs techniques standard utilisées pour gérer efficacement les erreurs.

Variables d'erreur

La création de variables d'erreur fixes, fréquemment nommées avec le préfixe « Err », est une approche bien établie. Ces variables encapsulent généralement une chaîne descriptive qui correspond à des conditions d'erreur spécifiques. Exemple :

var (
        ErrSomethingBad = errors.New("some string")
        ErrKindFoo      = errors.New("foo happened")
)

Types d'erreur

Les types d'erreur, désignés par les suffixes "...Erreur", fournissent une manière plus structurée de représenter les erreurs. Ils comprennent une définition de type personnalisée avec des champs ou des méthodes facultatifs pour transmettre des informations supplémentaires sur l'erreur. Exemple :

type SomeError struct {
     // extra information, whatever might be useful to callers
     // (or for making a nice message in `Error()`)
     ExtraInfo int
}
type OtherError string

func (e SomeError) Error() string { /* … */ }
func (e OtherError) Error() string {
        return fmt.Sprintf("failure doing something with %q", string(e))
}

Erreurs ad hoc

Utilisation d'erreurs. Nouveau pour générer des valeurs d'erreur ad hoc est acceptable pour les conditions d'erreur génériques qui ne nécessitent pas de développement supplémentaire. Exemple :

func SomepackageFunction() error {
        return errors.New("not implemented")
}

Exploiter les erreurs standard

La sélection des erreurs appropriées définies dans la bibliothèque standard, telles que io.EOF, peut être pratique dans certains scénarios. Néanmoins, il est plus courant de créer des erreurs personnalisées pour des conditions d'erreur spécifiques au sein de votre package. Exemple :

func SomeFunc() error {
        return io.EOF
}

Interfaces d'erreur

Go permet la création d'interfaces d'erreur personnalisées, telles que net.Error, qui permettent aux développeurs de définir des comportements spécifiques et des catégories d'erreurs. Exemple :

type Error interface {
    error
    Timeout() bool   // Is the error a timeout?
    Temporary() bool // Is the error temporary?
}

Error Wrapping

Dans Go 1.13 et versions ultérieures, l'Error Wrapping permet l'extension d'une erreur existante avec un contexte ou des détails supplémentaires. Cette approche facilite la propagation des erreurs et facilite l’analyse des erreurs. Exemple :

func SomepackageFunction() error {
    err := somethingThatCanFail()
    if err != nil {
            return fmt.Errorf("some context: %w", err)
    }
}

Test des erreurs

Les types d'erreurs établis dans Go permettent de tester de manière fiable les conditions d'erreur. Les développeurs peuvent comparer les erreurs à des variables prédéfinies ou utiliser des interfaces pour vérifier des comportements d'erreur spécifiques. Exemple :

err := somepkg.Function()
if err == somepkg.ErrSomethingBad {
        // …
}
// or for an error type, something like:
if e, ok := err.(somepkg.SomeError); ok && e.ExtraInfo > 42 {
        // use the fields/methods of `e` if needed
}

Dans Go 1.13 et versions ultérieures, les fonctions erreurs.Is et erreurs.As offrent des capacités de test d'erreur améliorées en déballant et en faisant correspondre efficacement les erreurs.

Conclusion

Go fournit un ensemble polyvalent d'outils de gestion des erreurs, permettant aux développeurs de sélectionner l'approche la plus appropriée en fonction de leurs besoins. En tirant parti des techniques abordées dans cet article, vous pouvez garantir une journalisation des erreurs robuste et une qualité de code améliorée dans vos applications Go.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!