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 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

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

// Créer un Set, en spécifiant le type d'élément comme number
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

// Set de chaînes
// 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 laSet<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

// WeakSet ne peut stocker que des objets, pas des valeurs primitives
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 queobject. 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

// Créer une Map avec un type de clé string et un type de valeur number
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

// Les clés de WeakMap doivent être des objets
// 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

// Utiliser Map pour compter les occurrences de chaque élément dans un tableau
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

Recommandation :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.

Autres extensions