Over 165 Swift iOS Interview Questions

Mastering the framework (SwiftUI or UIKit) is only half the battle. In high-level technical interviews, recruiters need to know if you understand the language underneath. Do you know how Swift manages memory? Do you understand the real difference between struct and class? have you mastered modern concurrency?

Here is the definitive collection of Swift questions, divided by difficulty level. We cover the 165 essential questions.

🟢 Level 1: Basic Concepts and Syntax

These questions are the initial filter. If you fail here, the interview usually ends.

1. What is Swift? It is a multi-paradigm, strongly typed, compiled, open-source programming language developed by Apple. It is designed to be safe, fast, and expressive.
2. What is the difference between var and let? var declares mutable variables (their value can change). let declares constants (immutable once assigned).
3. What is Type Inference? The Swift compiler’s ability to deduce the data type of a variable based on its initial value, without needing to write it explicitly.
4. What is an Optional in Swift? It is a type that represents the possibility of a variable having a value or having nothing (nil). It is defined with ?.
5. What is Type Safety? Swift forces you to be clear about data types. You cannot accidentally assign a String to an Intvariable; the compiler will throw an error.
6. What is a Tuple? A group of values combined into a single compound value. They can be of different types. Ex: (404, "Not Found").
7. What is a typealias? It allows you to give an alternative name to an existing type to make the code more readable. Ex: typealias AudioSample = UInt16.
8. What is the difference between Float and Double? Float is a 32-bit floating-point number (less precision). Double is 64-bit (higher precision and the default in Swift).
9. What are Generics? Flexible and reusable code that can work with any data type, subject to requirements you define (like Array<Element>).
10. What are Any and AnyObject? Any can represent an instance of any type (functions, structs, classes). AnyObject can only represent instances of classes.

🔵 Level 2: Collections and Control Flow

11. Main difference between Array and Set? An Array is ordered and allows duplicates. A Set is unordered and guarantees that every element is unique.
12. What protocol must Set elements or Dictionary keys conform to? They must conform to Hashable.
13. What is a Dictionary? An unordered collection of key-value associations.
14. What does the guard statement do? It is used to transfer control out of a scope if a condition is not met. It is ideal for “early exit” and avoiding the “pyramid of doom” indentation.
15. Difference between if let and guard let? if let unwraps the optional only inside its {} block. guard let unwraps the optional for the rest of the current scope, and requires an else { return/throw } if it fails.
16. What does it mean that switch in Swift must be exhaustive? It must cover all possible cases of the evaluated value, or include a default case.
17. What is the “Range Operator” ... and ..<? ... is a closed range (includes the end value). ..< is a half-open range (excludes the end value).
18. How do you iterate over a dictionary? Using for (key, value) in dictionary.
19. What is stride? A function to create numeric sequences with specific steps (e.g., from 0 to 10 by 2).
20. What does break do in a loop? Terminates the execution of the loop immediately.
21. What does continue do in a loop? Skips the current iteration and moves to the next one.

🟠 Level 3: Structs vs Classes

The most asked topic in Swift history.

22. What is the fundamental difference between struct and class? structs are Value Types. classes are Reference Types.
23. Explain “Value Type”. When you assign or pass a struct, a copy of the data is created. Modifying the copy does not affect the original.
24. Explain “Reference Type”. When you assign or pass a class, a reference (pointer) to the same instance in memory is passed. Modifying one affects all references.
25. What do Classes have that Structs don’t? Inheritance, deinitializers (deinit), identity (===), and reference counting (ARC).
26. What do Structs have that Classes don’t? Automatic memberwise init and they are lighter in memory (Stack vs Heap).
27. When should you use a Struct? By default. Use it for simple data models, values that behave like primitive data, and when you don’t need shared identity.
28. What does the mutating keyword mean in a Struct? It indicates that a method within the struct is going to modify its own properties. This is necessary because structs are immutable by default.
29. Are Array and String in Swift classes or structures? They are Structures (structs).
30. What is “Copy on Write” (COW)? It is a Swift optimization for collections (like Arrays). Although they are value types, the actual copy only occurs when the data is modified, not when assigned, saving performance.

🟣 Level 4: Optionals Deep Dive

