是否可以对 ES6映射对象进行排序？

一种方法是获取条目数组，对其进行排序，然后使用排序的数组创建一个新的 Map:

let ar = [...myMap.entries()];
sortedArray = ar.sort();
sortedMap = new Map(sortedArray);

但是如果你不想创建一个新的对象，但是要在同一个对象上工作，你可以这样做:

// Get an array of the keys and sort them
let keys = [...myMap.keys()];
sortedKeys = keys.sort();


sortedKeys.forEach((key)=>{
// Delete the element and set it again at the end
const value = this.get(key);
this.delete(key);
this.set(key,value);
})

也许这是一个更现实的例子，不是对 Map 对象排序，而是在执行 Map 之前预先准备排序。如果像这样做，语法实际上会变得非常紧凑。您可以像这样在 map 函数之前应用排序，在 map 之前应用排序函数(我正在使用 JSX 语法开发的 React 应用程序的示例)

请注意，我在这里使用箭头函数定义了一个内部排序函数，如果它比较小，返回 -1，否则返回0，这是根据我从 API 获得的数组中的 Javascript 对象的属性进行排序的。

report.ProcedureCodes.sort((a, b) => a.NumericalOrder < b.NumericalOrder ? -1 : 0).map((item, i) =>
<TableRow key={i}>


<TableCell>{item.Code}</TableCell>
<TableCell>{item.Text}</TableCell>
{/* <TableCell>{item.NumericalOrder}</TableCell> */}
</TableRow>
)

据我所知，目前还不可能对 Map 进行正确的排序。

其他将 Map 转换为数组并以这种方式排序的解决方案有以下缺陷:

var a = new Map([[1, 2], [3,4]])
console.log(a);    // a = Map(2) {1 => 2, 3 => 4}


var b = a;
console.log(b);    // b = Map(2) {1 => 2, 3 => 4}


a = new Map();     // this is when the sorting happens
console.log(a, b); // a = Map(0) {}     b = Map(2) {1 => 2, 3 => 4}

排序会创建一个新对象，指向未排序对象的所有其他指针都会中断。

花了两个小时来了解细节。

注意，问题的答案已经在 https://stackoverflow.com/a/31159284/984471给出了

然而，这个问题有一些不同寻常的关键点,
一个更加清晰的 下面是一个清晰的例子和一般的解释:

• 这里有更多的例子: https://javascript.info/map-set
• 您可以将下面的代码复制粘贴到以下链接，并根据您的特定用例修改它: https://www.jdoodle.com/execute-nodejs-online/

.

let m1 = new Map();


m1.set(6,1); // key 6 is number and type is preserved (can be strings too)
m1.set(10,1);
m1.set(100,1);
m1.set(1,1);
console.log(m1);


// "string" sorted (even if keys are numbers) - default behaviour
let m2 = new Map( [...m1].sort() );
//      ...is destructuring into individual elements
//      then [] will catch elements in an array
//      then sort() sorts the array
//      since Map can take array as parameter to its constructor, a new Map is created
console.log('m2', m2);


// number sorted
let m3 = new Map([...m1].sort((a, b) => {
if (a[0] > b[0]) return 1;
if (a[0] == b[0]) return 0;
if (a[0] < b[0]) return -1;
}));
console.log('m3', m3);


// Output
//    Map { 6 => 1, 10 => 1, 100 => 1, 1 => 1 }
// m2 Map { 1 => 1, 10 => 1, 100 => 1, 6 => 1 }
//           Note:  1,10,100,6  sorted as strings, default.
//           Note:  if the keys were string the sort behavior will be same as this
// m3 Map { 1 => 1, 6 => 1, 10 => 1, 100 => 1 }
//           Note:  1,6,10,100  sorted as number, looks correct for number keys

希望能帮上忙。

稍有变化-我没有扩展语法，我想工作的 object而不是 Map。

Object.fromEntries(Object.entries(apis).sort())

我建议对地图对象使用 自定义迭代器来实现排序访问，如下所示:

map[Symbol.iterator] = function* () {
yield* [...map.entries()].sort((a, b) => a[0].localeCompare(b[0]));
}

使用迭代器的优点是它只需要声明一次。在映射中添加/删除条目之后，映射上的新 for 循环将使用迭代器自动反映这些更改。在上述大多数答案中显示的排序副本不会，因为它们只能精确地反映地图在某个时间点的状态。

下面是使用初始情况的完整工作示例。

var map = new Map();
map.set('2-1', { name: 'foo' });
map.set('0-1', { name: 'bar' });


for (let [key, val] of map) {
console.log(key + ' - ' + val.name);
}
// 2-1 - foo
// 1-0 - bar


map[Symbol.iterator] = function* () {
yield* [...map.entries()].sort((a, b) => a[0].localeCompare(b[0]));
}


for (let [key, val] of map) {
console.log(key + ' - ' + val.name);
}
// 1-0 - bar
// 2-1 - foo


map.set('2-0', { name: 'zzz' });


for (let [key, val] of map) {
console.log(key + ' - ' + val.name);
}
// 1-0 - bar
// 2-0 - zzz
// 2-1 - foo

问候。

下面是通过递减对 Map ()进行排序的函数。

function groupBy(list, keyGetter) {
const map = new Map();
list.forEach((item) => {
const key = keyGetter(item);
const collection = map.get(key);
if (!collection) {
map.set(key, [item]);
} else {
collection.push(item);
}
});


const sortedMap = new Map();
[...map].sort((a, b) => b[1].length - a[1].length).forEach(e => sortedMap.set(e[0], e[1]));


return sortedMap;
}
const test = groupBy(array, item => item.fieldName);