Swift Academy · Lektion

Mutierende Methoden und Copy-on-Write-Semantik

Warum mutating erforderlich ist und wie Swifts COW-Optimierung funktioniert.

Lektion 4 von 412 Schritte

Mutierende Methoden und Copy-on-Write-Semantik ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Struct-Methoden, die gespeicherte Properties ändern, müssen mit `mutating` markiert werden. Swift verwendet außerdem Copy-on-Write (COW), um Wertsemantik effizient umzusetzen.

Schlüsselwort mutating

```swift struct Counter { var count = 0 mutating func increment() { count += 1 } mutating func reset() { count = 0 } } var c = Counter() c.increment() // count = 1 ``` Ohne `mutating` lehnt der Compiler Methoden ab, die `self` ändern.

Warum mutating erforderlich ist

Structs sind Werttypen. Wenn Sie ein Struct übergeben, übergeben Sie eine *Kopie*. Der Compiler benötigt `mutating`, um zu wissen, dass eine Methode den ursprünglichen Wert ändert: ```swift let c = Counter() c.increment() // ❌ cannot use mutating on let ```

self in mutating neu zuweisen

Eine `mutating`-Methode kann `self` vollständig ersetzen: ```swift struct Toggle { var isOn: Bool mutating func flip() { self = Toggle(isOn: !isOn) } } ```

Wertsemantik: Verhalten beim Kopieren

```swift var a = Counter() var b = a // b is an independent copy a.increment() print(a.count) // 1 print(b.count) // 0 — unaffected ``` Beim Zuweisen eines Structs werden alle gespeicherten Properties kopiert.

Copy-on-Write (COW)

Die integrierten Collections von Swift (Array, Dictionary, Set, String) verwenden 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] ```

Warum COW wichtig ist

Ohne COW würde jede Zuweisung eines Structs den gesamten Inhalt vollständig kopieren. Durch COW sind Kopien kostengünstig – es wird lediglich der Referenzzähler erhöht –, bis eine Mutation eine tatsächliche Kopie auslöst. Dadurch sind Werttypen in den meisten Szenarien genauso schnell wie Referenztypen.

Benutzerdefiniertes COW implementieren

```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 und Protocols

Protokollmethoden, die Daten verändern, müssen im Protokoll mit `mutating` markiert werden: ```swift protocol Resettable { mutating func reset() } struct Counter: Resettable { var count = 0 mutating func reset() { count = 0 } } ``` Klassen, die das Protokoll implementieren, benötigen `mutating` nicht, da Klassen Referenztypen sind.

let-Structs sind vollständig unveränderlich

```swift let pt = Point(x: 1, y: 2) pt.x = 3 // ❌ even though x is var inside Point ``` Wenn ein Struct in einer `let`-Konstante gespeichert ist, kann keine seiner gespeicherten Properties verändert werden.

Schnelltest

Wann führt Swift's Copy-on-Write tatsächlich eine Kopie durch?

Beantworte es in der interaktiven Lektion

Zusammenfassung

Die wichtigsten Punkte: • `mutating` kennzeichnet Methoden, die Struct-Properties ändern • `mutating`-Methoden können nicht für `let`-Structs aufgerufen werden • Eine Zuweisung kopiert das Struct; COW macht dies bei Collections kostengünstig • COW löst erst bei der ersten Mutation eine tatsächliche Kopie aus • Implementieren Sie benutzerdefiniertes COW mit `isKnownUniquelyReferenced` Kurs abgeschlossen! Als Nächstes: Klassenvererbung.

Kostenlos starten

Lerne Swift mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 122
Lektionen: 409

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Mutierende Methoden und Copy-on-Write-Semantik“ kostenlos?

Ja — der vollständige Text von „Mutierende Methoden und Copy-on-Write-Semantik“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Mutierende Methoden und Copy-on-Write-Semantik“?

Warum mutating erforderlich ist und wie Swifts COW-Optimierung funktioniert. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Mutierende Methoden und Copy-on-Write-Semantik“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Memberwise-Initialisierer und benutzerdefinierte Initialisierer
Gespeicherte Eigenschaften und Eigenschaftsbeobachter
Berechnete Eigenschaften in Structs
Mutierende Methoden und Copy-on-Write-Semantik

← Zurück zu Swift Academy