31. What is “Optional Binding”? The process of checking if an optional has a value and extracting it to a safe constant/variable (using if let or guard let).
32. What is “Optional Chaining” (?.)? Allows calling properties or methods on an optional that might be nil. If it is nil, the chain stops and returns nil; otherwise, it continues.
33. What is the “Nil Coalescing” operator (??)? Provides a default value in case the optional is nil. Ex: let name = user.name ?? "Guest".
34. What is “Force Unwrapping” (!)? Extracts the value from the optional forcibly. If it is nil, the app crashes. Should only be used if you are 100% sure.
35. What is an “Implicitly Unwrapped Optional” (Type!)? An optional that is assumed to always have a value after its first assignment. It does not require explicit unwrapping when used, but crashes if it is nil (common in @IBOutlets).
36. Can an optional contain nil as a valid value inside another optional? Yes, Double Optional (String??).

🔴 Level 5: Functions and Closures

37. What is a Closure? They are self-contained blocks of functionality that can be passed around and used in your code. Similar to lambdas in other languages.
38. What is the syntax for a “Trailing Closure”? If the last parameter of a function is a closure, you can write it outside the parentheses of the call. array.map { $0 * 2 }.
39. What do $0, $1 mean in a closure? They are shorthand argument names for the closure’s arguments.
40. What is @escaping in a closure? Indicates that the closure can be executed after the function returns (e.g., an asynchronous network call). By default, they are non-escaping.
41. What is @autoclosure? Automatically converts an expression passed as an argument into a closure. Allows writing assert(condition) instead of assert({ condition }).
42. What is a variadic function? A function that accepts zero or more values of a specific type (e.g., print(...)). It is written with ....
43. What are inout parameters? They allow a function to modify the value of a variable passed as a parameter (pass by reference).
44. Are functions first-class citizens in Swift? Yes, they can be assigned to variables, passed as arguments, and returned from other functions.
45. What is a Higher Order Function? A function that takes another function as an argument or returns one. Examples: map, filter, reduce.

⚫ Level 6: Properties and Methods

46. Difference between “Stored Property” and “Computed Property”? Stored: Stores a value in memory. Computed: Calculates the value every time it is accessed (has a getter and optionally a setter).
47. What are “Property Observers”? willSet (runs just before the value changes) and didSet (runs just after).
48. What is a lazy property? A property whose initial value is not calculated until the first time it is used. It must be a var.
49. What does static mean? Defines a property or method that belongs to the type itself, not to an instance.
50. Difference between static and class in methods? Both define type methods. static cannot be overridden in subclasses (it is final), class does allow override.
51. What is a Singleton and how is it created in Swift? A pattern where only one instance of a class exists. static let shared = MyClass(), with a private init().

⚪ Level 7: Protocols and Extensions (POP)

Swift is the first Protocol-Oriented language.

52. What is a Protocol? A “contract” that defines a blueprint of methods, properties, and requirements that a class, structure, or enumeration must conform to.
53. What is an Extension? Allows adding functionality to an existing type (even if you don’t have the original source code), such as new methods or computed properties (not stored).
54. What are “Protocol Extensions”? They allow providing a default implementation for protocol methods. It is the basis of Protocol Oriented Programming.
55. What is an “Associated Type” in a protocol? A placeholder for a type that will be defined when the protocol is adopted. associatedtype is used.
56. Can an extension add stored properties? No, only computed ones.
57. What does Codable mean? It is a typealias for the Encodable and Decodable protocols. It allows converting objects to/from JSON or other formats.
58. What is Equatable? A protocol that allows comparing two instances using ==.
59. What is Hashable? A protocol that allows an instance to generate an integer hash value, necessary to be a key in Dictionaries or an element in Sets.
60. What is CaseIterable in enums? Automatically generates a collection of all cases of the enum (allCases).

🟤 Level 8: Memory Management (ARC)

Crucial for avoiding Memory Leaks.

61. What is ARC? Automatic Reference Counting. It is Swift’s system for tracking and managing the app’s memory usage, releasing class instances that are no longer used.
62. What is a “Retain Cycle”? When two instances point to each other with strong references, preventing ARC from releasing them, causing memory leaks.
63. Difference between strong, weak, and unowned?
    • strong: Increments the reference count (default).
    • weak: Does not increment the count. Must be optional (var?) because it can become nil.
    • unowned: Does not increment the count. Is not optional (assumes it will always have a value). If the object dies and you access it, it crashes.
