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

好吧，你可能知道，javascript有sort()函数，排序数组，但没有对象…

在这种情况下，我们需要以某种方式获取数组的键并对它们进行排序，这就是api大多数时候给你数组中的对象的原因，因为数组有更多的本机函数来处理它们，而不是对象字面量，无论如何，快速解决方案是使用对象。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}

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

我还创建了下面的图像，以使函数步骤更加清晰，以防你需要稍微改变它来按照你的方式工作:

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

如果你需要对事物进行排序，可以使用数组和array .prototype.sort方法。

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

Eg输入输出

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

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

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(合适的);

打印稿

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