Das Konzept von Fehlern

Teil des Abschnitts Grundlagen der GO-Journey von Coddy — Lektion 102 von 109.

In Go sind Fehler Werte, die darauf hinweisen, dass etwas schiefgelaufen ist. Go behandelt Fehler explizit, anstatt Exceptions zu verwenden.

Erstellen wir eine Funktion, die beim Dividieren von Zahlen einen Fehler erzeugen könnte:

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}

Diese Funktion gibt zwei Werte zurück: das Ergebnis der Division und einen potenziellen Fehler. Wenn der Divisor Null ist, geben wir eine Fehlermeldung zurück, anstatt die Division zu versuchen.

Nun verwenden wir unsere Funktion und behandeln mögliche Fehler:

result, err := divide(10, 0)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

Nach der Ausführung dieses Codes wird eine Fehlermeldung auf dem Bildschirm angezeigt, da wir versucht haben, durch Null zu teilen:

Error: cannot divide by zero

Dies demonstriert das Fehlerbehandlungsmuster von Go: prüfen Sie, ob ein Fehler aufgetreten ist (err != nil), und ergreifen Sie dann entsprechende Maßnahmen. Wenn kein Fehler aufgetreten ist, können wir das Ergebnis sicher verwenden.

Aufgabe

Einfach

In dieser Challenge üben Sie den Umgang mit Fehlern in Go. Sie erstellen eine Funktion, die zwei Zahlen dividiert und einen Fehler zurückgibt, wenn eine Division durch Null versucht wird.

Ihre Aufgabe ist es:

Vervollständigen Sie die divide-Funktion, die zwei Ganzzahlen entgegennimmt und deren Quotienten sowie einen Fehler zurückgibt.
Wenn der Divisor Null ist, geben Sie 0 und einen Fehler mit der Nachricht "division by zero" zurück.
Wenn die Division gültig ist, geben Sie das Ergebnis und nil für den Fehler zurück.
In der main-Funktion rufen Sie divide mit den bereitgestellten Werten auf und behandeln Sie etwaige Fehler angemessen.

Diese Übung zeigt, wie Go-Funktionen üblicherweise ein Ergebnis und einen Fehler zurückgeben und wie man diese Fehler prüft und behandelt.

Spickzettel

In Go sind Errors (Fehler) Werte, die anzeigen, dass etwas schiefgelaufen ist. Go behandelt Fehler explizit, anstatt Exceptions zu verwenden.

Funktionen, die fehlschlagen könnten, geben zwei Werte zurück: das Ergebnis und einen potenziellen Fehler:

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}

Um Fehler zu behandeln, prüfen Sie, ob der Fehler nicht nil ist:

result, err := divide(10, 0)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

Verwenden Sie errors.New(), um neue Fehlermeldungen zu erstellen, und geben Sie nil zurück, wenn kein Fehler auftritt.

Probier es selbst

package main
import (
    "errors"
    "fmt"
)
// divide teilt a durch b und gibt das Ergebnis zurück
// Wenn b 0 ist, wird ein Fehler zurückgegeben
func divide(a, b int) (int, error) {
    // TODO: Implementiere die divide-Funktion
    // Wenn b 0 ist, gib 0 und einen Fehler mit der Nachricht "division by zero" zurück
    // Andernfalls gib a/b und nil für den Fehler zurück

}
func main() {
    // Erster Testfall
    a, b := 10, 2
    result, err := divide(a, b)
    if err != nil {
        fmt.Printf("Error: %s\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }

    // Zweiter Testfall
    a, b = 8, 0
    result, err = divide(a, b)
    if err != nil {
        fmt.Printf("Error: %s\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }
}