swift 自定义@

平时存东西,总用到 UserDefaults,每次使用取的时候很麻烦,提供一个好的简单的方案

0.首先定义一个存储读取的模型

///当单独存储 基本数据单元时,encode 会失败,所以搞个中间变量 ,因为单存储基本数据时,

JSONDecoder().decode(LsqUserDefaultModel<T>.self, from: data)转换失败,所以加了个中间变量。

```

public struct LsqUserDefaultModel: Codable {

    var key: String? 

    var value: T? 

}

```

1.自定义 @LsqUserDefault

///注意 T 只能是Codable数据类型

```

@propertyWrapper

public struct LsqUserDefault<T: Codable> {

    let key: String

    public init(key: String)  {

        self.key = key

    }

public var wrappedValue: T? {

        get{

            guard let data = UserDefaults.standard.object(forKey: self.key) as? Data,

                  let value =try? JSONDecoder().decode(LsqUserDefaultModel<T>self, from: data) else {

                return nil

            }

            return value.value

        }

        set{

            ifletv = newValue {

                do{

                    letmodel =LsqUserDefaultModel(key:key, value: v)

                    letdata =tryJSONEncoder().encode(model)

                    UserDefaults.standard.set(data,forKey:self.key)

                }catch{

                    print("LsqUserDefault存储失败key:\(key)")

                }

            }else{

                UserDefaults.standard.removeObject(forKey: self.key)

            }

        }

    }

}

```

///当单独存储 基本数据单元时,encode 会失败,所以搞个中间变量

public struct LsqUserDefaultModel<T: Codable>: Codable {

    var key: String?

    var value: T?

}

///注意 T 只能是Codable数据类型, 并且不能为空

@propertyWrapper

public struct LsqUserDefaultValue<T: Codable> {

    let key: String

    let defaultValue: T

    public init(key: String, _ defaultValue: T) {

        self.key = key

        self.defaultValue= defaultValue

    }

    public var wrappedValue: T  {

        get {

            guard let data = UserDefaults.standard.object(forKey: self.key) as? Data,

                  let value = try? JSONDecoder().decode(LsqUserDefaultModel.self, from: data) else {

                return self.defaultValue

            }

            return value.value ?? self.defaultValue

        }

        set {

            do {

                let model =LsqUserDefaultModel(key: key, value: newValue)

                let data =try JSONEncoder().encode(model)

                UserDefaults.standard.set(data, forKey: self.key)

            } catch {

                print("LsqUserDefaultValue存储失败key:\(key)")

            }

        }

    }

}

***使用方法***

1.首先我有个 model

struct MyTestModel: Codable {

    varname:String?

    varvalue:Int?

}

2.@LsqUserDefault(key: "你的名字,要唯一") 不能放在最顶层

struct App {

    *没有默认值的多个存储

     @LsqUserDefault(key: "AppConfigModelList")

      static var testList: [MyTestModel]?


    *没有默认值的单个存储

     @LsqUserDefault(key: "AppConfigModelOne")

    static var test: MyTestModel?


    *带有默认值的存储

     @LsqUserDefaultValue(key: "AppConfigModelNotNil", MyTestModel())

    static var testNotNil: MyTestModel


    *带有默认值的存储 基本数据类型

    @LsqUserDefaultValue(key: "KisLoginKey", false)

    static var isLogin:Bool


}






3使用------>>>>

class XxxxxCtr: UIViewController {

override func viewDidLoad() {

        super.viewDidLoad()


    ///读取

    let isLogin = App.isLogin

    ///存储

     App.isLogin = true    


   ///读取

    let test = App.test

    ///存储

     App.test = nil 

    App.test = MyTestModel(.....)

    }

}

还有就是服务器返回的数据类型不确定时,我封装了一个数据类型转换的 

public protocol LsqCodable: Codable {

    associatedtype T: Codable

    var wrappedValue: T? { get set }

}

///注意 String、 Int 和 Double 都转换成String, 返回数据类型不明确时使用

@propertyWrapper

public struct LsqStringable: LsqCodable {

    public var wrappedValue:String?

    public init(wrappedValue:String? =nil) {

        self.wrappedValue= wrappedValue

    }

    public init(from decoder:Decoder) throws {

        let container = try decoder.singleValueContainer()

        if container.decodeNil() {

           return

        }

        if let value = try? container.decode(String.self) {

            wrappedValue= value

        } else if let value = try? container.decode(Int.self) {

            wrappedValue="\(value)"

        } else { 

            do {

                let value = try container.decode(Double.self)

                wrappedValue= value.stringValue

            } catch {

                print("<====【解析异常】===>我不是String、Int、也不是Double==>\(error)")

            }

        }

    }

}

///注意 Int、String  都转换成Int, 返回数据类型不明确时使用

@propertyWrapper

public struct LsqIntable: LsqCodable {

    public var wrappedValue:Int?

    public init(wrappedValue:Int? =nil) {

        self.wrappedValue= wrappedValue

    }

    public init(from decoder:Decoder) throws {

        let container = try decoder.singleValueContainer()

        if container.decodeNil() {

           return

        }

        if let value = try? container.decode(Int.self) {

            wrappedValue= value

        }else{

            do{

                let value = try container.decode(String.self)

                if let intValue =Int(value) {

                    wrappedValue= intValue

                }else{

                    print("<====【解析异常】===>LsqIntable不能将String转换为Int***\(container.codingPath)")

                }

            }catch{

                print("<====【解析异常】===>我不是Int、也不是String==>\(error)")

            }

        }

    }

}

///注意 Bool、String  都转换成Bool, 返回数据类型不明确时使用

@propertyWrapper

public struct LsqBoolable: LsqCodable {

    public var wrappedValue:Bool?

    public init(wrappedValue:Bool? =nil) {

        self.wrappedValue= wrappedValue

    }

    public init(from decoder:Decoder) throws {

        let container =try decoder.singleValueContainer()

        if container.decodeNil() {

           return

        }

        if let value = try? container.decode(Bool.self) {

            wrappedValue= value

        }else{

            do{

                let value = try container.decode(String.self)

                if let boolValue =Bool(value) {

                    wrappedValue= boolValue

                }else{

                    print("<====【解析异常】===>LsqBoolable不能将String转换为Bool***\(container.codingPath)")

                }

            }catch{

                print("<====【解析异常】===>我不是Bool、也不是String==>\(error)")

            }

        }

    }

}

///注意 Double、String  都转换成Double, 返回数据类型不明确时使用

@propertyWrapper

public struct LsqDoubleable: LsqCodable {

    public var wrappedValue:Double?

    public init(wrappedValue:Double? =nil) {

        self.wrappedValue= wrappedValue

    }

    public init(from decoder:Decoder) throws {

        let container =try decoder.singleValueContainer()

        if container.decodeNil() {

           return

        }

        if let value = try? container.decode(Double.self) {

            wrappedValue= value

        } else {

            do {

                let value =try container.decode(String.self)

                if let doubleValue =Double(value) {

                    wrappedValue= doubleValue

                } else {

                    print("<====【解析异常】===>LsqDoubleable不能将String转换为Double***\(container.codingPath)")

                }

            } catch {

                print("<====【解析异常】===>我不是Double、也不是String==>\(error)")

            }

        }

    }

}

extension KeyedEncodingContainer {

    mutating func encode(_ value: some LsqCodable, forKey key: Self.Key) throws {

        try encodeIfPresent(value.wrappedValue, forKey: key)

    }

}

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容