Краткий ответ

Проверка Optional на nil лишь возвращает логическое значение и не изменяет его статический тип. После такой проверки переменная всё ещё имеет тип Optional<Wrapped>, поэтому для безопасной работы нужен optional binding, guard let или явное извлечение.

Исторический контекст

Swift проектировался как статически типизированный язык с явной обработкой отсутствующих значений. Такой подход не использует автоматическое сужение типа после произвольных логических проверок, чтобы извлечение не происходило скрыто и не зависело от сложного анализа изменяемого состояния.

Вместо неявного поведения Swift предлагает конструкции, которые одновременно проверяют наличие значения и создают переменную типа Wrapped. Это делает границу между Optional и содержащимся значением видимой в коде.

Постановка проблемы

Проверка value != nil не гарантирует для компилятора, что переменная останется неизменной до следующего обращения. Значение может быть изменяемым, вычисляемым свойством или результатом вызова, а между проверкой и использованием состояние потенциально может измениться.

Если после проверки обратиться к Optional как к Wrapped без извлечения, код не скомпилируется. Если использовать принудительное извлечение, ошибка переносится с этапа компиляции на выполнение: при неожиданном nil приложение завершится с ошибкой.

Подробное решение

Optional binding решает обе задачи за одну операцию: проверяет наличие значения и связывает его с новой переменной типа Wrapped. Внутри ветки if связанная переменная уже не является Optional.

let name: String? = "Анна"

if name != nil {
    // name всё ещё имеет тип String?
    print(name!)
}

if let unwrappedName = name {
    // unwrappedName имеет тип String
    print(unwrappedName.count)
}

Проверка name != nil не является операцией извлечения. Оператор сравнения возвращает Bool, а исходное значение name сохраняет свой тип String?.

guard let применяется, когда дальнейшее выполнение возможно только при наличии значения. После успешного guard связанная переменная доступна в оставшейся части текущей области видимости.

Принудительное извлечение через ! допустимо только при доказанной инварианте, которую невозможно нарушить в данном месте. В прикладном коде binding обычно предпочтительнее: он превращает ошибочное отсутствие значения в обычную ветку управления, а не в аварийное завершение.

Ситуация из практики

Сервис получает необязательный идентификатор пользователя. Вариант с проверкой nil и ! короче, но сохраняет риск аварии при изменении источника данных или логики между проверкой и использованием. Вариант с guard let явно завершает обработку при отсутствии идентификатора и оставляет основной сценарий без Optional.

func loadProfile(id: String?) -> String? {
    guard let id else {
        return nil
    }

    return "Профиль: \(id)"
}

Альтернатива — передать Optional дальше и обработать его на другом уровне. Это уместно, если отсутствие значения действительно является частью контракта функции, но тогда Optional распространяется по цепочке вызовов. Для обязательного на данном этапе значения выбран guard let, потому что он локализует проверку и не допускает принудительного извлечения.

Что кандидаты часто упускают

1. Вопрос: Меняет ли guard let тип исходной переменной на Wrapped?

Нет. Исходная переменная сохраняет свой тип Optional. guard let создаёт новую связанную переменную; при использовании синтаксиса с тем же именем она затеняет исходную переменную в доступной области видимости. После этого имени соответствует уже извлечённое значение.

2. Вопрос: Безопасно ли принудительно извлечь значение сразу после проверки на nil?

Логически для неизменяемого локального значения такая последовательность может быть безопасной, но типовая система всё равно не считает это гарантией. Для изменяемой переменной, свойства или повторного вычисления источник может дать nil в момент извлечения. Поэтому ! сохраняет потенциальную runtime-ошибку, тогда как optional binding выражает проверку и использование одной безопасной операцией.

3. Вопрос: Почему вызов функции, возвращающей Optional, не сужает тип результата автоматически после проверки?

Результат вызова не является стабильным именованным значением: повторный вызов может вернуть другое состояние или иметь побочные эффекты. Даже если результат сначала сохранить в локальную константу, Swift не превращает проверку != nil в общее правило извлечения. Нужно явно связать значение через if let или guard let, чтобы компилятор получил отдельную переменную типа Wrapped.