按值对对象属性进行排序答案

【问题标题】：Sorting object property by values按值对对象属性进行排序
【发布时间】：2013-02-12 12:33:54
【问题描述】：

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

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

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

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

【问题讨论】：

不仅是“排序”，更重要的是对数字进行排序。数字不受 Javascripts Array.sort() 方法的影响，这意味着您不仅需要找到对属性进行排序的方法，还必须编写自己的函数来比较数值。
在阅读答案之前：答案是否。对象属性的顺序在 ECMAScript 中是非标准的。你永远不应该对 JavaScript 对象中元素的顺序做出假设。对象是属性的无序集合。下面的答案向您展示了如何在数组的帮助下“使用”排序的属性，但从未真正改变对象本身的属性顺序。 所以，不，这是不可能的。 即使您构建具有预排序属性的对象，也不能保证它们将来会以相同的顺序显示。继续阅读:)。
@GovindRai 然而，在现实世界的前端应用程序中，我们循环使用 ID 作为键的对象集合，如果转换为 HTML 模板，顺序很重要。你说他们没有顺序，我说他们完全符合我在控制台中看到的顺序。在当前浏览器中记录它们。该订单可以重新排序。一旦你遍历它们，它们就会有一个命令。
@GovindRai：现在可以按照规范中的指定顺序访问属性。这是个好主意吗？几乎可以肯定不是。 :-) 但从 ES2015 开始，它就在那里。
2019 访问者：检查这个几乎没有被赞成的基于 Object.entries 的答案，这是自 ES2017 以来最干净、最易读的最新技术：stackoverflow.com/a/37607084/245966

标签： javascript sorting properties object

【解决方案1】：

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

如果您需要排序，请使用数组和 Array.prototype.sort 方法。

【讨论】：

请注意，关于这个问题有很多争论。大多数实现都按照添加元素的顺序保留列表。 IIRC，Chrome 没有。关于 Chrome 是否应该与其他实现保持一致存在争论。我的信念是 JavaScript 对象是一个散列，不应该假设任何顺序。我相信 Python 也经历了同样的争论，并且最近引入了一个新的有序哈希列表。对于大多数浏览器，您可以通过重新创建对象、按排序值添加元素来做您想做的事情。但你不应该。
编辑。 Chrome 通常会保持秩序，但并非总是如此。这是相关的 Chromium 错误：code.google.com/p/chromium/issues/detail?id=883
那个错误报告是不合理的，那些依赖未记录行为的人就是那些有错误的人。阅读 ECMASCript 第 8.6 节；它明确指出“一个对象是一个无序的属性集合”。任何人如果在一些实现中发现它似乎并非如此，然后开始依赖于特定于实现的行为，那么他们就犯了一个大错误，他们不应该试图将责任推卸给自己。如果我在 Chrome 团队，我会将该错误报告标记为“无效，WontFix”。
EcmaScript 5 实际上将枚举顺序定义为插入顺序——缺少定义被认为是 ES3 中的规范错误。值得注意的是，EcmaScript 规范定义了没有人认为理智的行为——例如规范行为是在许多情况下在运行时抛出语法错误，根据错误使用 continue、break、++、--、const 等根据规范，在到达该代码之前抛出异常的任何引擎都是错误
@olliej - 我不认为这是正确的。规范说：“枚举属性的机制和顺序（第一个算法中的步骤 6.a，第二个算法中的步骤 7.a）没有指定”。这是最终草案 PDF 的第 92 页。

【解决方案2】：

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

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 中，可以使用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]) => a-b)
    .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]) => a-b)
);

console.log(sortable);

【讨论】：

