Set.prototype.union() — Methode · JavaScript-Referenz

Signatur

Set.prototype.union(other)

Beschreibung

union() bildet die Vereinigungsmenge (A ∪ B): Das Ergebnis enthält jedes Element, das in der aufrufenden Menge, in other oder in beiden vorkommt, und zwar genau einmal. Keine der beiden Ausgangsmengen wird verändert, es entsteht immer ein neues Set.

Die Reihenfolge ist festgelegt: Zuerst kommen alle Elemente der aufrufenden Menge in ihrer Einfügereihenfolge, danach die Elemente aus other, die noch nicht enthalten waren. Gleichheit wird wie überall bei Set nach dem Algorithmus SameValueZero geprüft. NaN gilt also als gleich NaN, und +0 ist gleich -0. Objekte werden über ihre Referenz verglichen, nicht über ihren Inhalt.

other muss kein echtes Set sein. Es genügt ein mengenartiges Objekt, also eines mit einer numerischen Eigenschaft size sowie den Methoden has() und keys(). Eine Map funktioniert deshalb ebenfalls, dabei werden ihre Schlüssel übernommen. Ein Array wird dagegen nicht akzeptiert.

Typische Einsatzfälle sind das Zusammenführen von Berechtigungen, Tags, IDs oder Filtern aus mehreren Quellen, ohne dass dabei Duplikate entstehen. Bisher schrieb man dafür new Set([...a, ...b]).

Parameter

Name	Typ	Default	Beschreibung
$other Pflicht	Set \| Map \| mengenartiges Objekt		Die Menge, die mit der aufrufenden Menge vereinigt wird. Sie braucht eine Eigenschaft `size` (Zahl, nicht `NaN`) sowie die Methoden `has()` und `keys()`. Andernfalls wird ein `TypeError` bzw. ein `RangeError` ausgelöst.

Rückgabewert

Typ

Set

Beschreibung

Ein neues Set mit allen Elementen aus beiden Mengen, ohne Duplikate. Zuerst stehen die Elemente von this, danach die neuen Elemente aus other.

Beispiele

Einfache Vereinigungsmenge

const gerade = new Set([2, 4, 6, 8]);
const quadrate = new Set([1, 4, 9]);

const ergebnis = gerade.union(quadrate);
console.log(ergebnis);
console.log(gerade.size); // Original bleibt unverändert

Set(6) { 2, 4, 6, 8, 1, 9 } 4

Berechtigungen aus mehreren Rollen zusammenführen

const rollen = {
  redakteur: new Set(['lesen', 'schreiben']),
  moderator: new Set(['lesen', 'loeschen', 'sperren']),
  gast: new Set(['lesen'])
};

const nutzerRollen = ['redakteur', 'moderator'];

const rechte = nutzerRollen
  .map((rolle) => rollen[rolle])
  .reduce((gesamt, set) => gesamt.union(set), new Set());

console.log([...rechte]);
console.log(rechte.has('loeschen'));

[ 'lesen', 'schreiben', 'loeschen', 'sperren' ] true

Map als mengenartiges Argument und Array-Fallstrick

const tags = new Set(['js', 'css']);
const zaehler = new Map([['html', 3], ['js', 7]]);

// Bei einer Map werden die Schlüssel verwendet
console.log(tags.union(zaehler));

// Arrays sind nicht mengenartig, sie haben kein size/has()
try {
  tags.union(['html', 'svg']);
} catch (err) {
  console.log(err.name);
}

// Lösung: Array vorher in ein Set umwandeln
console.log(tags.union(new Set(['html', 'svg'])));

Set(3) { 'js', 'css', 'html' } TypeError Set(4) { 'js', 'css', 'html', 'svg' }

Fallback für ältere Umgebungen

const vereinige = (a, b) =>
  typeof a.union === 'function' ? a.union(b) : new Set([...a, ...b.keys()]);

const a = new Set([1, 2]);
const b = new Set([2, 3]);
console.log(vereinige(a, b));

Set(3) { 1, 2, 3 }

// Wichtig · Fallstricke

Kompatibilität: Die Methode gehört seit 2024 zur Baseline und wird in Chrome/Edge 122+, Firefox 127+, Safari 17+ und Node.js 22+ unterstützt. Für ältere Umgebungen gibt es Polyfills, etwa core-js, oder man nutzt new Set([...a, ...b]).
Keine Arrays: other muss mengenartig sein. Wer ein Array übergibt, bekommt einen TypeError, weil size fehlt.
Objekte werden über die Referenz verglichen: { id: 1 } und ein zweites { id: 1 } gelten als zwei verschiedene Elemente.
Unveränderlich: union() verändert die Ausgangsmengen nicht. Wer eine Menge direkt erweitern möchte, ruft add() in einer Schleife auf.
Unterklassen: Das Ergebnis ist immer ein einfaches Set, auch wenn die Methode auf einer Unterklasse von Set aufgerufen wird.
Die Laufzeit ist linear zur Summe beider Mengengrößen.

Siehe auch

Set.prototype.intersection() Set.prototype.difference() Set.prototype.symmetricDifference() Set.prototype.isSubsetOf() Set.prototype.isSupersetOf() Set.prototype.isDisjointFrom() Set