.map () una mappa Javascript ES6?

come lo faresti? Istintivamente, voglio fare:

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 }

Non ho raccolto molto dalla documentazione sul nuovo protocollo di iterazione .

Sono a conoscenza di wu.js , ma sto conducendo un progetto Babel e non voglio includere Traceur , da cui sembra che attualmente dipenda .

Sono anche un po ' incapace di come estrarre come fitzgen / wu.js lo ha fatto nel mio progetto.

Mi piacerebbe una spiegazione chiara e concisa di ciò che mi manca qui. Grazie!

Documenti per la mappa ES6 , FYI

Quindi di per .mapsé offre solo un valore a cui tieni ... Detto questo, ci sono alcuni modi per affrontare questo:

// 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);
}

Nota, sto usando molte cose nuove in quel secondo esempio ... ... Array.fromprende qualsiasi iterabile (ogni volta che useresti [].slice.call( ), più Set e Mappe) e lo trasforma in un array ... ... Mappe , quando viene forzato in un array, si trasforma in un array di array, dove el[0] === key && el[1] === value;(fondamentalmente, nello stesso formato con cui ho precompilato la mia mappa di esempio, sopra).

Sto usando la destrutturazione dell'array nella posizione dell'argomento del lambda, per assegnare quei punti dell'array ai valori, prima di restituire un oggetto per ogni el.

Se stai usando Babel, in produzione, dovrai usare il polyfill del browser di Babel (che include "core-js" e il "rigeneratore" di Facebook).
Sono abbastanza certo che contenga Array.from.

Dovresti semplicemente usare l' operatore 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]

Basta usare Array.from(iterable, [mapFn]).

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

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

Puoi usare questa funzione:

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

utilizzo:

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 }
*/

Utilizzando Array.fromho scritto una funzione Typescript che mappa i valori:

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 }

In realtà puoi ancora avere un Mapcon le chiavi originali dopo la conversione in array con Array.from. Ciò è possibile restituendo un array , in cui il primo elemento è il keye il secondo è il trasformato 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 }

Se non restituisci quella chiave come primo elemento dell'array, perdi le Mapchiavi.

Preferisco estendere la mappa

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;
  };
}

È possibile utilizzare myMap.forEach e in ogni ciclo utilizzando map.set per modificare il valore.

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

Se non desideri convertire in anticipo l'intera mappa in un array e / o destrutturare gli array di valori-chiave, puoi utilizzare questa sciocca funzione:

/**
 * 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)

Dipende dal tuo fervore religioso nell'evitare di modificare i prototipi, ma trovo che questo mi consenta di mantenerlo intuitivo.

Puoi map () array, ma non esiste tale operazione per Maps. La soluzione del dottor Axel Rauschmayer :

• Converti la mappa in un array di coppie [chiave, valore].
• Mappa o filtra la matrice.
• Converti il ​​risultato in una mappa.

Esempio:

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

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

provocato

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

Forse in questo modo:

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

Avresti solo bisogno di scimmia patch Mapprima:

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

Avremmo potuto scrivere una forma più semplice di questa patch:

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

Ma ci saremmo costretti a scrivere poi m.map(([k, v]) => [k, v * 2]);che mi sembra un po 'più doloroso e brutto.

Solo valori di mappatura

Potremmo anche mappare solo i valori, ma non consiglierei di optare per quella soluzione poiché è troppo specifica. Tuttavia può essere fatto e avremmo la seguente API:

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

Proprio come prima di applicare la patch in questo modo:

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

Forse puoi avere entrambi, nominando il secondo mapValuesper chiarire che non stai effettivamente mappando l'oggetto come probabilmente ci si aspetterebbe.