通过属性值对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);
为了完整起见，这个函数返回对象属性的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
更新：编辑2017年4月 – 这返回上面定义的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步骤更清晰，以防您需要改变一点点以您的方式工作：
我正在按照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
