Wie kann ich Fehler in den mehrstufigen Abstraktionen von Go effektiv behandeln?

Fehlerbehandlung in mehrstufigen Abstraktionen in Go

Die Fehlerbehandlung in mehrstufigen Abstraktionen kann umständlich werden, wenn Fehler wiederholt weitergegeben werden Kette, was zu doppelten Protokollen und verlorenem Kontext führt.

Annotation Fehler

Das Kommentieren von Fehlern ist ein empfohlener Ansatz. Dabei wird ein neuer Fehlerwert erstellt, der den ursprünglichen Fehler umschließt und zusätzlichen Kontext bereitstellt. Zu diesem Zweck stellt das Fehlerpaket die Funktionen Wrap() und Cause() bereit.

Im gegebenen Beispiel:

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

Das ObjectThreeHiggerLevel kommentiert den Fehler von ObjectTwoHigherLevel mit zusätzlichem Kontext.

Fehler „erweitern“

Ein alternativer Ansatz ist: Fehler mit fmt.Errorf() „erweitern“. Es bietet zwar keine Funktionen zum Entpacken von Fehlern, ermöglicht Ihnen aber das Erstellen benutzerdefinierter Fehlermeldungen mit zusätzlichem Kontext:

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

Delegieren oder Behandeln von Fehlern

Beim Behandeln von Fehlern , ist es wichtig zu entscheiden, ob man sie bearbeitet oder an eine höhere Ebene delegiert. Wenn ein Fehler nicht behandelt wird, sollte er mit zusätzlichem Kontext delegiert werden, um den Verlust von Informationen oder die Entstehung doppelter Protokolle zu vermeiden.

Im Beispiel:

// ObjectThreeHiggerLevel
func (oTh *ObjectThreeHiggerLevel) CheckObjectTwoIsReady() error {
    if err := oTh.ObjectTwoHigherLevel.CheckObjectOneIsReady(); err != nil {
        if err := oTh.HandleError(err); err != nil {
            // Error handling failed, log and return original error
            return errors.Wrapf(err, "Object3 failed to handle error: %v", err)
        }
        return nil
    }
    return nil
}

In diesem Beispiel versucht HandleError() um den Fehler zu behandeln. Wenn dies fehlschlägt, wird der ursprüngliche Fehler umschlossen und zurückgegeben.

Doppelte Protokolle vermeiden

Das Annotieren oder Erweitern von Fehlern mit Kontext stellt sicher, dass, wenn ein Fehler im Stapel weitergegeben wird, Es enthält alle notwendigen Informationen für eine sinnvolle Protokollierung und Fehlerbehandlung. Dies verhindert doppelte Protokolle und hilft, die Grundursache eines Problems zu verstehen.

Das obige ist der detaillierte Inhalt vonWie kann ich Fehler in den mehrstufigen Abstraktionen von Go effektiv behandeln?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!