JavaScript Sets and Maps: Beyond Arrays and Objects

How to handle unique values and key-value pairs properly without type coercion and performance issues

Trevor I. Lasn Trevor I. Lasn
Updated 8 min read

Update: Corrected JSON Example

November 8, 2026: The “When Not to Use Sets and Maps” example said JSON.stringify(new Set()) returns []. It returns {}, the same as a Map, because a Set has no enumerable own properties; spread it into an array first, as the corrected example shows (MDN).

Before ES6 introduced Sets and Maps, we had limited options for storing collections of data in JavaScript. We used objects for key-value pairs and arrays for lists. This led to common problems:




What are Sets and Maps?

Sets and Maps are specialized data structures in JavaScript, each designed to solve specific problems that arrays and objects handle poorly.

A Set is a collection of unique values. Think of it like a bag that automatically removes duplicates.

When you add the same value twice, the Set keeps only one copy. It’s perfect for maintaining lists where each item should appear only once.

A Map is a collection of key-value pairs where keys can be any type - numbers, strings, objects, even functions. Unlike objects, which convert all keys to strings, Maps preserve the type of the key. This makes them ideal for creating dictionaries or caches where the key type matters:

Here’s how Sets and Maps solve the two problems we saw earlier with arrays and objects.

Sets and Maps excel at handling data relationships, caching, and uniqueness checks. Each has specific use cases where they outperform traditional arrays and objects.

When to Use Sets

Sets shine when you need fast lookups and uniqueness guarantees in your data. In a tag system, you can instantly check if an article has a specific tag without looping through an array.


When to Use Maps

Maps are perfect when you need to associate data with any type of key - like caching API responses by URL, storing user preferences, or maintaining a relationship between DOM elements and their data.


Performance Trade-offs

Sets and Maps provide O(1) operations through their hash table implementation, compared to arrays which have O(n) for lookups and objects which coerce keys to strings.

Info

O(1) means an operation takes the same amount of time regardless of how much data you have - it’s “constant time”. If you have 10 items or 10 million items in your Set or Map, operations like adding, checking, or retrieving items will be equally fast.

Info

O(n) means the operation time grows linearly with the size of your data. If you have 1000 items, it might check 1000 times. If you have a million items, it might check a million times. The more data you have, the slower it gets.

However, this speed comes at a cost: Sets and Maps use more memory than arrays and objects. The hash table structure that enables their fast operations requires additional memory overhead to maintain.

For Sets specifically, the hash table ensures that duplicate detection is instantaneous, rather than requiring a full array scan. Maps achieve their performance by using a similar structure but storing both the key and value in the hash table.

Sets and Maps excel at handling user sessions. Sets provide instant O(1) lookups to check if a user is logged in - much faster than searching through an array of user IDs. Maps let us store session data with any type of user identifier (number, string, or object) without key type conversion issues.

The SessionManager example shows how Sets can track unique active users while Maps store detailed session data. This combination is particularly powerful because it separates concerns - the Set handles uniqueness while the Map handles data association.

The instant lookup times make this ideal for high-traffic applications where performance is critical.

When Not to Use Sets and Maps

Sets and Maps come with memory overhead from their hash table structure. For small collections or simple string keys, arrays and objects might be more efficient.

Sets and Maps aren’t just alternatives to arrays and objects - they’re specialized tools that make specific programming patterns more efficient and reliable. Use them when their unique characteristics align with your needs, and you’ll write more robust and performant code.

Info

Key takeaway: Sets solve the unique values problem, while Maps solve the key-type coercion problem. They trade more memory usage for better performance and type safety.

ES2025 Set Methods

As of ES2025, Sets gained several new methods for working with set operations directly:

These methods are now supported in all major browsers (Baseline since June 2024) and make many common set operations that previously required manual iteration available as built-in methods.


Trevor I. Lasn

Trevor I. Lasn

Building whiteheap.com and 0xinsider.com.



Related Articles

Check out these related articles that might be useful for you. They cover similar topics and provide additional insights.

JavaScript
4 min read

Stop mixing try/catch with Promise chains - JavaScript's new Promise.try handles return values, Promises, and errors uniformly

Nov 10, 2024
Read article
JavaScript
19 min read

Common causes of JavaScript memory leaks in Node.js and Deno, such as global objects and callbacks that hold large data, and how to profile heap usage.

Aug 10, 2024
Read article
JavaScript
4 min read

A left shift multiplies a number by 2 per position, and a right shift divides it by 2. How JavaScript's bitwise shift operators work, with binary examples.

Nov 12, 2024
Read article
JavaScript
3 min read

x ??= y assigns y only when x is null or undefined, so 0, false and empty strings stay. How it differs from || and where it saves code.

Nov 5, 2024
Read article
JavaScript
5 min read

scheduler.postTask() runs JavaScript at user-blocking, user-visible or background priority, giving finer control than setTimeout(0) over when work runs.

Nov 26, 2024
Read article
JavaScript
3 min read

Use the &&= operator to safely update truthy values while preserving falsy states

Nov 5, 2024
Read article
JavaScript
6 min read

Closures are essential for creating functions that maintain state, without relying on global variables.

Sep 6, 2024
Read article
JavaScript
7 min read

How was JavaScript written back in the day? I dug into early frameworks and libraries to see how code looked then and what still holds up.

Jun 12, 2025
Read article
JavaScript
6 min read

The creator of JavaScript and Node.js are challenging Oracle's control over the JavaScript name

Nov 23, 2024
Read article

This article was originally published on https://www.trevorlasn.com/blog/sets-and-maps-in-javascript. It was written by a human and polished using grammar tools for clarity.