lors de la suppression de l'objet, lowmap conserve sa référence.
mais le comportement normal est le suivant: lorsque oyu supprime l'objet, il sera automatiquement supprimé de lowmap et lowmap ne peut pas provoquer de fuite de mémoire.
est-ce que quelque chose ne va pas avec lowmap ou delete ?
let a = { aa : { aa : 123 } };
const w = new WeakMap();
w.set(a.aa,"hello");
delete a.aa
console.log(w);// shows that '{aa:123}' is still there in weakmap
j'ai fermé et ouvert l'outil de développement et {aa: 123 } est toujours là.
s'attendre à ce que lowmap soit vide
3 Réponses :
Votre fonction delete () devrait ressembler à ceci:
w.delete(a.aa);
vous avez raison, mais mon problème n'est pas de supprimer quelque chose de lowmap. lowmap est connu comme quelque chose qui a une référence faible. cela signifie que lorsque vous supprimez l'objet qui a une référence dans lowmap, le faible ne peut pas empêcher l'objet de gc . donc lowmap ne provoque pas de fuite de mémoire. mais dans mon code même si je supprime l'objet, lowmap empêche gorbage collector de supprimer l'objet. ma question est pourquoi lowmap fait une telle chose? regardez et essayez ceci peut vous aider: stackoverflow.com/a/43579723/2611020
Vous utilisez l'opérateur de suppression au lieu de la propriété delete de la carte faible.
var a = { aa : { aa : 123 } };
var w = new WeakMap();
w.set(a.aa,"hello");
console.log(a.aa)
w.delete(a.aa); // try this
console.log(w);
Docs lien
ma question ne supprime pas quelque chose de lowmap. mon Q est: le point de faiblesse de la carte est: lorsque vous supprimez un objet qui a une référence dans la carte faible, la carte faible supprime l'objet à l'intérieur, afin que gc puisse supprimer l'objet de la mémoire. mais dans mon cas, même si je supprime un objet, lowmap conserve la référence à l'objet et cela fait échouer gc à la suppression de l'objet {aa: 123} . cela peut aider: stackoverflow.com/a/43579723/2611020
Je pense que vous pouvez obtenir ce que vous recherchez à partir d'ici stackoverflow.com/questions/49841096/...
oh mon Dieu . oui c'est la réponse. Merci beaucoup
Cependant, je n'ai pas travaillé avec lowmap mais la raison de ne pas supprimer via
delete a.aa
est simplement parce que w est une référence distincte à l'objet plutôt qu'un pointeur vers le même objet.
Les valeurs simples (aka primitives scalaires) sont toujours assignées / transmises par value-copy: null, undefined, string, number, boolean et le symbole ES6.
Les valeurs composées - les objets (y compris les tableaux et tous les wrappers d'objets encadrés - voir le chapitre 3) et les fonctions - créent toujours une copie de la référence lors de l'affectation ou du passage.
considérez l'extrait ci-dessous:
function foo(x) {
x.push( 4 );
x; // [1,2,3,4]
// later
x = [4,5,6];
x.push( 7 );
x; // [4,5,6,7]
}
var a = [1,2,3];
foo( a );
a; // [1,2,3,4] not [4,5,6,7]
Quand on passe l'argument a, il assigne une copie de la référence a à x. x et sont des références distinctes pointant sur la même valeur [1,2,3]. Maintenant, à l'intérieur de la fonction, nous pouvons utiliser cette référence pour muter la valeur elle-même (push (4)). Mais lorsque nous faisons l'affectation x = [4,5,6], cela n'affecte en rien l'endroit où la référence initiale a pointe - pointe toujours sur la valeur (maintenant modifiée) [1,2,3,4].
Donnez-lui une lecture à this !
J'espère que cela sera clair!
aucune carte faible n'est pas la même chose qu'un objet normal. lowmap est appelé faible car il contient une référence faible à l'objet et cette référence faible signifie que lorsque vous supprimez l'objet lui-même> il sera automatiquement supprimé de la carte faible et de la référence faible à l'intérieur w ne peut pas empêcher gorbage collector de supprimer l'objet. regardez cette réponse: stackoverflow.com/a/43579723/2611020
grâce à @ komal-bansal, cette question a déjà été répondue dans ce lien. ainsi marqué comme duplicata: stackoverflow.com/a/49841518/2611020