Swift questions test the language itself: optionals, value types and modern concurrency.
Below are 48 Swift questions with the correct answer and a short explanation, grouped from fresher to experienced level. Try each one before you open the answer.
What does this Swift code print?
struct Point { var x: Int }
var a = Point(x: 1)
var b = a
b.x = 5
print(a.x, b.x)Answer: C. 1 5
Structs are value types in Swift, so 'var b = a' makes an independent copy. Changing b.x does not touch a, which prints 1 5. This is why SwiftUI models data with structs: changes are local and predictable.
Which SwiftUI container places its child views on top of each other, for example a text label over an image?
Answer: D. ZStack
ZStack layers children along the depth axis, with later children drawn on top. VStack arranges children vertically and HStack horizontally. The .overlay and .background modifiers are another common way to layer one view on another.
What does this Swift code print?
struct User: Codable {
let id: Int
let name: String
}
let json = #"{"id": 7, "name": "Sara", "age": 30}"#.data(using: .utf8)!
let user = try JSONDecoder().decode(User.self, from: json)
print(user.name)Answer: B. Sara
JSONDecoder ignores keys in the JSON that the type does not declare, so the extra age field is fine. name is a non-optional String, so print shows Sara without the Optional wrapper. Decoding fails only when a required key is missing or has the wrong type.
What happens at an await when calling an async function in Swift?
Answer: B. The function may suspend there, freeing the thread for other work, and resumes when the result is ready
await marks a possible suspension point. While the async work is in progress, the thread is free to run other code, such as drawing the UI, and the function continues later. This is why awaiting on the main actor does not freeze the app, unlike a blocking call.
What happens when you compile this code?
let price = 499 price = 549
Answer: D. A compile error: a let cannot be reassigned
let declares a constant that can be set only once. var declares a variable. Swift encourages let by default, which makes code easier to reason about and lets the compiler catch accidental changes.
user is of type User?, and User has a non-optional property city: String. What is the type of user?.city?
Answer: B. String?
Optional chaining returns nil if any link is nil, so the result is always optional, even if the property itself is not. The chain also flattens, so you get String?, not String??.
Since Swift 5.7, what does "if let token { … }" mean?
Answer: B. It unwraps token into a constant with the same name
Swift 5.7 added shorthand unwrapping: if let token is the same as if let token = token. It also works with guard let and while let, cutting repetition.
You try to create Set<Product> but get a compile error. What must Product conform to?
Answer: C. Hashable
Set and Dictionary keys need Hashable so they can be stored by hash value and compared for equality. For structs whose properties are all Hashable, adding ": Hashable" lets the compiler synthesise it.
What is the value of total after this code runs?
let prices = [100, 250, 50] let total = prices.reduce(0, +)
Answer: A. 400
reduce starts with the initial value 0 and combines each element using +. So 0 + 100 + 250 + 50 = 400. For simple sums it reads clearly and avoids a manual loop.
A struct method that changes self.count fails to compile. What keyword is missing?
Answer: D. mutating
Struct methods cannot change properties by default because structs are value types. Marking the method mutating allows it, and it can only be called on a var instance.
What does users.map(\.name) return?
Answer: A. An array of each user’s name
Key path expressions like \.name can be used where a function from the root type to the value is expected. users.map(\.name) is the same as users.map { $0.name }.
A view shown in a sheet has a "Done" button that should close it. What is the usual SwiftUI way?
Answer: C. Read @Environment(\.dismiss) and call dismiss()
The dismiss environment value closes the current presentation, such as a sheet or a pushed view in a NavigationStack. The presented view does not need a binding back to the parent for this.
ForEach(orders) { … } fails to compile for a plain struct Order. What does it need?
Answer: A. Order must be Identifiable, or pass id:
SwiftUI needs a stable identity for each element to track rows across updates. Conform to Identifiable with a unique id, or use ForEach(orders, id: \.orderID).
What does this line return?
let (data, response) = try await URLSession.shared.data(from: url)
Answer: D. A tuple of Data and URLResponse
URLSession’s async data(from:) returns (Data, URLResponse) and throws on transport errors. You should still check the HTTP status code, because a 404 or 500 is not thrown as an error.
A request to "http://api.example.com" fails with an App Transport Security error. What is the right fix?
Answer: A. Use HTTPS on the server
App Transport Security blocks insecure HTTP by default. The proper fix is HTTPS with modern TLS. Exceptions in Info.plist exist for special cases, but App Review may ask you to justify them.
An app stores the user’s refresh token in UserDefaults. Why is this a problem, and what should it use?
Answer: C. UserDefaults is a plain file; use the Keychain
UserDefaults is stored as an unencrypted property list in the app container and is included in some backups. The Keychain is built for secrets and supports access control settings.
A parent view owns an isOn Boolean. A child toggle view must read and change it. How should the child declare it?
Answer: D. @Binding var isOn: Bool
The parent owns the source of truth with @State and passes $isOn to the child. The child uses @Binding, which is a two-way reference to the parent value. If the child used @State, it would create its own copy and changes would not reach the parent.
In SwiftUI on iOS 17 or later, a view creates and owns an instance of an @Observable class. How should the view store it so the instance survives when SwiftUI re-creates the view struct?
Answer: C. With @State
SwiftUI rebuilds view structs often, so a plain property would create a new model each time. @State gives the view persistent storage that SwiftUI keeps for the life of the view, and it works with @Observable classes. @StateObject plays this role for older ObservableObject types, while @Binding is for state owned elsewhere.
What does this function require of T?
func largest<T>(_ items: [T]) -> T? where T: Comparable {
items.max()
}Answer: C. T must conform to Comparable
The where clause adds requirements on generic parameters. Because the body compares values with >, T must conform to Comparable. Calling it with a type that is not Comparable is a compile-time error.
What does calling work() print?
func work() {
defer { print("1") }
defer { print("2") }
print("3")
}Answer: D. 3, 2, 1
defer blocks run when the scope exits, in reverse order of declaration. The normal code prints 3 first, then the second defer prints 2, then the first prints 1. This is handy for cleanup such as closing files.
Why do many callback-based APIs use completion: (Result<User, Error>) -> Void?
Answer: C. It holds exactly one of success or failure, never both
A pair of optionals (User?, Error?) allows confusing states like both nil. Result forces one case, and switch makes callers handle both. With async/await, throwing functions often replace it.
What does this print after cart.count = 3?
struct Cart {
var count = 0 {
didSet { print("Changed from \(oldValue) to \(count)") }
}
}
var cart = Cart()
cart.count = 3Answer: C. Changed from 0 to 3
didSet runs after a stored property is assigned, and oldValue holds the previous value. willSet is the matching hook that runs before the change with newValue.
A property is marked private inside a struct. Where can it be accessed?
Answer: D. In the struct and its same-file extensions
Since Swift 4, private allows access within the declaration and its extensions in the same file. fileprivate opens access to the whole file, internal to the module, and public or open beyond it.
How do you call this function so that score is updated?
func addBonus(_ value: inout Int) {
value += 10
}
var score = 50Answer: D. addBonus(&score)
An inout parameter lets a function modify a caller’s variable. The call site must use & to show the value may change, and the argument must be a var. Behaviour is copy-in copy-out.
A view controller owns a table helper, and the helper holds the controller as its delegate. Why is the delegate property usually weak?
Answer: A. A strong reference both ways is a retain cycle that leaks
If both objects hold strong references to each other, neither reference count reaches zero and both leak. Declaring weak var delegate (with a class-constrained protocol) breaks the cycle.
You cancel a Task that runs a long CPU loop, but the loop keeps going. Why?
Answer: A. Cancellation is cooperative; the loop must check for it
cancel() only sets a flag. Code must check it, for example with try Task.checkCancellation() in the loop. Many system APIs, such as URLSession and Task.sleep, check it for you and throw CancellationError.
What does this loop do?
for try await line in fileURL.lines {
process(line)
}Answer: D. Reads lines one at a time, suspending as data arrives
url.lines is an AsyncSequence. for try await pulls each element when it is ready, suspending between them, so large files or streams are processed without loading everything at once.
A push notification should open Orders → Order 42 → Invoice. Which NavigationStack setup supports this cleanly?
Answer: B. Bind NavigationStack(path:) and append the routes
A path binding (an array of hashable routes or NavigationPath) makes navigation state data. Setting it to [.order(42), .invoice(42)] pushes those screens, with navigationDestination(for:) mapping each route to a view.
A view sorts 10,000 items inside body. Scrolling is janky. Why?
Answer: C. body can be evaluated often, so heavy work repeats each time
SwiftUI may call body whenever any dependency changes. Expensive work there runs on the main thread repeatedly. Compute sorted data in the model when inputs change, and keep body a cheap description.
Tapping a row should show a sheet for that specific order. Which modifier fits best?
Answer: B. .sheet(item: $selectedOrder) { order in … }
sheet(item:) presents when the optional binding is non-nil and passes the unwrapped value to the content. Setting it back to nil dismisses it. The item must be Identifiable.
After registerForRemoteNotifications(), what should the app do with the device token it receives?
Answer: B. Send it to your server each time, as it can change
APNs gives a token in didRegisterForRemoteNotificationsWithDeviceToken. It can change after restore, reinstall or other events, so send the current token to your backend whenever you receive it.
A List uses AsyncImage for 500 product photos, and images reload when rows scroll back into view. Why?
Answer: A. AsyncImage keeps no image cache of its own
AsyncImage loads through URLSession and holds the image only while that view is alive. Rows leaving the screen drop it. For long lists, use an image loader with memory and disk caching.
This view controller is never deallocated after it is dismissed. Why?
class ProfileVC: UIViewController {
var onUpdate: (() -> Void)?
override func viewDidLoad() {
super.viewDidLoad()
onUpdate = {
self.reload()
}
}
func reload() {}
}Answer: D. The VC strongly holds the closure and the closure strongly captures self, creating a retain cycle; use [weak self]
Swift uses ARC. The controller owns onUpdate, and the closure captures self strongly, so each keeps the other alive and the reference count never reaches zero. Capturing [weak self] (or unowned when lifetime is guaranteed) breaks the cycle. Xcode Memory Graph Debugger can show such cycles.
Inside a @MainActor view model method, what is the difference between starting work with Task { } and with Task.detached { }?
Answer: A. Task { } inherits the current actor (here the main actor), priority and task-local values; Task.detached inherits none of them
A plain Task is unstructured but takes its context from where it is created, so in a @MainActor method its body runs on the main actor. Task.detached starts fresh with no actor, priority or task-locals. Neither is cancelled when the method returns; you must keep a handle and cancel it yourself.
The user closes this screen before the request finishes. What happens when the completion handler runs?
final class OrderViewController: UIViewController {
func load() {
api.fetchOrder { [unowned self] result in
self.render(result)
}
}
}Answer: B. The app crashes, because unowned assumes self is still alive; use [weak self] with guard let self else { return }
unowned does not keep the object alive and does not become nil, so accessing a deallocated object traps at runtime. It is only safe when the closure can never outlive self. For network callbacks the lifetime is unknown, so [weak self] plus a guard is the safe choice.
When is the array storage actually copied, and what does this code print?
var a = [1, 2, 3] var b = a // (1) b.append(4) // (2) print(a.count, b.count)
Answer: B. At (2), because b is mutated while it still shares storage with a; it prints 3 4
Swift arrays are value types that use copy-on-write. Assignment only shares the buffer; the real copy happens on the first mutation when the buffer is not uniquely referenced. The result still behaves like a copy, so a has 3 items and b has 4.
What does this code print?
var count = 1
let a = { print(count) }
let b = { [count] in print(count) }
count = 2
a()
b()Answer: C. 2 then 1
Closures capture variables by reference by default, so a sees the updated count of 2. A capture list [count] copies the value when the closure is created, so b keeps 1.
The JSON has "image_url". The struct property is imageURL: String?, and the decoder uses .convertFromSnakeCase. Why is imageURL always nil?
Answer: A. The key becomes "imageUrl", which is not imageURL
convertFromSnakeCase turns image_url into imageUrl, capitalising only the first letter after each underscore. imageURL does not match, and because it is optional, decoding silently gives nil. Rename to imageUrl or add CodingKeys.
The server sends "2026-10-16T10:30:00.123Z". JSONDecoder uses .iso8601 and throws a dataCorrupted error. Why?
Answer: C. .iso8601 does not accept fractional seconds
The built-in .iso8601 strategy expects no fractional seconds. Use .custom with an ISO8601DateFormatter that includes .withFractionalSeconds, or a Date.ISO8601FormatStyle that includes them, or ask the API for a consistent format.
In Swift 6 language mode, sending a mutable non-Sendable class instance from the main actor into a detached Task gives an error. Why?
Answer: A. Both sides could mutate it at once, a data race
Values crossing isolation boundaries must be Sendable, or proven safe to transfer. A mutable class shared by two concurrent contexts could race. Fixes include making it a struct, an actor, immutable and final Sendable, or not sharing it after sending.
After switching to the Swift 6 language mode, this line reports that the variable is not concurrency-safe. What is a proper fix?
var imageCache: [URL: Data] = [:]
Answer: D. Isolate it to @MainActor or move it into an actor
Global and static mutable variables are shared state that any thread could touch. Swift 6 rejects them unless they are isolated to a global actor, protected inside an actor, or made immutable let constants of Sendable type.
An actor has let id: UUID and a computed property label built only from id. Why mark label nonisolated?
Answer: C. It reads no mutable state, so no await is needed
nonisolated members are not protected by the actor, so they cannot read mutable isolated state. Computing from immutable Sendable lets is safe, and making it nonisolated allows synchronous calls, for example to satisfy a protocol like Hashable.
A callback API sometimes calls its completion twice. It is wrapped with withCheckedThrowingContinuation. What happens on the second resume?
Answer: B. A runtime trap: resume must happen exactly once
Checked continuations detect misuse: resuming twice traps, and never resuming logs a leak and leaves the caller suspended forever. Guard against double callbacks, for example with a flag, before resuming.
An async function calls DispatchSemaphore.wait() to wait for another async task to signal. Under load the app hangs. Why?
Answer: D. It blocks a pool thread that other tasks need
Swift concurrency runs tasks on a small cooperative thread pool and assumes tasks never block. A blocked thread cannot run the task that would signal, which can deadlock. Use await on the other task, or async primitives like continuations.
Why can you write plain if/else and several views in a row inside a SwiftUI body without return or arrays?
Answer: C. @ViewBuilder, a result builder, combines them into one view
Result builders transform a block of statements into calls such as buildBlock and buildEither. @ViewBuilder uses this to combine child views and conditionals into one typed view, such as _ConditionalContent.
In a UITableView, each cell starts an image download in cellForRowAt. While scrolling fast, some rows show another row’s image. What fixes it?
Answer: D. Reset and cancel in prepareForReuse; check the row
Cells are reused, so a slow download from an earlier row can finish after the cell shows a new row. Reset the image and cancel the task in prepareForReuse, and verify the cell still represents the same item before setting the image.
Universal links for example.com open Safari instead of the app. The apple-app-site-association file is reachable only through a redirect to www.example.com. What is wrong?
Answer: D. The AASA file must be served over HTTPS with no redirect
iOS fetches /.well-known/apple-app-site-association for each associated domain over HTTPS and does not follow redirects. Serve it directly with the right appIDs, and list each domain in the Associated Domains entitlement.
An import of 50,000 records freezes the UI because it uses the main view’s ModelContext. What is the recommended approach?
Answer: C. Do the import in a @ModelActor with its own context
ModelContext is not Sendable and the main context is tied to the main actor. A @ModelActor creates its own context from the ModelContainer on a background executor; saved changes then reach the main context.
Take a 15-question Swift MCQ test with a score at the end, or practise the full Swift question bank and earn points on the leaderboard.