Bdtjtk

when delete the object , weakmap keeps refrence to it.

but the normal behaviour is : when oyu delete the object it will removed from weakmap automatically and weakmap cannot cause memory leak.

is it something wrong with weakmap or 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

i've closed and open the devtool and {aa:123} is still there.

expect weakmap to be empty

Your delete() function should look like this:

 w.delete(a.aa);

You are using delete operator instead of delete property of weak map.

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 link

However I have not worked with weakmap but the reason behind not deleting through

delete a.aa

is just because w is separate reference to the object rather pointer to the same object.

Simple values (aka scalar primitives) are always assigned/passed by value-copy: null, undefined, string, number, boolean, and ES6's symbol.

Compound values -- objects (including arrays, and all boxed object wrappers -- see Chapter 3) and functions -- always create a copy of the reference on assignment or passing.

consider the below snippet:

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]

When we pass in the argument a, it assigns a copy of the a reference to x. x and are a separate references pointing at the same [1,2,3] value. Now, inside the function, we can use that reference to mutate the value itself (push(4)). But when we make the assignment x = [4,5,6], this is in no way affecting where the initial reference a is pointing -- still points at the (now modified) [1,2,3,4] value.

Give it a read to this!

Hope it makes it clear!