Типы данных и объявление переменных в Swift

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ

Разработчику Архитектору

let / var, вывод типов, опционалы (if let, guard let), коллекции, struct и class в общих чертах.

Дальше: управление и switch → pattern matching · Работа с данными и коллекциями · Справочник Swift (таблицы Операции Array / Dictionary / Set)

---

Типы данных и объявление переменных в Swift

Теория

Статическая типизация, типобезопасность, составные типы, области видимости — типы данных

типизация

4.03.

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

---

Переменные и константы

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

Объявление переменной осуществляется с помощью ключевого слова var, а константы — с помощью let. После имени переменной или константы указывается её тип, хотя в большинстве случаев Swift способен вывести тип автоматически на основе присваиваемого значения. Например, запись let name = "Анна" создаёт константу типа String, а var age = 30 — переменную типа Int. Явное указание типа применяется, когда необходимо уточнить ожидаемый тип или когда значение инициализируется позже.

Имена переменных и констант в Swift могут содержать практически любые символы Unicode, включая эмодзи, что делает язык гибким, но в профессиональной практике рекомендуется использовать понятные, описательные имена на латинице. Имя должно начинаться с буквы или символа подчёркивания и не может совпадать с зарезервированными ключевыми словами языка.

let userName = "Анна"       // константа: тип String выведен автоматически
var score: Int = 0          // переменная: тип указан явно
score += 10                 // изменять можно только var

// userName = "Борис"      // ошибка компиляции: let переприсвоить нельзя

Разбор:

• let объявляет константу: после первого присваивания значение менять нельзя, компилятор отклонит попытку переписать userName.
• var объявляет переменную: score можно обновлять оператором +=, что эквивалентно score = score + 10.
• Двоеточие после имени (score: Int) задаёт тип явно; для userName компилятор вывел String из литерала "Анна".
• Подчёркивание в числе (1_000_000 в других примерах) — только разделитель для читаемости, на значение не влияет.
• В продакшене предпочтительнее let, а var оставляют для реально изменяемого состояния (счётчики, флаги UI).

---

Система типов в Swift

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

Типы данных в Swift делятся на две большие категории: значимые типы (value types) и ссылочные типы (reference types). Значимые типы включают все базовые скалярные типы, такие как целые числа, числа с плавающей точкой, булевы значения, строки, а также структуры и перечисления. При присваивании значимого типа или передаче его в функцию создаётся полная копия данных. Это гарантирует, что изменения в одной переменной не повлияют на другую, даже если они содержат одинаковые данные.

Ссылочные типы представлены классами. При работе с экземплярами класса переменная хранит не само значение, а ссылку на область памяти, где оно расположено. Если одна переменная ссылочного типа присваивается другой, обе переменные указывают на один и тот же объект в памяти. Изменение свойств объекта через одну переменную будет видно и через другую. Эта особенность требует особого внимания при проектировании архитектуры приложения, особенно в многопоточной среде.

---

Целочисленные типы

Swift предоставляет богатый набор целочисленных типов, отличающихся по размеру и знаковости. Целочисленные типы делятся на знаковые (signed) и беззнаковые (unsigned). Знаковые типы могут представлять как положительные, так и отрицательные числа, тогда как беззнаковые — только неотрицательные.

Основные знаковые целочисленные типы:

• Int8 — 8-битное целое число, диапазон от -128 до 127
• Int16 — 16-битное целое число, диапазон от -32 768 до 32 767
• Int32 — 32-битное целое число, диапазон от -2 147 483 648 до 2 147 483 647
• Int64 — 64-битное целое число, диапазон от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807
• Int — целое число, размер которого зависит от архитектуры платформы: 32 бита на 32-битных системах и 64 бита на 64-битных. Это предпочтительный тип для целых чисел, если нет специфических требований к размеру.

