Swift Academy · Leçon

Méthodes mutantes et sémantique de copie à l’écriture

Comprendre pourquoi mutating est nécessaire et comment fonctionne l’optimisation COW de Swift.

Méthodes mutantes et sémantique de copie à l’écriture est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 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

Les méthodes de structure qui modifient des propriétés stockées doivent être marquées `mutating`. Swift utilise également la copie à l’écriture (COW) pour rendre les sémantiques de valeur efficaces.

Mot-clé `mutating`

```swift struct Counter { var count = 0 mutating func increment() { count += 1 } mutating func reset() { count = 0 } } var c = Counter() c.increment() // count = 1 ``` Sans `mutating`, le compilateur rejette les méthodes qui modifient `self`.

Pourquoi `mutating` est nécessaire

Les structures sont des types valeur. Lorsque vous transmettez une structure, vous transmettez une *copie*. Le compilateur a besoin de `mutating` pour savoir qu’une méthode modifiera la valeur d’origine : ```swift let c = Counter() c.increment() // ❌ cannot use mutating on let ```

Réaffecter self dans une méthode `mutating`

Une méthode `mutating` peut remplacer entièrement `self` : ```swift struct Toggle { var isOn: Bool mutating func flip() { self = Toggle(isOn: !isOn) } } ```

Sémantique de valeur : comportement de copie

```swift var a = Counter() var b = a // b is an independent copy a.increment() print(a.count) // 1 print(b.count) // 0 — unaffected ``` L’affectation d’une structure copie toutes ses propriétés stockées.

Copie à l’écriture (COW)

Les collections intégrées de Swift (`Array`, `Dictionary`, `Set`, `String`) utilisent COW : ```swift var a = [1,2,3] var b = a // no copy yet — shared storage b.append(4) // NOW a copy is made — a is unchanged print(a) // [1,2,3] print(b) // [1,2,3,4] ```

Pourquoi COW est important

Sans COW, chaque affectation de structure effectuerait une copie profonde de tout le contenu. COW signifie que les copies sont peu coûteuses (seul un incrément de compteur de références est effectué) jusqu’à ce qu’une mutation déclenche une véritable copie. Cela rend les types valeur aussi rapides que les types référence dans la plupart des situations.

Implémenter une copie à l’écriture personnalisée

```swift struct Buffer { private var storage: NSMutableData private mutating func ensureUnique() { if !isKnownUniquelyReferenced(&storage) { storage = storage.mutableCopy() as! NSMutableData } } mutating func append(_ byte: UInt8) { ensureUnique() // safe to mutate storage now } } ```

Mutation et protocoles

Les méthodes de protocole qui effectuent une mutation doivent être marquées `mutating` dans le protocole : ```swift protocol Resettable { mutating func reset() } struct Counter: Resettable { var count = 0 mutating func reset() { count = 0 } } ``` Les classes qui implémentent le protocole n’ont pas besoin de `mutating` (les classes sont des types référence).

Les structures stockées dans let sont entièrement immuables

```swift let pt = Point(x: 1, y: 2) pt.x = 3 // ❌ even though x is var inside Point ``` Lorsqu’une structure est stockée dans une constante `let`, aucune de ses propriétés stockées ne peut être modifiée.

Vérification rapide

Quand Swift effectue-t-il réellement une copie avec la copie à l’écriture ?

Récapitulatif

Points clés à retenir : • `mutating` marque les méthodes qui modifient les propriétés d’une structure • Vous ne pouvez pas appeler de méthodes `mutating` sur des structures stockées dans `let` • L’affectation copie la structure ; COW rend cette opération peu coûteuse pour les collections • COW ne déclenche une véritable copie qu’à la première mutation • Implémentez une copie à l’écriture personnalisée avec `isKnownUniquelyReferenced` Cours terminé ! À suivre : héritage des classes.

Questions Fréquemment Posées

La leçon « Méthodes mutantes et sémantique de copie à l’écriture » est-elle gratuite ?

Oui — le texte complet de « Méthodes mutantes et sémantique de copie à l’écriture » 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 « Méthodes mutantes et sémantique de copie à l’écriture » ?

Comprendre pourquoi mutating est nécessaire et comment fonctionne l’optimisation COW de Swift. 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 4 sur 4.

Combien de temps prend la leçon « Méthodes mutantes et sémantique de copie à l’écriture » ?

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

Initialiseurs générés pour les membres et initialiseurs personnalisés
Propriétés stockées et observateurs de propriétés
Propriétés calculées dans les structures
Méthodes mutantes et sémantique de copie à l’écriture

← Retour à Swift Academy