通过属性值对JavaScript对象进行sorting

如果我有一个JavaScript对象,如:

var list = { "you": 100, "me": 75, "foo": 116, "bar": 15 }; 

有没有一种方法来基于值sorting属性? 所以我结束了

 list = { "bar": 15, "me": 75, "you": 100, "foo": 116 }; 

我对此有一个真正的脑死亡的时刻。

将它们移动到一个数组,sorting该数组,然后将数组用于您的目的。

这是我通过Google find的解决scheme :

 var maxSpeed = { car: 300, bike: 60, motorbike: 200, airplane: 1000, helicopter: 400, rocket: 8 * 60 * 60 }; var sortable = []; for (var vehicle in maxSpeed) { sortable.push([vehicle, maxSpeed[vehicle]]); } sortable.sort(function(a, b) { return a[1] - b[1]; }); //[["bike", 60], ["motorbike", 200], ["car", 300], //["helicopter", 400], ["airplane", 1000], ["rocket", 28800]] 

一旦你有了数组,你可以按照你喜欢的顺序从数组中重build对象,从而实现你准备做的事情。 这将在我所知道的所有浏览器中都能正常工作,但是这将取决于实现的问题,并可能在任何时候中断。 你不应该对JavaScript对象中元素的顺序做出假设。

我们不想复制整个数据结构,或者在需要关联数组的地方使用数组。

这里有另一种方法来做和bonna一样的事情:

 var list = {"you": 100, "me": 75, "foo": 116, "bar": 15}; keysSorted = Object.keys(list).sort(function(a,b){return list[a]-list[b]}) alert(keysSorted); // bar,me,you,foo 

