El objetoMap retiene tuplas de llave-valor y mantiene el orden de inserción de las llaves.Cualquier valor (ambos objetos yvalores primitivos) puede ser usado como llave o valor.

Pruébalo

const map1 = new Map();map1.set("a", 1);map1.set("b", 2);map1.set("c", 3);console.log(map1.get("a"));// Expected output: 1map1.set("a", 97);console.log(map1.get("a"));// Expected output: 97console.log(map1.size);// Expected output: 3map1.delete("b");console.log(map1.size);// Expected output: 2

Descripción

Los objetosMap son colecciones de tuplas tipo llave-valor. Una llave enMappuede aparecer solo una vez; es única en la colección deMap. Un objetoMap es iterado por sus tuplas llave-valor —un buclefor...of regresa un arreglo de[llave, valor] por cada iteración. La iteración sucede enorden de inserción, la cual corresponde al orden en el que cada tupla llave-valor fue incertada inicialmente en elmap por el métodoset() (eso es, si no había una llave con el mismo valor en el map, cuandoset() fué llamado).

La especificación requiere que losmaps sean implementados "que, en promedio, proporcione tiempos de acceso que sean sublineales al numero de elementos en la colección". Por lo tanto, podría ser representado internamente como una tabla hash (con una busqueda O(1)), un árbol de búsqueda (con una busqueda de O(log(N))), o cualquier otra estructura de datos, mientras la complejidad sea mejor que O(N).

Igualdad de llaves

La igualdad de valores se basa en el algoritmoIgualdad SameValueZero. (Se solía usarigualdad SameValue, el cual trataba0 y-0 como diferentes. Revisecompatibilidad con navegadores.) Lo que significa queNaN es conciderado lo mismo queNaN (a pesar de queNaN !== NaN) y todos los otros valores son conciderados iguales, de acuerdo a la semantica del operador===.

Objects vs. Maps

Object es similar aMap—ambos te permiten asignar llaves a valores, recuperar esos valores, borrar llaves, y detectar si hay algo guardado en una llave. Por esta razón (y porque no había alternativas incorporadas), históricamenteObject se ha usado comoMap.

Sin embargo, hay diferencias importantes que hacen que se prefiera aMap en algunos casos:

Asignando propiedades de objeto

Asignar propiedades de objeto funciona también para objetosMap, y puede crear confusión.

Por lo tanto, de alguna manera esto parece funcionar:

const wrongMap = new Map();wrongMap["bla"] = "blaa";wrongMap["bla2"] = "blaaa2";console.log(wrongMap); // Map { bla: 'blaa', bla2: 'blaaa2' }

Pero esta manera de asignar una propiedad, no interactua con la estructura de datos del objetoMap. Utiliza la característica de el objeto genérico. El valor 'bla' no es guardado en elMap para consultas. Otras operaciones que fallan:

wrongMap.has("bla"); // falsewrongMap.delete("bla"); // falseconsole.log(wrongMap); // Map { bla: 'blaa', bla2: 'blaaa2' }

El uso correcto para guardar datos en el objetoMap es através de el métodoset(key, value).

const contacts = new Map();contacts.set("Jessie", {  telefono: "213-555-1234",  direccion: "123 N 1st Ave",});contacts.has("Jessie"); // truecontacts.get("Hilary"); // undefinedcontacts.set("Hilary", { telefono: "617-555-4321", direccion: "321 S 2nd St" });contacts.get("Jessie"); // {teléfono: "213-555-1234", dirección: "123 N 1st Ave"}contacts.delete("Raymond"); // falsecontacts.delete("Jessie"); // trueconsole.log(contacts.size); // 1

APIs del navegador similares a Map

Objetos del Navegador similares aMap (o "objetos que parecenmap") son interfaces de laAPI Web que se comportan en muchos aspectos como un objetoMap.

Al igual que el objetoMap, las entradas pueden iterarse en el mismo orden en que fueron agregadas al objeto.Los objetos similares aMap y los objetosMap también tienen propiedades y métodos que comparten el mismo nombre y comportamiento. Sin embargo, contrario a los objetosMap estos sólo permiten tipos específicos predefinidos para las llaves y valores de cada entrada.

