TypeScript Set und WeakMap

TypeScript erbt die Set- und WeakMap-Datenstrukturen von JavaScript und bietet eine leistungsfähigere Typunterstützung.

Diese Datenstrukturen sind in Szenarien wie dem Umgang mit eindeutigen Wertemengen, Schlüssel-Wert-Paar-Zuordnungen und Caching sehr nützlich.


SVG-Diagramm: Set- und Map-Datenstrukturen Background Title Set and Map Data Structures Set A collection of values Values are unique and non-repeating Iterable add/has/delete WeakSet Weak references to objects Does not affect GC Not iterable add/has/delete Map A collection of key-value pairs Keys can be of any type Iterable set/get/has WeakMap Weak references to keys Keys must be objects Does not affect GC Not iterable Bottom section: Application Scenarios Application Scenarios Scenario Set: Deduplication, unique value sets Map: Key-value mapping, caching WeakMap/WeakSet: Memory optimization Arrow markers

Warum brauchen Sie Set und WeakMap

In der Entwicklung müssen wir häufig eindeutige Wertemengen und Schlüssel-Wert-Paar-Zuordnungen handhaben.

Set bietet automatische Deduplizierung für Sammlungen und ist dadurch praktischer als Arrays, wenn es um eindeutige Werte geht.

WeakSet und WeakMap verwenden schwache Referenzen und verhindern keine Garbage Collection, wodurch sie für Szenarien geeignet sind, in denen Speicherlecks vermieden werden müssen, wie z. B. beim Zwischenspeichern von DOM-Knoten.

Konzepterklärung:Set ist eine Sammlung von Werten, wobei die Werte eindeutig sind; Map ist eine Sammlung von Schlüssel-Wert-Paaren, wobei Schlüssel von beliebigem Typ sein können. WeakSet und WeakMap verwenden schwache Referenzen und beeinflussen die Garbage Collection nicht.


Set

Set ist eine Sammlung von Werten; Werte sind eindeutig und Duplikate sind nicht erlaubt.

Beispiel

// Ein Set erstellen, wobei der Elementtyp als number angegeben wird
var numbers = new Set<number>();

// Elemente hinzufügen
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(1); // Doppelte Werte werden ignoriert und nicht hinzugefügt

// Größe und Enthaltensein prüfen
console.log("Set-Größe: " + numbers.size);
console.log("Enthält 2: " + numbers.has(2));

// Über das Set iterieren
numbers.forEach(function(value) {
    console.log("Wert: " + value);
});

// In Array konvertieren
var arr = Array.from(numbers);
console.log("In Array umgewandelt: " + arr);

Ausgabe:

Set 大小: 3
是否包含 2: true
值: 1
值: 2
值: 3
转换为数组: 1,2,3

Deduplizierung:Set ignoriert automatisch doppelte Werte und eignet sich daher sehr gut zur Deduplizierung von Arrays.


Set-Typannotation

Sie können den Typ der Werte in einem Set explizit angeben.

Beispiel

// String-Set
// Nur Werte vom Typ String können hinzugefügt werden
var stringSet: Set<string> = new Set();
stringSet.add("a");
stringSet.add("b");

// Objekt-Set
// Definiere das Person-Interface
interface Person {
    name: string;
}
// Erstelle ein Set, das Person-Objekte speichert
var personSet: Set<Person> = new Set();
personSet.add({ name: "Alice" });
personSet.add({ name: "Bob" });

console.log("String-Set: " + Array.from(stringSet));
console.log("Objekt-Set-Größe: " + personSet.size);

Generics:Verwende dieSet<T>Syntax, um den Typ der Elemente in einem Set anzugeben.


WeakSet

WeakSet speichert Objektreferenzen, und die Referenzen sind schwache Referenzen (sie beeinflussen die Garbage Collection nicht).

Beispiel

// WeakSet kann nur Objekte speichern, keine primitiven Werte
var weakSet = new WeakSet();

// Objekte erstellen
var obj1 = { name: "Alice" };
var obj2 = { name: "Bob" };

// Objekte zum WeakSet hinzufügen
weakSet.add(obj1);
weakSet.add(obj2);

// Prüfen, ob es enthalten ist
console.log("Enthält obj1: " + weakSet.has(obj1));

// Nach dem Entfernen von Referenzen kann das Objekt möglicherweise durch die Garbage Collection erfasst werden
weakSet.delete(obj1);
console.log("Enthält obj1 nach dem Löschen: " + weakSet.has(obj1));

Hinweis:WeakSet kann nicht iteriert werden, und die Typannotation kann nurobject. Dadurch eignet sich WeakSet zum Speichern von Objekten, die vom Garbage Collector erfasst werden müssen.


Map

