GET request with async/await in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What is the output of this Swift async GET request code?

Consider this Swift code that fetches JSON data asynchronously. What will be printed if the request succeeds and the JSON contains {"message": "Hello"}?

iOS Swift

import Foundation

func fetchMessage() async {
  guard let url = URL(string: "https://example.com/api/message") else { return }
  do {
    let (data, _) = try await URLSession.shared.data(from: url)
    if let json = try? JSONSerialization.jsonObject(with: data) as? [String: String],
       let message = json["message"] {
      print(message)
    } else {
      print("No message found")
    }
  } catch {
    print("Request failed")
  }
}

Task {
  await fetchMessage()
}

A Request failed

B No message found

C Hello

D Compilation error

💡 Hint

Look at how the JSON is parsed and the key accessed.

The code fetches data from the URL, parses it as JSON dictionary, then prints the value for key "message". Since the JSON contains {"message": "Hello"}, it prints "Hello".

❓ lifecycle

intermediate

When is the async GET request executed in this SwiftUI view?

Given this SwiftUI view, when does the fetchData() async function run?

iOS Swift

import SwiftUI

struct ContentView: View {
  @State private var text = ""

  var body: some View {
    Text(text)
      .task {
        await fetchData()
      }
  }

  func fetchData() async {
    // async GET request code here
    text = "Data loaded"
  }
}

A Immediately when the app launches

B When the view appears on screen

C Only when the user taps the Text

D When the view disappears

💡 Hint

The .task modifier runs code related to the view's lifecycle.

The .task modifier runs its async code when the view appears on screen, so fetchData() runs then.

🔧 Debug

advanced

What error does this async GET request code produce?

Identify the error in this Swift async GET request code snippet.

iOS Swift

func loadData() async {
  let url = URL(string: "https://example.com/data")!
  let (data, response) = try await URLSession.shared.data(from: url)
  print(String(data: data, encoding: .utf8) ?? "No data")
}

A Missing await keyword before URLSession.shared.data call

B Missing try keyword before URLSession.shared.data call

C No error, code runs fine

D URL is optional and not unwrapped safely

💡 Hint

Check how async functions are called with await.

URLSession.shared.data(from:) is async and must be called with await. Missing await causes a compile error.

🧠 Conceptual

advanced

Which statement about async GET requests in Swift is true?

Choose the correct statement about using async/await for GET requests in Swift.

A Async/await requires manually creating completion handlers

B Async/await can only be used with POST requests

C Async/await blocks the main thread until the request finishes

D Async/await allows writing asynchronous code that looks like synchronous code

💡 Hint

Think about how async/await changes code style.

Async/await lets you write asynchronous code in a clear, linear style without callbacks.

📝 Syntax

expert

What is the value of 'result' after this Swift async GET request code runs?

Given this code snippet, what will be the value of 'result' after execution?

iOS Swift

import Foundation

func fetchNumber() async throws -> Int {
  let url = URL(string: "https://example.com/number")!
  let (data, _) = try await URLSession.shared.data(from: url)
  let numberString = String(data: data, encoding: .utf8) ?? "0"
  return Int(numberString) ?? 0
}

var result = 0

Task {
  do {
    result = try await fetchNumber()
  } catch {
    result = -1
  }
}

A All of the above depending on server response

B 0 if the server returns invalid data

C 0 if the server returns empty data

D 42 if the server returns "42" as plain text

💡 Hint

Consider how the code handles different server responses and errors.

The code returns the integer parsed from server data, or 0 if parsing fails, or -1 if the request throws an error. So result depends on server response.

Practice

1. What does the async keyword indicate in a Swift function that performs a GET request?

easy

A. The function is synchronous and blocks the main thread.

B. The function runs asynchronously and can be awaited.

C. The function automatically retries on failure.

D. The function only works with POST requests.

Solution

1. Step 1: Understand async keyword meaning

   The async keyword means the function runs asynchronously, allowing other code to run while waiting.

2. Step 2: Connect async with await usage

   Functions marked async can be called with await to pause until the result is ready without blocking.

3. Final Answer:

   The function runs asynchronously and can be awaited. -> Option B

4. Quick Check:

   async means asynchronous function [OK]

Hint: async means function can be paused with await [OK]

Common Mistakes:

• Thinking async means synchronous/blocking
• Confusing async with retry logic
• Assuming async only applies to POST requests

