Wie behandelt Go Fehler als Werte?

Question

Accepted Answer

Go hat **keine Ausnahmen** für gewöhnliche Fehler. Stattdessen sind Fehler **Werte**, die von Funktionen zurückgegeben werden (typischerweise als letzter Rückgabewert), und Aufrufer **prüfen sie explizit**. Dies macht die Fehlerbehandlung sichtbar, absichtlich und unmöglich zu übersehen — eine definierende Go-Philosophie.

## Der Fehlertyp und das Kernmuster

```go
// `error` is a built-in interface: anything with an Error() string method
type error interface {
    Error() string
}

// functions return (result, error) — error is nil on success
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")   // create an error
    }
    return a / b, nil    // nil = no error
}

// the ubiquitous calling pattern
result, err := divide(10, 0)
if err != nil {              // CHECK the error explicitly
    fmt.Println("error:", err)
    return
}
fmt.Println(result)
```

Die Überprüfung `if err != nil { ... }` erscheint ständig in Go — jeder Vorgang, der fehlschlagen kann, wird von einer expliziten Fehlerprüfung gefolgt. Diese Ausführlichkeit ist absichtlich: Fehler sind immer sichtbar und werden an der Aufrufstelle behandelt.

## Fehler erstellen

```go
errors.New("something failed")                       // simple error
fmt.Errorf("failed to process %s: %w", name, err)    // formatted, with WRAPPING (%w)
```

## Fehler verpacken und untersuchen

```go
// %w WRAPS an underlying error, preserving the chain
if err != nil {
    return fmt.Errorf("reading config: %w", err)   // adds context, keeps original
}

// unwrap and inspect with errors.Is / errors.As
if errors.Is(err, os.ErrNotExist) { ... }          // check for a specific error
var pathErr *os.PathError
if errors.As(err, &pathErr) { ... }                 // extract a specific error type
```

Verpackung (`%w`) fügt Kontext hinzu, wenn Fehler sich nach oben ausbreiten, während `errors.Is`/`errors.As` es Ihnen ermöglichen, bestimmte zugrunde liegende Fehler zu prüfen oder zu extrahieren — die moderne Methode zur Behandlung von Fehlerketten.

## Benutzerdefinierte Fehlertypen

```go
type ValidationError struct {
    Field string
}
func (e *ValidationError) Error() string {           // implement the error interface
    return "invalid field: " + e.Field
}
return &ValidationError{Field: "email"}
```

## errors vs panic

```text
error (values) → EXPECTED, recoverable conditions (file missing, bad input) — the norm
panic          → UNEXPECTED, programmer errors / unrecoverable (nil deref, out of bounds)
→ Use errors for normal failure handling; reserve panic for truly exceptional cases.
```

## Warum es wichtig ist

Gos Fehler-als-Wert-Ansatz ist einer seiner am meisten definierenden und umstrittenen Merkmale und unterscheidet sich grundlegend von ausnahmebedingten Sprachen.

Durch die Rückgabe von Fehlern als Werte, die Aufrufer explizit prüfen müssen (`if err != nil`), macht Go die Fehlerbehandlung **sichtbar, lokal und unmöglich versehentlich zu ignorieren** — Sie sehen genau, wo jeder Fehler behandelt wird, was die Zuverlässigkeit auf Kosten der Ausführlichkeit verbessert.

Das Verständnis dieser Philosophie, das Muster `(result, error)`, Fehlerverpackung (`%w`) mit `errors.Is`/`errors.As` zum Hinzufügen von Kontext und Untersuchen von Ketten, benutzerdefinierte Fehlertypen und die Unterscheidung zwischen Fehlern (normal, wiederherstellbar) und panic (außergewöhnlich, Programmiererfehler) ist absolut essentiell — es durchdringt jedes Go-Programm und stellt eine grundlegende mentale Verschiebung für Entwickler dar, die aus ausnahmebedingten Sprachen kommen.

Es ist auch eines der häufigsten Go-Interview-Themen.