您能否将“您可以重建”重新表述为“您可以使用数组来维护键的顺序并从对象中提取值”？正如您自己所提到的，它不仅是非标准的，而且如今除了 Chrome 之外，更多的浏览器都打破了这个错误的假设，所以最好不要鼓励用户尝试它。
这是您的代码的更紧凑版本。 Object.keys(maxSpeed).sort(function(a, b) {return -(maxSpeed[a] - maxSpeed[b])});
@TheBrain：补充一点，keys() 仅受 IE9+（和其他现代浏览器）支持，如果这值得关注的话。 keys() 也排除了元素原型链中的可枚举属性（与 for..in 不同）——但这通常更可取。
_.pairs 将对象转换为 [ [key1, value1], [key2, value2] ]。然后调用 sort 。然后在它上面调用_.object把它转回来。
我的项目需要对象键才能干净地合并，但还需要显式排序，因为元数据驱动 UI。我遵循了类似的方法，只是我添加了一个 hasOwnProperty 检查以避免爬上原型链。这是一篇关于在 JS 中迭代对象属性的好文章 hackernoon.com/…

【解决方案3】：

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

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() 转换以进行区分大小写的字符串比较。

【讨论】：

对象数组呢？ [ {name:Will}, {name:Bill}, {name:Ben} ]
您好，您可以使用localeCompare function 进行比较。将其添加到上面的答案中。
很好的解决方案。字符串排序需要返回
@Stano 正确而简单的解决方案。非常感谢。

【解决方案4】：

我正在关注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
}

【讨论】：

【解决方案5】：

我们不想复制整个数据结构，或者在需要关联数组的地方使用数组。

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

【讨论】：

这似乎是按键排序，而不是按值排序，这不是问题所要求的吗？
它按值排序，并显示键 - 但当它打印出来时我们会丢失值计数，因为它只打印键。
JavaScript 中不保证对象属性顺序，因此应将排序放入一个数组，而不是一个对象（即您所说的“关联数组”）。
别忘了。 keysSorted 是一个数组！不是对象！
如果在排序末尾添加.map(key => list[key]);，它将返回整个对象，而不仅仅是键

【解决方案6】：

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

demo

【讨论】：

【解决方案7】：

您的对象可以有任意数量的属性，如果您将对象放入数组中，您可以选择按您想要的任何对象属性（数字或字符串）进行排序。考虑这个数组：

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/

【讨论】：

按名称排序不应该substr出第一个字符；否则 Diana 和 Debra 有未定义的顺序。此外，您的byDate 排序实际上使用num，而不是born。
这看起来不错，但请注意，要比较字符串，您可以使用 x.localeCompare(y)
@JemarJones localCompare 看起来是一个非常有用的功能！请注意，并非所有浏览器都支持它 - IE 10 及更低版本、Safari Mobile 9 及更低版本。
@inorganik 是的，对于那些需要支持这些浏览器的人来说非常好
这是一个对象数组，不是 OP 要求的（具有多个属性的对象）

【解决方案8】：

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

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

【讨论】：

【解决方案9】：

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

【讨论】：

【解决方案10】：

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

【讨论】：

【解决方案11】：

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

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

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

【讨论】：

【解决方案12】：

使用query-js 你可以这样做

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

你可以在query-js上找到一篇介绍文章here

【讨论】：

【解决方案13】：

我为此做了一个插件，它接受 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

【讨论】：

【解决方案14】：

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

【讨论】：

【解决方案15】：

在上面找不到既可以工作又可以是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'
       } 
    }

【讨论】：

keysSorted 按 sortValue 升序排序，但由于 javascript 对象是属性的无序集合，因此尝试对这些属性进行排序是没有意义的

【解决方案16】：

ECMAScript 2017 引入了Object.values / Object.entries。顾名思义，前者把一个对象的所有值聚合成一个数组，后者把整个对象做成一个[key, value]数组的数组； Python 相当于 dict.values() 和 dict.items()。

这些功能使得将任何散列排序为有序对象变得非常容易。到目前为止，只有一小部分 JavaScript 平台支持它们，但您可以在 Firefox 47+ 上试用。

编辑：现在由all modern browsers!支持

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

【讨论】：