Беззнаковые аналоги — UInt8, UInt16, UInt32, UInt64 и UInt. Беззнаковые типы используются, когда известно, что значение никогда не будет отрицательным, например, при работе с индексами массивов, размерами буферов или цветовыми каналами.

Swift не допускает неявного преобразования между целочисленными типами. Даже присваивание значения Int8 переменной типа Int16 требует явного приведения. Это правило предотвращает скрытые ошибки, связанные с переполнением или усечением данных.

let small: Int8 = 100
let wide = Int(small)           // явное приведение Int8 -> Int

let total = 1_000_000 + 500_000 // Int, разделители _ для читаемости
let remainder = 17 % 5            // остаток от деления: 2
let isEven = (total % 2) == 0   // сравнение даёт Bool

Разбор:

• Int8 хранит узкий диапазон (−128…127); для "обычных" счётчиков чаще берут Int.
• Int(small) — инициализатор целевого типа: без него let wide: Int = small не скомпилируется.
• Оператор % работает только с целыми типами и возвращает остаток (здесь 17 % 5 → 2).
• == сравнивает два значения и возвращает Bool (true или false), не число.
• Явные приведения на границах API (например, UInt для индекса) снижают риск тихого переполнения.

---

Числа с плавающей точкой

Для представления дробных чисел Swift использует два основных типа: Float и Double. Тип Float представляет 32-битное число с плавающей точкой одинарной точности, обеспечивающее около 6–7 десятичных знаков точности. Тип Double — это 64-битное число двойной точности, обеспечивающее около 15–16 десятичных знаков. По умолчанию, если не указан тип явно, Swift выводит дробные литералы как Double.

Числа с плавающей точкой следуют стандарту IEEE 754, что гарантирует совместимость с другими системами и предсказуемое поведение при выполнении арифметических операций. Однако следует помнить, что числа с плавающей точкой не могут точно представлять все десятичные дроби, что может приводить к небольшим погрешностям в вычислениях. Для задач, требующих высокой точности, таких как финансовые расчёты, рекомендуется использовать специализированные типы, например Decimal.

let piApprox = 3.14          // Double по умолчанию
let ratio: Float = 0.5
let price = Decimal(string: "19.99")!

let sum = piApprox + 0.01    // Double + Double
// let mix = piApprox + ratio  // ошибка: разные типы без приведения

Разбор:

• Литерал 3.14 без суффикса — это Double; для Float пишут 0.5 с явной аннотацией или суффиксом.
• Decimal подходит для денег и налогов, где Double даёт артефакты вроде 0.1 + 0.2 != 0.3.
• Decimal(string:) возвращает опционал — инициализатор может вернуть nil при неверной строке.
• Смешивать Float и Double в одной операции нельзя; нужно явное приведение Double(ratio).
• Для графики и физики в играх часто хватает Float; для общей математики в коде — Double.

---

Булевый тип

Тип Bool в Swift представляет логическое значение и может принимать одно из двух состояний: true или false. Этот тип используется в условиях, циклах и логических выражениях. Swift требует, чтобы условия в конструкциях if, while и подобных были строго булевыми. Нельзя использовать целое число или строку в качестве условия, даже если оно не равно нулю или не пусто. Такое требование исключает неоднозначность и делает логику программы более явной.

let isLoggedIn = true
let attemptsLeft = 3

if isLoggedIn {
    print("Доступ разрешён")
}

// if attemptsLeft { }   // ошибка: в if нужен Bool, не Int

let canRetry = attemptsLeft > 0 && isLoggedIn

Разбор:

• Литералы true и false имеют тип Bool — отдельного ключевого слова для "да/нет" не требуется.
• В if и while выражение в скобках обязано быть Bool; Int, String и опционалы туда подставлять нельзя.
• attemptsLeft > 0 — сравнение, результат уже Bool; его можно комбинировать с && (логическое "и").
• && вычисляет правый операнд только если левый true (короткое замыкание) — полезно перед обращением к опционалу.
• Явные сравнения (> 0, == nil) делают намерение кода видимым при ревью.

