Le langage Swift
Partie 4 sur 5
8Les erreurs
Une fonction qui peut échouer est marquée throws ; l’appel doit alors être précédé de try, ce qui rend visible, à la lecture, chaque endroit où une erreur peut survenir. Les erreurs sont attrapées avec do et catch (voir les exceptions) :
enum ErreurCompte: Error {
case montantInvalide
case soldeInsuffisant(manque: Double)
}
func retirer(_ montant: Double, de solde: Double) throws -> Double {
guard montant > 0 else { throw ErreurCompte.montantInvalide }
guard montant <= solde else {
throw ErreurCompte.soldeInsuffisant(manque: montant - solde)
}
return solde - montant
}
do {
let reste = try retirer(80, de: 50)
print(reste)
} catch ErreurCompte.soldeInsuffisant(let manque) {
print("Il manque \(manque) euros")
} catch {
print("Erreur : \(error)")
}
Depuis Swift 6, une fonction peut préciser le type exact des erreurs qu’elle lève, ce qui permet au compilateur de vérifier qu’elles sont toutes traitées. Les variantes try?, qui transforme l’erreur en nil, et try!, qui arrête le programme en cas d’erreur, sont à manier avec la même prudence que le déballage forcé.
9La programmation concurrente
9.1async et await
Comme Kotlin avec ses coroutines, Swift permet depuis 2021 d’écrire les attentes, réseau, disque, calculs longs, comme du code séquentiel. Une fonction marquée async peut se suspendre à chaque await, sans bloquer l’interface :
func chargerMeteo(ville: String) async throws -> Meteo {
let url = URL(string: "https://api.example.org/meteo?ville=\(ville)")!
let (donnees, _) = try await URLSession.shared.data(from: url)
return try JSONDecoder().decode(Meteo.self, from: donnees)
}
async let paris = chargerMeteo(ville: "Paris") // en parallèle
async let lyon = chargerMeteo(ville: "Lyon")
let (p, l) = try await (paris, lyon)
Avec async let, les deux chargements démarrent en même temps ; le programme attend les deux résultats à la dernière ligne. Comme en Kotlin, les tâches sont organisées de façon structurée : l’annulation d’une tâche se propage à ses sous-tâches. Dans un vrai programme, le nom de la ville serait encodé avant d’être placé dans l’adresse, et le point d’exclamation de la première ligne remplacé par un traitement d’erreur.
9.2Les acteurs et Swift 6
Pour protéger les données partagées, Swift propose les acteurs (actor) : des objets dont l’état ne peut être modifié que par une tâche à la fois, le langage se chargeant de mettre les demandes en file d’attente. Le type Sendable indique les valeurs qui peuvent passer sans danger d’une tâche à l’autre.
actor Compteur {
private var valeur = 0
func incrementer() -> Int {
valeur += 1
return valeur
}
}
let c = Compteur()
let n = await c.incrementer() // accès sérialisé par l'acteur
Depuis Swift 6, en 2024, le mode de langage par défaut vérifie à la compilation que les données partagées entre tâches sont protégées : les courses de données deviennent des erreurs de compilation, comme en Rust (voir Rust). La transition a été laborieuse pour beaucoup de projets existants, qui ont dû signaler explicitement leurs données partagées ; Swift 6.2, en 2025, a rendu ces règles plus accessibles, en permettant de considérer par défaut, comme le font les nouveaux projets de Xcode, que le code d’une application s’exécute sur le fil principal, sauf indication contraire.
10SwiftUI
Pendant des années, les écrans des applications Apple étaient construits avec des cadriciels hérités de l’Objective-C, UIKit pour l’iPhone et AppKit pour le Mac, en manipulant directement chaque élément. En 2019, Apple présente SwiftUI, un cadriciel déclaratif : on décrit ce que l’écran doit afficher en fonction des données, et SwiftUI se charge de le mettre à jour quand elles changent (figure 3). Un même code s’adapte à l’iPhone, à l’iPad, au Mac, à la montre et au casque.
Dans cet exemple, la propriété clics est marquée @State : elle constitue l’état de l’écran. Le bouton l’augmente de 1 ; SwiftUI recalcule alors la description de l’écran et met à jour le texte, sans que le programmeur ait à le faire. Cette approche, partagée avec Jetpack Compose sur Android et React sur le Web, réduit fortement les erreurs d’affichage incohérent (voir Kotlin et les cadriciels Web). UIKit reste toutefois très présent dans les applications existantes, et les deux approches peuvent cohabiter dans une même application.