.map () một Bản đồ Javascript ES6?

Bạn sẽ làm điều này như thế nào? Theo bản năng, tôi muốn làm:

var myMap = new Map([["thing1", 1], ["thing2", 2], ["thing3", 3]]);

// wishful, ignorant thinking
var newMap = myMap.map((key, value) => value + 1); // Map { 'thing1' => 2, 'thing2' => 3, 'thing3' => 4 }

Tôi đã không thu thập được nhiều từ tài liệu về giao thức lặp mới .

Tôi biết về wu.js , nhưng tôi đang chạy một dự án Babel và không muốn bao gồm Traceur , có vẻ như nó hiện đang phụ thuộc vào .

Tôi cũng hơi khó hiểu về cách trích xuất cách fitzgen / wu.js đã thực hiện nó vào dự án của riêng tôi.

Rất thích một lời giải thích rõ ràng, ngắn gọn về những gì tôi đang thiếu ở đây. Cảm ơn!

Tài liệu cho Bản đồ ES6 , FYI

Vì vậy, .mapbản thân nó chỉ cung cấp một giá trị mà bạn quan tâm ... Điều đó nói rằng, có một số cách để giải quyết vấn đề này:

// instantiation
const myMap = new Map([
  [ "A", 1 ],
  [ "B", 2 ]
]);

// what's built into Map for you
myMap.forEach( (val, key) => console.log(key, val) ); // "A 1", "B 2"

// what Array can do for you
Array.from( myMap ).map(([key, value]) => ({ key, value })); // [{key:"A", value: 1}, ... ]

// less awesome iteration
let entries = myMap.entries( );
for (let entry of entries) {
  console.log(entry);
}

Lưu ý, tôi đang sử dụng rất nhiều thứ mới trong ví dụ thứ hai đó ... ... Array.fromlấy bất kỳ thứ gì có thể lặp lại (bất kỳ lúc nào bạn sử dụng [].slice.call( ), cộng với Bộ và Bản đồ) và biến nó thành một mảng ... ... Bản đồ , khi bị ép buộc vào một mảng, hãy biến thành một mảng mảng, trong đó el[0] === key && el[1] === value;(về cơ bản, ở cùng một định dạng mà tôi đã điền sẵn Bản đồ ví dụ của mình ở trên).

Tôi đang sử dụng cấu trúc hủy của mảng ở vị trí đối số của lambda, để gán các điểm mảng đó cho các giá trị, trước khi trả về một đối tượng cho mỗi el.

Nếu bạn đang sử dụng Babel, trong quá trình sản xuất, bạn sẽ cần sử dụng polyfill trình duyệt của Babel (bao gồm "core-js" và "tái tạo" của Facebook).
Tôi khá chắc chắn nó có chứa Array.from.

Bạn chỉ nên sử dụng toán tử Spread :

var myMap = new Map([["thing1", 1], ["thing2", 2], ["thing3", 3]]);

var newArr = [...myMap].map(value => value[1] + 1);
console.log(newArr); //[2, 3, 4]

var newArr2 = [for(value of myMap) value = value[1] + 1];
console.log(newArr2); //[2, 3, 4]

Chỉ cần sử dụng Array.from(iterable, [mapFn]).

var myMap = new Map([["thing1", 1], ["thing2", 2], ["thing3", 3]]);

var newArr = Array.from(myMap.values(), value => value + 1);

Bạn có thể sử dụng chức năng này:

function mapMap(map, fn) {
  return new Map(Array.from(map, ([key, value]) => [key, fn(value, key, map)]));
}

sử dụng:

var map1 = new Map([["A", 2], ["B", 3], ["C", 4]]);

var map2 = mapMap(map1, v => v * v);

console.log(map1, map2);
/*
Map { A → 2, B → 3, C → 4 }
Map { A → 4, B → 9, C → 16 }
*/

Bằng cách sử dụng, Array.fromtôi đã viết một hàm Typecript ánh xạ các giá trị:

function mapKeys<T, V, U>(m: Map<T, V>, fn: (this: void, v: V) => U): Map<T, U> {
  function transformPair([k, v]: [T, V]): [T, U] {
    return [k, fn(v)]
  }
  return new Map(Array.from(m.entries(), transformPair));
}

const m = new Map([[1, 2], [3, 4]]);
console.log(mapKeys(m, i => i + 1));
// Map { 1 => 3, 3 => 5 }

Trên thực tế, bạn vẫn có thể có một Mapvới các khóa ban đầu sau khi chuyển đổi thành mảng với Array.from. Điều đó có thể thực hiện được bằng cách trả về một mảng , trong đó mục đầu tiên là keyvà mục thứ hai là biến đổi value.

const originalMap = new Map([
  ["thing1", 1], ["thing2", 2], ["thing3", 3]
]);

const arrayMap = Array.from(originalMap, ([key, value]) => {
    return [key, value + 1]; // return an array
});

