Map

Resum

L'objecte Map és un simple mapa de parelles clau/valor. Qualsevol valor (tant objectes com primitive values) poden fer-se servir tant com a clau com a valor.

Sintaxi

new Map([iterable])

Paràmetres

iterable

Iterable és un Array o un altre objecte iterable els quals els seus elements són parelles clau/valor (Arrays de 2 elements). Cada parella clau/valor serà afegida al nou mapa. nul és tracta com a indefinit.

Descripció

Un objecte Map pot iterar els seus elements en ordre d'inserció - un bucle for..of retornarà un array de [key, value] per cada iteració.

Igualtat de claus

La igualtat de claus es basa en l'algorisme "mateix valor": NaN es considera igual a NaN (tot i que NaN !== NaN) i tots els altres valors es consideren iguals d'acord amb la semàntica de l'operador ===. En versions anteriors a l'esborrany de l'ECMAScript 6 -0 i +0 es consideraven diferents (tot i que -0 === +0), aquest comportament s'ha canviat en versions posteriors i ha sigut adaptat al (Firefox 29 / Thunderbird 29 / SeaMonkey 2.26) (errada 952870) i una versió diària de Chrome.

Comparació d'objectes amb mapes

Els Objects son similars als Maps en el sentit que tots dos permeten assignar valors a claus, obtenir aquests valors, esborrar claus i detectar si una clau té un valor assignat o no. Degut a això, històricament s'han fet anar Objects com a Maps; tot i això existeixen diferències importants entre Objects i Maps que fan que l'ús de Map sigui millor.

• Un Object té un prototipus, això implica que hi haurà algunes claus definides inicialment. Aquest problem es pot adreçar utilitzant map = Object.create(null).
• Les claus d'un Object són Strings, mentre que les claus d'un Map poden ser de qualsevol tipus.
• És fàcil obtindre el tamany d'un Map mentre que el tamany d'un Object ha de ser calculat manualment.

Utilitzeu mapes en comptes d'objejctes quan les claus no se sàpiguin en temps d'execució, o bé quan totes les claus o els valors siguin del mateix tipus.

Utilitzeu objectes quan hi hagi una lògica que operi els elements individualment.

Propietats

Map.length

El valor de la propietat length és 1.

Map.prototype

Representa el prototipus pel constructor Map. Permet afegir propietats a tots els objectes de tipus Map.

Instàncies de Map

Totes les instàncies de Map hereten de Map.prototype.

Propietats

Map.prototype.constructor

Retorna la funció que ha creat el una instància del prototipus. Per defecte és la funció Map.

Map.prototype.size

Retorna el nombre de parells clau-valor que conté l'objecte Map.

Mètodes

Map.prototype.clear()

Elimina tots els parells clau-valor de l'objecte Map.

Map.prototype.delete(clau)

Elimina el valor associat a la clau especificada i retorna el valor que el mètode Map.prototype.has(valor) hagués retornat abans d'eliminar-lo. Map.prototype.has(clau) retornarà false després de cridar aquest mètode.

Map.prototype.entries()

Retorna un nou objecte Iterator que conté un array de [clau, valor] per a cada element dins l'objecte Map, en estricte ordre d'inserció.

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

Crida callbackFn per a cada parell clau-valor present a l'objecte Map, recorreguts per ordre d'inserció. Si es proporciona el paràmetre thisArg, aquest s'utilitzarà com a valor de this per a cada crida a callbackFn.

Map.prototype.get(clau)

Retorna el valor associat a la clau, o bé undefined si aquesta clau no té cap valor associat.

Map.prototype.has(clau)

Retorna un booleà que especifica si la clau té un valor associat en aquest objecte Map o no.

Map.prototype.keys()

Retorna un nou objecte Iterator que conté les claus de cada element de l'objecte Map, en ordre d'inserció.

Map.prototype.set(clau, valor)

Assigna valor a la clau a l'objecte Map. Retorna l'objecte Map.

Map.prototype.values()

Retorna un nou objecte Iterator que conté els valors de cada element de l'objecte Map, en ordre d'inserció.

Map.prototype[@@iterator]()

Retorna un nou objecte Iterator que conté un array de [clau, valor] per a cada element de l'objecte Map, en ordre d'inserció.

Exemples

Exemple: Utilitzar l'objecte Map

var myMap = new Map();

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

// preparar els valors
myMap.set(keyString, "valor associat a amb 'un string'");
myMap.set(keyObj, "valor associat amb keyObj");
myMap.set(keyFunc, "valor associat amb with keyFunc");

myMap.size; // 3

// obtenir els valors
myMap.get(keyString);    // "valor associat amb 'un string'"
myMap.get(keyObj);       // "valor associat amb keyObj"
myMap.get(keyFunc);      // "valor associat amb keyFunc"

myMap.get("a string");   // "valor associat amb 'un string'"
                         // com que keyString === 'un string'
myMap.get({});           // undefined, perquè keyObj !== {}
myMap.get(function() {}) // undefined, perquè keyFunc !== function () {}

Exemple: Utilitzar NaN com a claus en un Map

NaN també pot emprar-se com a clau. Tot i que NaN no és igual a si mateix (NaN !== NaN és cert), l'exemple següent funciona perquè els NaNs són indistinguibles entre ells:

var myMap = new Map();
myMap.set(NaN, "no un nombre");

myMap.get(NaN); // "no un nombre"

var altreNaN = Number("foo");
myMap.get(altreNaN); // "no un nombre"

Exemple: Iterar Maps amb for..of

Els mapes es poden iterar fent servir un bucle for..of :

var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "un");
for (var [key, value] of myMap) {
  alert(key + " = " + value);
}
// Mostrarà 2 alertes; el primer amb "0 = zero" i el segon amb "1 = one"

for (var key of myMap.keys()) {
  alert(key);
}
// Mostrarà 2 alertes; el primer amb "0" i el segon amb "1"

for (var value of myMap.values()) {
  alert(value);
}
// Mostrarà 2 alertes; el primer amb "zero" i el segon amb "un"

for (var [key, value] of myMap.entries()) {
  alert(key + " = " + value);
}
// Mostrarà 2 alertes; el primer amb "0 = zero" i el segon amb "1 = un"

myMap.forEach(function(value, key) {
  alert(key + " = " + value);
}, myMap)
// Mostrarà 2 alertes; el primer amb "0 = zero" i el segon amb "1 = un"

Exemple: Relació amb els objectes Array

var kvArray = [["clau1", "valor1"], ["clau2", "valor2"]];

// Utilitzeu el constructor de Map normal per a transformar un Array 2D clau-valor en un mapa
var myMap = new Map(kvArray);

myMap.get("valor1"); // retorna "valor1"

// Utilitzeu l'operador spread per a transformar un mapa en un Array 2D clau-valor.
alert(uneval([...myMap])); // Mostrarà exactament el mateix Array que kvArray

// O bé utilitzeu l'operador spread a l'iterador de les claus o els valor per a obtenir
// un array de només les claus o els valors
alert(uneval([...myMap.keys()])); // Mostrarà ["clau1", "clau2"]

Especificacions

Compatibilitat amb navegadors

[1] The feature is available behind a preference. In chrome://flags, activate the entry “Enable Experimental JavaScript”.

Vegeu també

• Bug a Map i Set a Mozilla
• Proposta de ECMAScript Harmony
• Set
• WeakMap
• WeakSet