AWeakSet is a collection of garbage-collectable values, including objects andnon-registered symbols. A value in theWeakSet may only occur once. It is unique in theWeakSet's collection.

Description

Values of WeakSets must be garbage-collectable. Mostprimitive data types can be arbitrarily created and don't have a lifetime, so they cannot be stored. Objects andnon-registered symbols can be stored because they are garbage-collectable.

The main differences to theSet object are:

• WeakSets are collections ofobjects and symbols only. They cannot contain arbitrary values of any type, asSets can.

• TheWeakSet isweak, meaning references to objects in aWeakSet are heldweakly. If no other references to a value stored in theWeakSet exist, those values can be garbage collected.

  Note:This also means that there is no list of current values stored in the collection.WeakSets are not enumerable.

Key equality

Like regularSet, value equality is based on theSameValueZero algorithm, which is the same as the=== operator becauseWeakSet can only hold object and symbol values. This means that for object values, equality is based on object identity. They are compared byreference, not by value.

Constructor

WeakSet()

Creates a newWeakSet object.

Instance properties

These properties are defined onWeakSet.prototype and shared by allWeakSet instances.

WeakSet.prototype.constructor

The constructor function that created the instance object. ForWeakSet instances, the initial value is theWeakSet constructor.

WeakSet.prototype[Symbol.toStringTag]

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

Instance methods

WeakSet.prototype.add()

Inserts the specified value into this set, if it is not already present.

WeakSet.prototype.delete()

Removes the specified value from this set, if it is in the set.

WeakSet.prototype.has()

Returns a boolean indicating whether the specified value exists in thisWeakSet or not.

Examples

Using the WeakSet object

const ws = new WeakSet();const foo = {};const bar = {};ws.add(foo);ws.add(bar);ws.has(foo); // truews.has(bar); // truews.delete(foo); // removes foo from the setws.has(foo); // false, foo has been removedws.has(bar); // true, bar is retained

Note thatfoo !== bar. While they are similar objects,they are notthe same object. And so they are both added to the set.

Detecting circular references

Functions that call themselves recursively need a way of guarding against circular data structures by tracking which objects have already been processed.

WeakSets are ideal for this purpose:

// Execute a callback on everything stored inside an objectfunction execRecursively(fn, subject, _refs = new WeakSet()) {  // Avoid infinite recursion  if (_refs.has(subject)) {    return;  }  fn(subject);  if (typeof subject === "object" && subject) {    _refs.add(subject);    for (const key in subject) {      execRecursively(fn, subject[key], _refs);    }    _refs.delete(subject);  }}const foo = {  foo: "Foo",  bar: {    bar: "Bar",  },};foo.bar.baz = foo; // Circular reference!execRecursively((obj) => console.log(obj), foo);

Here, aWeakSet is created on the first run, and passed along with every subsequent function call (using the internal_refs parameter).

The number of objects or their traversal order is immaterial, so aWeakSet is more suitable (and performant) than aSet for tracking object references, especially if a very large number of objects is involved.

Specifications

Browser compatibility

See also

• Polyfill ofWeakSet incore-js
• Map
• Set
• WeakMap