Los tipos permitidos se encuentran en la especificación de la definición IDL (Interfaz de Descripcion del Lenguage). Por ejemplo,RTCStatsReport es un objeto similar aMap que debe usar cadenas de caracteres para sus llaves, y objetos para sus valores. Esto está definido en la especificación IDL a continuación:

interface RTCStatsReport {  readonly maplike<DOMString, object>;};

Los objetos similares aMap son o de solo-lectura o lectura-escritura (véase la palabra clavereadonly en el IDL de arriba).

• Los obejtos similares aMap de solo-lectura tienen la propiedadsize, y los métodos:entries(),forEach(),get(),has(),keys(),values(), y[Symbol.iterator]().
• Los objetos similares aMap de lectura-escritura tienen métodos adicionales:clear(),delete(), yset().

Los métodos y propiedades tienen el mismo comportamiento que las entidades equivalentes en el objetoMap, excepto por la restricción en los tipos de llaves y valores.

Los siguientes, son ejemplos de objetos de navegador similares aMap:

• AudioParamMap
• RTCStatsReport
• EventCounts
• KeyboardLayoutMap
• MIDIInputMap
• MIDIOutputMap

Constructor

Map()

Crea un nuevo objetoMap.

Propiedades estáticas

Map[Symbol.species]

La función constructor que es usada para crear objetos derivados.

Metodos estáticos

Map.groupBy()

Agrupa los elementos de un iterable usando los valores que regresa la función provista. El objetoMap que regresa, usa como llaves los valores únicos de la función de prueba, los cuales pueden ser usados para obtener el arreglo de elementos de cada grupo.

Propiedades de instancia

Estas propiedades están definidas enMap.prototype y las comparten todas las instancias deMap.

Map.prototype.constructor

La funcion constructor que creó el objeto de instancia. Para las instancias deMap el valor inicial es el constructorMap.

Map.prototype.size

Regresa el número de tuplas llave/valor en el objetoMap.

Map.prototype[Symbol.toStringTag]

El valor inicial de la propiedad[Symbol.toStringTag] es la cadena de caracteres"Map". Esta propiedad es usada enObject.prototype.toString().

Métodos de instancia

Map.prototype.clear()

Remueve todas las tuplas llave-valor del objetoMap.

Map.prototype.delete()

Regresatrue si un elemento en el objetoMap existía y ha sido removido, orfalse si el elemento no existe.map.has(key) regresaráfalse después de esto.

Map.prototype.entries()

Regresa un nuevo objeto Iterador que contiene un arreglo con dos miembros[llave, valor] por cada elemento en el objetoMap en orden de inserción.

Map.prototype.forEach()

Llama una funcióncallbackFn una vez por cada tupla llave-valor presente en el objetoMap, en orden de inserción. Si un parametrothisArg es proporcionado aforEach, será utilizado como el valorthis para cada llamada a la funcion callback.

Map.prototype.get()

Regresa el valor asociado a la llave que se pasa como argumento, oundefined si no hay ninguno.

Map.prototype.has()

Regresa un booleano indicando si, en el objetoMap un valor ha sido asociado a la llave pasada como argumento.

Map.prototype.keys()

Regresa un nuevo objeto Iterador que contiene las llaves para cada elemento en el objetoMap, en orden de inserción.

Map.prototype.set()

Asigna el valor en el objetoMap para la llave pasada como argumento. Regresa el objetoMap.

Map.prototype.values()

Regresa un nuevo objeto Iterador que contiene los valores para cada elemento en un objetoMap, en orden de inserción.

Map.prototype[Symbol.iterator]()

Regresa un nuevo objeto Iterador que contiene un arreglo con dos miembros[llave, valor] por cada elemento en el objetoMap, en orden de inserción.

Ejemplos

Usando el objeto Map

