Sử dụng map () trên một trình lặp

Giả sử chúng ta có Bản đồ: let m = new Map(); , sử dụng m.values()trả về trình lặp bản đồ.

Nhưng tôi không thể sử dụng forEach()hoặcmap() trên trình lặp đó và việc triển khai một vòng lặp while trên trình lặp đó có vẻ giống như một mẫu chống vì ES6 cung cấp các chức năng như map().

Vậy có cách nào để sử dụng map()trên trình lặp không?

Cách đơn giản nhất và ít hiệu quả nhất để làm điều này là:

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

Tốt hơn

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

Array.fromlấy bất kỳ thứ nào có thể lặp lại hoặc giống mảng và chuyển đổi nó thành một mảng! Như Daniel đã chỉ ra trong các nhận xét, chúng ta có thể thêm một hàm ánh xạ vào chuyển đổi để loại bỏ một lần lặp và sau đó là một mảng trung gian.

Sử dụng Array.fromsẽ di chuyển hiệu suất của bạn từ O(1)đến O(n)như điểm @hraban ra trong các ý kiến. Kể từ khi mlà mộtMap , và chúng không thể là vô hạn nên chúng ta không phải lo lắng về một chuỗi vô hạn. Đối với hầu hết các trường hợp, điều này là đủ.

Có một số cách khác để xem qua bản đồ.

Sử dụng forEach

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

Sử dụng 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

Bạn có thể xác định một hàm lặp khác để lặp lại điều này:

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

Bây giờ bạn có thể hỏi: tại sao không chỉ sử dụng Array.fromthay thế? Vì điều này sẽ chạy qua toàn bộ trình lặp, hãy lưu nó vào một mảng (tạm thời), lặp lại nó và sau đó thực hiện ánh xạ. Nếu danh sách rất lớn (hoặc thậm chí có khả năng vô hạn), điều này sẽ dẫn đến việc sử dụng bộ nhớ không cần thiết.

Tất nhiên, nếu danh sách các mặt hàng khá nhỏ, thì việc sử dụng Array.fromphải là quá đủ.

Cách đơn giản và hiệu quả nhất này là sử dụng đối số thứ hai Array.fromđể đạt được điều này:

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

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

Cách tiếp cận này hoạt động cho bất kỳ khả năng lặp lại không vô hạn . Và nó tránh phải sử dụng một cuộc gọi riêng biệt Array.from(map).map(...)sẽ lặp lại hai lần và sẽ kém hơn đối với hiệu suất.

Bạn có thể truy xuất một trình vòng lặp qua trình có thể lặp, sau đó trả về một trình vòng lặp khác gọi hàm gọi lại ánh xạ trên mỗi phần tử được lặp lại.

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

Bạn có thể sử dụng itiriri để triển khai các phương thức giống mảng cho các tệp lặp:

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

Hãy xem tại https://www.npmjs.com/package/fluent-iterable

Làm việc với tất cả các tệp lặp (Bản đồ, hàm trình tạo, mảng) và các tệp lặp không đồng bộ.

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

Các câu trả lời khác ở đây là ... Kỳ lạ. Họ dường như đang thực hiện lại các phần của giao thức lặp lại. Bạn chỉ có thể làm điều này:

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

và nếu bạn muốn có một kết quả cụ thể, chỉ cần sử dụng toán tử spread ... .

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