Wie gehen Sie mit Fehlern mit Go um?

Wie gehen Sie mit Fehlern mit Go um?

In GO wird die Fehlerbehandlung hauptsächlich mit dem error verwaltet, der eine Schnittstelle ist, die im builtin Paket wie folgt definiert ist:

 <code class="go">type error interface { Error() string }</code>

Jeder Typ, der diese Schnittstelle implementiert, kann als Fehler betrachtet werden. GOs Ansatz zur Fehlerbehandlung ist explizit und ermutigt Entwickler, Fehler unmittelbar nach ihrer Auftreten zu überprüfen und zu behandeln. Das gemeinsame Muster für den Umgang mit Fehlern in GO besteht darin, den Fehlerrückgabewert nach Funktionsaufrufen zu überprüfen und zu entscheiden, was zu tun ist, basierend darauf, ob ein Fehler aufgetreten ist. Hier ist ein einfaches Beispiel:

 <code class="go">result, err := someFunction() if err != nil { // Handle the error fmt.Println("An error occurred:", err) return } // Use result safely</code>

In Go können Funktionen mehrere Werte zurückgeben, und es ist eine Konvention, einen Fehler als letzter Wert zurückzugeben. Beim Schreiben von Funktionen sollten Sie immer überlegen, welche Fehler auftreten können, und sie angemessen zurückgeben. Zum Beispiel:

 <code class="go">func divide(a, b int) (int, error) { if b == 0 { return 0, errors.New("division by zero") } return a / b, nil }</code>

Wenn Sie beim Aufrufen divide den Fehler wie folgt behandeln:

 <code class="go">quotient, err := divide(10, 2) if err != nil { log.Fatal(err) } fmt.Println(quotient) // Output: 5</code>

Was sind die Best Practices für die Fehlerbehandlung in Go?

Die effektive Fehlerbehandlung in GO beinhaltet mehrere Best Practices, um sicherzustellen, dass Ihr Code robust und wartbar ist:

1. Überprüfen Sie immer Fehler: Ignorieren Sie niemals Fehler. Überprüfen Sie sie immer und behandeln Sie sie angemessen, auch wenn es nur den Fehler anmeldet und die Ausführung fortsetzt.
2. Seien Sie spezifisch: Wenn Sie Fehler erstellen, sind Sie so spezifisch wie möglich. Dies erleichtert das Debuggen und Umgang mit bestimmten Fehlern.

3. Verwenden Sie Wraping: Go 1.13 Einführte Fehlerverpackung, mit der Sie einem Fehler Kontext hinzufügen können, ohne den ursprünglichen Fehler zu verlieren. Verwenden Sie fmt.Errorf mit dem %w -Verb, um Fehler zu wickeln.

    <code class="go">err := fmt.Errorf("failed to read file: %w", os.ErrNotExist)</code>

   Nach dem Login kopieren
4. Erstellen Sie benutzerdefinierte Fehlertypen: Definieren Sie bei Bedarf benutzerdefinierte Fehlertypen für komplexere Szenarien. Dies kann dazu beitragen, zwischen verschiedenen Arten von Fehlern zu unterscheiden und sie anders zu handhaben.

5. recover Sie aufgeschobene Funktionen.

    <code class="go">defer func() { if r := recover(); r != nil { fmt.Println("Recovered from panic:", r) } }()</code>

   Nach dem Login kopieren
6. Protokollierung: Verwenden Sie eine strukturierte Protokollierung, um Fehler mit zusätzlichem Kontext zu protokollieren. Dies hilft beim Debuggen und Überwachen.
7. Fehlerbehandlungsstrategien: Entscheiden Sie zu Beginn Ihres Projekts eine Fehlerbehandlungsstrategie. Werden Sie Operationen wiederholen, schnell versagen oder protokollieren und weitermachen? Die Konsistenz des Fehlers der Fehler über die Codebasis ist entscheidend.
8. Dokumentation: Dokumentieren Sie, wie Fehler in Ihrer API behandelt werden und welche Fehler durch Ihre Funktionen zurückgegeben werden können. Dies macht Ihren Code verständlicher und wartbarer.

Wie können Sie benutzerdefinierte Fehlertypen in Go erstellen?

Das Erstellen benutzerdefinierter Fehlertypen in GO kann nützlich sein, um eine detailliertere Fehlerbehandlung zu erhalten und zwischen verschiedenen Arten von Fehlern zu unterscheiden. So können Sie einen benutzerdefinierten Fehlertyp definieren:

1. Definieren Sie den Fehlertyp: Sie können einen benutzerdefinierten Fehlertyp definieren, indem Sie eine Struktur erstellen, die die error implementiert.

    <code class="go">type MyError struct { Code int Message string } func (e *MyError) Error() string { return fmt.Sprintf("Error %d: %s", e.Code, e.Message) }</code>

   Nach dem Login kopieren

2. Verwenden Sie den benutzerdefinierten Fehler: Nach der Definition können Sie Ihren benutzerdefinierten Fehlertyp in Ihren Funktionen verwenden.

    <code class="go">func doSomething() error { // Some operation fails return &MyError{Code: 404, Message: "Resource not found"} }</code>

   Nach dem Login kopieren

3. Überprüfen Sie den benutzerdefinierten Fehlertyp.

    <code class="go">err := doSomething() if err != nil { if e, ok := err.(*MyError); ok { fmt.Printf("Custom error: Code %d, Message %s\n", e.Code, e.Message) } else { fmt.Println("Unknown error:", err) } }</code>

   Nach dem Login kopieren

4. Fehler mit Fehler: Sie können Ihren benutzerdefinierten Fehler auch mit zusätzlichem Kontext mit fmt.Errorf und %w einwickeln.

    <code class="go">err := doSomething() if err != nil { return fmt.Errorf("operation failed: %w", err) }</code>

   Nach dem Login kopieren

Welche Tools oder Bibliotheken können bei der Fehlerbehandlung in Go helfen?

Mehrere Tools und Bibliotheken können dazu beitragen, die Fehlerbehandlung in Go zu verbessern:

1. PKG/Fehler: Das Paket github.com/pkg/errors bietet zusätzliche Fehlerbehandlungsfunktionen wie Stack -Spuren, die beim Debuggen sehr hilfreich sein können. Es unterstützt auch die Fehlerverpackung, die später in die Standardbibliothek aufgenommen wurde.

    <code class="go">err := errors.New("original error") wrappedErr := errors.Wrap(err, "additional context")</code>

   Nach dem Login kopieren

2. Uber-Go/Zap: Diese Protokollierungsbibliothek bietet eine strukturierte, schnelle und ebene Protokollierung. Es ist besonders nützlich, um Fehler mit zusätzlichem Kontext zu protokollieren.

    <code class="go">logger := zap.NewExample() defer logger.Sync() sugar := logger.Sugar() sugar.Infow("Failed to fetch URL.", "url", url, "attempt", 3, "backoff", time.Second, )</code>

   Nach dem Login kopieren

3. Go-Chi/CHI: Wenn Sie einen Webdienst erstellen, verfügt der Router github.com/go-chi/chi auf integrierte Middleware für Handhabungs- und Protokollierungsfehler auf standardisierte Weise.

    <code class="go">r := chi.NewRouter() r.Use(middleware.Recoverer) r.Get("/", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("hello world")) })</code>

   Nach dem Login kopieren

4. Errgroup: Aus dem Paket golang.org/x/sync/errgroup hilft errgroup.Group bei der Verwaltung von Goroutinen und deren Fehler auf zentralisierte Weise.

    <code class="go">g := new(errgroup.Group) g.Go(func() error { // do something return nil }) if err := g.Wait(); err != nil { log.Fatal(err) }</code>

   Nach dem Login kopieren

5. github.com/hashicorp/go-multierror: Mit diesem Paket können Sie mehrere Fehler zu einem einzigen Fehler kombinieren, was bei der Behandlung mehrerer Operationen nützlich sein kann, die möglicherweise fehlschlagen.

    <code class="go">var errs error errs = multierror.Append(errs, errors.New("first error")) errs = multierror.Append(errs, errors.New("second error")) if errs != nil { log.Fatal(errs) }</code>

   Nach dem Login kopieren

Die Verwendung dieser Tools und Bibliotheken kann Ihre Fehlerbehandlungsstrategie bei GO erheblich verbessern und Ihre Anwendungen robuster und einfacher zu debuggen und zu warten.

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