Gestion des erreurs en Swift : try/catch et techniques avancées

Gestion des erreurs en Swift : try/catch et bien plus — niveau avancé

La gestion des erreurs est une partie essentielle de tout développement sérieux iOS/macOS. Swift fournit un système de gestion des erreurs puissant et expressif qui va bien au-delà du simple try/catch. Dans cet article, nous explorerons les techniques avancées : travail avec le protocole Error, énumérations d'erreurs, mots-clés throws, rethrows, ainsi que le type Result et les approches fonctionnelles. Ce contenu est destiné aux développeurs déjà familiarisés avec les bases de Swift.

1. Protocole Error et types d'erreurs personnalisés

À la base de la gestion des erreurs en Swift se trouve le protocole Error. Tout type conforme à ce protocole peut être lancé comme une erreur. Le plus souvent, on utilise des énumérations (enum) pour cela.

import Foundation

// Définir un type d'erreur personnalisé pour une requête réseauenum NetworkError: Error {    case invalidURL    case noData    case decodingFailed(description: String)    case serverError(statusCode: Int)}

// Fonction qui peut lancer une erreurfunc fetchUserData(from urlString: String) throws -> Data {    guard let url = URL(string: urlString) else {        throw NetworkError.invalidURL    }

    // Simulation d'une requête réseau    let success = Bool.random()    if !success {        throw NetworkError.serverError(statusCode: 500)    }

    return Data()}

L'utilisation d'énumérations permet de regrouper les erreurs connexes et de transmettre des informations supplémentaires (associated values), rendant le code plus lisible et auto-documenté.

2. Utilisation avancée de do-catch

Le bloc do-catch est l'outil principal pour intercepter les erreurs. À un niveau avancé, il est important de savoir traiter différents types d'erreurs de manière différente.

func processUserData() {    do {        let data = try fetchUserData(from: "https://api.example.com/user")        // Travailler avec les données        print("Données reçues : \\(data.count) octets")    } catch NetworkError.invalidURL {        print("Erreur : URL invalide")    } catch NetworkError.serverError(let code) where code >= 500 {        print("Erreur serveur avec le code \\(code). Réessayez plus tard.")    } catch let error as NetworkError {        print("Erreur réseau : \\(error)")    } catch {        // Gestion de toutes les autres erreurs        print("Erreur inconnue : \\(error.localizedDescription)")    }}

Points clés :

• Pattern matching avec where : permet de filtrer les erreurs selon des conditions supplémentaires (par exemple, une plage de codes de réponse).
• Conversion de type (as) : si vous attendez plusieurs types d'erreurs, vous pouvez utiliser catch let error as MyErrorType.
• catch universel : doit toujours être le dernier, car il intercepte toute erreur non traitée.

3. Mots-clés throws, rethrows et propagation des erreurs

Le mot-clé throws indique qu'une fonction peut lancer une erreur. rethrows est un mécanisme plus subtil : il indique qu'une fonction peut lancer une erreur uniquement si l'un de ses paramètres de fermeture (closure) a lancé une erreur.

// Fonction avec throws — peut lancer une erreur elle-mêmefunc loadConfig() throws -> [String: String] {    // ...    throw NetworkError.noData}

// Fonction avec rethrows — transmet l'erreur de la fermeturefunc performWithRetry(times: Int, operation: () throws -> Void) rethrows {    for _ in 0..<times {        try operation()    }}

// Utilisationdo {    try performWithRetry(times: 3) {        try loadConfig()    }} catch {    print("L'opération a échoué après 3 tentatives : \\(erro")