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
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
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
// 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 die
Set<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
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 nur
object. 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
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
// 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
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
Andere ErweiterungenEmpfehlung: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.