按键中对象的属性对字典进行排序/筛选

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

我想把字典按[Oj2:[1，2]，Obj4:[3，3]，Obj1:[3，4]，Obj3:[8，9]

简而言之，我希望根据关键字属性上的自定义引用数组对字典进行排序。我知道我们不能对字典进行排序，但想根据自定义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])]