Conjuntos en

Acerca de Conjuntos

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

Los conjuntos deben crearse usando el constructor Set; se pueden inicializar con valores pasando un array al constructor.

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

Agregar y eliminar elementos

No se puede agregar un valor a un conjunto si es estrictamente igual a alguno de los elementos del conjunto.

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 conjuntos y arrays

Los arrays se convierten en conjuntos usando el constructor Set. Los conjuntos se pueden convertir en arrays usando ya sea 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 conjunto es una colección con claves, lo que significa que sus elementos están indexados por una clave y se pueden iterar en orden de inserción. Debido a que la clave y el valor de un elemento de un conjunto 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 vs. arrays

Cuando se elige un conjunto para almacenar una colección de datos (en lugar de un array), generalmente es porque los valores almacenados deben ser únicos. Sin embargo, dado que también es posible imponer la unicidad con arrays, puede que no sea obvio por qué es así.

La respuesta corta es que los conjuntos 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 tiempo lleva buscarlo. Los métodos de búsqueda de conjuntos, por otro lado, tienen tiempos de ejecución constantes, lo que significa que permanecen igual sin importar el tamaño del conjunto.

En la práctica, sin embargo, esta diferencia de rendimiento es insignificante a menos que la colección contenga una gran cantidad de datos.