Swift Interview Questions and Answers

An optional represents a value that may be absent: either .some(value) or .none, written nil. Non-optional types can never be nil, and the compiler forces you to unwrap.

var name: String? = "Ada"
print(name?.count ?? 0)               // optional chaining + nil coalescing
if let name = name { print(name) }    // optional binding
guard let name = name else { return } // early exit
let forced = name!                    // crashes if nil

Use optional binding, guard let, optional chaining (?.) and the nil-coalescing operator (??). Swift 5.7 supports shorthand binding with if let name. Avoid force unwrapping with ! except when nil is genuinely impossible, and the same goes for try! and as!.

Optionals are an enum under the hood, so they work with pattern matching and map/flatMap. A nested optional such as String?? distinguishes .some(nil) from nil, which matters when wrapping optional APIs.

let declares a constant binding and var a mutable one. For value types, let also prevents changing stored properties.

Structs are value types: assignment and passing make a copy, with copy-on-write for collections. Classes are reference types: assignment shares the same instance and mutations are visible to every reference.

struct Point { var x = 0 }
class Box { var value = 0 }

var p = Point()
var p2 = p
p2.x = 1           // p.x stays 0

let b = Box()
let b2 = b
b2.value = 1       // b.value is 1, same object

Classes add inheritance, deinitialisers and identity comparison with ===. Structs get memberwise initialisers and avoid shared mutable state, which is safer under concurrency. The standard library and SwiftUI favour structs. Prefer structs unless you need reference semantics or inheritance.