---

Строки и символы

Тип String в Swift предназначен для работы с текстовыми данными. Он реализован как коллекция символов Unicode и поддерживает полную интернационализацию. Каждый символ в строке представлен как экземпляр типа Character, который может включать не только отдельные буквы, но и составные символы, такие как эмодзи с модификаторами кожи или флаги, состоящие из двух региональных индикаторов.

Строки в Swift являются значимым типом. При присваивании строки новой переменной создаётся копия данных, что гарантирует независимость изменений. Однако Swift использует механизм "ленивой копии" (copy-on-write): фактическое дублирование происходит только в момент, когда одна из строк изменяется. Это обеспечивает высокую производительность при работе с большими текстами.

Строки поддерживают интерполяцию — возможность встраивать значения переменных непосредственно в строковый литерал. Для этого используется синтаксис \(...) внутри двойных кавычек. Например, "Пользователь \(name) имеет возраст \(age) лет" создаст строку с подставленными значениями. Интерполяция работает с любыми типами, которые соответствуют протоколу CustomStringConvertible.

let name = "Мария"
let age = 28
let greeting = "Привет, \(name)! Тебе \(age) лет."

for character in "Swift 🚀" {
    print(character)   // Character, в том числе составные графемы
}

Разбор:

• String в Swift — value type с copy-on-write: копия буфера создаётся при первой записи в одну из копий строки.
• \(name) и \(age) — интерполяция: внутри строки подставляются текущие значения переменных.
• Цикл for-in по строке перебирает Character, а не "сырые" байты UTF-8 — корректно для эмодзи и составных символов.
• Конкатенация через + между String и Int без преобразования не компилируется; интерполяция или String(age) обязательны.
• Для логов и UI чаще используют интерполяцию вместо конкатенации — меньше шума и проще читать.

---

Опциональные типы

Одной из ключевых особенностей Swift является система опциональных типов. Опциональный тип указывает, что переменная может содержать значение определённого типа или отсутствовать вообще. Отсутствие значения обозначается ключевым словом nil. Любой тип в Swift может быть сделан опциональным путём добавления вопросительного знака после имени типа, например String?, Int?, Bool?.

Опциональные типы решают проблему "нулевых указателей", известную в других языках как источник множества ошибок. В Swift невозможно случайно обратиться к значению, которое может быть nil, без явной проверки. Для безопасной работы с опционалами используются механизмы распаковки — неявная распаковка (при уверенности, что значение существует), условная распаковка через if let или guard let, а также операторы нулевого слияния и цепочки опционалов.

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

Код ITЗагрузка примера кода…

Разбор:

• String? — опционал: либо .some("текст"), либо nil (значения нет).
• if let nick = nickname безопасно распаковывает опционал: тело выполняется только при наличии значения.
• ?? — оператор объединения с nil: если слева nil, берётся правый операнд ("Гость").
• guard let в функции требует return/throw в else и оставляет name доступным ниже по коду без вложенности.
• Принудительная распаковка nickname! допустима только при гарантии наличия значения; в остальных случаях — if let / guard let.

---

Кортежи

Кортеж (tuple) — это составной тип данных, позволяющий объединить несколько значений разных типов в одну упорядоченную группу. Кортежи особенно полезны для возврата нескольких значений из функции или временного хранения связанных данных без необходимости создавать полноценную структуру. Например, функция, возвращающая информацию о пользователе, может вернуть кортеж из имени, возраста и статуса активности — (String, Int, Bool).

Элементы кортежа доступны либо по позиции (.0, .1, .2), либо по именам, если они были заданы при объявлении. Именованные кортежи делают код более читаемым — let user = (name — "Мария", age: 28, isActive: true). После этого можно обращаться к полям как user.name, user.age, что приближает кортеж по удобству к простой структуре.

