स्विफ्ट में घोषित डिक्शनरी आइटम का ऑर्डर सुरक्षित रखें?

Question

कुंजी/मूल्य शब्दकोश बनाते समय, इसे यादृच्छिक रूप से क्रमबद्ध के रूप में वापस कर दिया जाता है। मैं उम्मीद कर रहा था कि वे उसी क्रम में होंगे जैसा कि यह बनाया गया था।

[kg: 1, oz: 5, g: 2, mg: 3, lb: 4, t: 6] 

मैं जिस क्रम में शब्दकोश घोषित किया गया था कैसे सुरक्षित करूं: यह निम्नलिखित रिटर्न

var dict = [ 
    "kg": 1, 
    "g": 2, 
    "mg": 3, 
    "lb": 4, 
    "oz": 5, 
    "t": 6 
] 

println(dict) 

:

उदाहरण के लिए, इस कोड को देखा है?

Answer 1

आपके मामले में कस्टम का एक सरणी वस्तुएं अधिक उपयुक्त हो सकती हैं। यहाँ एक सरल उदाहरण आप आरंभ करने के लिए मदद करनी चाहिए वह यह है कि:

struct Unit : Printable { 
    let name: String 
    let factor: Double 

    // println() should print just the unit name: 
    var description: String { return name } 
} 


let units = [ 
    Unit(name: "kg", factor: 1000.0), 
    Unit(name: "g", factor: 1.0), 
    Unit(name: "mg", factor: 0.001), 
    Unit(name: "lb", factor: 453.592292), 
    Unit(name: "oz", factor: 28.349523) 
] 

println(units) // [kg, g, mg, lb, oz] 

(मुझे यकीन है कि अगर गैर मीट्रिक इकाई कारकों सही हैं :)

Answer 2

के रूप में एप्पल का कहना है:

शब्दकोश कुंजी-मान संघों के अव्यवस्थित संग्रह हैं।

लिंक: https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html

है कि यदि आप में मदद मिलेगी लेकिन इस कड़ी में एक ordereddictionary के एक कार्यान्वयन है

पता नहीं है: http://www.raywenderlich.com/82572/swift-generics-tutorial

Answer 3

struct MenueItem { 
let title : String 
let image : String} 


let items = [MenueItem(title: "Readers", image: "multimedia"), 
      MenueItem(title: "Live Broadcast", image: "multimedia"), 
      MenueItem(title: "Quran Browsing", image: "multimedia"), 
      MenueItem(title: "Personal Quran", image: "multimedia"), 
      MenueItem(title: "Videos", image: "multimedia"), 
      MenueItem(title: "Favorites", image: "favorites")] 

नहीं कर रहा हूँ ....

override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int { 
    return items.count 

....

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell { 
    let cell = tableView.dequeueReusableCellWithIdentifier("MenuTableViewCell", forIndexPath: indexPath) as! MenuTableViewCell 

    cell.cellTitle.text = items[indexPath.row].title 
    cell.cellImage.image = UIImage(named: items[indexPath.row].image) 
    return cell 
} 
} 

Answer 4

अफसोस की बात है, ऐप्पल ने केवल बॉक्स के बाहर स्विफ्ट में तीन संग्रह डेटास्ट्रक्चर में बनाया है। ये ऐरे, शब्दकोश और सेट है। सौभाग्य से, ऐप्पल ने प्रोटोकॉल का एक बहुत ही व्यापक और शक्तिशाली पदानुक्रम पेश किया है जो आपके स्वयं के संग्रह वर्गों को आसानी से और सुंदर ढंग से परिभाषित करने का समर्थन करता है।

इसलिए, यदि आपको अपने समाधान की अतिरिक्त जगह- (और शायद समय-) जटिलता पर कोई फर्क नहीं पड़ता है, तो हो सकता है कि आप अपने स्वयं के स्विफ्ट संग्रह वर्ग/संरचना को चुनने का विकल्प चुन सकें जो उस क्रम को संरक्षित करता है जिसमें ऑर्डर को संरक्षित किया जाता है कुंजी को इंडेक्स से संबंधित और इसके विपरीत, तत्वों को इसमें जोड़ा गया था। अपना खुद का संग्रह डेटास्ट्रक्चर बनाने के बारे में अधिक जानकारी के लिए प्रलेखन देखें: https://developer.apple.com/documentation/swift/collection।

