.map() eine Javascript ES6 Karte?

Question

Wie würden Sie das tun? Instinktiv will ich tun:

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 } 

Ich habe noch nicht viel von der documentation on the new iteration protocol entnommen.

Ich kenne wu.js, aber ich bin ein Babel Projekt laufen und wollen nicht Traceur enthalten, die it seems like it currently depends on.

Ich bin auch ein bisschen ratlos, wie man how fitzgen/wu.js did it in mein eigenes Projekt extrahiert.

Ich würde gerne eine klare, prägnante Erklärung dafür bekommen, was mir hier fehlt. Vielen Dank!

---

Docs for ES6 Map, FYI

Answer 1

So .map selbst bietet nur einen Wert Sie interessieren ... Das heißt, es gibt ein paar Möglichkeiten, dies anzugehen:

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

Hinweis, ich Ich benutze viele neue Sachen in diesem zweiten Beispiel ... ... Array.from nimmt alle iterierbaren (jederzeit [].slice.call(), plus Sets und Maps) und verwandelt es in ein Array ... ... Maps werden, wenn sie in ein Array gezwungen werden, zu einem Array von Arrays, wobei el[0] === key && el[1] === value; (im Grunde genommen im selben Format, in dem ich meine Beispielkarte mit, oben, vorgefüllt hatte).

Ich verwende Destrukturierung des Arrays in der Argumentposition des Lambda, um diese Array-Spots zu Werten zuzuordnen, bevor ein Objekt für jedes el zurückgegeben wird.

Wenn Sie Babel verwenden, müssen Sie in der Produktion den Babel-Polyfill verwenden (der "core-js" und den "Regenerator" von Facebook enthält).
Ich bin mir ziemlich sicher, dass es Array.from enthält.

Answer 2

sollten Sie verwenden nur Spread operador:

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]

Answer 3

Nur Array.from(iterable, [mapFn]) verwenden.

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

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

Answer 4

const mapMap = (callback, map) => new Map(Array.from(map).map(callback)) 
 

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

 
var newMap = mapMap((pair) => [pair[0], pair[1] + 1], myMap); // Map { 'thing1' => 2, 'thing2' => 3, 'thing3' => 4 }

Answer 5

Array.from Mit schrieb ich eine Typoskript Funktion, die die Werte abbildet:

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 } 

Answer 6

Wenn Sie nicht möchten, dass die gesamte Karte in ein Array konvertieren vorher und/oder Struktur-Schlüssel-Wert-Arrays, können Sie diese alberne Funktion verwenden:

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