What are WeakSet and WeakMap, and the difference between them?

In JavaScript, collections such as Set and Map are powerful structures that allow us to store unique values and key-value pairs, respectively. However, when dealing with large applications, memory management becomes crucial. That’s where WeakSet and WeakMap come into play. These structures provide a way to hold “weak” references to objects, allowing for better garbage collection. Let’s dive deeper into what WeakSet and WeakMap are and how they differ from Set and Map.

WeakSet

A WeakSet is a collection of objects. Unlike a regular Set, which can store any type of value, a WeakSet can only store objects. Here’s the twist: WeakSet holds its objects weakly, meaning if there are no other references to an object stored in a WeakSet, the object can be garbage collected. This feature is particularly useful when creating a group of objects without preventing those objects from being garbage-collected.

Example of the WeakSet object

// Creating a WeakSet
let weakSet = new WeakSet();
// Creating objects
let object1 = {};
let object2 = {};
// Adding objects to the WeakSet
weakSet.add(object1);
weakSet.add(object2);
// Checking if an object is in the WeakSet
console.log(weakSet.has(object1)); // true
console.log(weakSet.has(object2)); // true
// Removing an object
weakSet.delete(object1);
console.log(weakSet.has(object1)); // false

In this example, we manipulate WeakSet by adding and removing objects, demonstrating how it interacts with its elements.

WeakMap

A WeakMap is similar to a regular Map but with a key difference: its keys are weakly referenced. A WeakMap can only have objects as keys, and if there’s no other reference to a key, the key-value pair in the WeakMap can be garbage collected. This characteristic is beneficial when we want to associate data with an object without preventing the object from being garbage-collected.

Example of the WeakMap object

// Creating a WeakMap
let weakMap = new WeakMap();
// Creating keys
let key1 = {};
let key2 = {};
// Setting key-value pairs
weakMap.set(key1, "Hello");
weakMap.set(key2, "World");
// Accessing values
console.log(weakMap.get(key1)); // "Hello"
console.log(weakMap.get(key2)); // "World"
// Checking for a key and deleting
weakMap.delete(key1);
console.log(weakMap.has(key1)); // false

This code snippet shows how to work with WeakMap, including setting values, checking for the existence of keys, and deleting key-value pairs.

Differences between WeakSet/WeakMap and Set/Map

Following are the major difference between WeakSet/WeakMap and Set/Map.

Feature

WeakSet/WeakMap

Set/Map

Reference Strength

Holds weak references, allows garbage collection

Holds strong references, prevents garbage collection

Element Types


Can only contain objects


Can contain both objects and primitive values

Enumeration

Not enumerable (no size property or iterator)

Enumerable (has size property and iterator)

Use Cases


Suitable for caching and tracking without affecting life cycle


Used for storing collections with life cycle tied to existence

In summary, WeakSet and WeakMap offer specialized behavior that is useful for managing memory and references in applications where objects may not need to persist indefinitely. By understanding and utilizing these structures, developers can write more efficient and effective JavaScript code.

Free Resources

Copyright ©2025 Educative, Inc. All rights reserved