Swift的UserDefaults简易封装

UserDefaults 这个东西相信大家都用过,但是它的存取需要写很长的方法调用,感觉很笨拙。我们为何不用 subscript 来改造它呢?

苹果十分不提倡将一些 Name 用 hardcode 的方式来表示,不要直接用 String 表示一个 asset 名称,不要用 tag 来获取 IB 中拖拽的 view。这些行为十分影响软件的可维护性。所以我们将应用中的 UserDefaults Key 用某种方式来表示:

final class PreferenceKey<T>: PreferenceKeys { }
class PreferenceKeys: RawRepresentable, Hashable {
    let rawValue: String
    
    required init!(rawValue: String) {
        self.rawValue = rawValue
    }
    
    convenience init(_ key: String) {
        self.init(rawValue: key)
    }
    
    var hashValue: Int {
        return rawValue.hashValue
    }
}

这小段代码很精巧,既通过 rawValue 存储了 key,同时通过范型在类型中注入了 value 的类型信息。

存储所有配置项的 Key与默认值:

// 设置key的默认值 
let defaultPreferences: [PreferenceKeys: Any] = [
    .firstLaunch: true,
]

extension PreferenceKeys {
    static let firstLaunch = PreferenceKey<Bool>("FirstLaunch")
    static let token = PreferenceKey<String>("Token")
}

接着定义一个专门负责存储的管理类:

final class PreferenceManager {
    static let shared = PreferenceManager()
    let defaults = UserDefaults.standard
    
    private init() {
        registerDefaultPreferences()
    }
    
    private func registerDefaultPreferences() {
        // Convert dictionary of type [PreferenceKey: Any] to [String: Any].
        let defaultValues: [String: Any] = defaultPreferences.reduce([:]) {
            var dictionary = $0
            dictionary[$1.key.rawValue] = $1.value
            return dictionary
        }
        defaults.register(defaults: defaultValues)
    }
}

extension 补充下:

extension PreferenceManager {    
    subscript(key: PreferenceKey<URL>) -> URL? {
        get { return defaults.url(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<[Any]>) -> [Any]? {
        get { return defaults.array(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<[String: Any]>) -> [String: Any]? {
        get { return defaults.dictionary(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<String>) -> String? {
        get { return defaults.string(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<[String]>) -> [String]? {
        get { return defaults.stringArray(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<Data>) -> Data? {
        get { return defaults.data(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<Bool>) -> Bool {
        get { return defaults.bool(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<Int>) -> Int {
        get { return defaults.integer(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<Float>) -> Float {
        get { return defaults.float(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<Double>) -> Double {
        get { return defaults.double(forKey: key.rawValue) }
        set { defaults.set(newValue, forKey: key.rawValue) }
    }
    
    subscript(key: PreferenceKey<Any>) -> Any? {
        get {
            let decodedObject = defaults.data(forKey:  key.rawValue)
            if let decoded = decodedObject {
                let object = NSKeyedUnarchiver.unarchiveObject(with: decoded)
                return object
            }
            return nil
        }
        set {
            var encodedObject: Data? = nil
            if newValue != nil {
                encodedObject = NSKeyedArchiver.archivedData(withRootObject: newValue!)
            }
            defaults.set(encodedObject, forKey: key.rawValue)
        }
    }
}

借助范型,我们将 subscript 用不同类型分开,这样存取不同类型的值时就不用去取分方法名称了,是不是很方便呢?

使用方式如下:

let firstLaunch = PreferenceManager.shared[.firstLaunch]

PreferenceManager.shared[.firstLaunch] = false

效率是不是瞬间爆炸???


看到这里可能你就会想问RawRepresentable是什么

它是什么

首先我们简单看一下这个东西是用来描述什么问题的,它的定义如下:

public protocol RawRepresentable {
    associatedtype RawValue

    public init?(rawValue: Self.RawValue)

    public var rawValue: Self.RawValue { get }
}

简单来说呢,遵循这个协议的类型可以表示另一个类型,并且可以通过 rawValue这个属性得到它表示的值。再简单的说就是表示一个值。

但是这个协议有没有它存在的道理呢?当然有!这也是为什么面向协议编程是 Swift 的一大核心之一。Swift 这个语言本身的组成也必须要求 RawRepresentable 这个协议,因为基本类型 enum 就遵循了它。当然还有很多系统类库的类型,比如 OptionSet 和一些从 Objective-C 迁移过来的 NS_ENUM 都遵循了这个协议。

Well, How to Use It?

首先我们来写一个简单的 OptionSet :

struct Directions: OptionSet {
    typealias RawValue = UInt8

    var rawValue: UInt8

    static let up = Directions(rawValue: 1 << 0)
    static let down = Directions(rawValue: 1 << 1)
    static let left = Directions(rawValue: 1 << 2)
    static let right = Directions(rawValue: 1 << 3)
}

由于 OptionSet 也是一个协议,而这个协议并没有指定 RawRepresentable 中的一个 associatedtype RawValue ,因此我们用第一行的语句指定:我们这个类型表示了一个 UInt8 类型。由于协议规定我们需要有个 rawValue 属性,所以我们还需要再声明一个 rawValue 成员变量。

下面我们需要定义几个选项,使用的方式就是静态常量,至于数值的设计本文不展开叙述了,大家可以参考位运算相关文章以及回忆自己高中时学的排列组合。

使用的时候也很方便,我们可以通过 [.up, .left] 或者 .down 来表示一个 Direction 变量,这得益于 Swift 的类型推断和便利的语法。

Wrap Up

RawRepresentable 就是为了让某类数值能具有更抽象的展现形式,并赋予更多相关的操作能力。

推荐阅读更多精彩内容