Grundlegende 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 zeroDieses 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
EinfachIn 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.
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)
}
Teste dich selbstDiese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.
Alle Lektionen in Grundlagen
4Vergleichs- und logische Operatoren
Vergleichsoperatoren – Teil 1Vergleichsoperatoren – Teil 2Logischer UND-OperatorLogischer ODER-OperatorLogischer NICHT-OperatorGrundlagen der OperatorrangfolgeZusammenfassung – Vergleiche durchführen7Kontrollfluss: Schleifen
Die `for`-Schleife erklärt`for`-Schleife – Grundlagen`for`-Schleife – nur BedingungDas Schlüsselwort `break`Das Schlüsselwort `continue`Verschachtelte SchleifenWiederholung – Aktionen wiederholen2Variablen und grundlegende Datentypen
Was ist eine VariableTypinferenz mit `:=`Ganzzahlen (int)GleitkommazahlenBoolesche WerteZeichenkettenNullwerteKonstantenNamenskonventionenRückblick – Variablen und Typen5Grundlegende Ein- und Ausgabe
Formatierte AusgabeFormatierungsverbenDatentypen ausgebenGrundlegende Benutzereingaben erhaltenRückblick – Ein- und Ausgabe8Funktionen
Funktionen verstehenEine Funktion deklarierenFunktionen aufrufenFunktionsparameterEinen einzelnen Wert zurückgebenMehrere Werte zurückgebenBenannte RückgabewerteGrundlagen des FunktionsumfangsRückblick – Wiederverwendbaren Code erstellen11Zusammengesetzte Datentypen: Slices
Einführung in SlicesSlice-Literale deklarierenSlices mit `make` erstellenSlice-Länge vs. KapazitätAuf Slice-Elemente zugreifenElemente anhängenVorhandene Slices/Arrays aufteilenÜber Slices iterierenSlices kopierenRückblick – Dynamische Listen14Grundlegende Fehlerbehandlung
Das Konzept von FehlernDas `error`-InterfaceFunktionen, die Fehler zurückgebenAuf Fehler prüfenEinfache Fehler erstellenFormatierte Fehler erstellenGrundlegende FehlerbehandlungZusammenfassung – Probleme behandeln3Grundlegende Operatoren
Arithmetische OperatorenDivisionsoperatorDer Modulo-OperatorZuweisungsoperatorErweiterte ZuweisungsoperatorenInkrement und DekrementRückblick – Berechnungen6Kontrollfluss: Bedingungen
Die `if`-AnweisungDas `else`-SchlüsselwortDas `else if`-SchlüsselwortVariablen-Shadowing in `if`Variablen initialisierenDie `switch`-AnweisungSwitch mit AusdrückenSwitch ohne AusdruckDas `fallthrough`-SchlüsselwortZusammenfassung – Entscheidungen treffen9Zeiger
Was ist ein Zeiger?Zeigervariablen deklarierenDer AdressoperatorZeiger dereferenzierenZeiger in Funktionen verwendenNil-ZeigerRückblick – Zeiger verstehen12Zusammengesetzte Datentypen: Maps
Einführung in MapsMap-Literale deklarierenMaps mit `make` erstellenSchlüssel-Wert-Paare hinzufügen und aktualisierenAuf Map-Werte zugreifenDas Vorhandensein eines Schlüssels prüfenMap-Einträge löschenLänge von MapsMaps durchlaufenZusammenfassung – Schlüssel-Wert-SpeicherungÜbe selbstständig: Online-Go-Compiler