Was sind WeakMaps in JS?

Eine WeakMap in JavaScript ist eine Sammlung von Schlüssel-Wert-Paaren, bei denen die Schlüssel Objekte sein müssen, und die Verweise auf diese Tasten sind „schwach“. Dies bedeutet, dass, wenn keine anderen Verweise auf ein Schlüsselobjekt vorhanden sind, dieses in den Garbage Collection-Speicher aufgenommen werden kann, auch wenn es sich noch in der WeakMap befindet.

---

Hauptfunktionen

1. Schlüssel müssen Objekte sein:

   • Primitive Werte (wie Zahlen, Zeichenfolgen oder boolesche Werte) können nicht als Schlüssel verwendet werden.
   • Als Schlüssel sind nur Objekte und Funktionen zulässig.

2. Schwache Referenzen:

   • Die Schlüsselobjekte in einer WeakMap werden schwach gehalten.
   • Wenn keine weiteren Verweise auf einen Schlüssel vorhanden sind, wird das Schlüssel-Wert-Paar automatisch aus der WeakMap entfernt.

3. Nicht iterierbar:

   • WeakMap verfügt nicht über Methoden wie forEach und kann nicht mit Konstrukten wie for...of oder Object.keys() durchlaufen werden.
   • Das liegt daran, dass der Garbage-Collection-Prozess es unmöglich macht, alle Einträge zuverlässig aufzulisten.

4. Nützlich für private Daten:

   • WeakMap wird oft verwendet, um private Daten mit Objekten zu verknüpfen, ohne sie offenzulegen.

---

Syntax

const weakMap = new WeakMap();

---

Methoden

Method	Description
weakMap.set(key, value)	Adds a new key-value pair or updates an existing key.
weakMap.get(key)	Retrieves the value associated with the key.
weakMap.has(key)	Checks if the key exists in the WeakMap.
weakMap.delete(key)	Removes the key-value pair associated with the key.

---

Beispiele

Grundlegende Verwendung

const weakMap = new WeakMap();

Müllabfuhr

const weakMap = new WeakMap();

const obj1 = { name: "Alice" };
const obj2 = { name: "Bob" };

// Adding key-value pairs
weakMap.set(obj1, "Data for Alice");
weakMap.set(obj2, "Data for Bob");

// Accessing values
console.log(weakMap.get(obj1)); // Output: "Data for Alice"

// Checking existence
console.log(weakMap.has(obj2)); // Output: true

// Removing a key-value pair
weakMap.delete(obj2);
console.log(weakMap.has(obj2)); // Output: false

---

Anwendungsfälle

1. Private Datenspeicherung:
   • Verknüpfen Sie private Daten mit einem Objekt und stellen Sie sicher, dass sie nicht an anderer Stelle offengelegt oder zugänglich sind.

let obj = { key: "value" };
const weakMap = new WeakMap();
weakMap.set(obj, "Some data");

// Remove all references to `obj`
obj = null;

// The `WeakMap` entry for `obj` is automatically removed by garbage collection.

1. DOM-Knoten-Metadaten:
   • Speichern Sie Metadaten im Zusammenhang mit DOM-Elementen, ohne die Speicherbereinigung zu verhindern.

const privateData = new WeakMap();

class User {
    constructor(name) {
        privateData.set(this, { name });
    }

    getName() {
        return privateData.get(this).name;
    }
}

const user = new User("Alice");
console.log(user.getName()); // Output: "Alice"

---

Vorteile

• Speichereffizienz: Das automatische Entfernen nicht referenzierter Schlüssel trägt zur effektiven Speicherverwaltung bei.
• Kapselung: Bietet eine Möglichkeit, Daten privat und sicher zu speichern.
• Keine Speicherlecks: Verhindert versehentliche Speicherlecks, indem die Speicherbereinigung von Schlüsseln ermöglicht wird.

---

Einschränkungen

1. Nicht iterierbar:
   • Es können nicht alle Schlüssel oder Werte aufgelistet werden.
2. Nur ​​Objektschlüssel:
   • Primitive Schlüssel werden nicht unterstützt.
3. Begrenzte Anwendungsfälle:
   • Nicht geeignet für Szenarien, die eine Aufzählung oder vollständigen Zugriff auf gespeicherte Daten erfordern.

Zusammenfassend ist WeakMap eine spezialisierte Sammlung, die für Szenarien entwickelt wurde, in denen schwache Referenzen und private Assoziationen erforderlich sind.

Unterschied zwischen Map und WeakMap

Der Hauptunterschied zwischen Map und WeakMap in JavaScript liegt in der Handhabung von Schlüsseln, der Speicherbereinigung und der Funktionalität. Hier ist ein detaillierter Vergleich:

---

Hauptunterschiede

Funktion

Feature	Map	WeakMap
Key Types	Keys can be any type: objects, primitives.	Keys must be objects.
Garbage Collection	Does not rely on garbage collection; keys persist.	Keys are held weakly and can be garbage-collected.
Iteration	Iterable (can use for...of, forEach, etc.).	Not iterable (cannot list keys or values).
Size Property	Has a size property to get the number of entries.	No size property available.
Use Case	General-purpose key-value storage.	Specialized for associating metadata or private data with objects.
Performance	Slightly slower due to strong key references.	Faster for memory-sensitive operations due to weak references.

