JavaScript
WeakMap

Sintaxis

• nuevo WeakMap ([iterable]);
• weakmap.get (clave);
• weakmap.set (clave, valor);
• weakmap.has (clave);
• weakmap.delete (clave);

Observaciones

Creando un objeto WeakMap

El objeto WeakMap le permite almacenar pares clave / valor. La diferencia con el Mapa es que las claves deben ser objetos y están mal referenciadas. Esto significa que si no hay otras referencias sólidas a la clave, el elemento en WeakMap puede ser eliminado por el recolector de basura.

El constructor WeakMap tiene un parámetro opcional, que puede ser cualquier objeto iterable (por ejemplo, Array) que contenga pares clave / valor como arreglos de dos elementos.

const o1 = {a: 1, b: 2},
      o2 = {};

const weakmap = new WeakMap([[o1, true], [o2, o1]]);

Obtención de un valor asociado a la clave.

Para obtener un valor asociado a la clave, use el método .get() . Si no hay ningún valor asociado a la clave, devuelve undefined .

const obj1 = {},
      obj2 = {};

const weakmap = new WeakMap([[obj1, 7]]);
console.log(weakmap.get(obj1)); // 7
console.log(weakmap.get(obj2)); // undefined

Asignando un valor a la clave.

Para asignar un valor a la clave, use el método .set() . Devuelve el objeto WeakMap, por lo que puede encadenar llamadas .set() .

const obj1 = {},
      obj2 = {};

const weakmap = new WeakMap();
weakmap.set(obj1, 1).set(obj2, 2);
console.log(weakmap.get(obj1)); // 1
console.log(weakmap.get(obj2)); // 2

Comprobando si existe un elemento con la clave.

Para verificar si un elemento con una clave especificada sale en un mapa débil, use el método .has() . Devuelve true si sale, y por lo demás false .

const obj1 = {},
      obj2 = {};

const weakmap = new WeakMap([[obj1, 7]]);
console.log(weakmap.has(obj1)); // true
console.log(weakmap.has(obj2)); // false

Eliminando un elemento con la llave.

Para eliminar un elemento con una clave específica, use el método .delete() . Devuelve true si el elemento existió y se ha eliminado, de lo contrario es false .

const obj1 = {},
      obj2 = {};

const weakmap = new WeakMap([[obj1, 7]]);
console.log(weakmap.delete(obj1)); // true
console.log(weakmap.has(obj1)); // false
console.log(weakmap.delete(obj2)); // false

Demostración de referencia débil

JavaScript utiliza la técnica de conteo de referencias para detectar objetos no utilizados. Cuando el recuento de referencias a un objeto es cero, ese objeto será liberado por el recolector de basura. Weakmap utiliza una referencia débil que no contribuye al recuento de referencia de un objeto, por lo que es muy útil para resolver problemas de pérdida de memoria.

Aquí hay una demostración de un mapa débil. Utilizo un objeto muy grande como valor para mostrar que una referencia débil no contribuye al conteo de referencias.

// manually trigger garbage collection to make sure that we are in good status.
> global.gc(); 
undefined

// check initial memory use，heapUsed is 4M or so
> process.memoryUsage(); 
{ rss: 21106688,
  heapTotal: 7376896,
  heapUsed: 4153936,
  external: 9059 }

> let wm = new WeakMap();
undefined

> const b = new Object();
undefined

> global.gc();
undefined

// heapUsed is still 4M or so
> process.memoryUsage(); 
{ rss: 20537344,
  heapTotal: 9474048,
  heapUsed: 3967272,
  external: 8993 }

// add key-value tuple into WeakMap，
// key is b，value is 5*1024*1024 array 
> wm.set(b, new Array(5*1024*1024));
WeakMap {}

// manually garbage collection
> global.gc();
undefined

// heapUsed is still 45M
> process.memoryUsage(); 
{ rss: 62652416,
  heapTotal: 51437568,
  heapUsed: 45911664,
  external: 8951 }

// b reference to null
> b = null;
null

// garbage collection
> global.gc();
undefined

// after remove b reference to object，heapUsed is 4M again 
// it means the big array in WeakMap is released
// it also means weekmap does not contribute to big array's reference count, only b does.
> process.memoryUsage(); 
{ rss: 20639744,
  heapTotal: 8425472,
  heapUsed: 3979792,
  external: 8956 }