Sets en JavaScript: Guía Completa y Ejemplos Prácticos

---

¿Qué Son y Cómo Usarlos?

En JavaScript, un Set es una estructura de datos que permite almacenar valores únicos de cualquier tipo, ya sea primitivo u objeto. A diferencia de los arreglos, los Sets no permiten elementos duplicados, lo que los hace ideales cuando necesitamos listas sin repeticiones.

¿Qué es un Set?

Un Set es un objeto que almacena elementos únicos y no mantiene un orden específico de inserción. Se pueden usar para evitar duplicados de manera eficiente y sencilla.

Crear un Set

Para crear un Set, utilizamos el constructor Set():

const mySet = new Set();

También podemos inicializar un Set con valores:

const colors = new Set(['red', 'green', 'blue']);
console.log(colors); 
// Salida: Set {'red', 'green', 'blue'}

Ejemplos de Uso

1. Agregar Elementos add(value):

Agrega un elemento al Set. Si el valor ya existe, no se agregará de nuevo.

const mySet = new Set();
mySet.add(1);
mySet.add(2);
mySet.add(1); // Este valor no se agregará porque ya existe
console.log(mySet); 
// Salida: Set {1, 2}

2. Eliminar Elementos delete(value)

Elimina un elemento específico del Set. Si el valor existe, se elimina; si no existe, el Set permanece igual.

mySet.delete(1);
console.log(mySet); // Set {2}

3. Comprobar Existencia (has(value))

Verifica si un valor está en el Set, devolviendo true o false.

const names = new Set(['Alice', 'Bob', 'Charlie']);
console.log(names.has('Alice')); // true
console.log(names.has('Eve')); // false

4. Tamaño del Set size

Retorna el número de elementos en el Set.

console.log(mySet.size); // 1

5. Vaciar el Set clear()

Elimina todos los elementos del Set, dejándolo vacío.

mySet.clear();
console.log(mySet); // Set {}

Eliminar elementos duplicados del Array

Una forma rápida de eliminar duplicados de un arreglo es convirtiéndolo a un Set y luego de vuelta a un arreglo.

const numbers = [1, 2, 3, 3, 4, 4, 5];
const uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers); 
// Salida: [1, 2, 3, 4, 5]

Cómo Iterar un Objeto Set en JavaScript

Puedes iterar sobre un Set utilizando for...of o el método forEach(). Ambos permiten acceder a cada elemento del Set.

const fruits = new Set(['apple', 'banana', 'mango']);

for (const fruit of fruits) {
console.log(fruit);
}

// También se puede usar forEach
fruits.forEach(fruit => console.log(fruit));

// Salida:
// apple
// banana
// mango

Relación con Objetos Array

Los Sets y los Arrays son ambos estructuras de datos, pero los Sets no permiten duplicados, mientras que los Arrays sí.

const myArray = [1, 2, 2, 3];
const mySet = new Set(myArray);

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

Explicación: Al convertir un Array en un Set, se eliminan automáticamente los duplicados, resultando en un conjunto único de elementos.

Relación con Strings

Los Sets pueden almacenar caracteres únicos de una cadena, lo que es útil para encontrar caracteres distintos.

const str = "hello";
const charSet = new Set(str);

console.log(charSet); // Salida: Set {'h', 'e', 'l', 'o'}

Usar Set para Garantizar la Unicidad de una Lista de Valores

Los Sets son ideales para asegurar que los elementos de una lista sean únicos.

const userIds = new Set();
userIds.add('user1');
userIds.add('user2');
userIds.add('user1'); // Este duplicado no se añadirá

console.log(userIds); // Salida: Set {'user1', 'user2'}

Convertir a Arrays

Los Sets se pueden convertir fácilmente en Arrays usando el operador de propagación o el método Array.from().

const mySet = new Set([1, 2, 3]);
const arrayFromSet1 = [...mySet];
const arrayFromSet2 = Array.from(mySet);

console.log(arrayFromSet1); // Salida: [1, 2, 3]
console.log(arrayFromSet2); // Salida: [1, 2, 3]

Unión de Dos Set en JavaScript

Puedes combinar dos Sets en uno nuevo utilizando el operador de propagación.

const setA = new Set([1, 2, 3]);
const setB = new Set([3, 4, 5]);
const union = new Set([...setA, ...setB]);

console.log(union); 
// Salida: Set {1, 2, 3, 4, 5}

Intersección de Dos Sets en JavaScript

La intersección de dos Sets consiste en crear un nuevo Set que contenga solo los elementos que están presentes en ambos Sets.

const setA = new Set([1, 2, 3, 4]);
const setB = new Set([3, 4, 5, 6]);
const intersection = new Set([...setA].filter(value => setB.has(value)));

console.log(intersection); 
// Salida: Set {3, 4}

Diferencia de Dos Sets en JavaScript

La diferencia de dos Sets genera un nuevo Set que contiene los elementos que están en el primer Set pero no en el segundo.

const setA = new Set([1, 2, 3, 4]);
const setB = new Set([3, 4, 5, 6]);
const difference = new Set([...setA].filter(value => !setB.has(value)));

console.log(difference); 
// Salida: Set {1, 2}