Map y Set

Hasta ahora, hemos aprendido sobre estas estructuras de datos:

• Objetos: ideales para colecciones de datos organizadas por claves.
• Arrays: perfectos para colecciones ordenadas de elementos.

Sin embargo, para algunos escenarios de la vida real, estas estructuras pueden quedarse cortas. Por eso tenemos a los poderosos Map y Set. 🚀

🔑 Map: La evolución de los objetos

Un Map es como un objeto, pero con superpoderes: permite usar cualquier tipo de dato como clave. ¡Eso significa que no estás limitado a strings o símbolos! 🎉

Métodos y propiedades principales

• new Map(): Crea un nuevo mapa vacío.
• map.set(clave, valor): Asocia un valor a una clave.
• map.get(clave): Obtiene el valor asociado a la clave. Devuelve undefined si no existe.
• map.has(clave): Verifica si una clave está en el mapa.
• map.delete(clave): Elimina una clave y su valor.
• map.clear(): Limpia todo el contenido del mapa.
• map.size: Devuelve el número de elementos en el mapa.

Ejemplo práctico

let map = new Map();

map.set("1", "string"); // Clave: string
map.set(1, "number"); // Clave: número
map.set(true, "boolean"); // Clave: booleano

console.log(map.get(1)); // "number"
console.log(map.get("1")); // "string"
console.log(map.size); // 3

🚨 Nota importante: A diferencia de los objetos, las claves en un Map no se convierten a cadenas automáticamente. ¡Esto da más control y flexibilidad! 🔥

Evita usar map[clave]

Aunque técnicamente puedes usar map[clave], esto trata al mapa como un objeto normal, perdiendo las ventajas de Map. Usa siempre los métodos como set y get para trabajar correctamente. ✅

¿Cuándo usar Map en lugar de un objeto?

1. Cuando necesitas claves que no sean strings: Un Map puede usar objetos, números, booleans, o cualquier otro tipo como claves, mientras que los objetos convierten todas las claves a strings.
2. Cuando requieres un tamaño conocido: Con Map, puedes usar la propiedad .size para obtener el número de elementos directamente.
3. Cuando necesitas iterar fácilmente: Los métodos de iteración como map.keys(), map.values(), y map.entries() son más cómodos que iterar sobre objetos.

Ejemplo: Contar concurrencias únicas

Imagina que estás desarrollando una funcionalidad para analizar una lista de usuarios activos en una app. Necesitas saber cuántas veces se ha registrado cada usuario:

const users = [
  { id: 1, name: "Alice" },
  { id: 2, name: "Bob" },
  { id: 1, name: "Alice" },
  { id: 3, name: "Charlie" },
  { id: 2, name: "Bob" },
];

const userMap = new Map();

// Contamos cuántas veces aparece cada usuario
users.forEach((user) => {
  const currentCount = userMap.get(user.id) || 0;
  userMap.set(user.id, currentCount + 1);
});

userMap.forEach((count, userId) => {
  console.log(`Usuario ${userId} se registró ${count} veces.`);
});
// Resultado:
// Usuario 1 se registró 2 veces.
// Usuario 2 se registró 2 veces.
// Usuario 3 se registró 1 vez.

🌟 Set: ¡Solo valores únicos, por favor!

Un Set es una colección especial donde cada valor debe ser único. Es perfecto para evitar duplicados sin necesidad de validar manualmente. ¡Un salvavidas! 🛟

Métodos y propiedades principales

• new Set([iterable]): Crea un nuevo conjunto, opcionalmente inicializado con un iterable (como un array).
• set.add(valor): Agrega un valor único.
• set.delete(valor): Elimina un valor. Devuelve true si existía, false si no.
• set.has(valor): Verifica si un valor existe.
• set.clear(): Limpia todo el contenido del conjunto.
• set.size: Retorna la cantidad de elementos en el conjunto.

Ejemplo práctico

let set = new Set();

