Say we have a Map: let m = new Map();, using m.values() returns a map iterator.
But I can't use forEach() or map() on that iterator and implementing a while loop on that iterator seems like an anti-pattern since ES6 offer functions like map().
So is there a way to use map() on an iterator?
The simplest and least performant way to do this is:
Array.from(m).map(([key,value]) => /* whatever */) Better yet
Array.from(m, ([key, value]) => /* whatever */)) Array.from takes any iterable or array-like thing and converts it into an array! As Daniel points out in the comments, we can add a mapping function to the conversion to remove an iteration and subsequently an intermediate array.
Using Array.from will move your performance from O(1) to O(n) as @hraban points out in the comments. Since m is a Map, and they can't be infinite, we don't have to worry about an infinite sequence. For most instances, this will suffice.
There are a couple of other ways to loop through a map.
forEachm.forEach((value,key) => /* stuff */ ) for..ofvar myMap = new Map(); myMap.set(0, 'zero'); myMap.set(1, 'one'); for (var [key, value] of myMap) { console.log(key + ' = ' + value); } // 0 = zero // 1 = one 
Other answers here are... Weird. They seem to be re-implementing parts of the iteration protocol. You can just do this:
function* mapIter(iterable, callback) { for (let x of iterable) { yield callback(x); } } and if you want a concrete result just use the spread operator ....
[...mapIter([1, 2, 3], x => x**2)] 
[1, 2, 3].mapIter(x => x**2)? (not just for arrays but any iterable)This simplest and most performant way is to use the second argument to Array.from to achieve this:
const map = new Map() map.set('a', 1) map.set('b', 2) Array.from(map, ([key, value]) => `${key}:${value}`) // ['a:1', 'b:2'] This approach works for any non-infinite iterable. And it avoids having to use a separate call to Array.from(map).map(...) which would iterate through the iterable twice and be worse for performance.
You could define another iterator function to loop over this:
function* generator() { for (let i = 0; i < 10; i++) { console.log(i); yield i; } } function* mapIterator(iterator, mapping) { for (let i of iterator) { yield mapping(i); } } 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(','));Now you might ask: why not just use Array.from instead? Because this will run through the entire iterator, save it to a (temporary) array, iterate it again and then do the mapping. If the list is huge (or even potentially infinite) this will lead to unnecessary memory usage.
Of course, if the list of items is fairly small, using Array.from should be more than sufficient.
mapIterator() does not guarantee that underlying iterator will be properly closed (iterator.return() called) unless the return value's next was called at least once. See: repeater.js.org/docs/safety
for .. of .. loop?There is a proposal, that brings multiple helper functions to Iterator: https://github.com/tc39/proposal-iterator-helpers (rendered)
You can use it today by utilizing 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); 
import and iterFrom wrapper.In case someone needs the typescript version:
function* mapIter<T1, T2>(iterable: IterableIterator<T1>, callback: (value: T1) => T2) { for (let x of iterable) { yield callback(x); } } You could retrieve an iterator over the iterable, then return another iterator that calls the mapping callback function on each iterated element.
const map = (iterable, callback) => { return { [Symbol.iterator]() { const iterator = iterable[Symbol.iterator](); return { next() { const r = iterator.next(); if (r.done) return r; else { return { value: callback(r.value), done: false, }; } } } } } }; // Arrays are iterable console.log(...map([0, 1, 2, 3, 4], (num) => 2 * num)); // 0 2 4 6 8 
You could use itiriri that implements array-like methods for iterables:
import { query } from 'itiriri'; let m = new Map(); // set map ... query(m).filter([k, v] => k < 10).forEach([k, v] => console.log(v)); let arr = query(m.values()).map(v => v * 10).toArray(); 
from fn from "core-js-pure/features/iterator" which returns the "new" iterator.Take a look at https://www.npmjs.com/package/fluent-iterable
Works with all of iterables (Map, generator function, array) and async iterables.
const map = new Map(); ... console.log(fluent(map).filter(..).map(..)); Based on the answer from MartyO256 (https://stackoverflow.com/a/53159921/7895659), a refactored typescript approach could be the following one:
function mapIterator<TIn, TOut>( iterator: Iterator<TIn>, callback: (input: TIn) => TOut, ): Iterator<TOut> { return { next() { const result: IteratorResult<TIn> = iterator.next(); if (result.done === true) { return result; } else { return { done: false, value: callback(result.value), }; } }, }; } export function mapIterable<TIn, TOut>( iterable: Iterable<TIn>, callback: (input: TIn) => TOut, ): Iterable<TOut> { const iterator: Iterator<TIn> = iterable[Symbol.iterator](); const mappedIterator: Iterator<TOut> = mapIterator(iterator, callback); return { [Symbol.iterator]: () => mappedIterator, }; } 
lodashmapfunction which supports Map as well.Array.from(m.values()).map(...)works, but I think it's not the best way to do this.Array#map?