JavaScript
WeakMap

Sintassi

• nuova WeakMap ([iterable]);
• weakmap.get (chiave);
• weakmap.set (chiave, valore);
• weakmap.has (chiave);
• weakmap.delete (chiave);

Osservazioni

Creazione di un oggetto WeakMap

L'oggetto WeakMap consente di memorizzare coppie chiave / valore. La differenza dalla Mappa è che le chiavi devono essere oggetti e sono debolmente referenziate. Ciò significa che se non ci sono altri riferimenti forti alla chiave, l'elemento in WeakMap può essere rimosso dal garbage collector.

Il costruttore WeakMap ha un parametro facoltativo, che può essere qualsiasi oggetto iterabile (ad esempio Array) contenente coppie chiave / valore come matrici a due elementi.

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

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

Ottenere un valore associato alla chiave

Per ottenere un valore associato alla chiave, utilizzare il metodo .get() . Se non c'è alcun valore associato alla chiave, restituisce undefined .

const obj1 = {},
      obj2 = {};

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

Assegnare un valore alla chiave

Per assegnare un valore alla chiave, utilizzare il metodo .set() . Restituisce l'oggetto WeakMap, in modo che tu possa concatenare le chiamate .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

Verifica se esiste un elemento con la chiave

Per verificare se un elemento con una chiave specificata esce in una WeakMap, utilizzare il metodo .has() . Restituisce true se esce, e in caso contrario false .

const obj1 = {},
      obj2 = {};

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

Rimozione di un elemento con la chiave

Per rimuovere un elemento con una chiave specificata, utilizzare il metodo .delete() . Restituisce true se l'elemento esiste ed è stato rimosso, altrimenti 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

Debole demo di riferimento

JavaScript utilizza la tecnica di conteggio dei riferimenti per rilevare gli oggetti non utilizzati. Quando il conteggio dei riferimenti a un oggetto è zero, tale oggetto verrà rilasciato dal garbage collector. Weakmap utilizza un riferimento debole che non contribuisce al conteggio dei riferimenti di un oggetto, pertanto è molto utile per risolvere i problemi di perdita di memoria.

Ecco una demo di weakmap. Io uso un oggetto molto grande come valore per mostrare che il riferimento debole non contribuisce al conteggio dei riferimenti.

// 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 }