Karte WeakMap Schlüsseltypen Schlüssel können jeden Typ haben: Objekte, Grundelemente. Schlüssel müssen Objekte sein. Garbage Collection Verlässt sich nicht auf die Speicherbereinigung; Schlüssel bleiben bestehen. Schlüssel werden nur schwach gespeichert und können im Müll gesammelt werden. Iteration Iterierbar (kann for...of, forEach usw. verwenden). Nicht iterierbar (Schlüssel oder Werte können nicht aufgelistet werden). Größeneigenschaft Verfügt über eine Größeneigenschaft, um die Anzahl der Einträge zu ermitteln. Keine Größeneigenschaft verfügbar. Anwendungsfall Allzweck-Schlüsselwertspeicher. Spezialisiert für die Verknüpfung von Metadaten oder privaten Daten mit Objekten. Leistung Etwas langsamer aufgrund starker Schlüsselreferenzen. Schneller für speicherempfindliche Vorgänge aufgrund schwacher Referenzen.

---

Funktionsvergleich

1. Schlüsseltypen

• Map: Akzeptiert sowohl Objekte als auch primitive Typen (wie Zeichenfolgen, Zahlen, Boolesche Werte) als Schlüssel.
• WeakMap: Akzeptiert nur Objekte als Schlüssel. Primitive sind nicht erlaubt.

const weakMap = new WeakMap();

---

2. Müllabfuhr

• Karte: Behält einen starken Verweis auf den Schlüssel bei und verhindert so, dass er im Garbage Collection-Speicher landet, solange er in der Karte vorhanden ist.
• WeakMap: Enthält eine schwache Referenz auf den Schlüssel und ermöglicht die Müllsammlung, wenn keine anderen Referenzen vorhanden sind.

const weakMap = new WeakMap();

const obj1 = { name: "Alice" };
const obj2 = { name: "Bob" };

// Adding key-value pairs
weakMap.set(obj1, "Data for Alice");
weakMap.set(obj2, "Data for Bob");

// Accessing values
console.log(weakMap.get(obj1)); // Output: "Data for Alice"

// Checking existence
console.log(weakMap.has(obj2)); // Output: true

// Removing a key-value pair
weakMap.delete(obj2);
console.log(weakMap.has(obj2)); // Output: false

---

3. Iteration

• Karte: Iterierbar. Sie können for...of, .keys(), .values(), .entries() oder .forEach() verwenden, um den Inhalt zu durchlaufen.
• WeakMap: Nicht iterierbar. Es gibt keine Methoden zum Abrufen aller Schlüssel, Werte oder Einträge.

let obj = { key: "value" };
const weakMap = new WeakMap();
weakMap.set(obj, "Some data");

// Remove all references to `obj`
obj = null;

// The `WeakMap` entry for `obj` is automatically removed by garbage collection.

---

4. Größeneigenschaft

• Map: Stellt eine Größeneigenschaft bereit, die die Anzahl der Einträge zurückgibt.
• WeakMap: Verfügt über keine Größeneigenschaft, da sie nicht iterierbar ist und Einträge schwach referenziert sind.

const privateData = new WeakMap();

class User {
    constructor(name) {
        privateData.set(this, { name });
    }

    getName() {
        return privateData.get(this).name;
    }
}

const user = new User("Alice");
console.log(user.getName()); // Output: "Alice"

---

Anwendungsfälle

Wann man die Karte verwenden sollte

• Allzweck-Schlüsselwertspeicher.
• Szenarien, die eine Aufzählung oder Iteration von Schlüsseln und Werten erfordern.
• Schlüssel können Grundelemente oder Objekte sein.

Beispiel:

const metadata = new WeakMap();

function trackElement(element) {
    metadata.set(element, { clicks: 0 });
}

function incrementClicks(element) {
    const data = metadata.get(element);
    if (data) {
        data.clicks++;
    }
}

const button = document.createElement("button");
trackElement(button);
incrementClicks(button);
console.log(metadata.get(button)); // Output: { clicks: 1 }

Wann sollte man WeakMap verwenden?

• Wenn Sie Metadaten oder private Daten mit Objekten verknüpfen müssen, ohne die Speicherbereinigung zu verhindern.
• Ideal für Fälle, in denen die Lebensdauer des Schlüssels die Lebensdauer des zugehörigen Werts bestimmen soll.

Beispiel:

const map = new Map();
map.set(1, "value"); // Allowed
map.set("key", "value"); // Allowed
map.set({}, "value"); // Allowed

const weakMap = new WeakMap();
weakMap.set({}, "value"); // Allowed
weakMap.set(1, "value"); // TypeError: Invalid value used as weak map key

---

Zusammenfassung

Funktion

Feature	Map	WeakMap
Flexibility	General-purpose, flexible.	Specialized, limited use case.
Performance	Persistent key references.	Memory-efficient with weak references.
Suitability	Iteration and long-term storage.	Private data and ephemeral relationships.

Karte WeakMap Flexibilität Allgemein einsetzbar, flexibel. Spezialisierter, begrenzter Anwendungsfall. Leistung Persistente Schlüsselreferenzen. Speichereffizient mit schwachen Referenzen. Eignung Iteration und Langzeitspeicherung. Private Daten und kurzlebige Beziehungen.

Das obige ist der detaillierte Inhalt vonWas sind WeakMaps in JS?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!