64. When to use unowned instead of weak? When the other instance has the same lifespan or longer (e.g., Customer and Credit Card; the card does not exist without a customer).
65. What is a “Capture List” in closures [weak self]? Defines how the closure captures external variables. [weak self]avoids retain cycles if the closure is owned by self and self is used inside the closure.
66. Do Structs use ARC? No, because they are Value Types (managed in the Stack, not the Heap). ARC is only for classes.

🌓 Level 9: Error Handling

67. What protocol must a type conform to in order to be thrown as an error? Error protocol.
68. What do try, try?, and try! mean?
    • try: Throws the error if it occurs (must be in do-catch or throwing function).
    • try?: If it fails, returns nil (ignores the error).
    • try!: If it fails, crashes the app (you assert it won’t fail).
69. What does defer do? Defines a block of code that will execute just before the current scope ends (doesn’t matter if it ends via return, error, or normal finish). Useful for closing files or freeing resources.
70. What is the Result type? An enum with two cases: .success(Value) and .failure(Error). Widely used in completion closures.

✨ Level 10: Modern Concurrency (Swift 5.5+)

71. What is async/await? Syntax for writing asynchronous code that looks synchronous, eliminating “Callback Hell”.
72. What is an Actor? A reference type (like a class) that protects its mutable state by ensuring only one thread accesses its data at a time. It is “Thread Safe” by default.
73. What is @MainActor? An attribute ensuring that the function or class always runs on the Main Thread, crucial for UI updates.
74. What is a Task? A unit of asynchronous work. Allows calling async functions from a synchronous context.
75. What is TaskGroup? Allows creating multiple asynchronous tasks dynamically and waiting for all of them to finish (structured concurrency).

🧩 Level 11: Access Control

76. What are the access levels in Swift (from most restrictive to most open)? private, fileprivate, internal (default), public, open.
77. Difference between private and fileprivate? private: Only visible within the declaration scope (e.g., inside the class).fileprivate: Visible throughout the current .swift file.
78. Difference between public and open? Both allow access from other modules. open allows the class to be subclassedand its methods overridden outside the module. public does not.

🛠 Level 12: Advanced and Runtime

79. What is “Method Dispatch”? The mechanism the program uses to know which operation to execute.
80. Types of Dispatch in Swift? Static Dispatch (Direct, very fast, Structs), Table Dispatch (Classes), Message Dispatch (Objective-C).
81. How do you achieve Static Dispatch in a class? Using final or private, which prevents overriding.
82. What is KVO (Key-Value Observing)? A pattern (inherited from Obj-C) to notify objects when properties of other objects change. Requires inheriting from NSObject and using @objc dynamic.
83. What is some (Opaque Types)? Indicates that you return a specific type that conforms to a protocol, but hide exactly which one it is.
84. What is associatedtype? Defines a generic type inside a protocol.
85. What are “Property Wrappers”? Types that wrap a property to add logic on read/write (e.g., @State, @Published, @UserDefault).
86. What does final do? Prevents a class from being inherited or a method from being overridden. Improves performance.
87. What are “Raw Values” in an Enum? Pre-populated values (like Int or String) assigned to each enum case. Must be unique.
88. What are “Associated Values” in an Enum? Values attached to an enum case at the time of instance creation (can be different each time).
89. What is autoreleasepool? A block that allows releasing temporary objects created in intensive loops immediately, reducing memory peaks.
90. How do you compare two tuples? The == operator works automatically if the elements inside the tuple are Equatable (up to 6 elements).

🧠 Level 13: Swift Functional Programming

91. What does map do? Transforms each element of a collection using a function and returns a new array.
92. What does compactMap do? Same as map, but removes results that are nil and unwraps the remaining optionals.
93. What does flatMap do? Flattens a collection of collections (e.g., [[1,2], [3,4]] -> [1,2,3,4]).
94. What does reduce do? Combines all elements of a collection into a single value (e.g., sum all numbers).
95. What does filter do? Returns an array with only the elements that meet a condition.
96. What does zip do? Combines two sequences into a sequence of pairs (tuples).
97. What is “Currying” (although Swift no longer supports it syntactically by default)? Converting a function with multiple arguments into a sequence of functions with a single argument.
98. Is Swift a functional language? Not purely, but it has strong support for functional programming (first-class functions, immutability, HOFs).

