키를 기준으로 사전 정렬

키를 기준으로 사전 정렬

나는 스위프트로 사전을 분류하고 싶습니다.다음과 같은 사전이 있습니다.

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

등. 나는 그것이 다음과 같았으면 좋겠습니다.

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

기타.

저는 SO에 대한 많은 솔루션을 시도해 보았지만 아무도 저를 위해 일하지 않았습니다.저는 XCode6 베타 5를 사용하고 있으며 일부는 컴파일러 오류를 제공하고 일부 솔루션은 예외를 제공하고 있습니다.사전 정렬 작업 복사본을 게시할 수 있는 사람이라면 누구나 가능합니다.

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

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

편집:

위의 코드에서 정렬된 배열은 키만 포함하고 값은 원래 사전에서 검색해야 합니다.하지만,'Dictionary'또한'CollectionType'(키, 값) 쌍의. 그리고 우리는 글로벌을 사용할 수 있습니다.'sorted'다음과 같이 키와 값을 모두 포함하는 정렬된 배열을 가져오는 함수:

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

EDIT2: 현재 월 단위로 변화하는 Swift 구문을 선호합니다.

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

글로벌sorted사용되지 않습니다.

사전을 정렬할 수 없습니다.배열을 출력할 수 있습니다. 정렬할 수 있습니다.

스위프트 2.0

Ivica M의 답변 업데이트 버전:

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

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

스위프트 3

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

Swift 5에서 사전을 KEY별로 정렬하려면

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

VALUE를 기준으로 사전을 정렬하려면

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

키와 값을 모두 정렬된 키 순서로 반복하려면 이 양식이 매우 간단합니다.

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

스위프트 1,2:

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

Swift 3+:

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

위의 모든 것을 시도해 보았습니다. 간단히 말해서, 당신이 필요한 것입니다.

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

swift 4를 사용하면 더 스마트하게 작성할 수 있습니다.

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

스위프트 4 & 5

문자열 키 정렬의 경우:

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

예:

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]

스위프트 5

키를 기준으로 알파벳 순으로 정렬할 사전을 입력합니다.

// 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.dict(by: {$0.key < $1.key})는 사전 [value: value] 대신 튜플(값, 값)을 반환합니다.따라서 for 루프는 튜플을 구문 분석하여 사전으로 반환합니다.그렇게 하면, 당신은 사전을 넣고 사전을 돌려받을 수 있습니다.

Swift 4의 경우 다음과 같은 이점이 있습니다.

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
}

이것은 사전 자체를 정렬하는 우아한 대안입니다.

스위프트 4 & 5 기준

let sortedKeys = myDict.keys.sorted()

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

iOS 9 & xcode 7.3에서 "sorted", swift 2.2는 불가능합니다. 다음과 같이 "sorted"를 "sorted"로 변경합니다.

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 3의 경우 다음 정렬은 키별로 정렬된 사전을 반환합니다.

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"]

Swift 3의 경우 다음과 같은 기능이 작동했지만 Swift 2 구문은 작동하지 않았습니다.

// 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은 다음 기준으로 정렬됩니다(<).

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

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

키별 신속 정렬 사전

부터Dictionary^[정보] 해시 함수를 기반으로 하여 배열과 같은 정렬 함수를 사용하는 것은 불가능합니다.대안으로 일종의 Java TreeMap/TreeSet을 구현할 수 있습니다.

가장 쉬운 방법은 사용하는 것입니다..sorted(by:)기능.정렬된 항목을 반환합니다.Arraykey/value

예:

struct Person {
    let name: String
    let age: Int
}

struct Section {
    let header: String
    let rows: [Int]
}

let persons = [
    Person(name: "A", age: 1),
    Person(name: "B", age: 1),
    Person(name: "C", age: 1),
    Person(name: "A", age: 2),
    Person(name: "B", age: 2),
    Person(name: "C", age: 2),
    Person(name: "A", age: 3),
    Person(name: "B", age: 3),
    Person(name: "C", age: 3),
]

//grouped
let personsGroupedByName: [String : [Person]] = Dictionary(grouping: persons, by: { $0.name })
/**
 personsGroupedByName
 [0] = {
   key = "B"
   value = 3 values {
     [0] = (name = "B", age = 1)
     [1] = (name = "B", age = 2)
     [2] = (name = "B", age = 3)
   }
 }
 [1] = {
   key = "A"
   value = 3 values {
     [0] = (name = "A", age = 1)
     [1] = (name = "A", age = 2)
     [2] = (name = "A", age = 3)
   }
 }
 [2] = {
   key = "C"
   value = 3 values {
     [0] = (name = "C", age = 1)
     [1] = (name = "C", age = 2)
     [2] = (name = "C", age = 3)
   }
 }
 */

//sort by key
let sortedPersonsGroupedByName: [Dictionary<String, [Person]>.Element] = personsGroupedByName.sorted(by: { $0.0 < $1.0 })
/**
 sortedPersonsGroupedByName
 [0] = {
     key = "A"
     value = 3 values {
       [0] = (name = "A", age = 1)
       [1] = (name = "A", age = 2)
       [2] = (name = "A", age = 3)
     }
   }
   [1] = {
     key = "B"
     value = 3 values {
       [0] = (name = "B", age = 1)
       [1] = (name = "B", age = 2)
       [2] = (name = "B", age = 3)
     }
   }
   [2] = {
     key = "C"
     value = 3 values {
       [0] = (name = "C", age = 1)
       [1] = (name = "C", age = 2)
       [2] = (name = "C", age = 3)
     }
   }
 */

//handle
let sections: [Section] = sortedPersonsGroupedByName.compactMap { (key: String, value: [Person]) -> Section in
    let rows = value.map { person -> Int in
        return person.age
    }
    return Section(header: key, rows: rows)
}
/**
 sections
 [0] = {
     header = "A"
     rows = 3 values {
       [0] = 1
       [1] = 2
       [2] = 3
     }
   }
   [1] = {
     header = "B"
     rows = 3 values {
       [0] = 1
       [1] = 2
       [2] = 3
     }
   }
   [2] = {
     header = "C"
     rows = 3 values {
       [0] = 1
       [1] = 2
       [2] = 3
     }
   }
 */

제 2센트는, 모든 답이 빗나가는 것처럼 보이기 때문에, 우리는 딕트를 가지고 있고 우리는 딕트를 원합니다.

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

let sortedMenu = menu.sorted(by: <) // is an ARRAY
print(type(of: sortedMenu))


let sortedDict = Dictionary( uniqueKeysWithValues: menu.sorted(by: <) )
print(type(of: sortedDict))

위의 I는 값별, 키별로 정렬되었습니다.

sorted1 = menu.timeout {(kv1, kv2)을 반환 kv1.key < kv2.key } 및/또는 생성자를 사용하여 Dict에 변환을 적용합니다.

언급URL : https://stackoverflow.com/questions/25377177/sort-dictionary-by-keys