Utilisation de map() sur un itérateur

Question

Disons que nous avons une carte : let m = new Map(); en utilisant m.values() renvoie un itérateur de carte.

Mais je ne peux pas utiliser forEach() o map() sur cet itérateur et l'implémentation d'une boucle while sur cet itérateur semble être un anti-modèle puisque l'ES6 offre des fonctions telles que map() .

Y a-t-il un moyen d'utiliser map() sur un itérateur ?

Answer 1

El le plus simple y le moins performant La façon de faire est la suivante :

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

Mieux encore

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

Array.from prend n'importe quel itérable ou objet similaire à un tableau et le convertit en un tableau ! Comme Daniel le fait remarquer dans les commentaires, nous pouvons ajouter une fonction de mappage à la conversion pour supprimer une itération et, par la suite, un tableau intermédiaire.

Utilisation de Array.from fera passer vos performances de O(1) a O(n) comme le souligne @hraban dans les commentaires. Depuis m est un Map et ils ne peuvent pas être infinis, nous n'avons pas à nous soucier d'une séquence infinie. Dans la plupart des cas, cela suffira.

Il existe plusieurs autres façons de parcourir une carte en boucle.

Utilisation de forEach

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

Utilisation de 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

Answer 2

Vous pourriez définir une autre fonction d'itération pour boucler sur cette fonction :

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

Maintenant, vous pourriez vous demander : pourquoi ne pas simplement utiliser Array.from à la place ? Parce que cela va parcourir l'itérateur entier, le sauvegarder dans un tableau (temporaire), l'itérer à nouveau et puis faire la cartographie. Si la liste est énorme (ou même potentiellement infinie), cela entraînera une utilisation inutile de la mémoire.

Bien sûr, si la liste d'éléments est relativement petite, l'utilisation de l'option Array.from devrait être plus que suffisant.

Answer 3

La méthode la plus simple et la plus performante consiste à utiliser le deuxième argument de la commande Array.from pour y parvenir :

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

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

Cette approche fonctionne pour tout non-infini itérable. Et cela évite d'avoir à utiliser un appel séparé à Array.from(map).map(...) qui itérerait deux fois dans l'itérable et serait moins performant.

Answer 4

Vous pourriez récupérer un itérateur sur l'itérable, puis renvoyer un autre itérateur qui appelle la fonction de rappel du mappage sur chaque élément itéré.

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

Answer 5

Vous pourriez utiliser itiriri qui implémente des méthodes de type tableau pour les itérables :

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