🔍 Level 14: Debugging and Miscellaneous

99. What is #if DEBUG? A conditional compilation directive to execute code only in development mode.
100. What is the difference between Self (capital) and self (lowercase)? self: the current instance. Self: the type of the current instance (useful in protocols).

🧬 Level 15: Advanced Generics and Existential Types

This is the most common barrier between a Mid-level and a Senior developer.

101. What is “Type Erasure” and why do we need it? It is a pattern for working with protocols that have associatedtype. Since those protocols cannot be used as direct variable types (historically), they are wrapped in a generic class/struct (e.g., AnyPublisher, AnyView) that “hides” the underlying concrete type.
102. What is the difference between some Protocol and any Protocol (Swift 5.7+)? some (Opaque Type) guarantees that the type is fixed and concrete, but hidden from the caller (static performance). any (Existential Type) is a dynamic box that can hold any type that conforms to the protocol, allowing the value to change at runtime (has a performance cost).
103. What are “Opaque Return Types”? Functions that return some View (or some Protocol). They allow the compiler to know the exact type for optimizations, but force the developer to always return the same concrete type within the function.
104. What does the where constraint mean in generics? It allows defining additional requirements for generic types. Ex: func compare<T>(a: T, b: T) where T: Equatable.
105. What is “Conditional Conformance”? It allows a generic type to conform to a protocol only if its internal types also conform. Ex: Array is Codable only if its elements (Element) are Codable.
106. What is a “Primary Associated Type” in protocols? Lightweight syntax (Protocol<Type>) introduced in Swift 5.7 to constrain associated types. Ex: func process(list: some Collection<String>).
107. Why couldn’t protocols with Self or associatedtype be used as types until recently? Because the compiler couldn’t know how much memory space to reserve for them without knowing the concrete type. Now any solves this by creating an “existential container” box.
108. What is covariance and contravariance in Swift? It refers to how subtypes relate in complex types. Swift is generally invariant in generics (an Array<Cat> is not an Array<Animal>), but functions have special subtyping rules for their return types and arguments.

🛠 Level 16: Pointers and “Unsafe” Swift

Swift is safe, but it allows you to be dangerous if you need to interact with C or optimize to the max.

109. What does “Unsafe” mean in Swift (e.g., UnsafePointer)? It means Swift disables its safety checks (like array bounds checking or automatic memory management). If you make a mistake here, you cause a crash or memory corruption.
110. Difference between UnsafePointer, UnsafeMutablePointer, UnsafeRawPointer, and UnsafeBufferPointer.
     • Pointer: Read-only, typed (UnsafePointer<Int>).
     • Mutable: Read and write.
     • Raw: Untyped (pure bytes, void* in C). It doesn’t know what data type is there, it only sees memory.
     • Buffer: Works like an array (has count) over a continuous memory region.
111. What is withUnsafeBytes? A method to temporarily access the byte representation of data (like an Array or Data) safely within a closure.
112. What is “Memory Layout” (alignment, size, and stride)?
     • size: Actual space the data occupies.
     • alignment: Memory rule (e.g., must start at a multiple of 8).
     • stride: Distance between the start of one element and the next in an array (includes padding).
113. How do you convert a Swift String to a C char *? Swift does automatic bridging in interoperability, or you can use string.withCString { ptr in ... }.
114. What is a “Dangling Pointer”? A pointer that points to a memory address where the object has already been deallocated.

⚙️ Level 17: Compiler and Performance

115. What are the main phases of Swift compilation? Parsing (Source code) -> AST (Abstract Syntax Tree) -> SIL (Swift Intermediate Language) -> LLVM IR -> Machine Code.
116. What is SIL (Swift Intermediate Language)? An intermediate language specific to Swift where high-level optimizations occur (like ARC optimization, devirtualization, generics specialization) before passing to LLVM.
117. What is “Whole Module Optimization” (WMO)? A compilation mode where the compiler analyzes the entire module at once (instead of file-by-file), allowing better optimizations like aggressive inlining and dead code elimination.
118. What is “Method Swizzling”? An Objective-C runtime technique (possible in Swift by inheriting from NSObject) to change the implementation of a method at runtime.
119. What is “Dynamic Dispatch” vs “Static Dispatch” vs “Witness Table”?
     • Static: The function address is known at compile time (fast).
     • Dynamic (V-Table): Looked up in a table at runtime (Classes).
     • Witness Table: Used for Protocols.
     • Message Dispatch: Obj-C Runtime (slower, but very flexible).
