Question

我有两本词典：

let dict1 = [String : MyType1]
let dict2 = [String : MyType2]

澄清：MyType1和MyType2是结构，每个dict只能有一个valueType。

我希望能够将它们传递给同一个函数：

func doSomethingWithDict(dict : [String : AnyObject]) {
   // do something with dict
}

但这显然给了我一个错误：

Cannot convert value of type '[String : MyType1]' to expected argument type '[String : AnyObject]'

有没有办法解决这个问题，这有可能吗？

Answer 1

AnyObject适用于班级类型。将您的功能重写为：

func doSomethingWithDict(dict: [String: Any]) {
    if let myValue = dict["key"] as? MyType1 { ... }
}

Answer 2

如果您想确保只将声明为[String:MyType1]或[String:MyType2]的字典传递给您的函数，我认为最佳解决方案是声明协议

protocol MyProtocol {}

然后让MyType1和MyType2符合它

struct MyType1: MyProtocol { }
struct MyType2: MyProtocol { }

现在，您可以声明一个必须符合T的泛型类型MyProtocol的函数。最后，您将dict参数声明为[String:T]。

func doSomethingWithDict<T where T: MyProtocol>(dict: [String: T]) {

    guard let value = dict["key"] else { return }

    switch value {
    case let type1 as MyType1: print(type1)
    case let type2 as MyType2: print(type2)
    default: fatalError()
    }
}

这可以保证字典的值为MyType1或MyType2。

更新

在下面的评论中，您说您不想再传递字典，而是传递MyType1或MyType2的值。

在这种情况下，它变得更容易，因为我们不再需要泛型。

protocol MyProtocol {}
struct MyType1: MyProtocol { }
struct MyType2: MyProtocol { }

func doSomething(elm: MyProtocol) {
    switch elm {
    case let myType1 as MyType1: print(1)
    case let myType2 as MyType2: print(2)
    default: fatalError()
    }
}

Answer 3

您可以使用泛型，但我不知道您在方法中要做什么：

func doSomethingWithDict<T>(dict : [String : T]) {
   // do something with dict
}

你可以用这种方式调用它：

 doSomethingWithDict(["string1":1])
 doSomethingWithDict(["string1":"v"])

其中1和v是具有不同类型的值（Int / String）。注意：使用泛型函数比使用AnyObject或类似的东西更安全。

将具有不同值类型的快速字典传递给相同的函数

3 个答案:

更新