按值对对象属性进行排序

Question

如果我有一个 JavaScript 对象，例如：

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

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

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

Answer 1

将它们移动到一个数组中，对该数组进行排序，然后将该数组用于您的目的。 这是一个解决方案：

let maxSpeed = {
    car: 300, 
    bike: 60, 
    motorbike: 200, 
    airplane: 1000,
    helicopter: 400, 
    rocket: 8 * 60 * 60
};
let 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 对象中元素的顺序做出假设。

let objSorted = {}
sortable.forEach(function(item){
    objSorted[item[0]]=item[1]
})

---

在 ES8 中，您可以使用Object.entries()将对象转换为数组：

 const maxSpeed = { car: 300, bike: 60, motorbike: 200, airplane: 1000, helicopter: 400, rocket: 8 * 60 * 60 }; const sortable = Object.entries(maxSpeed) .sort(([,a],[,b]) => ab) .reduce((r, [k, v]) => ({ ...r, [k]: v }), {}); console.log(sortable);

---

在 ES10 中，您可以使用Object.fromEntries()将数组转换为对象。 那么代码可以简化为：

 const maxSpeed = { car: 300, bike: 60, motorbike: 200, airplane: 1000, helicopter: 400, rocket: 8 * 60 * 60 }; const sortable = Object.fromEntries( Object.entries(maxSpeed).sort(([,a],[,b]) => ab) ); console.log(sortable);

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

ECMAScript 2017 引入了Object.values / Object.entries 。 顾名思义，前者把一个对象的所有值聚合成一个数组，后者把整个对象做成一个[key, value]数组的数组； Python 相当于 dict.values( 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 5

为了完整起见，此函数返回对象属性的排序数组：

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 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对象。

 const myObj = { you: 100, me: 75, foo: 116, bar: 15 }; const result = Object.keys(myObj) .sort((a, b) => myObj[a] - myObj[b]) .reduce( (_sortedObj, key) => ({ ..._sortedObj, [key]: myObj[key] }), {} ); document.write(JSON.stringify(result));

更新：2021 年 3 月- 具有排序功能的 Object.entries（根据评论更新）

 const myObj = { you: 100, me: 75, foo: 116, bar: 15 }; const result = Object .entries(myObj) .sort((a, b) => a[1] - b[1]) .reduce((_sortedObj, [k,v]) => ({ ..._sortedObj, [k]: v }), {}) document.write(JSON.stringify(result));

Answer 7

JavaScript 对象根据定义是无序的（参见ECMAScript 语言规范，第 8.6 节）。 语言规范甚至不保证，如果您连续两次迭代对象的属性，它们第二次将以相同的顺序出现。

如果您需要订购物品，请使用数组和 Array.prototype.sort 方法。

Answer 8

好的，你可能知道，javascript 有sort()函数，可以对数组进行排序，但没有对象......

因此，在这种情况下，我们需要以某种方式获取键数组并对它们进行排序，这就是 api 在大多数情况下为您提供数组中的对象的原因，因为 Array 具有比对象字面量更多的本机函数，无论如何，快速独奏使用Object.key ，它返回一个对象键数组，我在下面创建了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 ，您可以看到按如下键排序的结果：

{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

使用 ES6 更新：如果您担心要迭代一个排序的对象（这就是我想您希望对对象属性进行排序的原因），您可以使用Map对象。

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

非常简短！

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

Answer 12

在没有多个 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 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);

 <script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js" integrity="sha256-qXBd/EfAdjOA2FGrGAG+b3YBn2tn5A6bhz+LSgYD96k=" crossorigin="anonymous"></script>

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
}

Answer 15

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 ] ]

Answer 16

以防万一，有人正在寻找保留对象（带有键和值），使用@Markus R 和@James Moran 评论的代码参考，只需使用：

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}

Answer 17

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

Answer 18

有很多方法可以做到这一点，但由于我没有看到任何使用reduce()我把它放在这里。 也许它似乎对某人有用。

 var list = { "you": 100, "me": 75, "foo": 116, "bar": 15 }; let result = Object.keys(list).sort((a,b)=>list[a]>list[b]?1:-1).reduce((a,b)=> {a[b]=list[b]; return a},{}); console.log(result);

Answer 19

感谢 @orad 在 TypeScript 中提供答案。 现在，我们可以在 JavaScript 中使用以下代码片段。

 function sort(obj,valSelector) { 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); } const Countries = { "AD": { "name": "Andorra", }, "AE": { "name": "United Arab Emirates", }, "IN": { "name": "India", }} // Sort the object inside object. var sortedMap = sort(Countries, val => val.name); // Convert to object. var sortedObj = {}; sortedMap.forEach((v,k) => { sortedObj[k] = v }); console.log(sortedObj); //Output: {"AD": {"name": "Andorra"},"IN": {"name": "India"},"AE": {"name": "United Arab Emirates"}}

Answer 20

按值对对象属性进行排序

 const obj = { you: 100, me: 75, foo: 116, bar: 15 }; const keysSorted = Object.keys(obj).sort((a, b) => obj[a] - obj[b]); const result = {}; keysSorted.forEach(key => { result[key] = obj[key]; }); document.write('Result: ' + JSON.stringify(result));

所需的输出：

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

参考：

• 按值对对象属性进行排序
• 将数组转换为对象

Answer 21

这可能是将其作为真正的有序对象处理的简单方法。 不知道它有多慢。 使用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

}

然后我从以下位置找到了这个反转函数：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)

Answer 22

按值排序的对象 (DESC)

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

Answer 23

    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 }

Answer 24

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
   } , [])

输出 = [ { p: 8 }, { c: 2 }, { b: 1 }, { g: 1 } ]

Answer 25

打字稿

以下函数按值或值的属性对对象进行排序。 如果您不使用 TypeScript，您可以删除类型信息以将其转换为 JavaScript。

/**
 * 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);
}

用法

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

无法保证 JavaScript 对象中键的顺序，因此我将结果排序并返回为保留排序顺序的Map对象。

如果要将其转换回 Object，可以执行以下操作：

var sortedObj = {} as any;
sortedMap.forEach((v,k) => { sortedObj[k] = v });

Answer 26

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

Answer 27

我的排序解决方案：

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

Answer 28

另一个使用Object.values 、 sort()和spread operator的示例。

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)

最后，我们生成新的排序对象（同样，使用spread operator保持对象的原始形式，以[x: number]作为键）：

var paintingsSortedByYear = {
    ...sortedByYear
}

var paintingsSortedByPrice = {
    ...sortedByPrice
}

希望这会有所帮助！

Answer 29

对一个早已过时的问题的后续回答。 我编写了两个函数，一个按键排序，另一个按值排序，并在两个函数中以排序后的形式返回对象。 它也应该适用于字符串，因为这就是我发布此内容的原因（如果值不是数字，则在按值排序时遇到上述某些问题）。

 const a = { absolutely: "works", entirely: 'zen', best: 'player', average: 'joe' } const prop_sort = obj => { return Object.keys(obj) .sort() .reduce((a, v) => { a[v] = obj[v]; return a; }, {}); } const value_sort = obj => { const ret = {} Object.values(obj) .sort() .forEach(val => { const key = Object.keys(obj).find(key => obj[key] == val) ret[key] = val }) return ret } console.log(prop_sort(a)) console.log(value_sort(a))

Answer 30

许多相似且有用的功能： 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;
}

Answer 31

这里还有一个例子：

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

Answer 32

这是对对象进行排序并获得排序对象作为回报的方法

let sortedObject = {}
sortedObject = Object.keys(yourObject).sort((a, b) => {
                        return yourObject[a] - yourObject[b] 
                    }).reduce((prev, curr, i) => {
                        prev[i] = yourObject[curr]
                        return prev
                    }, {});

您可以根据需要自定义排序功能

Answer 33

输入为对象，输出为对象，使用lodash & js 内置库，带降序或升序选项，不改变输入对象

例如输入和输出

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

Answer 34

查找每个元素的频率并按频率/值对其进行排序。

 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' ]

Answer 35

解决此问题的另一种方法：-

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将有结果数组

Answer 36

谢谢并继续回答@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

Answer 37

尝试这个。 即使您的对象没有您尝试排序的属性，也将得到处理。

只需通过发送带有对象的属性来调用它。

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

Answer 38

使用query-js你可以这样做

list.keys().select(function(k){
    return {
        key: k,
        value : list[k]
    }
}).orderBy(function(e){ return e.value;});

您可以在 此处找到有关 query-js 的介绍性文章

Answer 39

我为此制作了一个插件，它接受 1 个未排序对象的 arg，并返回一个已按 prop 值排序的对象。 这将适用于所有二维对象，例如{"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));

这是按预期工作的功能的演示http://codepen.io/nicholasabrams/pen/RWRqve?editors=001

Answer 40

在上面找不到既可以工作又可以是SMALL的答案，并且会支持嵌套对象（不是数组），所以我自己写了一个 :) 适用于字符串和整数。

  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'
       } 
    }

Answer 41

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链接

Answer 42

我用我自己的方式尝试过

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)

Answer 43

我有一个对象数组，我根据值属性按降序对它们进行了排序

 var objs_1 = [{ "label": "allsight", "value": 0, "series": 0, "key": "Secondary Sources" }, { "label": "customertransaction", "value": 84, "series": 0, "key": "Secondary Sources" }, { "label": "emailfrom", "value": 20, "series": 0, "key": "Secondary Sources" }, { "label": "webchat", "value": 20, "series": 0, "key": "Secondary Sources" }, { "label": "deterministicmatch", "value": 0, "series": 0, "key": "Secondary Sources" } ]; objs_1.sort(function(a, b) { return b.value - a.value; }); console.log(objs_1);

Answer 44

如果我有这样的对象，

var dayObj = {
              "Friday":["5:00pm to 12:00am"] ,
              "Wednesday":["5:00pm to 11:00pm"],
              "Sunday":["11:00am to 11:00pm"], 
              "Thursday":["5:00pm to 11:00pm"],
              "Saturday":["11:00am to 12:00am"]
           }

想按天顺序排序，

我们应该先有 daySorterMap，

var daySorterMap = {
  // "sunday": 0, // << if sunday is first day of week
  "Monday": 1,
  "Tuesday": 2,
  "Wednesday": 3,
  "Thursday": 4,
  "Friday": 5,
  "Saturday": 6,
  "Sunday": 7
}

启动一个单独的 Object sortedDayObj，

var sortedDayObj={};
Object.keys(dayObj)
.sort((a,b) => daySorterMap[a] - daySorterMap[b])
.forEach(value=>sortedDayObj[value]= dayObj[value])

您可以返回 sortedDayObj