Come rilevare gli errori in Swift?

In Swift, gli errori vengono catturati tramite un sistema di gestione degli errori basato sull'uso delle parole chiave throw, throws, try e del blocco do-catch.

Dichiarazione di funzioni che possono generare errori: Si utilizza la parola chiave throws dopo i parametri della funzione.

enum DataError: Error {
    case emptyData
    case invalidFormat
}

func processData(input: String) throws -> String {
    guard !input.isEmpty else {
        throw DataError.emptyData // Genera errore
    }
    // ...logica di elaborazione dati...
    if input == "invalid" {
         throw DataError.invalidFormat
    }
    return "Processato: \(input)"
}

Chiamata di funzioni che possono generare errori: Si utilizza la parola chiave try.

do { // Blocco di gestione degli errori
    let result = try processData(input: "dati validi")
    print(result) // "Processato: dati validi"
} catch { // Blocco di cattura degli errori
    print("Si è verificato un errore: \(error)")
}

Cattura di tipi specifici di errori: Nel blocco catch si può indicare un tipo di errore specifico da catturare.

do {
    let result = try processData(input: "")
    print(result)
} catch DataError.emptyData {
    print("I dati sono vuoti, si prega di fornire un input.")
} catch DataError.invalidFormat {
    print("Il formato dei dati non è valido.")
} catch { // Cattura qualsiasi altro errore
    print("Si è verificato un errore imprevisto: \(error)")
}

Blocco defer: Viene eseguito immediatamente prima di uscire dall'ambito corrente, indipendentemente dal fatto che si sia verificato un errore o meno. Spesso usato per liberare risorse.

func openFile(_ filename: String) throws -> String {
    // Supponiamo che apra un file e ne ritorni il contenuto
    print("Apertura del file \(filename)")
    // ... logica di apertura ...

    defer {
        // Questo codice verrà eseguito prima di uscire dalla funzione,
        // anche se si verifica un errore
        print("Chiusura del file \(filename)")
    }

    // ... elaborazione del file ...
    if filename == "error.txt" {
       throw DataError.invalidFormat // Genera errore
    }

    return "Contenuto del file"
}

do {
    let content = try openFile("data.txt")
    print(content)
} catch {
    print("Errore nella gestione del file: \(error)")
}

try? opzionale: Restituisce un valore opzionale. Se la funzione genera un errore, try? restituisce nil.

let processedResult = try? processData(input: "") // processedResult sarà nil
let validResult = try? processData(input: "abc") // validResult sarà una String opzionale con il valore "Processed: abc"

try! forzato: Si utilizza quando si è sicuri che l'errore non si verificherà. Se si verifica, l'applicazione terminerà in modo anomalo. Usare con cautela.
```
// Usare solo se si è certi al 100% che la funzione non genererà errore
let result = try! processData(input: "sempre input valido")
```

Il sistema basato su do-catch è un modo più esplicito e sicuro di gestire gli errori rispetto alle eccezioni tradizionali in altri linguaggi, poiché richiede di dichiarare esplicitamente le funzioni che possono generare errori (throws) e di gestire esplicitamente tali errori durante la chiamata (try, do-catch).