Javascript 按值对对象属性排序

如果我有一个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 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>