Question

只是搞乱语言思考我想如何构建一些基于层次结构自动生成密钥的UserDefaults。这让我想知道......是否有可能同时定义和实例化一个类型，像这样？

let myUserSettings = {

    let formatting = {

        var lastUsedFormat:String

    }
}

let lastUsedFormat = myUserSettings.formatting.lastUsedFormat

注意：我不能使用静态，因为我特别需要实例化，所以嵌套的带有静态成员的结构/类对我的情况不起作用。

这是我能提出的最接近的事情，但我讨厌我必须创建初始化器来设置成员。我希望得到一些不那么冗长的东西。

class DefaultsScope {

    init(_ userDefaults:UserDefaults){
        self.userDefaults = userDefaults
    }

    let userDefaults:UserDefaults

    func keyForSelf(property:String = #function) -> String {
        return "\(String(reflecting: self)).\(property)"
    }
}

let sharedDefaults = SharedDefaults(UserDefaults(suiteName: "A")!)
class SharedDefaults : DefaultsScope {

    override init(_ userDefaults:UserDefaults){
        formatting = Formatting(userDefaults)
        misc       = Misc(userDefaults)
        super.init(userDefaults)
    }

    let formatting:Formatting
    class Formatting:DefaultsScope {

        let maxLastUsedFormats = 5

        fileprivate(set) var lastUsedFormats:[String]{
            get { return userDefaults.stringArray(forKey:keyForSelf()) ?? [] }
            set { userDefaults.set(newValue, forKey:keyForSelf()) }
        }

        func appendFormat(_ format:String) -> [String] {

            var updatedListOfFormats = Array<String>(lastUsedFormats.suffix(maxLastUsedFormats - 1))
            updatedListOfFormats.append(format)
            lastUsedFormats = updatedListOfFormats

            return updatedListOfFormats
        }
    }

    let misc:Misc
    class Misc:DefaultsScope {

        var someBool:Bool{
            get { return userDefaults.bool(forKey:keyForSelf()) }
            set { userDefaults.set(newValue, forKey:keyForSelf()) }
        }
    }
}

那么有更简单的方法吗？

Answer 1

免责声明：这可能只是一个不应该在现实生活中使用的抽象解决方案：）

enum x {
  enum y {
    static func success() {
      print("Success")
    }
  }
}
x.y.success()

更新：抱歉，伙计们，我无法停止试验。这个看起来非常糟糕：）

let x2= [
  "y2": [
    "success": {
      print("Success")
    }
  ]
]
x2["y2"]?["success"]?()

更新2 ：再一次尝试，这次使用元组。由于元组必须至少有两个值，我不得不在那里添加一些假人。此外，元组不能具有变异功能。

let x3 = (
  y3: (
    success: {
      print("Success")
    },
    failure: {
      print("Failure")
    }
  ),
  z3: 0
)
x3.y3.success()

Answer 2

你不能拥有那种结构，但是你无法从x内部访问y，因为y只在x的范围内可见，所以在y的范围内是成功的。你无法从外面访问它们

另一种替代方法是使用更高阶的函数，它返回可以调用的闭包。

let x = {
            {
                {
                    print("Success")
                }
            }
        }

let y = x()
let success = y()
success()

或

x()()()

用户默认的高阶函数的真实世界用法可能是这样的，

typealias StringType = (String) -> ((String) -> Void)
typealias IntType = (String) -> ((Int) -> Void)
typealias BoolType = (String) -> ((Bool) -> Void)

typealias StringValue = (String) -> String?
typealias IntValue = (String) -> Int?
typealias BoolValue = (String) -> Bool?

func userDefaults<T>(_ defaults: UserDefaults) -> (String) -> ((T) ->  Void) {
    return { key in
        return { value in
            defaults.setValue(value, forKey: key)
        }
    }
}

func getDefaultsValue<T>(_ defaults: UserDefaults) -> (String) -> T? {
    return { key in
        return defaults.value(forKey: key) as? T
    }
}

let setStringDefaults: StringType  = userDefaults(.standard)
setStringDefaults("Name")("Jack Jones")
setStringDefaults("Address")("Australia")

let setIntDefaults: IntType = userDefaults(.standard)
setIntDefaults("Age")(35)
setIntDefaults("Salary")(2000)

let setBoolDefaults: BoolType = userDefaults(.standard)
setBoolDefaults("Married")(false)
setBoolDefaults("Employed")(true)

let getStringValue: StringValue = getDefaultsValue(.standard)
let name = getStringValue("Name")
let address = getStringValue("Address")

let getIntValue: IntValue = getDefaultsValue(.standard)
let age = getIntValue("Age")
let salary = getIntValue("Salary")

let getBoolValue: BoolValue = getDefaultsValue(.standard)
let married = getBoolValue("Married")
let employed = getBoolValue("Employed")

我不确定你是否喜欢这个模式，但它有一些很好的用例，你可以从下面看到，setStringDefaults你可以将字符串值设置为字符串键，所有这些都是类型安全的。

您可以针对您的用例扩展此功能。但是，您也可以使用struct并使用命令式代码，这可能更容易理解。我也看到了美丽。

Answer 3

如何尝试嵌套一些快速structs？

struct x {
    struct y {
        static func success() {
            print("success")
        }
    }
}

x.y.success()

Answer 4

好的，我想我已经明白了。这个第一堂课可以放在你用于所有应用程序的公共库中。

class SettingsScopeBase {

    private init(){}

    static func getKey(setting:String = #function) -> String {
        return "\(String(reflecting:self)).\(setting)"
    }
}

下一部分是一对类：

“范围”类，您可以在其中定义要使用的用户默认实例（以及您可能要为此特定设置实例指定的任何其他内容）
定义设置的实际层次结构

这是第一个。我正在为我的应用程序和它的扩展程序之间的共享设置进行设置：

class SharedSettingsScope : SettingsScopeBase{
    static let defaults = UserDefaults(suiteName: "group.com.myco.myappgroup")!
}

最后，这里是你如何'设置'你的层次结构以及如何实现属性的主体。

class SharedSettings:SharedSettingsScope{

    class Formatting:SharedSettingsScope{

        static var groupsOnWhitespaceOnlyLines:Bool{
            get { return defaults.bool(forKey: getKey()) }
            set { defaults.set(newValue, forKey: getKey()) }
        }
    }
}

以下是你如何使用它们......

let x = SharedSettings.Formatting.groupsOnWhitespaceOnlyLines
// x = false

SharedSettings.Formatting.groupsOnWhitespaceOnlyLines = true

let y = SharedSettings.Formatting.groupsOnWhitespaceOnlyLines
// y = true

我将会看看我是否可以进一步优化/优化它，但这非常接近我想要的位置。没有硬编码的字符串，由使用它们的层次结构定义的键，只在一个地方设置特定的UserDefaults实例。

你能同时在Swift中定义和实例化隐式类型吗？

4 个答案: