根据与特定属性对应的另一个数组中的值对对象数组进行排序

Question

假设从 JSON API 检索对象数组：

[
    {
        "id": 48,
        "name": "Bob"
    },
    {
        "id": 198,
        "name": "Dave"
    },
    {
        "id": 2301,
        "name": "Amy"
    },
    {
        "id": 990,
        "name": "Colette"
    }
]

// e.g. for ease of reproduction:

let dataObjects = [
    ["id": 48, "name": "Bob"], 
    ["id": 198, "name": "Dave"], 
    ["id": 2301, "name": "Amy"], 
    ["id": 990, "name": "Colette"]
]

在客户端，我想允许用户重新排序这些对象。为了保存订单，我将一个 id 列表存储在一个数组中：

let index: [Int] = [48, 990, 2103, 198]

如何根据排序索引中 id 的顺序重新排序原始数据对象数组？

dataObjects.sort({ 
    // magic happens here maybe?
}

所以最后，我得到：

print(dataObjects)
/* 
[
    ["id": 48, "name": "Bob"], 
    ["id": 990, "name": "Colette"], 
    ["id": 2301, "name": "Amy"], 
    ["id": 198, "name": "Dave"]
]
/*

Answer 1

方法 A) 将数据解析为一个简单的字典，其中字典的键是用于对其进行排序的 id：

func sort<Value>(a: [Int: Value], basedOn b: [Int]) -> [(Int, Value)] {
    return a.sort { x, y in
        b.indexOf(x.0) < b.indexOf(y.0)
    }
}

// ....
let a = [48:"Bob", 198:"Dave", 2301:"Amy", 990:"Colette"]
let b = [48, 198, 2301, 990]
sort(a, basedOn: b)

方法 B) 使用一些自定义 DataObject 类型：（可能是最好的方法）

struct DataObject {
    let id: Int
    let name: String

    init(_ id: Int, _ name: String) {
        self.id = id
        self.name = name
    }
}

func sort(a: [DataObject], basedOn b: [Int]) -> [DataObject] {
    return a.sort { x, y in
        b.indexOf(x.id) < b.indexOf(y.id)
    }
}


let a = [DataObject(48, "Bob"), DataObject(198, "Dave"), DataObject(2301, "Amy"), DataObject(990, "Colette")]
let b = [48, 198, 2301, 990]

sort(a, basedOn: b)
/* [
     DataObject(id: 48, name: "Bob"), 
     DataObject(id: 990, name: "Colette"), 
     DataObject(id: 198, name: "Dave"), 
     DataObject(id: 2301, name: "Amy")
] */

方法 C) 使用 raw json 值，可以以不那么“干净”的方式完成：

func sort<Value>(a: [[String: Value]], basedOn b: [Int]) -> [[String: Value]] {
    return a.sort { x, y in
        let xId = x["id"] as! Int
        let yId = y["id"] as! Int
        return b.indexOf(xId) < b.indexOf(yId)
    }
}

let dataObjects = [
    ["id": 48, "name": "Bob"],
    ["id": 198, "name": "Dave"],
    ["id": 2301, "name": "Amy"],
    ["id": 990, "name": "Colette"]
]

let b = [48, 198, 2301, 990]

sort(dataObjects, basedOn: b)

Answer 2

您可以受益于 Swift 的功能支持，并使用 map 函数遍历 index 数组并获取相应的对象：

let sortedObjects = index.map{ id in
    dataObjects.filter{ $0["id"] as? Int == id }.first
}

这假设在映射数据对象之前正确计算了index 数组。

---

编辑

感谢 user3441734 的 flatMap 建议。这是一个使用它的解决方案，基本上它只是将map 替换为flatMap 以消除映射数组中可能的nil 值，并将生成的数组转换为非可选数组.

let sortedObjects = index.flatMap{ id in
    dataObjects.filter{ $0["id"] as? Int == id }.first
}

如果一个空的index 应该导致保持相同的顺序，那么我们可以简单地测试一下：

let sortedObjects = index.count > 0 ? index.flatMap{ id in
    dataObjects.filter{ $0["id"] as? Int == id }.first
} : dataObjects

Answer 3

您不需要保留一个带有索引的数组，您可以按您想要的对象排序，假设您具有以下结构：

struct DataObject {
   var id: Int
   var name: String
}

var data = [DataObject]()
data.append(DataObject(id: 48, name: "Bob"))
data.append(DataObject(id: 198, name: "Dave"))
data.append(DataObject(id: 2301, name: "Amy"))
data.append(DataObject(id: 990, name: "Colette"))

您可以使用sort 函数对结果进行排序并在其他数组中返回结果，或者如果您想就地进行排序，则可以只使用sorted 函数

// ordered by id
var sortedData = data.sort { index.indexOf($0.id) < index.indexOf($1.id) }

希望对你有所帮助。