Quelle est la différence entre ES6 Map et WeakMap?

En regardant ceci et ces pages MDN, il semble que la seule différence entre Maps et WeakMaps est une propriété "size" manquante pour WeakMaps. Mais est-ce vrai? Quelle est la différence entre eux?

De la même page, section " Pourquoi une carte faible ? " :

Le programmeur JavaScript expérimenté remarquera que cette API pourrait être implémentée en JavaScript avec deux tableaux (un pour les clés, un pour les valeurs) partagés par les 4 méthodes API. Une telle mise en œuvre présenterait deux inconvénients principaux. La première est une recherche O (n) (n étant le nombre de clés dans la carte). Le second est un problème de fuite de mémoire. Avec les cartes écrites manuellement, le tableau de clés conserverait les références aux objets clés, les empêchant d'être récupérés. Dans WeakMaps natif, les références aux objets clés sont conservées «faiblement» , ce qui signifie qu'elles n'empêchent pas le garbage collection au cas où il n'y aurait pas d'autre référence à l'objet.

En raison de la faiblesse des références, les clés WeakMap ne sont pas énumérables (c'est-à-dire qu'aucune méthode ne vous donne une liste des clés). Si tel était le cas, la liste dépendrait de l'état du garbage collection, introduisant le non-déterminisme.

[Et c'est pourquoi ils n'ont pas non plus de sizepropriété]

Si vous souhaitez avoir une liste de clés, vous devez la maintenir vous-même. Il existe également une proposition ECMAScript visant à introduire des ensembles et des cartes simples qui n'utiliseraient pas de références faibles et seraient énumérables.

- ce qui serait le "normal" Maps . Non mentionné chez MDN, mais dans la proposition d'harmonie , ceux-ci ont également items, keyset valuesgénérateurs de méthodes et implémentent l' Iteratorinterface .

Ils se comportent tous deux différemment lorsqu'un objet référencé par leurs clés / valeurs est supprimé. Prenons l'exemple de code ci-dessous:

var map = new Map();
var weakmap = new WeakMap();

(function(){
    var a = {x: 12};
    var b = {y: 12};

    map.set(a, 1);
    weakmap.set(b, 2);
})()

L'IIFE ci-dessus est exécuté il n'y a aucun moyen de référencer {x: 12}et {y: 12}plus. Le garbage collector continue et supprime le pointeur clé b de «WeakMap» et supprime également {y: 12}de la mémoire. Mais dans le cas de «Map», le garbage collector ne supprime pas un pointeur de «Map» et ne le supprime pas non plus {x: 12}de la mémoire.

Résumé: WeakMap permet au garbage collector de faire sa tâche mais pas à Map.

Références: http://qnimate.com/difference-between-map-and-weakmap-in-javascript/

Peut-être que la prochaine explication sera plus claire pour quelqu'un.

var k1 = {a: 1};
var k2 = {b: 2};

var map = new Map();
var wm = new WeakMap();

map.set(k1, 'k1');
wm.set(k2, 'k2');

k1 = null;
map.forEach(function (val, key) {
    console.log(key, val); // k1 {a: 1}
});

k2 = null;
wm.get(k2); // undefined

Comme vous le voyez, après avoir supprimé la k1clé de la mémoire, nous pouvons toujours y accéder à l'intérieur de la carte. En même temps, la suppression de la k2clé de WeakMap la supprime wmégalement par référence.

C'est pourquoi WeakMap n'a pas de méthodes énumérables comme forEach, car il n'existe pas de liste de clés WeakMap, ce ne sont que des références à un autre objet.

Autre différence (source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap ):

Les clés de WeakMaps sont du type Object uniquement. Les types de données primitifs en tant que clés ne sont pas autorisés (par exemple, un symbole ne peut pas être une clé WeakMap).

Une chaîne, un nombre ou un booléen ne peuvent pas non plus être utilisés comme WeakMapclé. A Map peut utiliser des valeurs primitives pour les clés.

w = new WeakMap;
w.set('a', 'b'); // Uncaught TypeError: Invalid value used as weak map key

m = new Map
m.set('a', 'b'); // Works

Depuis Javascript.info

Carte - Si nous utilisons un objet comme clé dans une carte régulière, alors que la carte existe, cet objet existe également. Il occupe de la mémoire et ne peut pas être récupéré.

