Set

• The Set object lets you store unique values of any type, whether primitive values or object references.
• Set objects are collections of values. A value in the set may only occur once. It is unique in the set's collection. You can iterate through the elements of a set in insertion order. The insertion order corresponds to the order in which each element was inserted into the set by the add() method successfully (that is, there wasn't an identical element already in the set when add() was called).
• The specification requires sets to be implemented "that, on average, provide access times that are sub-linear 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
  • Value equality is based on the SameValueZero Algorithm. (It used to use SameValue, which treated 0 and -0 as different. Check browser compatibility.) This means NaN is considered the same as NaN (even though NaN !== NaN) and all other values are considered equal according to the semantics of the === operator.
• Performance
  • The has 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 the Array.prototype.includes method when an array has a length equal to a set's size.
• Set composition

  • The Set object provides some methods that allow you to compose sets like you would with mathematical operations. These methods include

    Method	Return type	Mathematical equivalent
    A.difference(B)	Set	A \ B
    A.intersection(B)	Set	A ∩ B
    A.symmetricDifference(B)	Set	( A \ B ) U ( B \ A )
    A.union(B)	Set	A U B
    A.isDisjointFrom(B)	Boolean	A ∩ B = ∅
    A.isSubsetOf(B)	Boolean	A ⊆ B
    A.isSupersetOf(B)	Boolean	A ⊇ B

  • To make them more generalizable, these methods don't just accept Set objects, but anything that's set-like.

Set-like objects

• All set composition methods require this to be an actual Set instance, but their arguments just need to be set-like. A set-like object is an object that provides the following:

  • A size property that contains a number.
  • A has() method that takes an element and returns a boolean.
  • A keys() method that returns an iterator of the elements in the set.

• For example, Map objects are set-like because they also have size, has(), and keys(), 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 a has() method or the size property, and their keys() method produces indices instead of elements. WeakSet objects are also not set-like because they don't have a keys() method.

Constructor

• Set() - Creates a new Set object

Static properties

• Set[Symbol.species] - The constructor function that is used to create derived objects.

Instance properties

• These properties are defined on Set.prototype and shared by all Set instances.
• Set.prototype.constructor
  • The constructor function that created the instance object. For Set instances, the initial value is the Set constructor.
• Set.prototype.size
  • Returns the number of values in the Set object.