WeakSet

Beschreibung

Werte in WeakSets müssen vom Garbage Collector bereinigt werden können. Die meisten primitiven Datentypen können beliebig erzeugt werden und haben keine Lebensdauer, weshalb sie nicht gespeichert werden können. Objekte und nicht registrierte Symbole können gespeichert werden, da sie vom Garbage Collector bereinigt werden können.

Die wichtigsten Unterschiede zum Set-Objekt sind:

• WeakSets sind Sammlungen, die nur Objekte und Symbole enthalten. Anders als Sets können sie keine beliebigen Werte anderer Typen enthalten.

• Ein WeakSet ist schwach: Referenzen auf Objekte in einem WeakSet werden schwach gehalten. Wenn keine anderen Referenzen auf einen im WeakSet gespeicherten Wert vorhanden sind, kann dieser Wert vom Garbage Collector bereinigt werden.

  Hinweis: Das bedeutet auch, dass es keine Liste der aktuell in der Sammlung gespeicherten Werte gibt. WeakSets sind nicht aufzählbar.

Gleichheit von Werten

Wie bei einem regulären Set basiert die Gleichheit von Werten auf dem SameValueZero-Algorithmus. Da WeakSet nur Objekte und Symbole enthalten kann, entspricht dies dem ===-Operator. Bei Objekten basiert die Gleichheit somit auf der Objektidentität: Sie werden anhand ihrer Referenz verglichen, nicht anhand ihres Werts.

Konstruktor

WeakSet()

Erstellt ein neues WeakSet-Objekt.

Instanzeigenschaften

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

WeakSet.prototype.constructor

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

WeakSet.prototype[Symbol.toStringTag]

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

Instanzmethoden

WeakSet.prototype.add()

Fügt den angegebenen Wert zu diesem Set hinzu, sofern er noch nicht vorhanden ist.

WeakSet.prototype.delete()

Entfernt den angegebenen Wert aus diesem Set, sofern er darin vorhanden ist.

WeakSet.prototype.has()

Gibt einen booleschen Wert zurück, der angibt, ob der angegebene Wert in diesem WeakSet vorhanden ist.

Beispiele

Das WeakSet-Objekt verwenden

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 gilt. Obwohl es sich um ähnliche Objekte handelt, sind sie nicht dasselbe Objekt. Daher werden beide zum Set hinzugefügt.

Zirkuläre Referenzen erkennen

Funktionen, die sich rekursiv selbst aufrufen, müssen sich vor zirkulären Datenstrukturen schützen können. Dazu verfolgen sie, welche Objekte bereits verarbeitet wurden.

WeakSets sind für 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 beim ersten Durchlauf ein WeakSet erstellt und bei jedem nachfolgenden Funktionsaufruf über den internen Parameter _refs weitergegeben.

Die Anzahl der Objekte und die Reihenfolge, in der sie durchlaufen werden, sind unerheblich. Daher eignet sich ein WeakSet zum Verfolgen von Objektreferenzen besser als ein Set und ist leistungsfähiger, insbesondere wenn sehr viele Objekte beteiligt sind.

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Polyfill für WeakSet in core-js
• Map
• Set
• WeakMap