const myMap = new Map();const keyString = "a string";const keyObj = {};const keyFunc = function () {};// asignando valoresmyMap.set(keyString, "valor asociado con la llave 'a string'");myMap.set(keyObj, "valor asociado con la llave keyObj");myMap.set(keyFunc, "valor asociado con la llave keyFunc");console.log(myMap.size); // 3// obteniendo los valoresconsole.log(myMap.get(keyString)); // "valor asociado con la llave 'a string'"console.log(myMap.get(keyObj)); // "valor asociado con la llave keyObj"console.log(myMap.get(keyFunc)); // "valor asociado con la llave keyFunc"console.log(myMap.get("a string")); // "valor asociado con la llave 'a string'", porque keyString === 'a string'console.log(myMap.get({})); // undefined, porque keyObj !== {}console.log(myMap.get(function () {})); // undefined, porque keyFunc !== function () {}

Usando NaN como llave de Map

NaN puede también usarse como una llave. A pesar que cadaNaN no es igual a si mismo (NaN !== NaN es verdadero), el siguiente ejemplo funciona porque losNaN son indistinguibles entre sí:

const myMap = new Map();myMap.set(NaN, "not a number");myMap.get(NaN);// "not a number"const otherNaN = Number("foo");myMap.get(otherNaN);// "not a number"

Iterando Map con for...of

Los Maps pueden iterarse usando un buclefor...of:

const myMap = new Map();myMap.set(0, "zero");myMap.set(1, "one");for (const [key, value] of myMap) {  console.log(`${key} = ${value}`);}// 0 = zero// 1 = onefor (const key of myMap.keys()) {  console.log(key);}// 0// 1for (const value of myMap.values()) {  console.log(value);}// zero// onefor (const [key, value] of myMap.entries()) {  console.log(`${key} = ${value}`);}// 0 = zero// 1 = one

Iterando Map con forEach()

Los Maps pueden iterarse usando el métodoforEach():

myMap.forEach((value, key) => {  console.log(`${key} = ${value}`);});// 0 = zero// 1 = one

Relación con objetos Array

const kvArray = [  ["key1", "value1"],  ["key2", "value2"],];// Usa el constructor ordinario Map para transformar un Array 2D llave-valor a un mapconst myMap = new Map(kvArray);console.log(myMap.get("key1")); // "value1"// Usa Array.from() para transformar un map a un Array 2D llave-valorconsole.log(Array.from(myMap)); // Mostrará exactamente el mismo Array como kvArray// Una forma concisa de hacer lo mismo, usando la sintaxis spreadconsole.log([...myMap]);// O usa los iteradores keys() o values(), y conviertelos a un arregloconsole.log(Array.from(myMap.keys())); // ["key1", "key2"]

Clonando y uniendo Maps

Así como losArray, losMap pueden clonarse:

const original = new Map([[1, "one"]]);const clone = new Map(original);console.log(clone.get(1)); // oneconsole.log(original === clone); // false (útil para comparaciones superficiales)

Los objetosMap pueden unirse, manteniendo la unicidad de las llaves:

const first = new Map([  [1, "one"],  [2, "two"],  [3, "three"],]);const second = new Map([  [1, "uno"],  [2, "dos"],]);// Al unir ambos maps. La ultima llave repetida gana.// la sintaxis Spread convierte un Map a un Arrayconst merged = new Map([...first, ...second]);console.log(merged.get(1)); // unoconsole.log(merged.get(2)); // dosconsole.log(merged.get(3)); // three

Los Maps también pueden unirse a Arrays:

const first = new Map([  [1, "one"],  [2, "two"],  [3, "three"],]);const second = new Map([  [1, "uno"],  [2, "dos"],]);// Merge maps with an array. The last repeated key wins.const merged = new Map([...first, ...second, [1, "eins"]]);console.log(merged.get(1)); // einsconsole.log(merged.get(2)); // dosconsole.log(merged.get(3)); // three

Especificaciones

Compatibilidad con navegadores

Véase también

• Polyfill paraMap encore-js
• Set
• WeakMap
• WeakSet