从检查 nil 值的结构中优雅地填充字典

Question

给定一个结构A，我想用该结构中的值填充NSDictionary，前提是它们不为零。
为此，我插入所有值，然后遍历字典，删除所有 nil。有没有更优雅、更简洁、更少暴力的解决方案？

struct A {
    var first:String?
    var second:String?
    var third:String?

    /* some init */
}

let a = A(/*some init*/)

var dictionary = [
    "first":a.first,
    "second":a.second,
    "third":a.third
]

for (key,value) in dictionary {
    if value == nil {
        dictionary.removeValue(forKey: key)
    }
}

Answer 1

拥有一个可选值的字典通常不是一个好主意。字典使用nil 的分配作为您要从字典中删除键/值对的指示。此外，字典查找返回一个可选值，所以如果你的值是可选的，你最终会得到一个需要解包两次的双可选。

您可以使用分配nil 删除字典条目这一事实，通过仅分配值来构建[String : String] 字典。 nil 不会进入字典，因此您不必删除它们：

struct A {
    var first: String?
    var second: String?
    var third: String?
}

let a = A(first: "one", second: nil, third: "three")

let pairs: [(String, String?)] = [
    ("first", a.first),
    ("second", a.second),
    ("third", a.third)
]

var dictionary = [String : String]()

for (key, value) in pairs {
    dictionary[key] = value
}

print(dictionary)

["third": "three", "first": "one"]

正如@Hamish 在 cmets 中指出的那样，您可以为 pairs 使用 DictionaryLiteral（内部只是一个元组数组），这样您就可以使用更简洁的字典语法：

let pairs: DictionaryLiteral<String,String?> = [
    "first":  a.first,
    "second": a.second,
    "third":  a.third
]

所有其他代码保持不变。

注意：您可以只写DictionaryLiteral 并让编译器推断类型，但我看到 Swift 无法编译或编译大型字典文字的速度非常慢。这就是为什么我在这里展示了显式类型的使用。

---

或者，您可以跳过pairs 的Array 或DictionaryLiteral，直接分配值：

struct A {
    var first: String?
    var second: String?
    var third: String?
}

let a = A(first: "one", second: nil, third: "three")

var dictionary = [String : String]()

dictionary["first"] = a.first
dictionary["second"] = a.second
dictionary["third"] = a.third

print(dictionary)

["third": "three", "first": "one"]

Answer 2

作为@vacawama says，您通常应该避开具有可选值的Dictionary 类型，因为Dictionary API 是围绕使用nil 构建的，以指示给定键缺少值。因此，为 Dictionary 的 Value 使用可选类型会导致混淆双包装可选，这通常会表现出不直观的行为。

另一个（更过分的）解决方案是通过定义自己的“值展开”ExpressibleByDictionaryLiteral 类型来直接利用字典文字。

extension Dictionary {

    /// A dictionary wrapper that unwraps optional values in the dictionary literal
    /// that it's created with.
    struct ValueUnwrappingLiteral : ExpressibleByDictionaryLiteral {

        typealias WrappedValue = Dictionary.Value

        fileprivate let base: [Key : WrappedValue]

        init(dictionaryLiteral elements: (Key, WrappedValue?)...) {

            var base = [Key : WrappedValue]()

            // iterate through the literal's elements, unwrapping the values,
            // and updating the base dictionary with them.
            for case let (key, value?) in elements {

                if base.updateValue(value, forKey: key) != nil {
                    // duplicate keys are not permitted.
                    fatalError("Dictionary literal may not contain duplicate keys")
                }
            }

            self.base = base
        }
    }

    init(unwrappingValues literal: ValueUnwrappingLiteral) {
        self = literal.base // simply get the base of the unwrapping literal.
    }
}

然后您可以简单地将这种类型的实例传递给我们的 init(unwrappingValues:) 初始化程序：

struct A {
    var first: String?
    var second: String?
    var third: String?
}

let a = A(first: "foo", second: nil, third: "baz")

let dictionary = Dictionary(unwrappingValues: [
    "first"  : a.first,
    "second" : a.second,
    "third"  : a.third
])

print(dictionary) // ["third": "baz", "first": "foo"]