WeakSet

ES6+ WeakSet Overview

WeakSet is an ES6 collection that stores unique objects using weak references. Unlike a regular Set, a WeakSet does not prevent its objects from being garbage collected when no other references to them exist.

WeakSet is useful when you need to track object membership temporarily without causing memory leaks. Common examples include marking DOM nodes as processed, preventing duplicate event handler attachment, and tagging objects for internal library logic.

Basic WeakSet Example

const visitedUsers =
  new WeakSet();

const userA = { id: 1, name: "Alex" };
const userB = { id: 2, name: "Sam" };

visitedUsers.add(userA);
visitedUsers.add(userB);

console.log(visitedUsers.has(userA));
console.log(visitedUsers.has(userB));

visitedUsers.delete(userA);

console.log(visitedUsers.has(userA));

A WeakSet works like a Set for checking membership, but it only accepts objects. Use add(), has(), and delete() to manage tracked objects.

How WeakSet Works

When you add an object to a WeakSet, the collection holds a weak reference to that object. If the object is removed from your application and no strong references remain, JavaScript can garbage collect it and automatically remove it from the WeakSet.

WeakSet vs Set

WeakSet Accepts Objects Only

const tags =
  new WeakSet();

const product = {
  id: 101,
  name: "Laptop"
};

tags.add(product);
console.log(tags.has(product));

// This throws a TypeError

// tags.add("laptop");
// tags.add(101);
// tags.add(true);

WeakSet cannot store strings, numbers, booleans, or other primitives. It only works with object references such as plain objects, arrays, functions, and DOM nodes.

Track Processed DOM Nodes

const initializedElements =
  new WeakSet();

function setupTooltip(element) {
  if (initializedElements.has(element)) {
    return;
  }

  element.addEventListener("mouseenter", () => {
    console.log("Show tooltip");
  });

  initializedElements.add(element);
}

const button =
  document.querySelector("#helpButton");

setupTooltip(button);
setupTooltip(button);

WeakSet is ideal for marking DOM elements that already received setup logic. If the element is removed from the page and garbage collected, the WeakSet entry disappears automatically.

Prevent Duplicate Processing

const processedRequests =
  new WeakSet();

function handleRequest(request) {
  if (processedRequests.has(request)) {
    console.log("Already handled.");
    return;
  }

  console.log("Processing request...");
  processedRequests.add(request);
}

const requestA = { url: "/api/users" };
const requestB = { url: "/api/orders" };

handleRequest(requestA);
handleRequest(requestA);
handleRequest(requestB);

Use WeakSet when you need to remember which object instances were already handled without keeping those objects alive longer than necessary.

Tag Objects Internally

const validatedForms =
  new WeakSet();

function validateForm(formObject) {
  if (validatedForms.has(formObject)) {
    return true;
  }

  const isValid =
    formObject.email.includes("@");

  if (isValid) {
    validatedForms.add(formObject);
  }

  return isValid;
}

const signupForm = {
  email: "alex@example.com"
};

console.log(validateForm(signupForm));
console.log(validatedForms.has(signupForm));

Libraries and modules can use WeakSet to attach internal state to objects without modifying the objects themselves or exposing extra properties on them.

Weak References and Garbage Collection

const cache =
  new WeakSet();

function trackTempObject() {
  const temp = { id: Date.now() };
  cache.add(temp);
  return temp;
}

let item = trackTempObject();
console.log(cache.has(item));

item = null;

// Later, when temp has no other references,
// it can be garbage collected and removed
// from the WeakSet automatically

Because WeakSet does not strongly hold objects, it helps avoid memory leaks in long-running applications where temporary object tracking is needed.

WeakSet Methods

WeakSet Limitations

• Cannot store primitive values such as strings or numbers.
• Has no size property.
• Cannot iterate with for...of.
• No forEach(), keys(), or values() methods.
• Cannot convert directly to an array.
• Membership checks only work if you still hold the object reference.

Common WeakSet Use Cases

• Marking DOM nodes that already have event listeners attached.
• Preventing duplicate initialization of components or plugins.
• Tracking temporary object instances during processing.
• Tagging validated, cached, or authenticated object instances.
• Internal library bookkeeping without modifying user objects.
• Memory-safe membership tracking in long-lived applications.

WeakSet Best Practices

• Use WeakSet only when object membership tracking is enough.
• Prefer WeakSet over Set when garbage collection matters.
• Keep a strong reference to an object if you need to check it later.
• Use regular Set when you need iteration, size, or primitives.
• Do not expect to list all items stored in a WeakSet.
• Combine WeakSet with clear object lifecycle management.
• Document why weak membership tracking is needed in your code.

Common WeakSet Mistakes

• Trying to store strings, numbers, or booleans in a WeakSet.
• Expecting to loop through WeakSet contents.
• Using WeakSet when a Map or Set with iteration is required.
• Assuming has() works after losing all object references.
• Using WeakSet for general-purpose unique value storage.
• Expecting a size property to count stored objects.
• Choosing WeakSet without understanding garbage collection behavior.

WeakSet vs WeakMap

Key Takeaways

• WeakSet is an ES6 collection for tracking unique object references.
• It uses weak references, so objects can be garbage collected naturally.
• Use add(), has(), and delete() to manage membership.
• WeakSet cannot store primitives and is not iterable.
• Choose WeakSet for memory-safe object tagging, not general data storage.