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

Два Optional равны, если оба содержат nil либо оба содержат значения, равные друг другу. Если один содержит nil, а другой значение, они не равны.

Сравнение возможно, когда тип обёрнутого значения поддерживает Equatable: Optional сравнивает состояния .none и .some, а для двух .some делегирует сравнение их содержимых значений.

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

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

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

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

При сравнении нужно различать три ситуации: оба значения отсутствуют, отсутствует только одно значение, либо оба значения присутствуют. Ошибка в этой логике может привести, например, к тому, что неизвестный результат ошибочно будет принят за конкретное значение.

Кроме того, сам Optional не может сравнивать произвольные обёрнутые значения. Если Wrapped не соответствует Equatable, операция равенства для таких Optional недоступна, поскольку Swift не знает, как сравнить их содержимое.

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

Optional<Wrapped> концептуально имеет два состояния: .none и .some(Wrapped). При сравнении сначала учитывается состояние оболочки:

.none и .none считаются равными;
.none и .some(...) не равны;
.some(left) и .some(right) сравниваются через left == right.

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

let first: Int? = nil
let second: Int? = nil
let third: Int? = 7
let fourth: Int? = 7

print(first == second) // true
print(first == third)  // false
print(third == fourth) // true

Важно не путать равенство с идентичностью. Для значений сравнивается содержимое, а для классов внутри Optional оператор == использует правила Equatable самого класса; он не обязан проверять, указывают ли две ссылки на один экземпляр.

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

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

Сервис загружает сохранённый идентификатор пользователя и сравнивает его с идентификатором из ответа сервера. Оба идентификатора имеют тип String?, потому что один из источников может не предоставить значение.

Возможны два подхода. Сначала извлечь оба значения и отдельно обработать отсутствие — это явно, но увеличивает объём ветвлений и риск забыть один из случаев. Сравнить Optional напрямую короче и сохраняет различие между «оба идентификатора отсутствуют» и «значения различаются».

Выбранное решение — прямое сравнение String?, если бизнес-правило действительно считает два отсутствующих значения одинаковым состоянием. Если отсутствие должно означать ошибку или «данные ещё не загружены», одного равенства недостаточно: состояние нужно проверять отдельно, чтобы не скрыть эту семантику.

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

Считаются ли два nil равными?

Да, если они представлены сравнимыми Optional, то есть имеют совместимый обёрнутый тип, поддерживающий Equatable. Сравнение означает, что оба значения находятся в состоянии .none; оно не утверждает, что за nil скрывается какой-либо объект или значение.

Можно ли сравнить Optional с обёрнутым необязательным значением напрямую?

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

Что произойдёт, если обёрнутый тип — класс без Equatable?

Нельзя автоматически получить содержательное сравнение двух таких Optional. Наличие ссылочного типа само по себе не задаёт оператор ==: нужно либо реализовать Equatable с выбранной семантикой состояния, либо явно использовать проверку идентичности объектов, если требуется определить, является ли это один и тот же экземпляр.