WeakSet

Beschreibung

Werte in WeakSets mssen garbage-collectierbar sein. Die meisten primitiven Datentypen knnen willkrlich erstellt werden und haben keine Lebensdauer, daher knnen sie nicht gespeichert werden. Objekte und nicht registrierte Symbole knnen gespeichert werden, da sie garbage-collectierbar sind.

Die Hauptunterschiede zum Set-Objekt sind:

• WeakSets sind Sammlungen von nur Objekten und Symbolen. Sie knnen keine beliebigen Werte beliebigen Typs enthalten, wie es bei Sets der Fall ist.

• Der WeakSet ist schwach, was bedeutet, dass Referenzen auf Objekte in einem WeakSet schwach gehalten werden. Wenn keine anderen Referenzen auf einen im WeakSet gespeicherten Wert existieren, knnen diese Werte garbage-collectiert werden.

  Hinweis: Dies bedeutet auch, dass es keine Liste der aktuell in der Sammlung gespeicherten Werte gibt. WeakSets sind nicht aufzhlbar.

Schlsselgleichheit

Wie bei regulren Sets basiert die Wertgleichheit auf dem SameValueZero-Algorithmus, der dem ===-Operator entspricht, da WeakSet nur Objekt- und Symbolwerte enthalten kann. Das bedeutet, dass bei Objektwerten die Gleichheit auf der Objektidentitt basiert. Sie werden anhand der Referenz verglichen, nicht anhand des Werts.

Konstruktor

WeakSet()

Erstellt ein neues WeakSet-Objekt.

Instanz-Eigenschaften

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

WeakSet.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Fr WeakSet-Instanzen ist der Anfangswert der WeakSet-Konstruktor.

WeakSet.prototype[Symbol.toStringTag]

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

Instanz-Methoden

WeakSet.prototype.add()

Fgt den angegebenen Wert in dieses Set ein, falls er nicht bereits vorhanden ist.

WeakSet.prototype.delete()

Entfernt den angegebenen Wert aus diesem Set, falls er sich im Set befindet.

WeakSet.prototype.has()

Gibt einen booleschen Wert zurck, der anzeigt, ob der angegebene Wert in diesem WeakSet vorhanden ist oder nicht.

Beispiele

Verwenden des WeakSet-Objekts

const ws = new WeakSet();
const foo = {};
const bar = {};

ws.add(foo);
ws.add(bar);

ws.has(foo); // true
ws.has(bar); // true

ws.delete(foo); // removes foo from the set
ws.has(foo); // false, foo has been removed
ws.has(bar); // true, bar is retained

Beachten Sie, dass foo !== bar. Obwohl sie hnliche Objekte sind, sind sie nicht dasselbe Objekt. Und so werden beide zum Set hinzugefgt.

Erkennen von zirkulren Referenzen

Funktionen, die sich rekursiv aufrufen, bentigen eine Mglichkeit, gegen zirkulre Datenstrukturen zu schtzen, indem sie verfolgen, welche Objekte bereits verarbeitet wurden.

WeakSets sind fr diesen Zweck ideal:

// Execute a callback on everything stored inside an object
function execRecursively(fn, subject, _refs = new WeakSet()) {
  // Avoid infinite recursion
  if (_refs.has(subject)) {
    return;
  }

  fn(subject);
  if (typeof subject === "object" && subject) {
    _refs.add(subject);
    for (const key in subject) {
      execRecursively(fn, subject[key], _refs);
    }
    _refs.delete(subject);
  }
}

const foo = {
  foo: "Foo",
  bar: {
    bar: "Bar",
  },
};

foo.bar.baz = foo; // Circular reference!
execRecursively((obj) => console.log(obj), foo);

Hier wird bei der ersten Ausfhrung ein WeakSet erstellt und bei jedem nachfolgenden Funktionsaufruf (unter Verwendung des internen _refs-Parameters) weitergegeben.

Die Anzahl der Objekte oder ihre Traversierung ist unwesentlich, daher ist ein WeakSet geeigneter (und leistungsfhiger) als ein Set zum Verfolgen von Objektreferenzen, insbesondere wenn eine sehr groe Anzahl von Objekten beteiligt ist.

Spezifikationen

Browser-Kompatibilitt

Siehe auch

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