WeakSet

Werte von WeakSets müssen speicherbereinigbar sein. Die meisten primitiven Datentypen können beliebig erstellt werden und haben keine Lebensdauer, weshalb sie nicht gespeichert werden können. Objekte und nicht registrierte Symbole können gespeichert werden, da sie speicherbereinigbar sind.

Die Hauptunterschiede zum Set-Objekt sind:

• WeakSets sind Sammlungen aus nur Objekten und Symbolen. Sie können keine willkürlichen Werte eines beliebigen Typs enthalten, wie es Sets können.

• 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, können diese Werte speicherbereinigt werden.

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

Funktionen, die sich rekursiv selbst aufrufen, benötigen eine Möglichkeit, sich gegen zirkuläre Datenstrukturen abzusichern, indem sie verfolgen, 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 ein WeakSet beim ersten Aufruf erstellt und mit jedem nachfolgenden Funktionsaufruf weitergegeben (mithilfe des internen _refs-Parameters).

Die Anzahl der Objekte oder deren Traversierungsreihenfolge ist irrelevant, daher ist ein WeakSet geeigneter (und performanter) als ein Set zum Verfolgen von Objektreferenzen, insbesondere wenn eine sehr große Anzahl von Objekten beteiligt ist.

WeakSet()

Erstellt ein neues WeakSet-Objekt.

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

WeakSet.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Für 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.

WeakSet.prototype.add()

Fügt value dem WeakSet-Objekt hinzu.

WeakSet.prototype.delete()

Entfernt value aus dem WeakSet. WeakSet.prototype.has(value) wird danach false zurückgeben.

WeakSet.prototype.has()

Gibt einen boolean zurück, der angibt, ob value im WeakSet-Objekt vorhanden ist oder nicht.

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. Auch wenn sie ähnliche Objekte sind, sind sie nicht dasselbe Objekt. Und so werden sie beide dem Set hinzugefügt.

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