Swift Academy · Lektion

weak- und unowned-Referenzen

Wählen Sie zum Aufbrechen von Zyklen zwischen weak (Optional) und unowned (nicht Optional).

weak- und unowned-Referenzen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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

Zum Auflösen von Retain-Zyklen sind Referenzen erforderlich, die den ARC-Zähler nicht erhöhen. Swift stellt dafür zwei Varianten bereit: `weak` (optional, wird automatisch auf nil gesetzt) und `unowned` (nicht optional, unsicher, wenn der Wert nil ist).

weak-Referenzen

```swift class Owner { var pet: Pet? } class Pet { weak var owner: Owner? } // does not retain var o: Owner? = Owner() var p: Pet? = Pet() o?.pet = p p?.owner = o o = nil // Owner deinit — p.owner becomes nil automatically ```

weak ist immer optional

```swift class View { weak var delegate: ViewDelegate? } ``` `weak` muss als `var` und optional deklariert werden — Swift setzt die Referenz automatisch auf nil, wenn das referenzierte Objekt deallokiert wird.

unowned-Referenzen

```swift class Customer { var card: CreditCard? } class CreditCard { unowned let customer: Customer // card always has a customer init(customer: Customer) { self.customer = customer } } ``` `unowned` behält das referenzierte Objekt nicht und ist nicht optional — Sie garantieren, dass das referenzierte Objekt länger lebt als dieses Objekt.

Auswahl zwischen weak und unowned

| Szenario | Verwenden | |---|---| | Das referenzierte Objekt kann nil werden | `weak` | | Das referenzierte Objekt lebt immer länger als dieses Objekt | `unowned` | | Sie sind unsicher | `weak` (sicherer) |

Zugriff auf unowned nach der Deallokierung

```swift var customer: Customer? = Customer() var card = CreditCard(customer: customer!) customer = nil print(card.customer.name) // 💥 crash — unowned is dangling ``` Greifen Sie niemals auf `unowned` zu, nachdem das referenzierte Objekt deallokiert wurde.

[weak self] in Closures

```swift class VC { func load() { api.fetch { [weak self] data in guard let self else { return } self.render(data) } } } ``` `[weak self]` ist die häufigste Lösung für Retain-Zyklen in Swift.

[unowned self] in Closures

```swift class Session { var onComplete: (() -> Void)? init() { onComplete = { [unowned self] in // self always outlives closure self.finish() } } } ``` Verwenden Sie `[unowned self]` nur, wenn Sie sicher sind, dass `self` beim Ausführen der Closure nicht nil sein kann.

Automatisches Setzen auf nil beobachten

```swift class Timer { weak var delegate: TimerDelegate? } var d: TimerDelegate? = ConcreteDelegate() let t = Timer() t.delegate = d d = nil print(t.delegate) // nil — automatically zeroed ```

Best Practice beim Delegate-Muster

Deklarieren Sie Delegate-Eigenschaften immer als `weak`: ```swift protocol MyDelegate: AnyObject { func didUpdate() } class MyView { weak var delegate: MyDelegate? } ``` Die Einschränkung `AnyObject` ist erforderlich, um `weak` mit Protokollen zu verwenden.

Kurzer Test

Welcher Referenztyp wird automatisch auf `nil` gesetzt, wenn das referenzierte Objekt deallokiert wird?

Zusammenfassung

Wichtige Erkenntnisse: • `weak` — optional, automatisch auf nil gesetzt, sicher • `unowned` — nicht optional, lebt garantiert länger, führt bei falschen Annahmen zum Absturz • Delegate-Muster: immer `weak var delegate: Protocol?` mit der Einschränkung `AnyObject` • Closures: `[weak self]` ist das Standardmuster; verwenden Sie darin `guard let self` • Wählen Sie im Zweifel `weak` statt `unowned` Als Nächstes: Capture-Listen von Closures.

Häufig gestellte Fragen

Ist die Lektion „weak- und unowned-Referenzen“ kostenlos?

Ja — der vollständige Text von „weak- und unowned-Referenzen“ 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 „weak- und unowned-Referenzen“?

Wählen Sie zum Aufbrechen von Zyklen zwischen weak (Optional) und unowned (nicht Optional). 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 3 von 4.

Wie lange dauert die Lektion „weak- und unowned-Referenzen“?

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

← Zurück zu Swift Academy