JavaScript WeakMap

A WeakMap in JavaScript is a collection of key-value pairs where the keys are objects, and the values can be any arbitrary value. Unlike regular maps, WeakMap keys are weakly referenced, meaning they don't prevent garbage collection.

• The keys in a WeakMap can be automatically removed when no longer in use, helping save memory.
• You can't loop through the keys or values in a WeakMap.

Syntax

const weakmap=new WeakMap()

To create a new weak map, the constructor function of the inbuilt WeakMap class is invoked with the help of the new keyword. This initiates a weak map object that can be used to invoke various properties present in itself as it is a class.

Working of Weak Map

• In a WeakMap, the keys are weakly referenced, meaning they do not prevent garbage collection. If there are no other references to a key, it can be collected as garbage.
• Only objects can be used as keys in a WeakMap. Primitive values like strings or numbers cannot be used as keys.
• You cannot iterate over the keys or values in a WeakMap. Methods like forEach() and keys() are not available.
• When a key is garbage collected, its corresponding value is automatically removed from the WeakMap, ensuring there are no memory leaks.
• WeakMap is often used to create private properties for objects, as it allows storing private data without exposing it to outside access.

Components of a Weak Map

• Keys: The keys in a WeakMap must be objects. Primitive values like strings, numbers, or booleans cannot be used as keys.
• Values: The values in a WeakMap can be any type of data, including primitives or objects, and are associated with the keys.
• Garbage Collection: The keys in a WeakMap are weakly referenced, meaning that if there are no other references to a key object, it can be garbage collected along with its associated value.
• No Iteration: Unlike regular maps, a WeakMap does not allow iteration (such as using forEach() or keys()) because of the weak references to keys.
• Size: There is no direct way to check the size of a WeakMap. Since the garbage collector may remove keys at any time, the size is not a reliable property to access.

Implementation of a Weak Map

Here’s a simple example demonstrating how to use a WeakMap in JavaScript. It shows how to associate object keys with values and how the garbage collector can remove key-value pairs when the key is no longer referenced.

let weakMap = new WeakMap();

let obj1 = { name: "Pranjal" };
let obj2 = { name: "Pranav" };

weakMap.set(obj1, "Engineer");
weakMap.set(obj2, "Designer");

console.log(weakMap.get(obj1)); 
console.log(weakMap.get(obj2)); 


obj2 = null;

• A WeakMap is initialized with let weakMap = new WeakMap();. This will hold key-value pairs where the keys must be objects.
• Two objects, obj1 and obj2, are created and used as keys in the WeakMap. obj1 is associated with the value "Engineer" and obj2 with "Designer" using weakMap.set().
• The values associated with obj1 and obj2 are accessed using weakMap.get(). The console logs will show "Engineer" for obj1 and "Designer" for obj2.
• When obj2 is set to null, it no longer has a reference in the code. This allows the WeakMap to potentially remove obj2 and its associated value from memory since the key (obj2) is no longer referenced elsewhere.
• Since WeakMap uses weak references for keys, obj2 and its associated value may be garbage collected after obj2 = null, freeing up memory.

Functions present in Weak Map

• set(key, value): Adds a key-value pair to the WeakMap. The key must be an object.
• get(key): Retrieves the value associated with the given key. If the key does not exist, it returns undefined.
• has(key): Checks if a specific key exists in the WeakMap. Returns true if the key is present, otherwise false.
• delete(key): Removes the specified key and its associated value from the WeakMap. Returns true if the key was successfully removed, otherwise false.
• clear(): Clears all key-value pairs from the WeakMap. However, it is rarely used in practice since WeakMap entries are automatically removed when keys are garbage collected.

Coding Problems on WeakMap

• String Reversal
• Map Operations
• Parties and seats
• Unique Number of Occurrences
• Twice Counter
• Frequency Game
• Powerfull Integer
• Balloon Everywhere
• Sum of f(a[i], a[j]) over all pairs in an array of n integers
• Word with maximum frequency
• Duplicate Elements
• Earthquake and the Paint Shop 

Background working of WeakMap

A WeakMap stores key-value pairs where the keys are objects. If there are no other references to a key, it can be garbage collected, and the entry in the WeakMap will be removed automatically. Unlike Map, you can’t loop through a WeakMap because keys can be removed at any time. Only objects can be used as keys, making it memory-efficient for temporary data storage without blocking object cleanup.

Advantages of Weak Map

• Memory Efficiency: Automatically frees memory by allowing garbage collection of unused keys.
• Garbage Collection: Keys can be garbage-collected when there are no other references to them.
• No Enumeration: Does not allow iteration over keys or values, protecting privacy.
• Key Constraints: Only objects can be used as keys, preventing issues with primitive types.
• Efficient Memory Management: Ideal for scenarios like caching, where unused data is automatically removed.