Javascript 按值对对象属性排序
如果我有一个JavaScript对象,例如:Javascript 按值对对象属性排序,javascript,sorting,properties,object,Javascript,Sorting,Properties,Object,如果我有一个JavaScript对象,例如: var list = { "you": 100, "me": 75, "foo": 116, "bar": 15 }; <pre> function sortObjectByVal(obj){ var keysSorted = Object.keys(obj).sort(function(a,b){return obj[b]-obj[a]}); var newObj = {}; for(var x of key
var list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
<pre>
function sortObjectByVal(obj){
var keysSorted = Object.keys(obj).sort(function(a,b){return obj[b]-obj[a]});
var newObj = {};
for(var x of keysSorted){
newObj[x] = obj[x];
}
return newObj;
}
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
console.log(sortObjectByVal(list));
</pre>
有没有办法根据值对属性进行排序?这样我就有了
list = {
"bar": 15,
"me": 75,
"you": 100,
"foo": 116
};
JavaScript对象在定义上是无序的(参见第8.6节)。语言规范甚至不能保证,如果你连续两次迭代一个对象的属性,第二次它们将以相同的顺序出现
如果需要排序,请使用数组和array.prototype.sort方法。JavaScript对象根据定义是无序的(请参阅第8.6节)。语言规范甚至不能保证,如果你连续两次迭代一个对象的属性,第二次它们将以相同的顺序出现
如果需要排序,请使用数组和array.prototype.sort方法。将它们移动到数组中,对该数组进行排序,然后根据需要使用该数组。这里有一个解决方案:
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]]
一旦你有了数组,你就可以按照你喜欢的顺序从数组中重建对象,从而实现你想要做的事情。这在我所知道的所有浏览器中都可以使用,但这取决于实现的特殊性,并且可能随时中断。永远不要假设JavaScript对象中元素的顺序
var objSorted = {}
sortable.forEach(function(item){
objSorted[item[0]]=item[1]
})
在ES8中,可以使用将对象转换为数组:
const maxSpeed={
汽车:300,
自行车:60,
摩托车:200辆,
飞机:1000架,
直升机:400,
火箭:8*60*60
};
const sortable=Object.entries(maxSpeed)
.sort(([,a],,b])=>a-b)
.reduce((r[k,v])=>({…r[k]:v}),{});
console.log(可排序)代码>将它们移动到一个数组中,对该数组进行排序,然后根据需要使用该数组。这里有一个解决方案:
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]]
一旦你有了数组,你就可以按照你喜欢的顺序从数组中重建对象,从而实现你想要做的事情。这在我所知道的所有浏览器中都可以使用,但这取决于实现的特殊性,并且可能随时中断。永远不要假设JavaScript对象中元素的顺序
var objSorted = {}
sortable.forEach(function(item){
objSorted[item[0]]=item[1]
})
在ES8中,可以使用将对象转换为数组:
const maxSpeed={
汽车:300,
自行车:60,
摩托车:200辆,
飞机:1000架,
直升机:400,
火箭:8*60*60
};
const sortable=Object.entries(maxSpeed)
.sort(([,a],,b])=>a-b)
.reduce((r[k,v])=>({…r[k]:v}),{});
console.log(可排序)代码>为完整起见,此函数返回对象属性的排序数组:
功能排序对象(obj){
var-arr=[];
用于(obj中的var prop){
if(对象拥有自己的财产(财产)){
arr.push({
“关键”:道具,
“值”:对象[prop]
});
}
}
arr.sort(函数(a,b){返回a.value-b.value;});
//arr.sort(函数(a,b){a.value.toLowerCase().localeCompare(b.value.toLowerCase());});//使用此函数作为字符串排序
return arr;//返回数组
}
var list={“you”:100,“me”:75,“foo”:116,“bar”:15};
var arr=sortObject(列表);
console.log(arr);//[{key:“bar”,value:15},{key:“me”,value:75},{key:“you”,value:100},{key:“foo”,value:116}]
。此解决方案基于
您可以从中删除两个附加的.toLowerCase()转换,以进行区分大小写的字符串比较。为完整起见,此函数返回对象属性的排序数组:
功能排序对象(obj){
var-arr=[];
用于(obj中的var prop){
if(对象拥有自己的财产(财产)){
arr.push({
“关键”:道具,
“值”:对象[prop]
});
}
}
arr.sort(函数(a,b){返回a.value-b.value;});
//arr.sort(函数(a,b){a.value.toLowerCase().localeCompare(b.value.toLowerCase());});//使用此函数作为字符串排序
return arr;//返回数组
}
var list={“you”:100,“me”:75,“foo”:116,“bar”:15};
var arr=sortObject(列表);
console.log(arr);//[{key:“bar”,value:15},{key:“me”,value:75},{key:“you”,value:100},{key:“foo”,value:116}]
。此解决方案基于
您可以从中删除两个附加的.toLowerCase()转换,以进行区分大小写的字符串比较。我在下面(阅读所有详细信息),但由于您的对象是非嵌套的,因此进行了调整
// 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
}
//首先创建键/值数组,以便对其进行排序:
var sort_数组=[];
for(列表中的var键){
sort_array.push({key:key,value:list[key]});
}
//现在进行排序:
sort_array.sort(函数(x,y){返回x.value-y.value});
//现在使用它处理该对象:
对于(var i=0;i我在跟踪(阅读所有详细信息),但进行了调整,因为您的对象是非嵌套的
// 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
}
//首先创建键/值数组,以便对其进行排序:
var sort_数组=[];
for(列表中的var键){
sort_array.push({key:key,value:list[key]});
}
//现在进行排序:
sort_array.sort(函数(x,y){返回x.value-y.value});
//现在使用它处理该对象:
对于(var i=0;i我们不希望复制整个数据结构,或者在需要关联数组的地方使用数组
这里有另一种方法来做与bonna相同的事情:
var list={“you”:100,“me”:75,“foo”:116,“bar”:15};
keysorded=Object.keys(list).sort(函数(a,b){返回列表[a]-list[b]})
console.log(keysorded);//bar、me、you、foo
我们不想复制整个数据结构,也不想在需要关联数组的地方使用数组
这里有另一种方法来做与bonna相同的事情:
var list={“you”:100,“me”:75,“foo”:116,“bar”:15};
keysorded=Object.keys(list).sort(函数(a,b){返回列表[a]-list[b]})
log(keysorded);//bar、me、you、foo
下划线.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);
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 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;
}
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]]
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]]);
}
// [["you",100],["me",75],["foo",116],["bar",15]]
sortable.sort(function(a, b) {
return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0));
});
// [["bar",15],["me",75],["you",100],["foo",116]]
var orderedList = {};
for (var idx in sortable) {
orderedList[sortable[idx][0]] = sortable[idx][1];
}
return orderedList;
}
sortAssocObject(list);
// {bar: 15, me: 75, you: 100, foo: 116}
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 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);
{a: 1, b: 2, c: 3, d: 4, e: 5}
function sortObject(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;
}
var list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
var tmpList = {};
while (Object.keys(list).length) {
var key = Object.keys(list).reduce((a, b) => list[a] > list[b] ? a : b);
tmpList[key] = list[key];
delete list[key];
}
list = tmpList;
console.log(list); // { foo: 116, you: 100, me: 75, bar: 15 }
a = { b: 1, p: 8, c: 2, g: 1 }
Object.keys(a)
.sort((c,b) => {
return a[b]-a[c]
})
.reduce((acc, cur) => {
let o = {}
o[cur] = a[cur]
acc.push(o)
return acc
} , [])
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var newO = {};
Object.keys(list).sort(function(a,b){return list[a]-list[b]})
.map(key => newO[key] = list[key]);
console.log(newO); // {bar: 15, me: 75, you: 100, foo: 116}
var sortedList = {};
Object.keys(list).sort((a,b) => list[a]-list[b]).forEach((key) => {
sortedList[key] = list[key]; });
var list = {
"one": { height: 100, weight: 15 },
"two": { height: 75, weight: 12 },
"three": { height: 116, weight: 9 },
"four": { height: 15, weight: 10 },
};
var sortedMap = sort(list, val => val.height);
{
"a": 1,
"b": 4,
"c": 0,
"d": 2
}
{
"b": 4,
"d": 2,
"a": 1,
"c": 0
}
const _ = require('lodash');
const o = { a: 1, b: 4, c: 0, d: 2 };
function sortByValue(object, descending = true) {
const { max, min } = Math;
const selector = descending ? max : min;
const objects = [];
const cloned = _.clone(object);
while (!_.isEmpty(cloned)) {
const selectedValue = selector(...Object.values(cloned));
const [key, value] = Object.entries(cloned).find(([, value]) => value === selectedValue);
objects.push({ [key]: value });
delete cloned[key];
}
return _.merge(...objects);
}
const o2 = sortByValue(o);
console.log(JSON.stringify(o2, null, 2));
const arrayOfObjects = [
{name: 'test'},
{name: 'test2'}
]
const order = ['test2', 'test']
const setOrder = (arrayOfObjects, order) =>
arrayOfObjects.sort((a, b) => {
if (order.findIndex((i) => i === a.name) < order.findIndex((i) => i === b.name)) {
return -1;
}
if (order.findIndex((i) => i === a.name) > order.findIndex((i) => i === b.name)) {
return 1;
}
return 0;
});
let toSort = {a:2323, b: 14, c: 799}
let sorted = Object.entries(toSort ).sort((a,b)=> a[1]-b[1])
[ [ "b", 14 ], [ "c", 799 ], [ "a", 2323 ] ]
let list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
let sorted = Object.entries(list).sort((a,b) => a[1] - b[1]);
for(let element of sorted) {
console.log(element[0]+ ": " + element[1]);
}
<pre>
function sortObjectByVal(obj){
var keysSorted = Object.keys(obj).sort(function(a,b){return obj[b]-obj[a]});
var newObj = {};
for(var x of keysSorted){
newObj[x] = obj[x];
}
return newObj;
}
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
console.log(sortObjectByVal(list));
</pre>