Optional chaining ?. и nil-coalescing ??

1. Optional chaining ?.

В реальном коде optional чаще всего появляется не потому, что программисту скучно и он хочет усложнить жизнь, а потому что мир не гарантирует данные. Пользователь мог не ввести строку. Словарь мог не содержать ключ. Список мог быть пустым. И вот здесь возникает бытовая задача: «я хочу взять свойство или вызвать метод, но только если значение реально существует».

Optional chaining ?. — это как очень вежливый охранник: «пропущу дальше по цепочке только тех, кто реально пришёл». Если слева nil, цепочка не падает, не кричит и не зовёт fatalError, а просто спокойно возвращает nil.

Чаще всего ?. используют в ситуациях, когда на nil не нужно делать отдельную большую логику. Нам достаточно, чтобы результат тоже стал nil, и мы либо покажем пустоту, либо подставим дефолт через ??.

Свойства и методы у optional

Optional chaining начинается с простого: у нас есть optional, и мы хотим обратиться к его свойству или методу. Мы могли бы написать if let, но иногда это ощущается как «развернуть палатку ради того, чтобы налить стакан воды». В таких маленьких операциях ?. делает код короче и при этом не превращает его в опасный !.

Пример: свойство у optional

import Foundation

let maybeText: String? = "Swift 6.2"

let length: Int? = maybeText?.count
print(length as Any) // Optional(9)

Здесь maybeText — optional. Свойство count у обычной строки имеет тип Int, но из-за ?. результат становится Int?. Это важный момент: мы не «достаём значение насильно», мы говорим: «если строка есть — дай длину, если нет — верни nil».

Пример: вызов метода у optional

import Foundation

let maybeName: String? = "alice"

let upper: String? = maybeName?.uppercased()
print(upper as Any) // Optional("ALICE")

Если maybeName == nil, то upper просто станет nil. Метод не вызывается вообще — как будто вы даже не пытались.

Цепочки из нескольких шагов и эффект домино

В учебных примерах optional часто выглядит как «одна переменная, одно действие». В жизни всё интереснее: данные вложены, у объекта есть поле, которое тоже optional, и дальше начинается классическая история «я просто хотел вывести город пользователя, а у меня 5 уровней nil».

Optional chaining отлично работает именно в таких ситуациях: вы строите цепочку «шаг за шагом», и если где-то случается nil, вся цепочка аккуратно превращается в nil. Без взрывов. Без драм.

Пример: вложенные структуры

import Foundation

struct Publisher {
    let name: String
}

struct Book {
    let title: String
    let publisher: Publisher?
}

let book = Book(title: "Swift для людей", publisher: Publisher(name: "Acme Books"))

let publisherNameUpper: String? = book.publisher?.name.uppercased()
print(publisherNameUpper as Any) // Optional("ACME BOOKS")

Тут publisher — optional. Мы делаем book.publisher?.name и только потом вызываем uppercased(). Если publisher == nil, то name мы не читаем, и uppercased() не вызываем.

Небольшая схема мышления

flowchart TD
    A[book.publisher] -->|если .some| B[name]
    A -->|если nil| N[nil]
    B --> C["uppercased()"]
    C --> R[результат String?]
    N --> R

Идея простая: ?. как «развилка без паники». Никаких «unexpectedly found nil», только предсказуемое превращение результата в nil.

Optional chaining со словарями

Словари — один из главных поставщиков optional в Swift, потому что доступ по ключу (dict[key]) возвращает Value?: элемента может не быть. Это не «неудобство Swift», а честная модель реальности.

И вот тут optional chaining становится суперпрактичным: мы можем сразу что-то сделать со значением, если оно есть.

Пример: взять заголовок и преобразовать

import Foundation

let headers: [String: String] = ["Content-Type": "application/json"]

let ctUpper: String? = headers["Content-Type"]?.uppercased()
print(ctUpper as Any) // Optional("APPLICATION/JSON")

Если ключа нет, headers["Content-Type"] даст nil, цепочка остановится, ctUpper станет nil.

Пример: мутация значения в словаре через ?.

