Escaping closures (@escaping) in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an escaping closure in Swift?

An escaping closure is a closure that can outlive the function it was passed to. It means the closure can be called after the function returns, often stored or used asynchronously.

beginner

Why do we need to mark a closure with @escaping in Swift?

We mark a closure with @escaping when the closure is stored or called after the function returns. This tells Swift to keep the closure alive beyond the function's lifetime.

intermediate

What happens if you try to use a non-escaping closure as escaping in Swift?

Swift will give a compile-time error because non-escaping closures are expected to be used only during the function execution, not after it returns.

beginner

How do you declare a function parameter as an escaping closure in Swift?

You add the @escaping keyword before the closure type in the function parameter list, for example: func doSomething(completion: @escaping () -> Void) {}

intermediate

Give a simple example of an escaping closure usage in Swift.

Example: func fetchData(completion: @escaping (String) -> Void) { DispatchQueue.main.asyncAfter(deadline: .now() + 1) { completion("Data loaded") } } This closure runs after the function returns.

What does the @escaping keyword indicate in Swift closures?

A The closure cannot be stored

B The closure is optional

C The closure runs immediately and only once

D The closure can be called after the function returns

The @escaping keyword means the closure might be called after the function it was passed to has returned.

Which of these closures must be marked with @escaping?

A A closure stored in a property for later use

B A closure called immediately inside the function

C A closure passed as a parameter but never called

D A closure that returns a value immediately

Only closures that outlive the function, like those stored for later use, must be marked @escaping.

What error occurs if you forget @escaping for a closure that escapes?

A Warning only

B Compile-time error

C Runtime crash

D No error, code runs fine

Swift enforces @escaping at compile time to prevent misuse of closures.

Can a non-escaping closure be stored for later use?

A No, it must be used during the function execution

B Yes, always

C Only if marked optional

D Only if it returns Void

Non-escaping closures cannot be stored or used after the function returns.

Which keyword is used to mark a closure parameter that might escape?

A @inline

B @autoclosure

C @escaping

D @discardableResult

The @escaping keyword marks closures that can be called after the function returns.

Explain what an escaping closure is and why Swift requires the @escaping keyword.

Think about when the closure runs compared to the function.

Describe how to declare and use an escaping closure in a Swift function with a simple example.

Consider a closure called after a delay or stored in a property.

Practice

1. What does the @escaping keyword indicate in Swift closures?

easy

A. The closure can be called after the function returns

B. The closure is executed immediately within the function

C. The closure cannot capture variables from the surrounding scope

D. The closure is only used for synchronous tasks

Solution

1. Step 1: Understand closure execution timing

   Closures without @escaping run inside the function before it returns.

2. Step 2: Role of @escaping

   Marking a closure @escaping means it can be stored and called later, after the function ends.

3. Final Answer:

   The closure can be called after the function returns -> Option A

4. Quick Check:

   @escaping means delayed closure call [OK]

Hint: Escaping closures run later, not immediately [OK]

Common Mistakes:

• Thinking @escaping closures run immediately
• Confusing @escaping with synchronous execution
• Believing @escaping closures cannot capture variables

2. Which of the following is the correct syntax to declare a function parameter as an escaping closure in Swift?

easy

A. func fetchData(completion: () -> Void) {}

B. func fetchData(completion: escaping () -> Void) {}

C. func fetchData(@escaping completion: () -> Void) {}

D. func fetchData(completion: @escaping () -> Void) {}

Solution

1. Step 1: Identify correct placement of @escaping

   The @escaping keyword must appear before the closure type in the parameter list.

2. Step 2: Check each option's syntax

   func fetchData(completion: @escaping () -> Void) {} correctly places @escaping before the closure type. Options A, C, and D have incorrect syntax.

3. Final Answer:

   func fetchData(completion: @escaping () -> Void) {} -> Option D

4. Quick Check:

   Correct syntax = func fetchData(completion: @escaping () -> Void) {} [OK]

Hint: Put @escaping before the closure type in parameters [OK]

Common Mistakes:

• Placing @escaping before parameter name
• Omitting @escaping for delayed closures
• Writing 'escaping' without @ symbol

3. What will be the output of the following Swift code?

func performTask(completion: @escaping () -> Void) {
    DispatchQueue.main.async {
        completion()
    }
    print("Task started")
}

performTask {
    print("Task completed")
}

medium

A. Task started

B. Task completed\nTask started

C. Task started\nTask completed

D. Task completed

Solution

1. Step 1: Understand async dispatch behavior

   The closure passed to DispatchQueue.main.async runs later, after the current function finishes.

2. Step 2: Trace print statements order

   "Task started" prints immediately. Then the closure runs and prints "Task completed".

3. Final Answer:

   Task started\nTask completed -> Option C

4. Quick Check:

   Async closure runs after print [OK]

Hint: Async closures run after current code finishes [OK]

Common Mistakes:

• Assuming closure runs before print
• Ignoring async dispatch delay
• Confusing order of print statements

4. Identify the error in this Swift function using an escaping closure:

func saveData(completion: () -> Void) {
    DispatchQueue.global().async {
        // Save operation
        completion()
    }
}

medium

A. Missing @escaping before closure parameter

B. Closure parameter should be optional

C. DispatchQueue.global() cannot be used here

D. Completion closure must return a value

Solution

1. Step 1: Analyze closure usage inside async block

   The closure is called asynchronously after the function returns, so it must be marked @escaping.

2. Step 2: Check function parameter declaration

   The parameter lacks @escaping, causing a compile error.

3. Final Answer:

   Missing @escaping before closure parameter -> Option A

4. Quick Check:

   Async closure needs @escaping [OK]

Hint: Async closure parameters must be @escaping [OK]

Common Mistakes:

• Forgetting @escaping for async closures
• Assuming closure is synchronous by default
• Adding unnecessary optional to closure

5. You want to store a closure to call later after a network request finishes. Which is the correct way to declare and use this escaping closure in Swift?

class NetworkManager {
    var completionHandler: (() -> Void)?

    func requestData(completion: ???) {
        self.completionHandler = completion
        // Simulate network delay
        DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
            self.completionHandler?()
        }
    }
}

hard

A. completion: () -> Void

B. completion: @escaping () -> Void

C. completion: @autoclosure () -> Void

D. completion: @escaping @autoclosure () -> Void

Solution

1. Step 1: Understand closure storage and delayed call

   The closure is saved in a property and called later asynchronously, so it must be @escaping.

2. Step 2: Evaluate options for closure parameter

   Only completion: @escaping () -> Void correctly marks the closure as @escaping. Options A, B, and D are incorrect or unnecessary here.

3. Final Answer:

   completion: @escaping () -> Void -> Option B

4. Quick Check:

   Stored closures must be @escaping [OK]

Hint: Store closures? Use @escaping keyword [OK]

Common Mistakes:

• Omitting @escaping when storing closures
• Using @autoclosure unnecessarily
• Marking closure without @escaping for delayed call