Conjuntos em

Sobre Conjuntos

Em JavaScript, um conjunto é uma estrutura de dados semelhante a uma lista que só pode conter primitivos e/ou referências a objetos únicos.

Os conjuntos têm de ser criados com o construtor de conjuntos; podem ser inicializados com valores passando um array ao construtor.

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

Adicionar e remover elementos

Um valor não pode ser adicionado a um conjunto se for estritamente igual a algum dos elementos do 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

Converter entre conjuntos e arrays

Os arrays são convertidos em conjuntos com o construtor de conjuntos. Os conjuntos podem ser convertidos em arrays com a sintaxe de espalhamento ou com 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]

Iteração

Um conjunto é uma coleção com chaves, o que significa que os seus elementos são indexados por uma chave e podem ser iterados pela ordem de inserção. Como a chave e o valor de um elemento de um conjunto são iguais, Set.keys() e Set.values() são intercambiáveis.

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']

Desempenho de pesquisa vs. arrays

Quando se escolhe um conjunto para guardar uma coleção de dados (em vez de um array), é geralmente porque os valores guardados têm de ser únicos. No entanto, como também é possível garantir a unicidade com arrays, pode não ser óbvio por que razão isso acontece.

A resposta curta é que os conjuntos estão otimizados para a pesquisa, e os arrays não. Os métodos de pesquisa de arrays (como Array.indexOf()) têm tempos de execução que aumentam linearmente com o tamanho do array; ou seja, quantos mais elementos o array tiver, mais tempo demora a pesquisá-lo. Os métodos de pesquisa de conjuntos, por outro lado, têm tempos de execução constantes, o que significa que se mantêm iguais independentemente do tamanho do conjunto.

Na prática, porém, esta diferença de desempenho é insignificante, a menos que a coleção contenha uma enorme quantidade de dados.