Sets in Javascript ES6


Before ES6, Javascript had no native implementation of Sets. What is a set? A set is a list of values that cannot contain duplicates. Let’s explore what problems that native ES6 Set solves, and how we can use them.


To create a new set, we can use new Set(). You can also give an iterator directly in the constructor.

const set = new Set()
console.log(set) // Set {}

const set = new Set([1, 2, 3])
console.log(set) // Set { 1, 2, 3 }

If you give an iterable with duplicates, the Set will ignore the duplicates after the first one:

const set = new Set([1, 2, 2, 2, 3, 4, 5, 5, 5, 4])
// Set { 1, 2, 3, 4, 5 }

The add method and size property

Sets have an add method that allow you to add a single item to the set. Sets also have a size property to retrieve the number of items in the set.

const set = new Set()
set.size // 0
set.size // 1

add is ignored if the set already has the value:

const set = new Set(['Hello', 'World'])
console.log(set) // Set { 'Hello', 'World' }

Problems solved from workarounds

Before sets, you would have to use normal objects to simulate a set. Because only strings can be use as keys, some problems could arise. 5 would be coerced into “5”, {} would be “[object Object]”. Sets do not coerce values. 5 and “5” are two different values.

const set = new Set()

set.size // 2
console.log(set) // Set { {}, {} }

set.add(5) // this will be ignored

set.size // 4
console.log(set) // Set { {}, {}, 5, '5' }

Therefore, multiple objects can be added to the set. Sets use to compare two values:, 5) //true, '5') //false{},{}) //false

The has, delete and clear methods

  • has(value) checks if the value is in the set. Returns true or false
  • delete(value) removes the value from the set
  • clear() removes all values from the set
const set = new Set()

set.has(5) // true
set.has(8) // false

const set = new Set([1, 2, 3])
set.size // 3
set.size // 2
set.size // 0


To iterate through a set, you can use the forEach() method. There is one little difference from when you are using it on an object/array. forEach() takes three arguments:

  • the value
  • the key ( index )
  • the array or object your are iterating

However, in a set, the first two arguments are the same. That is because sets don’t have keys. So:

const set = new Set([1, 2, 3])
set.forEach((value, key, s) => {
    console.log(`${value} ${key}`)
    console.log( set === s)

//1 1
//2 2
//3 3

That way, you can use the same method that you already used for arrays and objects.

Set => Array

We already saw that you can convert an array to a set by passing an array to the Set constructor. You can also convert a set to an array by using the spread operator:

const set = new Set([1, 2, 3])
const array = [...set]
console.log(array) // [ 1, 2, 3 ]

Weak sets

These sets could be called strong sets, because it holds object references. It works as if you would store an object inside a variable. As long as the set instance exists, the object can’t be garbage-collected in order to free memory.

const set = new Set()
let obj = {}

set.size // 1
obj = null
set.size // 1

// We can retrieve the original reference
obj = [...set][0]
console.log(obj) // {}

In some cases, you do want references in a set to disappear if all the other references disappear. ES6 includes weak sets. Weak sets can only store weak object references. So, if there are no other references to an object, the reference inside the set will disappear. WeakSet also cannot contain primitive values ( no strings or integers )

const set = new WeakSet()
let obj = {}

set.add(5) // ERROR
let obj = {}
set.has(obj) // true
obj = null // remove the reference to obj, also removes it in set
set.has(obj) // false


  • will throw errors if you pass nonobjects to add(), has() or delete().
  • are not iterables. You can’t use for-of or the forEach() method.
  • do not have a size property.

The limited functionality of weak sets is necessary to properly handle memory.


ES6 gives you a new way to create sets and solves a lot of ES5 issues with the workarounds developers used. Use weak sets if you only need to track object references and prevent memory leaks.

One Comment, RSS

  1. Maps in Javascript ES6 - Damien Cosset July 17, 2018 @ 9:18 pm

    […] introduced a lot of new things. I’ve already write about Sets, so today we’ll explore Maps. What are those? A Map is an unordered list of key-values pairs […]

Your email address will not be published. Required fields are marked *