如果我有一个 JavaScript 对象,例如:
var list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
有没有一种方法可以根据值对属性进行排序?这样我最后会得到:
list = {
"bar": 15,
"me": 75,
"you": 100,
"foo": 116
};
如果我有一个 JavaScript 对象,例如:
var list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
有没有一种方法可以根据值对属性进行排序?这样我最后会得到:
list = {
"bar": 15,
"me": 75,
"you": 100,
"foo": 116
};
另一个示例使用 Object.values
、sort()
和 spread 操作符
。
var paintings = {
0: {
title: 'Oh my!',
year: '2020',
price: '3000'
},
1: {
title: 'Portrait V',
year: '2021',
price: '2000'
},
2: {
title: 'The last leaf',
year: '2005',
price: '600'
}
}
Object.values
将对象转换为对象数组:var toArray = Object.values(paintings)
接下来,我们使用 spread operator
使原始数组不可变,并使用 sort()
方法按年份和价格对数组进行排序:
var sortedByYear = [...toArray].sort((a, b) => a.year - b.year)
var sortedByPrice = [...toArray].sort((a, b) => a.price - b.price)
展开运算符
以保留具有[x:number]
作为键的对象形式):var paintingsSortedByYear = {
...sortedByYear
}
var paintingsSortedByPrice = {
...sortedByPrice
}
这是获取排序后对象并返回已排序对象的方法。
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) {
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);
查找每个元素的频率并按频率/值进行排序。
let response = ["apple", "orange", "apple", "banana", "orange", "banana", "banana"];
let frequency = {};
response.forEach(function(item) {
frequency[item] = frequency[item] ? frequency[item] + 1 : 1;
});
console.log(frequency);
let intents = Object.entries(frequency)
.sort((a, b) => b[1] - a[1])
.map(function(x) {
return x[0];
});
console.log(intents);
输出:
{ apple: 2, orange: 2, banana: 3 }
[ 'banana', 'apple', 'orange' ]
例如输入和输出
{
"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));
function sortObjByValue(list){
var sortedObj = {}
Object.keys(list)
.map(key => [key, list[key]])
.sort((a,b) => a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0)
.forEach(data => sortedObj[data[0]] = data[1]);
return sortedObj;
}
sortObjByValue(list);
Github Gist 链接
在上面的答案中,我找不到既能正常工作又小巧,并且支持嵌套对象(而不是数组)的解决方案,因此我自己编写了一个 :) 可以处理字符串和整数。
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'
}
}
我已经按照自己的方式尝试过了
var maxSpeed = {
car: 300,
bike: 60,
motorbike: 200,
airplane: 1000,
helicopter: 400,
rocket: 8 * 60 * 60
};
var sorted = {}
Object.keys(maxSpeed).sort ((a,b) => maxSpeed[a] - maxSpeed[b]).map(item => sorted[item] = maxSpeed[item]);
console.log(sorted)
感谢并继续回答@Nosredna
现在我们明白了对象需要转换为数组,然后对数组进行排序。这对于按字符串排序数组(或转换为数组的对象)非常有用:
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
Object.entries
的答案,它是自ES2017以来最干净、最易读的现代方法:https://dev59.com/LXNA5IYBdhLWcg3wKacx#37607084 - jakub.g