1let name: String? = "Alice"
2
3if name != nil {
4    print("Name exists: \(name!)")  // Force unwrap after nil check
5}
6
7if name == nil {
8    print("Name is nil")
9}

1let name: String? = "Alice"
2
3if let unwrappedName = name {
4    // unwrappedName is a non-optional String
5    print("Hello, \(unwrappedName)")
6} else {
7    print("Name is nil")
8}
9
10// Swift 5.7+ shorthand — same name
11if let name {
12    print("Hello, \(name)")  // name is non-optional here
13}

1let firstName: String? = "Alice"
2let lastName: String? = "Smith"
3let age: Int? = 30
4
5if let first = firstName, let last = lastName, let age = age {
6    print("\(first) \(last), age \(age)")
7}
8// Only executes if ALL optionals are non-nil

1func greet(name: String?) {
2    guard let name = name else {
3        print("No name provided")
4        return  // Must exit the scope
5    }
6
7    // name is non-optional for the rest of the function
8    print("Hello, \(name)")
9    print("Name has \(name.count) characters")
10}
11
12greet(name: "Alice")  // Hello, Alice
13greet(name: nil)       // No name provided

1// guard with multiple optionals
2func processUser(name: String?, email: String?, age: Int?) {
3    guard let name = name, let email = email, let age = age else {
4        print("Missing required fields")
5        return
6    }
7
8    // All three are non-optional here
9    print("User: \(name), \(email), age \(age)")
10}

1let temperature: Double? = 72.5
2
3switch temperature {
4case .some(let temp) where temp > 100:
5    print("Too hot: \(temp)")
6case .some(let temp):
7    print("Temperature: \(temp)")
8case .none:
9    print("No reading")
10}

1struct Address {
2    var street: String
3    var city: String
4}
5
6struct User {
7    var name: String
8    var address: Address?
9}
10
11let user: User? = User(name: "Alice", address: Address(street: "123 Main", city: "NYC"))
12
13// Each ?. returns nil if the preceding value is nil
14let city = user?.address?.city
15print(city)  // Optional("NYC")
16
17// Combine with nil-coalescing
18let cityName = user?.address?.city ?? "Unknown"
19print(cityName)  // "NYC"

1let input: String? = nil
2let value = input ?? "default"
3print(value)  // "default"
4
5// Chained fallbacks
6let primary: String? = nil
7let secondary: String? = nil
8let fallback: String? = "Guest"
9let name = primary ?? secondary ?? fallback ?? "Unknown"
10print(name)  // "Guest"

1import XCTest
2
3class UserTests: XCTestCase {
4    func testUserNameIsNotNil() {
5        let user = fetchUser(id: 1)
6
7        // XCTAssertNotNil — checks for non-nil
8        XCTAssertNotNil(user)
9
10        // XCTUnwrap — unwraps or fails the test
11        let unwrappedUser = try XCTUnwrap(user)
12        XCTAssertEqual(unwrappedUser.name, "Alice")
13    }
14
15    func testMissingUserIsNil() {
16        let user = fetchUser(id: 999)
17        XCTAssertNil(user)
18    }
19}

1let value: Int? = 42
2
3// 1. if let — use when you need the value in a block
4if let v = value { print(v) }
5
6// 2. guard let — use for early exit
7guard let v = value else { return }
8
9// 3. == nil — use for simple existence checks without the value
10if value == nil { print("missing") }
11
12// 4. ?? — use to provide defaults
13let v = value ?? 0
14
15// 5. map — use to transform without unwrapping
16let doubled = value.map { $0 * 2 }  // Optional(84)
17
18// 6. flatMap — use when transform returns optional
19let parsed = value.flatMap { String($0).count > 1 ? $0 : nil }