TypeScript Set et WeakMap
TypeScript hérite des structures de données Set et WeakMap de JavaScript, offrant un support de type plus puissant.
Ces structures de données sont très utiles dans des scénarios tels que la gestion d'ensembles de valeurs uniques, les mappages de paires clé-valeur et la mise en cache.
Diagramme SVG : structures de données Set et Map
Pourquoi avez-vous besoin de Set et WeakMap
En développement, nous avons souvent besoin de gérer des ensembles de valeurs uniques et des mappages de paires clé-valeur.
Set fournit une déduplication automatique pour les collections, ce qui le rend plus pratique que les tableaux pour gérer des valeurs uniques.
WeakSet et WeakMap utilisent des références faibles et n'empêchent pas la collecte des déchets, ce qui les rend adaptés aux scénarios qui doivent éviter les fuites de mémoire, comme la mise en cache de nœuds DOM.
Explication du concept :Set est une collection de valeurs, avec des valeurs uniques ; Map est une collection de paires clé-valeur, où les clés peuvent être de n'importe quel type. WeakSet et WeakMap utilisent des références faibles et n'affectent pas la collecte des déchets.
Set
Set est une collection de valeurs ; les valeurs sont uniques et les doublons ne sont pas autorisés.
Exemple
var numbers = new Set<number>();
// Ajouter des éléments
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(1); // Les valeurs dupliquées seront ignorées et ne seront pas ajoutées
// Vérifier la taille et l'appartenance
console.log("Taille du Set : " + numbers.size);
console.log("Contient 2 : " + numbers.has(2));
// Parcourir le Set
numbers.forEach(function(value) {
console.log("Valeur : " + value);
});
// Convertir en tableau
var arr = Array.from(numbers);
console.log("Converti en tableau : " + arr);
Sortie :
Set 大小: 3 是否包含 2: true 值: 1 值: 2 值: 3 转换为数组: 1,2,3
Dédoublonnage :Set ignore automatiquement les valeurs en double, ce qui le rend très adapté à la déduplication de tableaux.
Annotation de type Set
Vous pouvez spécifier explicitement le type des valeurs dans un Set.
Exemple
// Seules les valeurs de type string peuvent être ajoutées
var stringSet: Set<string> = new Set();
stringSet.add("a");
stringSet.add("b");
// Ensemble d'objets
// Définir l'interface Person
interface Person {
name: string;
}
// Créer un Set qui stocke des objets Person
var personSet: Set<Person> = new Set();
personSet.add({ name: "Alice" });
personSet.add({ name: "Bob" });
console.log("Ensemble de chaînes : " + Array.from(stringSet));
console.log("Taille de l'ensemble d'objets : " + personSet.size);
Génériques :Utilisez la
Set<T>syntaxe pour spécifier le type d'éléments dans un Set.
WeakSet
WeakSet stocke des références d'objets, et les références sont des références faibles (elles n'affectent pas le ramasse-miettes).
Exemple
var weakSet = new WeakSet();
// Créer des objets
var obj1 = { name: "Alice" };
var obj2 = { name: "Bob" };
// Ajouter des objets à WeakSet
weakSet.add(obj1);
weakSet.add(obj2);
// Vérifier s'il contient
console.log("Contient obj1: " + weakSet.has(obj1));
// Après suppression des références, l'objet peut être collecté par le ramasse-miettes
weakSet.delete(obj1);
console.log("Contient obj1 après suppression : " + weakSet.has(obj1));
Remarque :WeakSet ne peut pas être itéré, et l'annotation de type ne peut être que
object. Cela rend WeakSet adapté au stockage d'objets qui doivent être collectés par le ramasse-miettes.
Map
Map est une collection de paires clé-valeur, où les clés peuvent être de n'importe quel type.
Exemple
var map = new Map<string, number>();
// Définir des paires clé-valeur
map.set("one", 1);
map.set("two", 2);
map.set("three", 3);
// Obtenir les valeurs
console.log("Obtenir two : " + map.get("two"));
console.log("Taille de la Map : " + map.size);
console.log("Contient trois : " + map.has("three"));
// Parcourir la Map
map.forEach(function(value, key) {
console.log(key + ": " + value);
});
// Convertir en tableau
console.log("Converti en tableau : " + Array.from(map.entries()));
Sortie :
获取 two: 2 Map 大小: 3 是否包含 three: true one: 1 two: 2 three: 3 转换为数组: one,1,two,2,three,3
Avantages :Les clés de Map peuvent être de n'importe quel type (objets, fonctions, etc.), ce qui est plus flexible que d'utiliser des objets comme clés.
WeakMap
Les clés de WeakMap sont des références faibles et n'affectent pas la collecte des déchets.
Exemple
// Le type de la clé est un objet, le type de la valeur est une chaîne
var weakMap = new WeakMap<object, string>();
// Créer un objet comme clé
var keyObj = { id: 1 };
// Définir des paires clé-valeur
weakMap.set(keyObj, "value1");
// Obtenir la valeur
console.log("Obtenir la valeur : " + weakMap.get(keyObj));
console.log("Contient : " + weakMap.has(keyObj));
// Supprimer la paire clé-valeur
weakMap.delete(keyObj);
console.log("Après suppression : " + weakMap.has(keyObj));
Scénarios d'application :WeakMap est couramment utilisé pour mettre en cache les données de nœuds DOM. Lorsqu'un nœud DOM est supprimé, les données mises en cache sont automatiquement nettoyées, évitant les fuites de mémoire.
Scénarios d'application pratiques
Utiliser Map pour compter les occurrences des éléments d'un tableau.
Exemple
function countElements(arr: string[]): Map<string, number> {
// Créer une Map avec des clés string et des valeurs number
var counts = new Map<string, number>();
// Parcourir le tableau
for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
var item = arr_1[_i];
// Obtenir le nombre actuel, ou renvoyer 0 s'il n'existe pas
var currentCount = counts.get(item) || 0;
// Mettre à jour le compteur
counts.set(item, currentCount + 1);
}
return counts;
}
// Test
var fruits = ["apple", "banana", "apple", "orange", "banana", "apple"];
var result = countElements(fruits);
// Itérer sur les résultats
result.forEach(function(count, fruit) {
console.log(fruit + ": " + count);
});
Sortie :
apple: 3 banana: 2 orange: 1
En pratique :Map est un choix idéal pour implémenter la mise en cache, les statistiques, l'indexation et d'autres fonctionnalités.
Notes
- Unicité de Set :Set ignore automatiquement les valeurs en double
- WeakSet/WeakMap:Les clés doivent être des objets et l'itération n'est pas possible
- Types de clés de Map :Les clés de Map peuvent être de n'importe quel type
- Gestion de la mémoire :WeakSet/WeakMap n'empêchent pas le ramasse-miettes
Recommandations de choix :Utilisez Set pour les collections de valeurs uniques, Map pour les mappages clé-valeur, et WeakSet/WeakMap lorsque vous devez éviter les fuites de mémoire.
Résumé
Set et Map sont des structures de données très utiles en TypeScript.
- Set:Une collection de valeurs ; les valeurs sont uniques avec déduplication automatique
- WeakSet:Une collection de références faibles vers des objets ; non itérable ; adapté aux scénarios qui nécessitent une collecte de déchets
- Map :Une collection de paires clé-valeur ; les clés peuvent être de n'importe quel type
- WeakMap :Les clés utilisent des références faibles ; non itérable ; convient pour la mise en cache et les données privées
Autres extensionsRecommandation :Choisissez la structure de données appropriée en fonction de besoins spécifiques : utilisez Set pour la déduplication, Map pour les mappages, et les versions Weak pour l'optimisation de la mémoire.