Comment détecter les erreurs en Swift?

En Swift, les erreurs sont capturées à l'aide d'un système de gestion des erreurs basé sur l'utilisation des mots-clés throw, throws, try et du bloc do-catch.

Déclaration de fonctions pouvant lancer des erreurs : Utilisez le mot-clé throws après les paramètres de la fonction.

enum DataError: Error {
    case emptyData
    case invalidFormat
}

func processData(input: String) throws -> String {
    guard !input.isEmpty else {
        throw DataError.emptyData // Lancer une erreur
    }
    // ...logique de traitement des données...
    if input == "invalid" {
         throw DataError.invalidFormat
    }
    return "Traité : \(input)"
}

Appel de fonctions pouvant lancer des erreurs : Utilisez le mot-clé try.

do { // Bloc pour gérer les erreurs
    let result = try processData(input: "données valides")
    print(result) // "Traité : données valides"
} catch { // Bloc pour capturer les erreurs
    print("Une erreur est survenue : \(error)")
}

Capture de types spécifiques d'erreurs : Dans le bloc catch, vous pouvez indiquer un type d'erreur précis à capturer.

do {
    let result = try processData(input: "")
    print(result)
} catch DataError.emptyData {
    print("Les données sont vides, veuillez fournir une entrée.")
} catch DataError.invalidFormat {
    print("Le format des données est invalide.")
} catch { // Capture toutes autres erreurs
    print("Une erreur inattendue est survenue : \(error)")
}

Bloc defer : S'exécute juste avant de sortir du contexte actuel, indépendamment du fait qu'une erreur se soit produite ou non. Souvent utilisé pour libérer des ressources.

func openFile(_ filename: String) throws -> String {
    // Supposons que cela ouvre un fichier et retourne son contenu
    print("Ouverture du fichier \(filename)")
    // ... logique d'ouverture ...

    defer {
        // Ce code s'exécutera avant de sortir de la fonction,
        // même si une erreur se produit
        print("Fermeture du fichier \(filename)")
    }

    // ... traitement du fichier ...
    if filename == "error.txt" {
       throw DataError.invalidFormat // Lancer une erreur
    }

    return "Contenu du fichier"
}

do {
    let content = try openFile("data.txt")
    print(content)
} catch {
    print("Erreur lors de la gestion du fichier : \(error)")
}

try? optionnel : Renvoie une valeur optionnelle. Si la fonction lance une erreur, try? retourne nil.

let processedResult = try? processData(input: "") // processedResult sera nil
let validResult = try? processData(input: "abc") // validResult sera une String optionnelle avec la valeur "Traité : abc"

try! forcé : Utilisé lorsque vous êtes sûr qu'aucune erreur ne se produira. Si une erreur se produit, l'application se terminera brutalement. Utilisez avec précaution.
```
// Utilisez uniquement si vous êtes sûr à 100% que la fonction ne lancera pas d'erreur
let result = try! processData(input: "entrée toujours valide")
```

Le système basé sur do-catch est une manière plus explicite et sûre de gérer les erreurs par rapport aux exceptions traditionnelles dans d'autres langages, car il nécessite de déclarer explicitement les fonctions pouvant lancer des erreurs (throws) et de gérer ces erreurs de manière explicite lors de leur appel (try, do-catch).