स्विफ्ट के बराबर `[NSDictionary initWithObjects: forKeys:]`

Question

क्या स्विफ्ट के मूल Dictionary से [NSDictionary initWithObjects: forKeys:] के बराबर है?

मैं कुंजी और मूल्यों के साथ दो सरणियों है और उन्हें एक शब्दकोश में डालने के लिए चाहते हैं। ऑब्जेक्टिव-सी में मैं इसे इस तरह करना चाहते हैं:

NSArray *keys = @[@"one", @"two", @"three"]; 
NSArray *values = @[@1, @2, @3]; 
NSDictionary *dict = [[NSDictionary alloc] initWithObjects: values forKeys: keys]; 

पाठ्यक्रम मैं दोनों सरणियों के माध्यम से एक काउंटर के साथ पुनरावृति कर सकते हैं के

, एक var dict: [String:Int] का उपयोग करें और कदम से कदम सामान जोड़ें। लेकिन यह एक अच्छा समाधान प्रतीत नहीं होता है। zip और enumerate का उपयोग करना संभवतः एक ही समय में पुन: प्रयास करने के बेहतर तरीके हैं। हालांकि इस दृष्टिकोण का मतलब एक परिवर्तनीय शब्दकोश है, न कि एक अपरिवर्तनीय।

let keys = ["one", "two", "three"] 
let values = [1, 2, 3] 
// ??? 
let dict: [String:Int] = ["one":1, "two":2, "three":3] // expected result 

Answer 1

वन-लाइनर, zip और reduce का उपयोग कर:

let dict = zip(keys, values).reduce([String:Int]()){ var d = $0; d[$1.0] = $1.1; return d } 

आप + ऑपरेटर को परिभाषित करते हुए reduce अभिव्यक्ति छोटा कर सकते हैं Dictionary और tuple के लिए:

func +<K,V>(lhs: [K:V], rhs: (K, V)) -> [K:V] { 
    var result = lhs 
    result[rhs.0] = rhs.1 
    return result 
} 

let dict = zip(keys, values).reduce([String:Int](), combine: +) 

Answer 2

आप बस काम करते हुए structs के साथ शुद्ध स्विफ्ट समाधान initWithObjects:forKeys:

let keys = ["one", "two", "three"] 
let values = [1, 2, 3] 
var dict = NSDictionary.init(objects: values, forKeys: keys) 

Answer 3

की स्विफ्ट बराबर उपयोग कर सकते हैं। एक ट्यूपल के रूप में अपने दो सरणी के माध्यम से फिर से चलाने के लिए zip का उपयोग करें, और फिर प्रत्येक कुंजी के लिए एक शब्दकोश बनाएं, tuple में मान।

struct SomeStruct { 
    var someVal: Int? 
} 

var keys = [String]() 
var values = [SomeStruct]() 

for index in 0...5 { 
    keys.append(String(index)) 
    values.append(SomeStruct(someVal: index)) 
} 

var dict = [String : Any]() 

for (key, value) in zip(keys, values) { 
    dict[key] = value 
} 

print(dict) // "["4": SomeStruct(someVal: Optional(4)), "2": SomeStruct(someVal: Optional(2)), "1": SomeStruct(someVal: Optional(1)), "5": SomeStruct(someVal: Optional(5)), "0": SomeStruct(someVal: Optional(0)), "3": SomeStruct(someVal: Optional(3))]" 

तुम भी forEachzip पर इस्तेमाल कर सकते हैं:

var dict = [String : Any]() 
zip(keys, values).forEach { dict[$0.0] = $0.1 } 
print(dict) // "["4": SomeStruct(someVal: Optional(4)), "2": SomeStruct(someVal: Optional(2)), "1": SomeStruct(someVal: Optional(1)), "5": SomeStruct(someVal: Optional(5)), "0": SomeStruct(someVal: Optional(0)), "3": SomeStruct(someVal: Optional(3))]\n" 

Answer 4

let keys = ["one", "two", "three"] 
let values = [1, 2, 3] 

func createDict<K:Hashable,V>(keys: [K], values:[V])->[K:V] { 

    var dict: [K:V] = [:] 

    // add validity checks here by yourself ! 
    // and return early, or throw an error ... 

    keys.enumerate().forEach { (index,element) ->() in 
     dict[element] = values[index] 
    } 
    return dict 
} 

let dict = createDict(keys, values: values) 
// ["one": 1, "three": 3, "two": 2] 

let dict2:[Int:Any] = createDict([1,2,3,4,5], values: [true,"two",3.4,5,[1,2,3]]) 
// [5: [1, 2, 3], 2: "two", 3: 3.4, 1: true, 4: 5] 

क्या अंतर अगर यह जिप समाधान की तुलना में है है? मुश्किल कहने के लिए ... मेरे लिए ज़िप प्रकार एनोटेशन सबसे बड़ी समस्या

let a:Zip2Sequence<[Int],[Any]> = zip([1,2,3,4,5], [true,"two",3.4,5,[1,2,3]]) 
var d:[Int:Any] = [:] 
a.forEach { (key, value) ->() in 
    d[key] = value 
} 
print(d) 
// [5: [1, 2, 3], 2: "two", 3: 3.4, 1: true, 4: 5] 

है, लेकिन गणना समाधान भी है एक छोटा सा तेज

Answer 5

के रूप में स्विफ्ट 4 आप से एक शब्दकोश सीधे बना सकते हैं कुंजी/मान जोड़े के अनुक्रम:

let keys = ["one", "two", "three"] 
let values = [1, 2, 3] 

let dict = Dictionary(uniqueKeysWithValues: zip(keys, values)) 

print(dict) // ["one": 1, "three": 3, "two": 2] 

मतलब यह है कि सभी चाबियाँ अलग हैं, अन्यथा यह एक क्रम अपवाद के साथ रद्द कर देगा।

चाबियाँ अलग होने की गारंटी नहीं कर रहे हैं, तो आप

let keys = ["one", "two", "one"] 
let values = [1, 2, 3] 

let dict = Dictionary(zip(keys, values), uniquingKeysWith: { $1 }) 

print(dict) // ["one": 3, "two": 2] 

दूसरा तर्क एक बंद जो निर्धारित करता है जो मान "जीत" डुप्लिकेट चाबी के मामले में है कर सकते हैं।