set.add("🍎");
set.add("🍌");
set.add("🍎"); // Este valor no se duplicará

console.log(set.size); // 2

for (let fruit of set) {
  console.log(fruit); // "🍎", "🍌"
}

¿Cuándo usar Set en lugar de un array?

1. Cuando necesitas eliminar duplicados fácilmente: Un Set hace esto automáticamente, sin necesidad de escribir lógica adicional.
2. Cuando la unicidad es clave en tus datos: Si tienes una lista donde cada valor debe ser único (como nombres de usuario o correos), usa un Set.

Ejemplo: Encontrar palabras únicas

Imagina que estás creando una herramienta para analizar textos y necesitas extraer las palabras únicas de un párrafo:

const paragraph = "JavaScript es increíble, y JavaScript es popular.";
const words = paragraph.toLowerCase().match(/\w+/g); // Convertimos a minúsculas y extraemos palabras

const uniqueWords = new Set(words);

console.log(uniqueWords);
// Resultado: Set { 'javascript', 'es', 'increíble', 'y', 'popular' }

// Convertimos el Set a un array
console.log([...uniqueWords]);
// Resultado: ['javascript', 'es', 'increíble', 'y', 'popular']

🔄 Iterar sobre Map y Set

Ambas estructuras soportan varias formas de iteración. Aquí algunos ejemplos:

Map

let recipeMap = new Map([
  ["pepino", 500],
  ["tomates", 350],
  ["cebollas", 50],
]);

// Claves
for (let vegetable of recipeMap.keys()) {
  console.log(vegetable); // pepino, tomates, cebollas
}

// Valores
for (let amount of recipeMap.values()) {
  console.log(amount); // 500, 350, 50
}

// Entradas [clave, valor]
for (let entry of recipeMap.entries()) {
  console.log(entry); // ["pepino", 500] ...
}

Set

let fruits = new Set(["🍎", "🍌", "🍇"]);

for (let fruit of fruits) {
  console.log(fruit); // "🍎", "🍌", "🍇"
}

fruits.forEach((value) => {
  console.log(value); // "🍎", "🍌", "🍇"
});

Comparativa Práctica

Aquí tienes una guía rápida para decidir cuándo usar Map, Set, objetos o arrays:

Necesidad	Usa esto	Por qué
Almacenar pares clave/valor	Map	Soporta cualquier tipo de clave y métodos más prácticos.
Colección de datos únicos	Set	Garantiza unicidad de valores automáticamente.
Relación clave/valor simple	Objeto	Más ligero si las claves son strings y no necesitas iteración fácil.
Colección ordenada de datos	Array	Ideal para listas y operaciones como filtro o mapeo.

Ejempo Combinado

Supongamos que estamos desarrollando un sistema para registrar eventos únicos y su frecuencia.

Necesitamos:

1. Evitar duplicados en los nombres de los eventos.
2. Contar cuántas veces ocurre cada evento

const events = ["login", "viewPage", "login", "logout", "viewPage", "login"];

// Evitamos duplicados
const uniqueEvents = new Set(events);

// Contamos frecuencia de cada evento
const eventCount = new Map();

events.forEach((event) => {
  const currentCount = eventCount.get(event) || 0;
  eventCount.set(event, currentCount + 1);
});

console.log("Eventos únicos:", [...uniqueEvents]);
// Resultado: ['login', 'viewPage', 'logout']

console.log("Frecuencia de eventos:");
eventCount.forEach((count, event) => {
  console.log(`${event}: ${count}`);
});
// Resultado:
// login: 3
// viewPage: 2
// logout: 1

✨ Resumen

Map 🗺️

• Claves de cualquier tipo (¡incluso objetos!).
• Métodos útiles: set, get, has, delete.
• Ideal cuando necesitas pares clave-valor con tipos variados.

Set ✅

• Solo almacena valores únicos.
• Métodos clave: add, has, delete.
• Perfecto para eliminar duplicados o mantener colecciones únicas.