Доступ по ключу даёт Optional

1. Модель словаря

Когда вы впервые видите ages["Tom"] и в ответ получаете не Int, а Int?, в голове рождается мысль “Что? Опять?”. Но на самом деле Swift делает вам добро — просто довольно строгим тоном.

Словарь — это структура, где ключи не обязаны существовать. В массиве индекс почти всегда “подозрительный”, но хотя бы понятно, что он должен быть в диапазоне. В словаре же пользователь может попросить ключ "Tom", а у вас в данных есть только "Ann" и "Bob". Что вернуть? Ноль? Пустую строку? “-1”? Всё это — костыли и договорённости, которые ломаются при первом же реальном проекте.

Поэтому Swift говорит так: “Если ключа может не быть, результат чтения — Optional. Хочешь значение — докажи, что оно есть”. Это не занудство, это защита от очень дорогих ошибок.

Наглядно модель выглядит так:

flowchart TD
    A["Есть словарь dict"] --> B["Запрашиваем dict[key]"]
    B --> C{"Ключ есть?"}
    C -->|Да| D["Возвращаем .some(value)"]
    C -->|Нет| E["Возвращаем nil (.none)"]

2. Как увидеть nil и Optional при печати

Когда вы печатаете Optional, бывает ощущение, что Swift специально хочет, чтобы вы увидели слово Optional(...) и задумались о смысле жизни. И в этом есть педагогический элемент.

Проблема в том, что print(...) принимает аргументы типа Any, и когда вы передаёте туда optional, Swift старается предупредить, что вы “засунули Optional в Any без распаковки”.

Посмотрим простой пример:

let ages: [String: Int] = ["Ann": 24, "Bob": 30]

let annAge = ages["Ann"]
let tomAge = ages["Tom"]

print(annAge as Any) // Optional(24)
print(tomAge as Any) // nil

Здесь as Any — это не “магия”, а просто способ сказать компилятору: “да, я осознанно печатаю Optional, покажи мне, что там внутри”.

3. Распаковка значений из словаря

if let: базовый и самый читаемый вариант

Теперь перейдём к самому практичному: вы хотите получить значение, если оно есть, и нормально обработать ситуацию, если его нет. Для этого вам знакомый по прошлым темам инструмент — if let.

В контексте словаря это читается почти как русский: “если по ключу лежит значение — возьми его”.

let prices: [String: Int] = ["coffee": 250, "tea": 180]

if let teaPrice = prices["tea"] {
    print("Tea costs \(teaPrice)")   // Tea costs 180
} else {
    print("No tea in price list")
}

Обратите внимание на две вещи. Во-первых, внутри ветки if переменная teaPrice уже типа Int, а не Int?. То есть Swift “разрешил вам жить без Optional” в том месте, где вы доказали, что значение есть. Во-вторых, код получается честным: мы не притворяемся, что ключ существует.

guard let: «проверил и пошёл дальше»

Когда вы пишете функции, очень быстро надоедает вкладывать логику в “лесенки” if/else. Особенно если у вас есть несколько проверок подряд: “есть ли ключ, правильно ли введено, не пустая ли строка…” В таких случаях стиль Swift обычно предлагает guard let: “если условия не выполнены — выходим сразу”.

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

func printPrice(for item: String, in prices: [String: Int]) {
    guard let price = prices[item] else {
        print("No price for '\(item)'")
        return
    }

    print("'\(item)' costs \(price)")
}

printPrice(for: "coffee", in: ["coffee": 250]) // 'coffee' costs 250
printPrice(for: "cake", in: ["coffee": 250])   // No price for 'cake'

Заметьте, как читается функция: сначала “валидация”, потом “нормальный путь”. Это очень снижает шанс сделать логику кривой.

Нельзя сравнивать и считать, пока значение — Optional

Очень типичный новичковый сценарий: вы достали значение из словаря и сразу хотите сравнить его с числом.

Например, вы хотите проверить “есть ли товара больше нуля”:

