Gestion des erreurs

Gestion des erreurs

En programmation, il est essentiel de prévoir les erreurs potentielles qui peuvent survenir dans nos programmes. Par exemple, si tu développes une application où l’utilisateur peut télécharger un fichier, il se peut que ce fichier ait été supprimé pour une raison quelconque, ce qui entraînerait une erreur. Il est impératif de préparer cette éventualité. La gestion des erreurs permet de traiter toutes ces situations où quelque chose ne se passe pas comme prévu. Swift nous fournit un ensemble d’outils pour gérer ces cas.

  Types d’erreurs

Swift utilise des types conformant au protocole Error pour représenter les erreurs. Tu peux définir tes propres types d’erreurs en créant une énumération qui adopte le protocole Error.

enum FileError: Error {
    case fileNotFound
    case unreadable
    case encodingFailed
}

Le protocole Error est un protocole natif qui représente des types d’erreurs. Lorsqu’un type adopte ce protocole, il devient éligible pour être utilisé dans les mécanismes de gestion d’erreurs de Swift, tels que le try, catch, et throw. Ce protocole ne nécessite aucune méthode ou propriété particulière à implémenter, ce qui te permet d’être flexible dans ta définition des erreurs. 

  Propagation des erreurs

Simulons une situation où le fichier est introuvable 

func readFile(path: String) throws -> String {
    throw FileError.fileNotFound
}

On viens de créer une fonction readFile qui essaie de lire un fichier à un chemin donné. Si le fichier est introuvable, on lance une erreur en utilisant throw. Les fonctions et méthodes peuvent indiquer qu’elles peuvent lancer une erreur en ajoutant le mot-clé throws à leur déclaration. 

  Gestion des erreurs do try catch

Bloc do Le bloc do contient le code qui pourrait lancer une erreur. C’est ici que tu utilise try pour appeler les fonctions qui peuvent lancer des erreurs throws.

Mot-clé try Le mot-clé try est utilisé avant une expression qui peut lancer une erreur. Si une erreur est lancée, l’exécution passe immédiatement au bloc catch correspondant.

Bloc catch Le bloc catch capture et traite les erreurs lancées dans le bloc do. Tu peux avoir plusieurs blocs catch pour gérer différents types d’erreurs. Le dernier bloc catch sans condition capture toute erreur non spécifiquement traitée par les blocs catch précédents.

do {
    let content = try readFile(path: "/path/to/file")
    print(content)
} catch FileError.fileNotFound {
    print("Le fichier est introuvable.")
} catch {
    print("Une erreur inconnue s'est produite.")
}
}

Donc ici, on commence par le bloc do, qui va vérifier via le try s’il y a bien un fichier. S’il n’en trouve pas, alors on va gérer les erreurs potentielles. Par exemple, ici, s’il ne trouve pas le fichier (erreur FileError.fileNotFound), il exécute le premier bloc catch. Il peut évidemment y avoir plusieurs cas d’erreurs, donc plusieurs blocs catch.

 Optionnel

try?

if let fileContent = try? readFile(at: "path/to/file") {
    print(fileContent)
} else {
    print("Impossible de lire le fichier.")
}

Tu peux utiliser try? pour convertir une expression en une valeur optionnelle. Si une erreur est lancée, l’expression retourne nil.

try!

let fileContent = try! readFile(at: "path/to/file")
print(fileContent)

Tu peux également utiliser try! pour désactiver la propagation des erreurs et planter si une erreur est lancée. À utiliser avec prudence, car ca peut provoquer un crash de l’application.

 Propagation des erreurs dans les Initialiseurs

struct User {
    let name: String
    let age: Int
    
    init(name: String, age: Int) throws {
        guard age > 0 else {
            throw ValidationError.invalidAge
        }
        self.name = name
        self.age = age
    }
}

enum ValidationError: Error {
    case invalidAge
}

do {
    let user = try User(name: "Alan", age: -1)
} catch ValidationError.invalidAge {
    print("L'âge doit être supérieur à 0.")
}

Les initialiseurs peuvent également lancer des erreurs. C’est utile pour gérer les erreurs de validation lors de la création d’une instance.

 Les Closures qui lancent des erreurs

let throwingClosure: () throws -> Void = {
    throw FileError.unreadable
}

do {
    try throwingClosure()
} catch {
    print("Une erreur s'est produite dans la fermeture.")
}

Les closures peuvent également lancer des erreurs en ajoutant throws à leur type de retour.

Exercices Pratiques

Exo gestion des erreurs

Télécharger le playground

Accède aux consignes directement en téléchargeant le playground.

⚠️ Les consignes que tu trouveras dans le playground ne sont pas verrouillées. Fais attention à ne pas les effacer par inadvertance ! 

Objectif

La gestion des erreurs en Swift est essentielle pour écrire un code robuste et fiable. Elle te permet de gérer les situations où les choses ne se passent pas comme prévu, comme une donnée manquante ou une opération qui échoue. Avec les mécanismes de gestion des erreurs, comme do-catch, try, et throw, tu peux signaler, intercepter et traiter les erreurs de manière structurée. Swift te permet également de créer tes propres types d’erreurs pour répondre aux besoins spécifiques de ton application. En maîtrisant la gestion des erreurs, tu pourras écrire un code plus sûr, éviter les crashs imprévus et améliorer l’expérience utilisateur en anticipant les problèmes potentiels.

Note

Gérer les erreurs, c’est comme attacher sa ceinture en voiture, c’est contraignant, mais essentiel en cas de crash !

Exercices Pratiques

Exo gestion des erreurs

Télécharger le playground

Accède aux consignes directement en téléchargeant le playground.

⚠️ Les consignes que tu trouveras dans le playground ne sont pas verrouillées. Fais attention à ne pas les effacer par inadvertance ! 

Objectif

La gestion des erreurs en Swift est essentielle pour écrire un code robuste et fiable. Elle te permet de gérer les situations où les choses ne se passent pas comme prévu, comme une donnée manquante ou une opération qui échoue. Avec les mécanismes de gestion des erreurs, comme do-catch, try, et throw, tu peux signaler, intercepter et traiter les erreurs de manière structurée. Swift te permet également de créer tes propres types d’erreurs pour répondre aux besoins spécifiques de ton application. En maîtrisant la gestion des erreurs, tu pourras écrire un code plus sûr, éviter les crashs imprévus et améliorer l’expérience utilisateur en anticipant les problèmes potentiels.

Note

Gérer les erreurs, c’est comme attacher sa ceinture en voiture, c’est contraignant, mais essentiel en cas de crash !