multierr für Go: Mehrere Fehler kombinieren und verarbeiten

In Go ist die Fehlerbehandlung ein expliziter und wesentlicher Bestandteil der Entwicklung. Allerdings tritt häufig die Situation auf, dass während der Ausführung einer Operation nicht nur ein, sondern mehrere Fehler gleichzeitig auftreten können. Zum Beispiel bei der Batch-Verarbeitung von Dateien, der Validierung komplexer Datenstrukturen oder der Ausführung paralleler Aufgaben. Das Standardpaket errors erlaubt nur die Arbeit mit einem Fehler auf einmal, was das Sammeln und Analysieren aller aufgetretenen Fehler erschwert.

Die Bibliothek multierr von Uber (ja, demselben Unternehmen, das zap und fx entwickelt hat) löst dieses Problem elegant und effizient. Sie bietet eine einfache API zum Kombinieren mehrerer unabhängiger Fehler zu einem einzigen zusammengesetzten (Composite) Fehler. Dadurch bleibt der Kontext aller Fehler erhalten, ohne dass Informationen verloren gehen, und sie können an einer Stelle verarbeitet werden. Im Gegensatz zur manuellen Erstellung von Error-Slices bietet multierr praktische Funktionen zum Kombinieren, Prüfen auf Fehler und Iterieren über sie.

Die grundlegende Philosophie der Bibliothek ist Einfachheit und Leistung. Sie erzeugt keine unnötigen Heap-Allokationen, wenn es nicht nötig ist, und minimiert den Overhead. multierr ist ideal für Fälle, in denen Sie Fehler aus verschiedenen Quellen (z. B. aus Goroutinen) sammeln und als einheitliches Ergebnis zurückgeben möchten, das dann mit dem standardmäßigen if err != nil auf Fehler überprüft werden kann.

Installation

Die Installation der Bibliothek erfolgt mit dem Standardbefehl go get. Stellen Sie sicher, dass Sie Go Version 1.13 oder höher installiert haben (für die Unterstützung von errors.Is und errors.As).

go get go.uber.org/multierr

Nach der Ausführung des Befehls wird die Bibliothek zu Ihrer go.mod-Datei hinzugefügt. Der Import erfolgt wie folgt:

import "go.uber.org/multierr"

Schnellstart: Minimalbeispiel

Betrachten wir den einfachsten Fall: Wir haben zwei Funktionen, die einen Fehler zurückgeben können. Wir möchten beide ausführen und, falls mindestens eine fehlschlägt, einen gemeinsamen Fehler zurückgeben.

package main

import (
    "errors"
    "fmt"
    "go.uber.org/multierr"
)

func doSomething() error {
    return errors.New("erster Fehler")
}

func doAnotherThing() error {
    return errors.New("zweiter Fehler")
}

func main() {
    var err error
    
    // Erste Operation ausführen
    err = multierr.Append(err, doSomething())
    // Zweite Operation ausführen
    err = multierr.Append(err, doAnotherThing())
    
    if err != nil {
        fmt.Println("Es sind Fehler aufgetreten:")
        // Alle Fehler, getrennt durch Zeilenumbruch, ausgeben
        for _, e := range multierr.Errors(err) {
            fmt.Println("-", e)
        }
    }
}

In diesem Beispiel fügt multierr.Append einen neuen Fehler zu einem bestehenden hinzu. Wenn err gleich nil ist, gibt die Funktion einfach den neuen Fehler zurück. Als Ergebnis erhalten wir einen einzigen zusammengesetzten Fehler, der mit multierr.Errors in seine Einzelteile zerlegt werden kann.

Wichtige Funktionen und Methoden

Die Bibliothek multierr bietet einen kleinen, aber sehr leistungsstarken Satz von Funktionen. Betrachten wir jede davon im Detail.

1. multierr.Append

Signatur: func Append(left error, right error) error

Beschreibung: Dies ist die Hauptfunktion zum Kombinieren von zwei Fehlern. Wenn beide Fehler nil sind, wird nil zurückgegeben. Wenn einer von ihnen nil ist, wird der andere zurückgegeben. Wenn beide nicht nil sind, werden sie zu einem einzigen zusammengesetzten Fehler kombiniert.

err1 := errors.New("Fehler 1")
err2 := e