मानचित्र सरणी स्विफ्ट

Question

में शब्दकोश में मैं Person की वस्तुओं की एक सरणी है:

class Person { 
    let name:String 
    let position:Int 
} 

और सरणी है:

let myArray = [p1,p1,p3] 

मैं मैप करने के लिए myArray का एक शब्दकोश होना चाहता हूँ [position:name] क्लासिक समाधान है:

var myDictionary = [Int:String]() 

for person in myArray { 
    myDictionary[person.position] = person.name 
} 

है किसी भी सुरुचिपूर्ण तरीका ख y स्विफ्ट tuples से ऐसा करने के लिए है कि कार्यात्मक दृष्टिकोण map, flatMap ... या अन्य आधुनिक स्विफ्ट शैली

Answer 1

ठीक map इस का एक अच्छा उदाहरण है, क्योंकि इसके सिर्फ पाशन के रूप में ही नहीं है, आप कर सकते हो se reduce इसके बजाय यह आपके वस्तु के प्रत्येक ले लिया गठबंधन और एकल मान में बदलने के लिए:

let myDictionary = myArray.reduce([Int: String]()) { (dict, person) -> [Int: String] in 
    var dict = dict 
    dict[person.position] = person.name 
    return dict 
} 

//[2: "b", 3: "c", 1: "a"] 

Answer 2

आप Dictionary प्रकार के लिए कस्टम प्रारंभकर्ता लिख ​​सकते हैं, उदाहरण के लिए:

extension Dictionary { 
    public init(keyValuePairs: [(Key, Value)]) { 
     self.init() 
     for pair in keyValuePairs { 
      self[pair.0] = pair.1 
     } 
    } 
} 

और उसके बाद के लिए map का उपयोग Person के अपने सरणी:

var myDictionary = Dictionary(keyValuePairs: myArray.map{($0.position, $0.name)}) 

Answer 3

आप एक समारोह को कम कर सकते हैं।

let dictionary = myArray.reduce([Int: Person]()){ 
    (total, person) in 
    var totalMutable = total 
    totalMutable.updateValue(person, forKey: total.count) 
    return totalMutable 
} 

: सबसे पहले मैं व्यक्ति वर्ग

class Person { 
    var name:String 
    var position:Int 

    init(_ n: String,_ p: Int) { 
    name = n 
    position = p 
    } 
} 

बाद के लिए एक नामित प्रारंभकर्ता बना लिया है, मैं मान

let myArray = [Person("Bill",1), 
       Person("Steve", 2), 
       Person("Woz", 3)] 

और अंत में, शब्दकोश चर परिणाम है की किसी सरणी प्रारंभ किया है

Answer 4

Swift 4 में आप intoreduce के संस्करण का उपयोग करके @ Tj3n के दृष्टिकोण को अधिक स्वच्छ और कुशलता से कर सकते हैं यह अस्थायी dictio से छुटकारा पाता है नारी और वापसी मूल्य इसलिए यह पढ़ने के लिए तेज़ और आसान है।

struct Person { 
    let name: String 
    let position: Int 
} 
let myArray = [Person(name:"h", position: 0), Person(name:"b", position:4), Person(name:"c", position:2)] 
let myDict = myArray.reduce(into: [Int: String]()) { 
    $0[$1.position] = $1.name 
} 
print(myDict) 

नोट: स्विफ्ट 3.