Смотрите внимательно: это выглядит красиво, но может «молча ничего не сделать».

import Foundation

var tagsByBookID: [Int: [String]] = [:]

tagsByBookID[10]?.append("swift")
print(tagsByBookID) // [:]

Почему словарь остался пустым? Потому что tagsByBookID[10] вернул nil (ключа нет), и ?.append(...) просто не вызвался. Это поведение очень похоже на пример, где через optional chaining пытаются менять значение по ключу в словаре.

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

Главное правило типизации для ?.

С optional chaining есть одна штука, которую лучше выучить как «таблицу умножения», иначе вы будете регулярно удивляться типам в подсказках IDE. Правило звучит так: если вы использовали ?., результат выражения — optional.

Даже если справа у свойства/метода тип не optional (например, count: Int), chaining «оборачивает» итог в optional, потому что вся операция может не состояться.

При этом есть важный нюанс: optional chaining старается не создавать «лишнюю вложенность», когда справа и так получается optional. На уровне новичка достаточно запомнить практическое: ?. почти всегда означает, что итог — ...?

2. Оператор ??

Optional chaining часто отвечает на вопрос «как не упасть», но не отвечает на вопрос «что делать дальше». Потому что в конце у вас всё ещё optional. И вот тут появляется ?? — nil-coalescing operator.

Он читается по-человечески так: «если слева есть значение — бери его, иначе используй дефолт справа».

Пример: дефолтная строка

import Foundation

let maybeCity: String? = nil

let city: String = maybeCity ?? "Unknown"
print(city) // Unknown

Тип результата — не optional, потому что мы гарантировали значение дефолтом.

Важное правило типов у ??

У ?? есть железное требование: тип справа должен совпадать с «распакованным» типом слева.

То есть если слева Int?, справа должен быть Int, а не "0" и не 0.0.

import Foundation

let maybeCount: Int? = nil
let count = maybeCount ?? 0
print(count) // 0

Если подставить дефолт другого типа, компилятор вас остановит (и правильно сделает).

3. Комбо ?. + ??

Самая типичная «связка дня» выглядит так: мы делаем chaining, чтобы не упасть, а затем ставим ??, чтобы получить нормальное (не-optional) значение, с которым удобно работать дальше.

Это похоже на бытовую ситуацию: вы проверили, открыт ли магазин (?.), и если закрыт — пошли в другой (??). В конце вы всё равно с хлебом, просто иногда из другого места.

Пример: читаем ввод пользователя без лишних if

readLine() возвращает String?. Значит, любые обработки строки можно делать через ?., а потом закрывать дефолтом.

import Foundation

let raw: String? = readLine()

let name: String = raw?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "Гость"
print("Привет, \(name)!") // например: Привет, Гость!

Если readLine() вернул nil, trimmingCharacters не вызовется, и мы подставим "Гость".

Пример: берём длину, но хотим Int, а не Int?

import Foundation

let maybeText: String? = nil

let length: Int = maybeText?.count ?? 0
print(length) // 0

Свойство count возвращает Int, но chaining даёт Int?, и ?? 0 превращает это обратно в обычный Int.

Пример: со словарём

import Foundation

let headers: [String: String] = [:]

let contentType: String = headers["Content-Type"]?.uppercased() ?? "-"
print(contentType) // -

Получилось читаемо: «возьми Content-Type, приведи к верхнему регистру, а если не получилось — поставь дефолт».

4. Читаемость

Optional chaining легко превращается в «линию электропередач на 18 проводов», особенно если вы пытаетесь сделать всё в одну строку. На первых порах это даже приятно: “смотрите, как Swift умеет!”. На вторых порах код начинают читать другие люди, и у них появляется очень человеческий вопрос: «а можно это… как-нибудь попроще?»

Хорошее правило: если у вас больше двух-трёх шагов в цепочке, подумайте, не разбить ли её на промежуточные переменные. Это не делает код менее “Swift”, это делает его более читаемым.

Слишком длинно в одну строку

import Foundation

let result: String = readLine()?
    .trimmingCharacters(in: .whitespacesAndNewlines)
    .lowercased()
    .replacingOccurrences(of: " ", with: "_")
    ?? "empty"

