Swift學(xué)習(xí)之propertyWrapper

一、基本介紹

屬性包裝器給代碼之間添加了一層分離層，它用來管理屬性如何存儲數(shù)據(jù)以及代碼如何定義屬性。比如說，如果你有一個提供線程安全檢查或者把自身數(shù)據(jù)存入數(shù)據(jù)庫的屬性，你必須在每個屬性里寫相關(guān)代碼。當(dāng)你使用屬性包裝，你只需要在定義包裝時寫一遍就好了，然后把管理代碼應(yīng)用到多個屬性上。

1、propertyWrapper
@propertyWrapper
struct TwelveOrLess {
    var wrappedValue: Int {
        get { return 1}
    }
}
  • 1、定義一個屬性包裝器（propertyWrapper），需要用@propertyWrapper關(guān)鍵字聲明一下。
  • 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方法就需要兩遍差不多的代碼。而使用屬性包裝，你只需要在定義包裝時寫一遍就好了，然后把管理代碼應(yīng)用到多個屬性上。

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

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

  • 使用屬性包裝器，編譯器會為我們自動生成_height、height這兩個屬性。
    當(dāng)你給屬性應(yīng)用包裝時，編譯器會為包裝生成提供存儲的代碼以及通過包裝訪問屬性的代碼） 
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 結(jié)構(gòu)體中顯式地包裝了自己的屬性，而不是用 @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 來訪問包裝的映射值。在保存一個小數(shù)字比如四之后， s.$someNumber 的值是 false ?？傊?，在嘗試保存一個過大的數(shù)字時映射的值就是 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
     }
}

二、基礎(chǔ)實踐

2.1、本地歷史搜索

class History: Equatable,Codable{
    var searchStr = ""
    
    var  timestamp: String?
    // 實現(xiàn)Equatable協(xié)議
    static func == (lhs: History, rhs: History) -> Bool {
        // 在這里我們僅基于searchTerm判斷相等性，忽略timestamp
        return lhs.searchStr == rhs.searchStr
    }
}

@propertyWrapper
struct HistoryTracking {
    private var storage: String = ""
    private var historykey:String
    private var historys: [History] = [History]()
    var wrappedValue: String{
        set{
            storage = newValue
            
            let newHistory = History()
            newHistory.searchStr =  newValue
            newHistory.timestamp =   "\(Date().timestamp())"
            
            if let index = historys.firstIndex(where: { $0 == newHistory }) {
                historys.remove(at: index)
                historys.insert(newHistory, at: 0)
            } else {
                // 否則，添加新記錄
                historys.insert(newHistory, at: 0)
            }
            
            // 保持只保留最近的N條記錄，例如10條
            if historys.count > 10 {
                historys.removeLast(historys.count - 10)
            }
            
            if let jsonData = try? JSONEncoder().encode(historys) {
                UserDefaults.standard.set(jsonData, forKey: historykey)
                UserDefaults.standard.synchronize()
            }
            
        }
        get{
            
            return  self.storage
        }
        
    }
    
    //
    mutating func removeAllHistory(key:String){
        UserDefaults.standard.removeObject(forKey: historykey)
        UserDefaults.standard.synchronize()
        self.historys.removeAll()
    }
    
    mutating  func removeHistory(item:History){
        if let indext =   self.historys.firstIndex(of: item){
            self.historys.remove(at: indext)
            if let jsonData = try? JSONEncoder().encode(historys) {
                UserDefaults.standard.set(jsonData, forKey: historykey)
                UserDefaults.standard.synchronize()
            }
            
        }
        
    }
    
    
    
    // 通過projectedValue暴露歷史記錄
       var projectedValue: [History] {
           return historys
       }
    
    
    
    init(wrappedValue: String,historyKey: String) {
        self.storage = wrappedValue
        self.historykey = historyKey
        if let savedData = UserDefaults.standard.data(forKey: historykey),let historyArray = try? JSONDecoder().decode([History].self, from: savedData) {
            self.historys = historyArray
        }
    }
}






class TestViewController: UIViewController {
    @HistoryTracking(wrappedValue: "", historyKey: "searchTradmarkKey")
    var searchStr:String
    
    //加載歷史記錄數(shù)據(jù)
    func loadData() -> [History]{
        let dataArray = $searchStr
        return dataArray
    }
    
    //清楚歷史記錄
    func removeAllHistory(){
        var tracking:HistoryTracking  =  _searchStr
        tracking.removeAllHistory()
    }
    
    //清楚某條記錄
    func removeHistory(history:History){
        var tracking:HistoryTracking  =  _searchStr
        tracking.removeHistory(item: history)
    }
    
    //去搜索
    func goSearch(){
        //搜索新的字符串,并保存到本地記錄
        self.searchStr  = "hhh3ddd3"
    }


}

2.2、帶有默認(rèn)值合key的UserDefault

@propertyWrapper
struct UserDefault<T: Codable> {
    private var key: String
    private var defaultValue: T

    var wrappedValue: T {
        get {
            if let data = UserDefaults.standard.data(forKey: key) {
                do {
                    return try JSONDecoder().decode(T.self, from: data)
                } catch {
                    print("Error decoding data: \(error)")
                }
            }
            return defaultValue
        }

        set {
            do {
                let data = try JSONEncoder().encode(newValue)
                UserDefaults.standard.set(data, forKey: key)
                UserDefaults.standard.synchronize()
            } catch {
                print("Error encoding data: \(error)")
            }
        }
    }

    init(_ key: String, defaultValue: T) {
        self.key = key
        self.defaultValue = defaultValue
    }
}


struct AppUserDefaults{
    //是否是第一次
    @UserDefault("isFisrt",defaultValue: true)
    static  var isFirst:Bool
    
    //用戶是否同意了用戶協(xié)議
    @UserDefault("isAgree",defaultValue: false)
    static var isAgree:Bool
    
}

2.3、Codable類型不匹配處理


class Student:Codable {
    @Default var name:String
    @Default var age:Int
    required init(from decoder: any Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        _name = try container.decodeIfPresent(Default<String>.self, forKey: .name) ?? Default(wrappedValue: "")
        _age = try container.decodeIfPresent(Default<Int>.self, forKey: .age) ?? Default(wrappedValue:0)
    }
}

@propertyWrapper
struct Default<T:Codable>:Codable{
    var wrappedValue: T
    init(wrappedValue: T) {
        self.wrappedValue = wrappedValue
    }
    
    init(from decoder: any Decoder) throws {
        let container = try decoder.singleValueContainer()
        if T.self == String.self{
                 if let str  = try? container.decode(Int.self){
                     wrappedValue = "\(str)" as! T
                 }else if let str = try? container.decode(Bool.self){
                     wrappedValue = (str == true ? "0" : "1") as! T
                 }else if let str = try? container.decode(Double.self){
                     wrappedValue  = "\(str)" as! T
                 }else if let str = try? container.decode(Float.self){
                     wrappedValue  = "\(str)" as! T
                 }else{
                     wrappedValue = (try? container.decode(T.self)) ?? "" as! T
                 }
        }else{
            self.wrappedValue =   try! container.decode(T.self) 
        }

     }
}
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容