let stock: [String: Int] = ["pen": 3]
let count = stock["pen"]        // Int?
if count > 0 { ... }         // ❌ так нельзя

Swift не позволит сравнить Int? и Int, и это хорошо: сравнение “возможно отсутствующего значения” — логически странная операция. В комьюнити разработчиков Swift отдельно обсуждали, что сравнения Optional могут приводить к неожиданным эффектам и их лучше избегать без явной распаковки.

Правильный вариант — распаковать:

let stock: [String: Int] = ["pen": 3]

if let count = stock["pen"] {
    if count > 0 {
        print("In stock: \(count)")  // In stock: 3
    } else {
        print("Out of stock")
    }
} else {
    print("No such item")
}

Да, кода чуть больше. Зато логика честная: “нет ключа” и “нулевой остаток” — разные случаи.

Проверка != nil + повторное чтение — плохой стиль

Иногда пишут так: “если ключ существует, тогда прочитаем значение”.

// ❌ пример плохого стиля (но компилируемый)
if catalog["b1"] != nil {
    print(catalog["b1"]!) // два обращения + force unwrap
}

Здесь сразу две проблемы. Первая — вы читаете словарь дважды, а это лишняя работа и лишний шанс ошибиться при рефакторинге. Вторая — вы всё равно используете !, то есть если код когда-нибудь изменится (или ключ поменяется), вы получите падение.

Правильнее — “одним движением”:

if let title = catalog["b1"] {
    print(title)
}

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

4. Дефолты и !: где граница между удобством и хрупкостью

??: когда дефолт действительно имеет смысл

Иногда отсутствие значения — это не ошибка, а нормальная ситуация, где вы хотите подставить разумный дефолт. Например, если вы показываете “количество просмотров”, а ключа ещё нет — можно считать, что просмотров 0. Или вы храните “настройку громкости”, и если ключа нет — громкость по умолчанию 50.

Вот тут идеально подходит ??:

let views: [String: Int] = ["home": 120, "profile": 5]

let aboutViews = views["about"] ?? 0
print("About page views: \(aboutViews)") // About page views: 0

Важная мысль: ?? — это не “починка Optional”, а ваш договор с логикой. Если отсутствие ключа и значение 0 для вас — разные смыслы, то ?? 0 будет ошибкой дизайна. Например, “возраст неизвестен” и “возраст 0” — это не одно и то же.

Почему dict[key]! — плохая идея (почти всегда)

Иногда кажется: “Да ладно, я точно знаю, что ключ есть”. И рука тянется к !:

let age = ages["Ann"]! // 

Проблема не в том, что это “запрещено”. Проблема в том, что ! — это контракт уровня “если ключа нет, программа падает”. Словарь часто используется как хранилище данных “снаружи”: ввод пользователя, файл, сеть, результаты вычислений. В таких сценариях “программа падает” — это не нормальная ветка.

Если вы всё-таки используете !, пусть это будет осознанно: например, в учебном коде, где вы жёстко контролируете данные, или в ситуации, где отсутствие ключа означает баг разработчика (а не пользовательскую ошибку). Но в большинстве случаев для словаря — это слишком хрупко.

5. Мини-проект LibraryMini: поиск книги по id

Давайте продолжим развивать одну и ту же идею учебного приложения: мини-консольная “библиотека”. Пока без сложных типов и структур — мы ещё не дошли до struct, поэтому работаем на простых строках.

Пусть у нас есть словарь catalog, где ключ — это ID книги, а значение — её название. Пользователь вводит ID, а мы печатаем название или сообщаем, что книги нет.

Сначала — данные и ввод:

import Foundation

let catalog: [String: String] = [
    "b1": "Swift for Beginners",
    "b2": "Algorithms 101",
    "b3": "CLI Adventures"
]

print("Enter book id (b1/b2/b3):", terminator: " ")
let id = readLine() ?? ""

Теперь самое важное — безопасное чтение по ключу:

if let title = catalog[id] {
    print("Title: \(title)")
} else {
    print("No book with id '\(id)'")
}

Это тот момент, когда словарь и Optional работают вместе как команда: словарь не обещает, что ключ существует; optional заставляет вас обработать отсутствие.

Если хочется чуть более “функционально” (в смысле “короче и без ветвления”), можно подставить дефолт, но только если дефолт вам подходит:

let safeTitle = catalog[id] ?? "<unknown book>"
print("Title: \(safeTitle)")

Заметьте, здесь мы теряем возможность различать “книги реально нет” и “книга есть, но называется <unknown book>” (если бы вдруг такое название было). В реальных приложениях обычно полезнее первый вариант с if let, потому что он честнее.

6. Шпаргалка: какой способ распаковки выбрать

Когда вариантов несколько, новичкам важно не запоминать “по названиям”, а видеть смысл. Давайте зафиксируем это в одной таблице.

if let value = dict[key] { ... } else { ... }

guard let value = dict[key] else { return }

let v = dict[key] ?? defaultValue

dict[key]!

Про print добавлю маленькую тонкость: если вы хотите осознанно печатать optional, лучше писать as Any, чтобы явно показать намерение. Это связано с тем, что Optional может неявно попадать в Any, и Swift стремится предупреждать о таких местах.

7. Типичные ошибки при чтении из словаря

Ошибка №1: ожидать, что dict[key] возвращает “обычное значение”, а не Optional.
Это обычно проявляется так: студент пишет let age: Int = ages["Ann"] и получает ошибку типов. Лечится не “приведением типов” и не !, а пониманием модели: ключ может отсутствовать, значит результат — Int?, и его нужно распаковать через if let, guard let или осмысленный ??.

Ошибка №2: лечить все Optional через !, потому что “так компилируется”.
Да, компилируется. Но цена — падение программы в любой момент, когда ключ внезапно не найден (а словари часто живут рядом с вводом пользователя). Правильный подход — сначала решить, что для вас значит отсутствие ключа: это ошибка, “нет данных”, дефолт, или повод показать подсказку. И уже под это выбрать if let / guard let / ??.

Ошибка №3: смешивать “нет ключа” и “значение равно 0/пусто”.
Классика: хранить возраст, а при отсутствии ключа подставлять 0, после чего возраст 0 начинает вести себя как “данные существуют”. Это логическая ошибка, не синтаксическая. Нормальный стиль: если отсутствие — отдельное состояние, оставляйте nil и обрабатывайте его ветвлением, а не подменяйте “нет данных” на “данные равны нулю”.

Ошибка №4: пытаться сравнивать Optional напрямую (dict[key] > 0) или делать вычисления, не распаковав.
Swift запрещает это не из вредности, а чтобы вы не делали бессмысленных операций над “возможным отсутствием”. Важно принять правило: сравнения и арифметика делаются над обычными значениями (Int, Double), поэтому сначала распаковка. Дополнительно полезно помнить, что сравнения optional могут приводить к неожиданным семантикам, поэтому язык исторически ужесточал эту область.

Ошибка №5: “проверил != nil, потом ещё раз достал значение”.
Такой код почти всегда получается более хрупким: вы делаете два чтения, а ещё часто заканчиваете !. Намного проще и безопаснее сразу использовать if let, который одновременно проверяет наличие и даёт вам не-optional значение в теле ветки.

1

Задача

Swift SELF, 13 уровень, 2 лекция

Недоступна

Призрак Optional

Призрак Optional

Открыть

1

Задача

Swift SELF, 13 уровень, 2 лекция

Недоступна

Пульт границ

Пульт границ

Открыть

1

Задача

Swift SELF, 13 уровень, 2 лекция

Недоступна

Чек кофейни

Чек кофейни

Открыть

1

Задача

Swift SELF, 13 уровень, 2 лекция

Недоступна

Протокол экзамена

Протокол экзамена

Открыть