Set

En JavaScript, un Set es una colección de valores que no permite duplicados, es decir, cada valor dentro de un Set es único. Esto lo hace ideal para almacenar datos donde la unicidad es importante. Los valores de un Set pueden ser de cualquier tipo, como objetos, números, cadenas, entre otros.

Características principales de un `Set`:

No permite duplicados: Si intentas añadir un valor que ya existe, simplemente será ignorado.
Es iterable: Puedes recorrer un Set con bucles como for...of o métodos como .forEach().
Tiene métodos específicos: Incluye métodos como .add(), .delete(), .has(), y .clear().

Métodos comunes de un `Set`:

add(valor): Agrega un valor al Set.
delete(valor): Elimina un valor del Set.
has(valor): Verifica si un valor está en el Set.
clear(): Vacía completamente el Set.
size: Devuelve el número de elementos en el Set.

Ejemplo básico de uso:

// Crear un nuevo Set
const mySet = new Set();

// Agregar elementos al Set
mySet.add(1);
mySet.add(2);
mySet.add(3);
mySet.add(2); // Este valor no se agregará porque ya existe

console.log(mySet); // Output: Set { 1, 2, 3 }

// Comprobar si un valor está en el Set
console.log(mySet.has(2)); // Output: true
console.log(mySet.has(4)); // Output: false

// Eliminar un elemento del Set
mySet.delete(2);
console.log(mySet); // Output: Set { 1, 3 }

// Obtener el tamaño del Set
console.log(mySet.size); // Output: 2

// Recorrer un Set
mySet.forEach((value) => {
  console.log(value); // Output: 1, luego 3
});

// Vaciar el Set
mySet.clear();
console.log(mySet); // Output: Set {}

Ejemplo práctico: Eliminar duplicados de un array

const arrayConDuplicados = [1, 2, 3, 4, 4, 5, 5, 6];

// Convertir el array a un Set para eliminar duplicados
const arraySinDuplicados = [...new Set(arrayConDuplicados)];

console.log(arraySinDuplicados); // Output: [1, 2, 3, 4, 5, 6]

Nuevos métodos de `Set`

Union

Permite fusionar dos Set en uno, sin duplicados

const web = new Set(["JavaScript", "HTML", "CSS"]);
const backend = new Set(["JavaScript", "Java", "C#"]);
const compiled = new Set(["Java", "TypeScript", "C#"]);

web.union(backend); // Ahora web tiene los valores de web y backend sin duplicados

Intersection

Mira en dos conjuntos Set y devuelve los elementos que están en ambos conjuntos

const web = new Set(["JavaScript", "HTML", "CSS"]);
const backend = new Set(["JavaScript", "Java", "C#"]);
const compiled = new Set(["Java", "TypeScript", "C#"]);

web.intersection(backend); // Retorna solamente JavaScript

Difference

Nos muestra los elementos que están en el primer conjunto y no en el segundo

const web = new Set(["JavaScript", "HTML", "CSS"]);
const backend = new Set(["JavaScript", "Java", "C#"]);
const compiled = new Set(["Java", "TypeScript", "C#"]);

web.difference(backend); // Retorna HTML y CSS

Subconjuntos y superconjuntos

Subconjuntos (`isSubsetOf`)

isSubsetOf nos dirá si todos los elementos de begginer están en web

const web = new Set(["JavaScript", "HTML", "CSS"]);
const backend = new Set(["JavaScript", "Java", "C#"]);
const compiled = new Set(["Java", "TypeScript", "C#"]);

const begginer = new Set(["HTML", "CSS"]);

begginer.difference(web); // Retorna true porque HTML y CSS están también en web
web.difference(begginer); // Retorna false porque la colección web contiene más elementos que begginer

superconjuntos (`isSupersetOf`)

isSupersetOf nos dirá si web es un superconjunto de begginer

const web = new Set(["JavaScript", "HTML", "CSS"]);
const backend = new Set(["JavaScript", "Java", "C#"]);
const compiled = new Set(["Java", "TypeScript", "C#"]);

const begginer = new Set(["HTML", "CSS"]);

web.isSupersetOf(begginer); // Retorna true los elementos que están en begginer tamnbién están en web

isDisjointFrom

Nos dirá si todos elementos de dos colecciones son diferentes

const web = new Set(["JavaScript", "HTML", "CSS"]);
const backend = new Set(["JavaScript", "Java", "C#"]);
const compiled = new Set(["Java", "TypeScript", "C#"]);

const begginer = new Set(["HTML", "CSS"]);

compiled.isDisjointFrom(web); // Retorna true ya que todos los elementos son diferentes

Diferencias principales entre `Set` y `Map`:

Característica	Set	Map
Formato de datos	Colección de valores únicos	Colección de pares clave-valor
Claves	No tiene claves	Claves son únicas
Valores	Solo almacena valores	Cada clave tiene un valor asociado
Iteración	Itera sobre los valores	Itera sobre claves, valores o ambos
Acceso	Solo verifica si un valor existe	Accede a valores mediante claves

Ejemplo de `Set` (solo valores):

const mySet = new Set();

mySet.add(1);
mySet.add(2);
mySet.add(2); // Este duplicado será ignorado
mySet.add(3);

console.log(mySet); // Output: Set { 1, 2, 3 }

Ejemplo de `Map` (pares clave-valor):

const myMap = new Map();

myMap.set("a", 1);
myMap.set("b", 2);
myMap.set("c", 3);
myMap.set("a", 4); // Sobrescribe el valor de la clave 'a'

console.log(myMap); // Output: Map { 'a' => 4, 'b' => 2, 'c' => 3 }

En resumen:

Set: Una lista de valores únicos, como una bolsa de elementos donde no se repiten.
Map: Una tabla de pares clave-valor, como un diccionario.

Set

Características principales de un Set:

Métodos comunes de un Set: