Écrire du Swift
Réponse initiale
Lorsque ce skill est invoqué pour la première fois sans question spécifique, répondez uniquement par :
Je suis prêt à vous aider à écrire du Swift moderne, de la manière dont le langage veut être écrit.
Ne fournissez aucune autre information jusqu'à ce que l'utilisateur pose une question.
Comment écrire Swift de la manière dont le langage veut être écrit, à jour jusqu'à Swift 6.4.
Base de la chaîne d'outils : Swift 6.3 (version actuelle en août 2026). Tout ceci compile sous 6.3 sauf indication contraire ⚠, qui signale les fonctionnalités non encore publiées de Swift 6.4. Les conseils sur la concurrence supposent le modèle Swift 6.2 — si le projet est sur 6.1 ou antérieur, les règles du §3 concernant async et @concurrent ne s'appliquent pas.
Le fil conducteur : Swift est un langage à divulgation progressive. Commencez par la chose la plus simple, la plus statique, la plus mono-thread qui fonctionne, et n'achetez du dynamisme — concurrence, sémantique de référence, existentiels, pointeurs dangereux — que là où vous pouvez pointer une raison. Chaque règle ci-dessous est une application de ce principe.
Modélisez cette hiérarchie de valeurs par défaut. Ne descendez d'un niveau qu'avec une raison que vous pouvez énoncer :
| Besoin | Utilisez | Descendez seulement lorsque |
|---|---|---|
| Données | struct / enum | vous avez besoin d'identité, de partage ou d'héritage |
| Abstraction | type concret | vous avez du code répété entre types |
| Polymorphisme | some P (générique) | vous avez besoin de stockage hétérogène → any P |
| Exécution | acteur principal, synchrone | le profilage montre un blocage → async → @concurrent → actor |
| Mémoire | Array, String | le profilage montre le coût → InlineArray, Span |
| Sécurité | API sécurisée | interop C ou un chemin chaud mesuré → Unsafe* |
1. Modéliser les données avec des types valeur
Les types valeur sont la valeur par défaut en Swift, pas un cas particulier.
- Utilisez
structetenumpar défaut. N'utilisezclassque pour l'identité, l'état mutable partagé, l'héritage ou la durée de vie d'une ressource. Une fenêtre, une connexion à une base de données, une entité stockée dans un moteur de rendu — celles-ci ont une identité. UnPoint, uneBoisson, unMatériaun'en ont pas. letpar défaut ;varseulement lorsque vous mutez. C'est la même discipline quesomeavantanyet valeur avant référence : commencez étroit, élargissez avec une raison.- Une struct avec une propriété de type référence mutable n'est ni une valeur ni une référence. Les copies partagent l'objet ; les mutations se propagent entre les copies. Soit gardez le type référencé immuable, exposez uniquement des propriétés calculées qui lui délèguent, soit faites-en une propriété
privatestockée derrière une copie à l'écriture. - La copie à l'écriture est la façon d'obtenir un stockage hors ligne et une sémantique de valeur. Encapsulez une classe finale dans une struct et vérifiez
isKnownUniquelyReferenced(&stockage)avant de muter ; copiez d'abord si ce n'est pas le cas. C'est exactement ainsi que fonctionnentArray,StringetDictionary. - Les enums sont l'outil pour « un ensemble fixe de choses » et pour les états mutuellement exclusifs. Remplacer un tas de propriétés stockées optionnelles (
isPartage,lignesSelectionnees,ciblePartage) par uneenum Etatrend les combinaisons invalides irreprésentables et rend le changement d'état atomique au lieu d'une séquence d'écritures de propriétés que vous pouvez oublier de terminer. - Composer des valeurs produit une valeur. Une struct dont les propriétés stockées sont toutes des types valeur a une sémantique de valeur gratuitement — ce qui fait de l'annulation, du diff et de la restauration d'état un seul chemin de code au lieu d'un par propriété.
struct Materiau { // sémantique de valeur préservée
var rugosite: Double
private var _texture: Texture // une classe
var couleur: Couleur {
get { _texture.couleur }
set {
if !isKnownUniquelyReferenced(&_texture) { _texture = Texture(copiant: _texture) }
_texture.couleur = nouvelleValeur
}
}
}
Les types non copiables (~Copyable) expriment une propriété unique : un descripteur de fichier, un virement bancaire, une ressource ouverte. Supprimer la copie transforme « vous ne devez pas exécuter ceci deux fois » d'une assertion en une erreur de compilation, et donne un sens à deinit sur une struct. Marquez la méthode de terminaison consuming pour que le compilateur prouve qu'il s'agit de la dernière utilisation. La propriété des paramètres devient explicite : borrowing (lecture seule, par défaut), consuming (prend possession), inout/mutating (accès temporaire en écriture).
2. Erreurs et optionnels — rendez les chemins d'échec visibles
La gestion des erreurs en Swift repose sur trois points : les sources d'erreur sont marquées afin qu'elles ne puissent pas vous surprendre ; les erreurs portent suffisamment de contexte pour agir ; et les erreurs récupérables sont différentes des erreurs de programmation.
- Récupérable →
throw. Erreur de programmation →precondition/fatalError. Un appel réseau échoué maintient le programme en vie. Un index hors limites signifie que le code est erroné et doit s'arrêter avant que le bogue ne devienne un problème de sécurité. - Les enums avec valeurs associées constituent les meilleurs types d'erreur.
cas amiDoublon(Chaîne)batcas amiDoublon— le contexte est tout l'intérêt. guardpour les conditions d'erreur, car il force la sortie.if letpour le déballage ordinaire.throws(MonErreur)typé est pour les fonctions internes, le code générique qui transmet des erreurs, et les environnements contraints où l'encapsulation dansany Errorest trop coûteuse. Pour l'API publique,throwsnon typé préserve votre liberté de changer le type d'erreur plus tard. Notez l'unification :throwsestthrows(any Error), et ne pas lever estthrows(Never)— ce qui permet àmapde faire abstraction des deux.- Force-unwrap seulement là où vous pouvez énoncer l'invariant, et préférez un
#require/preconditionavec un message plutôt qu'un!nu.
3. Concurrence : restez mono-thread jusqu'à ce que le profilage dise le contraire
C'est la section que les agents comprennent le plus souvent de travers, car le modèle a changé dans Swift 6.2.
Démarrez chaque application entièrement sur le thread principal. Le code mono-thread va loin, et la plupart des applications n'ont jamais besoin de le quitter.
La progression, dans l'ordre. Ne sautez pas les étapes.
- Mono-thread sur l'acteur principal. Pas de concurrence du tout. Bon pour la plupart des applications.
async/awaitpour masquer la latence (réseau, disque). Toujours pas de concurrence de votre propre chef — les API du SDK commeURLSession.data(from:)déchargent pour vous.@concurrentpour déplacer votre travail coûteux hors du thread principal — seulement après qu'Instruments montre un blocage.actorpour déplacer l'état hors de l'acteur principal — seulement lorsque trop d'état sur l'acteur principal force les tâches à revenir constamment.
Activez d'abord les bons paramètres de build. Activez Concurrence Abordable dans chaque projet. Pour les modules d'application et les modules d'interface utilisateur, définissez également Isolement par Défaut de l'Acteur sur ActeurPrincipal — c'est la valeur par défaut pour les nouveaux projets d'application dans Xcode 26, et cela supprime la plupart de vos annotations @MainActor. Dans un package : swiftSettings: [.defaultIsolation(MainActor.self)]. Ne définissez pas main-actor-by-default pour une bibliothèque à usage général — les bibliothèques devraient fournir des API nonisolated et laisser les clients décider où le travail s'exécute.
La règle qui a changé
Dans Swift 6.2, marquer une fonction async ne la déplace pas de l'acteur courant. Elle s'exécute là d'où elle a été appelée. C'est ce qui rend « le code le plus naturel à écrire » sans course de données par défaut.
@concurrent— bascule toujours vers le pool de threads concurrents. Utilisez-le pour votre travail intensif en calcul.nonisolated— s'exécute là d'où il est appelé. C'est la valeur par défaut correcte pour les API de bibliothèque, car l'appelant décide.nonisolatedsur un type rend tous ses membres nonisolés (Swift 6.1+).- Ni l'un ni l'autre — reste sur l'acteur de l'appelant.
nonisolated struct ProcesseurPhoto { // découplé de l'acteur principal
@concurrent // garanti de s'exécuter en arrière-plan
func traiter(_ donnees: Donnees) async -> PhotoTraitee {
async let autocollant = extraireAutocollant(donnees) // deux tâches indépendantes, en parallèle
async let couleurs = extraireCouleurs(donnees)
return await PhotoTraitee(autocollant: autocollant, couleurs: couleurs)
}
}
- Profilez avant de décharger. Utilisez Instruments (Time Profiler, blocages). Si le code peut être accéléré sans concurrence, faites toujours cela en premier. La concurrence a un coût réel — allocation de tâche, ordonnancement et raisonnement.
- Ne créez pas de tâche pour un travail trivial. Une tâche enfant pour lire une valeur
UserDefaultscoûte plus qu'elle n'en sauve. - Une tâche par opération de bout en bout. Le travail qui doit se produire dans l'ordre va dans une tâche ; les opérations indépendantes obtiennent des tâches séparées pour que l'exécution puisse les entrelacer.
awaitest un point de suspension, et il brise l'atomicité. L'état peut changer pendant que vous êtes suspendu, et vous pouvez reprendre sur un thread différent. Revérifiez les hypothèses après chaqueawait. Ne tenez jamais un verrou à travers un. Ne comptez jamais sur le stockage local du thread à travers un.
Réentrance des acteurs
Les acteurs garantissent l'exclusion mutuelle, pas les transactions. Entre deux await sur le même acteur, d'autres travaux s'exécutent.
- Mutez l'état de l'acteur dans des méthodes synchrones. Le code synchrone sur un acteur s'exécute jusqu'à son terme sans interruption — c'est votre limite de transaction.
- Gardez les méthodes asynchrones des acteurs légères, composées d'opérations transactionnelles synchrones, et laissez l'acteur dans un état cohérent à chaque
await. - Le bogue classique : vérifier le cache →
awaittélécharger → écrire le cache. Deux tâches échouent toutes deux au cache, téléchargent toutes deux, la seconde écrase la première. Revérifiez après leawait, ou dédupliquez le travail en cours. - Les acteurs ne sont pas FIFO. Ils exécutent d'abord le travail de plus haute priorité, précisément pour éviter l'inversion de priorité. Si vous avez besoin d'ordonnancement, utilisez une tâche (qui s'exécute du début à la fin) ou un
AsyncStream, pas un acteur.
4. Sendable et partage de données
Sendable marque un type comme sûr à partager entre domaines d'isolement. Le compilateur le vérifie à chaque frontière de tâche et d'acteur.
- Les types valeur sont
Sendablelorsque leur stockage l'est — inféré automatiquement pour les types non publics. Les types publics n'ont jamais d'envoi inféré : marquer un type publicSendableest une promesse à vos clients, donc Swift vous oblige à l'écrire. - Les acteurs et les classes
@MainActorsont implicitementSendable, car leur état est isolé. - La plupart des classes de modèle ne devraient être ni
@MainActorniSendable. Gardez-les non-Sendableintentionnellement — cela empêche la moitié du modèle d'être mutée sur le thread principal tandis que l'autre moitié est mutée en arrière-plan. Si elles doivent quitter l'acteur principal, rendez-lesnonisolated, pasSendable. - Vous pouvez toujours envoyer un objet non-
Sendableentre domaines tant que l'expéditeur cesse de l'utiliser. Effectuez toutes vos mutations avant de le transmettre ; y toucher après est l'erreur. - Les fermetures capturent aussi l'état. Ne marquez un type de fonction
@Sendableque s'il traverse vraiment les domaines. @unchecked Sendableest une promesse que le compilateur ne peut pas vérifier. Réservez-le pour les types avec une véritable synchronisation interne (unMutex, un verrou). Idem pournonisolated(unsafe)sur un global — dernier recours, pas un silencieux d'avertissement.
Lorsque vous rencontrez une erreur de course de données, parcourez cette liste :
- Ne le partagez pas. Déplacez l'objet partagé dans une variable locale afin que chaque tâche concurrente obtienne sa propre instance. (C'est la correction pour la grande majorité des erreurs réelles.)
- Transformez-le en un type valeur
Sendable, de sorte que « partager » soit vraiment copier. - Isolez-le dans un acteur — l'acteur principal, ou le vôtre.
- Alors seulement, utilisez
Mutex/Atomicdu moduleSynchronization(stockez-les dans des propriétéslet), ou@unchecked Sendable.
Les variables globales et statiques sont la source la plus courante d'erreurs. Par ordre de préférence : faites-en un let ; mettez-le sur @MainActor ; encapsulez-le dans un Mutex ; nonisolated(unsafe). Notez que les globales en Swift sont initialisées paresseusement et atomiquement — contrairement au C.
Bridging des anciennes API de rappel : annotez les protocoles délégués avec @MainActor si vous les possédez. Si ce n'est pas le cas, marquez la méthode nonisolated et utilisez MainActor.assumeIsolated { } — cela affirme plutôt que de sauter, donc cela piège bruyamment au lieu de courir en silence. @preconcurrency sur la conformité est le raccourci pour la même chose. Utilisez @preconcurrency import pour faire taire temporairement les avertissements d'envoi d'un module qui n'a pas migré ; les avertissements reviennent — correctement — une fois qu'il l'a fait.
5. Concurrence structurée
Préférez toujours les tâches structurées.
Les tâches structurées (async let, groupes de tâches) sont limitées comme les variables locales : elles ne peuvent pas survivre au bloc, elles sont attendues automatiquement, et elles héritent de l'annulation, de la priorité et des valeurs locales à la tâche à travers l'arbre de tâches. Les tâches non structurées (Task { }, Task.detached) ne vous donnent rien de tout cela automatiquement.
async letpour un nombre fixe et statiquement connu d'enfants concurrents.withTaskGrouplorsque le nombre est dynamique. Les groupes de tâches sont conformes àAsyncSequence— itérez les résultats au fur et à mesure qu'ils arrivent. UtilisezwithDiscardingTaskGrouplorsque les enfants ne retournent rien : cela libère les ressources de chaque enfant immédiatement et annule les frères et sœurs à la première erreur.Task { }uniquement lorsque la durée de vie du travail ne correspond pas à une portée — réagir à un rappel de délégué, un clic sur un bouton, une vue qui apparaît. Il hérite de l'isolement et de la priorité de l'acteur ; vous devez gérer l'annulation vous-même.Task.detachedpresque jamais. Il n'hérite de rien — ni isolement, ni priorité, ni variables locales de tâche. Si vous avez besoin d'une racine détachée, mettez un groupe de tâches à l'intérieur plutôt que de détacher à plusieurs reprises.
L'annulation est coopérative. Annuler définit un drapeau ; cela n'arrête rien. Vérifiez Task.isCancelled ou try Task.checkCancellation() avant de commencer un travail coûteux, et aussi dans les aides synchrones. Pour un travail qui est suspendu plutôt qu'en cours d'exécution (le next() d'un AsyncSequence), utilisez withTaskCancellationHandler — et rappelez-vous que le gestionnaire s'exécute immédiatement et concurrentiellement au corps, donc l'état qu'il touche a besoin d'une véritable synchronisation (un atomique ou un verrou, pas un acteur — vous ne pouvez pas garantir l'ordre sur un acteur).
Limitez votre concurrence. Ne répartissez pas un enfant par élément sur une liste non bornée. Démarrez N enfants, puis ajoutez-en un nouveau de plus.