JavaScript
Carte faible

Syntaxe

• nouveau WeakMap ([itérable]);
• faiblessemap.get (clé);
• faiblessemap.set (clé, valeur);
• faiblessemap.has (clé);
• faiblessemap.delete (clé);

Remarques

Créer un objet WeakMap

L'objet WeakMap vous permet de stocker des paires clé / valeur. La différence avec Map est que les clés doivent être des objets et sont faiblement référencées. Cela signifie que s'il n'y a pas d'autres références fortes à la clé, l'élément de WeakMap peut être supprimé par le garbage collector.

Le constructeur de WeakMap possède un paramètre facultatif, qui peut être n'importe quel objet itérable (par exemple, Array) contenant des paires clé / valeur en tant que tableaux à deux éléments.

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

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

Obtenir une valeur associée à la clé

Pour obtenir une valeur associée à la clé, utilisez la méthode .get() . S'il n'y a pas de valeur associée à la clé, elle renvoie undefined .

const obj1 = {},
      obj2 = {};

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

Assigner une valeur à la clé

Pour attribuer une valeur à la clé, utilisez la méthode .set() . Il renvoie l'objet WeakMap, vous pouvez donc enchaîner les .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

Vérifier si un élément avec la clé existe

Pour vérifier si un élément avec une clé spécifiée existe dans un WeakMap, utilisez la méthode .has .has() . Il retourne true s'il quitte, et sinon false .

const obj1 = {},
      obj2 = {};

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

Supprimer un élément avec la clé

Pour supprimer un élément avec une clé spécifiée, utilisez la méthode .delete() . Il renvoie true si l'élément existait et a été supprimé, sinon 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

Démo de référence faible

JavaScript utilise la technique de comptage de référence pour détecter les objets inutilisés. Lorsque le nombre de références à un objet est égal à zéro, cet objet sera libéré par le ramasse-miettes. Weakmap utilise une référence faible qui ne contribue pas au compte de référence d'un objet, il est donc très utile pour résoudre les problèmes de fuite de mémoire.

Voici une démo de faiblesse. J'utilise un objet très grand comme valeur pour montrer qu'une référence faible ne contribue pas au compte de référence.

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