การใช้ map () บนตัววนซ้ำ

สมมติว่าเรามีแผนที่: let m = new Map();โดยใช้m.values()คืนค่าตัววนซ้ำแผนที่

แต่ฉันไม่สามารถใช้forEach()หรือmap()บน iterator ที่และการดำเนินการในขณะที่ห่วงว่า iterator ดูเหมือนว่าต่อต้านรูปแบบฟังก์ชั่นตั้งแต่ ES6 map()เสนอเช่น

มีวิธีใช้map()กับ iterator หรือไม่?

วิธีที่ง่ายที่สุดและมีประสิทธิภาพน้อยที่สุดคือ:

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

ยังดีกว่า

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

Array.fromนำสิ่งที่ทำซ้ำได้หรือคล้ายอาร์เรย์และแปลงเป็นอาร์เรย์! ดังที่ Daniel ชี้ให้เห็นในความคิดเห็นเราสามารถเพิ่มฟังก์ชันการทำแผนที่ลงในการแปลงเพื่อลบการวนซ้ำและต่อมาเป็นอาร์เรย์กลาง

การใช้Array.fromจะย้ายประสิทธิภาพของคุณจากO(1)ไปO(n)เป็นที่ @hraban ชี้ให้เห็นในความคิดเห็น เนื่องจากmเป็น a 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) {
    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(','));

ตอนนี้คุณอาจถาม: ทำไมไม่ใช้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 ทั้งหมด (แผนที่ฟังก์ชันเครื่องกำเนิดไฟฟ้าอาร์เรย์) และการวนซ้ำแบบไม่ตรงกัน

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

มีข้อเสนอที่นำฟังก์ชั่นตัวช่วยหลายตัวไปที่Iterator: https://github.com/tc39/proposal-iterator-helpers ( แสดงผล )

คุณสามารถใช้งานได้แล้ววันนี้โดยใช้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);

คำตอบอื่น ๆ ที่นี่คือ ... ดูเหมือนว่าพวกเขาจะนำส่วนต่างๆของโปรโตคอลการทำซ้ำมาใช้ใหม่ คุณสามารถทำได้:

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

และหากคุณต้องการผลลัพธ์ที่เป็นรูปธรรมให้ใช้ตัวดำเนินการสเปร...ด

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