Swift Academy · Leçon

Mutation, partage et aliasing inattendu

Comprendre comment les références partagées provoquent des bogues et comment les types valeur les évitent.

Mutation, partage et aliasing inattendu est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Bienvenue

L’aliasage se produit lorsque deux variables désignent le même objet. Avec les types valeur, c’est impossible ; avec les types référence, cela entraîne des erreurs surprenantes. Comprendre cette distinction est essentiel.

Les types valeur n’ont pas d’aliasage

```swift var a = [1,2,3] var b = a // independent copy a.append(4) print(b) // [1,2,3] — unchanged ``` Chaque affectation d’un type valeur crée une copie indépendante.

Les types référence créent des alias (DO)

```swift class Counter { var value = 0 } let a = Counter() let b = a // SAME object a.value += 1 print(b.value) // 1 — b sees the change! ``` `a` et `b` désignent tous deux le même objet du tas.

Aliasage dans les paramètres de fonction

```swift func increment(_ c: Counter) { c.value += 1 } let shared = Counter() increment(shared) print(shared.value) // 1 — mutated by the function ``` Les classes sont transmises par référence — la fonction modifie l’original.

Le problème : l’état mutable partagé

```swift class Cache { var items: [String] = [] } var cache = Cache() var cache2 = cache // aliased! cache.items.append("data") print(cache2.items) // ["data"] — unexpected! ``` C’est ainsi que des parties apparemment indépendantes du code s’influencent mutuellement.

Résoudre le problème avec les types valeur

```swift struct Cache { var items: [String] = [] } var cache = Cache() var cache2 = cache // independent copy cache.items.append("data") print(cache2.items) // [] — unaffected ```

Résoudre le problème avec des classes qui se copient

```swift func process(_ c: Counter) { var local = Counter() local.value = c.value // copy values, not reference local.value += 1 } ``` Lorsque vous avez besoin d’une sémantique de référence sans aliasage, copiez explicitement les valeurs.

Sécurité des threads et aliasage

Le partage de références devient particulièrement dangereux entre les fils d’exécution : ```swift // Thread 1: cache.items.append("a") // Thread 2 simultaneously: cache.items.append("b") // ❌ data race! ``` Les types valeur de Swift Concurrency empêchent cela par défaut — seuls les acteurs peuvent partager un état mutable.

Détecter les partages de références accidentels

Le détecteur de courses d’Xcode (TSan) détecte les courses aux données à l’exécution. Activez-le sous Schéma > Diagnostics > Détection des courses. Le contrôle de l’exclusivité de Swift détecte à l’exécution les violations de partage de références sur un seul fil d’exécution pour les paramètres `inout`.

Schémas de partage de références intentionnel

Parfois, le partage de références est intentionnel — par exemple, pour un cache global : ```swift class AppCache { static let shared = AppCache() // intentional shared reference var data: [String: Any] = [:] } ``` Documentez clairement le partage intentionnel ; par défaut, évitez les partages de références accidentels en privilégiant les types valeur.

Vérification rapide

Que se passe-t-il lorsque vous affectez une instance de classe à une nouvelle variable ?

Récapitulatif

Points essentiels : • Types valeur (structures) — l’affectation copie la valeur ; aucun partage de références possible • Types référence (classes) — l’affectation partage la référence ; le partage de références est possible • Partage de références entre les fils d’exécution = course aux données • Privilégiez les structures ; utilisez les classes uniquement lorsqu’une identité partagée est nécessaire • Utilisez TSan et le contrôle de l’exclusivité de Swift pour détecter les problèmes Ensuite : graphes mixtes de valeurs et de références.

Questions Fréquemment Posées

La leçon « Mutation, partage et aliasing inattendu » est-elle gratuite ?

Oui — le texte complet de « Mutation, partage et aliasing inattendu » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mutation, partage et aliasing inattendu » ?

Comprendre comment les références partagées provoquent des bogues et comment les types valeur les évitent. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Mutation, partage et aliasing inattendu » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Pile ou tas : où résident les valeurs
Mutation, partage et aliasing inattendu
Graphes mixtes de valeurs et de références
Concevoir des interfaces pour la sémantique des valeurs

← Retour à Swift Academy