120. How does Swift reduce the cost of ARC? The compiler (in the SIL phase) analyzes the code and removes redundant calls to retain and release.
121. What is “Generic Specialization”? The compiler creates specific versions of a generic function for concrete types (e.g., creates a version of sum<Int> and another of sum<Float>) to avoid abstraction overhead.
122. What attribute do you use to force a function to be “inlined”? @inline(__always).

🍏 Level 18: Interoperability (Obj-C and C++)

123. What does the @objc modifier do? Exposes a Swift method or property to the Objective-C runtime.
124. What does dynamic mean in Swift? Forces the method to use Objective-C “Message Dispatch” instead of Swift’s static or virtual table dispatch. Necessary for KVO and Swizzling.
125. Can a Swift struct be used in Objective-C? No. Only classes inheriting from NSObject (or pure Swift classes with @objc that don’t use Swift-exclusive features) are visible.
126. What is a “Bridging Header”? A .h file that allows importing Objective-C headers so they are visible and usable from Swift code.
127. What is C++ Interop in Swift 5.9? The native ability to import and use C++ types directly in Swift without needing to create “wrappers” in Objective-C++.

📦 Level 19: Swift Package Manager (SPM) and Modularization

128. What is the difference between a Library and a Framework? Technically, a library is compiled code (static or dynamic). A framework is a directory structure that packages the library along with resources (images, headers).
129. Static vs Dynamic Library?
     • Static: Code is copied inside your app’s executable (increases app size, faster launch).
     • Dynamic: Code lives outside the executable and loads at launch (reduces app size, launch might be slower, allows code sharing between extensions).
130. What is Package.swift? The manifest file that defines the dependencies, targets, and products of an SPM package.
131. How do you manage resources (images/JSON) in an SPM package? Using the Resources folder and accessing via Bundle.module.

🔮 Level 20: Modern Swift (5.9, 6.0) and Macros

