Map

new Map([iterable])

iterable

Der Parameter iterable ist ein Array oder anderes iterierbares Objekt, dessen Elemente Schlüssel-Wert Paare (2-Element Arrays) sind. Jedes Schlüssel-Wert Paar wird der neuen Map hinzugefügt.

Ein Map Object iteriert in der Reihenfolge des Einfügens über seine Elemente — eine for...of Schleife gibt ein Array mit [key, value] für jede Iteration zurück.

Es ist festzuhalten, dass eine Map, bestehend aus objects, insbesondere ein "dictionary of dictionaries", nur nach der Einfügereihenfolge angelegt wird, die zufällig und ungeordnet ist.

Der Schlüsselvergleich basiert auf dem "gleicher-Wert" Algorithmus: NaN wird als gleich mit einer anderen NaN angesehen (trotz dem, dass NaN !== NaN) und alle anderen Werte müssen typ- und wert identisch, wie beim === Operator, sein. In der aktuellen ECMAScript Spezifikation werden -0 und +0 als gleich behandelt, auch wenn dies in früheren Entwürfen anders war. Details dazu sind der Tabelle browser compatibility zu entnehmen. 

Objects und Maps haben einige gemeinsame Eigenschaften. In beiden lassen sich Schlüssel auf Werte setzen, diese Werte wiederfinden, Schlüssel löschen und herausfinden, ob etwas unter einem bestimmten Schlüssel gespeichert ist. Aus diesem Grund (und weil es keine spracheigenen Alternativen gab) wurden früher Objects als Maps benutzt. Doch es gibt bedeutende Unterschiede zwischen diesen beiden Strukturen, die es in verschiedenen Fällen zu beachten gilt:

• Die Schlüssel eines Objects sind Strings und Symbols, während sie bei einer Map jeglichen Wert haben können. Inklusive functions, objects, und alle primitive.
• Die Grösse einer Map lässt sich einfach über die size Eigenschaft ermitteln, während die Zahl der Eigenschaften in einem Object erst manuell herausgefunden werden müssen.
• Eine Map ist iterierbar, wohingegen das Iterieren über ein Object erfordert, dass man dessen Schlüssel temporär extrahiert und dann über diese iteriert.
• Ein Object hat einen Prototypen mit default-Schlüsseln in seiner Map, die mit den Namen von selbst angelegten Schlüsseln kollidieren können, wenn man nicht aufpasst. Seit ES5 lässt sich dies durch die Anweisung map = Object.create(null) umgehen, was aber selten verwendet wird.
• Eine Map bietet in Szenarien mit hochfrequentem Einfügen und Löschen von Schlüssel-Wert Paaren ein besseres Laufzeitverhalten als Objects.

Map.length

Der Wert von length beträgt 0.

get Map[@@species]

Die Konstruktor-Funktion, zum Erzeugen abgeleiteter Objekte.

Map.prototype

Repräsentiert den Prototyp für den Map Konstruktor. Erlaubt das Hinzufügen von Eigenschaften zu allen Map Objekten.

Alle Map Instanzen erben von Map.prototype.

Map.prototype.constructor

Gibt die Funktion zurück, die einen Instanzenprototype erstellt. Der Standardwert ist die Map Funktion.

Map.prototype.size

Gibt die Anzahl an Schlüssel/Werte-Paaren in dem Map Objekt zurück.

Map.prototype.clear()

Entfernt alle Schlüssel/Werte-Paare von dem Map Objekt.

Map.prototype.delete(schlüssel)

Gibt true zurück, wenn ein Element im Map Objekt existiert und gelöscht wird, oder false wenn das Element nicht existiert. Map.prototype.has(schlüssel) wird danach false zurückgeben.

Map.prototype.entries()

Gibt ein neues Iterator Objekt mit allen [Schlüssel, Wert] Paaren als Array von jedem Element in dem Map Objekt in Einfügereihenfolge zurück.

Map.prototype.forEach(callbackFn[, thisArg])

Ruft callbackFn einmal für jedes Schlüssel/Wert Paar in dem Map Objekt in der Einfügereihenfolge aus. Wenn ein thisArg Parameter angegeben ist, wird dieser als this für jeden Funktionsaufruf benutzt.

Map.prototype.get(schlüssel)

Gibt den Wert zu dem zugehörigen schlüssel zurück oder undefined wenn dieser nicht existiert.

Map.prototype.has(schlüssel)

Gibt einen boolean zurück, der angibt, ob ein Wert mit den schlüssel in einem Map Objekt vorhanden ist oder nicht.

Map.prototype.keys()

Gibt ein neues Iterator Objekt mit allen Schlüsseln von jedem Element in dem Map Objekt in Einfügereihenfolge zurück.

Map.prototype.set(schlüssel, wert)

Setzt den wert für einen schlüssel im Map Objekt. Gibt das Map Objekt zurück.

Map.prototype.values()

Gibt ein neues Iterator Objekt mit allen Werten von jedem Element in dem Map Objekt in Einfügereihenfolge zurück.

Map.prototype[@@iterator]()

Gibt ein neues Iterator Objekt mit allen [Schlüssel, Wert] Paaren als Array von jedem Element in dem Map Objekt in Einfügereihenfolge zurück.

var myMap = new Map();

var keyString = "ein string",
    keyObj = {},
    keyFunc = function () {};

// setting the values
myMap.set(keyString, "value associated with 'ein string'");
myMap.set(keyObj, "value associated with keyObj");
myMap.set(keyFunc, "value associated with keyFunc");

myMap.size; // 3

// getting the values
myMap.get(keyString);    // "value associated with 'ein string'"
myMap.get(keyObj);       // "value associated with keyObj"
myMap.get(keyFunc);      // "value associated with keyFunc"

myMap.get("ein string");   // "value associated with 'ein string'"
                         // because keyString === 'ein string'
myMap.get({});           // undefined, because keyObj !== {}
myMap.get(function() {}) // undefined, because keyFunc !== function () {}

NaN kann auch als Schlüssel benutzt werden. Auch wenn jede NaN nicht gleich zu sich selbst ist (NaN !== NaN is true) funktioniert das folgende Beispiel, da NaNs ununterscheidbar von jeder anderen ist:

var myMap = new Map();
myMap.set(NaN, "not a number");

myMap.get(NaN); // "not a number"

var otherNaN = Number("foo");
myMap.get(otherNaN); // "not a number"

Über Maps kann mit der for..of Schleife iteriert werden:

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

for (var key of myMap.keys()) {
  console.log(key);
}
// 0
// 1

for (var value of myMap.values()) {
  console.log(value);
}
// zero
// one

for (var [key, value] of myMap.entries()) {
  console.log(key + " = " + value);
}
// 0 = zero
// 1 = one

Über Maps kann mit der forEach() method iteriert werden:

myMap.forEach(function(value, key) {
  console.log(key + " = " + value);
}, myMap)
// Will show 2 logs; first with "0 = zero" and second with "1 = one"

var kvArray = [['key1', 'value1'], ['key2', 'value2']];

// Use the regular Map constructor to transform a 2D key-value Array into a map
var myMap = new Map(kvArray);

myMap.get('key1'); // returns "value1"

// Use the Array.from function to transform a map into a 2D key-value Array
console.log(Array.from(myMap)); // Will show you exactly the same Array as kvArray

// Or use the keys or values iterators and convert them to an array
console.log(Array.from(myMap.keys())); // Will show ["key1", "key2"]

• Map and Set bug at Mozilla
• ECMAScript Harmony proposal
• Set
• WeakMap
• WeakSet