按属性值排序JavaScript对象

Question

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

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

有没有办法根据值对属性进行排序？所以我最终得到了

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

Answer 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对象中元素的顺序.

Answer 2

我们不想复制整个数据结构,也不想使用需要关联数组的数组.

这是与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

Answer 3

您的对象可以包含任意数量的属性,如果将对象放在数组中,则可以选择按所需的任何对象属性,数字或字符串进行排序.考虑这个数组:

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);

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

Answer 4

为了完整起见,此函数返回已排序的对象属性数组:

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就在这里.此解决方案基于本文.

这里有用于排序字符串的更新小提琴.您可以从中删除其他.toLowerCase()转换,以进行区分大小写的字符串比较.

Answer 5

JavaScript对象按定义排序(请参阅ECMAScript语言规范,第8.6节).语言规范甚至不保证,如果你连续两次迭代一个对象的属性,它们将在第二次以相同的顺序出现.

如果需要订购内容,请使用数组和Array.prototype.sort方法.

Answer 6

@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月 - 返回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
 }), {})

试试吧!

Answer 7

ECMAScript 2017介绍Object.values / Object.entries.顾名思义,前者将对象的所有值聚合到一个数组中,后者将整个对象聚合成一个数组[key, value]数组; Python相当于dict.values()和dict.items().

这些功能使得将任何哈希排序为有序对象变得相当容易.截至目前,只有一小部分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]]

Answer 8

好吧,你可能知道,javascript有sort()函数,对数组进行排序,但没有任何对象...

所以在这种情况下,我们需要以某种方式获取键的数组并对它们进行排序,这就是api在大多数情况下为数组提供对象的原因,因为Array具有比对象文字更多的本机函数,无论如何,快速解决方法是使用Object.key返回一个对象键数组,我创建了ES6函数,在其下面为你完成了这项工作,它在javascript中使用了native 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,您可以看到按键排序的结果,如下所示:

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

这样,主要对象将不会被触及,我们实际上获得了一个新对象.

我还创建了下面的图像,以使功能步骤更加清晰,以防您需要更改它以便按照您的方式工作:

Answer 9

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}

Answer 10

在没有多个 for 循环的情况下对值进行排序（按键排序，将排序回调中的索引更改为“0”）

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) 

Answer 11

很短很简单！

var sortedList = {};
Object.keys(list).sort((a,b) => list[a]-list[b]).forEach((key) => {
    sortedList[key] = list[key]; });

Answer 12

使用ES6进行更新:如果您关心的是有一个要排序的已排序对象(这就是为什么我想您要对对象属性进行排序),您可以使用Map对象.

您可以按排序顺序插入(键,值)对,然后执行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

Answer 13

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);

演示

Answer 14

我正在遵循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
}