按值排序对象属性
问题描述 投票：0回答：1
如果我有JavaScript对象，例如：
var list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
是否有一种基于值对属性进行排序的方法？这样我最终得到
list = {
"bar": 15,
"me": 75,
"you": 100,
"foo": 116
};
1个回答
投票
将它们移至数组，对该数组进行排序，然后将其用于您的目的。这是一个解决方案：
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]
})
投票
ES6更新：如果您担心要遍历排序对象（这就是为什么我想您希望对对象属性进行排序的原因），则可以使用{a: 1, b: 2, c: 3, d: 4, e: 5}
对象。
您可以按已排序的顺序插入（键，值）对，然后进行
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}
投票
投票
我正在关注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 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);
投票
这可能是将其作为真实有序对象处理的简单方法。不知道它有多慢。使用while循环也可能会更好。
demo
然后我从以下位置找到了此求反函数：the solution given by slebetman
// 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
}
所以
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
}
投票
http://nelsonwells.net/2011/10/swap-object-key-and-values-in-javascript/
输出= [{p：8}，{c：2}，{b：1}，{g：1}]
投票
以防万一，有人使用@Markus R和@James Moran注释的代码引用来寻找保留对象（带有键和值），只需使用：
Object.invert = function (obj) {
var new_obj = {};
for (var prop in obj) {
if(obj.hasOwnProperty(prop)) {
new_obj[obj[prop]] = prop;
}
}
return new_obj;
};
投票
没有多个for循环的排序值（按键排序将排序回调中的索引更改为“ 0”）
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)
投票
非常简短！
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}
const list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
let sorted = Object.fromEntries(
Object.entries(list).sort( (a,b) => a[1] - b[1] )
)
console.log('Sorted object: ', sorted) 投票
对象按值排序（DESC）
var sortedList = {};
Object.keys(list).sort((a,b) => list[a]-list[b]).forEach((key) => {
sortedList[key] = list[key]; });
投票
我们不想复制整个数据结构，或者在需要关联数组的地方使用数组。
这是与bonna相同的另一种方式：
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(list).sort(function(a,b){return list[a]-list[b]})
console.log(keysSorted); // bar,me,you,foo投票
投票
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;
}
投票
TypeScript
以下函数按值或值的属性对对象进行排序。如果您不使用TypeScript，则可以删除类型信息以将其转换为JavaScript。
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;
}
用法
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);无法保证JavaScript对象中键的顺序，因此我将结果排序并返回为 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 }
对象，该对象保留了排序顺序。
如果要将其转换回Object，则可以执行此操作：
/**
* Represents an associative array of a same type.
*/
interface Dictionary<T> {
[key: string]: T;
}
/**
* Sorts an object (dictionary) by value or property of value and returns
* the sorted result as a Map object to preserve the sort order.
*/
function sort<TValue>(
obj: Dictionary<TValue>,
valSelector: (val: TValue) => number | string,
) {
const sortedEntries = Object.entries(obj)
.sort((a, b) =>
valSelector(a[1]) > valSelector(b[1]) ? 1 :
valSelector(a[1]) < valSelector(b[1]) ? -1 : 0);
return new Map(sortedEntries);
}
投票
输入是对象，输出是对象，使用lodash＆js内置库，带有降序或升序选项，并且不会使输入对象发生突变
例如输入和输出
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);
实施
Map投票
解决此问题的另一种方法：-
var sortedObj = {} as any;
sortedMap.forEach((v,k) => { sortedObj[k] = v });
// res将具有结果数组
投票
谢谢，并继续回答@Nosredna
现在我们了解对象需要转换为数组，然后对数组进行排序。这对于按字符串对数组（或转换为数组的对象）进行排序很有用：
{
"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));
投票
我为此专门制作了一个插件，它接受1 arg（未排序的对象，并返回已按prop值排序的对象）。这将适用于所有二维对象，例如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];
});
...
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
这里是该功能的演示，按预期工作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;
}
投票
使用{"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));
您可以找到有关query-js的介绍性文章http://codepen.io/nicholasabrams/pen/RWRqve?editors=001
投票
上面找不到答案，它既可以工作，又可以是[[SMALL，并且可以支持嵌套对象（而不是数组），所以我写了我自己的一个:)可以用于字符串和整数。] >query-js
用法：
list.keys().select(function(k){
return {
key: k,
value : list[k]
}
}).orderBy(function(e){ return e.value;});
投票
您的对象可以具有任意数量的属性，如果将对象放入数组，则可以选择按所需的对象属性，数字或字符串进行排序。考虑这个数组：
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'
}
];
按出生日期排序，从大到大
// 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);
按名称排序
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);
投票
投票
出于完整性考虑，此函数返回对象属性的sorted array：
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 with the code above is here。此解决方案基于this article。
Updated fiddle for sorting strings is here.您可以从中删除两个附加的.toLowerCase（）转换，以进行区分大小写的字符串比较。
投票
JavaScript对象根据定义是无序的（请参见ECMAScript Language Specification，第8.6节）。语言规范甚至不能保证，如果您连续两次遍历对象的属性，那么第二次它们将以相同的顺序出现。
如果需要订购，请使用数组和Array.prototype.sort方法。
投票
@ marcusR的answer的“箭头”版本供参考
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月-这将返回上面定义的排序的myObj对象。
Object
.keys(myObj)
.sort((a, b) => myObj[a]-myObj[b])
.reduce((_sortedObj, key) => ({
..._sortedObj,
[key]: myObj[key]
}), {})
更新：2018年10月-Object.entries版本
Object
.entries(myObj)
.sort()
.reduce((_sortedObj, [k,v]) => ({
..._sortedObj,
[k]: v
}), {})
投票
ECMAScript 2017引入了Object.values / Object.entries。顾名思义，前者将一个对象的所有值聚合到一个数组中，后者将整个对象聚合到一个Object.values / Object.entries数组中。 Python的[key, value]和dict.values()等效项。
这些功能使将任何哈希排序到有序对象中变得非常容易。到目前为止，dict.values()，但是您可以在Firefox 47+上尝试。
dict.items()投票
OK，您可能知道，javascript具有sort（）函数，可以对数组进行排序，但对对象则没有任何作用...
因此，在这种情况下，我们需要以某种方式获取键的数组并对其进行排序，这就是api大部分时间为您提供数组对象的原因，因为Array具有比对象文字更多的本机功能，无论如何，快速排序是使用Object.key返回对象键的数组，我创建了ES6函数，该函数在下面为您完成工作，它使用本机sort（）和reduce（）在javascript中的功能：
dict.items()现在您可以像这样使用它：
only a small portion of JavaScript platforms support them
检查sortedMyObject，您可以看到按如下键排序的结果：
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]]
这样，主对象也不会被触摸，实际上我们得到了一个新对象。
我还在下面创建了图像，以使功能步骤更加清晰，以防万一您需要对其进行一些更改以按自己的方式工作：
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);
最新问题
- Docker Compose 上的 Trino、Hive Metastore、MinIo 无法创建外部路径 s3a:
- 使用 `pip freeze >requirements.txt` 创建带有环境标记的文件？
- Pandarallel 在 Openai 升级时失败并出现 SSLContext 错误
- 如何使用服务器端插件 Nuxt 3 的 event.context 来使用 NuxtApp
- 如何使 pip 在不兼容的依赖项上退出非零？
- 使字段内的树无法在不使用只读的情况下创建/编辑/删除。奥多16
- 需要帮助理解 Kotlin Arrow 中的 mapOrAccumulate()
- 如何从视图模型类设置代码隐藏属性？
- 如何区分textField.setText()和在java中手动向textField添加文本？
- “application/x-www-form-urlencoded”和空值的标准是什么？
- dataframe 到 json 列，其中多个值读取为一个字符串
- 为什么我的 ros2 节点在 /install 文件夹而不是 src/foo/resource/data 文件夹中查找数据？
- 转置后（行到列）分组在 3 列的行中查找最大日期
- PHP 致命错误，错误提示存在重复的类，但实际上并不存在
- Vuejs/Ionic 中的 Vuetify 模板
- 在数据分割过程中保留数据的空间分布
- SCSS 中的 Mixin（一个类在另一个类中的属性）
- 更改时的 JavaScript 检查所有输入字段值
- 按组内的唯一计数进行过滤
- 在flutter上安装http依赖项后打开应用程序出现问题