是否可以对ES6地图对象进行排序？

Question

是否可以对es6地图对象的条目进行排序？

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

结果是:

map.entries = {
    0: {"2-1", foo },
    1: {"0-1", bar }
}

是否可以根据键输入条目？

map.entries = {
    0: {"0-1", bar },
    1: {"2-1", foo }
}

Answer 1

根据MDN文件:

Map对象按插入顺序迭代其元素.

你可以这样做:

var map = new Map();
map.set('2-1', "foo");
map.set('0-1', "bar");
map.set('3-1', "baz");

var mapAsc = new Map([...map.entries()].sort());

console.log(mapAsc)

使用时.sort(),请记住,根据每个元素的字符串转换,数组根据每个字符的Unicode代码点值进行排序.所以2-1, 0-1, 3-1将正确排序.

Answer 2

转换Map为数组使用Array.from,排序数组,转换回Map,例如

new Map(
  Array
    .from(eventsByDate)
    .sort((a, b) => {
      // a[0], b[0] is the key of the map
      return a[0] - b[0];
    })
)

Answer 3

简短的回答

 new Map([...map].sort((a, b) => 
   // Some sort function comparing keys with a[0] b[0] or values with a[1] b[1]
   // Be sure to return -1 if lower and, if comparing values, return 0 if equal
 ))

例如,比较可以相等的值字符串,我们传递一个访问[1]并具有返回0的等于条件的sort函数:

 new Map([...map].sort((a, b) => (a[1] > b[1] && 1) || a[1] === b[1] ? 0 : -1))

比较关键字符串,它们不能相等(相同的字符串键会相互覆盖),我们可以跳过equals条件.但是,我们仍应显式返回-1,因为在以下情况下,返回惰性a[0] > b[0]错误会给出false(视为0,即等于)a[0] < b[0]:

 new Map([...map].sort((a, b) => a[0] > b[0] ? 1 : -1))

详细举例说明

将.entries()在[...map.entries()](在许多答案的建议)是多余的,除非JS引擎优化是离开你可能添加在地图的一个额外的迭代.

在简单的测试用例中,您可以执行以下问题:

new Map([...map].sort())

...如果键都是字符串,则比较压缩和强制逗号连接的键值字符串,比如'2-1,foo'和'0-1,[object Object]',返回带有新插入顺序的新Map:

注意:如果只看到{}SO的控制台输出,请查看真实的浏览器控制台

const map = new Map([
  ['2-1', 'foo'],
  ['0-1', { bar: 'bar' }],
  ['3-5', () => 'fuz'],
  ['3-2', [ 'baz' ]]
])

console.log(new Map([...map].sort()))

但是,依靠像这样的强制和字符串化并不是一个好习惯.您可以获得以下惊喜:

const map = new Map([
  ['2', '3,buh?'],
  ['2,1', 'foo'],
  ['0,1', { bar: 'bar' }],
  ['3,5', () => 'fuz'],
  ['3,2', [ 'baz' ]],
])

// Compares '2,3,buh?' with '2,1,foo'
// Therefore sorts ['2', '3,buh?'] ******AFTER****** ['2,1', 'foo']
console.log('Buh?', new Map([...map].sort()))

// Let's see exactly what each iteration is using as its comparator
for (const iteration of map) {
  console.log(iteration.toString())
}

像这样的错误很难调试 - 不要冒险!

如果要对键或值进行排序,最好使用a[0]和b[0]在sort函数中显式访问它们,如下所示.请注意,我们应该返回-1和1之前和之后,不是false或0与raw一样,a[0] > b[0]因为它被视为等于:

const map = new Map([
  ['2,1', 'this is overwritten'],
  ['2,1', '0,1'],
  ['0,1', '2,1'],
  ['2,2', '3,5'],
  ['3,5', '2,1'],
  ['2', ',9,9']
])

// For keys, we don't need an equals case, because identical keys overwrite 
const sortStringKeys = (a, b) => a[0] > b[0] ? 1 : -1 

// For values, we do need an equals case
const sortStringValues = (a, b) => (a[1] > b[1] && 1) || a[1] === b[1] ? 0 : -1

console.log('By keys:', new Map([...map].sort(sortStringKeys)))
console.log('By values:', new Map([...map].sort(sortStringValues)))

Answer 4

我们的想法是将地图的键提取到数组中.对此数组进行排序 然后遍历此排序数组,从未排序的映射中获取其值对并将它们放入新映射中.新地图将按排序顺序排列.下面的代码是它的实现:

var unsortedMap = new Map();
unsortedMap.set('2-1', 'foo');
unsortedMap.set('0-1', 'bar');

// Initialize your keys array
var keys = [];
// Initialize your sorted maps object
var sortedMap = new Map();

// Put keys in Array
unsortedMap.forEach(function callback(value, key, map) {
    keys.push(key);
});

// Sort keys array and go through them to put in and put them in sorted map
keys.sort().map(function(key) {
    sortedMap.set(key, unsortedMap.get(key));
});

// View your sorted map
console.log(sortedMap);

Answer 5

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

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

问候。

Answer 6

您可以转换为数组并对其调用数组排序方法：

[...map].sort(/* etc */);