Conjuntos Set em JavaScript

Conjuntos em JavaScript são estruturas de dados que armazenam valores únicos. Para definir um conjunto, utilizamos o objeto Set. A criação de um conjunto é feita por meio do seu construtor:

const mySet = new Set();

Também é possível inicializar um conjunto com um array de valores:

const arr = [1, 1, 2, 3, 4, 5, 2, 4];
const numbers = new Set(arr);
console.log(numbers); // Set(5) {1, 2, 3, 4, 5}

Neste caso, os dados do array são passados para o conjunto, mas como ele armazena apenas valores únicos, os valores repetidos são automaticamente removidos.

Para simplificar, podemos passar um array diretamente para o construtor do Set:

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

Tamanho do conjunto

Para verificar o número de elementos em um conjunto, utilizamos a propriedade size.

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

Adicionando elementos

Para adicionar elementos, usamos o método add(), que modifica o conjunto:

const numbers = new Set();
numbers.add(1);
numbers.add(3);
numbers.add(5);
numbers.add(3); // não é adicionado
numbers.add(1); // não é adicionado
console.log(numbers); // Set(3) {1, 3, 5}

Como um conjunto armazena apenas valores únicos, adicionar um elemento já presente nele é ineficaz.

O método add retorna uma referência ao próprio conjunto, permitindo o encadeamento de métodos:

const numbers = new Set();
numbers.add(1).add(3).add(5);
console.log(numbers); // Set(3) {1, 3, 5}

Remoção de elementos

Para remover elementos, usamos o método delete():

const numbers = new Set([1, 3, 5]);
numbers.delete(3);
console.log(numbers); // Set(2) {1, 5}

Este método retorna um valor booleano: true se o elemento foi removido e false se a remoção não ocorreu (por exemplo, quando o elemento a ser removido não está presente no conjunto):

const numbers = new Set([1, 3, 5]);

let isDeleted = numbers.delete(3);
console.log(isDeleted); // true
isDeleted = numbers.delete(54);
console.log(isDeleted); // false

Para remover todos os elementos de um conjunto, usamos o método clear():

let numbers = new Set([1, 3, 5]);
numbers.clear();
console.log(numbers); // Set(0) {}

Verificação de presença de um elemento

Para verificar a presença de um elemento no conjunto, utilizamos o método has(). Ele retorna true se o elemento estiver presente e false caso contrário:

const numbers = new Set([1, 3, 5]);
console.log(numbers.has(3)); // true
console.log(numbers.has(32)); // false

Iteração sobre conjuntos

Para iterar sobre os elementos de um conjunto, utilizamos o método forEach():

const numbers = new Set([1, 2, 3, 5]);

numbers.forEach(function (value1, value2, set) {
  console.log(value1);
});

Semelhante ao método forEach() de arrays, esse método em conjuntos aceita uma função callback que recebe três parâmetros. Para conjuntos, o primeiro e o segundo parâmetros representam o elemento atual sendo iterado, e o terceiro parâmetro representa o conjunto inteiro. No entanto, apenas o primeiro parâmetro é geralmente utilizado.

Também podemos usar o laço for..of para percorrer um conjunto:

const numbers = new Set([1, 2, 3, 5]);

for (let n of numbers) {
  console.log(n);
}

Obtendo iteradores

O objeto Set possui métodos que retornam um iterador, especificamente o objeto SetIterator. Esses métodos são values(), keys(), e entries():

const numbers = new Set([1, 2, 3, 5]);

console.log(numbers.values()); // SetIterator {1, 2, 3, 5}
console.log(numbers.keys()); // SetIterator {1, 2, 3, 5}
console.log(numbers.entries()); // SetIterator {1 => 1, 2 => 2, 3 => 3, 5 => 5}

O método values() retorna um iterador que contém os valores dos elementos do conjunto. O método keys() é um alias para values() e retorna o mesmo iterador. O método entries() retorna um iterador que contém pares de chave-valor.

Os iteradores retornados podem ser usados para acessar os elementos do conjunto:

const people = new Set(["Tom", "Bob", "Sam"]);

const iterator = people.values();

console.log(iterator.next()); // {value: "Tom", done: false}
console.log(iterator.next()); // {value: "Bob", done: false}
console.log(iterator.next()); // {value: "Sam", done: false}
console.log(iterator.next()); // {value: undefined, done: true}

Remoção de elementos duplicados de um array

As propriedades exclusivas de um objeto Set permitem sua aplicação em várias operações, como a remoção de elementos duplicados de um array:

const peopleArray = ["Tom", "Bob", "Sam", "Alice", "Sam", "Kate", "Tom"];
const peopleSet = new Set(peopleArray);
const newPeopleArray = Array.from(peopleSet);

console.log(newPeopleArray); // ["Tom", "Bob", "Sam", "Alice", "Kate"]

A função Array.from() é utilizada aqui para criar um novo array a partir de um conjunto, garantindo que todos os elementos sejam únicos.