5.14. Работа с данными

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

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

Работа с данными

Общие принципы работы с данными

В Swift данные представляются через типы. Язык строго типизирован, и все значения имеют определённый тип времени компиляции. Это позволяет избежать множества ошибок, связанных с несоответствием форматов или потерей информации. Swift предоставляет мощную систему значимых типов (struct), перечислений (enum) и классов (class), которые могут использоваться для моделирования сложных структур данных. Важной частью обработки данных является преобразование между внутренними представлениями программы и внешними форматами, такими как текстовые файлы, бинарные потоки или сетевые пакеты.

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

Работа с файлами

Swift использует фреймворк Foundation для доступа к файловой системе. Все операции с файлами выполняются через класс FileManager. Этот класс предоставляет методы для создания, чтения, записи, перемещения, копирования и удаления файлов и директорий. Путь к файлу задаётся с помощью типа URL, который обеспечивает безопасную и читаемую работу с локальными и удалёнными ресурсами.

Чтение содержимого файла осуществляется с помощью метода contentsOfDirectory(at:includingPropertiesForKeys:options:) для получения списка файлов в директории или contents(atPath:) для загрузки данных из конкретного файла. Запись выполняется через write(toFile:atomically:encoding:) для строк или write(to:) для сырых данных (Data). Все операции с файлами могут выбрасывать ошибки, поэтому они оборачиваются в блок do-catch.

Swift поддерживает как текстовые, так и бинарные форматы. Текстовые файлы обычно обрабатываются как строки (String), а бинарные — как экземпляры типа Data. Преобразование между этими типами возможно при указании кодировки (например, UTF-8).

Файловая система в среде Apple ограничена песочницей приложения. Приложение имеет доступ только к своему собственному контейнеру и к тем областям, которые явно предоставлены пользователем через системные диалоги (например, UIDocumentPickerViewController на iOS или NSOpenPanel на macOS). Это требует аккуратного проектирования архитектуры хранения данных, особенно если приложение должно обмениваться файлами с другими программами или использовать облачные хранилища.

Сериализация и десериализация: JSON

JSON (JavaScript Object Notation) — это основной формат обмена данными в современных приложениях. Swift предоставляет встроенную поддержку JSON через класс JSONEncoder и JSONDecoder. Эти классы работают с типами, соответствующими протоколу Codable.

Протокол Codable объединяет два других протокола: Encodable (для преобразования объекта в JSON) и Decodable (для обратного преобразования). Большинство стандартных типов Swift — такие как Int, Double, String, Bool, массивы и словари — уже соответствуют Codable. Пользовательские структуры и классы также становятся совместимыми с JSON, если все их свойства поддерживают Codable.

Пример:

struct User: Codable {
    var name: String
    var age: Int
}

Такой тип можно легко сериализовать в JSON:

let user = User(name: "Анна", age: 28)
let encoder = JSONEncoder()
let jsonData = try encoder.encode(user)
let jsonString = String(data: jsonData, encoding: .utf8)

И десериализовать обратно:

let decoder = JSONDecoder()
let restoredUser = try decoder.decode(User.self, from: jsonData)

Swift позволяет настраивать процесс кодирования и декодирования. Например, можно указать соответствие между именами свойств в Swift и ключами в JSON с помощью CodingKeys. Это полезно, когда сервер использует имена в стиле snake_case, а в коде принято использовать camelCase.

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

Работа с XML

В отличие от JSON, Swift не предоставляет встроенной поддержки XML. Однако XML остаётся важным форматом в корпоративных системах, документах Office и некоторых API. Для работы с XML в Swift используются сторонние библиотеки.

Одной из популярных библиотек является SWXMLHash. Она предоставляет простой и читаемый интерфейс для парсинга XML-документов. Библиотека загружает XML как древовидную структуру, где каждый узел может быть доступен по имени тега или атрибуту.

Пример использования:

let xml = """
<book id="123">
    <title>Вселенная IT</title>
    <author>Тимур Тагиров</author>
</book>
"""

let parsed = SWXMLHash.parse(xml)
let title = parsed["book"]["title"].element?.text
let author = parsed["book"]["author"].element?.text

Другие библиотеки, такие как AEXML или XMLMapper, предлагают альтернативные подходы — от DOM-подобного представления до декларативного маппинга на структуры Swift, аналогичного Codable.

Поскольку XML более сложен по структуре (поддерживает пространства имён, CDATA, комментарии, атрибуты), его обработка требует больше внимания к деталям. В большинстве мобильных приложений XML используется реже, чем JSON, но при необходимости интеграции с унаследованными системами он остаётся актуальным.

