排序两个数组以相同的方式

举例来说，如果我有这些阵列：排序两个数组以相同的方式

var name = ["Bob","Tom","Larry"]; 
var age = ["10", "20", "30"];

而且我用name.sort()“名称”排列的顺序变为：

var name = ["Bob","Larry","Tom"];

但是，如何能我排序“名称”数组，并让“年龄”数组保持相同的顺序？像这样：

var name = ["Bob","Larry","Tom"]; 
var age = ["10", "30", "20"];

来源

2012-07-16 supercoolville

有没有改变你存储数据的方式的机会吗？为了嵌套数组或者对象 – zerkms 2012-07-16 06:44:59

我会做出一个很好的猜测，并且说你没有办法用你当前发布的代码来做到这一点。每个阵列都没有在其中存储足够的信息。任何给定点的名称数组不知道它是否已被更改，没有属性保存排序顺序或类似。 – 2012-07-16 06:48:50

[JavaScript：操作两个数组]的可能重复（http://stackoverflow.com/questions/8862220/javascript-manipulate-two-arrays） – 2012-07-16 06:50:13

您可以对现有数组进行排序或重新组织数据。

方法1： 要使用现有的阵列，可以组合，排序和分隔它们： （假设相等的长度数组）

var names = ["Bob","Tom","Larry"]; 
var ages = ["10", "20", "30"]; 

//1) combine the arrays: 
var list = []; 
for (var j = 0; j < names.length; j++) 
    list.push({'name': names[j], 'age': ages[j]}); 

//2) sort: 
list.sort(function(a, b) { 
    return ((a.name < b.name) ? -1 : ((a.name == b.name) ? 0 : 1)); 
    //Sort could be modified to, for example, sort on the age 
    // if the name is the same. 
}); 

//3) separate them back out: 
for (var k = 0; k < list.length; k++) { 
    names[k] = list[k].name; 
    ages[k] = list[k].age; 
}

这具有不依赖的优点字符串解析技术，并且可以用于需要一起排序的任意数量的数组。

方法2：或者你也可以重新组织数据位，只是排序对象的集合：

var list = [ 
    {name: "Bob", age: 10}, 
    {name: "Tom", age: 20}, 
    {name: "Larry", age: 30} 
    ]; 

list.sort(function(a, b) { 
    return ((a.name < b.name) ? -1 : ((a.name == b.name) ? 0 : 1)); 
}); 

for (var i = 0; i<list.length; i++) { 
    alert(list[i].name + ", " + list[i].age); 
}

对于比较，-1意味着更低的指标，0表示相等，1所表示指数更高。值得注意的是sort()实际上改变了底层数组。

http://jsfiddle.net/ghBn7/38/

来源

2012-07-16 06:52:58 jwatts1980

非常感谢!!!!!!!! – supercoolville 2012-07-16 07:40:58

我总是忘记如何在JavaScript中做到这一点。 Serverside脚本语言只是内置了这个内容......我猜是太糟糕了。 – AlexMA 2013-03-14 20:36:15

这是非常好的答案，尤其是那些更新... – Andrew 2014-06-08 06:48:13

您试图通过仅对其中一个调用sort（）来排序2个independet数组。

实现此目的的一种方法是编写自己的排序方法来处理这个问题，这意味着当它在原始数组中就地交换2个元素时，它应该在“属性“数组。

这是一个关于如何尝试它的伪代码。

function mySort(originals, attributes) { 
    // Start of your sorting code here 
     swap(originals, i, j); 
     swap(attributes, i, j); 
    // Rest of your sorting code here 
}

来源

2012-07-16 06:49:17 Lopina

我实际上在想同样的事情，但是如果数据以不同的方式存储，当有更简单的方法来做到这一点时，似乎该死的不切实际。 – 2012-07-16 06:50:39

你可以每个成员的原始索引追加到值，对数组进行排序，然后取出索引并使用它来重新排序其它阵列。它只能在内容是字符串的地方工作，或者可以成功地转换成字符串和从字符串转换。

