En JavaScript, un Map es una colección que almacena pares clave-valor, donde cada clave es única. A diferencia de los objetos tradicionales, los Map permiten usar cualquier tipo de dato como clave, no solo cadenas de texto o símbolos.

¿Qué es un Map?

Un Map es una estructura que permite almacenar datos en forma de pares clave-valor. Puedes pensar en un Map como una especie de "diccionario" en el que buscas valores utilizando claves.

Ejemplo básico de un Map:

 
1let mapa = new Map();
2
3mapa.set('nombre', 'Juan');
4mapa.set('edad', 30);
5
6console.log(mapa.get('nombre')); // Muestra "Juan"
7console.log(mapa.get('edad'));   // Muestra 30
Salida de Consola!:
Juan
30

En este ejemplo:

• 'nombre' es una clave, y 'Juan' es el valor asociado.
• 'edad' es otra clave, y 30 es su valor.

Cómo crear un Map

Puedes crear un Map usando el constructor Map(). Puedes inicializarlo vacío o pasarle un array de pares clave-valor.

Ejemplo de creación de un Map:

 
1// Creando un Map vacío
2let miMapa = new Map();
3
4// Creando un Map con valores iniciales
5let otroMapa = new Map([
6  ['nombre', 'Ana'],
7  ['edad', 25]
8]);
9
10console.log(otroMapa.get('nombre')); // Muestra "Ana"
Salida de Consola!:
Ana

Métodos y propiedades de los Map

1. set(clave, valor):

   • Agrega un nuevo par clave-valor al Map o actualiza el valor si la clave ya existe.
   • Ejemplo:

      
     1let miMapa = new Map();
     2
     3miMapa.set('color', 'rojo');
     4miMapa.set('color', 'azul'); // Actualiza el valor de la clave 'color'
     5console.log(miMapa); // Muestra azul
     Salida de Consola!:
     Map(1) { 'color' => 'azul' }

2. get(clave):

   • Devuelve el valor asociado a la clave especificada.
   • Ejemplo:

      
     1let miMapa = new Map();
     2miMapa.set('color', 'azul');
     3console.log(miMapa.get('color')); // Muestra "azul"
     Salida de Consola!:
     azul

3. has(clave):

   • Verifica si una clave existe en el Map.
   • Ejemplo:

      
     1let miMapa = new Map();
     2miMapa.set('color', 'azul');
     3console.log(miMapa.has('color')); // true
     4console.log(miMapa.has('tamaño')); // false
     Salida de Consola!:
     true
     false

4. delete(clave):

   • Elimina el par clave-valor asociado a la clave especificada.
   • Ejemplo:

      
     1let miMapa = new Map();
     2miMapa.set('color', 'azul');
     3miMapa.delete('color');
     4console.log(miMapa.has('color')); // false
     Salida de Consola!:
     false

5. size:

   • Devuelve el número de pares clave-valor en el Map.
   • Ejemplo:

      
     1let miMapa = new Map();
     2miMapa.set('color', 'azul');
     3console.log(miMapa.size); // Muestra 1
     Salida de Consola!:
     1

6. clear():

   • Elimina todos los pares clave-valor del Map.
   • Ejemplo:

      
     1let miMapa = new Map();
     2miMapa.set('uno', 1);
     3miMapa.set('dos', 2);
     4miMapa.clear();
     5console.log(miMapa.size); // Muestra 0
     Salida de Consola!:
     0

Iteración sobre un Map

Puedes iterar sobre los elementos de un Map de varias formas:

1. forEach():

   • Ejecuta una función para cada par clave-valor.
   • Ejemplo:

      
     1let miMapa = new Map();
     2miMapa.set('nombre', 'Ana');
     3miMapa.set('edad', 25);
     4miMapa.forEach((valor, clave) => {
     5  console.log(clave + ' = ' + valor);
     6});
     Salida de Consola!:
     nombre = Ana
     edad = 25

2. for...of:

   • Puedes usar for...of para iterar sobre las claves, valores o ambos.
   • Ejemplo:

      
     1let miMapa = new Map();
     2miMapa.set('nombre', 'Ana');
     3miMapa.set('edad', 25);
     4for (let [clave, valor] of miMapa) {
     5  console.log(clave + ' = ' + valor);
     6}
     Salida de Consola!:
     nombre = Ana
     edad = 25

3. keys(), values(), entries():

   • keys(): Devuelve un iterador con las claves.

      
     1let miMapa = new Map();
     2miMapa.set('nombre', 'Ana');
     3miMapa.set('edad', 25);
     4for (let clave of miMapa.keys()) {
     5  console.log(clave); // Muestra "nombre" y "edad"
     6}
     Salida de Consola!:
     nombre
     edad

   • values(): Devuelve un iterador con los valores.

      
     1let miMapa = new Map();
     2miMapa.set('nombre', 'Ana');
     3miMapa.set('edad', 25);
     4for (let valor of miMapa.values()) {
     5  console.log(valor);
     6}
     Salida de Consola!:
     Ana
     25

   • entries(): Devuelve un iterador con los pares clave-valor (es el predeterminado para for...of).

      
     1let miMapa = new Map();
     2miMapa.set('nombre', 'Ana');
     3miMapa.set('edad', 25);
     4for (let valor of miMapa.entries()) {
     5  console.log(valor);
     6}
     Salida de Consola!:
     [ 'nombre', 'Ana' ]
     [ 'edad', 25 ]

Diferencias entre Map y objetos

Aunque los Map y los objetos son colecciones clave-valor, existen diferencias importantes:

• Tipos de clave: En un objeto, las claves son siempre cadenas o símbolos, mientras que en un Map pueden ser de cualquier tipo (incluyendo objetos, funciones, etc.).
• Orden: En un Map, los elementos se mantienen en el orden en que se añadieron, lo que no siempre es cierto para las claves de un objeto.
• Propiedades integradas: Los objetos tienen un prototipo, lo que significa que pueden heredar propiedades y métodos, mientras que un Map no tiene prototipo y solo contiene lo que tú le agregas.

Resumen

• Un Map es una colección de pares clave-valor donde las claves pueden ser de cualquier tipo y son únicas.
• Métodos como set(), get(), y delete() te permiten añadir, obtener, y eliminar pares clave-valor.
• Los Map son útiles cuando necesitas almacenar datos relacionados con claves que no son necesariamente cadenas de texto, o cuando necesitas mantener el orden de inserción.

Los Map ofrecen una forma más flexible y poderosa de trabajar con colecciones clave-valor en JavaScript, comparado con los objetos tradicionales.