Работа с базами данных

Swift не имеет встроенной поддержки реляционных баз данных, таких как SQLite или PostgreSQL. Однако экосистема предоставляет множество решений для локального и удалённого хранения данных.

Core Data

Core Data — это фреймворк от Apple для управления объектной моделью приложения. Он не является базой данных в классическом понимании, хотя может использовать SQLite в качестве одного из возможных хранилищ. Core Data работает с объектами, а не с таблицами, и предоставляет высокоуровневый API для сохранения, поиска, фильтрации и отслеживания изменений.

Модель данных в Core Data описывается визуально через .xcdatamodeld-файл или программно через NSManagedObjectModel. Каждый объект представлен подклассом NSManagedObject. Core Data поддерживает отношения между объектами, наследование, валидацию и миграцию схемы.

Преимущества Core Data:

Глубокая интеграция с экосистемой Apple.
Поддержка фоновых очередей (NSManagedObjectContext).
Автоматическое управление жизненным циклом объектов.
Возможность синхронизации через CloudKit.

Недостатки:

Сложность при работе с большими объёмами данных.
Ограниченная гибкость по сравнению с SQL.
Отсутствие поддержки на Linux (что важно для серверных приложений на Swift).

SQLite

SQLite — это встраиваемая реляционная база данных, широко используемая в мобильных приложениях. В Swift для работы с SQLite применяются обёртки, такие как SQLite.swift или GRDB.

SQLite.swift предоставляет типобезопасный DSL для написания SQL-запросов. Он позволяет создавать таблицы, вставлять записи, выполнять выборки с фильтрацией и сортировкой, всё это с проверкой типов на этапе компиляции.

Пример:

let db = try Connection("path/to/database.sqlite3")
let users = Table("users")
let id = Expression<Int64>("id")
let name = Expression<String>("name")

try db.run(users.create { t in
    t.column(id, primaryKey: true)
    t.column(name)
})

try db.run(users.insert(name <- "Мария"))

GRDB предлагает более продвинутые возможности: поддержку Codable, миграции, наблюдение за изменениями и интеграцию с Combine. Он считается одним из самых зрелых решений для работы с SQLite в Swift.

Realm

Realm — это альтернативная база данных, разработанная специально для мобильных платформ. Она хранит данные в собственном бинарном формате и обеспечивает высокую производительность даже при работе с миллионами записей. Realm использует объектную модель, похожую на Core Data, но с более простым API.

Объекты в Realm наследуются от Object, и их свойства объявляются как динамические переменные:

class Person: Object {
    @Persisted var name: String = ""
    @Persisted var age: Int = 0
}

Realm поддерживает живые коллекции, реактивные обновления и синхронизацию через Realm Sync. Однако он является проприетарным решением, и его использование может повлечь лицензионные ограничения в коммерческих проектах.

ORM в Swift

Термин «ORM» (Object-Relational Mapping) в контексте Swift применяется условно. Поскольку большинство решений ориентированы на мобильные устройства, где нет полноценных серверных СУБД, ORM чаще заменяются на объектные хранилища (Core Data, Realm) или легковесные обёртки над SQLite.

Тем не менее, библиотеки вроде GRDB и SQLite.swift реализуют принципы ORM: они отображают объекты Swift на строки таблиц, обеспечивают типобезопасные запросы и управляют транзакциями. В серверных приложениях на Swift (например, с использованием Vapor или Kitura) применяются более традиционные ORM, такие как Fluent.

Fluent — это ORM, встроенный во фреймворк Vapor. Он поддерживает несколько драйверов: PostgreSQL, MySQL, SQLite и MongoDB. Fluent позволяет описывать модели как структуры, соответствующие протоколу Model, и выполнять запросы через цепочки методов:

let users = try await User.query(on: database)
    .filter(\.$age > 18)
    .all()

Fluent поддерживает отношения «один ко многим», «многие ко многим», миграции и агрегатные функции. Это делает его полноценным ORM для серверной разработки на Swift.

Работа с сетевыми данными

Современные приложения редко ограничиваются только локальными данными. Большинство из них взаимодействуют с удалёнными серверами через HTTP-запросы. В Swift для этого используется фреймворк URLSession, входящий в состав Foundation.

URLSession предоставляет гибкий и асинхронный API для загрузки данных по сети. Он поддерживает как простые GET-запросы, так и сложные сценарии: отправку форм, загрузку файлов, фоновые задачи, авторизацию и работу с потоками.

