Wie erkennt man Fehler in Swift?

In Swift werden Fehler mit einem Fehlerbehandlungssystem abgefangen, das auf der Verwendung der Schlüsselwörter throw, throws, try und des Blocks do-catch basiert.

1. Deklaration von Funktionen, die Fehler werfen können: Das Schlüsselwort throws wird nach den Parametern der Funktion verwendet.

   enum DataError: Error {
       case emptyData
       case invalidFormat
   }
   
   func processData(input: String) throws -> String {
       guard !input.isEmpty else {
           throw DataError.emptyData // Fehler werfen
       }
       // ...Datenverarbeitungslogik...
       if input == "invalid" {
            throw DataError.invalidFormat
       }
       return "Verarbeitet: \(input)"
   }
   

2. Aufruf von Funktionen, die Fehler werfen können: Das Schlüsselwort try wird verwendet.

   do { // Fehlerbehandlungsblock
       let result = try processData(input: "gültige Daten")
       print(result) // "Verarbeitet: gültige Daten"
   } catch { // Fehlerfangblock
       print("Ein Fehler ist aufgetreten: \(error)")
   }
   

3. Abfangen bestimmter Fehlertypen: Im catch-Block kann ein spezifischer Fehlertyp angegeben werden.

   do {
       let result = try processData(input: "")
       print(result)
   } catch DataError.emptyData {
       print("Daten sind leer, bitte Eingabe bereitstellen.")
   } catch DataError.invalidFormat {
       print("Datenformat ist ungültig.")
   } catch { // Alle anderen Fehler abfangen
       print("Unerwarteter Fehler: \(error)")
   }
   

4. defer-Block: Wird unmittelbar vor dem Verlassen des aktuellen Gültigkeitsbereichs ausgeführt, unabhängig davon, ob eine Ausnahme aufgetreten ist oder nicht. Wird häufig zum Freigeben von Ressourcen verwendet.

   func openFile(_ filename: String) throws -> String {
       // Angenommen, dies öffnet eine Datei und gibt ihren Inhalt zurück
       print("Datei \(filename) wird geöffnet")
       // ... Öffnungslogik ...
   
       defer {
           // Dieser Code wird vor dem Verlassen der Funktion ausgeführt,
           // auch wenn ein Fehler auftritt
           print("Datei \(filename) wird geschlossen")
       }
   
       // ... Dateiverarbeitung ...
       if filename == "error.txt" {
          throw DataError.invalidFormat // Fehler werfen
       }
   
       return "Dateiinhalt"
   }
   
   do {
       let content = try openFile("data.txt")
       print(content)
   } catch {
       print("Fehler beim Umgang mit der Datei: \(error)")
   }
   

5. Optionale try?: Gibt einen optionalen Wert zurück. Wenn die Funktion einen Fehler wirft, gibt try? nil zurück.

   let processedResult = try? processData(input: "") // processedResult ist nil
   let validResult = try? processData(input: "abc") // validResult ist ein optionaler String mit dem Wert "Processed: abc"
   

6. Erzwungenes try!: Wird verwendet, wenn man sicher ist, dass kein Fehler auftreten wird. Wenn doch, beendet die Anwendung abrupt.

   // Nur verwenden, wenn man zu 100% sicher ist, dass die Funktion keinen Fehler wirft
   let result = try! processData(input: "immer gültige Eingabe")
   

Das auf do-catch basierende System ist eine explizitere und sicherere Methode zur Fehlerbehandlung im Vergleich zu traditionellen Ausnahmen in anderen Sprachen, da es erfordert, Funktionen, die Fehler werfen können (throws), explizit zu deklarieren, und diese Fehler beim Aufruf (try, do-catch) explizit zu behandeln.