JavaScript incluye la estructura Set para almacenar valores únicos y aplicar ideas de teoría de conjuntos en programas reales.
Después de estudiar conjuntos desde el punto de vista matemático, es importante ver cómo llevar esas ideas a código. JavaScript ofrece la estructura Set, diseñada para guardar valores únicos.
Con Set se pueden representar colecciones sin repetidos, consultar pertenencia, recorrer elementos y construir operaciones como unión, intersección y diferencia.
Un conjunto se crea con new Set(). Se pueden agregar elementos al declararlo o después de crearlo.
const lenguajes = new Set(["JavaScript", "SQL", "HTML"]);
console.log(lenguajes);El conjunto contiene cada valor una sola vez.
Si se intenta agregar un valor que ya existe, el conjunto no lo repite.
const numeros = new Set([1, 2, 2, 3, 3, 3]);
console.log(numeros); // Set { 1, 2, 3 }Esta propiedad coincide con la idea matemática de que un conjunto no depende de la repetición de sus elementos.
El método add incorpora un nuevo elemento al conjunto.
const permisos = new Set();
permisos.add("leer");
permisos.add("escribir");
permisos.add("leer");
console.log(permisos); // Set { "leer", "escribir" }Agregar el mismo elemento más de una vez no cambia el conjunto.
Para comprobar si un elemento pertenece a un conjunto se usa has.
const roles = new Set(["admin", "editor", "lector"]);
console.log(roles.has("admin")); // true
console.log(roles.has("invitado")); // falseEsta operación representa la pregunta matemática x ∈ A.
El método delete quita un elemento del conjunto si existe.
const activos = new Set(["Ana", "Luis", "Sofía"]);
activos.delete("Luis");
console.log(activos); // Set { "Ana", "Sofía" }Eliminar un elemento se relaciona con construir un conjunto sin ese valor.
La propiedad size indica la cantidad de elementos del conjunto.
const categorias = new Set(["web", "datos", "seguridad"]);
console.log(categorias.size); // 3En términos matemáticos, size representa la cardinalidad del conjunto.
Un conjunto puede recorrerse con for...of.
const etiquetas = new Set(["urgente", "pendiente", "revisado"]);
for (const etiqueta of etiquetas) {
console.log(etiqueta);
}El recorrido visita cada elemento una sola vez.
Una aplicación frecuente de Set es eliminar duplicados de un arreglo.
const ids = [10, 20, 10, 30, 20, 40];
const idsUnicos = new Set(ids);
console.log(idsUnicos); // Set { 10, 20, 30, 40 }El arreglo original puede tener repeticiones, pero el conjunto resultante conserva solo valores únicos.
Para obtener un arreglo desde un conjunto se puede usar el operador de propagación.
const codigos = new Set(["A1", "B2", "C3"]);
const lista = [...codigos];
console.log(lista); // ["A1", "B2", "C3"]Esto es útil cuando se necesita ordenar, mapear o mostrar los datos en una interfaz.
La unión de dos conjuntos contiene los elementos que están en uno, en el otro o en ambos.
function union(a, b) {
return new Set([...a, ...b]);
}
const A = new Set([1, 2, 3]);
const B = new Set([3, 4, 5]);
console.log(union(A, B)); // Set { 1, 2, 3, 4, 5 }Esta función implementa A ∪ B.
La intersección contiene los elementos comunes a ambos conjuntos.
const A = new Set([1, 2, 3]);
const B = new Set([3, 4, 5]);
function interseccion(a, b) {
return new Set([...a].filter(x => b.has(x)));
}
console.log(interseccion(A, B)); // Set { 3 }Esta función implementa A ∩ B.
La diferencia contiene los elementos que están en el primer conjunto y no están en el segundo.
const A = new Set([1, 2, 3]);
const B = new Set([3, 4, 5]);
function diferencia(a, b) {
return new Set([...a].filter(x => !b.has(x)));
}
console.log(diferencia(A, B)); // Set { 1, 2 }Esta función implementa A - B.
La diferencia simétrica contiene los elementos que pertenecen a uno solo de los conjuntos.
const A = new Set([1, 2, 3]);
const B = new Set([3, 4, 5]);
function diferenciaSimetrica(a, b) {
const soloA = [...a].filter(x => !b.has(x));
const soloB = [...b].filter(x => !a.has(x));
return new Set([...soloA, ...soloB]);
}
console.log(diferenciaSimetrica(A, B)); // Set { 1, 2, 4, 5 }Esta operación elimina los elementos compartidos.
Un conjunto es subconjunto de otro si todos sus elementos pertenecen al segundo conjunto.
const A = new Set([1, 2, 3]);
const C = new Set([1, 2]);
function esSubconjunto(a, b) {
return [...a].every(x => b.has(x));
}
console.log(esSubconjunto(C, A)); // trueEsta función implementa la relación C ⊆ A.
Dos conjuntos son iguales si tienen la misma cardinalidad y cada elemento de uno pertenece al otro.
function sonIguales(a, b) {
return a.size === b.size && [...a].every(x => b.has(x));
}
console.log(sonIguales(new Set([1, 2]), new Set([2, 1]))); // trueEl orden de inserción no cambia la igualdad matemática del conjunto.
El método clear elimina todos los elementos.
const seleccionados = new Set(["tema1", "tema2"]);
seleccionados.clear();
console.log(seleccionados.size); // 0Después de limpiar el conjunto, queda vacío.
Los conjuntos son útiles para controlar permisos sin repetir valores.
function esSubconjunto(a, b) {
return [...a].every(x => b.has(x));
}
const permisosUsuario = new Set(["leer", "editar"]);
const permisosRequeridos = new Set(["leer"]);
const puedeAcceder = esSubconjunto(permisosRequeridos, permisosUsuario);
console.log(puedeAcceder); // trueLa validación se resuelve como una comparación entre conjuntos.
Set permite implementar de forma directa muchas ideas de teoría de conjuntos en JavaScript. Con esta estructura se pueden representar valores únicos, consultar pertenencia, calcular cardinalidad y construir operaciones fundamentales.
Dominar estas operaciones facilita resolver problemas de validación, filtrado, permisos, etiquetas, datos únicos y comparación de colecciones.