Question

我有类型字典 - [String : [MyClass]]。

我有MyClass类型的数组，我想要检查的是，我的字典是否包含特定键的MyClass对象数组。如果是，则将元素附加到数组，否则，它创建具有单个元素MyClass的新数组。我最终得到了：

for item in items{
    if let _ = dict[key] {
        // Add operations if corresponding array exist
        dict[key]?.append(item)         
    } else {
        // Create array if need
        dict[key] = [item]
   }
}

它工作但看起来有点难看，我使用可选绑定来检查数组是否存在，但不使用结果（通配符模式_）。

有没有让代码看起来更短更干净？感谢。

Answer 1

首先，您可以使用可选绑定测试和获取现有值，然后追加（或设置）所有新项目：

if let oldItems = dict[key] {
    dict[key] = oldItems + items
} else {
    dict[key] = items
}

使用nil-coalescing运算符??：

可以简化这一过程

dict[key] = (dict[key] ?? []) + items

在 Swift 4 中，您只需使用subscript method with a default value：

即可

dict[key, default: []] += items
// Or:
dict[key, default: []].append(contentsOf: items)

自包含的例子：

var dict = ["foo": [1, 2, 3]]

dict["foo", default: []] += [4, 5]
dict["bar", default: []] += [6,7]

print(dict) // ["bar": [6, 7], "foo": [1, 2, 3, 4, 5]]

Answer 2

您可以使用以下实现来避免使用wildCart模式：

import Foundation

class MyClass { }
class Apple : MyClass { }
class Ant : MyClass { }
class Ambulance : MyClass { }

class Test {

 var dictionary : [String : [MyClass.Type]] = [:]
 let items : [MyClass.Type] = [Apple.self, Ant.self, Ambulance.self]
 let key = "a"

 public func insert(key : String, items : [MyClass.Type] ) {
    guard !items.isEmpty else { return }

    items.forEach { (item) in
        if dictionary[key] == nil {
            dictionary[key] = [item]
        } else {
            dictionary[key]?.append(item)
        }
    }
 }

}

let test = Test()
test.insert(key: test.key, items: test.items)
print(test.dictionary)

输出：

["a": [__lldb_expr_27.Apple, __lldb_expr_27.Ant, __lldb_expr_27.Ambulance]]

使语句更清晰：在字典中检查对象的键

2 个答案:

输出：