Swift Interview Questions and Answers

Swift's structured concurrency builds on async/await, Task and TaskGroup. An async function can suspend without blocking a thread, and await marks a potential suspension point. Tasks form a hierarchy: a child is awaited and cancelled with its parent, which avoids leaked work.

func fetchAll(_ ids: [Int]) async throws -> [Item] {
    try await withThrowingTaskGroup(of: Item.self) { group in
        for id in ids {
            group.addTask { try await fetch(id) }
        }
        var out: [Item] = []
        for try await item in group { out.append(item) }
        return out
    }
}

An actor protects mutable state: its methods are mutually exclusive, so access is serialised. Cross-actor calls are async and require await. @MainActor marks code that must run on the main thread, and Sendable marks types safe to cross concurrency domains. Avoid Task.detached unless you truly want to escape structured cancellation.

Swift collections such as Array, Dictionary and String are value types with copy-on-write. Copying a variable is cheap because both copies share the same buffer until one mutates, then a unique copy is made.

var a = [1, 2, 3]
var b = a          // shares storage, no copy yet
b.append(4)        // copies here; a is still [1, 2, 3]

The runtime checks the reference count: if the buffer is uniquely referenced it mutates in place, otherwise it clones.

Pitfalls to know:

• A struct containing a class property does not deep-copy that reference when copied, so both copies share the class instance. Implement a custom copy or use value types instead.
• Building your own COW type requires isKnownUniquelyReferenced and careful class-backed storage.
• Passing a large array to a function is cheap until it is mutated.
• Sharing a value-type buffer across threads is not automatically safe unless access is synchronised.

Understanding COW matters for both performance and reasoning about shared state.