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. null wird als undefined behandelt.

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 Werten zuordnen, 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 Object 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 muss.
  • Eine Map ist iterierbar, wohingegen das iterieren über ein Object es 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 selbst angelegter Schlüssel kollidieren können, wenn man nicht aufpasst. Seit  ES5 lässt sich dies durch die Anweisung map = Object.create(null) umgehen, es wird aber selten verwendet.
  • 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 shclü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 jede 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

Spezifikation Status Kommentar
ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Map' in dieser Spezifikation.
Standard Initiale Definition.
ECMAScript Latest Draft (ECMA-262)
Die Definition von 'Map' in dieser Spezifikation.
Entwurf  

Browserkompatibilität

FeatureChromeEdgeFirefoxInternet ExplorerOperaSafari
Grundlegende Unterstützung38121311258
new Map(iterable)381213 Nein259
new Map(null) Ja123711 Ja9
Map() without new throws Ja124211 Ja9
Key equality for -0 and 0381229 Nein259
clear38121911258
delete38121311258
entries381220 Nein258
forEach38122511258
get38121311258
has38121311258
keys381220 Nein258
prototype38121311258
set381213111258
size381219211258
values381220 Nein258
@@iterator Ja Ja

36

27 — 363 4

17 — 275 6

Nein Ja Ja
@@species511341 Nein3810
@@toStringTag44 Nein Nein Nein Nein Nein
FeatureAndroid webviewChrome for AndroidEdge mobileFirefox for AndroidOpera AndroidiOS SafariSamsung Internet
Grundlegende Unterstützung38381214258 Ja
new Map(iterable)38381214259 Ja
new Map(null) Ja Ja1237 Ja9 Ja
Map() without new throws Ja Ja1242 Ja9 Ja
Key equality for -0 and 038381229259 Ja
clear38381219258 Ja
delete38381214258 Ja
entries38381220258 Ja
forEach38381225258 Ja
get38381214258 Ja
has38381214258 Ja
keys38381220258 Ja
prototype38381214258 Ja
set38381214258 Ja
size383812192258 Ja
values38381220258 Ja
@@iterator Ja Ja Ja

36

27 — 363 4

17 — 275 6

Ja Ja Ja
@@species5151134138105.0
@@toStringTag4444 Nein Nein Nein Nein4.0

1. Returns 'undefined' instead of the 'Map' object.

2. From Firefox 13 to Firefox 18, the size property was implemented as a Map.prototype.size() method, this has been changed to a property in later versions conform to the ECMAScript 2015 specification.

3. A placeholder property named @@iterator is used.

4. Supported as @@iterator.

5. A placeholder property named iterator is used.

6. Supported as iterator.

Siehe auch

Schlagwörter des Dokuments und Mitwirkende

Schlagwörter: 
Mitwirkende an dieser Seite: kdex, Flonk, schlagi123, the-bluesnik, GinoHereIam, Chris-CR, Fearodin
Zuletzt aktualisiert von: kdex,