JavaScript
Explica cómo WeakMap y WeakSet asocian datos o marcas a objetos sin mantenerlos vivos, y por qué no ofrecen iteración, tamaño ni limpieza total.
WeakMap y WeakSet almacenan relaciones débiles con sus claves o valores.
Una relación débil no obliga al garbage collector a mantener vivo un objeto únicamente porque aparece dentro de la colección.
const metadata = new WeakMap();
let user = {
id: "user-1",
};
metadata.set(user, {
lastAccess: Date.now(),
});Con un Map normal:
const map = new Map();
let user = { id: 1 };
map.set(user, "metadata");
user = null;El Map todavía conserva una referencia fuerte a la clave.
Con WeakMap:
const weakMap = new WeakMap();
let user = { id: 1 };
weakMap.set(user, "metadata");
user = null;Si no existe otra referencia fuerte al objeto, la entrada puede desaparecer cuando el motor realice garbage collection.
No puedes observar ni controlar el instante exacto.
user = null;Esta asignación no ejecuta obligatoriamente el garbage collector en ese momento.
La recolección:
Una colección débil ayuda a no extender la vida de un objeto; no ofrece eventos confiables de destrucción.
Las claves de WeakMap y los valores de WeakSet deben ser valores que puedan mantenerse débilmente.
En la práctica se utilizan principalmente objetos y funciones.
const metadata = new WeakMap();
metadata.set({}, "valid");
metadata.set(function handler() {}, "valid");El estándar moderno también permite symbols no registrados globalmente.
const token = Symbol("token");
const map = new WeakMap([[token, "metadata"]]);Un symbol registrado mediante Symbol.for no es una clave débil válida porque el registro global conserva su identidad.
const sharedToken = Symbol.for("token");
// weakMap.set(sharedToken, value) produce TypeError.Los primitivos ordinarios no son válidos.
weakMap.set("user-1", value); // TypeErrorconst metadata = new WeakMap();
metadata.set(object, value);
metadata.get(object);
metadata.has(object);
metadata.delete(object);No ofrece:
size.clear.keys, values o entries.for...of.forEach.Supón que pudiera enumerarse:
for (const [key, value] of weakMap) {
// ...
}El resultado dependería de si el garbage collector ya eliminó ciertas claves. Ese momento no es observable ni determinista.
Para evitar que el programa dependa de detalles internos de memoria, las colecciones débiles no exponen enumeración ni tamaño.
La clave es débil; el valor asociado puede ser cualquier valor.
metadata.set(user, {
permissions: ["read", "write"],
});Mientras la clave siga viva y la entrada exista, el valor puede permanecer accesible mediante esa relación.
Si el valor conserva una referencia hacia la clave, los motores pueden tratar el ciclo correctamente; lo importante es si existe una referencia fuerte desde fuera del grupo.
const validationState = new WeakMap();
function markValidated(object) {
validationState.set(object, {
validatedAt: Date.now(),
});
}
function isValidated(object) {
return validationState.has(object);
}La información queda asociada al objeto sin agregarle propiedades visibles.
Cuando el objeto ya no se utiliza, el registro no necesita una limpieza manual obligatoria.
const privateState = new WeakMap();
class Counter {
constructor() {
privateState.set(this, {
value: 0,
});
}
increment() {
privateState.get(this).value++;
}
read() {
return privateState.get(this).value;
}
}Este patrón todavía puede servir cuando:
Para privacidad interna de una clase moderna, los campos # suelen ser más directos.
const calculatedLayouts = new WeakMap();
function calculateLayout(element) {
if (calculatedLayouts.has(element)) {
return calculatedLayouts.get(element);
}
const layout = expensiveCalculation(element);
calculatedLayouts.set(element, layout);
return layout;
}Cuando el elemento deja de existir en la aplicación y el DOM, la cache no tiene por qué mantenerlo vivo.
Esto no añade expiración temporal ni límite de tamaño observable; resuelve una relación de vida ligada a la clave.
El estándar ECMAScript 2026 incorpora:
weakMap.getOrInsert(key, defaultValue);Y una versión calculada:
weakMap.getOrInsertComputed(
key,
() => createMetadata(key),
);Crean la entrada únicamente cuando la clave no existe.
Son APIs recientes. Comprueba compatibilidad antes de utilizarlas en runtimes antiguos.
Un WeakSet mantiene valores débiles sin un dato asociado.
const processedObjects = new WeakSet();
processedObjects.add(object);
processedObjects.has(object);
processedObjects.delete(object);No ofrece tamaño, limpieza total ni iteración.
const processed = new WeakSet();
function processNode(node) {
if (processed.has(node)) {
return;
}
processed.add(node);
performWork(node);
}El marcador no obliga al programa a conservar nodos que ya no utiliza.
function serialize(value, visited = new WeakSet()) {
if (value === null || typeof value !== "object") {
return value;
}
if (visited.has(value)) {
return "[Circular]";
}
visited.add(value);
const result = {};
for (const [key, nestedValue] of Object.entries(value)) {
result[key] = serialize(
nestedValue,
visited,
);
}
return result;
}WeakSet registra qué objetos fueron visitados sin convertirse necesariamente en el dueño permanente de esas referencias.
Dentro de una sola llamada también podría usarse Set; la elección depende del tiempo de vida y de si necesitas inspeccionar la colección.
Usa Map cuando necesitas:
Usa WeakMap cuando:
Usa Set cuando necesitas:
Usa WeakSet cuando solo necesitas preguntar si un objeto vivo está marcado y no deseas mantenerlo vivo por ese marcador.
Una colección débil no es adecuada para:
Sus entradas pueden desaparecer cuando sus claves dejan de ser accesibles.
JavaScript ofrece FinalizationRegistry para solicitar una callback después de que ciertos valores sean recolectados.
No debe utilizarse para lógica esencial:
close, dispose o limpieza explícita de recursos.WeakMap y WeakSet suelen ser útiles sin observar la recolección.
const componentState = new WeakMap();
function initializeComponent(element) {
componentState.set(element, {
isOpen: false,
mountedAt: Date.now(),
});
}
function toggleComponent(element) {
const state = componentState.get(element);
if (!state) {
throw new Error(
"Component is not initialized",
);
}
state.isOpen = !state.isOpen;
return state.isOpen;
}El estado pertenece al tiempo de vida del elemento, pero no se añade como propiedad pública sobre él.
null.size.¿Por qué WeakMap no ofrece keys() ni size?
Porque sus claves pueden desaparecer según decisiones no deterministas del garbage collector. Exponer enumeración o tamaño permitiría que el programa observara ese proceso y dependiera de él.
Iterables e iteradores explica el protocolo que permite a arrays, Maps, Sets, strings y otras secuencias entregar valores uno a uno.