Go Academy · Lektion

Eigene Fehler erstellen

errors.New, fmt.Errorf und Sentinel-Fehler

Eigene Fehler erstellen ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum eigene Fehlertypen?

Eigene Fehlertypen enthalten über eine String-Meldung hinaus strukturierte Daten. Dadurch können Aufrufer bestimmte Fehlerbedingungen untersuchen und darauf reagieren:

package main
import "fmt"

// Custom error type carries extra context
type HTTPError struct {
    StatusCode int
    Message    string
}

func (e *HTTPError) Error() string {
    return fmt.Sprintf("HTTP %d: %s", e.StatusCode, e.Message)
}

func fetch(url string) error {
    return &HTTPError{404, "page not found"}
}

func main() {
    err := fetch("http://example.com")
    fmt.Println(err) // HTTP 404: page not found
}

Das error-Interface implementieren

Jeder Typ mit einer Error() string-Methode erfüllt error:

package main
import "fmt"

type ValidationError struct {
    Field   string
    Value   interface{}
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation: field %q value %v — %s", e.Field, e.Value, e.Message)
}

func validateAge(age int) error {
    if age < 0 || age > 150 {
        return &ValidationError{"age", age, "must be between 0 and 150"}
    }
    return nil
}

func main() {
    fmt.Println(validateAge(-5))
}

Sentinel-Fehler mit errors.New

Sentinel-Fehler sind Variablen auf Paketebene für bekannte Fehlerbedingungen:

package main
import ("fmt"; "errors")

var (
    ErrNotFound      = errors.New("not found")
    ErrUnauthorized  = errors.New("unauthorized")
    ErrAlreadyExists = errors.New("already exists")
)

func getUser(id int) (string, error) {
    if id != 1 { return "", ErrNotFound }
    return "Alice", nil
}

func main() {
    _, err := getUser(99)
    if errors.Is(err, ErrNotFound) {
        fmt.Println("user does not exist")
    }
}

fmt.Errorf mit %w zum Wrapping

fmt.Errorf mit %w wrapped einen Fehler und bewahrt das Original für errors.Is und errors.As:

package main
import ("fmt"; "errors")

var ErrDatabase = errors.New("database error")

func queryDB() error {
    return fmt.Errorf("queryDB: %w", ErrDatabase)
}

func main() {
    err := queryDB()
    fmt.Println(err)                       // queryDB: database error
    fmt.Println(errors.Is(err, ErrDatabase)) // true — unwrapped
}

Eigener Fehler mit Unwrap

Implementieren Sie Unwrap() error für Ihren eigenen Fehlertyp, damit er an Fehlerketten teilnehmen kann:

package main
import ("fmt"; "errors")

var ErrNotFound = errors.New("not found")

type QueryError struct {
    Query string
    Err   error
}

func (e *QueryError) Error() string {
    return fmt.Sprintf("query %q: %v", e.Query, e.Err)
}
func (e *QueryError) Unwrap() error { return e.Err }

func main() {
    err := &QueryError{"SELECT *", ErrNotFound}
    fmt.Println(err)
    fmt.Println(errors.Is(err, ErrNotFound)) // true
}

errors.Is — Identitätsprüfung

errors.Is durchläuft die Fehlerkette und sucht nach einem Fehler, der dem Ziel entspricht:

package main
import ("fmt"; "errors")

var ErrTimeout = errors.New("timeout")

func deepCall() error {
    return fmt.Errorf("layer3: %w", fmt.Errorf("layer2: %w", ErrTimeout))
}

func main() {
    err := deepCall()
    fmt.Println(errors.Is(err, ErrTimeout)) // true — found deep in chain
}

errors.As — Typ auslesen

errors.As findet den ersten Fehler in der Kette, der dem Zieltyp entspricht, und weist ihn zu:

package main
import ("fmt"; "errors")

type PermissionError struct{ User string }
func (e *PermissionError) Error() string { return "permission denied for " + e.User }

func action(user string) error {
    return fmt.Errorf("action: %w", &PermissionError{user})
}

func main() {
    err := action("bob")
    var pe *PermissionError
    if errors.As(err, &pe) {
        fmt.Println("denied:", pe.User) // denied: bob
    }
}

Mehrfaches Fehler-Wrapping (Go 1.20+)

Go 1.20 fügte errors.Join und fmt.Errorf mit mehreren %w zum Zusammenführen von Fehlern hinzu:

package main
import ("fmt"; "errors")

func validate(name, email string) error {
    var errs []error
    if name == ""  { errs = append(errs, errors.New("name required")) }
    if email == "" { errs = append(errs, errors.New("email required")) }
    return errors.Join(errs...)
}

func main() {
    err := validate("", "")
    fmt.Println(err)
    // name required
    // email required
}

Namenskonventionen für Fehlertypen

Konventionen für Fehlervariablen und -typen in Go:

Sentinel-Fehlervariablen: ErrXxx (z. B. ErrNotFound)
Eigene Fehlertypen: XxxError (z. B. ValidationError)
Variable auf Paketebene für Sentinel-Fehler, Zeigertyp für umfangreiche Fehler
Exportieren Sie sie, damit Aufrufer sie in errors.Is / errors.As verwenden können

Wann welcher Ansatz verwendet wird

Den richtigen Ansatz für Fehler auswählen:

errors.New — einfach, ohne zusätzliche Daten, für den Identitätsvergleich von Sentinel-Fehlern
fmt.Errorf — formatierte Meldung mit optionalem Wrapping
Eigener Typ — wenn der Aufrufer strukturierte Daten benötigt (Felder, Codes)
errors.Join — mehrere Validierungsfehler zusammenfassen

Schnelltest

Mit welcher Funktion lässt sich ein bestimmter Fehlertyp aus einer Fehlerkette auslesen?

Zusammenfassung: Eigene Fehler

Zusammenfassung:

Implementieren Sie Error() string, um eigene Fehlertypen zu erstellen
Fügen Sie Unwrap() error hinzu, damit der Fehler an Fehlerketten teilnehmen kann
Verwenden Sie errors.Is für Identitätsprüfungen und errors.As zum Auslesen von Typen
Sentinel-Fehler: ErrXxx; eigene Typen: XxxError
errors.Join fasst mehrere Fehler zusammen (Go 1.20+)

Häufig gestellte Fragen

Ist die Lektion „Eigene Fehler erstellen“ kostenlos?

Ja — der vollständige Text von „Eigene Fehler erstellen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Eigene Fehler erstellen“?

errors.New, fmt.Errorf und Sentinel-Fehler Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Eigene Fehler erstellen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy