1var name: String? = "Alice"   // Can hold a String or nil
2var age: Int? = nil            // Currently holds no value
3
4// Non-optional — MUST always have a value
5var greeting: String = "Hello" // Cannot be nil
6// greeting = nil  // Compile error!

1var name: String? = "Alice"
2
3if let unwrapped = name {
4    print("Name is \(unwrapped)")  // "Name is Alice"
5} else {
6    print("Name is nil")
7}
8
9// Shorthand (Swift 5.7+) — reuses the same variable name
10if let name {
11    print("Name is \(name)")
12}

1func greet(name: String?) {
2    guard let name = name else {
3        print("No name provided")
4        return
5    }
6    // name is non-optional from here
7    print("Hello, \(name)")
8}

1var name: String? = "Alice"
2print(name!)  // "Alice" — crashes if name is nil!
3
4var empty: String? = nil
5// print(empty!)  // Runtime crash: "Unexpectedly found nil while unwrapping"

1class Address {
2    var city: String = "New York"
3}
4
5class Person {
6    var address: Address?
7}
8
9let person = Person()
10person.address = Address()
11
12// Optional chaining — returns String? (optional)
13let city = person.address?.city
14print(city)  // Optional("New York")
15
16// Without optional chaining — would need explicit unwrapping
17// let city = person.address!.city  // Crashes if address is nil
18
19// Chaining multiple levels
20class Company {
21    var ceo: Person?
22}
23
24let company = Company()
25let ceoCity = company.ceo?.address?.city  // nil (ceo is nil)

1let name: String? = nil
2let displayName = name ?? "Anonymous"
3print(displayName)  // "Anonymous"
4
5let age: Int? = 25
6let displayAge = age ?? 0
7print(displayAge)  // 25 (age is not nil, so ?? is not used)
8
9// Chaining multiple fallbacks
10let primary: String? = nil
11let secondary: String? = nil
12let fallback = primary ?? secondary ?? "Default"
13print(fallback)  // "Default"

1class Animal {}
2class Dog: Animal {
3    func bark() { print("Woof!") }
4}
5class Cat: Animal {
6    func meow() { print("Meow!") }
7}
8
9let animal: Animal = Dog()
10
11// as? returns an optional — nil if the cast fails
12if let dog = animal as? Dog {
13    dog.bark()  // "Woof!"
14}
15
16if let cat = animal as? Cat {
17    cat.meow()  // Not executed — cast fails, returns nil
18}

1struct Temperature {
2    let celsius: Double
3
4    init?(celsius: Double) {
5        // Absolute zero is -273.15°C — reject lower values
6        guard celsius >= -273.15 else { return nil }
7        self.celsius = celsius
8    }
9}
10
11let valid = Temperature(celsius: 100)    // Optional(Temperature)
12let invalid = Temperature(celsius: -300) // nil
13
14if let temp = Temperature(celsius: 20) {
15    print("Temperature: \(temp.celsius)°C")
16}

1// Declared with ! instead of ?
2var label: UILabel!  // Implicitly unwrapped optional
3
4// Used in Interface Builder outlets
5@IBOutlet weak var titleLabel: UILabel!
6
7// Access without explicit unwrapping
8// titleLabel.text = "Hello"  // Works if not nil, crashes if nil

1let number: Int? = 5
2
3// map — transforms the value if it exists
4let doubled = number.map { $0 * 2 }
5print(doubled)  // Optional(10)
6
7let nilNumber: Int? = nil
8let result = nilNumber.map { $0 * 2 }
9print(result)  // nil
10
11// flatMap — unwraps one level of optional nesting
12let str: String? = "42"
13let parsed = str.flatMap { Int($0) }  // Int? (not Int??)
14print(parsed)  // Optional(42)