---

---

In the previous article, we learned that once the keyed object in WeakMap is changed/overridden to null, it gets removed from memory because the WeakMap can't reach it any longer. It helps to free up space when past stored data are not needed. Such objects are garbage-collected automatically. JavaScript engine cleans up the memory at a specific instance.

let bello = { name: "Bello" };

const weakMap = new WeakMap();
weakMap.set(bello, 'secret documents');

bello = null; // changed/overriden reference

console.log( weakMap.has(bello) ); // false 
// bello is removed from memory!

If Map is used in place of weakMap then the object bello still exists provided WeakMap is alive even though it can't get the reference to its keyed object, bello. Such objects are non-garbage-collected.

let bello = { name: "Bello" };

const map = new Map();
map.set(bello, 'secret documents');

bello = null; // overwrite the reference

console.log( map.keys() ); // [Map Iterator] { { name: 'Bello' } }
// bello still exist

Let's see the use cases of WeakMap below:

---

Additional data storage

In the example above, if bello dies then the secret documents will be destroyed automatically.

Another example is to assume a website is accessible to signed-up users.

In the example below, the user object is the key and the signed-up count is the value.

signup.js

const signedUpMap = new WeakMap(); // weakmap: user => visits count

// increase the visits count
function countUser(user) {
  let count = signedUpMap.get(user) || 0;
  signedUpMap.set(user, count + 1);
}

For a user that deletes his/her account, the count is reduced and the data of the user are removed from memory automatically.

count.js

let bello = { name: "Bello" };

countUser(bello); // bello signed-up

bello = null; // Bello deleted his account

---

Caching

Cache memory is a chip-based computer component that makes retrieving data from the computer's memory more efficient. It acts as a temporary storage area for the computer's processor to retrieve data from easily - SeachStorage

Let's assume we can store (cache) results from a function, so that future calls on the same object can reuse it.

cache.js

let cache = new WeakMap();

// calculate and remember the result
function process(obj) {
  if (!cache.has(obj)) {
    let result = /* calculate the result for */ obj;

    cache.set(obj, result);
  }

  return cache.get(obj);
}

main.js

let obj = {/* some object */};

let result1 = process(obj);
let result2 = process(obj);

// ...later, when the object is not needed any more:
obj = null;

// Can't get cache.size, as it's a WeakMap,
// but it's 0 or soon be 0
// When obj gets garbage collected, cached data will be removed as well

For multiple calls of process(obj) with the same object, there's a clean-up of cache when certain objects are not needed. That is, the cached result will be removed from memory automatically after the object gets garbage collected.

You can read more on cache on MDN

---

weakRef

The weakRef feature was introduced in ECMAScript 2021. It holds a weak reference to another object. It doesn't prevent garbage collection of unreachable object. It is useful when we don't want to keep the object in memory forever.

See the example below:

const weakRef= new WeakRef({ name: 'Bello', age: 27 });

console.log( weakRef.deref() ); // {name: "Bello", age: 27}
console.log( weakRef.deref().name ); // Bello

Learn more on MDN

---

---