Swift interview questions with answer outlines

Fifteen common Swift interview questions

1. What are optionals, and how do you unwrap them safely?
2. if let versus guard let?
3. Struct versus class — when to use each?
4. What does copy-on-write mean?
5. How does ARC work?
6. What is a retain cycle, and how do weak and unowned help?
7. What are capture lists in closures?
8. Escaping versus non-escaping closures?
9. What is protocol-oriented programming?
10. What are associated types and generics?
11. How does Swift error handling work?
12. What are async/await and structured concurrency?
13. What are actors, and what problem do they solve?
14. What is @MainActor?
15. What are property wrappers?

Optionals and types

• Optionals represent a value or nil; unwrap with if let, guard let, nil-coalescing (??) or optional chaining (?.). Force unwrapping (!) crashes on nil.
• guard let exits early and keeps the unwrapped value in scope afterwards; if let scopes it to the block.
• Structs are value types — copied on assignment — making them safer for data models and thread-friendly. Classes are reference types with identity and inheritance.
• Copy-on-write: standard collections share storage until one copy is mutated, so value semantics stay cheap.

Memory management

Automatic Reference Counting frees a class instance when no strong references remain. Retain cycles occur when two objects hold strong references to each other — commonly a view controller and a closure it stores that captures self. Break them with weak references (optional, become nil when the object is freed) or unowned references (non-optional, for when the other object is guaranteed to outlive the reference). In closures, use a capture list such as [weak self] and unwrap self inside.

Protocols, generics and closures

Errors and concurrency

Functions that can fail are marked throws and called with try inside do–catch, or with try? to convert errors to nil. Swift concurrency uses async functions and await for suspension points, with structured concurrency via async let and task groups so child tasks are cancelled with their parent. Actors protect mutable state by allowing only one task at a time to access their isolated properties, preventing data races. @MainActor ensures code runs on the main thread, which UI updates require. Swift 6's strict concurrency checking turns many data-race risks into compile-time errors.

Property wrappers and SwiftUI

Property wrappers encapsulate storage logic, such as @State and @Binding in SwiftUI or @AppStorage for user defaults. Expect SwiftUI questions about view identity, state ownership (@State versus @StateObject versus @ObservedObject, or the Observation framework's @Observable) and why views should be lightweight. See iOS interview questions.

A code question to rehearse

A view controller stores a closure that refers to self, and the controller is never deallocated. Explain the retain cycle — the controller holds the closure strongly and the closure holds the controller — and fix it with a capture list such as [weak self], unwrapping self inside with guard let. Then mention how you'd confirm the fix: a deinit log or the memory graph debugger in Xcode.

Practising

Reading answers is not the same as saying them. Pick ten of the questions above and answer them aloud against a timer; a free AI interview assistant like CoPilot Interview can ask Swift questions in a mock interview and flag answers that ran long or lacked an example. Prepare to spot a retain cycle in a closure snippet and fix it — it's one of the most common code questions.

Disclosure: CoPilot Interview is our product, so weigh what we say about it accordingly. Everything else on this page applies whichever tool you use, or none.

Frequently asked questions

What are common Swift interview questions?

Optionals and unwrapping, structs versus classes, copy-on-write, ARC and retain cycles, weak versus unowned, closures and capture lists, protocols and generics, error handling, async/await, actors and property wrappers.

Struct or class in Swift?

Prefer structs for data models because value semantics avoid shared mutable state. Use classes when you need identity, inheritance or reference semantics, such as shared controllers.

How do you avoid retain cycles in Swift?

Use weak or unowned references for back-references and capture lists such as [weak self] in closures that the object stores.

What is an actor in Swift?

A reference type that protects its mutable state by allowing only one task at a time to access it, preventing data races in concurrent code.