Conjuntos en

Acerca de Conjuntos

En JavaScript, un set es una estructura de datos similar a un array que solo puede contener primitivos únicos y/o referencias a objetos.

Los sets se deben crear con el constructor de sets; puedes inicializarlos con valores pasando un array al constructor.

const emptySet = new Set();
const setWithInitialValues = new Set(['hello', 'world']);

Añadir y eliminar elementos

No se puede añadir un valor a un set si es estrictamente igual a alguno de los elementos del set.

const set = new Set();
set.add(10);
set.add(10); // 10 is strictly equal to 10, so it can't be added again
set.size;
//=> 1;

set.has(10);
//=> true
set.delete(10);
//=> true; 10 was removed
set.delete(10);
//=> false; 10 is not in the set, so nothing happened

const obj = { color: 'magenta' };
const eerilySimilarObj = { color: 'magenta' };

set.add(obj);
set.add(eerilySimilarObj); // obj and eerilySimilarObj reference different objects, so they can both be added
set.size;
//=> 2

set.clear();
set.size;
//=> 0

Convertir entre sets y arrays

Los arrays se convierten en sets con el constructor de sets. Los sets se pueden convertir en arrays usando la sintaxis de propagación o Array.from().

const arrayWithDuplicates = [7, 3, 3, 9, 3];
const arrayWithoutDuplicates = [...new Set(arrayWithDuplicates)]; // [7, 3, 9]
const anotherArrayWithoutDuplicates = Array.from(new Set(arrayWithDuplicates)); // [7, 3, 9]

Iteración

Un set es una colección indexada por clave, lo que significa que sus elementos se indexan mediante una clave y se pueden recorrer en orden de inserción. Como la clave y el valor de un elemento de un set son lo mismo, Set.keys() y Set.values() son intercambiables.

const apples = ['Granny Smith', 'Honey Crisp', 'Royal Gala'];
const appleSet = new Set(apples);

for (let apple of appleSet.keys()) {
  console.log(apple);
}
// 'Granny Smith'
// 'Honey Crisp'
// 'Royal Gala'

for (let apple of appleSet.values()) {
  console.log(apple);
}
// 'Granny Smith'
// 'Honey Crisp'
// 'Royal Gala'

for (let apple of appleSet.entries()) {
  console.log(apple);
}
// ['Granny Smith', 'Granny Smith']
// ['Honey Crisp', 'Honey Crisp']
// ['Royal Gala', 'Royal Gala']

Rendimiento de búsqueda frente a los arrays

Cuando se elige un set para almacenar una colección de datos (en lugar de un array), suele ser porque los valores almacenados deben ser únicos. Sin embargo, como también es posible garantizar la unicidad con arrays, puede que no resulte obvio por qué.

La respuesta corta es que los sets están optimizados para la búsqueda, y los arrays no. Los métodos de búsqueda de arrays (como Array.indexOf()) tienen tiempos de ejecución que aumentan linealmente con el tamaño del array; es decir, cuantos más elementos contiene el array, más tarda en buscarse. Los métodos de búsqueda de sets, en cambio, tienen tiempos de ejecución constantes, lo que significa que se mantienen igual independientemente del tamaño del set.

En la práctica, no obstante, esta diferencia de rendimiento es insignificante salvo que la colección contenga una cantidad enorme de datos.