Wie kann man Fehler über mehrere Abstraktionsebenen hinweg in Go effektiv behandeln?

So behandeln Sie Fehler über mehrere Abstraktionsebenen hinweg in Go effektiv

Der ordnungsgemäße und konsistente Umgang mit Fehlern ist entscheidend für die Aufrechterhaltung der Gesundheit und Zuverlässigkeit großer Unternehmen und komplexe Go-Anwendungen. Bei der Arbeit mit mehreren Abstraktionsebenen wird es jedoch zu einer Herausforderung, Fehler effektiv zu verwalten und gleichzeitig eine doppelte Protokollierung oder den Verlust wichtiger Kontexte zu vermeiden.

Fehler mit Anmerkungen zur kontextbezogenen Weitergabe versehen

Eine leistungsstarke Technik zur Fehlerbehandlung über Abstraktionsebenen hinweg ist die Fehlerannotation. Bei diesem Ansatz wird ein neuer Fehlerwert erstellt und der ursprüngliche Fehler darin eingeschlossen, wodurch zusätzlicher Kontext und Informationen zum Ursprung des Fehlers bereitgestellt werden.

Um Fehleranmerkungen zu implementieren, können Sie eine Bibliothek wie github.com/pkg/errors verwenden . Es bietet Funktionen zum Umschließen von Fehlern (errors.Wrap()) und zum Extrahieren umschlossener Fehler (errors.Cause()).

Hier ist ein Beispiel, das die Fehleranmerkung zeigt:

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
}

Wenn ein Benutzer Wenn ein Benutzer von ObjectThreeHiggerLevel beschließt, den Fehler zu behandeln, erhält er eine umfassende Fehlermeldung, die den Fehler über alle Abstraktionsebenen hinweg nachverfolgt und dabei das Original bewahrt Kontext.

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

Ausgabe:

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

Erweitern von Fehlern für eine vereinfachte Ausbreitung

Wenn Sie einen einfacheren Ansatz bevorzugen, können Sie auch „ Erweitern Sie Fehler, indem Sie fmt.Errorf() verwenden, um eine aussagekräftigere Fehlermeldung zu erstellen. Diese Methode ist weniger flexibel als Annotation, ermöglicht aber dennoch das Hinzufügen einiger Kontextinformationen.

Beispiel für die Verwendung von 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
}

Fehlermeldung bei der Verarbeitung in ObjectThreeHiggerLevel:

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

Durch den Einsatz von Fehleranmerkungen oder -erweiterungen können Sie Fehler auf verschiedenen Abstraktionsebenen effektiv behandeln und Duplikate vermeiden Protokollierung und stellen Sie sicher, dass der gesamte relevante Kontext für die Fehleruntersuchung und -lösung erhalten bleibt.

Das obige ist der detaillierte Inhalt vonWie kann man Fehler über mehrere Abstraktionsebenen hinweg in Go effektiv behandeln?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!