Comment gérer efficacement les erreurs sur plusieurs niveaux d'abstraction dans Go ?

Comment gérer efficacement les erreurs sur plusieurs niveaux d'abstraction dans Go

La gestion des erreurs de manière gracieuse et cohérente est cruciale pour maintenir la santé et la fiabilité des grands et des applications Go complexes. Cependant, lorsque vous travaillez avec plusieurs couches d'abstraction, il devient difficile de gérer efficacement les erreurs tout en évitant la journalisation en double ou la perte de contexte important.

Annotation des erreurs pour la propagation contextuelle

L’annotation des erreurs est une technique puissante pour la gestion des erreurs à travers les niveaux d’abstraction. Cette approche implique de créer une nouvelle valeur d'erreur et d'y envelopper l'erreur d'origine, fournissant ainsi un contexte et des informations supplémentaires sur l'origine de l'erreur.

Pour implémenter l'annotation d'erreur, vous pouvez utiliser une bibliothèque comme github.com/pkg/errors . Il propose des fonctions pour encapsuler les erreurs (errors.Wrap()) et extraire les erreurs encapsulées (errors.Cause()).

Voici un exemple illustrant l'annotation d'erreur :

func (o *ObjectOne) CheckValue() error {
    if o.someValue == 0 {
        return errors.New("Object1 illegal state: value is 0")
    }
    return nil
}

func (oT *ObjectTwoHigherLevel) CheckObjectOneIsReady() error {
    if err := oT.objectOne.CheckValue(); err != nil {
        return errors.Wrap(err, "Object2 illegal state: Object1 is invalid")
    }
    return nil
}

func (oTh *ObjectThreeHiggerLevel) CheckObjectTwoIsReady() error {
    if err := oTh.ObjectTwoHigherLevel.CheckObjectOneIsReady(); err != nil {
        return errors.Wrap(err, "Object3 illegal state: Object2 is invalid")
    }
    return nil
}

Si un utilisateur de ObjectThreeHiggerLevel décide de gérer l'erreur, il recevra un message d'erreur complet qui retrace l'erreur à travers tous les niveaux d'abstraction, en préservant l'original. contexte.

o3 := &ObjectThreeHiggerLevel{}
if err := o3.CheckObjectTwoIsReady(); err != nil {
    fmt.Println(err)
}

Sortie :

Object3 illegal state: Object2 is invalid: Object2 illegal state: Object1 is invalid: Object1 illegal state: value is 0

Extension des erreurs pour une propagation simplifiée

Si vous préférez une approche plus simple, vous pouvez également " extend" en utilisant fmt.Errorf() pour créer un message d'erreur plus descriptif. Cette méthode est moins flexible que l'annotation mais permet tout de même d'ajouter certaines informations contextuelles.

Exemple d'utilisation de fmt.Errorf() :

func (o *ObjectOne) CheckValue() error {
    if o.someValue == 0 {
        return fmt.Errorf("Object1 illegal state: value is %d", o.someValue)
    }
    return nil
}

func (oT *ObjectTwoHigherLevel) CheckObjectOneIsReady() error {
    if err := oT.objectOne.CheckValue(); err != nil {
        return fmt.Errorf("Object2 illegal state: %v", err)
    }
    return nil
}

func (oTh *ObjectThreeHiggerLevel) CheckObjectTwoIsReady() error {
    if err := oTh.ObjectTwoHigherLevel.CheckObjectOneIsReady(); err != nil {
        return fmt.Errorf("Object3 illegal state: %v", err)
    }
    return nil
}

Message d'erreur lors de la manipulation dans ObjectThreeHiggerLevel :

Object3 illegal state: Object2 illegal state: Object1 illegal state: value is 0

En employant une annotation ou une extension d'erreur, vous pouvez gérer efficacement les erreurs à différentes abstractions. niveaux, évitez la journalisation en double et assurez-vous que tout le contexte pertinent est préservé pour l'enquête et la résolution des erreurs.

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!