按键或值对 JavaScript 对象进行排序； ES6

Question

在我问之前；关于这个特定主题有很多讨论，其中大部分与 ES5 相关，不一定适用于 ES6。我试图得到一些澄清，也许可以帮助下一个在互联网上寻找答案的人。 这是专门针对 ES6 的。

问题：

考虑以下对象结构：

const unsorted_object = {
    'C': '0003',
    'D': '0004',
    'A': '0001',
    'B': '0002',
    'F': '0005',
}; 

1. 如何按键对 JavaScript 对象进行排序？ （已回复here）

   const sorted_object = {};
   Object.keys(unsorted_object).sort().forEach(function(key) {
       sorted_object[key] = unsorted_object[key];
   });
   

2. 如何按键值对 JavaScript 对象进行排序？

编辑 #1

我可能对问题 #2 不太清楚。这个想法是通过键的值而不是键和值对 JavaScript 对象进行排序。

编辑#2

const unsorted_object = {
    '0001': '13.1666',
    '0002': '11.0001',
    '0003': '10.6664',
    '0004': '13.1666',
    '0005': '7.3331',
};

输出：

'0001': '13.1666'
'0004': '13.1666'
'0002': '11.0001'
'0003': '10.6664'
'0005': '7.3331'

Answer 1

ES6 中的对象键具有遍历顺序。整数键总是第一个，并按升序（0 -> 9）排序。在非整数键中，分配顺序被保留（参见article）。要对对象的键进行排序，我们需要重新创建对象，并按所需的顺序添加键。

注意：这意味着排序只会对非整数键起作用，因为整数总是排在第一位，并且总是按升序排序。

排序和重新创建对象：

• 使用Object.entries() 获取键/值对数组 - [[key, value], [key, value]]
• 按值（对中的第二项）using array destructuring - [, v1] 对它们进行排序。使用 + 运算符将字符串转换为数字，
• Reduce 回到一个对象。使用解构 [k , v] 获取键和值，并使用 computed property names - ({ [k]: v }) 和 object spread - ({ ...r, [k]: v }) 将它们添加到累加器对象

const unsorted_object = {
    '0001': '13.1666',
    '0002': '11.0001',
    '0003': '10.6664',
    '0004': '13.1666',
    '0005': '7.3331',
};

const sorted_object = Object.entries(unsorted_object)
  .sort(([,v1], [,v2]) => +v2 - +v1)
  .reduce((r, [k, v]) => ({ ...r, [k]: v }), {});

console.log(sorted_object);

如果支持，您可以使用 Object.fromEntries() 而不是 Array.reduce() 从条目创建对象：

const unsorted_object = {
    '0001': '13.1666',
    '0002': '11.0001',
    '0003': '10.6664',
    '0004': '13.1666',
    '0005': '7.3331',
};

const sorted_object = Object.fromEntries(
  Object.entries(unsorted_object)
    .sort(([,v1], [,v2]) => +v2 - +v1)
);

console.log(sorted_object);

边缘友好版本，使用 Object.assign() 而不是传播：

const unsorted_object = {
    '0001': '13.1666',
    '0002': '11.0001',
    '0003': '10.6664',
    '0004': '13.1666',
    '0005': '7.3331',
};

const sorted_object = Object.entries(unsorted_object)
  .sort(([,v1], [,v2]) => +v2 - +v1)
  .reduce((r, [k, v]) => Object.assign(r, { [k]: v }), {});

console.log(sorted_object);

Answer 2

提取entries而不是keys，然后通过每个值的差异提取sort：

const unsorted_object = {
    'C': '0003',
    'D': '0004',
    'A': '0001',
    'B': '0002',
    'F': '0005',
};

const sorted_object = {};
Object.entries(unsorted_object)
  .sort((a, b) => a[1] - b[1])
  .forEach(([key, val]) => {
    sorted_object[key] = val;
  });
console.log(sorted_object);

请注意，使用reduce 从数组构造对象可能更合适：

const unsorted_object = {
    'C': '0003',
    'D': '0004',
    'A': '0001',
    'B': '0002',
    'F': '0005',
};

const sorted_object = Object.entries(unsorted_object)
  .sort((a, b) => a[1] - b[1])
  .reduce((a, [key, val]) => {
    a[key] = val;
    return a;
  }, {});
console.log(sorted_object);

Answer 3

您可以对entries 进行排序并使用reduce() 创建新对象。

话虽如此，您的应用设计中可能存在问题，甚至需要执行此类操作

const unsorted_object = {
  'C': '0003',
  'D': '0004',
  'A': '0001',
  'B': '0002',
  'F': '0005',
};

const sorted = Object.entries(unsorted_object)
  .sort((a, b) => a[1] - b[1])
  .reduce((a, c) => (a[c[0]] = c[1], a), {})

console.log(sorted)