WeakSet

Werte von WeakSets müssen speicherbereinigbar sein. Die meisten primitiven Datentypen können beliebig erstellt werden und haben keine Lebensdauer, sodass 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 von nur Objekten und Symbolen. Sie können keine beliebigen Werte enthalten, wie es Sets können.

• Das 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: Dies bedeutet auch, dass es keine Liste der aktuell in der Sammlung gespeicherten Werte gibt. WeakSets sind nicht aufzählbar.

Funktionen, die sich selbst rekursiv aufrufen, benötigen eine Möglichkeit, sich gegen zyklische Datenstrukturen abzusichern, indem sie verfolgen, welche Objekte bereits verarbeitet wurden.

WeakSets sind ideal für diesen Zweck:

// 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 Ausführung ein WeakSet erstellt und bei jedem folgenden Funktionsaufruf (unter Verwendung des internen Parameters _refs) weitergegeben.

Die Anzahl der Objekte oder deren Traversierreihenfolge ist unerheblich, daher ist ein WeakSet geeigneter (und leistungsfähiger) 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 zum WeakSet Objekt hinzu.

WeakSet.prototype.delete()

Entfernt value aus dem WeakSet. WeakSet.prototype.has(value) wird anschließend false zurückgeben.

WeakSet.prototype.has()

Gibt einen booleschen Wert 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. Obwohl sie ähnliche Objekte sind, sind sie nicht dasselbe Objekt. Und so werden beide zur Menge hinzugefügt.

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