Set objects are collections of values. A value in the setmay only occur once; it is unique in the set's collection. You can iterate through the elements of a set in insertion order. Theinsertion order corresponds to the order in which each element was inserted into the set by theadd() method successfully (that is, there wasn't an identical element already in the set whenadd() was called).

The specification requires sets to be implemented "that, on average, provide access times that are sublinear on the number of elements in the collection". Therefore, it could be represented internally as a hash table (with O(1) lookup), a search tree (with O(log(N)) lookup), or any other data structure, as long as the complexity is better than O(N).

Value equality is based on theSameValueZero algorithm. (It used to useSameValue, which treated0 and-0 as different. Checkbrowser compatibility.) This meansNaN is considered the same asNaN (even thoughNaN !== NaN) and all other values are considered equal according to the semantics of the=== operator.

Thehas method checks if a value is in the set, using an approach that is, on average, quicker than testing most of the elements that have previously been added to the set. In particular, it is, on average, faster than theArray.prototype.includes method when an array has alength equal to a set'ssize.

TheSet object provides some methods that allow you to compose sets like you would with mathematical operations. These methods include:

Method	Return type	Mathematical equivalent	Venn diagram
A.difference(B)	Set	$A\setminus B$
A.intersection(B)	Set	$A\cap B$
A.symmetricDifference(B)	Set	$(A\setminus B)\cup (B\setminus A)$
A.union(B)	Set	$A\cup B$
A.isDisjointFrom(B)	Boolean	$A\cap B=\varnothing$
A.isSubsetOf(B)	Boolean	$A\subseteq B$
A.isSupersetOf(B)	Boolean	$A\supseteq B$

To make them more generalizable, these methods don't just acceptSet objects, but anything that'sset-like.

Allset composition methods requirethis to be an actualSet instance, but their arguments just need to be set-like. Aset-like object is an object that provides the following:

• Asize property that contains a number.
• Ahas() method that takes an element and returns a boolean.
• Akeys() method that returns aniterator of the elements in the set.

For example,Map objects are set-like because they also havesize,has(), andkeys(), so they behave just like sets of keys when used in set methods:

const a = new Set([1, 2, 3]);const b = new Map([  [1, "one"],  [2, "two"],  [4, "four"],]);console.log(a.union(b)); // Set(4) {1, 2, 3, 4}

Arrays are not set-like because they don't have ahas() method or thesize property, and theirkeys() method produces indices instead of elements.WeakSet objects are also not set-like because they don't have akeys() method.

BrowserSet-like objects (or "setlike objects") areWeb API interfaces that behave in many ways like aSet.

Just likeSet, elements can be iterated in the same order that they were added to the object.Set-like objects andSet also have properties and methods that share the same name and behavior.However unlikeSet they only allow a specific predefined type for each entry.

The allowed types are set in the specification IDL definition.For example,GPUSupportedFeatures is aSet-like object that must use strings as the key/value.This is defined in the specification IDL below:

interface GPUSupportedFeatures {  readonly setlike<DOMString>;};

Set-like objects are either read-only or read-writable (see thereadonly keyword in the IDL above).

• Read-onlySet-like objects have the propertysize, and the methods:entries(),forEach(),has(),keys(),values(), andSymbol.iterator().
• WriteableSet-like objects additionally have the methods:clear(),delete(), andadd().

The methods and properties have the same behavior as the equivalent entities inSet, except for the restriction on the types of the entry.

The following are examples of read-onlySet-like browser objects:

• GPUSupportedFeatures
• XRAnchorSet

The following are examples of writableSet-like browser objects:

• CustomStateSet
• FontFaceSet
• Highlight

Set()

Creates a newSet object.

Set[Symbol.species]

The constructor function that is used to create derived objects.

These properties are defined onSet.prototype and shared by allSet instances.

Set.prototype.constructor

The constructor function that created the instance object. ForSet instances, the initial value is theSet constructor.

Set.prototype.size

Returns the number of values in theSet object.

Set.prototype[Symbol.toStringTag]

The initial value of the[Symbol.toStringTag] property is the string"Set". This property is used inObject.prototype.toString().

Set.prototype.add()

Inserts a new element with a specified value in to aSet object, if there isn't an element with the same value already in theSet.

Set.prototype.clear()

Removes all elements from theSet object.

Set.prototype.delete()

Removes the element associated to thevalue and returns a boolean asserting whether an element was successfully removed or not.Set.prototype.has(value) will returnfalse afterwards.

Set.prototype.difference()

Takes a set and returns a new set containing elements in this set but not in the given set.

Set.prototype.entries()

Returns a new iterator object that containsan array of[value, value] for each element in theSet object, in insertion order. This is similar to theMap object, so that each entry'skey is the same as itsvalue for aSet.

Set.prototype.forEach()

CallscallbackFn once for each value present in theSet object, in insertion order. If athisArg parameter is provided, it will be used as thethis value for each invocation ofcallbackFn.

Set.prototype.has()

Returns a boolean asserting whether an element is present with the given value in theSet object or not.

Set.prototype.intersection()

Takes a set and returns a new set containing elements in both this set and the given set.

Set.prototype.isDisjointFrom()

Takes a set and returns a boolean indicating if this set has no elements in common with the given set.

Set.prototype.isSubsetOf()

Takes a set and returns a boolean indicating if all elements of this set are in the given set.

Set.prototype.isSupersetOf()

Takes a set and returns a boolean indicating if all elements of the given set are in this set.

Set.prototype.keys()

An alias forSet.prototype.values().

Set.prototype.symmetricDifference()

Takes a set and returns a new set containing elements which are in either this set or the given set, but not in both.

Set.prototype.union()

Takes a set and returns a new set containing elements which are in either or both of this set and the given set.

Set.prototype.values()

Returns a new iterator object that yields thevalues for each element in theSet object in insertion order.

Set.prototype[Symbol.iterator]()

Returns a new iterator object that yields thevalues for each element in theSet object in insertion order.

The iteration over a set visits elements in insertion order.

for (const item of mySet1) {  console.log(item);}// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5for (const item of mySet1.keys()) {  console.log(item);}// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5for (const item of mySet1.values()) {  console.log(item);}// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5// key and value are the same herefor (const [key, value] of mySet1.entries()) {  console.log(key);}// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5// Convert Set object to an Array object, with Array.fromconst myArr = Array.from(mySet1); // [1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2}, 5]// the following will also work if run in an HTML documentmySet1.add(document.body);mySet1.has(document.querySelector("body")); // true// converting between Set and Arrayconst mySet2 = new Set([1, 2, 3, 4]);console.log(mySet2.size); // 4console.log([...mySet2]); // [1, 2, 3, 4]// intersect can be simulated viaconst intersection = new Set([...mySet1].filter((x) => mySet2.has(x)));// difference can be simulated viaconst difference = new Set([...mySet1].filter((x) => !mySet2.has(x)));// Iterate set entries with forEach()mySet2.forEach((value) => {  console.log(value);});// 1// 2// 3// 4

• Polyfill ofSet incore-js
• es-shims polyfill ofSet
• Map
• WeakMap
• WeakSet