I nuovi metodi di Set in JavaScript: union, intersection, difference e gli altri

Q: Questi metodi modificano i set originali?

No — union, intersection, difference e symmetricDifference restituiscono tutti un Set nuovo di zecca. I tre metodi predicato (isSubsetOf, isSupersetOf, isDisjointFrom) restituiscono un booleano e non toccano affatto nessuno dei due set.

Q: Serve ancora una libreria come le utility set di lodash?

Per queste operazioni specifiche, no — i metodi nativi di Set coprono direttamente i casi comuni. Le librerie restano utili per cose non supportate nativamente, come operazioni insiemistiche ordinate che preservano un ordinamento specifico nel risultato.

Per anni, fare teoria degli insiemi di base in JavaScript — unione, intersezione, “cosa c’è in A ma non in B” — significava ricorrere a Array.filter()/includes() a mano, o importare una piccola libreria di utility. Non serve più: i motori JavaScript moderni ora offrono queste operazioni nativamente su Set.

ℹ️ Disponibilità

Questi metodi sono arrivati nelle versioni recenti di Chrome, Firefox, Safari e Node.js. Verifica i tuoi runtime target prima di affidartici senza polyfill — il supporto è ampio nel 2026 ma non universale sugli ambienti più vecchi che potresti dover ancora supportare.

Il vecchio modo: operazioni insiemistiche basate su array

Prima che esistessero questi metodi, un’unione o un’intersezione significava scrivere questo a mano ogni volta:

function union(a, b) {
  return new Set([...a, ...b]);
}

function intersection(a, b) {
  return new Set([...a].filter((x) => b.has(x)));
}

function difference(a, b) {
  return new Set([...a].filter((x) => !b.has(x)));
}

Corretto, ma verboso, e facile da sbagliare in modo sottile (unione senza deduplicazione, intersezione con complessità O(n²) quando entrambi gli input sono grandi). I nuovi metodi sono sia più concisi sia meglio ottimizzati internamente.

I nuovi metodi

const admin = new Set(["alice", "bob", "carol"]);
const editor = new Set(["bob", "carol", "dave"]);

admin.union(editor);
// Set(4) { 'alice', 'bob', 'carol', 'dave' }

admin.intersection(editor);
// Set(2) { 'bob', 'carol' }

admin.difference(editor);
// Set(1) { 'alice' } — in admin ma non in editor

admin.symmetricDifference(editor);
// Set(2) { 'alice', 'dave' } — in esattamente uno dei due set

admin.isSubsetOf(editor); // false
admin.isSupersetOf(new Set(["bob"])); // true
admin.isDisjointFrom(new Set(["zara"])); // true — nessun elemento in comune

Ognuno di questi si legge esattamente per quello che fa — nessuna callback di filter da interpretare, nessun rischio di modificare accidentalmente uno dei set di input (union, intersection, difference e symmetricDifference restituiscono tutti un nuovo Set, lasciando gli originali intatti).

Un esempio pratico: confrontare set di permessi

Questo è il tipo di codice che prima richiedeva gli helper manuali sopra, e ora si legge quasi come il requisito stesso:

function getPermissionChanges(currentPermissions, requestedPermissions) {
  return {
    added: requestedPermissions.difference(currentPermissions),
    removed: currentPermissions.difference(requestedPermissions),
    unchanged: currentPermissions.intersection(requestedPermissions),
  };
}

const current = new Set(["read", "write"]);
const requested = new Set(["write", "delete"]);

getPermissionChanges(current, requested);
// { added: Set {'delete'}, removed: Set {'read'}, unchanged: Set {'write'} }

Riferimento dei metodi

Metodo	Restituisce
`a.union(b)`	Elementi in `a` o `b` (o entrambi)
`a.intersection(b)`	Elementi sia in `a` sia in `b`
`a.difference(b)`	Elementi in `a` ma non in `b`
`a.symmetricDifference(b)`	Elementi in esattamente uno tra `a` e `b`
`a.isSubsetOf(b)`	`true` se ogni elemento di `a` è in `b`
`a.isSupersetOf(b)`	`true` se ogni elemento di `b` è in `a`
`a.isDisjointFrom(b)`	`true` se `a` e `b` non condividono elementi

💡 Consiglio

Tutti e sette i metodi accettano come argomento qualsiasi oggetto “set-like”, non solo un vero Set — un oggetto con una proprietà size e metodi has()/keys() funziona altrettanto bene, utile se stai interagendo con una libreria che modella un proprio tipo di collezione.

FAQ

❓ Questi metodi modificano i set originali?

No — union, intersection, difference e symmetricDifference restituiscono tutti un Set nuovo di zecca. I tre metodi predicato (isSubsetOf, isSupersetOf, isDisjointFrom) restituiscono un booleano e non toccano affatto nessuno dei due set.

❓ È più veloce della versione manuale basata su array?

Generalmente sì — i motori possono implementare queste operazioni con una complessità migliore della O(n × m) che una combinazione filter+includes spesso ha, specialmente per set grandi. Non micro-ottimizzare attorno a questo, ma ora è un default ragionevole invece di loop scritti a mano.

❓ Serve ancora una libreria come le utility set di lodash?

Per queste operazioni specifiche, no — i metodi nativi di Set coprono direttamente i casi comuni. Le librerie restano utili per cose non supportate nativamente, come operazioni insiemistiche ordinate che preservano un ordinamento specifico nel risultato.

Conclusione

Le operazioni native di Set sostituiscono una classe di funzioni di utility scritte a mano che praticamente ogni codebase JavaScript finisce per accumulare. union, intersection, difference, symmetricDifference, e i tre predicati subset/superset/disjoint coprono la stragrande maggioranza dei confronti insiemistici reali — usali direttamente invece di scrivere helper filter+includes da zero.

Riferimenti