Что такое Property Wrapper?

Что такое Property Wrapper?

Property Wrapper (обёртка свойства) — это механизм в Swift, который позволяет инкапсулировать общую логику работы с get и set свойств, обеспечивая повторное использование кода и сокращая boilerplate. Появился в Swift 5.1. По сути, это способ добавить слой абстракции между объявлением свойства и его фактическим хранением, позволяя централизованно управлять валидацией, трансформацией, синхронизацией или другими аспектами доступа к значению.

Как работает Property Wrapper?

Property Wrapper определяется как структура или класс, который реализует протоколы @propertyWrapper, содержит обязательное свойство wrappedValue. При применении к свойству через синтаксис @WrapperName, компилятор автоматически генерирует код доступа, делегируя его обёртке.

Пример простейшего Property Wrapper для ограничения значения:

@propertyWrapper
struct Clamped {
    private var value: Int
    let min: Int
    let max: Int

    init(wrappedValue: Int, min: Int, max: Int) {
        self.min = min
        self.max = max
        self.value = Self.clamp(wrappedValue, min: min, max: max)
    }

    var wrappedValue: Int {
        get { value }
        set { value = Self.clamp(newValue, min: min, max: max) }
    }

    private static func clamp(_ value: Int, min: Int, max: Int) -> Int {
        return max(min, min(value, max))
    }
}

// Использование
struct Exam {
    @Clamped(min: 0, max: 100) var score: Int = 0
}

var exam = Exam(score: 85)
exam.score = 120
print(exam.score) // 100 — значение ограничено максимумом

Ключевые компоненты Property Wrapper

1. wrappedValue — обязательное свойство, через которое происходит доступ к значению. Содержит геттер и сеттер с нужной логикой.
2. Инициализатор — может принимать wrappedValue и дополнительные параметры для конфигурации.
3. projectedValue — опциональное свойство, позволяющее предоставлять дополнительную функциональность (например, доступ к самому экземпляру обёртки). Доступ через синтаксис $propertyName.

Пример с projectedValue:

@propertyWrapper
struct Published<T> {
    private var value: T
    var publisher: (T) -> Void = { _ in }

    var wrappedValue: T {
        get { value }
        set {
            value = newValue
            publisher(newValue)
        }
    }

    var projectedValue: (T) -> Void {
        get { publisher }
        set { publisher = newValue }
    }
}

class ViewModel {
    @Published var text: String = ""
}

let viewModel = ViewModel()
viewModel.$text = { newValue in
    print("Text changed to: \(newValue)")
}
viewModel.text = "Hello" // Выведет: Text changed to: Hello

Практические применения Property Wrapper

• UserDefaults: автоматическая сериализация и сохранение.
• Thread Safety: атомарный доступ через мьютексы.
• Formatting: автоматическое форматирование строк или чисел.
• Dependency Injection: инъекция зависимостей с lazy-инициализацией.
• SwiftUI: @State, @Binding, @ObservedObject — все built-in обёртки, управляющие жизненным циклом и реактивностью.

Пример для UserDefaults:

@propertyWrapper
struct UserDefault<T> {
    let key: String
    let defaultValue: T

    var wrappedValue: T {
        get { UserDefaults.standard.object(forKey: key) as? T ?? defaultValue }
        set { UserDefaults.standard.set(newValue, forKey: key) }
    }
}

struct Settings {
    @UserDefault(key: "darkMode", defaultValue: false)
    static var isDarkMode: Bool
}

Преимущества и ограничения

Плюсы:

• Уменьшение дублирования кода: логика инкапсулирована в одном месте.
• Читаемость: синтаксис @Name делает намерения ясными.
• Гибкость: можно комбинировать несколько обёрток, применять к локальным переменным.

Ограничения:

• Нельзя применять к вычисляемым свойствам без явного хранилища.
• Могут быть проблемы с инициализацией в некоторых контекстах (например, внутри протоколов).
• Чрезмерное использование усложняет отладку из-за скрытой логики.

Заключение

Property Wrapper — мощный инструмент Swift, который превращает повторяющиеся паттерны доступа к свойствам в декларативные, reusable компоненты. Он активно используется в стандартных библиотеках (особенно SwiftUI) и позволяет писать более выразительный, поддерживаемый код. Понимание его работы критически важно для современных iOS-разработчиков, работающих с Swift 5.1 и выше.