Mulțimi Set

Mulțimile (sets) reprezintă o structură de date care poate stoca doar valori unice. În JavaScript, funcționalitatea seturilor este definită de obiectul Set. Pentru a crea o mulțime, se utilizează constructorul acestui obiect:

const mySet = new Set();

De asemenea, puteți furniza un șir de valori către constructor, cu ajutorul căruia mulțimea va fi inițializată:

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}

În acest caz, datele dintr-un array sunt transmise în mulțime. Totuși, deoarece o mulțime poate stoca doar valori unice, la crearea sa, valorile repetitive din array sunt eliminate.

Pentru a simplifica crearea unui set, putem transmite direct array-ul în constructorul Set:

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

Dimensiunea setului

Pentru a verifica numărul de elemente, puteți utiliza proprietatea size.

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

Adăugare

Pentru a adăuga, se utilizează metoda add(). Rezultatul său este o modificare a mulțimii:

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

În acest context, deoarece mulțimea stochează doar valori unice, adăugarea de elemente care sunt deja prezente în mulțime nu are sens.

Deoarece metoda add returnează o referință la aceeași mulțime, putem apela metode într-o catenă:

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

Ștergere

Pentru a șterge elemente, se utilizează metoda delete():

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

Această metodă returnează o valoare booleană: true - dacă elementul a fost șters și false - dacă ștergerea nu a avut loc (de exemplu, atunci când elementul de șters nu există în mulțime):

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

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

Dacă este necesar să ștergeți toate elementele din mulțime, se utilizează metoda clear():

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

Verificarea existenței elementului

Pentru a verifica dacă un element există în mulțime, se utilizează metoda has(). Dacă elementul există, metoda returnează true, în caz contrar returnează false:

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

Iterarea prin mulțime

Iterarea prin elementele mulțimii se realizează prin utilizarea metodei forEach():

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

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

Pentru a fi compatibil cu array-urile, care au, de asemenea, metoda forEach, în această metodă se transmite o funcție de callback care primește trei parametri. În cazul mulțimii, primul și al doilea parametru reprezintă elementul curent iterat, iar al treilea parametru reprezintă mulțimea iterată. În acest context, este folosit doar primul parametru.

De asemenea, pentru a itera prin mulțime, se poate utiliza și bucla for...of:

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

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

Obținerea unui Iterator

Obiectul Set are, de asemenea, câteva metode care returnează un iterator, mai exact obiectul SetIterator. Acestea sunt metodele values(), keys() și 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}

Prin urmare, iteratorul returnat poate fi folosit pentru a obține obiectele din mulțime:

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}

Ștergerea elementelor duplicate dintr-un array

Restricția obiectului Set de a stoca valori unice permite utilizarea eficientă într-o serie de operațiuni. De exemplu, eliminarea elementelor duplicate dintr-un 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"]

Aici, pentru a crea un nou array cu elemente unice, se utilizează funcția Array.from(), care primește ca argument obiectul Set.