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 Aufgabe übst du den Umgang mit Fehlern in Go. Du erstellst eine Funktion, die zwei Zahlen dividiert und einen Fehler zurückgibt, wenn eine Division durch null versucht wird.

Deine Aufgabe ist es:

Die Funktion divide zu vervollständigen, die zwei Ganzzahlen entgegennimmt und ihren Quotienten sowie einen Fehler zurückgibt.
Wenn der Divisor null ist, 0 und einen Fehler mit der Meldung "division by zero" zurückzugeben.
Wenn die Division gültig ist, das Ergebnis und nil für den Fehler zurückzugeben.
In der Funktion main divide mit den bereitgestellten Werten aufzurufen und alle Fehler angemessen zu behandeln.

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

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)
    }
}