存储异构键路径数组

Question

我有一个类似的对象：

class MyObject {
  var title:String? = nil
  var value:Int? = nil
  var otherData:[String] = []
}

我正在尝试存储一个异构的更新数组，以便以后可以使用它们来设置值。像这样。

class SomeFormThing {
  func getUpdates() -> [WritableKeyPath<MyObject, Any> : Any] {
    var updates:[WritableKeyPath<MyObject, Any> : Any]
    updates[\MyObject.title] = "New Title"
    updates[\MyObject.value] = 0
    updates[\MyObject.value] = ["Other", "Values"]
    return updates
  }
}

class SyncManager {
  var form:SomeFormThing = SomeFormThing()
  var sync:MyObject = MyObject()
  func updateValues() {
    let updates = form.getUpdates()
    for key in updates.keys {
      sync[forKeyPath: key] = updates[key]
    }
  }
}

但是，这在 getUpdates() 中读取 Cannot convert value of type 'WritableKeyPath<MyObject, String?>' to expected argument type 'WritableKeyPath<MyObject, Any>' 的行中当然存在编译问题。

需要有一组异构的可写键路径，然后我可以使用它们来设置值。鉴于泛型通常是如何工作的，我不明白为什么 String 不能等同于 Any 泛型，因为该类型是向下转换的。

Answer 1

Swift 集合不喜欢异构。此外，为了类型安全，键路径是泛型的，而泛型不是协变的。

所以你不能在一个集合中组合不同的类型——除非你类型擦除。当然，如果您这样做，您必须稍后un 键入erase，这很麻烦。这就像一个蟑螂汽车旅馆：包裹的类型进入但它们不会出来，除非你手动引出它们。

例如：

    struct MyObject {
      var title:String
      var value:Int
    }

    // okay, roaches go in...
    let kp1 = \MyObject.title
    let kp2 = \MyObject.value
    let dict : [PartialKeyPath<MyObject>:Any] = [kp1:"Yo", kp2:1]

    var object = MyObject(title: "Ha", value: 0)

    // but now what? how can we apply our `dict` entries to `object`? well...
    for (kp,val) in dict {
        switch (kp,val) {
        case (let kp2 as WritableKeyPath<MyObject,String>, let val2 as String):
            object[keyPath:kp2] = val2
        case (let kp2 as WritableKeyPath<MyObject,Int>, let val2 as Int):
            object[keyPath:kp2] = val2
        default:break
        }
    }
    print(object) // yep, we did it, sort of

所以你看，你可以做到，但你必须单独处理每一种可能的属性类型。您已经在 PartialKeyPath 的 Partial 和 Any 中隐藏了类型，现在将它们强制公开由您决定。

也就是说，我实际上这样做的方式是给 MyObject 一个通用的update 方法，并且一次只调用一个更改：

    struct MyObject {
        var title:String
        var value:Int
        mutating func update<T>(_ kp:WritableKeyPath<Self,T>, to val:T) {
            self[keyPath:kp] = val
        }
    }

所以：

    object.update(\.title, to: "Teehee")
    object.update(\.value, to: 42)

请注意，您不能直接从 dict 中的条目执行此操作，因为您已经隐藏了类型。泛型不会等到运行时才查看“真正”的类型是什么；它由编译器解析，所以类型必须是已知的——并且通过说 PartialKeyPath 和 Any 你已经使类型 un 已知。