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

Связанная переменная получает сам Optional, а не его содержимое. Простое связывание через case let только присваивает сопоставленное значение; извлечение выполняет специальный optional-шаблон или if let.

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

Optional в Swift моделирует наличие или отсутствие значения как типобезопасное состояние, а pattern matching позволяет явно разбирать такие состояния. Это заменяет неявные проверки на null и снижает риск обращения к отсутствующему значению.

Разделение простого связывания и извлечения важно: шаблоны должны иметь предсказуемую структуру и не выполнять скрытые преобразования типов.

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

Если применить простое связывание к Optional<String>, можно ошибочно ожидать, что переменная станет String. На самом деле она останется String?, поэтому обращение к ней как к обычной строке потребует дальнейшего извлечения.

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

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

Простой шаблон связывания считается иррефутируемым: он сопоставляется с любым значением и просто связывает его с новой переменной. Поэтому при сопоставлении значения типа String? связанная переменная также имеет тип String?.

Для извлечения значения нужен шаблон, проверяющий наличие some, либо синтаксис optional binding. В pattern matching постфиксный вопросительный знак означает проверку состояния some и связывание содержащегося значения; при none совпадения не будет.

Минимальный пример:

let name: String? = "Алиса"

if case let value = name {
    print(value as Any) // Optional("Алиса")
}

if case let value? = name {
    print(value) // Алиса
}

В первом случае value имеет тип String?. Во втором шаблон сначала проверяет наличие значения, поэтому value имеет тип String.

Для Optional<Optional<String>> один optional-шаблон снимает только один уровень. Чтобы получить именно String, нужно явно обработать оба уровня; наличие внешнего some ещё не означает наличие внутреннего значения.

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

Сервис возвращает необязательный идентификатор пользователя, а обработчик использует pattern matching. Вариант с простым связыванием удобен, если нужно сохранить сам Optional для последующей передачи в другую функцию, но он не даёт безопасного доступа к строковым операциям.

Вариант с optional-шаблоном сразу отбрасывает отсутствие значения и позволяет работать с обычным String. Его минус — он подходит только для ветки, где значение существует; для отдельной обработки nil потребуется дополнительная ветка.

Практический выбор — использовать шаблон извлечения, когда внутри ветки нужен String, и простое связывание, когда важно сохранить исходную структуру значения. Это делает намерение явным и не смешивает связывание с распаковкой.

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

Вопрос: Считает ли простое связывание nil несовпадением?

Ответ: Нет. Простое связывание сопоставляется с любым значением, включая nil, и связывает сам Optional. Поэтому оно не является проверкой наличия содержимого.
Вопрос: Сколько уровней Optional снимает один optional-шаблон?

Ответ: Только один. Если значение имеет тип Int?? и внешний уровень содержит внутренний Optional, шаблон извлечёт внутренний Int?, но не гарантирует наличие самого Int.
Вопрос: Чем optional binding отличается от простого связывания в pattern matching?

Ответ: Optional binding проверяет, что значение находится в состоянии some, и вводит переменную уже с типом содержимого. Простое связывание проверки не выполняет и сохраняет исходный тип, включая Optional-обёртку.