一、啥是属性包装器
咱先来说说属性包装器是个啥。在 Swift 里，属性包装器就像是一个“小帮手”，它能把属性的存储和访问逻辑给封装起来。简单来讲，就是你可以把一些通用的代码逻辑放到属性包装器里，这样就不用在每个属性里重复写这些代码啦。
举个例子，假如你有很多属性都需要做一些验证，每次都在属性设置的时候写验证代码就很麻烦。用属性包装器就能把验证逻辑封装起来，让代码更简洁。
// Swift 技术栈
// 定义一个属性包装器，用于验证整数是否大于 0
@propertyWrapper
struct PositiveInt {
private var value: Int
init(wrappedValue: Int) {
// 如果传入的值小于等于 0，就把值设为 1
self.value = wrappedValue > 0 ? wrappedValue : 1
}
var wrappedValue: Int {
get { return value }
set {
// 每次设置值的时候都进行验证
value = newValue > 0 ? newValue : 1
}
}
}
// 使用属性包装器
struct User {
@PositiveInt var age: Int
}
var user = User()
user.age = -5
print(user.age) // 输出 1，因为 -5 不满足大于 0 的条件，被设置成了 1
在这个例子里，PositiveInt 就是一个属性包装器，它把验证整数是否大于 0 的逻辑封装起来了。在 User 结构体里使用 @PositiveInt 来修饰 age 属性，这样每次设置 age 的值时，都会自动进行验证。
二、应用场景
1. 数据验证
就像上面那个例子，数据验证是属性包装器很常见的应用场景。比如你有一个表单，里面有很多输入框，每个输入框都有自己的验证规则。你可以用属性包装器把这些验证规则封装起来，让代码更清晰。
// Swift 技术栈
// 定义一个属性包装器，用于验证字符串长度
@propertyWrapper
struct ValidatedString {
private var value: String
private let minLength: Int
private let maxLength: Int
init(wrappedValue: String, minLength: Int, maxLength: Int) {
self.minLength = minLength
self.maxLength = maxLength
// 对传入的字符串进行长度验证
if wrappedValue.count < minLength {
self.value = String(repeating: " ", count: minLength)
} else if wrappedValue.count > maxLength {
self.value = String(wrappedValue.prefix(maxLength))
} else {
self.value = wrappedValue
}
}
var wrappedValue: String {
get { return value }
set {
// 每次设置值的时候都进行长度验证
if newValue.count < minLength {
value = String(repeating: " ", count: minLength)
} else if newValue.count > maxLength {
value = String(newValue.prefix(maxLength))
} else {
value = newValue
}
}
}
}
// 使用属性包装器
struct Profile {
@ValidatedString(minLength: 3, maxLength: 10) var name: String
}
var profile = Profile()
profile.name = "a"
print(profile.name) // 输出 " "，因为 "a" 长度小于 3，被设置成了长度为 3 的空格字符串
2. 数据存储
属性包装器还可以用来处理数据的存储。比如你想把一些数据存储到 UserDefaults 里，每次读写数据都要写很多代码。用属性包装器就能把这些代码封装起来。
// Swift 技术栈
import Foundation
// 定义一个属性包装器，用于将数据存储到 UserDefaults
@propertyWrapper
struct UserDefaultWrapper<T> {
let key: String
let defaultValue: T
var wrappedValue: T {
get {
return UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
}
set {
UserDefaults.standard.set(newValue, forKey: key)
}
}
}
// 使用属性包装器
struct AppSettings {
@UserDefaultWrapper(key: "isDarkMode", defaultValue: false) var isDarkMode: Bool
}
var settings = AppSettings()
settings.isDarkMode = true
print(settings.isDarkMode) // 输出 true，并且已经把 true 存储到了 UserDefaults 里
3. 延迟加载
有时候我们希望某个属性在第一次使用的时候才进行初始化，这就是延迟加载。属性包装器可以很方便地实现延迟加载。
// Swift 技术栈
// 定义一个属性包装器，用于实现延迟加载
@propertyWrapper
struct LazyWrapper<T> {
private var lazyValue: T?
private let initializer: () -> T
init(initializer: @escaping () -> T) {
self.initializer = initializer
}
var wrappedValue: T {
if lazyValue == nil {
lazyValue = initializer()
}
return lazyValue!
}
}
// 使用属性包装器
struct HeavyObject {
init() {
print("HeavyObject initialized")
}
}
struct Container {
@LazyWrapper { HeavyObject() } var heavyObject: HeavyObject
}
var container = Container()
// 第一次访问 heavyObject 时才会初始化 HeavyObject
print("About to access heavyObject")
print(container.heavyObject)
三、技术优缺点
优点
- 代码复用：属性包装器可以把一些通用的逻辑封装起来，在多个属性里复用，避免了代码的重复编写。比如上面的数据验证和数据存储的例子，都可以在不同的结构体里使用同一个属性包装器。
- 代码简洁：使用属性包装器可以让代码更简洁，把一些复杂的逻辑隐藏起来，让属性的定义更清晰。
- 提高可维护性：当需要修改某个逻辑时，只需要修改属性包装器里的代码，而不需要在每个使用该属性的地方都进行修改。
缺点
- 增加理解成本：对于初学者来说，属性包装器可能有点难以理解，因为它引入了新的概念和语法。
- 过度使用会导致代码复杂：如果滥用属性包装器，会让代码变得复杂，难以维护。比如在一个小项目里，为了一点点小功能就使用属性包装器，可能会让代码变得臃肿。
四、注意事项
- 初始化顺序：属性包装器的初始化顺序可能会影响代码的行为。在使用属性包装器时，要注意初始化的顺序，确保属性包装器在正确的时机进行初始化。
- 内存管理：如果属性包装器里持有一些大对象，要注意内存管理，避免出现内存泄漏的问题。比如在延迟加载的属性包装器里，如果
initializer闭包持有了一些大对象，要确保在不需要的时候及时释放。 - 命名规范：属性包装器的命名要清晰，能够准确表达其功能。比如
PositiveInt这个属性包装器，从名字就能看出它是用于验证整数是否为正数的。
五、文章总结
属性包装器是 Swift 里一个很有用的特性，它可以把属性的存储和访问逻辑封装起来，让代码更简洁、更易于维护。它的应用场景很广泛，包括数据验证、数据存储、延迟加载等。虽然属性包装器有很多优点，但也有一些缺点，比如增加理解成本和可能导致代码复杂。在使用属性包装器时，要注意初始化顺序、内存管理和命名规范等问题。总之，合理使用属性包装器可以让你的 Swift 代码更加优雅。
评论