Swift — Optionals

What are optionals

var name: String? = "Alice"
var nothing: String? = nil

Unwrapping optionals

// if let
if let name = name {
    print("Name is \(name)")
}

// guard
func process(name: String?) {
    guard let name = name else {
        print("No name")
        return
    }
    print("Processing: \(name)")
}

// Optional binding in conditions
if let name = name, !name.isEmpty {
    print("Name: \(name)")
}

Nil coalescing

let display = name ?? "Unknown"
print(display) // Alice

Optional chaining

struct Address {
    var city: String
}

struct Person {
    var address: Address?
}

let p = Person(address: Address(city: "NYC"))
print(p.address?.city ?? "Unknown") // NYC

let p2 = Person()
print(p2.address?.city ?? "Unknown") // Unknown

Force unwrapping

let name: String? = "Alice"
print(name!) // Alice (crashes if nil)

Implicitly unwrapped optionals

var name: String! = "Alice"
print(name.count) // No optional needed

Map and flatMap

let numStr: String? = "42"
let num = numStr.map { Int($0) ?? 0 }
print(num ?? 0)

let numStr2: String? = nil
let num2 = numStr2.flatMap { Int($0) }
print(num2 ?? 0) // 0

Best practices

• Prefer if let and guard over force unwrapping
• Use nil coalescing for defaults
• Use optional chaining for safe access
• Avoid implicitly unwrapped optionals

Mini Practice

Write Swift code that:

1. Uses if let to unwrap an optional
2. Uses guard for early return
3. Uses optional chaining on nested optionals
4. Uses map to transform an optional

Up Next

In the next lesson, you'll learn about Error Handling — try, catch, and throws in Swift.