В чем разница между `let` и `var` в Swift? Когда что использовать?

Ключевое различие: изменяемость (мутабельность) vs неизменяемость (иммутабельность)

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

1. Базовое поведение для value-типов (структуры, перечисления, примитивы)

Для простых типов, таких как Int, String, Array, Dictionary и других структур, правило простое:

• var — вы можете изменить значение в любой момент.
• let — значение устанавливается один раз (при инициализации) и больше не может быть изменено.

Ваш пример с отложенной инициализацией let userName: String — это абсолютно корректный паттерн, который называется «отложенная инициализация константы». Компилятор гарантирует, что:

• Константа будет установлена ровно один раз перед первым использованием.
• Если вы попытаетесь прочитать userName до присвоения значения — получите ошибку компиляции.
• Если попытаетесь присвоить значение второй раз — тоже ошибка.

Это очень удобно, когда значение константы зависит от условий, вычисляемых в рантайме:

let userStatus: String
if isPremiumUser {
    userStatus = "Premium"
} else {
    userStatus = "Free"
}
// Теперь userStatus — константа, и никто случайно не изменит её позже

2. Поведение для reference-типов (классы)

Здесь начинается самое интересное. Когда вы объявляете ссылку на объект класса через let, вы запрещаете изменять ссылку (то есть указывать на другой объект), но не запрещаете изменять свойства самого объекта:

class Person {
    var name: String
    init(name: String) { self.name = name }
}

let person = Person(name: "Алексей")
person.name = "Иван" // ✅ Это работает! Свойство name объявлено как var
// person = Person(name: "Петр") // ❌ Ошибка! Нельзя изменить саму ссылку

Это важнейшее отличие от структур. Если бы Person был структурой:

struct PersonStruct {
    var name: String
}

let personStruct = PersonStruct(name: "Алексей")
// personStruct.name = "Иван" // ❌ Ошибка! Структура — value-тип, и let делает неизменяемым весь объект

3. Почему Apple рекомендует использовать let по умолчанию?

Есть несколько веских причин:

• Безопасность кода: Чем больше констант, тем меньше шансов случайно изменить значение там, где не нужно. Компилятор защищает вас от глупых ошибок.
• Производительность: Компилятор может оптимизировать константы более агрессивно, зная, что их значение не изменится.
• Читаемость: Когда другой разработчик видит let, он сразу понимает: «Это значение не изменится на протяжении всего жизненного цикла». Это упрощает понимание логики.
• Функциональное программирование: Swift поддерживает функциональный стиль, где иммутабельность (неизменяемость) — это норма. Это уменьшает количество побочных эффектов и делает код более предсказуемым.

Правило простое: используйте let всегда, когда не планируете изменять значение. Если компилятор скажет, что нужно var — тогда меняйте. Обычно в реальном коде соотношение let к var составляет примерно 80% на 20%.

4. Практический пример из жизни

Представьте, что вы пишете приложение для банковского счета:

class BankAccount {
    let accountNumber: String // Неизменяемый номер счета
    let ownerName: String     // Имя владельца (обычно не меняется)
    var balance: Double       // Баланс постоянно меняется
    
    init(accountNumber: String, ownerName: String, balance: Double) {
        self.accountNumber = accountNumber
        self.ownerName = ownerName
        self.balance = balance
    }
}

Здесь accountNumber и ownerName логически не должны меняться — это идеальные кандидаты для let. А balance будет меняться при каждой транзакции — поэтому var.

Итог: let — это не просто «константа», это обещание компилятору и другим разработчикам, что данное значение не будет изменено. Используйте это обещание щедро!

var mutableArray = [1, 2, 3]
mutableArray.append(4) // ✅ Можно

let immutableArray = [1, 2, 3]
// immutableArray.append(4) // ❌ Ошибка! Нельзя изменить содержимое

// Но! Если массив хранит ссылочные типы:
class Item { var value = 0 }
let items = [Item(), Item()]
items[0].value = 10 // ✅ Можно! Меняем свойство объекта, а не массив