将两个泛型数组合并成一个具有泛型的Swift字典

Question

我试图将两个不同的泛型类型放入集合中。在这个例子中有两个阵列，一个包含Ints和另一个Strings。

let intArray = Array<Int>() 
let stringArray = Array<String>() 
let dict = [1:intArray, "one": stringArray] 

错误消息为表达式的类型在没有更多上下文的情况下是不明确的。

所以，我想指定Dictionary的类型

let dict: [Hashable: Any] = [1:intArray, "one": stringArray] 

这导致了两个错误。

• 不支持使用'Hashable'作为符合协议'Hashable'的具体类型。
• 协议“哈希的”只能作为一种通用的约束，因为它具有自我或相关类型的要求

添加import Foundation和使用NSDictionary作为类型工作正常。

let dict: NSDictionary = [1:intArray, "one": stringArray] 

但是，在没有使用Foundation的情况下，这在纯Swift中也应该是可能的。 Dictionary必须有什么类型？

编辑：这显然有更多的与键的类型。他们必须是相同的类型，不仅符合Hashable。

let dict: [Int:Any] = [1:intArray, 2: stringArray] 

This works。但是是否有可能使价值的类型更加精确？ [Int:Array<Any>]不起作用。

Answer 1

在阐述了answer从@RobNapier，这里是使用enum的字典两者键和值类似的方法：

enum Key: Equatable, Hashable { 
    case IntKey(Int) 
    case StringKey(String) 

    var hashValue: Int { 
     switch self { 
     case .IntKey(let value)  : return 0.hashValue^value.hashValue 
     case .StringKey(let value) : return 1.hashValue^value.hashValue 
     } 
    } 

    init(_ value: Int) { self = .IntKey(value) } 
    init(_ value: String) { self = .StringKey(value) } 
} 

func == (lhs: Key, rhs: Key) -> Bool { 
    switch (lhs, rhs) { 
    case (.IntKey(let lhsValue), .IntKey(let rhsValue)) : return lhsValue == rhsValue 
    case (.StringKey(let lhsValue), .StringKey(let rhsValue)) : return lhsValue == rhsValue 
    default: return false 
    } 
} 

enum Value { 
    case IntValue(Int) 
    case StringValue(String) 

    init(_ value: Int) { self = .IntValue(value) } 
    init(_ value: String) { self = .StringValue(value) } 
} 

var dict = [Key: Value]() 

dict[Key(1)] = Value("One") 
dict[Key(2)] = Value(2) 
dict[Key("Three")] = Value("Three") 
dict[Key("Four")] = Value(4) 

Answer 2

该字典必须具有什么类型？

你可以试试：

let dict: [NSObject: Any] = [1: intArray, "one": stringArray] 

---

let dict: [Hashable: Any] = ...不能编译的声明，因为Dictionary关键的类型必须是具体类型符合Hashable，例如Int，String等Hashable不是具体类型。

上述建议的工作，因为1. NSObject是一个具体类型（在这里你可以从实例化对象），2 NSObject是Hashable，并3.由于NSObjects子类的实例将在这里工作，以及，4 。编译器可以从字符串和数字文字初始化NSObject子类。

如果您不喜欢NSObject作为键的类型，您可以创建自己的类或结构。

Answer 3

请注意，您的第一次尝试let dict = [1:intArray, "one": stringArray]如果包含Foundation;产生一个NSDictionary（所以不需要明确说明这种类型）。

当使用Foundation时，我们可以拥有这些类型的显然是通用字典的原因是编译器在将Swift本机类型桥接到Foundation时执行的隐式类型转换（在引擎盖后面）。

let intArray : [Int] = [10, 20, 30] 
let stringArray : [String] = ["foo", "baz", "bar"] 
let dict = [1:intArray, "onx": stringArray] 

print(dict.dynamicType) 
for e in dict { 
    print(e.dynamicType, e.key.dynamicType, e.value.dynamicType) 
} 

/* __NSDictionaryI 
    (AnyObject, AnyObject) __NSCFString _SwiftDeferredNSArray 
    (AnyObject, AnyObject) __NSCFNumber _SwiftDeferredNSArray */ 

在上述dict的键以及值被包裹在AnyObject类型;它只能容纳引用（类）类型的对象; the compiler implicitly performs conversion价值类型Int/String以基础参考类型__NSCFNumber/__NSCFString。尽管如此，这仍然是一个NSDictionary;例如AnyObject本身不符合Hashable，因此它不能用作本地Swift字典中的密钥。

---

如果你想创建斯威夫特天然的“通用钥匙”的字典，我建议你创建一个包装符合Hashable和封装在底层（各种）密钥类型（比如结构） （S）。见例如（有些过时）线程

• How to create Dictionary that can hold anything in Key? or all the possible type it capable to hold