Wie gehen idiomatische Go-Praktiken mit der Fehlerbehandlung um?

Fehlerbehandlung in Go: Standard- und idiomatische Ansätze

Golang empfiehlt die Verwendung von Fehlervariablen, um das Auftreten von Fehlern anzuzeigen. Es gibt jedoch keinen vordefinierten Satz von Standardfehlervariablen. Stattdessen wird Entwicklern empfohlen, idiomatische Vorgehensweisen zum Definieren und Behandeln von Fehlern anzuwenden.

Feste Fehlervariablen

Es ist üblich, dass Pakete feste Fehlervariablen definieren, deren Namen mit beginnen das Präfix „Err“. Diese Variablen werden normalerweise verwendet, um bestimmte Fehlerbedingungen darzustellen und so eine einfache Fehlerprüfung zu ermöglichen. Zum Beispiel:

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

Fehlertypen

Ein weiterer idiomatischer Ansatz besteht darin, benutzerdefinierte Fehlertypen zu definieren, indem Strukturen erstellt werden, die die Fehlerschnittstelle implementieren. Diese Fehlertypen können zusätzliche Informationen enthalten, die für den Fehler relevant sind, sodass Sie bequem nach bestimmten Fehlertypen suchen können.

type SomeError struct {
    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-Fehlerwerte

In bestimmten Situationen Wenn bestimmte Fehlerbedingungen nicht zu erwarten sind, ist es möglich, mithilfe der Funktion „errors.New()“ im Handumdrehen neue Fehlerwerte zu erstellen. Diese Methode gibt einen Fehlerwert mit einer benutzerdefinierten Fehlermeldung zurück.

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

Standardfehler verwenden

Go stellt einen begrenzten Satz von Standardfehlern bereit, die in seinen Paketen definiert sind. Diese Fehler werden häufig bei der Implementierung von Schnittstellen oder der Einhaltung bestimmter Standards verwendet. Es wird jedoch generell empfohlen, benutzerdefinierte Fehler für spezifischere Fehlerbedingungen innerhalb von Paketen zu definieren.

func SomeFunc() error {
    return io.EOF
}

Fehlerschnittstellen

Go ermöglicht auch die Erstellung von Fehlerschnittstellen die häufiges Fehlerverhalten definieren. Diese Schnittstellen ermöglichen die Überprüfung von Fehlern für bestimmte Eigenschaften.

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

Fehlerumschließung in Go 1.13

Seit Go 1.13 ist es möglich, vorhandene Fehler mit Kontext zu umschließen oder zusätzliche Informationen. Dies vereinfacht die Fehlerbehandlung, indem Benutzern mehr Kontext bereitgestellt wird, ohne dass umfangreiche benutzerdefinierte Fehlertypen erforderlich sind.

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

Durch die Befolgung dieser idiomatischen Vorgehensweisen können Entwickler Fehler in ihrem Go-Code effektiv behandeln und so eine klare und überschaubare Fehlerbehandlung gewährleisten Mechanismen.

Das obige ist der detaillierte Inhalt vonWie gehen idiomatische Go-Praktiken mit der Fehlerbehandlung um?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!