Wie kann ich mit Is() und As() in Go einen rekursiven Fehlerumbruch erreichen?

Go-Fehler: Is() und As() unterstützen rekursives Fehler-Wrapping

In Go ist die Fehlerbehandlung von entscheidender Bedeutung für die Verwaltung und Analyse von Fehlern während der gesamten Anwendung. Die Fehlerschnittstelle bietet eine allgemeine Methode zur Darstellung von Fehlern und umfasst Methoden wie Is() und As() zur Fehlerintrospektion.

Es ist jedoch wichtig zu beachten, dass die Standardfehlerschnittstelle keine rekursive Fehlerumschließung unterstützt . Das bedeutet, dass Sie, wenn Sie fmt.Errorf zum Umschließen von Fehlern verwenden, Is() und As() nicht verwenden können, um rekursiv nach zugrunde liegenden Fehlern zu suchen.

Benutzerdefinierter Fehlertyp für rekursive Fehler Wrapping

Um ein rekursives Fehler-Wrapping zu erreichen, können Sie einen benutzerdefinierten Fehlertyp erstellen, der die Fehlerschnittstelle implementiert. Dieser Typ sollte einen Verweis auf den umschlossenen Fehler enthalten und benutzerdefinierte Is()- und As()-Methoden definieren, um rekursive Vergleiche zu ermöglichen.

Hier ist eine Beispielimplementierung eines rekursiven Fehlertyps:

type errorChain struct {
    err  error
    next *errorChain
}

func (c errorChain) Is(err error) bool {
    // Check the current error against the given error
    if c.err == err {
        return true
    }
    // Check if there is a wrapped error and recursively call Is()
    if c.next != nil {
        return c.next.Is(err)
    }
    return false
}

func (c errorChain) As(target interface{}) bool {
    // Check if the current error As() to the target interface
    if errors.As(c.err, target) {
        return true
    }
    // Check if there is a wrapped error and recursively call As()
    if c.next != nil {
        return c.next.As(target)
    }
    return false
}

Fehler rekursiv umschließen

Sobald Sie einen benutzerdefinierten Fehlertyp definiert haben, können Sie Fehler umschließen rekursiv mit einer Funktion wie der folgenden:

func Wrap(errs ...error) error {
    if len(errs) == 0 {
        return nil
    }
    // Create the first error in the chain
    out := &errorChain{err: errs[0]}
    // Iterate over the remaining errors
    for _, err := range errs[1:] {
        // Link the errors together
        out.next = &errorChain{err: err}
        out = out.next
    }
    return out
}

Verwendung

Sie können jetzt diesen benutzerdefinierten Fehlertyp verwenden, um Fehler zu umschließen und rekursiv nach zugrunde liegenden Fehlern zu suchen, indem Sie Is( ) und As(). Zum Beispiel:

var Err1 = errors.New("error 1")
var Err2 = errors.New("error 2")
var Err3 = errors.New("error 3")

err := Wrap(Err1, Err2, Err3)

fmt.Println(errors.Is(err, Err2)) // true
fmt.Println(errors.Is(err, Err3)) // true
fmt.Println(errors.Is(err, Err0)) // false

Fazit

Durch die Erstellung eines benutzerdefinierten Fehlertyps mit rekursiven Is()- und As()-Methoden können Sie eine rekursive Fehlerumschließung und -ausführung erreichen Präzisere Fehlerbehandlung in Ihren Go-Anwendungen.

Das obige ist der detaillierte Inhalt vonWie kann ich mit Is() und As() in Go einen rekursiven Fehlerumbruch erreichen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!