Map ist eine Sammlung von Schlüssel-Wert-Paaren, wobei Schlüssel von jedem Typ sein können.

Beispiel

// Erstelle eine Map mit Schlüsseltyp string und Werttyp number
var map = new Map<string, number>();

// Schlüssel-Wert-Paare setzen
map.set("one", 1);
map.set("two", 2);
map.set("three", 3);

// Werte abrufen
console.log("two abrufen: " + map.get("two"));
console.log("Map-Größe: " + map.size);
console.log("Enthält three: " + map.has("three"));

// Über die Map iterieren
map.forEach(function(value, key) {
    console.log(key + ": " + value);
});

// In Array konvertieren
console.log("In Array konvertiert: " + Array.from(map.entries()));

Ausgabe:

获取 two: 2
Map 大小: 3
是否包含 three: true
one: 1
two: 2
three: 3
转换为数组: one,1,two,2,three,3

Vorteile:Map-Schlüssel können von jedem Typ sein (Objekte, Funktionen usw.), was flexibler ist als die Verwendung von Objekten als Schlüssel.


WeakMap

WeakMap-Schlüssel sind schwache Referenzen und haben keinen Einfluss auf die Garbage Collection.

Beispiel

// WeakMap-Schlüssel müssen Objekte sein
// Schlüsseltyp ist object, Werttyp ist string
var weakMap = new WeakMap<object, string>();

// Ein Objekt als Schlüssel erstellen
var keyObj = { id: 1 };
// Schlüssel-Wert-Paare setzen
weakMap.set(keyObj, "value1");

// Den Wert abrufen
console.log("Wert abrufen: " + weakMap.get(keyObj));
console.log("Enthält: " + weakMap.has(keyObj));

// Schlüssel-Wert-Paar löschen
weakMap.delete(keyObj);
console.log("Nach dem Löschen: " + weakMap.has(keyObj));

Anwendungsszenarien:WeakMap wird häufig verwendet, um DOM-Knoten-Daten zwischenzuspeichern. Wenn ein DOM-Knoten entfernt wird, werden die zwischengespeicherten Daten automatisch bereinigt, wodurch Speicherlecks vermieden werden.


Praktische Anwendungsszenarien

Verwende Map, um die Vorkommen von Array-Elementen zu zählen.

Beispiel

// Map verwenden, um die Vorkommen jedes Elements in einem Array zu zählen
function countElements(arr: string[]): Map<string, number> {
    // Erstelle eine Map mit string-Schlüsseln und number-Werten
    var counts = new Map<string, number>();

    // Über das Array iterieren
    for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
        var item = arr_1[_i];
        // Hole die aktuelle Anzahl oder gib 0 zurück, wenn sie nicht existiert
        var currentCount = counts.get(item) || 0;
        // Aktualisiere die Anzahl
        counts.set(item, currentCount + 1);
    }

    return counts;
}

// Test
var fruits = ["apple", "banana", "apple", "orange", "banana", "apple"];
var result = countElements(fruits);

// Über die Ergebnisse iterieren
result.forEach(function(count, fruit) {
    console.log(fruit + ": " + count);
});

Ausgabe:

apple: 3
banana: 2
orange: 1

Praktisch:Map ist eine ideale Wahl für die Implementierung von Caching, Statistiken, Indizierung und anderen Funktionen.


Hinweise

  • Set-Eindeutigkeit:Set ignoriert automatisch doppelte Werte
  • WeakSet/WeakMap:Schlüssel müssen Objekte sein und können nicht iteriert werden
  • Map-Schlüsseltypen:Map-Schlüssel können von beliebigem Typ sein
  • Speicherverwaltung:WeakSet/WeakMap verhindern keine Garbage Collection

Auswahlempfehlungen:Verwenden Sie Set für Sammlungen eindeutiger Werte, Map für Schlüssel-Wert-Zuordnungen und WeakSet/WeakMap, wenn Sie Speicherlecks vermeiden müssen.


Zusammenfassung

Set und Map sind sehr nützliche Datenstrukturen in TypeScript.

  • Set:Eine Sammlung von Werten; Werte sind eindeutig und werden automatisch dedupliziert
  • WeakSet:Eine Sammlung schwacher Objektreferenzen; nicht iterierbar; geeignet für Szenarien, die Garbage Collection erfordern
  • Map:Eine Sammlung von Schlüssel-Wert-Paaren; Schlüssel können von beliebigem Typ sein
  • WeakMap:Schlüssel verwenden schwache Referenzen; nicht iterierbar; geeignet für Caching und private Daten

Empfehlung:Wählen Sie die geeignete Datenstruktur basierend auf spezifischen Anforderungen: Verwenden Sie Set zur Deduplizierung, Map für Mappings und die Weak-Versionen zur Speicheroptimierung.

Andere Erweiterungen