Простейший запрос выглядит так:

let url = URL(string: "https://api.example.com/users")!
let task = URLSession.shared.dataTask(with: url) { data, response, error in
    if let data = data {
        // Обработка полученных данных
    }
}
task.resume()

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

При работе с сетью важно учитывать:

Обработку ошибок: отсутствие интернета, недоступность сервера, неверный формат ответа.
Парсинг ответа: обычно данные приходят в формате JSON, поэтому сразу после получения Data их декодируют с помощью JSONDecoder.
Типизация ответов: использование собственных структур, соответствующих Codable, позволяет избежать работы с сырыми словарями.

Для удобства многие разработчики используют сторонние библиотеки, такие как Alamofire. Она предоставляет более высокоуровневый API, включая автоматическую сериализацию, цепочки запросов, мониторинг прогресса и встроенную поддержку заголовков, кук и авторизации. Однако в большинстве случаев стандартного URLSession достаточно, особенно если приложение не требует сложной сетевой логики.

Кэширование данных

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

На уровне системы URLSession поддерживает HTTP-кэширование. Если сервер указывает заголовки Cache-Control или ETag, система может автоматически использовать закэшированный ответ без обращения к сети. Это работает прозрачно для разработчика, но требует корректной настройки сервера.

Для более гибкого контроля применяется ручное кэширование. Например, после получения данных с сервера их можно сохранить в памяти (через Dictionary или NSCache) или на диск (в виде файла или записи в Core Data/SQLite). Это особенно полезно для:

Отображения данных при отсутствии интернета.
Ускорения запуска приложения.
Снижения потребления трафика.

Библиотека Kingfisher (для изображений) или Disk (для общих данных) предлагают готовые решения для дискового кэширования с TTL (временем жизни), размером кэша и автоматической очисткой.

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

Обработка ошибок

Swift использует механизм throwing functions и блоки do-catch для обработки ошибок. Все операции, связанные с данными — чтение файла, парсинг JSON, сетевой запрос — могут завершиться неудачей, и компилятор требует явной обработки таких случаев.

Ошибки в Swift описываются через протокол Error. Часто используются перечисления:

enum DataError: Error {
    case invalidURL
    case noData
    case decodingFailed
}

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

В сетевых запросах проверяются три условия:

Наличие error — означает сбой соединения.
Наличие data — если данных нет, запрос не вернул тело.
Корректность HTTPStatusCode — даже успешное соединение может вернуть 404 или 500.

Хорошая практика — централизовать обработку ошибок. Например, создать функцию handleNetworkError(_:), которая преобразует технические ошибки в понятные пользователю сообщения.

Управление состоянием данных

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

NotificationCenter — простой способ отправки уведомлений между компонентами. Однако он легко приводит к «спагетти-коду», если не контролировать поток событий.

Combine — реактивный фреймворк от Apple, позволяющий работать с асинхронными потоками данных. Он поддерживает операторы вроде map, filter, debounce, что делает обработку данных декларативной. Например, можно подписаться на изменения в базе данных и автоматически обновлять интерфейс.

Async/Await (начиная с Swift 5.5) упрощает написание асинхронного кода. Вместо замыканий можно писать последовательные вызовы:

let users = try await fetchUsers()
let filtered = users.filter { $0.isActive }

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

Для глобального состояния часто используют Singleton-сервисы или dependency injection. Например, UserDataManager хранит текущего пользователя и уведомляет подписчиков при его изменении. Такой подход масштабируется лучше, чем передача данных через параметры.

Безопасность данных

Работа с данными включает и вопросы безопасности. Чувствительная информация — токены, пароли, персональные данные — не должна храниться в открытом виде.

В iOS и macOS для этого используется Keychain — защищённое хранилище, управляемое операционной системой. Доступ к нему осуществляется через фреймворк Security или упрощённые обёртки вроде KeychainAccess.

Keychain шифрует данные аппаратно и привязывает их к приложению. Даже при резервном копировании эти данные не попадают в iCloud, если явно не разрешено.

Также важно:

Использовать HTTPS для всех сетевых запросов.
Проверять сертификаты сервера (SSL pinning).
Не логировать чувствительные данные в консоль или аналитику.

Работа с данными​

Общие принципы работы с данными​

Работа с файлами​

Сериализация и десериализация: JSON​

Работа с XML​

Работа с базами данных​

Core Data​

SQLite​

Realm​

ORM в Swift​

Работа с сетевыми данными​

Кэширование данных​

Обработка ошибок​

Управление состоянием данных​

Безопасность данных​