在迭代器上使用map()

Question

假设我们有一个Map : let m = new Map();, using m.values()返回一个map迭代器.

但是我不能使用forEach()或者map()在那个迭代器上并且在迭代器上实现while循环看起来像反模式,因为ES6提供了类似的功能map().

那么有没有办法map()在迭代器上使用？

Answer 1

执行此操作的最简单且性能最差的方法是:Array.from(m).map(([key,value])=> //无论如何)

Array.from 采取任何可迭代或类似数组的东西,并给它阵列的权力!

然而,正如@hraban在评论中指出的那样,这将把你的表现从O(1)移到O(n).既然Array.from是一个O(1),O(n)也不可能是无限的,我们不必担心无限的序列.对于大多数情况,这就足够了.

还有其他几种方法可以遍历地图.

m

Array.from(m).map(([key,value]) => /* whatever */)

Map

Array.from(m, ([key, value]) => /* whatever */))

Answer 2

您可以定义另一个迭代器函数来循环遍历:

function* generator() {
    for(let i = 0; i < 10; i++) {
        console.log(i);
        yield i;
    }
}

function* mapIterator(iterator, mapping) {
    while (true) {
        let result = iterator.next();
        if (result.done) {
            break;
        }
        yield mapping(result.value);
    }
}

let values = generator();
let mapped = mapIterator(values, (i) => {
    let result = i*2;
    console.log(`x2 = ${result}`);
    return result;
});

console.log('The values will be generated right now.');
console.log(Array.from(mapped).join(','));

现在你可能会问:为什么不Array.from改用呢？因为这将遍历整个迭代器,将其保存到(临时)数组,再次迭代它然后执行映射.如果列表很大(甚至可能是无限的),这将导致不必要的内存使用.

当然,如果项目列表相当小,使用Array.from应该绰绰有余.

Answer 3

这种最简单、最高效的方法是使用第二个参数Array.from来实现：

const map = new Map()
map.set('a', 1)
map.set('b', 2)

Array.from(map, ([key, value]) => `${key}:${value}`)
// ['a:1', 'b:2']

这种方法适用于任何非无限迭代。并且它避免了必须使用单独的调用，Array.from(map).map(...)该调用会遍历可迭代对象两次并且性能更差。

Answer 4

有一个提案，将多个辅助函数引入Iterator：https://github.com/tc39/proposal-iterator-helpers（渲染）

您今天可以通过以下方式使用它core-js-pure：

import { from as iterFrom } from "core-js-pure/features/iterator";

// or if it's working for you (it should work according to the docs,
// but hasn't for me for some reason):
// import iterFrom from "core-js-pure/features/iterator/from";

let m = new Map();

m.set("13", 37);
m.set("42", 42);

const arr = iterFrom(m.values())
  .map((val) => val * 2)
  .toArray();

// prints "[74, 84]"
console.log(arr);

Answer 5

这里的其他答案是......奇怪。他们似乎正在重新实施迭代协议的部分内容。你可以这样做：

function* mapIter(iterable, callback) {
  for (let x of iterable) {
    yield callback(x);
  }
}

如果你想要一个具体的结果，只需使用扩展运算符...。

[...iterMap([1, 2, 3], x => x**2)]