let john = { name: "John" };
let array = [ john ];
john = null; // overwrite the reference

// john is stored inside the array, so it won't be garbage-collected
// we can get it as array[0]

Similaire à cela, si nous utilisons un objet comme clé dans une carte normale, alors que la carte existe, cet objet existe également. Il occupe de la mémoire et peut ne pas être ramassé

let john = { name: "John" };
let map = new Map();
map.set(john, "...");
john = null; // overwrite the reference

// john is stored inside the map,
// we can get it by using map.keys()

WeakMap - Maintenant, si nous utilisons un objet comme clé et qu'il n'y a pas d'autres références à cet objet - il sera automatiquement supprimé de la mémoire (et de la carte).

let john = { name: "John" };
let weakMap = new WeakMap();
weakMap.set(john, "...");
john = null; // overwrite the reference

// john is removed from memory!

WeapMap en javascript ne contient aucune clé ou valeur, il manipule simplement la valeur de clé en utilisant un identifiant unique et définit une propriété pour l'objet clé.

car elle définit la propriété key objectpar méthode Object.definePropert(), la clé ne doit pas être de type primitif .

et aussi parce que WeapMap ne contient pas réellement de paires valeur / clé, nous ne pouvons pas obtenir la propriété length de lowmap.

et la valeur manipulée est également attribuée à l'objet clé, le garbage collector peut facilement collecter la clé si elle n'est pas utilisée.

Exemple de code pour l'implémentation.

if(typeof WeapMap != undefined){
return;
} 
(function(){
   var WeapMap = function(){
      this.__id = '__weakmap__';
   }
        
   weakmap.set = function(key,value){
       var pVal = key[this.__id];
        if(pVal && pVal[0] == key){
           pVal[1]=value;
       }else{
          Object.defineProperty(key, this.__id, {value:[key,value]});
          return this;
        }
   }

window.WeakMap = WeakMap;
})();

référence de mise en œuvre

WeakMap les clés doivent être des objets et non des valeurs primitives.

let weakMap = new WeakMap();

let obj = {};

weakMap.set(obj, "ok"); // works fine (object key)

// can't use a string as the key
weakMap.set("test", "Not ok"); // Error, because "test" is not an object

Pourquoi????

Voyons l'exemple ci-dessous.

let user = { name: "User" };

let map = new Map();
map.set(user, "...");

user = null; // overwrite the reference

// 'user' is stored inside the map,
// We can get it by using map.keys()

Si nous utilisons un objet comme clé dans un régulier Map, alors tant que le Mapexiste, cet objet existe également. Il occupe de la mémoire et ne peut pas être récupéré.

WeakMapest fondamentalement différent à cet égard. Cela n'empêche pas le garbage collection d'objets clés.

let user = { name: "User" };

let weakMap = new WeakMap();
weakMap.set(user, "...");

user = null; // overwrite the reference

// 'user' is removed from memory!

si nous utilisons un objet comme clé, et qu'il n'y a pas d'autres références à cet objet - il sera automatiquement supprimé de la mémoire (et de la carte).

WeakMap ne prend pas en charge l'itération et les méthodes keys () , values ​​() , entries () , il n'y a donc aucun moyen d'en obtenir toutes les clés ou valeurs.

WeakMap n'a que les méthodes suivantes:

• lowMap.get (clé)
• lowMap.set (clé, valeur)
• lowMap.delete (clé)
• lowMap.has (clé)

C'est évident, comme si un objet avait perdu toutes les autres références (comme «utilisateur» dans le code ci-dessus), alors il doit être récupéré automatiquement. Mais techniquement, ce n'est pas exactement spécifié quand le nettoyage a lieu.

Le moteur JavaScript décide cela. Il peut choisir d'effectuer le nettoyage de la mémoire immédiatement ou d'attendre et de le faire plus tard lorsque d'autres suppressions se produisent. Donc, techniquement, le nombre d'éléments actuel de a WeakMapn'est pas connu. Le moteur peut l'avoir nettoyé ou non ou l'a fait partiellement. Pour cette raison, les méthodes qui accèdent à toutes les clés / valeurs ne sont pas prises en charge.

Remarque: - Le principal domaine d'application de WeakMap est un stockage de données supplémentaire. Comme mettre en cache un objet jusqu'à ce que cet objet soit récupéré.