合并多个字典，获取自定义对象数组

Question

我有以下 5 个字典

var serialsDict = [ Source(address: 0, endpoint: 3) : "860408ff",
             Source(address: 0, endpoint: 4) : "560410ff"]
var namesDict = [ Source(address: 0, endpoint: 3) : "SLIGHTR10",
             Source(address: 0, endpoint: 4) : "SLIGHTR09"]
var fwVersionsDict = [ Source(address: 0, endpoint: 3) : "FG01b",
             Source(address: 0, endpoint: 4) : "FG02c"]
var hwVersionDict = [ Source(address: 0, endpoint: 3) : "604a1r00",
             Source(address: 0, endpoint: 4) : "674b1r45"]
var typesDict = [ Source(address: 0, endpoint: 3) : 4,
             Source(address: 0, endpoint: 4) : 1]

Source 在哪里

struct Source: Hashable {
    let address: Int
    let endpoint: Int
}

我必须合并 5 个字典以获得包含 2 个 FoundDevice 对象的数组。其中FoundDevice 是以下结构：

struct FoundDevice {
    
    let source: Source
    
    let serial: String
    let name: String
    let fwVersion: String
    let hwVersion: String
    let type: Int
}

例如第一个元素必须是

FoundDevice(source: Source(address: 0, endpoint: 3), serial: “860408ff”，名称：“SLIGHTR10”，fwVersion：“FG01b”，hwVersion： “604a1r00”，类型：4)

这是我当前的实现：

serialsDict.keys.forEach { source in
    if let serial = serialsDict[source], let name = namesDict[source], let fwVersion = fwVersionsDict[source], let hwVersion = hwVersionDict[source], let type = typesDict[source] {
        devices.append(FoundDevice(source: source, serial: serial, name: name, fwVersion: fwVersion, hwVersion: hwVersion, type: type))
    }
}

有没有更聪明的方法来实现我的目标？

Answer 1

您需要将一组数据映射到另一组类型。那将是地图。但是由于您使用字典，因此我们需要这里的紧凑地图。

let sources = serialsDict.map({ $0.key })

let foundDevices: [FoundDevice] = sources.compactMap({
    if let serial = serialsDict[$0],
       let name = namesDict[$0],
       let fwVersion = fwVersionsDict[$0],
       let hwVersion = hwVersionDict[$0],
       let typ = typesDict[$0] {
        return FoundDevice(source: $0, serial: serial, name: name, fwVersion: fwVersion, hwVersion: hwVersion, type: typ)
    }
    return nil 
})

Answer 2

没有可用的“技巧”，但您无需再次检查其中一个字典中的值；你已经有了。

extension FoundDevice {
  init?(
    source: Source,
    serial: String,
    names: [Source: String],
    fwVersions: [Source: String],
    hwVersions: [Source: String],
    types: [Source: Int]
  ) {
    guard
      let name = names[source],
      let fwVersion = fwVersions[source],
      let hwVersion = hwVersions[source],
      let type = types[source]
    else { return nil }
    
    self.init(
      source: source,
      serial: serial,
      name: name,
      fwVersion: fwVersion,
      hwVersion: hwVersion,
      type: type
    )
  }
}

serialsDict.compactMap {
  FoundDevice(
    source: $0.key,
    serial: $0.value,
    names: namesDict,
    fwVersions: fwVersionsDict,
    hwVersions: hwVersionDict,
    types: typesDict
  )
}

---

在下面解决您的评论，

我的字典可能包含比其他字典更多的键。我必须创造 仅当键在每个字典中时，我的对象。

无论您使用哪个字典进行迭代，上面的 guard 语句都会处理这个问题。

但是如果你周围有钥匙的交叉点，不管出于什么原因，那是……

let sources = [serialsDict, namesDict, fwVersionsDict, hwVersionDict]
  .reduce(into: Set(typesDict.keys)) {
    $0.formIntersection($1.keys)
  }

...那么您可以安全地强制展开。

extension FoundDevice {
  /// - Precondition: `source` is a key in all of the dictionaries.
  init(
    source: Source,
    serials: [Source: String],
    names: [Source: String],
    fwVersions: [Source: String],
    hwVersions: [Source: String],
    types: [Source: Int]
  ) {
    self.init(
      source: source,
      serial: serials[source]!,
      name: names[source]!,
      fwVersion: fwVersions[source]!,
      hwVersion: hwVersions[source]!,
      type: types[source]!
    )
  }
}

sources.map {
  FoundDevice(
    source: $0,
    serials: serialsDict,
    names: namesDict,
    fwVersions: fwVersionsDict,
    hwVersions: hwVersionDict,
    types: typesDict
  )
}