Set

Set-Objekte sind Sammlungen von Werten. Ein Wert im Set darf nur einmal vorkommen; er ist einzigartig in der Sammlung des Sets. Sie können die Elemente eines Sets in der Einfügereihenfolge durchlaufen. Die Einfügereihenfolge entspricht der Reihenfolge, in der jedes Element mit der Methode add() erfolgreich in das Set eingefügt wurde (das heißt, es war kein identisches Element bereits im Set vorhanden, als add() aufgerufen wurde).

Die Spezifikation erfordert, dass Sets so implementiert werden, "dass sie im Durchschnitt Zugriffszeiten bieten, die unterlinear zur Anzahl der Elemente in der Sammlung sind". Daher könnte es intern als Hashtabelle (mit O(1)-Suchzeit), Suchbaum (mit O(log(N))-Suchzeit) oder jede andere Datenstruktur dargestellt werden, solange die Komplexität besser als O(N) ist.

Die Wertgleichheit basiert auf dem SameValueZero-Algorithmus. (Früher wurde SameValue verwendet, das 0 und -0 als unterschiedlich behandelte. Prüfen Sie die Browser-Kompatibilität.) Dies bedeutet, dass NaN als gleich zu NaN betrachtet wird (obwohl NaN !== NaN) und alle anderen Werte gemäß der Semantik des ===-Operators als gleich gelten.

Die Methode has prüft, ob ein Wert im Set vorhanden ist, und verwendet dabei einen Ansatz, der im Durchschnitt schneller ist, als die meisten der zuvor hinzugefügten Elemente zu testen. Insbesondere ist es im Durchschnitt schneller als die Methode Array.prototype.includes, wenn ein Array die gleiche length wie die size eines Sets hat.

Das Set-Objekt bietet einige Methoden, die es Ihnen ermöglichen, Sets wie mathematische Operationen zu komponieren. Diese Methoden umfassen:

Methode	Rückgabetyp	Mathematisches Äquivalent	Venn-Diagramm
A.difference(B)	Set	$A\setminus B$
A.intersection(B)	Set	$A\cap B$
A.symmetricDifference(B)	Set	$(A\setminus B)\cup(B\setminus A)$
A.union(B)	Set	$A\cup B$
A.isDisjointFrom(B)	Boolean	$A\cap B = \empty$
A.isSubsetOf(B)	Boolean	$A\subseteq B$
A.isSupersetOf(B)	Boolean	$A\supseteq B$

Um sie allgemeiner anwendbar zu machen, akzeptieren diese Methoden nicht nur Set-Objekte, sondern alles, was set-artig ist.

Alle Set-Zusammensetzungsmethoden erfordern, dass this eine tatsächliche Set-Instanz ist, aber ihre Argumente müssen nur set-artig sein. Ein set-artiges Objekt ist ein Objekt, das Folgendes bereitstellt:

• Eine size-Eigenschaft, die eine Zahl enthält.
• Eine has()-Methode, die ein Element nimmt und einen Boolean zurückgibt.
• Eine keys()-Methode, die einen Iterator der Elemente im Set zurückgibt.

Zum Beispiel sind Map-Objekte set-artig, da sie auch size, has() und keys() haben, sodass sie sich in Set-Methoden wie Sets von Schlüsseln verhalten:

const a = new Set([1, 2, 3]);
const b = new Map([
  [1, "one"],
  [2, "two"],
  [4, "four"],
]);
console.log(a.union(b)); // Set(4) {1, 2, 3, 4}

Arrays sind nicht set-artig, weil sie keine has()-Methode oder die size-Eigenschaft haben und ihre keys()-Methode Indizes statt Elemente erzeugt. WeakSet-Objekte sind auch nicht set-artig, weil sie keine keys()-Methode haben.

Browser-Set-artige Objekte (oder "Set-artige Objekte") sind Web API-Schnittstellen, die sich in vielerlei Hinsicht wie ein Set verhalten.

Genau wie Set können Elemente in der gleichen Reihenfolge durchlaufen werden, in der sie dem Objekt hinzugefügt wurden. Set-artige Objekte und Set haben auch Eigenschaften und Methoden, die denselben Namen und Verhalten haben. Im Gegensatz zu Set erlauben sie jedoch nur einen spezifischen vordefinierten Typ für jeden Eintrag.

Die erlaubten Typen sind in der Spezifikation IDL-Definition festgelegt. Zum Beispiel ist GPUSupportedFeatures ein Set-artiges Objekt, das Zeichenfolgen als Schlüssel/Werte verwenden muss. Dies ist in der Spezifikation IDL unten definiert:

interface GPUSupportedFeatures {
  readonly setlike<DOMString>;
};

Set-artige Objekte sind entweder schreibgeschützt oder lese-schreibfähig (siehe das readonly-Schlüsselwort in der IDL oben).

• Schreibgeschützte Set-artige Objekte haben die Eigenschaft size und die Methoden: entries(), forEach(), has(), keys(), values() und [Symbol.iterator]().
• Beschreibbare Set-artige Objekte haben zusätzlich die Methoden: clear(), delete() und add().

Die Methoden und Eigenschaften haben dasselbe Verhalten wie die entsprechenden Entitäten in Set, mit Ausnahme der Einschränkung des Typs der Einträge.

Im Folgenden sind Beispiele für schreibgeschützte Set-artige Browser-Objekte:

• GPUSupportedFeatures
• XRAnchorSet

Im Folgenden sind Beispiele für schreibbare Set-artige Browser-Objekte:

• CustomStateSet
• FontFaceSet
• Highlight

Set()

Erstellt ein neues Set-Objekt.

Set[Symbol.species]

Die Konstrukturfunktion, die verwendet wird, um abgeleitete Objekte zu erstellen.

Diese Eigenschaften sind auf Set.prototype definiert und werden von allen Set-Instanzen geteilt.

Set.prototype.constructor

Die Konstrukturfunktion, die das Instanzobjekt erstellt hat. Für Set-Instanzen ist der Anfangswert der Set-Konstruktor.

Set.prototype.size

Gibt die Anzahl der Werte im Set-Objekt zurück.

Set.prototype[Symbol.toStringTag]

Der Anfangswert der [Symbol.toStringTag]-Eigenschaft ist die Zeichenkette "Set". Diese Eigenschaft wird in Object.prototype.toString() verwendet.

Set.prototype.add()

Fügt ein neues Element mit einem angegebenen Wert in ein Set-Objekt ein, wenn nicht bereits ein Element mit demselben Wert im Set vorhanden ist.

Set.prototype.clear()

Entfernt alle Elemente aus dem Set-Objekt.

Set.prototype.delete()

Entfernt das mit dem value assoziierte Element und gibt einen Boolean zurück, der angibt, ob ein Element erfolgreich entfernt wurde oder nicht. Set.prototype.has(value) wird anschließend false zurückgeben.

Set.prototype.difference()

Nimmt ein Set und gibt ein neues Set zurück, das Elemente in diesem Set, aber nicht im gegebenen Set enthält.

Set.prototype.entries()

Gibt ein neues Iterator-Objekt zurück, das ein Array aus [value, value] für jedes Element im Set-Objekt in Einfügereihenfolge enthält. Dies ähnelt dem Map-Objekt, sodass jeder Eintrag denselben key wie seinen value für ein Set hat.

Set.prototype.forEach()

Ruft callbackFn einmal für jeden im Set-Objekt vorhandenen Wert in Einfügereihenfolge auf. Wenn ein thisArg-Parameter bereitgestellt wird, wird er als this-Wert für jede Ausführung von callbackFn verwendet.

Set.prototype.has()

Gibt einen Boolean zurück, der angibt, ob ein Element mit dem angegebenen Wert im Set-Objekt vorhanden ist oder nicht.

Set.prototype.intersection()

Nimmt ein Set und gibt ein neues Set zurück, das Elemente in sowohl diesem Set als auch im gegebenen Set enthält.

Set.prototype.isDisjointFrom()

Nimmt ein Set und gibt einen Boolean zurück, der angibt, ob dieses Set keine gemeinsamen Elemente mit dem gegebenen Set hat.

Set.prototype.isSubsetOf()

Nimmt ein Set und gibt einen Boolean zurück, der angibt, ob alle Elemente dieses Sets im gegebenen Set vorhanden sind.

Set.prototype.isSupersetOf()

Nimmt ein Set und gibt einen Boolean zurück, der angibt, ob alle Elemente des gegebenen Sets in diesem Set vorhanden sind.

Set.prototype.keys()

Ein Alias für Set.prototype.values().

Set.prototype.symmetricDifference()

Nimmt ein Set und gibt ein neues Set zurück, das Elemente enthält, die entweder in diesem Set oder im gegebenen Set, aber nicht in beiden vorhanden sind.

Set.prototype.union()

Nimmt ein Set und gibt ein neues Set zurück, das Elemente enthält, die entweder in diesem oder in beiden diesem Set und dem gegebenen Set vorhanden sind.

Set.prototype.values()

Gibt ein neues Iterator-Objekt zurück, das die Werte für jedes Element im Set-Objekt in Einfügereihenfolge ausgibt.

Set.prototype[Symbol.iterator]()

Gibt ein neues Iterator-Objekt zurück, das die Werte für jedes Element im Set-Objekt in Einfügereihenfolge ausgibt.

Die Iteration über ein Set besucht Elemente in Einfügereihenfolge.

for (const item of mySet1) {
  console.log(item);
}
// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5

for (const item of mySet1.keys()) {
  console.log(item);
}
// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5

for (const item of mySet1.values()) {
  console.log(item);
}
// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5

// key and value are the same here
for (const [key, value] of mySet1.entries()) {
  console.log(key);
}
// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5

// Convert Set object to an Array object, with Array.from
const myArr = Array.from(mySet1); // [1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2}, 5]

// the following will also work if run in an HTML document
mySet1.add(document.body);
mySet1.has(document.querySelector("body")); // true

// converting between Set and Array
const mySet2 = new Set([1, 2, 3, 4]);
console.log(mySet2.size); // 4
console.log([...mySet2]); // [1, 2, 3, 4]

// intersect can be simulated via
const intersection = new Set([...mySet1].filter((x) => mySet2.has(x)));

// difference can be simulated via
const difference = new Set([...mySet1].filter((x) => !mySet2.has(x)));

// Iterate set entries with forEach()
mySet2.forEach((value) => {
  console.log(value);
});
// 1
// 2
// 3
// 4

• Polyfill von Set in core-js
• Map
• WeakMap
• WeakSet