Переменные, константы и вывод типов

В Swift есть два слова для хранения данных: let для констант и var для переменных. Выбор между ними — это уже проектное решение.

Суть урока: предпочитайте let. Неизменяемость по умолчанию делает код предсказуемым, помогает компилятору оптимизировать программу и предотвращает целый класс ошибок.

Когда мы храним данные, нужно решить: будет ли это значение меняться. Если нет — используем let (константа). Если да — var (переменная). Это не просто стилистика: компилятор Swift по-разному относится к этим двум случаям, и грамотный выбор экономит нервы.

let pi = 3.14159        // константа, изменить нельзя
var score = 0           // переменная, можно менять
score = score + 10      // ок
// pi = 3.0             // ошибка компиляции!

Заметьте: мы нигде не написали тип. Swift сам понял, что pi — это Double, а score — Int. Это называется вывод типов (type inference). Компилятор смотрит на значение справа и присваивает переменной соответствующий тип. Но иногда тип нужно указать явно — например, когда значения ещё нет:

let name: String = "Анна"
var age: Int = 25
var temperature: Double      // тип задан, значение позже
temperature = 36.6

Двоеточие после имени и тип — это аннотация типа. Она нужна, когда из значения тип неочевиден или когда вы хотите быть точнее (например, Float вместо Double).

Почему неизменяемость так важна? Представьте, что десять разных мест программы читают переменную. Если она может измениться в любой момент, отследить логику тяжело. Константа же даёт гарантию: значение не дрогнет. В мире SwiftUI это особенно ценно — там неизменяемость лежит в основе всего.

Попробуй сам ▶ — запусти код прямо в браузере (Pyodide). Здесь нет Swift, но логика та же, что под капотом мобильного кода:

# Аналог в Python: "константа" — это просто соглашение (имя капсом),
# но логику неизменяемости можно прочувствовать.
PI = 3.14159   # как let — мы договорились не менять
score = 0      # как var

score = score + 10
print('score =', score)
print('PI =', PI)

# Swift запретил бы менять PI на этапе компиляции —
# Python же доверяет дисциплине программиста.

Как работает под капотом

Когда вы пишете let, компилятор знает, что значение не изменится, и может разместить его эффективнее, иногда даже встроив прямо в машинный код (constant folding). Для var компилятор обязан выделить изменяемую ячейку памяти. Кроме того, неизменяемость критична для многопоточности: к константе можно безопасно обращаться из разных потоков, что напрямую связано со строгой моделью Swift 6.

Частые ошибки

Использовать var везде «на всякий случай». Компилятор выдаст предупреждение, если var ни разу не меняется, и предложит заменить на let.
Забыть аннотацию там, где значение откладывается. Без значения и без типа Swift не сможет вывести тип — будет ошибка.
Смешивать типы. Нельзя присвоить String переменной типа Int — Swift строго типизирован.

Best practices

Начинайте с let, меняйте на var только когда компилятор этого потребует.
Давайте переменным осмысленные имена в стиле camelCase: userName, totalPrice.
Полагайтесь на вывод типов для очевидных случаев, но добавляйте аннотацию ради читаемости публичных API.

Итоги. let — это обещание неизменяемости, var — разрешение на изменение. Вывод типов избавляет от лишнего шума, а аннотация добавляет точности. Привычка предпочитать let — один из главных маркеров зрелого Swift-кода.

Шире контекста

Привычка к неизменяемости — это не только про корректность, но и про читаемость кода в команде. Когда коллега видит let, он мгновенно понимает: это значение зафиксировано, его не нужно держать в голове как «движущуюся цель». Каждое var, наоборот, — сигнал «здесь возможны изменения, будь внимателен». В больших проектах это снижает когнитивную нагрузку и количество багов. Кроме того, неизменяемость напрямую связана с темами, которые ждут нас впереди: структуры-значения, чистые функции отрисовки в SwiftUI и безопасность при работе с несколькими потоками. Все они опираются на идею, что данные, которые не меняются, безопасно читать откуда угодно. Поэтому, выбирая между let и var, вы не просто пишете строчку — вы закладываете архитектурную привычку, которая будет окупаться на каждом следующем уроке курса.