Кортежи не предназначены для сложной логики или наследования. Они служат лёгким, временным контейнером для связанных значений и не могут быть расширены через extension или использованы в качестве базового типа. Тем не менее, их гибкость и компактность делают их незаменимыми в локальных контекстах, особенно при обработке результатов операций, где требуется передать более одного значения.

Код ITЗагрузка примера кода…

Разбор:

• (major: Int, minor: Int) — именованный кортеж: поля доступны как version.major, а не только .0 / .1.
• Возвращаемый тип (…)? означает "кортеж или nil", если разбор строки не удался.
• split(separator:) режет String на части; Int(parts[0]) даёт Int?, поэтому нужен guard let.
• Кортеж удобен для 2–3 связанных значений; для модели с методами лучше struct.
• Именованные поля кортежа повышают читаемость по сравнению с анонимным (Int, Int).

---

Коллекции

Play ITЗагрузка интерактивного демо…

Play ITЗагрузка интерактивного демо…

Play ITЗагрузка интерактивного демо…

Play ITЗагрузка интерактивного демо…

Swift предоставляет три основных типа коллекций: массивы, множества и словари. Все они реализованы как обобщённые (generic) типы, что позволяет указывать точный тип хранимых элементов и обеспечивает строгую проверку на этапе компиляции.

Массив (Array) — это упорядоченная коллекция значений одного типа. Элементы массива индексируются целыми числами, начиная с нуля. Массивы в Swift являются значимыми типами, поэтому при присваивании создаётся копия. Однако, как и в случае со строками, применяется оптимизация "ленивой копии": физическое дублирование происходит только при изменении данных. Массивы поддерживают широкий набор операций — добавление, удаление, перебор, сортировка, фильтрация и преобразование через функции высшего порядка, такие как map, filter, reduce.

Множество (Set) — это неупорядоченная коллекция уникальных значений одного типа. Основное преимущество множества — эффективная проверка принадлежности: операция contains(_:) выполняется за константное время благодаря внутренней реализации на основе хеш-таблицы. Множества особенно полезны при работе с задачами, где важна уникальность элементов и отсутствие дубликатов, например, при сравнении двух групп пользователей или вычислении пересечений и объединений. Для использования в множестве тип элемента должен соответствовать протоколу Hashable.

Словарь (Dictionary) — это коллекция пар "ключ–значение", где каждый ключ уникален и ассоциирован с одним значением. Ключи также должны соответствовать протоколу Hashable, чтобы обеспечить быстрый доступ к значениям. Словари широко применяются для хранения конфигураций, кэширования данных, маппинга идентификаторов на объекты. Как и массивы, словари являются значимыми типами и поддерживают безопасный доступ через опциональные значения: попытка получить значение по несуществующему ключу возвращает nil.

Все три типа коллекций предоставляют унифицированный интерфейс для перебора через цикл for-in, поддержку литералов ([...] для массивов и словарей, Set([...]) для множеств), а также совместимость с функциональными методами обработки данных. Это делает работу с коллекциями в Swift единообразной, предсказуемой и выразительной.

var numbers = [3, 1, 4, 1, 5]
numbers.append(9)
numbers.sort()                          // [1, 1, 3, 4, 5, 9]

var tags: Set = ["swift", "ios", "swift"]
tags.insert("macos")                    // дубликат "swift" не добавится

var capitals: [String: String] = ["RU": "Москва", "FR": "Париж"]
capitals["DE"] = "Берлин"
let tokyo = capitals["JP"]              // String? — ключа нет → nil

let evens = numbers.filter { $0.isMultiple(of: 2) }

Разбор:

• Array упорядочен — индексы с нуля, append добавляет в конец, sort() меняет массив на месте.
• Set хранит уникальные элементы; повторная вставка того же значения игнорируется.
• Dictionary сопоставляет ключ и значение; чтение capitals["JP"] возвращает опционал, потому что ключа может не быть.
• Замыкание { $0.isMultiple(of: 2) } в filter оставляет только элементы, для которых предикат вернул true.
• Тип элементов коллекции задаётся при создании ([String: String], Set<String>) — смешивать типы в одном массиве без Any нельзя.

