Swift Academy · Lezione

Metodi mutating e semantica copy-on-write

Capire perché è necessario mutating e come funziona l’ottimizzazione COW di Swift.

Metodi mutating e semantica copy-on-write è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Benvenuto

I metodi delle struct che modificano proprietà memorizzate devono essere contrassegnati con `mutating`. Swift usa anche Copy-on-Write (COW) per rendere efficienti le semantiche dei valori.

Parola chiave mutating

```swift struct Counter { var count = 0 mutating func increment() { count += 1 } mutating func reset() { count = 0 } } var c = Counter() c.increment() // count = 1 ``` Senza `mutating`, il compilatore rifiuta i metodi che modificano `self`.

Perché è necessario mutating

Le struct sono tipi valore. Quando si passa una struct, si passa una *copia*. Il compilatore ha bisogno di `mutating` per sapere che un metodo modificherà il valore originale: ```swift let c = Counter() c.increment() // ❌ cannot use mutating on let ```

Riassegnare self in mutating

Un metodo `mutating` può sostituire interamente `self`: ```swift struct Toggle { var isOn: Bool mutating func flip() { self = Toggle(isOn: !isOn) } } ```

Semantica dei valori: comportamento della copia

```swift var a = Counter() var b = a // b is an independent copy a.increment() print(a.count) // 1 print(b.count) // 0 — unaffected ``` L'assegnazione di una struct copia tutte le proprietà memorizzate.

Copy-on-Write (COW)

Le collezioni integrate di Swift (Array, Dictionary, Set, String) usano 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] ```

Perché COW è importante

Senza COW, ogni assegnazione di una struct copierebbe in profondità tutti i contenuti. COW significa che le copie sono economiche (richiedono solo un incremento del conteggio dei riferimenti) finché una mutazione non attiva una copia reale. Nella maggior parte degli scenari, questo rende i tipi valore veloci quanto i tipi riferimento.

Implementazione di COW personalizzato

```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 } } ```

mutating e protocolli

I metodi dei protocolli che modificano lo stato devono essere contrassegnati con `mutating` nel protocollo: ```swift protocol Resettable { mutating func reset() } struct Counter: Resettable { var count = 0 mutating func reset() { count = 0 } } ``` Le classi che implementano il protocollo non hanno bisogno di `mutating` (le classi sono tipi riferimento).

Le struct archiviate in let sono completamente immutabili

```swift let pt = Point(x: 1, y: 2) pt.x = 3 // ❌ even though x is var inside Point ``` Quando una struct è archiviata in una costante `let`, nessuna delle sue proprietà memorizzate può essere modificata.

Verifica rapida

Quando Copy-on-Write di Swift esegue effettivamente una copia?

Riepilogo

Punti chiave: • `mutating` contrassegna i metodi che modificano le proprietà di una struct • Non è possibile chiamare metodi `mutating` su struct dichiarate con `let` • L'assegnazione copia la struct; COW rende economica questa operazione per le collezioni • COW attiva una copia reale solo alla prima mutazione • Implementi COW personalizzato con `isKnownUniquelyReferenced` Corso completato! Prossimo argomento: ereditarietà delle classi.

Domande Frequenti

La lezione «Metodi mutating e semantica copy-on-write» è gratuita?

Sì — il testo completo di «Metodi mutating e semantica copy-on-write» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Metodi mutating e semantica copy-on-write»?

Capire perché è necessario mutating e come funziona l’ottimizzazione COW di Swift. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Metodi mutating e semantica copy-on-write»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Inizializzatori memberwise e init personalizzati
Proprietà memorizzate e observer delle proprietà
Proprietà calcolate nelle struct
Metodi mutating e semantica copy-on-write

← Torna a Swift Academy