Fehlerbehandlung

Das Problem: „Hat nicht geklappt“ reicht nicht

Aus den Lektionen 1.8 bis 1.10 kennst du Optionals als Antwort auf „hat nicht geklappt“. Int("abc") liefert nil. Das funktioniert gut, solange es nur einen Grund für ein Scheitern gibt.

Aber stell dir eine Registrierung vor. Ein Benutzername kann aus vielen Gründen ungültig sein:

• zu kurz
• schon vergeben
• enthält Leerzeichen

Gibt deine Prüffunktion nur nil zurück, weiß der Nutzer nicht, was er falsch gemacht hat. Und später, beim Laden aus dem Internet, gibt es noch mehr Gründe: kein Netz, Server nicht erreichbar, falsche Daten.

Du brauchst einen Weg, um nicht nur „hat nicht geklappt“ zu sagen, sondern warum. Dafür gibt es in Swift die Fehlerbehandlung.

Schritt 1: Fehler beschreiben

Zuerst legst du fest, welche Fehler es geben kann. Am besten eignet sich dafür ein Enum (Lektion 1.14), das das Protokoll Error erfüllt:

enum UsernameError: Error {
    case tooShort
    case containsSpaces
    case alreadyTaken
}

Error ist ein Protokoll ohne Anforderungen. Es markiert einen Typ nur als „Das ist ein Fehler“. Mehr ist nicht nötig.

Schritt 2: Fehler werfen

Eine Funktion, die scheitern kann, markierst du mit throws. Tritt ein Problem auf, wirfst du einen Fehler mit throw:

func validate(username: String) throws -> String {
    if username.count < 3 {
        throw UsernameError.tooShort
    }
    if username.contains(" ") {
        throw UsernameError.containsSpaces
    }
    if username.lowercased() == "admin" {
        throw UsernameError.alreadyTaken
    }
    return username
}

• throws steht nach den Parametern und vor dem Pfeil ->.
• throw beendet die Funktion sofort, ähnlich wie return, liefert aber einen Fehler statt eines Ergebnisses.

Statt if kannst du natürlich auch guard verwenden. Das ist hier sogar besonders elegant:

guard username.count >= 3 else {
    throw UsernameError.tooShort
}

Erinnerst du dich an die Fehlermeldung zu guard in Lektion 1.9? Dort hieß es „consider using a 'return' or 'throw'“. Jetzt weißt du, was throw ist.

Schritt 3: Fehler abfangen

Eine Funktion mit throws kannst du nicht einfach aufrufen:

let name = validate(username: "Al")

Swift zwingt dich, dich um mögliche Fehler zu kümmern, genau wie bei Optionals. Dafür gibt es do, try und catch:

do {
    let name = try validate(username: "Al")
    print("Willkommen, \(name)!")
} catch {
    print("Fehler: \(error)")
}
// Fehler: tooShort

So liest du das:

• do { ... }: „Versuch Folgendes.“
• try: markiert die Stelle, an der ein Fehler auftreten kann. Tritt einer auf, springt Swift sofort in den catch-Block. Die restlichen Zeilen im do-Block werden übersprungen.
• catch { ... }: „Falls es schiefgeht, mach das.“ Innerhalb von catch steht der Fehler automatisch in einer Konstante namens error.

Fehler einzeln behandeln

Willst du je nach Fehler anders reagieren, schreibst du mehrere catch-Blöcke:

do {
    let name = try validate(username: "anna maria")
    print("Willkommen, \(name)!")
} catch UsernameError.tooShort {
    print("Der Name muss mindestens 3 Zeichen haben.")
} catch UsernameError.containsSpaces {
    print("Bitte keine Leerzeichen verwenden.")
} catch UsernameError.alreadyTaken {
    print("Dieser Name ist leider schon vergeben.")
} catch {
    print("Unbekannter Fehler: \(error)")
}

Das letzte catch ohne Muster fängt alles ab, was vorher nicht gepasst hat. Swift verlangt es, weil eine throws-Funktion theoretisch jeden Fehlertyp werfen kann.

Verständliche Fehlermeldungen

tooShort ist für Entwickler verständlich, für Nutzer nicht. Mit einer berechneten Eigenschaft gibst du jedem Fehler einen lesbaren Text:

enum UsernameError: Error {
    case tooShort
    case containsSpaces
    case alreadyTaken

    var message: String {
        switch self {
        case .tooShort: "Der Name muss mindestens 3 Zeichen haben."
        case .containsSpaces: "Bitte keine Leerzeichen verwenden."
        case .alreadyTaken: "Dieser Name ist leider schon vergeben."
        }
    }
}

do {
    let name = try validate(username: "admin")
    print("Willkommen, \(name)!")
} catch let error as UsernameError {
    print(error.message)
} catch {
    print("Unbekannter Fehler.")
}
// Dieser Name ist leider schon vergeben.

catch let error as UsernameError heißt: „Fang alle Fehler vom Typ UsernameError und gib ihn mir als genau diesen Typ.“ Dann kannst du auf .message zugreifen.

Und Associated Values funktionieren natürlich auch. Ein Fehler kann so Zusatzinformationen mitbringen:

enum UsernameError: Error {
    case tooShort(minimum: Int)
}

throw UsernameError.tooShort(minimum: 3)

try?: Fehler in ein Optional verwandeln

Manchmal ist dir egal, warum etwas gescheitert ist. Dann gibt es eine Abkürzung:

let name = try? validate(username: "Al")
print(name)   // nil

try? wandelt das Ergebnis in ein Optional um: Klappt alles, bekommst du den Wert, sonst nil. Der Fehler selbst geht dabei verloren.

Das passt perfekt zu den Werkzeugen aus Lektion 1.9:

let displayName = (try? validate(username: input)) ?? "Gast"

if let name = try? validate(username: input) {
    print("Gültig: \(name)")
}

Fehler weiterreichen

Ruft eine Funktion eine andere throws-Funktion auf, muss sie den Fehler nicht selbst behandeln. Sie kann ihn auch weiterreichen, indem sie selbst throws ist:

func register(username: String) throws {
    let validName = try validate(username: username)
    print("\(validName) wurde registriert.")
}

Tritt in validate ein Fehler auf, beendet er auch register und landet beim Aufrufer von register. Irgendwo weiter oben muss ihn dann jemand mit do/catch abfangen.

So kannst du Fehler genau dort behandeln, wo es sinnvoll ist. In einer App ist das meist die Stelle, die dem Nutzer eine Meldung anzeigen kann.

Optional oder Fehler?

Typische Fehler

try vergessen

Setz try vor den Aufruf und schließ ihn in do/catch ein, oder verwende try?.

try ohne do

let name = try validate(username: "anna")

Ein try muss entweder in einem do-Block stehen oder in einer Funktion, die selbst throws ist.

throws vergessen

func validate(username: String) -> String {
    throw UsernameError.tooShort
}

Eine Funktion, die throw verwendet, muss mit throws markiert sein.

Fehlertyp erfüllt Error nicht

enum UsernameError {
    case tooShort
}
throw UsernameError.tooShort

Ergänze : Error beim Enum.

FAQ

Übungen

enum AgeError: Error {
    case negative
    case unrealistic
}

func checkAge(_ age: Int) throws {
    guard age >= 0 else { throw AgeError.negative }
    guard age <= 130 else { throw AgeError.unrealistic }
    print("\(age) ist ein gültiges Alter.")
}

for age in [25, -3, 200] {
    do {
        try checkAge(age)
    } catch {
        print("\(age): \(error)")
    }
}

enum ATMError: Error {
    case invalidAmount
    case insufficientFunds(missing: Double)
}

func withdraw(amount: Double, from balance: Double) throws -> Double {
    guard amount > 0 else {
        throw ATMError.invalidAmount
    }
    guard amount <= balance else {
        throw ATMError.insufficientFunds(missing: amount - balance)
    }
    return balance - amount
}

do {
    let newBalance = try withdraw(amount: 150, from: 100)
    print("Neuer Kontostand: \(newBalance)")
} catch ATMError.insufficientFunds(let missing) {
    print("Es fehlen \(missing) €.")
} catch ATMError.invalidAmount {
    print("Bitte einen positiven Betrag eingeben.")
} catch {
    print("Unbekannter Fehler.")
}
// Es fehlen 50.0 €.

enum FormError: Error {
    case invalidEmail
    case passwordTooShort

    var message: String {
        switch self {
        case .invalidEmail: "Bitte eine gültige E-Mail-Adresse eingeben."
        case .passwordTooShort: "Das Passwort braucht mindestens 8 Zeichen."
        }
    }
}

func validateEmail(_ email: String) throws {
    guard email.contains("@"), email.contains(".") else {
        throw FormError.invalidEmail
    }
}

func validatePassword(_ password: String) throws {
    guard password.count >= 8 else {
        throw FormError.passwordTooShort
    }
}

func validateForm(email: String, password: String) throws {
    try validateEmail(email)
    try validatePassword(password)
    print("Alles in Ordnung ✅")
}

do {
    try validateForm(email: "anna@example.com", password: "kurz")
} catch let error as FormError {
    print(error.message)
} catch {
    print("Unbekannter Fehler.")
}
// Das Passwort braucht mindestens 8 Zeichen.

Zusammenfassung

• Fehlertypen sind meist Enums, die das Protokoll Error erfüllen.
• throws markiert eine Funktion, die scheitern kann. throw wirft den Fehler.
• do { try ... } catch { ... } fängt Fehler ab. In catch heißt der Fehler error.
• Mehrere catch-Blöcke behandeln Fehler einzeln.
• try? macht aus dem Ergebnis ein Optional, der Grund geht verloren.
• Funktionen können Fehler weiterreichen, indem sie selbst throws sind.
• Ein Grund → Optional, mehrere Gründe → Fehler.

Spickzettel

enum LoginError: Error { case wrongPassword, noNetwork }

func login(_ pw: String) throws -> String {
    guard pw == "geheim" else { throw LoginError.wrongPassword }
    return "Token"
}

do {
    let token = try login("abc")
} catch LoginError.wrongPassword {
    ...
} catch {
    print(error)
}

let token = try? login("abc")   // Optional