Javascript 根据另一个数组对数组进行排序'；s排序索引

我有两个数组。我应该对一个数组进行常规排序（降序或升序），并根据第一个数组的排序方式对另一个数组进行排序。这是因为第一个数组中的每个元素都与第二个数组中的同一索引元素有关系，我必须保持这种关系为真。例如：

sortThis=[3,1,2];
sortAccording=["With 3","With 1","With 2];

function zip(a, b) {
    var i = 0, j = 0, r = [];
    while(i < a.length && j < b.length)
        r.push([a[i++], b[j++]]);
    return r;
}

function unzip(r) {
    var a = [], b = [];
    for(var i = 0; i < r.length; i++) {
        a.push(r[i][0]);
        b.push(r[i][1]);
    }
    return [a, b];
}

r = zip(sortAccording, sortThis);
r.sort();
r = unzip(r);

sortAccording = r[0]
sortThis = r[1]

我找不到任何方法从JavaScript的

sort

函数获取索引更改。例如：

sortThis=[3,1,2];
sortAccording=["With 3","With 1","With 2];

function zip(a, b) {
    var i = 0, j = 0, r = [];
    while(i < a.length && j < b.length)
        r.push([a[i++], b[j++]]);
    return r;
}

function unzip(r) {
    var a = [], b = [];
    for(var i = 0; i < r.length; i++) {
        a.push(r[i][0]);
        b.push(r[i][1]);
    }
    return [a, b];
}

r = zip(sortAccording, sortThis);
r.sort();
r = unzip(r);

sortAccording = r[0]
sortThis = r[1]

zip和unzip的更好实现（都使用可变数量的参数）：

例如：

sortThis=[3,1,2];
sortAccording=["With 3","With 1","With 2];

function zip(a, b) {
    var i = 0, j = 0, r = [];
    while(i < a.length && j < b.length)
        r.push([a[i++], b[j++]]);
    return r;
}

function unzip(r) {
    var a = [], b = [];
    for(var i = 0; i < r.length; i++) {
        a.push(r[i][0]);
        b.push(r[i][1]);
    }
    return [a, b];
}

r = zip(sortAccording, sortThis);
r.sort();
r = unzip(r);

sortAccording = r[0]
sortThis = r[1]

zip和unzip的更好实现（都使用可变数量的参数）：

---

我有一个简单的解决办法。创建第三个索引数组。只需根据第一个数组的排序对索引数组进行排序

  var indexArray = [];
  for (var i=0; i < sortThis.length; i++) {
    indexArray[i] = i;
  }

  indexArray.sort(function(a, b) {
    return (sortThis[a] > sortThis[b]) ? 1 : (sortThis[a] === sortThis[b]) ? 0 : -1;
  });

  // Now you have the sorted index ready
  console.log("The first elements in the arrays are: " + sortThis(indexArray[0]) + " and " +  sortAccording(indexArray[0]));

var indexArray=[]；
for（var i=0；isorttthis[b]）？1:（sorttthis[a]===sorttthis[b]）？0:-1；
});
//现在您已经准备好了排序索引
log（“数组中的第一个元素是：“+sorttthis（indexArray[0]）+”和“+sortacording（indexArray[0]）”；

我有一个简单的解决方案。创建第三个索引数组。只需根据第一个数组的排序对索引数组进行排序

  var indexArray = [];
  for (var i=0; i < sortThis.length; i++) {
    indexArray[i] = i;
  }

  indexArray.sort(function(a, b) {
    return (sortThis[a] > sortThis[b]) ? 1 : (sortThis[a] === sortThis[b]) ? 0 : -1;
  });

  // Now you have the sorted index ready
  console.log("The first elements in the arrays are: " + sortThis(indexArray[0]) + " and " +  sortAccording(indexArray[0]));

var indexArray=[]；
for（var i=0；isorttthis[b]）？1:（sorttthis[a]===sorttthis[b]）？0:-1；
});
//现在您已经准备好了排序索引
log（“数组中的第一个元素是：“+sorttthis（indexArray[0]）+”和“+sortacording（indexArray[0]）”；

解决方案： 要实现这一点，您必须将两个数组压缩到一个数组中。这就是，假设您有两个阵列：

