TypeScript Set y WeakMap

TypeScript hereda las estructuras de datos Set y WeakMap de JavaScript, proporcionando un soporte de tipos más potente.

Estas estructuras de datos son muy útiles en escenarios como manejo de colecciones de valores únicos, mapeos de pares clave-valor, caché, etc.


Diagrama SVG: Estructuras de datos Set y Map Contexto Título Estructuras de datos Set y Map Set Colección de valores Valores únicos, sin duplicados Iterable add/has/delete WeakSet Referencia débil a objetos No afecta al GC No iterable add/has/delete Map Colección de pares clave-valor La clave puede ser de cualquier tipo Iterable set/get/has WeakMap Claves con referencia débil Las claves deben ser objetos No afecta al GC No iterable Parte inferior: escenarios de aplicación Escenarios de aplicación Escenario Set: deduplicación, colección de valores únicos Map: mapeo clave-valor, caché WeakMap/WeakSet: optimización de memoria Flecha indicadora

¿Por qué se necesitan Set y WeakMap?

En el desarrollo, a menudo necesitamos manejar colecciones de valores únicos y mapeos de pares clave-valor.

Set proporciona una funcionalidad de colección con deduplicación automática, más conveniente que los arrays para manejar valores únicos.

WeakSet y WeakMap utilizan referencias débiles y no impiden la recolección de basura; son adecuados para escenarios donde se necesita evitar fugas de memoria, como almacenar en caché nodos del DOM.

Explicación de conceptos:Set es una colección de valores, con valores únicos; Map es una colección de pares clave-valor, donde las claves pueden ser de cualquier tipo. WeakSet y WeakMap usan referencias débiles y no afectan la recolección de basura.


Set

Set es una colección de valores, los valores son únicos y no se permiten duplicados.

Ejemplo

// Crear un Set, especificando el tipo de elemento como number
var numbers = new Set<number>();

// Añadir elementos
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(1); // Los valores duplicados se ignoran, no se añaden

// Verificar el tamaño y la contención
console.log("Tamaño del Set: " + numbers.size);
console.log("¿Contiene 2? " + numbers.has(2));

// Recorrer el Set
numbers.forEach(function(value) {
    console.log("Valor: " + value);
});

// Convertir a array
var arr = Array.from(numbers);
console.log("Convertido a array: " + arr);

Resultado de la ejecución:

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

Deduplicación:Set ignora automáticamente los valores duplicados, lo que lo hace muy adecuado para la deduplicación de arrays.


Anotación de tipos de Set

Se puede especificar explícitamente el tipo de los valores dentro de un Set.

Ejemplo

// Set de cadenas
// Solo se pueden añadir valores de tipo cadena
var stringSet: Set<string> = new Set();
stringSet.add("a");
stringSet.add("b");

// Set de objetos
// Definir la interfaz Person
interface Person {
    name: string;
}
// Crear un Set que almacena objetos Person
var personSet: Set<Person> = new Set();
personSet.add({ name: "Alice" });
personSet.add({ name: "Bob" });

console.log("Set de cadenas: " + Array.from(stringSet));
console.log("Tamaño del Set de objetos: " + personSet.size);

Genéricos:UsaSet<T>la sintaxis para especificar el tipo de los elementos del Set.


WeakSet

WeakSet almacena referencias a objetos; las referencias son débiles (no afectan la recolección de basura).

Ejemplo

// WeakSet solo puede almacenar objetos, no valores primitivos
var weakSet = new WeakSet();

// Crear objetos
var obj1 = { name: "Alice" };
var obj2 = { name: "Bob" };

// Añadir objetos al WeakSet
weakSet.add(obj1);
weakSet.add(obj2);

// Verificar si contiene
console.log("¿Contiene obj1? " + weakSet.has(obj1));

// Después de eliminar la referencia, el objeto puede ser recolectado por el GC
weakSet.delete(obj1);
console.log("¿Contiene obj1 después de eliminar? " + weakSet.has(obj1));

