通过转换数组初始化字典

Question

有没有一种方法可以快速地从数组中以声明方式初始化字典？ 我正在寻找这样的东西：

struct MyStruct {

   var key: Int
   var value: String
}

let array = [MyStruct(key: 0, value: "a"), MyStruct(key: 1, value: "b")]
let dict = array.someTransform { // Some arguments
   // Some transformation
}

所以dict 的类型是[Int: String]？

注意：我不是在寻找包含forEach 的解决方案，因为从这个任务的角度来看，它只是for 循环的更复杂版本。

Answer 1

Dictionary 的序列初始化器

在 Swift 4 中，假设键保证是唯一的，你可以简单地说：

let array = [MyStruct(key: 0, value: "a"), MyStruct(key: 1, value: "b")]

let dict = Dictionary(uniqueKeysWithValues: array.lazy.map { ($0.key, $0.value) })

print(dict) // [0: "a", 1: "c"]

这是使用来自SE-0165 的init(uniqueKeysWithValues:) 初始化程序。它需要一个键值元组序列，其中的键保证是唯一的（如果不是，你会得到一个致命错误）。因此，在这种情况下，我们将对数组中的元素应用惰性转换，以获得键值对的惰性集合。

如果键不保证是唯一的，您将需要某种方法来决定将哪些可能的值用于给定键。为此，您可以使用 init(_:uniquingKeysWith:) 初始化程序 from the same proposal，并传递给定函数以确定在出现重复键时为给定键使用哪个值。

uniquingKeysWith: 函数的第一个参数是字典中已经存在的值，第二个是试图插入的值。

例如，这里每次在序列中出现重复键时，我们都会覆盖该值：

let array = [MyStruct(key: 0, value: "a"), MyStruct(key: 0, value: "b"),
             MyStruct(key: 1, value: "c")]

let keyValues = array.lazy.map { ($0.key, $0.value) }
let dict = Dictionary(keyValues, uniquingKeysWith: { _, latest in latest })

print(dict) // [0: "b", 1: "c"]

要保留给定键的第一个值，并忽略同一键的任何后续值，您需要{ first, _ in first } 的uniquingKeysWith: 闭包，在这种情况下给出[0: "a", 1: "c"] 的结果。

---

使用inout 累加器减少

在 Swift 4 中，另一个可能的选项是使用 reduce(into:_:)，在 SE-0171 中引入，假设您希望通过覆盖每次出现给定键的值来合并任何重复键。

与reduce(_:_:) 不同，此方法使用inout 参数作为组合函数中的累加器。这允许它避免在填充字典累加器时在reduce(_:_:) 的每次迭代中发生不必要的累加器复制。因此，这允许我们以线性时间而不是二次时间来填充它。

你可以这样使用它：

let array = [MyStruct(key: 0, value: "a"), MyStruct(key: 0, value: "b"),
             MyStruct(key: 1, value: "c")]

let dict = array.reduce(into: [:]) { $0[$1.key] = $1.value }

print(dict) // [0: "b", 1: "c"]


// with initial capacity to avoid resizing upon populating.
let dict2 = array.reduce(into: Dictionary(minimumCapacity: array.count)) { dict, element in
    dict[element.key] = element.value
}

print(dict2) // [0: "b", 1: "c"]

Answer 2

您还可以扩展 Dictionary 类型以添加​​一个接受元组数组的初始化程序：

extension Dictionary
{
  init(_ keyValues:[(Key,Value)] )
  {
     self.init(minimumCapacity: keyValues.underestimatedCount) // self.init()
     for (key,value) in keyValues { self[key] = value }
  }
}

struct MyStruct {

   var key: Int
   var value: String
}

let array = [MyStruct(key: 0, value: "a"), MyStruct(key: 1, value: "b")]
let dict = Dictionary(array.map{($0.key,$0.value)})

for 循环仍然存在，但仅在 Dictionary 类型中，并且不需要样板代码在需要此类初始化的各个位置以数组形式构建它。

[EDIT] 将 init 更改为使用 3441734 建议的最小容量。这应该使其与 #1 一样快。但是，我觉得这种优化牺牲了一点简单性，因为这种初始化将成为关键性能因素的非常罕见的用例。

Answer 3

使用减少

let dict = array.reduce([:]) { (d, s) -> [Int:String] in
    var d = d
    d[s.key] = s.value
    return d
}

正如 @Martin R 所提到的，这不是表现最好的，但非常易于使用。 @Hamish的扩展不错，至少同样的性能给你简单一点

var dict:[Int:String] = [:]
for s in array {
    dict[s.key] = s.value
}

是的，我明白了，您希望避免使用 forEach 版本，但实际上，它是一个很好且强大的解决方案。

var dict:[Int:String] = [:]
array.forEach {
    dict[$0.key] = $0.value
}

使事情尽可能简单，减少产生不良副作用（错误）的机会

定义最小容量

var dict = Dictionary<Int,String>(minimumCapacity: array.count)
array.forEach {
    dict[$0.key] = $0.value
}

你的表现最好。

比较解决方案

do {
    let start = Date()
    let dict = Dictionary(uniqueKeysWithValues: array.lazy.map { ($0.key, $0.value) })
    let time = start.timeIntervalSince(Date())
    print(1,time, dict.count)
}

do {
    let start = Date()
    var dict = Dictionary<Int,String>(minimumCapacity: array.count)
    array.forEach {
        dict[$0.key] = $0.value
    }
    let time = start.timeIntervalSince(Date())
    print(2,time, dict.count)
}

它打印在我的电脑上

1 -1.93269997835159 10000000
2 -1.80712699890137 10000000

我喜欢 @Hamish 使用 inout 参数 作为累加函数的想法。我用相同的数据集测试过

do {
    let start = Date()
    let dict = array.reduce(into: Dictionary(minimumCapacity: array.count)) { dict, element in
        dict[element.key] = element.value
    }
    let time = start.timeIntervalSince(Date())
    print(3,time, dict.count)
}

我期望与上面其他的性能相同，但不幸的是，它打印出来了

3 -3.80046594142914 10000000

看起来它需要 cc 两次才能执行相同的工作。