print(result) // например: "hello_world" или "empty"

Так писать можно, но новичку (и уставшему человеку) сложнее глазами поймать, где заканчивается chaining и где начинается дефолт.

Разбиваем на шаги

import Foundation

let raw = readLine()
let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines)
let normalized = trimmed?.lowercased()

let result = normalized ?? "empty"
print(result)

Да, строк больше. Зато каждый шаг проще проверить и легче отладить.

И ещё важный момент: если реакция на nil — не «подставь дефолт», а «покажи ошибку пользователю, выйди из функции, сделай альтернативный сценарий», то chaining начинает быть неудобным. В таких случаях возвращаемся к if let / guard let: они лучше выражают «ветвление», а не «трубу преобразований».

5. Пример: аккуратный вывод карточки книги

Чтобы ?. и ?? не остались «операторами ради операторов», давайте применим их в маленьком кусочке нашего консольного приложения про библиотеку. Мы не будем делать сложный парсинг команд, а сосредоточимся на простом: красиво вывести информацию, даже если часть полей отсутствует.

Представим, что у нас есть модель Book, где автор и год могут быть неизвестны.

import Foundation

struct Book {
    let title: String
    let author: String?
    let year: Int?
}

func printBookCard(_ book: Book) {
    let author = book.author ?? "Автор неизвестен"
    let yearText = book.year.map { String($0) } ?? "Год неизвестен"
    print("— \(book.title) | \(author) | \(yearText)")
}

Если вы заметили, что тут используется map, то вы правы: это мостик к следующей теме про преобразования optional. Но даже сейчас важна сама мысль: ?? позволяет задать дефолт рядом с местом использования, а optional остаётся безопасным на всём пути.

Если же map пока кажется «слишком умным», то на текущем этапе курса можно считать достаточным общий принцип: chaining (?.) — для безопасного доступа, ?? — для дефолтов, а более сложные преобразования можно временно делать через if let (или отложить до следующей темы).

6. Типичные ошибки при работе с ?. и ??

Ошибка №1: ожидать, что после ?. получится не-optional.
Очень частая ситуация: студент пишет let n: Int = text?.count и удивляется ошибке компилятора. Логика языка тут строгая: если слева возможен nil, то и результат возможен nil. Поэтому либо держим результат как Int?, либо закрываем дефолтом через ??.

Ошибка №2: подставлять в ?? дефолт «другого смысла», путая nil с пустотой.
Иногда хочется писать let name = maybeName ?? "" везде подряд. Но "" — это «значение есть, просто пустая строка», а nil — «значения нет». Если вы смешиваете эти ситуации, логика приложения становится мутной: вы уже не можете отличить «пользователь ничего не ввёл» от «пользователь ввёл пустую строку». Иногда это нормально, но чаще это тихая логическая ошибка.

Ошибка №3: использовать dict[key]?.append(...) и ожидать, что ключ появится сам.
Optional chaining на словаре делает мутацию очень компактной, но она выполняется только если значение уже существует. Как мы видели, tagsByBookID[10]?.append("swift") может вообще ничего не сделать. Это не баг Swift, это буквальное следование правилу ?.: «если слева nil — молчи». Если вам нужно «создать при отсутствии», придётся явно обработать ситуацию (например, через dict[key, default: []].append(...), если вы уже проходили этот API).

Ошибка №4: строить длинные цепочки ради красоты, а потом самим в них теряться.
?. позволяет писать длинные выражения, но это не значит, что так всегда нужно. Если цепочка становится визуально тяжёлой, лучше разрезать её на шаги и дать промежуточным значениям имена. IDE и будущий вы скажут спасибо.

Ошибка №5: пытаться заменить guard let на ??, когда нужен именно ранний выход.
?? хорош, когда дефолт действительно нормален. Но если nil — это ошибка сценария («без пользователя нельзя продолжать», «без id нельзя обновить запись»), то подстановка дефолта превращает проблему в скрытый баг. В таких местах лучше честно выйти из функции через guard let и не продолжать «как ни в чём не бывало».