WeakMap

Schlüssel von WeakMaps müssen garbage-sammlungsfähig sein. Die meisten primitiven Datentypen können willkürlich erstellt werden und haben keine Lebensdauer, daher können sie nicht als Schlüssel verwendet werden. Objekte und nicht-registrierte Symbole können als Schlüssel verwendet werden, da sie garbage-sammlungsfähig sind.

Eine Map-API könnte in JavaScript mit zwei Arrays (eines für die Schlüssel, eines für die Werte) implementiert werden, die von den vier API-Methoden gemeinsam genutzt werden. Das Setzen von Elementen in dieser Map würde bedeuten, dass gleichzeitig ein Schlüssel und ein Wert an das Ende jedes dieser Arrays angehängt werden. Dadurch würden die Indizes des Schlüssels und des Wertes beiden Arrays entsprechen. Um Werte aus der Map zu erhalten, müsste durch alle Schlüssel iteriert werden, um eine Übereinstimmung zu finden, und dann der Index dieser Übereinstimmung verwendet werden, um den entsprechenden Wert aus dem Array der Werte abzurufen.

Eine solche Implementierung hätte zwei Hauptnachteile:

1. Der erste Nachteil ist ein O(n)-Set- und Suchvorgang (n ist die Anzahl der Schlüssel in der Map), da beide Operationen durch die Liste der Schlüssel iterieren müssen, um einen passenden Wert zu finden.
2. Der zweite Nachteil ist ein Speicherleck, da die Arrays sicherstellen, dass Referenzen auf jeden Schlüssel und jeden Wert unbegrenzt beibehalten werden. Diese Referenzen verhindern, dass die Schlüssel vom Garbage Collector gesammelt werden, selbst wenn es keine anderen Referenzen auf das Objekt gibt. Dies würde auch verhindern, dass die entsprechenden Werte gesammelt werden.

Im Gegensatz dazu verweist in einer WeakMap ein Schlüsselobjekt stark auf seinen Inhalt, solange der Schlüssel nicht vom Garbage Collector gesammelt wird, aber ab dann schwach. Daher:

• verhindert eine WeakMap nicht die Garbage Collection, die letztendlich Referenzen auf das Schlüsselobjekt entfernt
• erlaubt eine WeakMap die Garbage Collection von Werten, wenn ihre Schlüsselobjekte nicht von einem anderen Ort als einer WeakMap referenziert werden

Eine WeakMap kann ein besonders nützliches Konstrukt sein, wenn Schlüssel zu Informationen über den Schlüssel selbst abgebildet werden, die nur wertvoll sind, solange der Schlüssel nicht vom Garbage Collector gesammelt wurde.

Da eine WeakMap jedoch nicht erlaubt, die Lebendigkeit ihrer Schlüssel zu beobachten, sind ihre Schlüssel nicht aufzählbar. Es gibt keine Methode, um eine Liste der Schlüssel zu erhalten. Wenn es eine gäbe, würde die Liste vom Zustand der Garbage Collection abhängen, was zu Nicht-Determinismus führt. Wenn Sie eine Liste von Schlüsseln benötigen, sollten Sie eine Map verwenden.

WeakMap()

Erstellt ein neues WeakMap-Objekt.

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

WeakMap.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Für WeakMap-Instanzen ist der anfängliche Wert der WeakMap-Konstruktor.

WeakMap.prototype[Symbol.toStringTag]

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

WeakMap.prototype.delete()

Entfernt einen Wert, der mit dem key verknüpft ist. WeakMap.prototype.has(key) wird danach false zurückgeben.

WeakMap.prototype.get()

Gibt den mit dem key verknüpften Wert zurück oder undefined, wenn es keinen gibt.

WeakMap.prototype.has()

Gibt einen Booleschen Wert zurück, der angibt, ob ein Wert mit dem key im WeakMap-Objekt verknüpft wurde oder nicht.

WeakMap.prototype.set()

Setzt den value für den key im WeakMap-Objekt. Gibt das WeakMap-Objekt zurück.

Entwickler können eine WeakMap verwenden, um privaten Daten mit einem Objekt zu verknüpfen, mit folgenden Vorteilen:

• Im Vergleich zu einer Map hält eine WeakMap keine starken Referenzen zu dem Objekt, das als Schlüssel verwendet wird, so dass die Metadaten die gleiche Lebensdauer wie das Objekt selbst haben und Speicherlecks vermieden werden.
• Im Vergleich zur Verwendung nicht-auflistbarer und/oder Symbol-Eigenschaften ist eine WeakMap extern zum Objekt und es gibt keinen Weg für Benutzer, die Metadaten durch reflektierende Methoden wie Object.getOwnPropertySymbols abzurufen.
• Im Vergleich zu einem Closure kann dieselbe WeakMap für alle Instanzen wiederverwendet werden, die von einem Konstruktor erstellt wurden, was speichereffizienter ist und es verschiedenen Instanzen derselben Klasse ermöglicht, die privaten Mitglieder voneinander zu lesen.

let Thing;

