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
¿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
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
// 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:Usa
Set<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
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 ser
object. 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
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
// 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
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
Otras extensionesSugerencia: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.