TechCamp Pro
Learn the differences between Map, Set, WeakMap, and WeakSet in JavaScript. Understand their syntax, use cases, key differences, memory behavior, and when to use each.
Muhammad Ali
Full Stack Developer
Occasional notes on code, craft, and things I break along the way. No spam — unsubscribe anytime.
Written by
Muhammad Ali
Full Stack Developer
A Map is an object that holds key-value pairs where both the keys and the values can be any type of data. It is introduced in ES6.
A Set is a built-in object introduced in ES6 that allows storing unique values (no duplicates) of any data type.
JavaScript provides several built-in data structures for storing and managing collections of data.
The most commonly used ones are:
MapSetWeakMapWeakSetAt first, they can look quite similar, but each one is designed for a different purpose.
For example:
const map = new Map();
const set = new Set();
const weakMap = new WeakMap();
const weakSet = new WeakSet();
So, when should you use each one?
In this article, we'll understand all four with simple examples and real-world use cases.
A Map is an object that holds key-value pairs where both the keys and the values can be any type of data. It is introduced in ES6.
Best for complex data where keys can be any type (objects, functions, etc.).
Unlike a normal Object, a Map can use any value as a key.
const users = new Map();
users.set(1, "Ali");
users.set(2, "Ahmed");
console.log(users.get(1));
Output:
Ali
You can use strings, numbers, objects, functions, and other values as Map keys.
map.set(key, value);
map.get(key);
map.has(key);
map.delete(key);
map.clear();
map.size;
Example:
const user = new Map();
user.set("name", "Ali");
user.set("role", "Developer");
console.log(user.get("name")); // Ali
console.log(user.has("role")); // true
console.log(user.size); // 2
Maps are easy to iterate.
const users = new Map([
["name", "Ali"],
["age", 24],
["role", "Developer"]
]);
for (const [key, value] of users) {
console.log(key, value);
}
Output:
name Ali
age 24
role Developer
You can also use:
users.keys();
users.values();
users.entries();
Use Map when:
set(), get(), and has().A common real-world example is caching:
const cache = new Map();
cache.set(userId, userData);
const user = cache.get(userId);
A Set is a built-in object introduced in ES6 that allows storing unique values (no duplicates) of any data type.
If you add the same value multiple times, it will only be stored once.
const numbers = new Set();
numbers.add(10);
numbers.add(20);
numbers.add(10);
console.log(numbers);
Output:
Set(2) { 10, 20 }
The duplicate 10 is automatically ignored.
set.add(value);
set.has(value);
set.delete(value);
set.clear();
set.size;
Example:
const skills = new Set();
skills.add("JavaScript");
skills.add("React");
skills.add("Node.js");
console.log(skills.has("React")); // true
console.log(skills.size); // 3
One of the most useful applications of Set is removing duplicates from an array.
const numbers = [1, 2, 2, 3, 4, 4, 5];
const uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers);
Output:
[1, 2, 3, 4, 5]
This is one of the simplest ways to remove duplicate primitive values from an array.
A WeakMap is similar to a Map, but it has an important difference:
WeakMap keys must be objects or non-registered symbols.
For example:
const weakMap = new WeakMap();
const user = {
name: "Ali"
};
weakMap.set(user, "Developer");
console.log(weakMap.get(user));
Output:
Developer
You cannot use a normal string as a WeakMap key:
weakMap.set("user", "Ali");
That throws a TypeError.
The important concept is garbage collection.
Consider:
const weakMap = new WeakMap();
let user = {
name: "Ali"
};
weakMap.set(user, "Developer");
user = null;
After user no longer has another strong reference, the JavaScript engine can garbage-collect the object.
The WeakMap does not keep that object alive merely because it is used as a key.
This can be useful when associating extra information with objects without preventing those objects from being garbage-collected.
Unlike Map, you cannot do:
weakMap.size;
or:
weakMap.keys();
or:
for (const item of weakMap) {
}
This is intentional.
Because keys can disappear through garbage collection, the contents of a WeakMap are not designed to be enumerated.
WeakMap can be useful for storing metadata associated with objects.
const metadata = new WeakMap();
const user = {
name: "Ali"
};
metadata.set(user, {
lastLogin: "Today"
});
console.log(metadata.get(user));
The metadata is associated with the object without requiring you to modify the object itself.
A WeakSet is similar to a Set, but it stores objects only.
const weakSet = new WeakSet();
const user = {
name: "Ali"
};
weakSet.add(user);
console.log(weakSet.has(user));
Output:
true
Primitive values cannot be added:
weakSet.add("Ali");
This causes a TypeError.
WeakSet is useful when you only need to track whether an object has been seen or processed.
For example:
const processedUsers = new WeakSet();
const user = {
name: "Ali"
};
processedUsers.add(user);
if (processedUsers.has(user)) {
console.log("User already processed");
}
The object can still be garbage-collected when there are no other strong references to it.
| Feature | Map | Set | WeakMap | WeakSet |
|---|---|---|---|---|
| Stores | Key-value pairs | Unique values | Key-value pairs | Objects |
| Keys | Any value | — | Objects / non-registered symbols | — |
| Values | Any value | Any value | Any value | Objects |
| Duplicates | Keys unique | Values unique | Keys unique | Objects unique |
| Iterable | Yes | Yes | No | No |
.size | Yes | Yes | No | No |
| Garbage-collection-friendly keys | No | N/A | Yes | Yes |
| Main use | Key-value data | Unique values | Object metadata | Object tracking |
The biggest difference is how their keys behave.
const map = new Map();
let user = {
name: "Ali"
};
map.set(user, "Developer");
user = null;
The Map still has the key-value entry unless you explicitly remove it.
const weakMap = new WeakMap();
let user = {
name: "Ali"
};
weakMap.set(user, "Developer");
user = null;
The WeakMap does not prevent the object from being garbage-collected.
The same general idea applies here.
A Set can store primitive values and objects.
const set = new Set();
set.add(10);
set.add("JavaScript");
set.add({ name: "Ali" });
A WeakSet only stores objects.
const weakSet = new WeakSet();
weakSet.add({
name: "Ali"
});
A simple way to remember:
MapWhen you need:
Key → Value
Example:
userId → userData
SetWhen you need:
Unique Values
Example:
[1, 2, 3, 4]
without duplicates.
WeakMapWhen you need:
Object → Metadata
and don't want the association to prevent garbage collection.
WeakSetWhen you need:
Track Objects
without preventing those objects from being garbage-collected.
const weakMap = new WeakMap();
weakMap.set("user", "Ali");
WeakMap keys must be objects or non-registered symbols.
.sizeconsole.log(weakMap.size);
WeakMap does not provide .size.
for (const item of weakSet) {
console.log(item);
}
WeakSet is not iterable.
If you need:
userId → userData
a Map is usually more appropriate than a Set.
Use Map for dynamic key-value collections.
Use Set when you need unique values.
Use WeakMap for object-associated metadata and similar object-keyed relationships where weak references are useful.
Use WeakSet when you need to track objects without keeping them alive.
Don't use Map or WeakMap just because they are newer than Objects.
Choose the data structure based on the problem you're solving.
Map, Set, WeakMap, and WeakSet are powerful collection types in modern JavaScript.
You don't need to choose one based on which is "better." Each one solves a different problem.
If you need key-value pairs, use Map.
If you need unique values, use Set.
If you need object-keyed data that should not prevent garbage collection, consider WeakMap.
If you need to track objects without keeping them alive, consider WeakSet.
Understanding these four collections will help you write cleaner JavaScript and is also extremely useful for JavaScript interviews.