Swift学习之propertyWrapper

属性包装器给代码之间添加了一层分离层，它用来管理属性如何存储数据以及代码如何定义属性。比如说，如果你有一个提供线程安全检查或者把自身数据存入数据库的属性，你必须在每个属性里写相关代码。当你使用属性包装，你只需要在定义包装时写一遍就好了，然后把管理代码应用到多个属性上。

1、propertyWrapper

@propertyWrapper
struct TwelveOrLess {
    var wrappedValue: Int {
        get { return 1}
    }
}

• 1、定义一个属性包装器（propertyWrapper），需要用@propertyWrapper关键字声明一下。
• 2、必须要有wrappedValue属性，至少有一个get方法。

@propertyWrapper
struct TwelveOrLess {
    private var number = 0
    var wrappedValue: Int {
        get { return number }
        set { number = min(newValue, 12) }
    }
}

struct SmallRectangle {
    @TwelveOrLess var height: Int
    @TwelveOrLess var width: Int
}


var rectangle = SmallRectangle()
print(rectangle.height)
// Prints "0"
 
rectangle.height = 10
print(rectangle.height)
// Prints "10"
 
rectangle.height = 24
print(rectangle.height)

这个例子里需要让宽高都不能大于12，假如你自己直接要set,get方法就需要两遍差不多的代码。而使用属性包装，你只需要在定义包装时写一遍就好了，然后把管理代码应用到多个属性上。

truct  SmallRectangle{
    @TwelveOrLess var height: Int
    @TwelveOrLess var width: Int
    func test(){
        print(_height)
        print(height)
    }
}

print(_height) 输出：TwelveOrLess()
print(height)输出：24

• 使用属性包装器，编译器会为我们自动生成_height、height这两个属性。
  当你给属性应用包装时，编译器会为包装生成提供存储的代码以及通过包装访问属性的代码）

struct SmallRectangle {
    private var _height = TwelveOrLess()
    private var _width = TwelveOrLess()
    var height: Int {
        get { return _height.wrappedValue }
        set { _height.wrappedValue = newValue }
    }
    var width: Int {
        get { return _width.wrappedValue }
        set { _width.wrappedValue = newValue }
    }
}

• 这里有一个前面 SmallRectangle 的例子，它在 TwelveOrLess 结构体中显式地包装了自己的属性，而不是用 @TwelveOrLess 这个特性。
• _height 和 _width 属性存储了一个属性包装的实例， TwelveOrLess 。 height 和 width 的 getter 和 setter 包装了 wrappedValue 属性的访问。

2、通过属性包装映射值：

@propertyWrapper
struct SmallNumber {
    private var number = 0
    var projectedValue = false
    var wrappedValue: Int {
        get { return number }
        set {
            if newValue > 12 {
                number = 12
                projectedValue = true
            } else {
                number = newValue
                projectedValue = false
            }
        }
    }
}
struct SomeStructure {
    @SmallNumber var someNumber: Int
}
var someStructure = SomeStructure()
 
someStructure.someNumber = 4
print(someStructure.$someNumber)
// Prints "false"
 
someStructure.someNumber = 55
print(someStructure.$someNumber)
// Prints "true"

• 添加了projectedValue属性来定义一个映射值。
• 使用 s.$someNumber 来访问包装的映射值。在保存一个小数字比如四之后， s.$someNumber 的值是 false 。总之，在尝试保存一个过大的数字时映射的值就是 true 了，比如 55.
• wrappedValue: 属性包装存储的值； someNumber
  projectedValue：映射值，$someNumber；
  属性包装本身：SomeStructure()，_someNumber；

3、SwiftUI常见的propertyWrapper

@State、@Binding、@ObservedObject、@EnvironmentObject、@StateObject

4、模仿@State的一个propertyWrapper

import SwiftUI
struct ContentView: View {

    @Test var h = "20"
    var body: some View {
        VStack {
            
                
            Text("Hello, world!").foregroundColor(.red)
            Button {
                h = "100"
               
            } label: {
               
                Text("点击")
            }

        }
        
    }
}
 class Object{
    var value:String = ""
}
@propertyWrapper
struct Test{
     var object:Object = Object()
     var wrappedValue: String{
            get{
                return object.value
            }
            nonmutating  set{
                
                object.value = newValue
            }
     }
     init(wrappedValue: String) {
     self.object.value = wrappedValue
     }
}