Capture lists in closures in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a capture list in Swift closures?

A capture list is a way to define how variables are captured inside a closure. It lets you specify whether to capture variables strongly, weakly, or unowned to control memory management and avoid retain cycles.

beginner

Why do we use capture lists in closures?

We use capture lists to avoid strong reference cycles (retain cycles) by controlling how variables are captured. For example, capturing a variable as weak or unowned prevents the closure from keeping the variable alive forever.

beginner

How do you write a capture list in a Swift closure?

You write a capture list inside square brackets before the closure parameters. For example: {[weak self] in ...} captures self weakly inside the closure.

intermediate

What is the difference between capturing a variable as weak and unowned in a capture list?

Capturing as weak means the variable can become nil and is optional inside the closure. Capturing as unowned means the variable is expected to always exist and is non-optional, but if it doesn't exist, the program will crash.

intermediate

Show an example of a capture list preventing a retain cycle with self in a closure.

Example:

class MyClass {
  var closure: (() -> Void)?
  func setup() {
    closure = { [weak self] in
      print(self)
    }
  }
}

Here, self is captured weakly to avoid a retain cycle between the class and the closure.

What does the capture list [weak self] do inside a Swift closure?

A Prevents the closure from running

B Captures self strongly to keep it alive

C Makes self optional outside the closure

D Captures self weakly to avoid retain cycles

The capture list [weak self] captures self weakly inside the closure to avoid strong reference cycles.

Where do you place the capture list in a Swift closure?

A At the end of the function

B Inside square brackets before the closure parameters

C Inside the closure body

D After the closure body

Capture lists are placed inside square brackets before the closure parameters.

What happens if you capture a variable as unowned but it becomes nil?

A The program crashes

B The variable becomes optional

C The closure ignores the variable

D The variable is captured weakly instead

Capturing as unowned assumes the variable always exists; if it becomes nil, the program crashes.

Why might you want to use a capture list in a closure?

A To control how variables are captured and avoid memory leaks

B To make the closure run faster

C To change the closure's return type

D To make the closure synchronous

Capture lists help control variable capture to avoid retain cycles and memory leaks.

Which of these is a correct capture list syntax?

A { weak self in print(self) }

B { (weak self) -> Void in print(self) }

C { [weak self] in print(self) }

D { [self weak] in print(self) }

The correct syntax uses square brackets: { [weak self] in ... }

Explain what a capture list is and why it is important in Swift closures.

Think about how closures keep references to variables and how that can cause problems.

Describe the difference between capturing a variable as weak versus unowned in a closure's capture list.

Consider safety and lifetime guarantees of the captured variable.