Swift Academy · leksjon

Muterende metoder og copy-on-write-semantikk

Forstå hvorfor mutating kreves, og hvordan Swift sin COW-optimalisering fungerer.

Leksjon 4 av 412 trinn

Muterende metoder og copy-on-write-semantikk er en gratis leksjon i Swift Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Swift Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Velkommen

Struct-metoder som endrer lagrede egenskaper, må merkes med `mutating`. Swift bruker også Copy-on-Write (COW) for å gjøre verd语semantikk effektiv.

mutating-nøkkelordet

```swift struct Counter { var count = 0 mutating func increment() { count += 1 } mutating func reset() { count = 0 } } var c = Counter() c.increment() // count = 1 ``` Uten `mutating avviser kompilatoren metoder som endrer `self`.

Hvorfor mutating er nødvendig

Struct-er er verdityper. Når du sender en struct, sender du en *kopi*. Kompilatoren trenger `mutating` for å vite at en metode endrer den opprinnelige verdien: ```swift let c = Counter() c.increment() // ❌ cannot use mutating on let ```

Tilordne self på nytt i mutating

En `mutating`-metode kan erstatte hele `self`: ```swift struct Toggle { var isOn: Bool mutating func flip() { self = Toggle(isOn: !isOn) } } ```

Verd_semantikk: kopieringsadferd

```swift var a = Counter() var b = a // b is an independent copy a.increment() print(a.count) // 1 print(b.count) // 0 — unaffected ``` Når du tilordner en struct, kopieres alle lagrede egenskaper.

Copy-on-Write (COW)

Swifts innebygde samlinger (Array, Dictionary, Set, String) bruker 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] ```

Hvorfor COW er viktig

Uten COW ville hver tilordning av en struct kopiert alt innholdet i dybden. COW gjør at kopier er billige — bare en økning av en referanseteller — helt til en mutasjon utløser en faktisk kopi. Dette gjør verdityper like raske som referansetyper i de fleste situasjoner.

Implementere egendefinert COW

```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 og protokoller

Protokollmetoder som endrer verdien, må merkes med `mutating` i protokollen: ```swift protocol Resettable { mutating func reset() } struct Counter: Resettable { var count = 0 mutating func reset() { count = 0 } } ``` Klasser som implementerer protokollen, trenger ikke `mutating` (klasser er referansetyper).

let gjør struct-er fullstendig uforanderlige

```swift let pt = Point(x: 1, y: 2) pt.x = 3 // ❌ even though x is var inside Point ``` Når en struct lagres i en `let`, kan ingen av de lagrede egenskapene muteres.

Hurtigsjekk

Når utfører Swifts Copy-on-Write faktisk en kopiering?

Besvar den i den interaktive leksjonen

Oppsummering

Viktigste punkter: • `mutating` markerer metoder som endrer struct-egenskaper • Du kan ikke kalle `mutating`-metoder på `let`-struct-er • Tilordning kopierer struct-en; COW gjør dette billig for samlinger • COW utløser en faktisk kopi først ved den første mutasjonen • Implementer egendefinert COW med `isKnownUniquelyReferenced` Kurset er fullført! Neste tema: arv i klasser.

Gratis å komme i gang

Lær deg Swift med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 122
Leksjoner: 409

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Muterende metoder og copy-on-write-semantikk» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Swift Academy, inkludert «Muterende metoder og copy-on-write-semantikk», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Muterende metoder og copy-on-write-semantikk»?

Forstå hvorfor mutating kreves, og hvordan Swift sin COW-optimalisering fungerer. Du øver på Swift Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Swift Academy?

Ingen tidligere erfaring er nødvendig. Swift Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Muterende metoder og copy-on-write-semantikk»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Swift Academy-leksjonen?

Ja. Alle Swift Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Medlemsvise initialiserere og egendefinerte init
Lagrede egenskaper og egenskapsobservatører
Beregnede egenskaper i strukturer
Muterende metoder og copy-on-write-semantikk

← Tilbake til Swift Academy