Grundlagen der Fehlerbehandlung

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

Grundlegende Fehlerbehandlung ist ein grundlegendes Muster in Go, bei dem man nach Operationen, die fehlschlagen könnten, auf Fehler prüft.

Lernen wir, wie man Fehler in Go behandelt, indem wir eine einfache Divisionsfunktion erstellen, die einen Fehler zurückgibt, wenn durch Null geteilt wird:

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

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

Sehen wir uns nun an, wie man diese Funktion verwendet und mögliche Fehler behandelt:

result, err := divide(10, 0)
    
if err != nil {
    fmt.Println("Error occurred:", err)
    return // Ausführung stoppen oder den Fehler behandeln
}
    
fmt.Println("Result:", result)

Nach der Ausführung dieses Codes prüfen wir mithilfe der Bedingung if err != nil, ob ein Fehler aufgetreten ist. Da wir versucht haben, durch Null zu teilen, gibt die Funktion einen Fehler zurück, und Folgendes wird auf dem Bildschirm angezeigt:

Error occurred: division by zero

Dieses Muster, einen Fehler als letzten Rückgabewert zurückzugeben und ihn sofort zu prüfen, ist in Go sehr verbreitet. Es ermöglicht Ihrem Programm, Fehler kontrolliert zu behandeln, anstatt abzustürzen.

Aufgabe

Einfach

In dieser Herausforderung wirst du die grundlegende Fehlerbehandlung in Go üben. Du hast eine Funktion, die zwei Zahlen dividiert, aber eine Division durch Null verursacht einen Laufzeitfehler. Deine Aufgabe ist es, eine Fehlerbehandlung hinzuzufügen, um diesen Absturz zu verhindern.

Der Code verfügt bereits über eine Funktion, die sowohl ein Ergebnis als auch einen Fehler zurückgibt. Du musst prüfen, ob ein Fehler vorliegt, bevor du das Ergebnis verwendest.

Spickzettel

In Go geben Funktionen, die fehlschlagen könnten, einen Fehler als letzten Rückgabewert zurück:

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

Prüfen Sie auf Fehler mit if err != nil:

result, err := divide(10, 0)
    
if err != nil {
    fmt.Println("Error occurred:", err)
    return // Ausführung stoppen oder den Fehler behandeln
}
    
fmt.Println("Result:", result)

Dieses Muster ermöglicht es Programmen, Fehler kontrolliert zu behandeln, anstatt abzustürzen.

Probier es selbst

package main

import (
	"errors"
	"fmt"
)

// Diese Funktion teilt x durch y und gibt einen Fehler zurück, wenn y Null ist
func divide(x, y float64) (float64, error) {
	if y == 0 {
		return 0, errors.New("cannot divide by zero")
	}
	return x / y, nil
}

func main() {
	// Testwerte
	numerator := 10.0
	denominator := 0.0
	
	// Rufe die divide-Funktion auf
	result, err := divide(numerator, denominator)
	
	// TODO: Überprüfen, ob err nicht nil ist (es liegt ein Fehler vor)
	// Wenn ein Fehler vorliegt, gib ihn mit fmt.Println(err) aus
	// Andernfalls gib das Ergebnis mit fmt.Printf("Result: %.2f\n", result) aus
	
	// Entferne diese Zeile und implementiere oben eine ordnungsgemäße Fehlerbehandlung
	fmt.Printf("Result: %.2f\n", result)
}