Swift Academy · Lesson

weak and unowned References

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

Lesson 3 of 412 steps

weak and unowned References is a free Swift Academy lesson on CoddyKit. This is lesson 3 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, and your progress syncs across the web and the CoddyKit app. The Swift Academy course includes 4 lessons in total.

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?

Answer it in the interactive lesson

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.

Free to start

Learn Swift with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 122
Lessons: 409

Start learning free View the full course

Frequently Asked Questions

Is the “weak and unowned References” lesson free?

Yes — any 3 lessons of the Swift Academy learning path, including “weak and unowned References”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Swift Academy course includes 4 lessons in total.

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, so you can start here or from the beginning and move at your own pace. This is lesson 3 of 4.

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