Wie gehe ich effektiv mit Fehlern in Go um?

Umgang mit Fehlern in Go: Standardansätze

Bei der Go-Entwicklung ist die Fehlerprotokollierung ein entscheidendes Anliegen. In diesem Artikel werden verschiedene Standardtechniken zur effektiven Fehlerbehandlung untersucht.

Fehlervariablen

Das Erstellen fester Fehlervariablen, die häufig mit dem Präfix „Err“ benannt werden, ist ein bewährter Ansatz. Diese Variablen kapseln normalerweise eine beschreibende Zeichenfolge, die auf bestimmte Fehlerbedingungen ausgerichtet ist. Beispiel:

var (
        ErrSomethingBad = errors.New("some string")
        ErrKindFoo      = errors.New("foo happened")
)

Fehlertypen

Fehlertypen, gekennzeichnet mit „...Error“-Suffixen, bieten eine strukturiertere Möglichkeit zur Darstellung von Fehlern. Sie umfassen eine benutzerdefinierte Typdefinition mit optionalen Feldern oder Methoden, um zusätzliche Informationen über den Fehler zu übermitteln. Beispiel:

type SomeError struct {
     // extra information, whatever might be useful to callers
     // (or for making a nice message in `Error()`)
     ExtraInfo int
}
type OtherError string

func (e SomeError) Error() string { /* … */ }
func (e OtherError) Error() string {
        return fmt.Sprintf("failure doing something with %q", string(e))
}

Ad-hoc-Fehler

Die Verwendung von „errors.New“ zum Generieren von Ad-hoc-Fehlerwerten ist für generische Fehlerbedingungen akzeptabel, die keiner weiteren Ausarbeitung bedürfen. Beispiel:

func SomepackageFunction() error {
        return errors.New("not implemented")
}

Nutzung von Standardfehlern

Die Auswahl geeigneter Fehler, die in der Standardbibliothek definiert sind, wie z. B. io.EOF, kann in bestimmten Szenarien praktisch sein. Dennoch ist es üblicher, benutzerdefinierte Fehler für bestimmte Fehlerbedingungen in Ihrem Paket zu erstellen. Beispiel:

func SomeFunc() error {
        return io.EOF
}

Fehlerschnittstellen

Go ermöglicht die Erstellung benutzerdefinierter Fehlerschnittstellen wie net.Error, die es Entwicklern ermöglichen, spezifische Verhaltensweisen und Fehlerkategorien zu definieren. Beispiel:

type Error interface {
    error
    Timeout() bool   // Is the error a timeout?
    Temporary() bool // Is the error temporary?
}

Fehlerumbruch

In Go 1.13 und höher ermöglicht der Fehlerumbruch die Erweiterung eines vorhandenen Fehlers um zusätzlichen Kontext oder Details. Dieser Ansatz erleichtert die Fehlerausbreitung und hilft bei der Fehleranalyse. Beispiel:

func SomepackageFunction() error {
    err := somethingThatCanFail()
    if err != nil {
            return fmt.Errorf("some context: %w", err)
    }
}

Testen auf Fehler

Die etablierten Fehlertypen in Go ermöglichen ein zuverlässiges Testen von Fehlerbedingungen. Entwickler können Fehler mit vordefinierten Variablen vergleichen oder Schnittstellen verwenden, um auf bestimmte Fehlerverhalten zu prüfen. Beispiel:

err := somepkg.Function()
if err == somepkg.ErrSomethingBad {
        // …
}
// or for an error type, something like:
if e, ok := err.(somepkg.SomeError); ok && e.ExtraInfo > 42 {
        // use the fields/methods of `e` if needed
}

In Go 1.13 und höher bieten die Funktionen „errors.Is“ und „errors.As“ erweiterte Fehlertestfunktionen durch effektives Auspacken und Abgleichen von Fehlern.

Fazit

Go bietet einen vielseitigen Satz an Tools zur Fehlerbehandlung, mit denen Entwickler basierend auf ihren Anforderungen den am besten geeigneten Ansatz auswählen können. Durch die Nutzung der in diesem Artikel beschriebenen Techniken können Sie eine robuste Fehlerprotokollierung und eine verbesserte Codequalität in Ihren Go-Anwendungen sicherstellen.

Das obige ist der detaillierte Inhalt vonWie gehe ich effektiv mit Fehlern in Go um?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!