另一种解决方案是保留原始数组的副本，然后在排序后，找到每个成员现在的位置并适当调整另一个数组。

来源

2012-07-16 07:10:33 RobG

灵感来自@jwatts1980's answer和@Alexander's answer here我将这两个答案合并成一个快速和肮脏的解决方案; 主阵列是要排序的一个，剩下的只是遵循其指标

注意：非常非常大的阵列

/* @sort argument is the array that has the values to sort 
    @followers argument is an array of arrays which are all same length of 'sort' 
    all will be sorted accordingly 
    example: 

    sortMutipleArrays(
     [0, 6, 7, 8, 3, 4, 9], 
     [ ["zr", "sx", "sv", "et", "th", "fr", "nn"], 
      ["zero", "six", "seven", "eight", "three", "four", "nine"] 
     ] 
    ); 

    // Will return 

    { 
    sorted: [0, 3, 4, 6, 7, 8, 9], 
    followed: [ 
     ["zr", th, "fr", "sx", "sv", "et", "nn"], 
     ["zero", "three", "four", "six", "seven", "eight", "nine"] 
    ] 
    } 
*/

你可能想改变方法签名/回报效率不高结构，但这应该很容易。我就是这么做的，因为我需要它

var sortMultipleArrays = function (sort, followers) { 
    var index = this.getSortedIndex(sort) 
    , followed = []; 
    followers.unshift(sort); 
    followers.forEach(function(arr){ 
    var _arr = []; 
    for(var i = 0; i < arr.length; i++) 
     _arr[i] = arr[index[i]]; 
    followed.push(_arr); 
    }); 
    var result = {sorted: followed[0]}; 
    followed.shift(); 
    result.followed = followed; 
    return result; 
}; 

var getSortedIndex = function (arr) { 
    var index = []; 
    for (var i = 0; i < arr.length; i++) { 
    index.push(i); 
    } 
    index = index.sort((function(arr){ 
    /* this will sort ints in descending order, change it based on your needs */ 
    return function (a, b) {return ((arr[a] > arr[b]) ? -1 : ((arr[a] < arr[b]) ? 1 : 0)); 
    }; 
    })(arr)); 
    return index; 
};

来源

2013-06-14 17:12:30 bentael

最简单explantion是最好的，合并的阵列，然后排序后解压：像以前一样创建一个数组

name_age=["[email protected]","[email protected]","[email protected]"];

排序数组，然后提取名称和年龄，您可以使用@来调整名称结尾和年龄开始的位置。也许不是一个纯粹主义者的方法，但我有同样的问题，这是我的方法。

来源

2014-12-06 23:42:30

它与jwatts1980's answer (Update 2)非常相似。考虑阅读Sorting with map。

name.map(function (v, i) { 
    return { 
     value1 : v, 
     value2 : age[i] 
    }; 
}).sort(function (a, b) { 
    return ((a.value1 < b.value1) ? -1 : ((a.value1 == b.value1) ? 0 : 1)); 
}).forEach(function (v, i) { 
    name[i] = v.value1; 
    age[i] = v.value2; 
});

来源

2015-06-20 11:33:22 w35l3y

我遇到了同样的问题，想出了这个令人难以置信的简单解决方案。首先，相关ellements组合成字符串在一个单独的数组然后在排序比较函数像这样使用parseInt函数：

<html> 
<body> 
<div id="outPut"></div> 
<script> 
var theNums = [13,12,14]; 
var theStrs = ["a","b","c"]; 
var theCombine = []; 

for (var x in theNums) 
{ 
    theCombine[x] = theNums[x] + "," + theStrs; 
} 

var theSorted = theAr.sort(function(a,b) 
{ 
    var c = parseInt(a,10); 
    var d = parseInt(b,10); 
    return c-d; 
}); 
document.getElementById("outPut").innerHTML = theS; 
</script> 
</body> 
</html>

来源

2016-02-07 15:45:21

排序两个数组以相同的方式

回答

相关问题