sortThis=[3,1,2];
sortAccording=["With 3","With 1","With 2];

在zip它们之后，您将拥有以下数组：

zipped = [{a: 3, b: "With 3"}, {a: 1, b: "With 1"}, {a: 2, b: "With 2"}];

然后，按a对其进行排序，以便：

zippedAndSorted = [{a: 1, b: "With 1"}, {a: 2, b: "With 2"}, {a: 3, b: "With 3"}];

下一步是什么？

好的，一旦你按照你想要的对这个数组进行了排序，你就必须用map函数提取它们的值，最后你将按照相同的标准对两个数组进行排序：

代码：

// your arrays
sortThis=[3,1,2];
sortAccording=["With 3","With 1","With 2"];

// the zip function    
function zip(a,b) {
    return a.map(function(aa, i){ return { i: aa, j: b[i]};} )
};               

// ziping and sorting the arrays
var zipped = zip(sortThis, sortAccording);
zippedAndSorted = zipped.sort(function(a,b){ return a.i - b.i; });

// your two sorted arrays
sortedThis = zippedAndSorted.map(function(a){ return a.i;});
sortedAccording = zippedAndSorted.map(function(a){ return a.j;});

您还可以在此处看到它的工作原理：

祝你好运

解决方案： 要实现这一点，您必须将两个数组压缩到一个数组中。这就是，假设您有两个阵列：

sortThis=[3,1,2];
sortAccording=["With 3","With 1","With 2];

在zip它们之后，您将拥有以下数组：

zipped = [{a: 3, b: "With 3"}, {a: 1, b: "With 1"}, {a: 2, b: "With 2"}];

然后，按a对其进行排序，以便：

zippedAndSorted = [{a: 1, b: "With 1"}, {a: 2, b: "With 2"}, {a: 3, b: "With 3"}];

下一步是什么？

好的，一旦你按照你想要的对这个数组进行了排序，你就必须用map函数提取它们的值，最后你将按照相同的标准对两个数组进行排序：

代码：

// your arrays
sortThis=[3,1,2];
sortAccording=["With 3","With 1","With 2"];

// the zip function    
function zip(a,b) {
    return a.map(function(aa, i){ return { i: aa, j: b[i]};} )
};               

// ziping and sorting the arrays
var zipped = zip(sortThis, sortAccording);
zippedAndSorted = zipped.sort(function(a,b){ return a.i - b.i; });

// your two sorted arrays
sortedThis = zippedAndSorted.map(function(a){ return a.i;});
sortedAccording = zippedAndSorted.map(function(a){ return a.j;});

您还可以在此处看到它的工作原理：

---

祝你好运

它们必须在单独的数组中吗？当我获取它们时，它们是分开的，我还必须输出两个单独的数组。但是，如果再次合并和拆分它们解决了问题，那么这很好。它们必须在单独的数组中吗？当我获取它们时，它们是分开的，并且我还必须输出两个单独的数组。但是，如果再次合并和拆分它们可以解决问题，那么这很好。在您的

zip

函数中，

i

不总是等于

j

？如果是这样，为什么不省略

j

？@Andomar:好主意！在你的

zip

函数中，不是

i

总是等于

j

？如果是这样，为什么不省略

j

？@Andomar:好主意！在

zip

中使用对象并不是一个好主意。您最好使用数组数组-这样可以大大简化排序和“解压缩”。@thg435:有什么区别？数组只是一个具有数字属性的对象，在这里的代码中不会有不同的用法。理论上，您需要一个元组。@Bergi:区别在于javascript知道如何对多维数组排序。@thg435:嗯，什么？不，没有。您仍然需要自定义比较函数，尤其是在对OP.@thg435:这样的数字进行排序时。然后尝试

[[2,0]，[10,1]]。sort（）

或

[[a]，0]，“b”，1]，“a，a”，2]，“a，”，“u3]”。sort（）

在

zip

中使用对象绝非好主意。您最好使用数组数组-这样可以大大简化排序和“解压缩”。@thg435:有什么区别？数组只是一个具有数字属性的对象，在这里的代码中不会有不同的用法。理论上，您需要一个元组。@Bergi:区别在于javascript知道如何对多维数组排序。@thg435:嗯，什么？不，没有。您仍然需要自定义比较函数，尤其是在排序数字时，如OP.@thg435:然后尝试

[[2,0]，[10,1].sort（）

或

[[a]，0]，“b”，1]，“a，a”，2]，“a，[uu3]”。sort（）