Опционалы: безопасность вместо null

Опционал — это ответ Swift на «ошибку на миллиард долларов»: на падения из-за обращения к отсутствующему значению.

Суть урока: опционал — это коробка, в которой либо есть значение, либо ничего (nil). Компилятор заставляет вас проверить коробку прежде, чем достать содержимое. Так Swift убивает целый класс аварий.

Во многих языках любая переменная может внезапно оказаться «пустой» (null), и обращение к ней роняет программу. Создатель null Тони Хоар назвал это своей «ошибкой на миллиард долларов». Swift решает проблему радикально: обычная переменная не может быть пустой. А если значения может не быть — тип становится опциональным, и это видно прямо в коде через знак вопроса.

var nickname: String? = "swiftfan"   // опционал: есть строка ИЛИ nil
nickname = nil                        // допустимо

let age: Int = 25       // обычный Int — nil сюда положить нельзя
// let bad: Int = nil   // ОШИБКА

Под капотом String? — это перечисление (enum) с двумя случаями: .some(значение) и .none. Поэтому опционал нельзя использовать «как есть»: сначала его нужно развернуть (unwrap), то есть достать значение из коробки. Самый безопасный способ — if let:

if let name = nickname {
    print("Привет, \(name)")   // сюда попадём, только если значение есть
} else {
    print("Ник не задан")
}

Конструкция if let name = nickname читается так: «если в коробке есть значение, положи его в новую константу name и выполни блок». Внутри блока name — уже обычная строка, не опционал. Второй важный инструмент — guard let, который делает ранний выход:

func greet(_ nick: String?) {
    guard let nick else {
        print("Нет имени, выходим")
        return
    }
    // дальше nick гарантированно не nil
    print("Здравствуй, \(nick)")
}

Есть и оператор ?? (nil-coalescing): он подставляет запасное значение, если опционал пуст. let shown = nickname ?? "гость".

Опционал String?
   +-----------------+
   |  .some("Анна")  |  ->  if let / guard let  ->  "Анна"
   +-----------------+
          ИЛИ
   +-----------------+
   |     .none       |  ->  ?? "запасное"          ->  "гость"
   +-----------------+

Попробуй сам ▶ — запусти код прямо в браузере (Pyodide). Здесь нет Swift, но логика та же, что под капотом мобильного кода:

# Опционал = аналог None в Python. Видно ту же логику разворачивания.
def greet(nick):
    if nick is None:          # как guard let nick else
        return 'Нет имени'
    return 'Здравствуй, ' + nick

print(greet('Анна'))
print(greet(None))

# Аналог ?? (nil-coalescing):
nickname = None
shown = nickname if nickname is not None else 'гость'
print('Показываем:', shown)

Как работает под капотом

Опционал — это generic-перечисление Optional<Wrapped>. Запись String? — лишь синтаксический сахар для Optional<String>. Когда вы пишете if let, компилятор разбирает enum по случаям и в безопасной ветке предоставляет развёрнутое значение. Поскольку проверка обязательна, обращение к отсутствующему значению просто не скомпилируется.

Частые ошибки

Принудительное разворачивание через !. nickname! вытащит значение, но уронит приложение, если там nil. Используйте крайне осторожно.
Лес из вложенных if let. Глубокую вложенность лучше заменить на guard let с ранними выходами.
Путать пустую строку и nil. "" — это значение (пустая строка), а nil — отсутствие значения.

Best practices

Предпочитайте if let и guard let принудительному !.
Используйте guard let в начале функций, чтобы основной код шёл без вложенности.
Давайте развёрнутой константе то же имя: if let nickname — современный лаконичный синтаксис.

Итоги. Опционалы — визитная карточка Swift. Они делают отсутствие значения явным и заставляют его обработать. Освоив if let, guard let и ??, вы избавитесь от самых частых падений мобильных приложений.

Шире контекста

Опционалы пронизывают весь Swift и всю работу с iOS. Ответ от сети может не прийти, поле формы может быть пустым, словарь может не содержать ключа, преобразование строки в число может не удаться — во всех этих случаях вы встретите опционал. Поэтому уверенное владение if let, guard let и ?? — это не отдельный навык, а ежедневный инструмент. Со временем вы научитесь читать опциональность типа как часть его смысла: User? честно говорит «пользователя может и не быть», и компилятор не даст об этом забыть. Это резко контрастирует с языками, где любое значение тайком может оказаться null и уронить приложение в самый неподходящий момент. Сделав отсутствие значения явным и обязательным к обработке, Swift превращает целый класс трудноуловимых ошибок выполнения в понятные ошибки компиляции, которые вы чините ещё до того, как пользователь увидит сбой.