We're looking for a user researcher to understand the needs of developers and designers. Is this you or someone you know? Check out the post: https://mzl.la/2IGzdXS

Esta traducción está incompleta. Por favor, ayuda a traducir este artículo del inglés.

Resumen

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

Sintaxis

new Map([iterable])

Parámetros

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.

Descripción

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 aleatoreo y no ordenado.

Igualdad de claves

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.

Objetos y mapas comparados

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 sus 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.

Propiedades

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.

Instancias de Map

Todas las instancias de Map heredan de Map.prototype.

Propiedades

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.

Métodos

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.

Ejemplos

Ejemplo: Usando el objeto Map

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

Ejemplo: Usando NaN como claves de Map

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"

Ejemplo: Iterando Map con for..of

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"

Iterando Maps usando forEach()

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"

Ejemplo: Relación con los objetos Array

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

Especificaciones

Especificación Estado Comentario
ECMAScript 2015 (6th Edition, ECMA-262)
La definición de 'Map' en esta especificación.
Standard Definición inicial.
ECMAScript Latest Draft (ECMA-262)
La definición de 'Map' en esta especificación.
Draft  

Compatibilidad con Navegadores

 

FeatureChromeEdgeFirefoxInternet ExplorerOperaSafari
Soporte básico38121311258
new Map(iterable)381213 No259
new Map(null) Si123711 Si9
Map() without new throws Si124211 Si9
Key equality for -0 and 0381229 No259
clear38121911258
delete38121311258
entries381220 No258
forEach38122511258
get38121311258
has38121311258
keys381220 No258
prototype38121311258
set381213111258
size381219211258
values381220 No258
@@iterator Si Si

36

27 — 363 4

17 — 275 6

No Si Si
@@species511341 No3810
@@toStringTag44 No No No No No
FeatureAndroid webviewChrome para AndroidEdge mobileFirefox para AndroidOpera AndroidiOS SafariSamsung Internet
Soporte básico38381214258 Si
new Map(iterable)38381214259 Si
new Map(null) Si Si1237 Si9 Si
Map() without new throws Si Si1242 Si9 Si
Key equality for -0 and 038381229259 Si
clear38381219258 Si
delete38381214258 Si
entries38381220258 Si
forEach38381225258 Si
get38381214258 Si
has38381214258 Si
keys38381220258 Si
prototype38381214258 Si
set38381214258 Si
size383812192258 Si
values38381220258 Si
@@iterator Si Si Si

36

27 — 363 4

17 — 275 6

Si Si Si
@@species5151134138105.0
@@toStringTag4444 No No No No4.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.

 

Ver también

Etiquetas y colaboradores del documento

Última actualización por: SphinxKnight,