Nota:WeakSet no se puede recorrer, la anotación de tipo solo puede serobject. Esto hace que WeakSet sea adecuado para almacenar objetos que necesitan ser recolectados por el GC.


Map

Map es una colección de pares clave-valor, donde las claves pueden ser de cualquier tipo.

Ejemplo

// Crear un Map, con claves de tipo string y valores de tipo number
var map = new Map<string, number>();

// Establecer pares clave-valor
map.set("one", 1);
map.set("two", 2);
map.set("three", 3);

// Obtener el valor
console.log("Obtener two: " + map.get("two"));
console.log("Tamaño del Map: " + map.size);
console.log("¿Contiene three? " + map.has("three"));

// Recorrer el Map
map.forEach(function(value, key) {
    console.log(key + ": " + value);
});

// Convertir a array
console.log("Convertido a array: " + Array.from(map.entries()));

Resultado de la ejecución:

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

Ventajas:Las claves de Map pueden ser de cualquier tipo (objetos, funciones, etc.), lo que resulta más flexible que usar objetos como claves.


WeakMap

Las claves de WeakMap son referencias débiles, no afectan la recolección de basura.

Ejemplo

// Las claves de WeakMap deben ser objetos
// Tipo de clave object, tipo de valor string
var weakMap = new WeakMap<object, string>();

// Crear un objeto como clave
var keyObj = { id: 1 };
// Establecer pares clave-valor
weakMap.set(keyObj, "value1");

// Obtener el valor
console.log("Valor obtenido: " + weakMap.get(keyObj));
console.log("¿Contiene? " + weakMap.has(keyObj));

// Eliminar el par clave-valor
weakMap.delete(keyObj);
console.log("Después de eliminar: " + weakMap.has(keyObj));

Escenarios de aplicación:WeakMap se usa a menudo para almacenar en caché datos de nodos DOM; cuando un nodo DOM se elimina, los datos en caché también se limpian automáticamente, evitando fugas de memoria.


Escenarios de aplicación práctica

Usar Map para contar las ocurrencias de elementos en un array.

Ejemplo

// Usar Map para contar las ocurrencias de cada elemento en el array
function countElements(arr: string[]): Map<string, number> {
    // Crear un Map, claves de tipo string, valores de tipo number
    var counts = new Map<string, number>();

    // Recorrer el array
    for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
        var item = arr_1[_i];
        // Obtener el contador actual, si no existe devuelve 0
        var currentCount = counts.get(item) || 0;
        // Actualizar el contador
        counts.set(item, currentCount + 1);
    }

    return counts;
}

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

// Recorrer el resultado
result.forEach(function(count, fruit) {
    console.log(fruit + ": " + count);
});

Resultado de la ejecución:

apple: 3
banana: 2
orange: 1

Práctico:Map es una opción ideal para implementar funcionalidades como caché, estadísticas, índices, etc.


Notas

  • Unicidad de Set:Set ignora automáticamente valores duplicados
  • WeakSet/WeakMap:Las claves deben ser objetos, no se pueden recorrer
  • Tipo de clave en Map:Las claves de Map pueden ser de cualquier tipo
  • Gestión de memoria:WeakSet/WeakMap no impiden la recolección de basura

Recomendaciones de selección:Si necesitas una colección de valores únicos, usa Set; si necesitas mapeo clave-valor, usa Map; si necesitas evitar fugas de memoria, usa WeakSet/WeakMap.


Resumen

Set y Map son estructuras de datos muy útiles en TypeScript.

  • Set:Colección de valores, valores únicos, deduplicación automática
  • WeakSet:Colección de referencias débiles a objetos, no iterable, adecuada para escenarios que requieren recolección de basura
  • Map:Colección de pares clave-valor, las claves pueden ser de cualquier tipo
  • WeakMap:Referencias débiles en las claves, no iterable, adecuado para caché y datos privados

Sugerencia:Elige la estructura de datos adecuada según tus necesidades: usa Set para deduplicación, Map para mapeo y las versiones Weak para optimización de memoria.

Otras extensiones