如何通过在Javascript中的值来sorting关联数组？

我有关联数组：

array["sub2"] = 1; array["sub0"] = -1; array["sub1"] = 0; array["sub3"] = 1; array["sub4"] = 0; 

按其值sorting（降序）的最优雅的方式是什么，结果将是具有各自索引的数组：

 sub2, sub3, sub1, sub4, sub0? 

Answer 1

Javascript没有“关联数组”的方式，你想他们。 相反，您只需使用类似数组的语法（如您的示例）设置对象属性的function，以及对对象属性进行迭代的function。

这样做的结果是，不能保证你遍历属性的顺序 ，所以没有什么比这个更重要。 相反，你需要将你的对象属性转换成一个“真正的”数组（确保顺序）。 这里有一个代码片段，用于将一个对象转换为两元组（two-element arrays）数组，按照您所描述的对其进行sorting，然后遍历它：

 var tuples = []; for (var key in obj) tuples.push([key, obj[key]]); tuples.sort(function(a, b) { a = a[1]; b = b[1]; return a < b ? -1 : (a > b ? 1 : 0); }); for (var i = 0; i < tuples.length; i++) { var key = tuples[i][0]; var value = tuples[i][1]; // do something with key and value } 

你可能会发现把它包装在一个需要callback的函数中更自然：

 function bySortedValue(obj, callback, context) { var tuples = []; for (var key in obj) tuples.push([key, obj[key]]); tuples.sort(function(a, b) { return a[1] < b[1] ? 1 : a[1] > b[1] ? -1 : 0 }); var length = tuples.length; while (length--) callback.call(context, tuples[length][0], tuples[length][1]); } bySortedValue({ foo: 1, bar: 7, baz: 3 }, function(key, value) { document.getElementById('res').innerHTML += `${key}: ${value}<br>` }); 

 <p id='res'>Result:<br/><br/><p> 

Answer 2

而不是纠正你的关联数组的语义，我认为这是你想要的：

 function getSortedKeys(obj) { var keys = []; for(var key in obj) keys.push(key); return keys.sort(function(a,b){return obj[b]-obj[a]}); } 

你转储一个对象（就像你的），并得到一个关键字的数组–eh属性 – 返回，按照（eh）对象的值（eh）的（数值）降序排列。

这只适用于你的值是数值的。 Tweek中的小function(a,b)可以将sorting机制更改为上升，或者对string值进行处理（例如）。 留给读者作为练习。

$ 2c，* -pike

Answer 3

继续讨论和其他解决scheme涵盖如何按值sorting（关联）数组？ 最好的解决scheme（对于我的情况）是saml （下面引用）。

数组只能有数字索引。 您需要将其重写为对象或对象数组。

 var status = new Array(); status.push({name: 'BOB', val: 10}); status.push({name: 'TOM', val: 3}); status.push({name: 'ROB', val: 22}); status.push({name: 'JON', val: 7}); 

如果你喜欢status.push方法，你可以用下面的方法进行sorting：

 status.sort(function(a,b) { return a.val - b.val; }); 

Answer 4

在JavaScript中确实没有像“关联数组”那样的东西。 你在那里只是一个普通的老对象。 当然，它们的工作类似于关联数组，键可用，但键的顺序没有语义。

你可以把你的对象转换成一个对象数组（键/值对）并对其进行sorting：

 function sortObj(object, sortFunc) { var rv = []; for (var k in object) { if (object.hasOwnProperty(k)) rv.push({key: k, value: object[k]}); } rv.sort(function(o1, o2) { return sortFunc(o1.key, o2.key); }); return rv; } 

然后你可以用比较函数调用它。

Answer 5

如果你不喜欢元组，那么这里就是本空白答案的一个变种。

这为您节省了一些字符。

 var keys = []; for (var key in sortme) { keys.push(key); } keys.sort(function(k0, k1) { var a = sortme[k0]; var b = sortme[k1]; return a < b ? -1 : (a > b ? 1 : 0); }); for (var i = 0; i < keys.length; ++i) { var key = keys[i]; var value = sortme[key]; // Do something with key and value. } 

Answer 6

没有不必要的复杂性需要…

 function sortMapByValue(map) { var tupleArray = []; for (var key in map) tupleArray.push([key, map[key]]); tupleArray.sort(function (a, b) { return a[1] - b[1] }); return tupleArray; } 

Answer 7

我使用$。每个jQuery的，但你可以做一个for循环，一个改进是这样的：

  //.ArraySort(array) /* Sort an array */ ArraySort = function(array, sortFunc){ var tmp = []; var aSorted=[]; var oSorted={}; for (var k in array) { if (array.hasOwnProperty(k)) tmp.push({key: k, value: array[k]}); } tmp.sort(function(o1, o2) { return sortFunc(o1.value, o2.value); }); if(Object.prototype.toString.call(array) === '[object Array]'){ $.each(tmp, function(index, value){ aSorted.push(value.value); }); return aSorted; } if(Object.prototype.toString.call(array) === '[object Object]'){ $.each(tmp, function(index, value){ oSorted[value.key]=value.value; }); return oSorted; } }; 

所以，现在你可以做

  console.log("ArraySort"); var arr1 = [4,3,6,1,2,8,5,9,9]; var arr2 = {'a':4, 'b':3, 'c':6, 'd':1, 'e':2, 'f':8, 'g':5, 'h':9}; var arr3 = {a: 'green', b: 'brown', c: 'blue', d: 'red'}; var result1 = ArraySort(arr1, function(a,b){return ab}); var result2 = ArraySort(arr2, function(a,b){return ab}); var result3 = ArraySort(arr3, function(a,b){return a>b}); console.log(result1); console.log(result2); console.log(result3); 

Answer 8

就这样，有人正在寻找基于元组的sorting。 这将比较数组中对象的第一个元素，比第二个元素等等。 即在下面的例子中，它将首先比较“a”，然后比较“b”等等。

 let arr = [ {a:1, b:2, c:3}, {a:3, b:5, c:1}, {a:2, b:3, c:9}, {a:2, b:5, c:9}, {a:2, b:3, c:10} ] function getSortedScore(obj) { var keys = []; for(var key in obj[0]) keys.push(key); return obj.sort(function(a,b){ for (var i in keys) { let k = keys[i]; if (a[k]-b[k] > 0) return -1; else if (a[k]-b[k] < 0) return 1; else continue; }; }); } console.log(getSortedScore(arr)) 

。OUPUTS

  [ { a: 3, b: 5, c: 1 }, { a: 2, b: 5, c: 9 }, { a: 2, b: 3, c: 10 }, { a: 2, b: 3, c: 9 }, { a: 1, b: 2, c: 3 } ] 

Answer 9

@ commonpike的答案是“正确的”，但他继续评论…

现在大多数浏览器只是支持Object.keys()

是的.. Object.keys()是更好的方法 。

但什么更好 ？ coffeescript ，这是coffeescript ！

 sortedKeys = (x) -> Object.keys(x).sort (a,b) -> x[a] - x[b] sortedKeys 'a' : 1 'b' : 3 'c' : 4 'd' : -1 

[ 'd', 'a', 'b', 'c' ]