Menu

Tech

Deutsch

Einfache Fehler erstellen

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

In Go können Sie benutzerdefinierte Fehler mit der errors.New() Funktion aus der Standardbibliothek erstellen.

Importieren Sie das errors-Paket:

import (
    "errors"
    "fmt"
)

Erstellen Sie einen einfachen Fehler mit einer Fehlermeldung:

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

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

Die Ausgabe lautet:

Error: cannot divide by zero

Aufgabe

Anfänger

In dieser Challenge üben Sie das Erstellen eines einfachen Fehlers in Go mit der Funktion errors.New().

Sie haben eine Funktion, die prüft, ob ein Benutzername gültig ist. Ein Benutzername gilt als gültig, wenn er mindestens 5 Zeichen lang ist. Ihre Aufgabe ist es, die Funktion zu vervollständigen, indem Sie einen entsprechenden Fehler zurückgeben, wenn der Benutzername zu kurz ist.

Spickzettel

Erstellen Sie benutzerdefinierte Fehler mit errors.New() aus der Standardbibliothek:

import (
    "errors"
    "fmt"
)

Geben Sie einen Fehler aus einer Funktion zurück:

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

Behandeln Sie den Fehler:

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

Probier es selbst

package main

import (
	"errors"
	"fmt"
)

func main() {
	// Test mit einem gültigen Benutzernamen
	result, err := validateUsername("gopher123")
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println(result)
	}

	// Test mit einem ungültigen Benutzernamen
	result, err = validateUsername("go")
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println(result)
	}
}

func validateUsername(username string) (string, error) {
	if len(username) < 5 {
		// TODO: Gib einen Fehler mit der Nachricht "username must be at least 5 characters long" zurück
		// Hinweis: Verwende errors.New(), um einen neuen Fehler zu erstellen
		return "", nil // Ersetze diese Zeile
	}
	return "Username is valid", nil
}

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Grundlagen

1Einführung in Go

Was ist Go?Hello World Println Go-Kommentare

4Vergleichs- & logische Operatoren

Vergleichsoperatoren - Teil 1 Vergleichsoperatoren - Teil 2 Logischer UND-Operator Logischer ODER-Operator Logischer NICHT-Operator Grundlagen der Operatorrangfolge Zusammenfassung - Vergleiche anstellen

7Kontrollfluss: Schleifen

Die `for`-Schleife erklärt for-Schleife - Grundlagen for-Schleife - Nur Bedingung Das `break`-Schlüsselwort Das `continue`-Schlüsselwort Verschachtelte Schleifen Zusammenfassung - Aktionen wiederholen

10Zusammengesetzte Typen: Arrays

Einführung in Arrays Deklarieren von Arrays Initialisieren von Arrays Zugriff auf Array-Elemente Array-Länge mit `len`Iterieren über Arrays Mehrdimensionale Arrays

13Zusammengesetzte Typen: Structs

Benutzerdefinierte Typen definieren Struct-Instanzen erstellen Zugriff auf Struct-Felder Pointer auf Structs Structs initialisieren Eingebettete Structs Anonyme Structs Zusammenfassung – Benutzerdefinierte Datenstrukturen

2Variablen und grundlegende Datentypen

Was ist eine Variable Typinferenz mit `:=`Ganzzahlen (int)Gleitkommazahlen Boolesche Werte Strings Zero Values Konstanten Namenskonventionen Zusammenfassung - Variablen und Typen

5Grundlagen der Ein- und Ausgabe

Formatierte Ausgabe Format-Verben Typen ausgeben Einfache Benutzereingaben erhalten Zusammenfassung – Ein- und Ausgabe

8Funktionen

Funktionen verstehen Eine Funktion deklarieren Funktionen aufrufen Funktionsparameter Einen einzelnen Wert zurückgeben Mehrere Werte zurückgeben Benannte Rückgabewerte Grundlagen des Funktions-Scopes Zusammenfassung – Wiederverwendbaren Code erstellen

11Zusammengesetzte Typen: Slices

Einführung in Slices Deklaration von Slice-Literalen Slices mit `make` erstellen Slice-Länge vs. Kapazität Zugriff auf Slice-Elemente Elemente anhängen Slicing von bestehenden Slices/Arrays Iterieren über Slices Kopieren von Slices Zusammenfassung – Dynamische Listen

14Grundlagen der Fehlerbehandlung

Das Konzept von Fehlern Das `error`-Interface Funktionen, die Fehler zurückgeben Fehler prüfenEinfache Fehler erstellenFormatierte Fehler erstellen Grundlagen der Fehlerbehandlung Zusammenfassung – Probleme behandeln

3Grundlegende Operatoren

Arithmetische Operatoren Divisionsoperator Der Modulo-Operator Zuweisungsoperator Kombinierte Zuweisungsoperatoren Inkrement und Dekrement Zusammenfassung - Berechnungen

6Kontrollfluss: Bedingte Anweisungen

Die `if`-Anweisung Das `else`-Schlüsselwort Das `else if`-Schlüsselwort Variable Shadowing in `if`Variablen initialisieren Die `switch`-Anweisung Switch mit Ausdrücken Switch ohne Ausdruck Das `fallthrough`-Schlüsselwort Zusammenfassung – Entscheidungen treffen

9Zeiger

Was ist ein Zeiger?Deklarieren von Zeigervariablen Der Adressoperator Dereferenzieren von Zeigern Verwendung von Zeigern in Funktionen Nil-Zeiger Zusammenfassung – Zeiger verstehen

12Zusammengesetzte Typen: Maps

Einführung in Maps Deklarieren von Map-Literalen Erstellen von Maps mit `make`Hinzufügen und Aktualisieren von Key-Value-Paaren Zugriff auf Map-Werte Überprüfen der Existenz von Schlüsseln Löschen von Map-Einträgen Map-Länge Iterieren über Maps Zusammenfassung – Key-Value-Speicher