这怎么可能回答问题的标题Sorting JavaScript Object by property value？您误解了我认为的问题，因为您要更改原始对象而不是从中创建新数组。
@vsync 这个答案给出的结果与接受的答案相同，但代码更少，没有临时变量。
FWIW，这个答案很干净，是唯一帮助我的答案。
仅在 ff 中，不再是 ie，也不是 chrome，它们会自动对对象进行排序。 wtf
请注意，这不会保留密钥。

【解决方案17】：

这里还有一个例子：

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

【讨论】：

【解决方案18】：

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

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（根据 cmets 更新）

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

【讨论】：

不适用于var myObj = {"1": {"Value": 40}, "2": {"Value": 10}, "3": {"Value": 30}, "4": {"Value": 20}};
OP 的问题以及这个答案不包含嵌套对象@Rohanil 也许你想问另一个问题而不是投票。您的各种类型的嵌套对象显然需要比此解决方案提供的更多
请注意：您的更新实际上不会起作用。至少不是无处不在，也不是因为entries。根据标准，对象是属性的无序集合。好吧，这意味着如果您在按属性值或其他任何内容对新对象进行排序后尝试构造新对象，则属性键顺序再次变为未定义。例如，Chrome 默认对属性键进行排序，因此每次尝试对它们进行不同的排序都是无用的。您唯一的机会是根据您的排序偏好获取“索引”并相应地遍历原始对象。
是的@ZorgoZ，你是对的，很多人在这篇文章中提到了它。大多数时候，我们在转换为另一种类型（如 JSON）或另一个 reduce 函数之前将此函数用作转换。如果目标是此后改变对象，那么可能会出现意想不到的结果。我在跨引擎的这个功能上取得了成功。
注意：你不想在Object.entries()上使用sort()

【解决方案19】：

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

【讨论】：

同样在 ES6 (ES2015) 中：对象属性 do 有顺序（或者有一种方法可以按定义的顺序访问它们，这取决于您的观点）。如果属性名称是字符串并且看起来不像数组索引，则顺序是它们添加到对象的顺序。此顺序未指定为for-in 或Object.keys 遵守，但它已定义为Object.getOwnPropertyNames 和其他访问属性的新方法遵守名称数组。所以这是另一种选择。
但是“排序”操作在哪里呢？它们根本没有排序
@Green 我想我想在这里强调的是，使用Map，您实际上拥有一个可以按排序顺序存储的数据结构（对数据进行排序、循环并将其存储在地图），因为你不能保证与对象。

【解决方案20】：

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}

【讨论】：

简单而完美！这回答了这个问题。谢谢。
在 javascript 中不能保证键顺序，所以如果键是整数等，这对我来说会失败
没错，ParoX。当键是整数类型时，这不能正常工作。

【解决方案21】：

这是对对象进行排序并返回排序对象的方法

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

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

【讨论】：

很好的答案。谢谢！

【解决方案22】：

OK，你可能知道，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}

同样这样，主对象不会被触及，我们实际上得到了一个新对象。

我还创建了下面的图像，以使功能步骤更清晰，以防您需要对其进行一些更改以按照自己的方式工作：

【讨论】：

按键排序，而不是按值。
@ROROROOROROR，这只是说明它是如何工作的，因为它们没有那么不同，但都很好，我也会按值添加排序
按值排序是错误的，它是您的数据集。将c: 3 更改为c: 13，您会看到它分崩离析。
@VtoCorleone 这只是一个自然的排序错误，1 优先，而不是算法中的缺陷。

【解决方案23】：

按值排序的对象 (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;
}

【讨论】：

【解决方案24】：

如果我有这样的对象，

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

【讨论】：

这根本不回答 OP 的问题
@notnavindu .. 是的，这可能无法回答所有问题，但确实有一个更简单的解决方案，` 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章

【解决方案25】：

    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 }

【讨论】：

【解决方案26】：

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

【讨论】：

【解决方案27】：

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 Link

【讨论】：

【解决方案28】：

以防万一，有人正在寻找保留对象（带有键和值），使用@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}

【讨论】：

你正在返回一个作业，map，forEach 会更好

【解决方案29】：

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

【讨论】：

【解决方案30】：

非常简短！

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

【讨论】：