Trier le dictionnaire par clés

Je veux trier un dictionnaire dans Swift. J'ai un dictionnaire comme:

"A" => Array[]
"Z" => Array[]
"D" => Array[]

etc. Je veux que ce soit comme

"A" => Array[]
"D" => Array[]
"Z" => Array[]

etc.

J'ai essayé de nombreuses solutions sur SO mais personne n'a fonctionné pour moi. J'utilise XCode6 Beta 5 et certains donnent des erreurs de compilation et certaines solutions donnent des exceptions. Donc, quiconque peut publier la copie de travail du tri du dictionnaire.

let dictionary = [
    "A" : [1, 2],
    "Z" : [3, 4],
    "D" : [5, 6]
]

let sortedKeys = Array(dictionary.keys).sorted(<) // ["A", "D", "Z"]

ÉDITER:

Le tableau trié à partir du code ci-dessus contient uniquement des clés, tandis que les valeurs doivent être extraites du dictionnaire d'origine. Cependant, 'Dictionary'est également une 'CollectionType'paire de (clé, valeur) et nous pouvons utiliser la 'sorted'fonction globale pour obtenir un tableau trié contenant à la fois des clés et des valeurs, comme ceci:

let sortedKeysAndValues = sorted(dictionary) { $0.0 < $1.0 }
println(sortedKeysAndValues) // [(A, [1, 2]), (D, [5, 6]), (Z, [3, 4])]

EDIT2: La syntaxe Swift changeante mensuellement préfère actuellement

let sortedKeys = Array(dictionary.keys).sort(<) // ["A", "D", "Z"]

Le global sortedest obsolète.

Swift 2.0

Version mise à jour de la réponse d'Ivica M:

let wordDict = [
     "A" : [1, 2],
     "Z" : [3, 4],
     "D" : [5, 6]
]

let sortedDict = wordDict.sort { $0.0 < $1.0 }
print("\(sortedDict)") // 

Swift 3

wordDict.sorted(by: { $0.0 < $1.0 })

Remarquer:

Ne soyez pas surpris que le type résultant soit un tableau plutôt qu'un dictionnaire. Les dictionnaires ne peuvent pas être triés ! Le type de données résultant est un tableau trié, tout comme dans la réponse de @ Ivica.

Si vous souhaitez parcourir à la fois les clés et les valeurs dans un ordre trié par clé, ce formulaire est assez succinct

let d = [
    "A" : [1, 2],
    "Z" : [3, 4],
    "D" : [5, 6]
]

for (k,v) in Array(d).sorted({$0.0 < $1.0}) {
    println("\(k):\(v)")
}

Dans Swift 4, vous pouvez l'écrire plus intelligemment:

let d = [ 1 : "hello", 2 : "bye", -1 : "foo" ]
d = [Int : String](uniqueKeysWithValues: d.sorted{ $0.key < $1.key })

J'ai essayé tout ce qui précède, en un mot, tout ce dont vous avez besoin est

let sorted = dictionary.sorted { $0.key < $1.key }
let keysArraySorted = Array(sorted.map({ $0.key }))
let valuesArraySorted = Array(sorted.map({ $0.value }))

Pour Swift 4, ce qui suit a fonctionné pour moi:

let dicNumArray = ["q":[1,2,3,4,5],"a":[2,3,4,5,5],"s":[123,123,132,43,4],"t":[00,88,66,542,321]]

let sortedDic = dicNumArray.sorted { (aDic, bDic) -> Bool in
    return aDic.key < bDic.key
}

C'est une alternative élégante au tri du dictionnaire lui-même:

À partir de Swift 4 et 5

let sortedKeys = myDict.keys.sorted()

for key in sortedKeys {
   // Ordered iteration over the dictionary
   let val = myDict[key]
}

Dans Swift 5 , afin de trier le dictionnaire par CLÉS

let sortedYourArray = YOURDICTIONARY.sorted( by: { $0.0 < $1.0 })

Afin de trier le dictionnaire par VALEURS

let sortedYourArray = YOURDICTIONARY.sorted( by: { $0.1 < $1.1 })

Pour Swift 3, le tri suivant renvoie le dictionnaire trié par clés:

let unsortedDictionary = ["4": "four", "2": "two", "1": "one", "3": "three"]

let sortedDictionary = unsortedDictionary.sorted(by: { $0.0.key < $0.1.key })

print(sortedDictionary)
// ["1": "one", "2": "two", "3": "three", "4": "four"]

"trié" dans iOS 9 et xcode 7.3, swift 2.2 est impossible, remplacez "trié" par "tri", comme ceci:

let dictionary = ["main course": 10.99, "dessert": 2.99, "salad": 5.99]
let sortedKeysAndValues = Array(dictionary).sort({ $0.0 < $1.0 })
print(sortedKeysAndValues)

//sortedKeysAndValues = ["desert": 2.99, "main course": 10.99, "salad": 5.99]

Swift 5

Saisissez votre dictionnaire que vous souhaitez trier par ordre alphabétique par touches.

// Sort inputted dictionary with keys alphabetically.
func sortWithKeys(_ dict: [String: Any]) -> [String: Any] {
    let sorted = dict.sorted(by: { $0.key < $1.key })
    var newDict: [String: Any] = [:]
    for sortedDict in sorted {
        newDict[sortedDict.key] = sortedDict.value
    }
    return newDict
}

dict.sorted (par: {$ 0.key <$ 1.key}) par lui-même renvoie un tuple (valeur, valeur) au lieu d'un dictionnaire [valeur: valeur]. Ainsi, la boucle for analyse le tuple à renvoyer en tant que dictionnaire. De cette façon, vous mettez un dictionnaire et récupérez un dictionnaire.

Swift 4 et 5

Pour le tri des clés de chaîne:

dictionary.keys.sorted(by: {$0.localizedStandardCompare($1) == .orderedAscending})

Exemple:

var dict : [String : Any] = ["10" : Any, "2" : Any, "20" : Any, "1" : Any]

dictionary.keys.sorted() 

["1" : Any, "10" : Any, "2" : Any, "20" : Any]

dictionary.keys.sorted(by: {$0.localizedStandardCompare($1) == .orderedAscending})

["1" : Any, "2" : Any, "10" : Any, "20" : Any]

Pour Swift 3, ce qui suit a fonctionné pour moi et la syntaxe Swift 2 n'a pas fonctionné:

// menu is a dictionary in this example

var menu = ["main course": 10.99, "dessert": 2.99, "salad": 5.99]

let sortedDict = menu.sorted(by: <)

// without "by:" it does not work in Swift 3

Swift 3 est trié (par: <)

let dictionary = [
    "A" : [1, 2],
    "Z" : [3, 4],
    "D" : [5, 6]
]

let sortedKeys = Array(dictionary.keys).sorted(by:<) // ["A", "D", "Z"]