Map

Das Map Objekt ist eine einfache Schlüssel/Wert Zuordnung. Jeder Wert (Sowohl Objekte, als auch  primitive Datentypen) kann als Schlüssel/Wert verwendet werden.

Syntax

new Map([iterable])

Parameter

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.

Beschreibung

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.

Schlüsselvergleich

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 im Vergleich

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.

Eigenschaften

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.

Map Instanzen

Alle Map Instanzen erben von Map.prototype.

Eigenschaften

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.

Methoden

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.

Beispiele

Einsatz vom Map Objekt

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 () {}

Benutzung von NaN als Map Schlüssel

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"

Iterieren über Maps mit for..of

Ü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

Integration von Maps mit forEach()

Ü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"

Relation mit Array Objekten

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"]

Spezifikationen

Browserkompatibilität

BCD tables only load in the browser

Siehe auch