制作一个键为“类型”的 Swift 字典？

Question

我正在尝试做这种事情..

static var recycle: [Type: [CellThing]] = []

但是 - 我不能:)

未声明的类型“类型”

在示例中，CellThing 是我的基类，所以 A:CellThing、B:CellThing、C:CellThing 等等。我的想法是我会在字典数组中存储各种 A A A、B B、C C C C。

如何使“类型”（理想情况下我猜，仅限于 CellThing）成为 Swift 字典中的键？

我很感激我可以（也许？）使用String(describing: T.self)，但这会让我失眠。

---

这是一个用例，设想的代码看起来像这样......

@discardableResult class func make(...)->Self {
  return makeHelper(...)
  }

private class func makeHelper<T: CellThing>(...)->T {
  let c = instantiateViewController(...) as! T
  return c
  }

那么像...

static var recycle: [Type: [CellThing]] = []

private class func makeHelper<T: CellThing>(...)->T {
  let c = instantiateViewController(...) as! T

  let t = type whatever of c (so, maybe "A" or "B")
  recycle[t].append( c )

  let k = recycle[t].count
  print wow, you have k of those already!

  return c
  }

Answer 1

不幸的是，元类型目前不可能符合协议（请参阅this related question 关于此事） - 所以CellThing.Type 目前不符合Hashable。因此，这意味着它不能直接用作Dictionary 的Key。

但是，您可以使用ObjectIdentifier 为元类型创建包装器，以提供Hashable 实现。例如：

/// Hashable wrapper for a metatype value.
struct HashableType<T> : Hashable {

  static func == (lhs: HashableType, rhs: HashableType) -> Bool {
    return lhs.base == rhs.base
  }

  let base: T.Type

  init(_ base: T.Type) {
    self.base = base
  }

  func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(base))
  }
  // Pre Swift 4.2:
  // var hashValue: Int { return ObjectIdentifier(base).hashValue }
}

然后，您还可以在 Dictionary 上提供一个方便的下标，它接受一个元类型并将其包装在 HashableType 中：

extension Dictionary {
  subscript<T>(key: T.Type) -> Value? where Key == HashableType<T> {
    get { return self[HashableType(key)] }
    set { self[HashableType(key)] = newValue }
  }
}

然后可以这样使用：

class CellThing {}
class A : CellThing {}
class B : CellThing {}

var recycle: [HashableType<CellThing>: [CellThing]] = [:]

recycle[A.self] = [A(), A(), A()]
recycle[B.self] = [B(), B()]

print(recycle[A.self]!) // [A, A, A]
print(recycle[B.self]!) // [B, B]

这也应该适用于泛型，您只需使用 T.self 为您的字典下标即可。

---

不幸的是，在此处使用带有get 和set 的下标的一个缺点是，在使用诸如Array 之类的写时复制类型的字典值（例如在你的例子中）。这个问题我多讲in this Q&A.

一个简单的操作如：

recycle[A.self]?.append(A())

将触发存储在字典中的数组的 O(N) 副本。

这是一个旨在通过 generalised accessors 解决的问题，它已作为 Swift 5 中的 非官方 语言功能实现。如果您愿意使用可能会破坏的非官方语言功能在未来的版本中（不推荐用于生产代码），那么您可以将下标实现为：

extension Dictionary {
  subscript<T>(key: T.Type) -> Value? where Key == HashableType<T> {
    get { return self[HashableType(key)] }
    _modify {
      yield &self[HashableType(key)]
    }
  }
}

解决了性能问题，允许在字典中就地改变数组值。

否则，一个简单的替代方法是不定义自定义下标，而是在您的类型上添加一个方便的计算属性，让您将其用作键：

class CellThing {
  // Convenience static computed property to get the wrapped metatype value.
  static var hashable: HashableType<CellThing> { return HashableType(self) }
}

class A : CellThing {}
class B : CellThing {}

var recycle: [HashableType<CellThing>: [CellThing]] = [:]

recycle[A.hashable] = [A(), A(), A()]
recycle[B.hashable] = [B(), B()]

print(recycle[A.hashable]!) // [A, A, A]
print(recycle[B.hashable]!) // [B, B]

Answer 2

如果你扩展Dictionary type，你可以直接使用已经定义的泛型Key。

extension Dictionary {
    // Key and Value are already defined by type dictionary, so it's available here
    func getSomething(key: Key) -> Value {
        return self[key]
    }
}

这是因为 Dictionary 已经定义了泛型 Key 和 Value 供自己使用。

Answer 3

希望AnyHashable 有所帮助。但它出现在 Xcode 8.0

你可以这样做：

var info: [AnyHashable : Any]? = nil