---

Пользовательские типы

Помимо встроенных скалярных и коллекционных типов, Swift позволяет создавать собственные типы данных. Основные механизмы для этого — структуры (struct) и классы (class). Оба подхода позволяют определять свойства (переменные и константы внутри типа) и методы (функции, связанные с типом), но различаются по семантике копирования и жизненному циклу.

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

Классы — это ссылочные типы. Все экземпляры класса разделяют одну и ту же область памяти, и изменения через одну переменную видны во всех других ссылках на тот же объект. Классы поддерживают наследование, переопределение методов, деструкторы (deinit) и механизмы управления памятью через автоматический подсчёт ссылок (ARC). Они подходят для представления сложных сущностей с общим состоянием — контроллеров, сетевых менеджеров, игровых объектов.

Выбор между структурой и классом — это архитектурное решение. Swift рекомендует использовать структуры по умолчанию, если нет явной необходимости в ссылочной семантике или наследовании. Такой подход способствует созданию более безопасного и тестируемого кода.

Код ITЗагрузка примера кода…

Разбор:

• struct Point — value type: при присваивании p2 = p1 копируются поля, изменение p2 не трогает p1.
• class Session — reference type: s1 и s2 указывают на один объект в памяти (ARC удерживает его, пока есть ссылки).
• У класса обязателен инициализатор init, если не заданы значения по умолчанию для всех свойств.
• DTO, координаты, настройки экрана обычно делают struct; делегаты, сетевые клиенты — class.
• Сравнение "одинаковые данные" у классов — через === (та же ссылка), у структур — через ==, если тип Equatable.

---

Copy-on-write (CoW)

У крупных value-типов (Array, String, Dictionary) копирование при присваивании не дублирует память сразу: пока обе переменные только читают данные, они разделяют один буфер. Реальная копия создаётся при первой записи в одну из копий. Поэтому передача Array в функцию недорога, пока функция не мутирует массив (или пока массив не объявлен как inout).

Практический вывод: модели данных и DTO чаще делают struct; общее изменяемое состояние UI или сервисов — class или actor.

var original = [1, 2, 3]
var alias = original       // буфер пока общий (CoW)
alias.append(4)            // копия создаётся при первой записи в alias
// original == [1, 2, 3], alias == [1, 2, 3, 4]

Разбор:

• Array, String, Dictionary — value types с оптимизацией copy-on-write (CoW).
• После var alias = original обе переменные могут разделять один буфер, пока их только читают.
• append меняет alias — в этот момент для него выделяется отдельная копия данных.
• original не меняется, поэтому передача массива в функцию "только для чтения" остаётся дешёвой.
• Если функция должна менять переданный массив, параметр помечают inout и вызывают с &array.

---

Перечисления

Перечисление (enum) — это тип, который определяет группу связанных значений как единое целое. В отличие от перечислений в некоторых других языках, Swift-перечисления могут содержать не только именованные случаи (case), но и ассоциированные значения любого типа. Это позволяет каждому случаю нести дополнительную информацию. Например, перечисление ошибок может включать сообщение и код: case networkError(code: Int, message: String).

Перечисления также могут иметь методы и вычисляемые свойства, что делает их мощным инструментом для моделирования состояний, вариантов поведения или категорий. Благодаря сопоставлению с образцом (switch), работа с перечислениями становится исключительно надёжной: компилятор требует обработки всех возможных случаев, если не используется default.

Перечисления часто используются для представления ограниченного набора состояний — статуса загрузки (idle, loading, success, failure), типа пользователя (guest, regular, admin), направления движения (north, south, east, west). Ассоциированные значения превращают перечисления в гибкие и выразительные конструкции, способные заменить целые иерархии классов в некоторых сценариях.

Код ITЗагрузка примера кода…