अस्वीकरण::

मैं तुम्हें एक छोटे से कुछ तुम जा पाने के लिए दे देंगे इस कोड का परीक्षण नहीं किया गया है, और मैं एल्गोरिथम जटिलता के मामलों पर विचार की एक महान सौदा खर्च नहीं किया है। कृपया अपने समाधान की आवश्यकताओं को निर्धारित करें और स्वयं को जांचें कि क्या निम्न कोड का पालन करता है।

public struct KeepOrderDictionary<Key, Value> where Key : Hashable 
{ 
    public private(set) var values: [Value] 

    fileprivate var keyToIndexMap: [Key:Int] 
    fileprivate var indexToKeyMap: [Int:Key] 

    public init() 
    { 
     self.values = [Value]() 
     self.keyToIndexMap = [Key:Int]() 
     self.indexToKeyMap = [Int:Key]() 
    } 

    public var count: Int 
    { return values.count} 

    public mutating func add(key: Key, _ value: Value) 
    { 
     if let index = keyToIndexMap[key] 
     { values[index] = value} 
     else 
     { 
      values.append(value) 
      keyToIndexMap[key] = values.count - 1 
      indexToKeyMap[values.count - 1] = key 
     } 
    } 

    public mutating func add(index: Int, _ value: Value) -> Bool 
    { 
     if let key = indexToKeyMap[index] 
     { 
      add(key: key, value) 
      return true 
     } 

     return false 
    } 

    public func get(key: Key) -> (Key, Value)? 
    { 
     if let index = keyToIndexMap[key] 
     { return (key, values[index])} 

     return nil 
    } 

    public func get(index: Int) -> (Key, Value)? 
    { 
     if let key = indexToKeyMap[index] 
     { return (key, values[index])} 

     return nil 
    } 

    public mutating func removeValue(forKey key: Key) -> Bool 
    { 
     guard let index = keyToIndexMap[key] else 
     { return false} 

     values.remove(at: index) 

     keyToIndexMap.removeValue(forKey: key) 
     indexToKeyMap.removeValue(forKey: index) 

     return true 
    } 

    public mutating func removeValue(at index: Int) -> Bool 
    { 
     guard let key = indexToKeyMap[index] else 
     { return false} 

     values.remove(at: index) 

     keyToIndexMap.removeValue(forKey: key) 
     indexToKeyMap.removeValue(forKey: index) 

     return true 
    } 
} 

extension KeepOrderDictionary 
{ 
    public subscript(key: Key) -> Value? 
     { 
     get 
     { return get(key: key)?.1} 

     set 
     { 
      if let newValue = newValue 
      { add(key: key, newValue)} 
      else 
      { let _ = removeValue(forKey: key)} 
     } 
    } 

    public subscript(index: Int) -> Value? 
     { 
     get 
     { return get(index: index)?.1} 

     set 
     { 
      if let newValue = newValue 
      { let _ = add(index: index, newValue)} 
     } 
    } 
} 

extension KeepOrderDictionary : ExpressibleByDictionaryLiteral 
{ 
    public init(dictionaryLiteral elements: (Key, Value)...) 
    { 
     self.init() 
     for entry in elements 
     { add(key: entry.0, entry.1)} 
    } 
} 

extension KeepOrderDictionary : Sequence 
{ 
    public typealias Iterator = IndexingIterator<[(key: Key, value: Value)]> 

    public func makeIterator() -> KeepOrderDictionary.Iterator 
    { 
     var content = [(key: Key, value: Value)]() 

     for i in 0 ..< count 
     { 
      if let value: Value = self[i], let key: Key = indexToKeyMap[i] 
      {  content.append((key: key, value: value))} 
     } 

     return content.makeIterator() 
    } 
}