const alteredMap = new Map(arrayMap);

console.log(originalMap); // Map { 'thing1' => 1, 'thing2' => 2, 'thing3' => 3 }
console.log(alteredMap);  // Map { 'thing1' => 2, 'thing2' => 3, 'thing3' => 4 }

Nếu bạn không trả lại khóa đó dưới dạng mục mảng đầu tiên, bạn đã mất Mapchìa khóa của mình .

Tôi thích mở rộng bản đồ hơn

export class UtilMap extends Map {  
  constructor(...args) { super(args); }  
  public map(supplier) {
      const mapped = new UtilMap();
      this.forEach(((value, key) => mapped.set(key, supplier(value, key)) ));
      return mapped;
  };
}

Bạn có thể sử dụng myMap.forEach và trong mỗi vòng lặp, sử dụng map.set để thay đổi giá trị.

myMap = new Map([
  ["a", 1],
  ["b", 2],
  ["c", 3]
]);

for (var [key, value] of myMap.entries()) {
  console.log(key + ' = ' + value);
}


myMap.forEach((value, key, map) => {
  map.set(key, value+1)
})

for (var [key, value] of myMap.entries()) {
  console.log(key + ' = ' + value);
}

Nếu bạn không muốn chuyển đổi toàn bộ Bản đồ thành một mảng trước đó và / hoặc hủy cấu trúc các mảng khóa-giá trị, bạn có thể sử dụng hàm ngớ ngẩn này:

/**
 * Map over an ES6 Map.
 *
 * @param {Map} map
 * @param {Function} cb Callback. Receives two arguments: key, value.
 * @returns {Array}
 */
function mapMap(map, cb) {
  let out = new Array(map.size);
  let i = 0;
  map.forEach((val, key) => {
    out[i++] = cb(key, val);
  });
  return out;
}

let map = new Map([
  ["a", 1],
  ["b", 2],
  ["c", 3]
]);

console.log(
  mapMap(map, (k, v) => `${k}-${v}`).join(', ')
); // a-1, b-2, c-3

Map.prototype.map = function(callback) {
  const output = new Map()
  this.forEach((element, key)=>{
    output.set(key, callback(element, key))
  })
  return output
}

const myMap = new Map([["thing1", 1], ["thing2", 2], ["thing3", 3]])
// no longer wishful thinking
const newMap = myMap.map((value, key) => value + 1)
console.info(myMap, newMap)

Phụ thuộc vào lòng nhiệt thành tôn giáo của bạn trong việc tránh chỉnh sửa nguyên mẫu, nhưng, tôi thấy điều này cho phép tôi giữ nó trực quan.

Bạn có thể ánh xạ () mảng, nhưng không có thao tác như vậy đối với Maps. Giải pháp từ Tiến sĩ Axel Rauschmayer :

• Chuyển đổi bản đồ thành một mảng các cặp [khóa, giá trị].
• Ánh xạ hoặc lọc mảng.
• Chuyển đổi kết quả trở lại bản đồ.

Thí dụ:

let map0 = new Map([
  [1, "a"],
  [2, "b"],
  [3, "c"]
]);

const map1 = new Map(
  [...map0]
  .map(([k, v]) => [k * 2, '_' + v])
);

dẫn đến

{2 => '_a', 4 => '_b', 6 => '_c'}

Có thể theo cách này:

const m = new Map([["a", 1], ["b", 2], ["c", 3]]);
m.map((k, v) => [k, v * 2]); // Map { 'a' => 2, 'b' => 4, 'c' => 6 }

Bạn chỉ cần vá khỉ Maptrước:

Map.prototype.map = function(func){
    return new Map(Array.from(this, ([k, v]) => func(k, v)));
}

Chúng tôi có thể đã viết một dạng đơn giản hơn của bản vá này:

Map.prototype.map = function(func){
    return new Map(Array.from(this, func));
}

Nhưng chúng tôi buộc chúng tôi phải viết m.map(([k, v]) => [k, v * 2]); đó có vẻ đau đớn và xấu xí hơn đối với tôi.

Chỉ ánh xạ giá trị

Chúng tôi cũng có thể chỉ lập bản đồ các giá trị, nhưng tôi không khuyên bạn nên chọn giải pháp đó vì nó quá cụ thể. Tuy nhiên, nó có thể được thực hiện và chúng tôi sẽ có API sau:

const m = new Map([["a", 1], ["b", 2], ["c", 3]]);
m.map(v => v * 2); // Map { 'a' => 2, 'b' => 4, 'c' => 6 }

Giống như trước khi vá theo cách này:

Map.prototype.map = function(func){
    return new Map(Array.from(this, ([k, v]) => [k, func(v)]));
}

Có lẽ bạn có thể có cả hai, đặt tên thứ hai mapValuesđể làm rõ rằng bạn không thực sự ánh xạ đối tượng như nó có thể mong đợi.