你的对象可以有任何数量的属性,你可以selectsorting你想要的任何对象属性,数字或string,如果你把对象在数组中。 考虑这个数组:

 var arrayOfObjects = [ { name: 'Diana', born: 1373925600000, // Mon, Jul 15 2013 num: 4, sex: 'female' }, { name: 'Beyonce', born: 1366832953000, // Wed, Apr 24 2013 num: 2, sex: 'female' }, { name: 'Albert', born: 1370288700000, // Mon, Jun 3 2013 num: 3, sex: 'male' }, { name: 'Doris', born: 1354412087000, // Sat, Dec 1 2012 num: 1, sex: 'female' } ]; 

按出生datesorting,先到先

 // use slice() to copy the array and not just make a reference var byDate = arrayOfObjects.slice(0); byDate.sort(function(a,b) { return a.born - b.born; }); console.log('by date:'); console.log(byDate); 

按名称sorting

 var byName = arrayOfObjects.slice(0); byName.sort(function(a,b) { var x = a.name.toLowerCase(); var y = b.name.toLowerCase(); return x < y ? -1 : x > y ? 1 : 0; }); console.log('by name:'); console.log(byName); 

http://jsfiddle.net/xsM5s/16/

为了完整起见,这个函数返回对象属性的sorting数组

 function sortObject(obj) { var arr = []; for (var prop in obj) { if (obj.hasOwnProperty(prop)) { arr.push({ 'key': prop, 'value': obj[prop] }); } } arr.sort(function(a, b) { return a.value - b.value; }); //arr.sort(function(a, b) { a.value.toLowerCase().localeCompare(b.value.toLowerCase()); }); //use this to sort as strings return arr; // returns array } var list = {"you": 100, "me": 75, "foo": 116, "bar": 15}; var arr = sortObject(list); console.log(arr); // [{key:"bar", value:15}, {key:"me", value:75}, {key:"you", value:100}, {key:"foo", value:116}] 

上面的代码Jsfiddle在这里 。 这个解决scheme是基于这篇文章 。

更新的小提琴sortingstring在这里。 您可以从中删除额外的.toLowerCase()转换,以区分大小写的string比较。

JavaScript对象根据定义是无序的(请参阅ECMAScript语言规范 ,第8.6节)。 语言规范甚至不保证,如果你连续两次遍历一个对象的属性,它们将在第二次以相同的顺序出来。

如果您需要订购的东西,请使用数组和Array.prototype.sort方法。

@marcusR的“箭头”版本供参考

 var myObj = {"you": 100, "me": 75, "foo": 116, "bar": 15}; keysSorted = Object.keys(myObj).sort((a,b) => myObj[a]-myObj[b]) alert(keysSorted); // bar,me,you,foo 

更新:编辑20174月 – 这返回上面定义的sorting的myObj对象。

 Object .keys(myObj) .sort((a, b) => myObj[a]-myObj[b]) .reduce((_sortedObj, key) => ({ ..._sortedObj, [key]: myObj[key] }), {}) 

在这里尝试!

用于高级数组或对象sorting的Underscore.js或Lodash.js

  var data={ "models": { "LTI": [ "TX" ], "Carado": [ "A", "T", "A(пасс)", "A(груз)", "T(пасс)", "T(груз)", "A", "T" ], "SPARK": [ "SP110C 2", "sp150r 18" ], "Autobianchi": [ "A112" ] } }; var arr=[], obj={}; for(var i in data.models){ arr.push([i, _.sortBy(data.models[i],function (el){return el;})]); } arr=_.sortBy(arr,function (el){ return el[0]; }); _.map(arr,function (el){return obj[el[0]]=el[1];}); console.log(obj); 

演示

ECMAScript 2017引入了Object.values / Object.entries 。 顾名思义,前者将一个对象的所有值聚合成一个数组,后者将整个对象转换为一个[key, value]数组的数组; Python相当于dict.items()dict.items()

这些特性使得将任何哈希sorting到一个有序的对象中变得相当容易。 到目前为止, 只有一小部分JavaScript平台支持它们 ,但您可以在Firefox 47+上试用。

 let obj = {"you": 100, "me": 75, "foo": 116, "bar": 15}; let entries = Object.entries(obj); // [["you",100],["me",75],["foo",116],["bar",15]] let sorted = entries.sort((a, b) => a[1] - b[1]); // [["bar",15],["me",75],["you",100],["foo",116]] 

好吧 ,你可能知道,JavaScript有sort()函数,sorting数组,但没有对象…

所以在这种情况下,我们需要以某种方式获取键的数组并sorting它们,这就是apis在大多数情况下给你一个数组中的对象的原因,因为Array比对象字面量有更多的原生函数来处理它们,不pipe怎样,快速solo是使用Object.key返回一个对象键数组,我创build了ES6函数下面为你做的工作,它使用JavaScript中的本地sort()reduce()函数:

 function sortObject(obj) { return Object.keys(obj) .sort().reduce((a, v) => { a[v] = obj[v]; return a; }, {}); } 

现在你可以像这样使用它:

 let myObject = {a: 1, c: 3, e: 5, b: 2, d: 4}; let sortedMyObject = sortObject(myObject); 

检查sortedMyObject,你可以看到这样按键sorting的结果:

 {a: 1, b: 2, c: 3, d: 4, e: 5} 

也是这样,主要的对象不会被触及,我们实际上得到一个新的对象。

我也创build下面的图像,使function步骤更清晰,以防您需要改变一点点以您的方式工作:

按属性值排序javascript对象

我正在按照slebetman给出的解决scheme (去阅读所有的细节),但调整,因为你的对象是非嵌套的。

 // First create the array of keys/values so that we can sort it: var sort_array = []; for (var key in list) { sort_array.push({key:key,value:list[key]}); } // Now sort it: sort_array.sort(function(x,y){return x.value - y.value}); // Now process that object with it: for (var i=0;i<sort_array.length;i++) { var item = list[sort_array[i].key]; // now do stuff with each item } 

使用ES6更新:如果您的担心是有一个sorting的对象迭代(这就是为什么我想你想要你的对象属性sorting),你可以使用地图对象。

你可以插入你的(键,值)对按sorting顺序,然后做一个for..of循环将保证让他们循环插入他们的顺序

 var myMap = new Map(); myMap.set(0, "zero"); myMap.set(1, "one"); for (var [key, value] of myMap) { console.log(key + " = " + value); } // 0 = zero // 1 = one 
 var list = { "you": 100, "me": 75, "foo": 116, "bar": 15 }; function sortAssocObject(list) { var sortable = []; for (var key in list) { sortable.push([key, list[key]]); } sortable.sort(function(a, b) { return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0)); }); var orderedList = {}; for (var i = 0; i < sortable.length; i++) { orderedList[sortable[i][0]] = sortable[i][1]; } return orderedList; } sortAssocObject(list); // {bar: 15, me: 75, you: 100, foo: 116} 

这可能是一个简单的方法来处理它作为一个真正的有序对象。 不知道它有多慢。 也可能是更好的一个while循环。

 Object.sortByKeys = function(myObj){ var keys = Object.keys(myObj) keys.sort() var sortedObject = Object() for(i in keys){ key = keys[i] sortedObject[key]=myObj[key] } return sortedObject } 

然后我发现这个倒置function: http : //nelsonwells.net/2011/10/swap-object-key-and-values-in-javascript/

 Object.invert = function (obj) { var new_obj = {}; for (var prop in obj) { if(obj.hasOwnProperty(prop)) { new_obj[obj[prop]] = prop; } } return new_obj; }; 

所以

 var list = {"you": 100, "me": 75, "foo": 116, "bar": 15}; var invertedList = Object.invert(list) var invertedOrderedList = Object.sortByKeys(invertedList) var orderedList = Object.invert(invertedOrderedList) 

这里还有一个例子:

 function sortObject(obj) { var arr = []; var prop; for (prop in obj) { if (obj.hasOwnProperty(prop)) { arr.push({ 'key': prop, 'value': obj[prop] }); } } arr.sort(function(a, b) { return a.value - b.value; }); return arr; // returns array } var list = { car: 300, bike: 60, motorbike: 200, airplane: 1000, helicopter: 400, rocket: 8 * 60 * 60 }; var arr = sortObject(list); console.log(arr); 

许多相似和有用的function: https : //github.com/shimondoodkin/groupbyfunctions/

 function sortobj(obj) { var keys=Object.keys(obj); var kva= keys.map(function(k,i) { return [k,obj[k]]; }); kva.sort(function(a,b){ if(a[1]>b[1]) return -1;if(a[1]<b[1]) return 1; return 0 }); var o={} kva.forEach(function(a){ o[a[0]]=a[1]}) return o; } function sortobjkey(obj,key) { var keys=Object.keys(obj); var kva= keys.map(function(k,i) { return [k,obj[k]]; }); kva.sort(function(a,b){ k=key; if(a[1][k]>b[1][k]) return -1;if(a[1][k]<b[1][k]) return 1; return 0 }); var o={} kva.forEach(function(a){ o[a[0]]=a[1]}) return o; } 

尝试这个

  var speed = { car: 300, bike: 60, motorbike: 200, airplane: 1000, helicopter: 400, rocket: 8 * 60 * 60 }; var sortable = []; for (var vehicle in speed) { sortable.push([vehicle, speed[vehicle]]); } sortable.sort(function(a, b) { return a[1] - b[1]; }); 

解决这个问题的另一种方法:

 var res = [{"s1":5},{"s2":3},{"s3":8}].sort(function(obj1,obj2){ var prop1; var prop2; for(prop in obj1) { prop1=prop; } for(prop in obj2) { prop2=prop; } //the above two for loops will iterate only once because we use it to find the key return obj1[prop1]-obj2[prop2]; }); 

// res将有结果数组

谢谢你,继续回答@Nosredna

现在我们知道对象需要转换为数组,然后对数组进行sorting。 这对于按string排列数组(或转换的对象到数组)是很有用的:

 Object {6: Object, 7: Object, 8: Object, 9: Object, 10: Object, 11: Object, 12: Object} 6: Object id: "6" name: "PhD" obe_service_type_id: "2" __proto__: Object 7: Object id: "7" name: "BVC (BPTC)" obe_service_type_id: "2" __proto__: Object //Sort options var sortable = []; for (var vehicle in options) sortable.push([vehicle, options[vehicle]]); sortable.sort(function(a, b) { return a[1].name < b[1].name ? -1 : 1; }); //sortable => prints [Array[2], Array[2], Array[2], Array[2], Array[2], Array[2], Array[2]] 0: Array[2] 0: "11" 1: Object id: "11" name: "AS/A2" obe_service_type_id: "2" __proto__: Object length: 2 __proto__: Array[0] 1: Array[2] 0: "7" 1: Object id: "7" name: "BVC (BPTC)" obe_service_type_id: "2" __proto__: Object length: 2 

尝试这个。 即使你的对象没有基于你想要sorting的属性也将得到处理。

只需通过发送带有对象的属性来调用它。

 var sortObjectByProperty = function(property,object){ console.time("Sorting"); var sortedList = []; emptyProperty = []; tempObject = []; nullProperty = []; $.each(object,function(index,entry){ if(entry.hasOwnProperty(property)){ var propertyValue = entry[property]; if(propertyValue!="" && propertyValue!=null){ sortedList.push({key:propertyValue.toLowerCase().trim(),value:entry}); }else{ emptyProperty.push(entry); } }else{ nullProperty.push(entry); } }); sortedList.sort(function(a,b){ return a.key < b.key ? -1 : 1; //return a.key < b.key?-1:1; // Asc //return a.key < b.key?1:-1; // Desc }); $.each(sortedList,function(key,entry){ tempObject[tempObject.length] = entry.value; }); if(emptyProperty.length>0){ tempObject.concat(emptyProperty); } if(nullProperty.length>0){ tempObject.concat(nullProperty); } console.timeEnd("Sorting"); return tempObject; } 

我为此创build了一个插件,它接受1个未sorting对象的参数arg,并返回一个已经按prop值sorting的对象。 这将适用于所有2维对象,如{"Nick": 28, "Bob": 52}

 var sloppyObj = { 'C': 78, 'A': 3, 'B': 4 }; // Extend object to support sort method function sortObj(obj) { "use strict"; function Obj2Array(obj) { var newObj = []; for (var key in obj) { if (!obj.hasOwnProperty(key)) return; var value = [key, obj[key]]; newObj.push(value); } return newObj; } var sortedArray = Obj2Array(obj).sort(function(a, b) { if (a[1] < b[1]) return -1; if (a[1] > b[1]) return 1; return 0; }); function recreateSortedObject(targ) { var sortedObj = {}; for (var i = 0; i < targ.length; i++) { sortedObj[targ[i][0]] = targ[i][1]; } return sortedObj; } return recreateSortedObject(sortedArray); } var sortedObj = sortObj(sloppyObj); alert(JSON.stringify(sortedObj)); 

这里是一个按预期工作的function演示 http://codepen.io/nicholasabrams/pen/RWRqve?editors=001

使用查询-js你可以这样做

 list.keys().select(function(k){ return { key: k, value : list[k] } }).orderBy(function(e){ return e.value;}); 

你可以在这里find关于query-js的介绍性文章

Couln't没有find答案上面这将工作和 ,并将支持嵌套的对象(不是数组),所以我写了我自己的一个:)工作都与string和整数。

  function sortObjectProperties(obj, sortValue){ var keysSorted = Object.keys(obj).sort(function(a,b){return obj[a][sortValue]-obj[b][sortValue]}); var objSorted = {}; for(var i = 0; i < keysSorted.length; i++){ objSorted[keysSorted[i]] = obj[keysSorted[i]]; } return objSorted; } 

用法:

  /* sample object with unsorder properties, that we want to sort by their "customValue" property */ var objUnsorted = { prop1 : { customValue : 'ZZ' }, prop2 : { customValue : 'AA' } } // call the function, passing object and property with it should be sorted out var objSorted = sortObjectProperties(objUnsorted, 'customValue'); // now console.log(objSorted) will return: { prop2 : { customValue : 'AA' }, prop1 : { customValue : 'ZZ' } } 

这里是对对象进行sorting并获得sorting对象的方式

 let sortedObject = {} sortedObject = Object.keys(yourObject).sort((a, b) => { return yourObject[a] - yourObject[b] }).reduce((prev, curr, i) => { prev[i] = yourObject[curr] return prev }, {}); 

您可以根据您的要求定制您的分类function