Map

El objeto Map almacena pares clave/valor. Cualquier valor (tanto objetos como valores primitivos) pueden ser usados como clave o valor.

new Map([iterable])

iterable

Iterable es un array o cualquier otro objeto iterable cuyos elementos son pares clave-valor (arrays de 2 elementos). Cada par clave-valor será agregado al nuevo Map.

Un objeto Map puede iterar sobre sus elementos en orden de inserción. Un bucle for..of devolverá un array de [clave, valor] en cada iteración.

Cabe destacar que un Map el cual es un mapa de un objeto, especialmente un diccionario de diccionarios, solo se va a mapear en el orden de inserción del objeto — el cual es aleatorio y no ordenado.

La igualdad de claves esta basada en el algoritmo "SameValueZero": NaN es considerado lo mismo que NaN (sin importar que NaN !== NaN) y todos los otros operadores son considerados iguales de acuerdo a la semantica del operador ===. En las primeras versiones de ECMAScript 6 -0 y +0 eran considarados distintos (even though -0 === +0), esto fue cambiado en posteriores versiones y ha sido implementado en Gecko 29 (Firefox 29 / Thunderbird 29 / SeaMonkey 2.26) (error 952870) and a recent nightly Chrome.

Los Objetos son similares a los Maps en cuanto a que ambos permiten establecer claves a valores, recuperar dichos valores, eliminar claves, y detectar si existe algo almacenado en una clave determinada. Por esto, los Objects han sido usados históricamente como Maps; no obstante, hay diferencias importantes entre  Objects y Maps que hacen mejor usar un  Map  en la mayoría de casos.

• Las claves de un Object son Strings y Symbols, mientras que para un Map pueden ser de cualquier tipo, incluyendo funciones, objetos y cualquier otro tipo primitivo.
• Puedes saber facilmente el tamaño de un Map usando la propiedad size, mientras que le número de propiedades en un Object tiene que ser deternminado manualmente.
• Un Map es un iterable lo que permite iterar directamente sobre el, mientras que si queremos iterar sobre un Object necesitamos obtener primero las claves de alguna forma para después iterar sobre el.
• Un Object tiene prototipo, por lo que hay claves por defecto en tu mapa que pueden colisionar con tus claves si no eres cuidadoso. En el estandard ES5 esto se puede evitar usando mapa = Object.create(null), pero esto raramente se hace.

Map.length

El valor de la propiedad de longitud es 0

get Map[@@species]

La función constructor que se usa para crear objetos derivados.

Map.prototype

Representa el prototipo para el constructor de Map. Permite añadir propiedades a todos los objetos Map.

Todas las instancias de Map heredan de Map.prototype.

Map.prototype.constructor

Devuelve la función que creó el prototipo de una instancia. Esta es la función de Map por defecto.

Map.prototype.size

Devuelve el número de conjuntos de llave/valor en el objeto Map.

Map.prototype.clear()

Elimina todos los conjuntos de llave/valor del objeto Map.

Map.prototype.delete(key)

Elimina cualquier valor asociado a la llave y devuelve el valor que  Map.prototype.has(key) tenía previamente. Después  Map.prototype.has(key) devolverá false.

Map.prototype.entries()

Devuelve un nuevo objeto  Iterador que contiene un array de [llave, valor] para cada elemento en el objeto  Map en orden de inserción.

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

Llama a la callbackFn una vez por cada conjunto llave/valor presentes en cada objeto  Map, en orden de inserción. Si se le proporciona un parámetro thisArg a forEach, se usará como valor "this" para cada callback.

Map.prototype.get(key)

Devuelve el valor asociado a la  llave, o undefined si no tiene ninguno.

Map.prototype.has(key)

Devuelve un booleano que indica si un valor se ha asociado a la llave en el objeto Map o no se ha asociado.

Map.prototype.keys()

Devuelve un nuevo objeto  Iterador que contiene las llaves para cada elemento en el objeto Map en orden de inserción.

Map.prototype.set(key, value)

Establece un valor para la llave en el objeto Map. Devuelve el objeto  Map.

Map.prototype.values()

Devuelve un nuevo objeto  Iterador que contiene los valores para cada elemento en el objeto  Map en orden de inserción.

Map.prototype[@@iterator]()

Devuelve un nuevo objeto  Iterador que contiene un array de [llave, valor] para cada elemento en el objeto Map en orden de inserción.

var miMapa = new Map();

var claveObj = {},
    claveFunc = function () {},
    claveCadena = "una cadena";

// asignando valores
miMapa.set(claveCadena, "valor asociado con 'una cadena'");
miMapa.set(claveObj, "valor asociado con claveObj");
miMapa.set(claveFunc, "valor asociado with claveFunc");

miMapa.size; // 3

// obteniendo los valores
miMapa.get(claveCadena);    // "valor asociado con 'una cadena'"
miMapa.get(claveObj);       // "valor asociado con claveObj"
miMapa.get(claveFunc);      // "valor asociado con claveFunc"

miMapa.get("una cadena");   // ""valor asociado con 'una cadena'"
                         // porque claveCadena === 'una cadena'
miMapa.get({});           // undefined, porque claveObj !== {}
miMapa.get(function() {}) // undefined, porque claveFunc !== function () {}

NaN también puede ser usado como una clave. Aún cuando cada clave NaN no es igual a sí misma (NaN !== NaN es verdadera), el siguiente ejemplo funciona, porque las claves NaNs NaNs no son distinguibles unas de otras:

var miMapa = new Map();
miMapa.set(NaN, "no es un número");

miMapa.get(NaN); // "no es un número"

var otroNaN = Number("foo");
miMapa.get(otroNaN); // "no es un número"

Los Map pueden ser iterados usando un bucle for..of:

var miMapa = new Map();
miMapa.set(0, "cero");
miMapa.set(1, "uno");
for (var [clave, valor] of miMapa) {
  alert(clave + " = " + valor);
}
// Mostrará 2 alertas; primero con "0 = cero" y segundo con "1 = uno"

for (var clave of miMapa.keys()) {
  alert(clave);
}
// Mostrará 2 alertas; primero con "0" y segundo con "1"

for (var valor of miMapa.values()) {
  alert(valor);
}
// Mostrará 2 alertas; primero con "cero" y segundo con "uno"

for (var [clave, valor] of miMapa.entries()) {
  alert(clave + " = " + valor);
}
// Mostrará 2 alertas; primero con "0 = cero" y segundo con "1 = uno"

miMapa.forEach(function(valor, clave, miMapa) {
  alert(clave + " = " + valor);
})
// Mostrará 2 alertas; primero con "0 = cero" y segundo con "1 = uno"

Los Map pueden ser iterados usando el método forEach():

miMapa.forEach(function(valor, clave) {
  console.log(clave + ' = ' + valor);
});
// Mostrará 2 logs; el primero con "0 = cero" y el segundo con "1 = uno"

var kvArray = [["clave1", "valor1"], ["clave2", "valor2"]];

// El constructor por defecto de Map para transforar un Array 2D (clave-valor) en un mapa
var miMapa = new Map(kvArray);

miMapa.get("clave1"); // devuelve "valor1"

// Usando la función Array.from para transformar el mapa a un Array 2D clave-valor.
console.log(Array.from(miMapa)); // Muestra exactamente el mismo Array que kvArray

// O usando los iteradores de claves o valores y convirtiendo a array.
console.log(Array.from(miMapa.keys())); // Muestra ["clave1", "clave2"]

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