Bir yineleyicide map () kullanma

Bir Haritamız olduğunu varsayalım :, let m = new Map();kullanmak m.values()bir harita yineleyicisi döndürür.

Ancak bu yineleyiciyi kullanamıyorum forEach()ve map()bu yineleyicide bir while döngüsü uygulamak, ES6 gibi işlevler sunduğu için bir anti-model gibi görünüyor map().

Öyleyse map()bir yineleyicide kullanmanın bir yolu var mı?

Bunu yapmanın en basit ve en az performanslı yolu şudur:

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

Daha iyisi

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

Array.fromyinelenebilir veya dizi benzeri herhangi bir şeyi alır ve bir diziye dönüştürür! Daniel'in yorumlarda belirttiği gibi, bir yinelemeyi ve ardından bir ara diziyi kaldırmak için dönüşüme bir eşleme işlevi ekleyebiliriz.

@ Hraban'ın yorumlarda belirttiği gibi kullanmak Array.fromperformansınızı 'dan' O(1)a O(n)taşır. Yana mbir olduğunu Mapve onlar sonsuz olamaz, biz sonsuz dizisi hakkında endişe gerekmez. Çoğu durumda bu yeterli olacaktır.

Bir haritada döngü oluşturmanın birkaç başka yolu vardır.

Kullanma forEach

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

Kullanma 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

Bunun üzerinden geçmek için başka bir yineleyici işlevi tanımlayabilirsiniz:

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

Şimdi sorabilirsiniz: neden Array.frombunun yerine kullanmıyorsunuz ? Bu, tüm yineleyici boyunca çalışacağından, onu (geçici) bir diziye kaydedin, tekrar yineleyin ve ardından eşlemeyi yapın. Liste çok büyükse (veya hatta potansiyel olarak sonsuzsa), bu gereksiz bellek kullanımına yol açacaktır.

Tabii ki, öğeler listesi oldukça küçükse, kullanmak Array.fromfazlasıyla yeterli olmalıdır.

Bu en basit ve en performanslı yol, Array.frombunu başarmak için ikinci argümanı kullanmaktır :

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

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

Bu yaklaşım, sonsuz olmayan her yinelenebilir için işe yarar. Ayrıca Array.from(map).map(...), yinelenebilirde iki kez yinelenen ve performans için daha kötü olan ayrı bir çağrı kullanmak zorunda kalmaz.

Yinelenebilir üzerinde bir yineleyici alabilir, ardından yinelenen her öğede eşleme geri arama işlevini çağıran başka bir yineleyici döndürebilirsiniz.

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

Sen kullanabilirsiniz itiriri bunu uygulayan dizi benzeri Iterables yöntemleri:

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 adresine bir göz atın

Tüm yinelenebilir öğelerle (Harita, oluşturucu işlevi, dizi) ve zaman uyumsuz yinelemelerle çalışır.

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

Birden çok yardımcı işlevi şuraya getiren bir öneri var Iterator: https://github.com/tc39/proposal-iterator-helpers ( render )

Bugün aşağıdakilerden yararlanarak kullanabilirsiniz 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);

Buradaki diğer cevaplar ... Garip. Yineleme protokolünün parçalarını yeniden uyguluyor gibi görünüyorlar. Sadece bunu yapabilirsiniz:

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

ve somut bir sonuç istiyorsanız, sadece yayma operatörünü kullanın ....

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