按另一个数组中包含的对象属性排序Javascript数组

我的第一个数组如下所示：

[
    {entityId: 1, name: 'Total sales'},
    {entityId: 2, name: 'Total customers'},
    {entityId: 3, name: 'Reach'}
]

[1, 3, 2]

[
    {entityId: 1, name: 'Total sales'},
    {entityId: 3, name: 'Reach'},
    {entityId: 2, name: 'Total customers'}
]

我有一个存储

entityId

s的第二个数组，我需要使用第二个数组的值对第一个数组进行排序。因此，如果我的第二个数组如下所示：

[
    {entityId: 1, name: 'Total sales'},
    {entityId: 2, name: 'Total customers'},
    {entityId: 3, name: 'Reach'}
]

[1, 3, 2]

[
    {entityId: 1, name: 'Total sales'},
    {entityId: 3, name: 'Reach'},
    {entityId: 2, name: 'Total customers'}
]

那么我的第一个数组应该按如下方式排序：

[
    {entityId: 1, name: 'Total sales'},
    {entityId: 2, name: 'Total customers'},
    {entityId: 3, name: 'Reach'}
]

[1, 3, 2]

[
    {entityId: 1, name: 'Total sales'},
    {entityId: 3, name: 'Reach'},
    {entityId: 2, name: 'Total customers'}
]

我知道我可以使用

sort

方法和我自己的回调函数，根据对象属性对数组进行排序：

array.sort(function(a, b) {
    // ... sorting logic ...
});

但是，我很难理解排序逻辑将如何遵循第二个数组施加的排序规则，而不仅仅是比较两个相邻元素。

使用：

.

使用：

---

最简单的代码是：

var a = [
    {entityId: 1, name: 'Total sales'},
    {entityId: 2, name: 'Total customers'},
    {entityId: 3, name: 'Reach'}
];

var b = [1,3,2];
var c = b.slice(); //create copy

for (var i = 0;i< a.length;i++)
{
   var indexOf = b.indexOf(a[i].entityId);

   c[indexOf] = a[i];
}

console.log(c)

var a=[
{entityId:1，名称：'总销售额'}，
{entityId:2，名称：'Total customers'}，
{entityId:3，名称：'Reach'}
];
var b=[1,3,2]；
var c=b.slice（）//创建副本
对于（变量i=0；i

---

试试最简单的代码是：

var a = [
    {entityId: 1, name: 'Total sales'},
    {entityId: 2, name: 'Total customers'},
    {entityId: 3, name: 'Reach'}
];

var b = [1,3,2];
var c = b.slice(); //create copy

for (var i = 0;i< a.length;i++)
{
   var indexOf = b.indexOf(a[i].entityId);

   c[indexOf] = a[i];
}

console.log(c)

var a=[
{entityId:1，名称：'总销售额'}，
{entityId:2，名称：'Total customers'}，
{entityId:3，名称：'Reach'}
];
var b=[1,3,2]；
var c=b.slice（）//创建副本
对于（变量i=0；i

---

请尝试另一种变体，对于大数组可能更好，因为只需在数组上迭代两次。如果

indexOf

，则在每个调用排序回调上迭代两次

首先，从第一个数组创建映射

var array = [
    {entityId: 1, name: 'Total sales'},
    {entityId: 2, name: 'Total customers'},
    {entityId: 3, name: 'Reach'}
];

var map = array.reduce(function(acc,el){
    acc[el.entityId] = el;
    return acc;
},{});

第二，只需映射第二个数组

var indexes = [1, 3, 2];

var result = indexes.map(function(index){ return map[index];});

---

naive

另一个变体，对于大数组可能更好，因为只需在数组上迭代两次。如果

indexOf

，则在每个调用排序回调上迭代两次

首先，从第一个数组创建映射

var array = [
    {entityId: 1, name: 'Total sales'},
    {entityId: 2, name: 'Total customers'},
    {entityId: 3, name: 'Reach'}
];

var map = array.reduce(function(acc,el){
    acc[el.entityId] = el;
    return acc;
},{});

第二，只需映射第二个数组

var indexes = [1, 3, 2];

var result = indexes.map(function(index){ return map[index];});

---

天真的

没错。他在我准备这篇文章时回答了我的问题。考虑一下：

a.reduce（function（acc，obj）{return（acc[b.indexOf（obj.entityId）]=obj）&acc}，[]）

。但不使用sort.true。他在我准备这篇文章时回答了我的问题。考虑一下：

a.reduce（function（acc，obj）{return（acc[b.indexOf（obj.entityId）]=obj）&acc}，[]）

。但不使用排序。以什么方式“更好？”@RobG，只需按数组检查两次，以防使用sort-

indexOf

在调用排序时检查数组两次callback@Grudy-酷，只是指出当你说“更好”时，你需要说为什么。；-）您应该在jsperf示例中包含一个没有映射的普通reduce方法。@RobG，您是指注释中的版本吗

a.reduce（函数（acc，obj）{return（acc[b.indexOf（obj.entityId）]=obj）和&acc}，[]）

？“更好”是什么方式？@RobG，只需按数组检查两次，如果使用sort-

indexOf

每次调用sort时检查数组两次callback@Grudy-酷，只是指出当你说“更好”时，你需要说为什么。；-）您应该在jsperf示例中包含一个没有映射的普通reduce方法。@RobG，您是指注释中的版本吗

a.reduce（函数（acc，obj）{return（acc[b.indexOf（obj.entityId）]=obj）和&acc}，[]）

？简洁，但正如Grundy所指出的，非常慢，因为它在每次迭代中调用indexOf两次。完全不调用indexOf可能要快得多。简明，但正如格伦迪所指出的，每次迭代调用indexOf两次非常慢。根本不调用indexOf会快得多（也许）。