Разбор:

• enum перечисляет фиксированный набор case; вне этих вариантов значение иметь нельзя.
• success(data:) и failure(message:) — associated values: к случаю "привязаны" дополнительные данные.
• switch по enum должен покрыть все случаи — компилятор проверит исчерпываемость без default, если перечисление конечно.
• case .success(let data) извлекает связанное значение прямо в switch — удобная форма pattern matching.
• Состояния экрана, сетевые ответы и ошибки в Swift чаще моделируют enum, а не строковыми константами.

---

Типизация функций

В Swift функции также являются типами. Тип функции определяется её сигнатурой: типами параметров и возвращаемым типом. Например, функция, принимающая два целых числа и возвращающая целое, имеет тип (Int, Int) -> Int. Такие типы можно использовать для объявления переменных, передачи функций как аргументов или возврата из других функций.

Эта особенность лежит в основе функционального программирования в Swift. Она позволяет создавать гибкие API, где поведение определяется передаваемыми функциями — обработка событий, асинхронные колбэки, стратегии сортировки. Компилятор гарантирует соответствие сигнатур, что исключает ошибки несовместимости на этапе выполнения.

Функции могут быть вложенными, захватывать переменные из окружающего контекста (замыкания), и даже возвращать другие функции. Замыкания особенно полезны при работе с асинхронными операциями, обработкой коллекций и настройкой поведения компонентов. Swift оптимизирует работу с замыканиями, минимизируя накладные расходы и обеспечивая эффективное управление памятью.

---

Протоколы и обобщённое программирование

Хотя тема протоколов выходит за рамки базового обсуждения типов данных, она тесно связана с системой типов Swift. Протокол (protocol) определяет интерфейс — набор требований к свойствам и методам, которые должен реализовать тип. Любой тип (структура, класс, перечисление) может соответствовать одному или нескольким протоколам.

Протоколы лежат в основе обобщённого программирования в Swift. Функции и типы могут быть параметризованы через обобщения (generics), что позволяет писать универсальный код, работающий с любыми типами, удовлетворяющими заданным ограничениям. Общие определения и сравнение с другими языками — Обобщения и обобщённое программирование. Например, функция сортировки может принимать массив любого типа, если этот тип соответствует протоколу Comparable.

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

---

Безопасность типов и предотвращение ошибок

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

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

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

---

Управление памятью и владение данными

Swift использует автоматический подсчёт ссылок (Automatic Reference Counting, ARC) для управления памятью объектов ссылочных типов. Каждый раз, когда создаётся новая ссылка на экземпляр класса, счётчик ссылок увеличивается. Когда ссылка выходит из области видимости или устанавливается в nil, счётчик уменьшается. Как только счётчик достигает нуля, объект автоматически освобождается.

ARC работает без участия разработчика, но требует внимания при создании замыканий или делегатов, где возможны сильные циклические ссылки. В таких случаях используются слабые (weak) или несвязанные (unowned) ссылки, чтобы разорвать цикл и позволить объектам быть освобождёнными. Swift предоставляет чёткие правила для выбора между этими модификаторами, основанные на жизненном цикле объектов.

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

---

Совместимость и межтиповые операции

Swift не допускает смешивания значений разных типов без явного преобразования. Даже два целочисленных типа, такие как Int и UInt, не могут использоваться в одной арифметической операции без приведения. Это правило распространяется и на числа с плавающей точкой: нельзя сложить Float и Double напрямую.

Преобразование типов выполняется через инициализаторы целевого типа. Например, чтобы превратить Int в Double, используется запись Double(myInt). Такой подход делает все преобразования явными и контролируемыми. Разработчик видит каждую точку, где данные меняют форму, и может убедиться в корректности операции.

Строки и числа также не смешиваются автоматически. Конкатенация строки с числом требует либо интерполяции, либо явного преобразования числа в строку. Это исключает неожиданные результаты, такие как превращение числа в строку в одном контексте и в число — в другом.