2. Which of the following is the correct syntax to perform a GET request using async/await in Swift?

easy

A. let (data, _) = try await URLSession.shared.data(from: url)

B. let data = URLSession.shared.dataTask(with: url)

C. let data = await URLSession.shared.data(from: url)

D. let (data, response) = URLSession.shared.data(from: url)

Solution

1. Step 1: Identify correct async/await syntax

   The correct syntax uses try await with URLSession.shared.data(from:) to get data and response.

2. Step 2: Check tuple unpacking

   The method returns a tuple of (Data, URLResponse), so unpacking with (data, _) is correct if response is unused.

3. Final Answer:

   let (data, _) = try await URLSession.shared.data(from: url) -> Option A

4. Quick Check:

   Use try await with data(from:) [OK]

Hint: Use try await with data(from:) and unpack tuple [OK]

Common Mistakes:

• Omitting try keyword
• Using dataTask without await
• Not unpacking the returned tuple

3. Given the code below, what will be printed if the GET request succeeds?

func fetchData() async {
  let url = URL(string: "https://example.com/data.json")!
  do {
    let (data, _) = try await URLSession.shared.data(from: url)
    print("Data length: \(data.count)")
  } catch {
    print("Failed to fetch")
  }
}

medium

A. Syntax error

B. Failed to fetch

C. Data length: 0

D. Data length: [number of bytes in data]

Solution

1. Step 1: Analyze successful GET request

   If the request succeeds, try await returns data and response without throwing an error.

2. Step 2: Understand print statement output

   The code prints the length of the received data in bytes, so output is "Data length: [number]".

3. Final Answer:

   Data length: [number of bytes in data] -> Option D

4. Quick Check:

   Success prints data length [OK]

Hint: Success prints data length, failure prints error [OK]

Common Mistakes:

• Assuming print shows raw data
• Confusing catch block output
• Expecting zero length on success

4. Identify the error in this Swift async GET request code:

func load() async {
  let url = URL(string: "https://api.example.com")!
  let (data, response) = URLSession.shared.data(from: url)
  print(String(data: data, encoding: .utf8) ?? "No data")
}

medium

A. Incorrect print statement syntax

B. URL is invalid

C. Missing await keyword before URLSession.shared.data(from: url)

D. Missing try keyword before URLSession.shared.data(from: url)

Solution

1. Step 1: Check async call usage

   The method data(from:) is async and must be awaited with await.

2. Step 2: Confirm missing await keyword

   The code calls URLSession.shared.data(from: url) without await, causing a compile error.

3. Final Answer:

   Missing await keyword before URLSession.shared.data(from: url) -> Option C

4. Quick Check:

   Async calls require await [OK]

Hint: Async calls always need await keyword [OK]

Common Mistakes:

• Forgetting await on async calls
• Assuming try is optional
• Misreading URL validity

5. You want to fetch JSON data from a URL and decode it into a Swift struct using async/await. Which code snippet correctly performs the GET request and decodes the data?

struct User: Decodable {
  let id: Int
  let name: String
}

func fetchUser() async throws -> User {
  let url = URL(string: "https://api.example.com/user")!
  // Which code goes here?
}

hard

A. let (data, _) = try await URLSession.shared.data(from: url)
return try JSONDecoder().decode(User.self, from: data)

B. let data = try URLSession.shared.data(from: url)
return JSONDecoder().decode(User.self, from: data)

C. let (data, _) = URLSession.shared.data(from: url)
return try JSONDecoder().decode(User.self, from: data)

D. let (data, _) = try await URLSession.shared.dataTask(with: url)
return try JSONDecoder().decode(User.self, from: data)

Solution

1. Step 1: Use async/await with data(from:)

   The correct async call is try await URLSession.shared.data(from: url) which returns data and response.

2. Step 2: Decode JSON data into struct

   Use JSONDecoder().decode(User.self, from: data) to convert JSON bytes into the User struct.

3. Final Answer:

   let (data, _) = try await URLSession.shared.data(from: url) return try JSONDecoder().decode(User.self, from: data) -> Option A

4. Quick Check:

   Use try await with data(from:) and decode JSON [OK]

Hint: Use try await data(from:) then decode JSON [OK]

Common Mistakes:

• Using dataTask instead of data(from:)
• Omitting await or try keywords
• Not decoding JSON properly