Что такое Optional Chaining?

Optional Chaining в Swift

Определение

Optional Chaining — это техника безопасного обращения к свойствам, методам и подписчикам optional значений. Если optional содержит значение, операция выполнится; если nil, операция безопасно не произойдет.

Синтаксис

// Использование ? для optional chaining
optional?.property
optional?.method()
optional?[index]

// Отличие от force-unwrap !
optional!.property  // Крашит, если nil
optional?.property  // Безопасно, если nil

Основной пример

class Person {
    var residence: Residence?
}

class Residence {
    var numberOfRooms: Int = 1
    
    func printNumberOfRooms() {
        print("The residence has \(numberOfRooms) rooms.")
    }
}

let john = Person()

// ❌ Без optional chaining — будет крах
john.residence?.numberOfRooms = 5  // Вызовется только если residence не nil

// ❌ Force-unwrap опасен
john.residence!.numberOfRooms = 5  // Fatal error

// ✅ Optional chaining безопасен
if let roomCount = john.residence?.numberOfRooms {
    print("John's residence has \(roomCount) rooms.")
} else {
    print("Unable to retrieve the number of rooms.")
}

Различные использования

1. Доступ к свойствам

struct User {
    var profile: Profile?
}

struct Profile {
    var name: String = "Unknown"
    var age: Int = 0
}

let user: User? = User(profile: Profile(name: "John", age: 25))

// Optional chaining для чтения
if let name = user?.profile?.name {
    print(name)  // "John"
}

// Optional chaining для записи
user?.profile?.name = "Jane"  // Сработает, если user и profile не nil

// Множественное chaining
if let age = user?.profile?.age {
    print(age)  // 25
}

2. Вызов методов

class Room {
    func printDescription() {
        print("This is a room.")
    }
}

class Residence {
    var room: Room?
}

let residence: Residence? = Residence()
residence?.room?.printDescription()  // Ничего не произойдет, потому что room nil

residence?.room = Room()
residence?.room?.printDescription()  // Выведет: "This is a room."

3. Проверка успешности операции

// Optional chaining для методов возвращает Void?
// Это позволяет проверить, выполнился ли метод

class Residence {
    func printNumberOfRooms() {
        print("The residence has 4 rooms.")
    }
}

let residence: Residence? = Residence()

if residence?.printNumberOfRooms() != nil {
    print("It was possible to print the number of rooms.")
} else {
    print("It was not possible to print the number of rooms.")
}

4. Доступ к элементам массива

class Residence {
    var rooms: [Room] = []
    
    func addRoom(_ room: Room) {
        rooms.append(room)
    }
}

let residence: Residence? = Residence()

// Добавление комнаты через optional chaining
let room = Room()
residence?.rooms.append(room)  // Безопасно

// Доступ к элементу
if let firstRoom = residence?.rooms[0] {
    print(firstRoom)
}

Сравнение подходов

class Address {
    var street: String = "Main St"
}

class Person {
    var address: Address?
}

let person: Person? = Person()

// ❌ Плохо 1: Force-unwrap
let street = person!.address!.street  // Крашит при nil

// ❌ Плохо 2: Вложенные if let
if let p = person {
    if let a = p.address {
        let street = a.street
    }
}

// ✅ Хорошо 1: Optional chaining
if let street = person?.address?.street {
    print(street)
}

// ✅ Хорошо 2: guard let с optional chaining
guard let street = person?.address?.street else {
    return
}
print(street)

// ✅ Хорошо 3: if let с несколькими значениями
if let p = person, let a = p.address {
    print(a.street)
}

Практические примеры

Пример 1: Работа с UI элементами

class ViewController: UIViewController {
    @IBOutlet var nameLabel: UILabel?
    
    func updateUI(with name: String) {
        // ✅ Safe: если label не инициализирован или nil
        nameLabel?.text = name
        nameLabel?.textColor = .blue
        nameLabel?.font = UIFont.boldSystemFont(ofSize: 16)
    }
}

// Использование
let vc: ViewController? = ViewController()
vc?.nameLabel?.text = "Hello"  // Безопасно

Пример 2: Модели со вложенностью

struct API {
    struct Response {
        struct Data {
            struct User {
                let name: String
            }
            let user: User?
        }
        let data: Data?
    }
    let response: Response?
}

let api: API? = nil

// Множественное optional chaining
if let userName = api?.response?.data?.user?.name {
    print(userName)
} else {
    print("Unable to get user name")
}

Пример 3: Проверка выполнения метода

class NotificationService {
    weak var delegate: NotificationDelegate?  // Обычно delegate optional
    
    func notifyUser(message: String) {
        // Проверяем, может ли delegate обработать
        if delegate?.application(message) != nil {
            print("Notification sent successfully")
        } else {
            print("Delegate is nil, notification not sent")
        }
    }
}

protocol NotificationDelegate: AnyObject {
    func application(_ message: String)
}

Optional Chaining vs Guard/If Let

// Сценарий: Получить имя пользователя из API

// Вариант 1: Guard let (более явный)
func getUserName(user: User?) -> String {
    guard let user = user,
          let profile = user.profile,
          let name = profile.name else {
        return "Unknown"
    }
    return name
}

// Вариант 2: Optional chaining (более компактный)
func getUserName(user: User?) -> String {
    return user?.profile?.name ?? "Unknown"
}

// Используется в зависимости от контекста и предпочтений

Важные моменты

// 1. Результат optional chaining всегда optional
let value: Int? = 5
let result = value?.description  // String?, не String

// 2. Множественное chaining можно комбинировать
struct Company {
    struct Employee {
        struct Department {
            var name: String?
        }
        var department: Department?
    }
    var employee: Employee?
}

let company: Company? = Company()
company?.employee?.department?.name = "Engineering"

// 3. Безопасность с subscripts
let array: [String]? = ["a", "b", "c"]
if let value = array?[1] {
    print(value)  // "b"
}

// 4. Можно проверить, произошла ли операция
if company?.employee?.department?.name != nil {
    print("Name was set")
} else {
    print("Was not able to set name")
}

Лучшие практики

✅ Делай так:

// Используй optional chaining для безопасности
user?.profile?.updateName(name)

// Используй guard для критичных значений
guard let user = user else { return }
let name = user.name

// Используй if let для проверки
if let value = optional?.property {
    // Work with non-nil value
}

❌ Избегай:

// Force-unwrap без проверки
user!.profile!.name  // Опасно

// Множественные nested if let (когда можно optional chaining)
if let u = user {
    if let p = u.profile {
        if let n = p.name {}
    }
}