Swift Optionals

var nickname: String? = "Addy"
nickname = nil              // allowed: it's optional

var name: String = "Ada"
name = nil                  // error: 'nil' cannot be assigned to type 'String'

• Any type can be optional: Int?, Double?, [String]?.
• An optional either contains a value or is nil.
• Printing an optional shows Optional("Addy") or nil, a sign you should usually unwrap it first.
• Many functions return optionals because they can fail: Int("42") returns Int?, and array.first returns nil for an empty array.

if let unwraps an optional and runs a block only when there's a value:

if let nick = nickname {
    print("Hi, \(nick)")      // nick is a plain String here
} else {
    print("No nickname")
}

Swift 5.7 added a shorthand when you want the same name: if let nickname { ... }.

guard let unwraps for the rest of the function, and requires you to leave (return, break or throw) when the value is missing. It keeps the main path of a function flat, without nesting:

func greet(_ name: String?) {
    guard let name else {
        print("Hello, stranger")
        return
    }
    print("Hello, \(name)")
}

The nil-coalescing operator ?? gives a default when the optional is nil:

let shown = nickname ?? "Guest"
let age = Int(input) ?? 0

Optional chaining with ?. calls a property or method only if the value isn't nil; otherwise the whole expression is nil:

let length = nickname?.count          // Int?
let upper = user?.address?.city?.uppercased() ?? "UNKNOWN"

Chains stop at the first nil, so long chains through optional data stay short and safe.

Adding ! after an optional force unwraps it: "I'm certain there's a value". If you're wrong, the app crashes:

let n = Int("abc")!       // crash: unexpectedly found nil

Use ! only when nil is genuinely impossible and a crash would indicate a programming mistake, such as a resource that's always bundled with your app. In everyday code, if let, guard let and ?? are safer and just as short.

An optional isn't magic. Int? is shorthand for Optional<Int>, an enum with two cases: .some(value) when there's a value and .none when there isn't. nil is simply another way to write .none:

let maybe: Int? = .some(5)     // same as = 5
let nothing: Int? = .none      // same as = nil

switch maybe {
case .some(let value):
    print("Got \(value)")      // Got 5
case .none:
    print("Nothing")
}

You'll rarely write .some yourself, but knowing it explains why printing an optional shows Optional(5), and why you can switch over one. A shorter pattern, case let value?:, matches only when there's a value.

if let and guard let can unwrap several values, separated by commas, and mix in ordinary conditions. The block runs only if every unwrap succeeds and every condition is true:

let name: String? = "Ada"
let ageText: String? = "42"

if let name, let ageText, let age = Int(ageText), age >= 18 {
    print("\(name) is \(age)")      // Ada is 42
}

Each step can use the names unwrapped before it, so Int(ageText) sees a plain String. This replaces a pyramid of nested if let blocks with a single readable line. To transform an optional without unwrapping it, map applies a function only when a value is present: Int("21").map { $0 * 2 } is Optional(42), and nil stays nil.