Comment gérer efficacement les erreurs dans les hiérarchies d'abstraction multi-niveaux de Go ?

Gestion des erreurs dans une hiérarchie d'abstraction multi-niveaux dans Go

Dans Go, lorsque vous travaillez avec plusieurs niveaux d'abstraction, la gestion des erreurs devient critique pour maintenir une base de code propre et maintenable. Il est crucial d'éviter les messages d'erreur en double et de garantir que les erreurs sont traitées de manière significative.

Encapsuler les erreurs

L'approche recommandée consiste à envelopper les erreurs à l'aide du package d'erreurs ou similaire. outils. Cette technique consiste à créer une nouvelle valeur d'erreur qui enveloppe l'erreur d'origine, fournissant un contexte à chaque niveau de la hiérarchie d'abstraction.

Exemple d'annotation d'erreurs

Considérez l'exemple suivant en utilisant le package d'erreurs :

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
}

Dans cet exemple, les erreurs sont encapsulées à chaque niveau, fournissant une trace claire du contexte menant à la cause première du problème. error.

Extension fmt.Errorf()

Au lieu d'encapsuler les erreurs, vous pouvez également étendre l'erreur en utilisant fmt.Errorf(). Cette approche est plus simple mais ne vous permet pas d'extraire l'erreur d'origine.

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
}

Gestion des erreurs vs délégation

Il est important de déterminer si une erreur doit être gérées ou déléguées à un niveau supérieur. Le traitement d'une erreur implique de l'inspecter et de prendre des actions spécifiques, tandis que la délégation transfère la responsabilité à l'appelant. La délégation est préférable si l'appelant est mieux équipé pour gérer l'erreur ou si l'erreur est simplement informative.

Enregistrer les messages d'erreur

Lors de l'enregistrement des messages d'erreur, assurez-vous de fournissez suffisamment de détails sur l’erreur et son contexte. Utilisez la chaîne d'erreur de l'erreur et toute information supplémentaire disponible pour identifier clairement la cause première du problème.

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!