Utilizzando map () su un iteratore

Supponiamo di avere una mappa:, let m = new Map();utilizzando m.values()restituisce un iteratore di mappa.

Ma non posso usare forEach()o map()su quell'iteratore e l'implementazione di un ciclo while su quell'iteratore sembra un anti-pattern poiché ES6 offre funzioni come map().

Quindi c'è un modo per usarlo map()su un iteratore?

Il modo più semplice e meno performante per farlo è:

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

Meglio ancora

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

Array.fromprende qualsiasi cosa iterabile o simile ad un array e lo converte in un array! Come sottolinea Daniel nei commenti, possiamo aggiungere una funzione di mappatura alla conversione per rimuovere un'iterazione e successivamente un array intermedio.

L'uso Array.fromsposterà la tua performance da O(1)a O(n)come indica @hraban nei commenti. Poiché mè a Map, e non possono essere infiniti, non dobbiamo preoccuparci di una sequenza infinita. Per la maggior parte dei casi, questo sarà sufficiente.

Ci sono un paio di altri modi per scorrere una mappa.

Utilizzando forEach

m.forEach((value,key) => /* stuff */ )

Utilizzando for..of

var 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

Potresti definire un'altra funzione iteratore per eseguire il ciclo su questo:

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(','));

Ora potresti chiederti: perché non usarlo semplicemente Array.from? Poiché questo eseguirà l'intero iteratore, lo salverà in un array (temporaneo), lo itererà di nuovo e quindi eseguirà la mappatura. Se l'elenco è enorme (o addirittura potenzialmente infinito), ciò comporterà un utilizzo della memoria non necessario.

Ovviamente, se l'elenco degli elementi è abbastanza piccolo, l'utilizzo Array.fromdovrebbe essere più che sufficiente.

Questo modo più semplice ed efficiente è utilizzare il secondo argomento Array.fromper ottenere ciò:

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

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

Questo approccio funziona per qualsiasi iterabile non infinito . Ed evita di dover utilizzare una chiamata separata per Array.from(map).map(...)cui iterare due volte attraverso l'iterabile e peggiorare le prestazioni.

È possibile recuperare un iteratore sull'iterabile, quindi restituire un altro iteratore che chiama la funzione di callback di mappatura su ogni elemento iterato.

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

Potresti usare itiriri che implementa metodi di tipo array per iterabili:

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();

Dai un'occhiata a https://www.npmjs.com/package/fluent-iterable

Funziona con tutti gli iterabili (mappa, funzione generatore, array) e iterabili asincroni.

const map = new Map();
...
console.log(fluent(map).filter(..).map(..));

C'è una proposta, che sta portando più funzioni di supporto a Iterator: https://github.com/tc39/proposal-iterator-helpers ( renderizzato )

Puoi usarlo oggi utilizzando core-js:

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

// or if it's working for you:
// 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);

Altre risposte qui sono ... Strane. Sembra che stiano reimplementando parti del protocollo di iterazione. Puoi semplicemente fare questo:

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

e se vuoi un risultato concreto usa l'operatore spread ....

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