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

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

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 = { 车: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(合适的);

在ES10中，你可以使用object. fromentries()将数组转换为对象。然后代码可以简化为:

const maxSpeed = { 车:300, 自行车:60岁 摩托车:200, 飞机:1000, 直升机:400, 火箭:8 * 60 * 60 }; const sortable = Object.fromEntries( Object.entries(maxSpeed).sort(([，a]，[，b]) => a-b) ）; console.log(合适的);

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

如果我有一个这样的对象，

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
}

初始化一个单独的对象sortedDayObj，

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

你可以返回sortedDayObj

打印稿

下面的函数根据值或值的属性对对象进行排序。如果你不使用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 });

按值排序对象属性

Const obj ={你:100，我:75,foo: 116, bar: 15}; const keysSorted = Object.keys(obj)。排序((a, b) => obj[a] - obj[b]); Const result = {}; keysSorted。forEach(key => {result[key] = obj[key];})； 文档。write('Result: ' + JSON.stringify(Result));

期望的输出:

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

引用:

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