---

Типы как граждане первого класса

В Swift типы являются полноценными сущностями, которые можно передавать, возвращать и хранить. Метатип — это тип самого типа, обозначаемый с помощью .Type. Например, String.self представляет метатип строки. Это позволяет писать код, который принимает решения на основе типа во время выполнения, создавать фабрики объектов или реализовывать сериализацию.

Метатипы особенно полезны при работе с обобщёнными функциями, рефлексией или динамической загрузкой компонентов. Хотя Swift не является динамическим языком в полной мере, он предоставляет достаточные инструменты для гибкой работы с типами там, где это необходимо, сохраняя при этом преимущества статической проверки.

---

Связанные материалы

• Параметры функций и читаемость API
• Сопоставление с образцом
• Управляющие конструкции

---

Практическое закрепление темы

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

---

Базовые правила для ежедневной разработки

• Используйте let по умолчанию, var только для действительно изменяемых значений.
• Для моделей данных чаще выбирайте struct, а class оставляйте для разделяемого состояния.
• Опционалы распаковывайте через guard let в начале функции для линейного чтения кода.
• На границе с API задавайте Codable-типы вместо сырых словарей.

---

Мини-антипример и исправление

struct BadUser {
    var id: Any
    var name: Any
}

struct User: Codable {
    let id: Int
    let name: String
    let email: String?
}

Разбор:

• BadUser с полями Any принимает что угодно — компилятор не проверяет тип на этапе сборки, ошибки всплывают в runtime при приведении.
• User использует конкретные типы (Int, String) и опциональный email: String? для поля, которое может отсутствовать в JSON.
• Codable на User даёт автоматическую сериализацию через JSONEncoder/JSONDecoder без ручного разбора словарей.
• let для id и name фиксирует идентичность записи после декодирования; изменяемым оставляют только то, что реально меняется в UI.
• В API-слое всегда предпочтительны узкие типы вместо Any — меньше as? и неожиданных крашей.

---

Что читать после этой статьи

• Работа с данными и коллекциями
• Сопоставление с образцом
• Параметры функций и читаемость API

---

Сквозной мини-кейс — типизация профиля пользователя

Задача — получить JSON с профилем, безопасно декодировать, отобразить имя и возраст, корректно обработать отсутствие поля email.

Код ITЗагрузка примера кода…

Разбор:

• UserProfile: Codable описывает контракт JSON: компилятор сгенерирует encode/decode, если все свойства тоже Codable.
• email: String? явно моделирует отсутствие поля в ответе API — без опционала пришлось бы подставлять пустую строку и путать "нет почты" с "пустой почтой".
• decodeProfile(from:) помечена throws: ошибка формата JSON или несовпадения типов уходит наверх вызывающему коду.
• JSONDecoder().decode(UserProfile.self, from: data) привязывает байты к типу UserProfile — опечатка в ключе даст DecodingError, а не тихий nil.
• label(for:) использует if let email — ветка с почтой и без неё разделены, принудительный profile.email! не нужен.

Польза этого подхода:

• Ошибки формата ловятся на этапе декодирования.
• email как String? явно показывает, что поле может отсутствовать.
• Компилятор не дает смешивать несовместимые типы в логике UI.

---

Анти-паттерны и типичные ошибки

Ошибка	Последствие	Как лучше
Широкие типы Any в моделях	runtime-ошибки и сложный код	конкретные Int/String/Bool + Codable
Принудительная распаковка !	краш при nil	if let, guard let, ??
class для простых DTO	лишняя ссылочная семантика	struct по умолчанию
Смешивать Int, Double, String без явного преобразования	неожиданные ошибки компиляции	явные преобразования на границах
Хранить “сырой” JSON в UI-слое	сложная поддержка экранов	декодирование в отдельном сервисе/репозитории
Нечитаемые имена переменных (a, x1, tmp)	трудная отладка	смысловые имена по домену

---