按键sortingJavaScript对象

我需要通过键sortingJavaScript对象。

因此如下：

{ 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' } 

会成为：

 { 'a' : 'dsfdsfsdf', 'b' : 'asdsad', 'c' : 'masdas' } 

Answer 1

JavaScript对象¹没有sorting。 试图对它们进行“sorting”是没有意义的。 如果要迭代对象的属性，可以对键进行sorting，然后检索关联的值：

 var myObj = { 'b': 'asdsadfd', 'c': 'masdasaf', 'a': 'dsfdsfsdf' }, keys = [], k, i, len; for (k in myObj) { if (myObj.hasOwnProperty(k)) { keys.push(k); } } keys.sort(); len = keys.length; for (i = 0; i < len; i++) { k = keys[i]; alert(k + ':' + myObj[k]); } 

Answer 2

这个问题的其他答案已经过时，从未匹配过实际的实际情况，现在ES6 / ES2015规范已经发布，并且已经正式变得不正确了。

---

请参阅Axel Rauschmayer 探索ES6中的属性迭代顺序部分 ：

遍历属性键的所有方法都按照相同的顺序进行：

1. 首先全部数组索引，按数字sorting。
2. 然后所有的string键（不是索引），按照它们的创build顺序。
3. 然后所有的符号，按照它们被创build的顺序。

所以是的，JavaScript对象实际上是有序的，它们的键/属性的顺序可以改变。

以下是如何按字母顺序sorting对象的按键/属性：

 const unordered = { 'b': 'foo', 'c': 'bar', 'a': 'baz' }; console.log(JSON.stringify(unordered)); // → '{"b":"foo","c":"bar","a":"baz"}' const ordered = {}; Object.keys(unordered).sort().forEach(function(key) { ordered[key] = unordered[key]; }); console.log(JSON.stringify(ordered)); // → '{"a":"baz","b":"foo","c":"bar"}' 

使用var而不是const来与ES5引擎兼容。

Answer 3

很多人都提到“物体不能sorting” ，但是之后他们给了你一个解决scheme。 悖论，不是吗？

没有人提到这些解决scheme为什么起作用。 它们是，因为在浏览器的大部分实现中，对象中的值都按照添加顺序存储。 这就是为什么如果你从键sorting创build新的对象，它返回一个预期的结果。

我想我们可以添加一个解决scheme – ES5的function方式：

 function sortObject(obj) { return Object.keys(obj).sort().reduce(function (result, key) { result[key] = obj[key]; return result; }, {}); } 

上面的ES2015版本（格式化为“单行”）：

 function sortObject(o) { return Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {}); } 

上述例子的简短解释（如评论中所述）：

Object.keys给了我们提供的对象列表（ obj或o ），然后我们使用默认的sortingalgorithm对它们进行sorting，接下来使用.reduce将数组转换回一个对象，但是这一次按键sorting。

Answer 4

这对我有用

 /** * Return an Object sorted by it's Key */ var sortObjectByKey = function(obj){ var keys = []; var sorted_obj = {}; for(var key in obj){ if(obj.hasOwnProperty(key)){ keys.push(key); } } // sort keys keys.sort(); // create new array based on Sorted Keys jQuery.each(keys, function(i, key){ sorted_obj[key] = obj[key]; }); return sorted_obj; }; 

Answer 5

使用lodash这将工作：

 some_map = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' } // perform a function in order of ascending key _(some_map).keys().sort().each(function (key) { var value = some_map[key]; // do something }); // or alternatively to build a sorted list sorted_list = _(some_map).keys().sort().map(function (key) { var value = some_map[key]; // return something that shall become an item in the sorted list }).value(); 

只是思考的食物。

Answer 6

这是一个古老的问题，但从Mathias Bynens的回答中可以看出，我做了一个简短的版本来sorting当前的对象，没有太多的开销。

  Object.keys(unordered).sort().forEach(function(key) { var value = unordered[key]; delete unordered[key]; unordered[key] = value; }); 

代码执行后，“无序”对象本身将按字母顺序sorting键。

Answer 7

假设它在显示无序对象属性的VisualStudiodebugging器中很有用。

 (function(s){var t={};Object.keys(s).sort().forEach(function(k){t[k]=s[k]});return t})({b:2,a:1,c:3}) 

Answer 8

下划线版本 ：

 function order(unordered) { return _.object(_.sortBy(_.pairs(unordered),function(o){return o[0]})); } 

如果你不信任你的浏览器保持键的顺序，我强烈build议依靠一个有序的键 – 值成对数组数组。

 _.sortBy(_.pairs(c),function(o){return o[0]}) 

Answer 9

如前所述，对象是无序的。

然而…

你可能会发现这个成语很有用：

 var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }; var kv = []; for (var k in o) { kv.push([k, o[k]]); } kv.sort() 

然后你可以遍历kv并做任何你想做的事情。

 > kv.sort() [ [ 'a', 'dsfdsfsdf' ], [ 'b', 'asdsad' ], [ 'c', 'masdas' ] ] 

Answer 10

