Escaping closures (@escaping) in Swift - Mini Project: Build & Apply

Using @escaping Closures in Swift

📖 Scenario: Imagine you are building a simple app that fetches user data asynchronously. You want to practice how to use @escaping closures in Swift to handle the data after the fetch completes.

🎯 Goal: Build a Swift program that defines a function with an @escaping closure parameter, simulates an asynchronous fetch, and then calls the closure with the fetched data.

📋 What You'll Learn

Create a function called fetchUserData that takes an @escaping closure parameter named completion.

The completion closure should accept a String parameter representing user data.

Inside fetchUserData, simulate a delay using DispatchQueue.main.asyncAfter to mimic asynchronous fetching.

Call the completion closure inside the async block with the string "User data loaded".

Call fetchUserData and print the result inside the closure.

💡 Why This Matters

🌍 Real World

Escaping closures are used in real apps to handle asynchronous tasks like network requests, animations, or user interactions that complete later.

💼 Career

Understanding @escaping closures is essential for Swift developers working on iOS apps that fetch data from servers or perform delayed actions.

1

Create the fetchUserData function with an @escaping closure parameter

Write a function called fetchUserData that takes one parameter named completion. This parameter should be a closure marked with @escaping that accepts a String and returns Void. Inside the function, leave the body empty for now.

Swift

func fetchUserData(completion: @escaping (String) -> Void) {
    // Your code here
}

Hint

Remember to mark the closure parameter with @escaping because it will be called after the function returns.

2

Add asynchronous simulation inside fetchUserData

Inside the fetchUserData function, use DispatchQueue.main.asyncAfter with a delay of 1 second to simulate asynchronous work. Inside the async block, call the completion closure with the string "User data loaded".

Swift

func fetchUserData(completion: @escaping (String) -> Void) {
    // Simulate async delay
    // Your code here
}

Hint

Use DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) to delay the closure call by 1 second.

3

Call fetchUserData and handle the result

After the fetchUserData function, write a call to fetchUserData passing a closure that takes one parameter named data of type String. Inside the closure, print the data.

Swift

func fetchUserData(completion: @escaping (String) -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
        completion("User data loaded")
    }
}

// Call fetchUserData and print the data
// Your code here

Hint

Call fetchUserData and provide a closure that prints the received data.

4

Run the program and see the output

Run the program to see the printed output from the closure after the simulated delay.

Swift

func fetchUserData(completion: @escaping (String) -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
        completion("User data loaded")
    }
}

fetchUserData { data in
    print(data)
}

// Run the program to see the output

Hint

Wait one second after running to see the output printed.

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