Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / JavaScript

WeakMap: comprobar, leer y escribir entradas con has(), get() y set()

Comprueba si existe una clave, lee su valor o actualízalo. Aprende a distinguir una entrada ausente de un `undefined` almacenado y a reconocer las claves válidas.

Versión: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxis

weakMap.has(key)
weakMap.get(key)
weakMap.set(key, value)

WeakMap.prototype.has/get/set abrevia los nombres de tres métodos de instancia de WeakMap. Las claves se comparan por identidad: dos objetos distintos con propiedades idénticas son claves diferentes.

  • has(key) devuelve true si existe una entrada y false en caso contrario.
  • get(key) devuelve el valor almacenado, o undefined si no hay entrada. Usa has(key) para distinguir una entrada ausente de un undefined almacenado.
  • set(key, value) añade una entrada o sustituye el valor de la misma clave. Acepta cualquier valor de JavaScript y devuelve la misma instancia de WeakMap, por lo que permite encadenar llamadas.

ECMAScript 2024 admite como claves objetos (incluidas las funciones) y símbolos no registrados, como Symbol() y Symbol.iterator, pero no símbolos obtenidos con Symbol.for(). Es posible que los entornos de ejecución antiguos solo acepten objetos como claves; comprueba si el entorno de destino admite claves de tipo símbolo.

Para una clave no válida como 1, has() devuelve false, get() devuelve undefined y set() lanza un TypeError. Los tres métodos comprueban primero this: si no es una instancia real de WeakMap, la llamada lanza un TypeError con independencia de la clave.

Usa WeakMap para asociar metadatos a un objeto sin mantener viva la clave, aunque el valor almacenado haga referencia a ella. No hay garantías sobre cuándo se recuperará la memoria. WeakMap no permite iterar sobre las claves ni ofrece size; usa Map si necesitas esas funciones o si quieres usar cadenas o números como claves.

Ejemplos

{
  const map = new WeakMap();
  const key = { id: 1 };
  const lookalike = { id: 1 };

  map.set(key, undefined);
  console.log(`stored: ${map.has(key)}, ${map.get(key)}`);
  console.log(`missing: ${map.has(lookalike)}, ${map.get(lookalike)}`);

  const result = map.set(key, 42);
  console.log(`updated: ${map.get(key)}, same map: ${result === map}`);

  console.log(`invalid key: ${map.has(1)}, ${map.get(1)}`);
  try {
    map.set(1, 42);
  } catch (error) {
    console.log(error.name);
  }
}

Resultado

stored: true, undefined
missing: false, undefined
updated: 42, same map: true
invalid key: false, undefined
TypeError

`key` y `lookalike` tienen el mismo `id`, pero son objetos distintos. Ambas lecturas devuelven inicialmente `undefined`; solo `has(key)` devuelve `true`. La segunda escritura sustituye el valor por `42` y devuelve el mismo mapa. La clave `1` muestra la diferencia entre leer y escribir con una clave no válida.

Lecciones relacionadas

  • JavaScript · Lección 17 · Avanzado · Versión: 4

Fuentes