Swift Academy · Lesson

weak and unowned References

Choosing between weak (Optional) and unowned (non-Optional) to break cycles.

weak and unowned References is a free Swift Academy lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

Breaking retain cycles requires references that don't increment the ARC count. Swift provides two: `weak` (optional, zeroed automatically) and `unowned` (non-optional, unsafe if nil).

weak References

```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 is Always Optional

```swift class View { weak var delegate: ViewDelegate? } ``` `weak` must be `var` and optional — Swift zeros it automatically when the referenced object is deallocated.

unowned References

```swift class Customer { var card: CreditCard? } class CreditCard { unowned let customer: Customer // card always has a customer init(customer: Customer) { self.customer = customer } } ``` `unowned` doesn't retain and is non-optional — you guarantee the referenced object outlives this one.

weak vs unowned Choosing

| Scenario | Use | |---|---| | Referenced object may become nil | `weak` | | Referenced object always outlives this | `unowned` | | Unsure | `weak` (safer) |

Accessing unowned After Dealloc

```swift var customer: Customer? = Customer() var card = CreditCard(customer: customer!) customer = nil print(card.customer.name) // 💥 crash — unowned is dangling ``` Never access `unowned` after the referenced object is deallocated.

[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]` is the most common retain cycle fix in Swift.

[unowned self] in Closures

```swift class Session { var onComplete: (() -> Void)? init() { onComplete = { [unowned self] in // self always outlives closure self.finish() } } } ``` Use `[unowned self]` only when you're certain `self` won't be nil when the closure runs.

Zeroing-Out Observed

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

Delegate Pattern Best Practice

Always declare delegate properties as `weak`: ```swift protocol MyDelegate: AnyObject { func didUpdate() } class MyView { weak var delegate: MyDelegate? } ``` `AnyObject` constraint is required to use `weak` with protocols.

Quick Check

Which reference type is automatically set to `nil` when the referenced object is deallocated?

Recap

Key takeaways: • `weak` — optional, auto-zeroed, safe • `unowned` — non-optional, guaranteed outlives, crashes if wrong • Delegate patterns: always `weak var delegate: Protocol?` with `AnyObject` constraint • Closures: `[weak self]` is the standard pattern; use `guard let self` inside • When in doubt, choose `weak` over `unowned` Next: closure capture lists.

Frequently asked questions

Is the “weak and unowned References” lesson free?

Yes — the full text of “weak and unowned References” is free to read here on the web, and the Swift Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

What will I learn in “weak and unowned References”?

Choosing between weak (Optional) and unowned (non-Optional) to break cycles. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “weak and unowned References” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Swift Academy