Використання map () на ітераторі

Скажімо, у нас є Map:, let m = new Map();за допомогою m.values()повертає ітератор карти.

Але я не можу використовувати forEach()або map()на цьому ітераторі, і реалізація циклу while на цьому ітераторі здається анти-шаблоном, оскільки ES6 пропонує такі функції, як map().

Тож чи є спосіб використовувати map()на ітераторі?

Найпростішим і НЕ менш продуктивний спосіб зробити це:

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

Ще краще

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

Array.fromбере будь-яку ітерабельну або схожу на масив річ і перетворює її в масив! Як зазначає Даніель у коментарях, ми можемо додати функцію відображення до перетворення, щоб видалити ітерацію та згодом проміжний масив.

Використання Array.fromперенесе вашу ефективність із O(1)на, O(n)як зазначає @hraban у коментарях. Оскільки mє Map, і вони не можуть бути нескінченними, нам не доведеться турбуватися про нескінченну послідовність. Для більшості випадків цього буде достатньо.

Існує ще кілька способів прокрутити карту.

Використовуючи forEach

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

Використовуючи 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

Ви можете визначити іншу ітераторну функцію, щоб цикл над цим:

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має бути більш ніж достатнім.

Цей найпростіший і найефективніший спосіб полягає у використанні другого аргументу 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(...)який би повторив ітерацію двічі та погіршив роботу.

Ви можете отримати ітератор над ітерабельним, а потім повернути інший ітератор, який викликає функцію зворотного виклику відображення на кожному ітераційному елементі.

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

Ви можете використовувати itiriri, який реалізує схожі на масив методи для 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();

Погляньте на https://www.npmjs.com/package/fluent-iterable

Працює з усіма iterables (Map, функцією генератора, масивом) та асинхронними iterables.

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

Інші відповіді тут ... Дивно. Здається, вони повторно впроваджують частини протоколу ітерацій. Ви можете просто зробити це:

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

а якщо ви хочете отримати конкретний результат, просто використовуйте оператор поширення ....

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