{
  const privateScope = new WeakMap();
  let counter = 0;

  Thing = function () {
    this.someProperty = "foo";

    privateScope.set(this, {
      hidden:   counter,
    });
  };

  Thing.prototype.showPublic = function () {
    return this.someProperty;
  };

  Thing.prototype.showPrivate = function () {
    return privateScope.get(this).hidden;
  };
}

console.log(typeof privateScope);
// "undefined"

const thing = new Thing();

console.log(thing);
// Thing {someProperty: "foo"}

thing.showPublic();
// "foo"

thing.showPrivate();
// 1

Dies ist grob gleichwertig mit dem folgenden, unter Verwendung von privaten Feldern:

class Thing {
  static #counter = 0;
  #hidden;
  constructor() {
    this.someProperty = "foo";
    this.#hidden =   Thing.#counter;
  }
  showPublic() {
    return this.someProperty;
  }
  showPrivate() {
    return this.#hidden;
  }
}

console.log(thing);
// Thing {someProperty: "foo"}

thing.showPublic();
// "foo"

thing.showPrivate();
// 1

Eine WeakMap kann verwendet werden, um ein Objekt mit Metadaten zu verknüpfen, ohne die Lebensdauer des Objekts selbst zu beeinflussen. Dies ist dem Beispiel der privaten Mitglieder sehr ähnlich, da private Mitglieder ebenfalls als externe Metadaten modelliert sind, die nicht an der prototypischen Vererbung teilnehmen.

Dieser Anwendungsfall kann auf bereits erstellte Objekte erweitert werden. Beispielsweise möchten wir im Web möglicherweise zusätzliche Daten mit einem DOM-Element verknüpfen, auf die das DOM-Element später zugreifen kann. Ein gängiger Ansatz ist, die Daten als Eigenschaft anzuhängen:

const buttons = document.querySelectorAll(".button");
buttons.forEach((button) => {
  button.clicked = false;
  button.addEventListener("click", () => {
    button.clicked = true;
    const currentButtons = [...document.querySelectorAll(".button")];
    if (currentButtons.every((button) => button.clicked)) {
      console.log("All buttons have been clicked!");
    }
  });
});

Dieser Ansatz funktioniert, hat jedoch einige Fallstricke:

• Die clicked-Eigenschaft ist aufzählbar, sodass sie in Object.keys(button), for...in-Schleifen usw. angezeigt wird. Dies kann durch die Verwendung von Object.defineProperty() gemildert werden, macht den Code jedoch ausführlicher.
• Die clicked-Eigenschaft ist eine normale String-Eigenschaft, sodass sie von anderem Code zugegriffen und überschrieben werden kann. Dies kann durch die Verwendung eines Symbol-Schlüssels gemildert werden, aber der Schlüssel wäre immer noch über Object.getOwnPropertySymbols() zugänglich.

Die Verwendung einer WeakMap behebt diese Probleme:

const buttons = document.querySelectorAll(".button");
const clicked = new WeakMap();
buttons.forEach((button) => {
  clicked.set(button, false);
  button.addEventListener("click", () => {
    clicked.set(button, true);
    const currentButtons = [...document.querySelectorAll(".button")];
    if (currentButtons.every((button) => clicked.get(button))) {
      console.log("All buttons have been clicked!");
    }
  });
});

Hier kennt nur der Code, der Zugriff auf clicked hat, den geklickten Zustand jedes Buttons, und externer Code kann die Zustände nicht ändern. Wenn einer der Buttons aus dem DOM entfernt wird, werden die zugehörigen Metadaten automatisch vom Garbage Collector gesammelt.

Sie können Objekte, die an eine Funktion übergeben werden, mit dem Ergebnis der Funktion verknüpfen, sodass bei erneuter Übergabe desselben Objekts das zwischengespeicherte Ergebnis zurückgegeben werden kann, ohne die Funktion erneut ausführen zu müssen. Dies ist nützlich, wenn die Funktion rein ist (d. h. sie mutiert keine äußeren Objekte oder verursacht andere beobachtbare Seiteneffekte).

const cache = new WeakMap();
function handleObjectValues(obj) {
  if (cache.has(obj)) {
    return cache.get(obj);
  }
  const result = Object.values(obj).map(heavyComputation);
  cache.set(obj, result);
  return result;
}

Dies funktioniert nur, wenn der Eingang Ihrer Funktion ein Objekt ist. Selbst wenn der Eingang nie wieder übergeben wird, bleibt das Ergebnis für immer im Cache, solange der Schlüssel (Eingabe) existiert. Ein effektiverer Weg ist die Verwendung einer Map gepaart mit WeakRef-Objekten, die es Ihnen erlauben, jeden Eingabewert mit seinem jeweiligen (potenziell großen) Berechnungsergebnis zu verknüpfen. Weitere Details finden Sie im Beispiel WeakRefs and FinalizationRegistry.

• Polyfill von WeakMap in core-js
• Keyed Collections
• Hiding Implementation Details with ECMAScript 6 WeakMaps von Nick Fitzgerald (2014)
• Map
• Set
• WeakSet