132. What is a Macro in Swift (#Predicate, @Model)? Code that runs at compile time to generate more Swift code, reducing boilerplate.
133. Difference between Freestanding Macro and Attached Macro?
     • Freestanding: Appear on their own (e.g., #warning("Careful")).
     • Attached: Attached to a declaration (e.g., @Observable on a class).
134. What is the “Ownership Manifesto”? A set of features to granularly control memory without ARC overhead, approaching Rust-like control.
135. What do the keywords consuming and borrowing do?
     • consuming: The function takes ownership of the value (and is responsible for destroying it).
     • borrowing: The function “borrows” the value (read access) without incrementing reference counts.
136. What is a Noncopyable Type (~Copyable)? A type (struct or enum) that cannot be copied. Useful for unique resources like file descriptors or mutexes.
137. What is “Actor Reentrancy” and what problem does it cause? An actor can suspend a function (await) and start processing another task before the first one finishes. This can change the actor’s internal state unexpectedly between the “before” and “after” of the await.

🧩 Level 21: Trick Code Questions (“Output Prediction”)

The interviewer puts this code on the whiteboard. What is your answer?

138. The Mystery of Protocol Dispatch:

protocol A { func a() }
extension A { func a() { print("A") } }
struct B: A { func a() { print("B") } }
let b = B()
let a: A = b
b.a() // What does it print?
a.a() // What does it print?

Answer: Prints “B” and “B”. Since a() is defined in the protocol requirement, it uses dynamic dispatch (Witness Table) and finds B‘s implementation.

The Mystery of the Hidden Extension:

protocol A { }
extension A { func a() { print("A") } } // Not in the protocol definition
struct B: A { func a() { print("B") } }
let a: A = B()
a.a()

Answer: Prints “A”. Since a() is not in the original protocol definition protocol A {}, static dispatch is used. The variable a is of type A, so it uses A‘s extension, ignoring B‘s.

Arrays and Closures:

var array = [1, 2, 3]
let closure = { print(array) }
array.append(4)
closure()

Answer: Prints [1, 2, 3]. Arrays are value types and the closure captures a copy of the array at the moment of closure creation (implicit capture list for value types). Note: If array were a Class, it would print 1, 2, 3, 4.

Defer Stack:

func test() {
    defer { print("1") }
    defer { print("2") }
    print("3")
}

138. Answer: “3”, “2”, “1”. defer statements execute in reverse order (like a stack) when exiting the scope.
139. Lazy var and Concurrency: Is it safe to access a lazy var property from multiple threads at once? Answer: No. lazy var is not thread-safe. If two threads access it simultaneously for the first time, the initializer might run twice or cause a crash.

📐 Level 22: Design Patterns in Swift

143. What is the “Delegate” pattern? A pattern where an object delegates responsibility or notification to another. In Swift, it is used with protocols weak var delegate: DelegateProtocol? to avoid retain cycles.
144. How do you implement the “Observer” pattern in pure Swift? Using NotificationCenter, KVO, or more modernly, @Published with Combine/SwiftUI.
145. What is “Dependency Injection” and why is it vital? Passing dependencies to an object (usually in the init) instead of the object creating them. Vital for Unit Testing with Mocks.
146. What is the “Builder” pattern? Useful for creating complex objects step-by-step. In Swift, it’s often seen functionally (e.g., URLRequest configurators).
147. What is the “Coordinator” pattern? (Widely used in iOS) Extracts navigation logic from ViewControllers, facilitating flow and screen reusability.

🏛 Level 23: Data Structures and Algorithms (Swift Context)

148. What is the complexity of array.insert(element, at: 0)? O(n), because it has to shift all remaining elements one position.
149. What is the complexity of accessing a value in a Dictionary? O(1) on average.
150. How does Dictionary work internally in Swift? It uses Linear Probing and open addressing hash tables. Requires keys to be Hashable.
151. What is ContiguousArray? A specialized version of Array that always stores its elements contiguously in memory. It is more efficient than standard Array if storing classes or if bridging to Objective-C NSArray is not needed.
152. What are the Collection protocols? Sequence -> Collection -> BidirectionalCollection -> RandomAccessCollection. Knowing which one to use is key to creating your own data structures.

🧪 Level 24: Testing

153. Difference between setUp and setUpWithError in XCTest? setUpWithError allows throwing errors. If it fails, the test marks as failed cleanly without crashing.
154. What is a “Mock” vs a “Stub”?
     • Stub: Fake object that returns predefined data (so the test runs).
     • Mock: Fake object that also verifies behavior (e.g., “was this method called exactly 1 time?”).
155. How do you test asynchronous code in old vs new XCTest? Old: XCTestExpectation and wait. New: Mark the test function as async and use await.

🏁 Level 25: Expert Miscellaneous

156. What is Never in Swift? A type indicating that a function never returns (e.g., fatalError() or a function that intentionally crashes).
157. What is Void really? It is a typealias for an empty tuple ().
158. What is reflection (Mirror) in Swift? Allows inspecting the structure of a type at runtime (listing properties, types). It is limited and slow compared to other languages, but useful for logging or custom serialization.
159. What is the @discardableResult attribute? Silences the compiler warning if you call a function that returns something but you ignore the result.
160. What is the @available attribute? Allows marking code that should only run on certain iOS/macOS versions or that is deprecated.
161. What are “KeyPaths” (\Person.name)? Safe references to a property of a type, not its value. They allow metaprogramming and elegant dynamic APIs.
162. What is @dynamicMemberLookup? Allows accessing properties of a type using dot syntax (a.b) even if those properties don’t exist at compile time, resolving them dynamically (useful for wrapping JSON or Python).
163. What is @propertyWrapper? The mechanism behind @State, @Published, etc. It allows you to encapsulate property storage logic in a reusable type.
164. How do you avoid generic code bloat in the binary? Using existential types (any) where static performance is not critical, or using @_specialize carefully.
165. What is “ABI Stability”? Achieved in Swift 5.0. It means the Swift runtime is built into the OS (iOS) and apps don’t need to include Swift libraries inside the binary, reducing app size and allowing binary compatibility between versions.