easystructs vs classes
Which statement about class instances assigned to two `let` constants is correct?
class Box { var n = 0 }
let x = Box()
let y = x
y.n = 42Swift Interview Questions (549 to practise)
Swift is Apple's language for iOS and macOS. Reference-counting behaviour and value semantics drive most of its gotchas.
Retain cycles and capture lists, struct versus class copying, optionals and forced unwraps, protocol witness dispatch, and actor isolation in structured concurrency.
- Total questions
- 549
- Easy
- 60
- Medium
- 245
- Hard
- 244
Where it shows up: iOS, iPadOS, macOS, watchOS engineering, and server-side Swift at a handful of companies.
Sample Swift questions
Twenty real Swift questions from the library, code snippet included. Nothing here is paraphrased for search engines. It is the same text a signed-in user sees.
easyif let and guard let
Can you combine an optional binding and a boolean check in one `guard`?
func check(_ n: Int?) -> String {
guard let n = n, n > 0 else { return "invalid" }
return "ok: \(n)"
}
print(check(0))easyoptionals and unwrapping
What is the result of force-unwrapping here?
let dict = ["a": 1]
let v = dict["b"]!
print(v)easystructs vs classes
A struct with a stored property is held in a `let` constant. What happens?
struct Counter { var value = 0 }
let c = Counter()
c.value = 1easyif let and guard let
What is printed by this `if let` shadowing example?
let value: Int? = 10
if let value = value {
print(value + 1)
}easyenums with associated values
Why does this enum declaration fail to compile?
enum Reading: Int {
case low(Int)
case high(Int)
}easyoptional chaining
What does calling an optional method via chaining return when the method itself returns Void?
var list: [Int]? = [1, 2, 3]
let r = list?.removeAll()
print(type(of: r))easydefer
What does the function return when called as `read("data")`?
func read(_ name: String) -> String {
var status = "opened"
defer { status = "closed" }
return status
}easyarrays dictionaries sets
What is the value of `result`?
let a: Set = [1, 2, 3]
let b: Set = [3, 4, 5]
let result = a.intersection(b)
print(result)easymap filter reduce
Given an array of optional Ints, which call produces `[1, 2, 3]` from `[1, nil, 2, nil, 3]`?
let nums: [Int?] = [1, nil, 2, nil, 3]easyarrays dictionaries sets
After this runs, what is `dict["x"]`?
var dict = ["x": 1]
dict["x", default: 0] += 10easyarrays dictionaries sets
What is the count of `s` after this code?
var s: Set = [1, 2, 3]
s.insert(2)
s.insert(4)hardstatic vs dynamic witness dispatch
Given the protocol and extension below, what does this program print, and what governs each line's dispatch?
protocol Greeter {
func hello() -> String // a protocol requirement
}
extension Greeter {
func hello() -> String { "default hello" }
func bye() -> String { "default bye" } // NOT a requirement
}
struct G: Greeter {
func hello() -> String { "G hello" }
func bye() -> String { "G bye" }
}
let g: Greeter = G()
print(g.hello())
print(g.bye())mediumassociated types
How does a primary associated type declaration like `protocol Container<Item>` change what you can write at use sites?
protocol Container<Item> {
associatedtype Item
func get() -> Item
}mediumresult builders
Given this builder using `buildPartialBlock`, what does `out` print?
@resultBuilder
struct Concat {
static func buildPartialBlock(first: String) -> String { first }
static func buildPartialBlock(accumulated: String, next: String) -> String {
accumulated + next
}
}
@Concat
func build() -> String {
"x"
"y"
"z"
}
let out = build()easynil coalescing
What does this code print?
let scores: [String: Int] = ["math": 90]
print(scores["science"] ?? -1)hardstatic vs dynamic witness dispatch
What does this program print, and what is the dispatch mechanism for the `g.describe()` call?
protocol Shape { func area() -> Int }
extension Shape {
func area() -> Int { 0 }
func describe() -> String { "Shape area \(area())" }
}
struct Square: Shape {
func area() -> Int { 9 }
func describe() -> String { "Square!" }
}
let g: Shape = Square()
print(g.describe())mediumprotocol-oriented programming
Given a protocol with a default method implementation in an extension AND a conforming type that provides its own implementation, what determines which version runs when the value is held in a variable typed as the protocol (existential)?
protocol Greeter {
func hello()
}
extension Greeter {
func hello() { print("protocol") }
func bonus() { print("protocol bonus") }
}
struct Bob: Greeter {
func hello() { print("Bob") }
func bonus() { print("Bob bonus") }
}
let g: Greeter = Bob()
g.hello()
g.bonus()mediumresult builders
What does this code print, demonstrating how `buildOptional`/`buildEither` interact with control flow in a result builder?
@resultBuilder
enum StringBuilder {
static func buildBlock(_ parts: String...) -> String { parts.joined() }
static func buildEither(first: String) -> String { first }
static func buildEither(second: String) -> String { second }
}
func make(@StringBuilder _ b: () -> String) -> String { b() }
let flag = false
print(make {
"a"
if flag { "b" } else { "c" }
})easynil coalescing
Given a non-optional `let count = 5`, what does `count ?? 0` produce?
let count = 5
let result = count ?? 0Sign in to answer
Everything above is free to read. Answering needs a free account.
We keep the correct answer, the explanation and the scoring behind sign-in so the platform stays honest, which is why the answer options and the worked explanation for every Swift question stay behind a free account. Signing in is free and takes a few seconds.
Swift topics covered
51 distinct Swift topics are tagged across the library. These are the real topic labels stored on the questions, not a hand-written list.
- weak side tables (22)
- associated types (21)
- actors and actor isolation (20)
- result builders (19)
- existential containers (19)
- retain cycles and capture lists (19)
- escaping vs non-escaping closures (18)
- generics and constraints (18)
- structured concurrency task trees (17)
- protocol-oriented programming (17)
- property wrappers (17)
- value witness tables (16)
- phantom types (15)
- unsafeBitCast and pointers (15)
- custom operators (14)
- weak vs unowned mechanics (13)
- ARC internals retain release (13)
- copy-on-write internals (13)
- protocol witness tables (13)
- ownership borrowing consuming (13)
- custom error types (13)
- Sendable and data-race safety (13)
- weak self in closures (12)
- opaque return types (11)
- inlinable cross-module (11)
- memory layout and alignment (10)
- autoclosure (10)
- KeyPath expressions (10)
- async await runtime model (10)
- structs vs classes (9)
- static vs dynamic witness dispatch (9)
- Codable custom keys (9)
- type erasure (9)
- metatype and runtime metadata (9)
- whole-module optimization (8)
- generic where clauses (7)
- if let and guard let (6)
- conditional conformance (6)
- protocols basic conformance (6)
- nil coalescing (5)
- optionals and unwrapping (5)
- enums with associated values (4)
- defer (4)
- arrays dictionaries sets (4)
- access control (4)
- closures and trailing closures (4)
- optional chaining (3)
- map filter reduce (2)
- extensions simple (2)
- do try catch (1)
- tuples and pattern matching (1)
Search and filter every Swift question
…
Difficulty