Async functions in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What will this SwiftUI view display after 2 seconds?

Consider this SwiftUI view using an async function to fetch data:

struct ContentView: View {
  @State private var message = "Loading..."

  var body: some View {
    Text(message)
      .task {
        message = await fetchMessage()
      }
  }

  func fetchMessage() async -> String {
    try? await Task.sleep(nanoseconds: 2_000_000_000)
    return "Hello, async!"
  }
}

What text will be shown on screen after 2 seconds?

iOS Swift

struct ContentView: View {
  @State private var message = "Loading..."

  var body: some View {
    Text(message)
      .task {
        message = await fetchMessage()
      }
  }

  func fetchMessage() async -> String {
    try? await Task.sleep(nanoseconds: 2_000_000_000)
    return "Hello, async!"
  }
}

A The app crashes due to missing await

B "Hello, async!" replaces "Loading..." after 2 seconds

C "Loading..." remains forever

D "Loading..." changes to empty string after 2 seconds

💡 Hint

Think about what the .task modifier does and how await pauses the function.

The .task modifier runs the async code when the view appears. The await fetchMessage() waits 2 seconds, then updates message. This triggers the view to show "Hello, async!".

❓ lifecycle

intermediate

What happens if you call an async function without await in Swift?

Given this code snippet:

func loadData() async {
  print("Start loading")
  try? await Task.sleep(nanoseconds: 1_000_000_000)
  print("Finished loading")
}

func example() {
  loadData()
  print("After loadData call")
}

What is the order of printed lines when example() is called?

iOS Swift

func loadData() async {
  print("Start loading")
  try? await Task.sleep(nanoseconds: 1_000_000_000)
  print("Finished loading")
}

func example() {
  loadData()
  print("After loadData call")
}

A Start loading\nFinished loading\nAfter loadData call

B Compilation error: missing await

C Start loading\nAfter loadData call\nFinished loading

D After loadData call\nStart loading\nFinished loading

💡 Hint

Remember that calling an async function without await starts it but does not wait for it to finish.

Calling loadData() without await starts the async function but does not pause example(). So "Start loading" prints first, then "After loadData call" immediately, and finally "Finished loading" after 1 second.

📝 Syntax

advanced

Which option correctly defines an async function that returns an Int after delay?

Choose the correct Swift function definition that waits 1 second and returns 42 asynchronously.

A

func getNumber() async -> Int {
  try? await Task.sleep(nanoseconds: 1_000_000_000)
  return 42
}

B

async func getNumber() -> Int {
  try? await Task.sleep(nanoseconds: 1_000_000_000)
  return 42
}

C

func getNumber() -> async Int {
  try? await Task.sleep(nanoseconds: 1_000_000_000)
  return 42
}

D

func async getNumber() -> Int {
  try? await Task.sleep(nanoseconds: 1_000_000_000)
  return 42
}

💡 Hint

In Swift, the async keyword goes after the function parentheses.

The correct syntax is func name() async -> ReturnType. Options A, B, and C misuse the placement of async, causing syntax errors.

🔧 Debug

advanced

Why does this async function cause a runtime error?

Analyze this code snippet:

func fetchData() async -> String {
  DispatchQueue.global().async {
    print("Fetching data")
  }
  return "Done"
}

When calling await fetchData(), why might this cause unexpected behavior?

iOS Swift

func fetchData() async -> String {
  DispatchQueue.global().async {
    print("Fetching data")
  }
  return "Done"
}

A The function causes a compile-time error because DispatchQueue cannot be used in async functions

B The function throws a runtime exception due to missing await

C The function blocks the main thread indefinitely

D The function returns immediately before the async block finishes, causing race conditions

💡 Hint

Think about how DispatchQueue.global().async works compared to Swift concurrency.

The DispatchQueue.global().async runs code asynchronously but does not suspend the async function. So fetchData() returns "Done" immediately, while the print happens later. This can cause race conditions if the caller expects the work to be done.

🧠 Conceptual

expert

What is the main advantage of Swift async/await over completion handlers?

Choose the best explanation for why Swift introduced async/await instead of using completion handlers for asynchronous code.

A Async/await makes asynchronous code look and behave like synchronous code, improving readability and reducing callback nesting

B Async/await runs all code on the main thread, improving UI responsiveness

C Async/await eliminates the need for error handling in asynchronous code

D Async/await automatically parallelizes all asynchronous tasks without developer control

💡 Hint

Think about how code looks and feels when using async/await compared to nested callbacks.

Async/await allows writing asynchronous code in a linear, easy-to-read style, avoiding deeply nested completion handlers (callback hell). It does not force main thread execution, remove error handling, or automatically parallelize tasks.