排序/关键

Question

过滤器字典的对象的性质我有一个像一本字典 例如：

let dict = Dictionary<Month, Array<Int32>>() 

Obj1.price = "10" 
Obj1.value = "abc" 
Obj1.title = "January" 

Obj2.price = "10" 
Obj2.value = "def" 
Obj2.title = "April" 

Obj3.price = "10" 
Obj3.value = "pqr" 
Obj3.title = "February" 

Obj4.price = "4" 
Obj4.value = "mnq" 
Obj4.title = "April" 

dict = [ Obj1: [3,4], Obj2 : [1,2], Obj3: [8,9], Obj4: [3,3] ] 

我有一个月的自定义阵列

let sortTemplate = ["April", "May", "June", "July", "August", "September", "October", "November", "December", "January", "February", "March"] 

我想要得到的字典排序为 [Obj2：[1,2]，Obj4：[3,3]，Obj1：[3,4]，Obj3：[8,9]]

总之，我期望根据自定义字典排序pro上的参考数组关键性。 我知道我们不能排序字典，但想按照自定义sortTemplate进行排序并插入到字典数组中

在这方面的任何提示将是有用的。 我知道我们可以用价值，也键

Answer 1

这是使用内置的排序功能Dictionary■一个可能的解决方案进行排序，但呈现title财产在你的例子定制enum而非String。然后通过enum中月份的排序隐式给出“分类模板”。

也就是说，enum MonthSortTemplate和你MyClass类（后者还没有洗澡了我们，所以我做了一个MWE自己）为：

enum MonthSortTemplate: Int { 
    case April = 1 
    case January 
    case February 
    // ... rest of months follows, in the order you prefer 
} 

class MyClass { 
    var price = "" 
    var value = "" 
    var title: MonthSortTemplate = .April  
} 

// Hashable (just some dummy, don't know how you've set this up) 
extension MyClass: Hashable { 
    var hashValue: Int { 
     return price.hashValue^value.hashValue 
    } 
} 

// Equatable (just some dummy, don't know how you've set this up) 
func ==(lhs: MyClass, rhs: MyClass) -> Bool { 
    return lhs.price == rhs.price && lhs.value == rhs.value 
} 

创建MyClass情况下，添加到您的字典，并使用.sort(...)后者用于自定义闭合的功能，指定用于此特定类型的比较。

var Obj1 = MyClass() 
var Obj2 = MyClass() 
var Obj3 = MyClass() 

Obj1.price = "10" 
Obj1.value = "abc" 
Obj1.title = .January 

Obj2.price = "10" 
Obj2.value = "def" 
Obj2.title = .April 

Obj3.price = "10" 
Obj3.value = "pqr" 
Obj3.title = .February 

var dict = Dictionary<MyClass, Array<Int32>>() 
dict = [ Obj1: [3,4], Obj2 : [1,2], Obj3: [8,9]] 

// your custom sort closure, for Dictionary.sort(...) method 
let byMonthTemplate = { 
    (elem1:(key: MyClass, val: [Int32]), elem2:(key: MyClass, val: [Int32]))->Bool in 
    if elem1.key.title.rawValue < elem2.key.title.rawValue { 
     return true 
    } else { 
     return false 
    } 
} 

let sortedDict = dict.sort(byMonthTemplate) 
print("\(dict)") 

---

另一种---如果你真的喜欢你的类属性title是String类型的---是定义<运营商MyClass对象：

func <(lhs: MyClass, rhs: MyClass) -> Bool { 
    // do comparison stuff with strings lhs.title and rhs.title 
    // with regard to your ordering of choice (array sortTemplate) 
    return ... 
} 

在这情况下，“杂乱”的东西最终在这个功能，而实际的排序可以执行相当优雅

let sortedDict = dict.sort { $0.0 < $1.0 } 

就我个人而言，我更喜欢enum解决方案（但是，这是脱离主题）。

---

编辑：

您的要求，我会为您的MyClass类<操作的一个例子。这绝不是最佳选择，但也许你可以从我的例子中改进它。

// add sortTemplate as a static property of MyClass 
class MyClass { 
    var price = "" 
    var value = "" 
    var title = "" 
    static let sortTemplate = ["April", "May", "June", "July", "August", "September", "October", "November", "December", "January", "February", "March"] 
} 

// define < operator for MyClass objects 
func <(lhs: MyClass, rhs: MyClass) -> Bool { 
    let indexOfLhs = MyClass.sortTemplate.indexOf({$0 == lhs.title}) 
    let indexOfRhs = MyClass.sortTemplate.indexOf({$0 == rhs.title}) 
    return indexOfLhs < indexOfRhs 
} 

// you can now sort your dictionary according to 
let sortedDict = dict.sort { $0.0 < $1.0 } 

Answer 2

希望这有助于，快速和肮脏的方式

let dict = ["Obj1":[3,4],"Obj2":[1,2],"Obj3":[8,9],"Obj4":[3,3]] 

let dict1 = dict.sort { $0.1[0] < $1.1[0]} //Sort by first object in array 
let dict2 = dict1.sort { $0.1[1] < $1.1[1]} //Sort by second object in array 

print(dict2) 

输出地说：[("Obj2", [1, 2]), ("Obj4", [3, 3]), ("Obj1", [3, 4]), ("Obj3", [8, 9])]