也许有点更优雅的forms：

  /** * Sorts a key-value object by key, maintaining key to data correlations. * @param {Object} src key-value object * @returns {Object} */ var ksort = function ( src ) { var keys = Object.keys( src ), target = {}; keys.sort(); keys.forEach(function ( key ) { target[ key ] = src[ key ]; }); return target; }; // Usage console.log(ksort({ a:1, c:3, b:2 })); 

Answer 11

这是一个干净的基于lodash的版本，与嵌套对象一起工作

 /** * Sort of the keys of an object alphabetically */ const sortKeys = function(obj) { if(_.isArray(obj)) { return obj.map(sortKeys); } if(_.isObject(obj)) { return _.fromPairs(_.keys(obj).sort().map(key => [key, sortKeys(obj[key])])); } return obj; }; 

如果lodash有一个toObject()方法，它会更干净。

Answer 12

这里sorting对象键的很好的例子： 以sorting的顺序迭代Javascript关联数组

Answer 13

如果您有嵌套的对象或嵌套的数组obj，请使用此代码。

 var sortObjectByKey = function(obj){ var keys = []; var sorted_obj = {}; for(var key in obj){ if(obj.hasOwnProperty(key)){ keys.push(key); } } // sort keys keys.sort(); // create new array based on Sorted Keys jQuery.each(keys, function(i, key){ var val = obj[key]; if(val instanceof Array){ //do for loop; var arr = []; jQuery.each(val,function(){ arr.push(sortObjectByKey(this)); }); val = arr; }else if(val instanceof Object){ val = sortObjectByKey(val) } sorted_obj[key] = val; }); return sorted_obj; }; 

Answer 14

解：

 function getSortedObject(object) { var sortedObject = {}; var keys = Object.keys(object); keys.sort(); for (var i = 0, size = keys.length; i < size; i++) { key = keys[i]; value = object[key]; sortedObject[key] = value; } return sortedObject; } // Test run getSortedObject({d: 4, a: 1, b: 2, c: 3}); 

说明：

许多JavaScript运行时按照添加顺序存储对象内的值。

要通过按键sorting对象的属性，可以使用Object.keys函数，该函数将返回一组键。 然后可以通过Array.prototype.sort（）方法对数组进行sorting，该方法对数组元素进行sorting（不需要将其分配给新variables）。

一旦键被sorting，你可以开始逐一使用它们来访问旧对象的内容来填充一个新的对象（现在已经sorting）。

以下是该过程的一个示例（您可以在目标浏览器中对其进行testing）：

 /** * Returns a copy of an object, which is ordered by the keys of the original object. * * @param {Object} object - The original object. * @returns {Object} Copy of the original object sorted by keys. */ function getSortedObject(object) { // New object which will be returned with sorted keys var sortedObject = {}; // Get array of keys from the old/current object var keys = Object.keys(object); // Sort keys (in place) keys.sort(); // Use sorted keys to copy values from old object to the new one for (var i = 0, size = keys.length; i < size; i++) { key = keys[i]; value = object[key]; sortedObject[key] = value; } // Return the new object return sortedObject; } /** * Test run */ var unsortedObject = { d: 4, a: 1, b: 2, c: 3 }; var sortedObject = getSortedObject(unsortedObject); for (var key in sortedObject) { var text = "Key: " + key + ", Value: " + sortedObject[key]; var paragraph = document.createElement('p'); paragraph.textContent = text; document.body.appendChild(paragraph); } 

Answer 15

我将一些Java枚举转移到JavaScript对象。

这些对象为我返回正确的数组。 如果对象键是混合types（string，int，char），则存在问题。

 var Helper = { isEmpty: function (obj) { return !obj || obj === null || obj === undefined || Array.isArray(obj) && obj.length === 0; }, isObject: function (obj) { return (typeof obj === 'object'); }, sortObjectKeys: function (object) { return Object.keys(object) .sort(function (a, b) { c = a - b; return c }); }, containsItem: function (arr, item) { if (arr && Array.isArray(arr)) { return arr.indexOf(item) > -1; } else { return arr === item; } }, pushArray: function (arr1, arr2) { if (arr1 && arr2 && Array.isArray(arr1)) { arr1.push.apply(arr1, Array.isArray(arr2) ? arr2 : [arr2]); } } }; function TypeHelper() { var _types = arguments[0], _defTypeIndex = 0, _currentType, _value; if (arguments.length == 2) { _defTypeIndex = arguments[1]; } Object.defineProperties(this, { Key: { get: function () { return _currentType; }, set: function (val) { _currentType.setType(val, true); }, enumerable: true }, Value: { get: function () { return _types[_currentType]; }, set: function (val) { _value.setType(val, false); }, enumerable: true } }); this.getAsList = function (keys) { var list = []; Helper.sortObjectKeys(_types).forEach(function (key, idx, array) { if (key && _types[key]) { if (!Helper.isEmpty(keys) && Helper.containsItem(keys, key) || Helper.isEmpty(keys)) { var json = {}; json.Key = key; json.Value = _types[key]; Helper.pushArray(list, json); } } }); return list; }; this.setType = function (value, isKey) { if (!Helper.isEmpty(value)) { Object.keys(_types).forEach(function (key, idx, array) { if (Helper.isObject(value)) { if (value && value.Key == key) { _currentType = key; } } else if (isKey) { if (value && value.toString() == key.toString()) { _currentType = key; } } else if (value && value.toString() == _types[key]) { _currentType = key; } }); } else { this.setDefaultType(); } return isKey ? _types[_currentType] : _currentType; }; this.setTypeByIndex = function (index) { var keys = Helper.sortObjectKeys(_types); for (var i = 0; i < keys.length; i++) { if (index === i) { _currentType = keys[index]; break; } } }; this.setDefaultType = function () { this.setTypeByIndex(_defTypeIndex); }; this.setDefaultType(); } var TypeA = { "-1": "Any", "2": "2L", "100": "100L", "200": "200L", "1000": "1000L" }; var TypeB = { "U": "Any", "W": "1L", "V": "2L", "A": "100L", "Z": "200L", "K": "1000L" }; console.log('keys of TypeA', Helper.sortObjectKeys(TypeA));//keys of TypeA ["-1", "2", "100", "200", "1000"] console.log('keys of TypeB', Helper.sortObjectKeys(TypeB));//keys of TypeB ["U", "W", "V", "A", "Z", "K"] var objectTypeA = new TypeHelper(TypeA), objectTypeB = new TypeHelper(TypeB); console.log('list of objectA = ', objectTypeA.getAsList()); console.log('list of objectB = ', objectTypeB.getAsList()); 

Answer 16

简单易读的代码片断，使用lodash。

只有在调用sortBy时，才需要将键放在引号中。 数据本身不一定要用引号。

 _.sortBy(myObj, "key") 

另外，你映射的第二个参数是错误的。 这应该是一个function，但使用采摘更容易。

 _.map( _.sortBy(myObj, "key") , "value"); 

Answer 17

只需使用lodash解压缩map和sortBy对的第一个值和zip再次它将返回sorting的关键。

如果要将sortby值更改为1，而不是0

 var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }; console.log(_(o).toPairs().sortBy(0).fromPairs().value()) 

Answer 18

@sindresorhus有一个伟大的项目，称为sort-keys，它的function非常棒。

你可以在这里查看它的源代码：

https://github.com/sindresorhus/sort-keys

或者你可以用npm来使用它：

 $ npm install --save sort-keys 

以下是自述文件中的代码示例

 const sortKeys = require('sort-keys'); sortKeys({c: 0, a: 0, b: 0}); //=> {a: 0, b: 0, c: 0} sortKeys({b: {b: 0, a: 0}, a: 0}, {deep: true}); //=> {a: 0, b: {a: 0, b: 0}} sortKeys({c: 0, a: 0, b: 0}, { compare: (a, b) => -a.localeCompare(b) }); //=> {c: 0, b: 0, a: 0} 

Answer 19

 function sortObjectKeys(obj){ return Object.keys(obj).sort().reduce((acc,key)=>{ acc[key]=obj[key]; return acc; },{}); } sortObjectKeys({ telephone: '069911234124', name: 'Lola', access: true, }); 

Answer 20

recursionsorting，用于嵌套对象和数组

 function sortObjectKeys(obj){ return Object.keys(obj).sort().reduce((acc,key)=>{ if (Array.isArray(obj[key])){ acc[key]=obj[key].map(sortObjectKeys); } if (typeof obj[key] === 'object'){ acc[key]=sortObjectKeys(obj[key]); } else{ acc[key]=obj[key]; } return acc; },{}); } // test it sortObjectKeys({ telephone: '069911234124', name: 'Lola', access: true, cars: [ {name: 'Family', brand: 'Volvo', cc:1600}, { name: 'City', brand: 'VW', cc:1200, interior: { wheel: 'plastic', radio: 'blaupunkt' } }, { cc:2600, name: 'Killer', brand: 'Plymouth', interior: { wheel: 'wooden', radio: 'earache!' } }, ] }); 

Answer 21

纯粹的JavaScript回答sorting对象。 这是我知道的唯一答案，将处理负数。 此function用于sorting数字对象。

inputobj = {1000：{}，-1200：{}，10000：{}，200：{}};

 function osort(obj) { var keys = Object.keys(obj); var len = keys.length; var rObj = []; var rK = []; var t = Object.keys(obj).length; while(t > rK.length) { var l = null; for(var x in keys) { if(l && parseInt(keys[x]) < parseInt(l)) { l = keys[x]; k = x; } if(!l) { // Find Lowest var l = keys[x]; var k = x; } } delete keys[k]; rK.push(l); } for (var i = 0; i < len; i++) { k = rK[i]; rObj.push(obj[k]); } return rObj; } 

输出将是一个按这些数字sorting的对象，新键从0开始。

Answer 22

只是为了简化它，并更清楚地从马特球的答案

 //your object var myObj = { b : 'asdsadfd', c : 'masdasaf', a : 'dsfdsfsdf' }; //fixed code var keys = []; for (var k in myObj) { if (myObj.hasOwnProperty(k)) { keys.push(k); } } keys.sort(); for (var i = 0; i < keys.length; i++) { k = keys[i]; alert(k + ':' + myObj[k]); }