Comment les pratiques idiomatiques Go abordent-elles la gestion des erreurs ?

Gestion des erreurs dans Go : approches standard et idiomatiques

Golang encourage l'utilisation de variables d'erreur pour indiquer l'apparition d'erreurs. Cependant, il n’existe pas d’ensemble prédéfini de variables d’erreur standard. Au lieu de cela, il est conseillé aux développeurs d'adopter des pratiques idiomatiques pour définir et gérer les erreurs.

Variables d'erreur fixes

Il est courant que les packages définissent des variables d'erreur fixes dont les noms commencent par le préfixe "Err". Ces variables sont généralement utilisées pour représenter des conditions d'erreur spécifiques, permettant une vérification facile des erreurs. Par exemple :

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

Types d'erreur

Une autre approche idiomatique consiste à définir des types d'erreur personnalisés en créant des structures qui implémentent l'interface d'erreur. Ces types d'erreurs peuvent contenir des informations supplémentaires relatives à l'erreur, ce qui facilite la vérification de types d'erreurs spécifiques.

type SomeError struct {
    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))
}

Valeurs d'erreur ad hoc

Dans les situations lorsque des conditions d'erreur spécifiques ne sont pas anticipées, il est possible de créer de nouvelles valeurs d'erreur à la volée à l'aide de la fonction error.New(). Cette méthode renvoie une valeur d'erreur avec un message d'erreur personnalisé.

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

Utilisation des erreurs standard

Go fournit un ensemble limité d'erreurs standard définies dans ses packages. Ces erreurs sont souvent utilisées lors de la mise en œuvre d’interfaces ou du respect de normes spécifiques. Cependant, il est généralement recommandé de définir des erreurs personnalisées pour des conditions d'erreur plus spécifiques au sein des packages.

func SomeFunc() error {
    return io.EOF
}

Interfaces d'erreur

Go permet également la création d'interfaces d'erreur qui définissent les comportements d’erreur courants. Ces interfaces permettent de vérifier les erreurs pour des propriétés spécifiques.

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

Error Wrapping dans Go 1.13

Depuis Go 1.13, il est possible d'envelopper les erreurs existantes avec le contexte ou des informations complémentaires. Cela simplifie la gestion des erreurs en fournissant plus de contexte aux utilisateurs sans avoir besoin de types d'erreurs personnalisés étendus.

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

En suivant ces pratiques idiomatiques, les développeurs peuvent gérer efficacement les erreurs dans leur code Go, garantissant une gestion des erreurs claire et gérable. mécanismes.

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!