Why Does Javascript Set Not Do Unique Objects

JavaScript's Set object is a useful data structure that allows you to store unique values of any type, whether primitive values or object references. However, when it comes to objects, the behavior of Set might not always work as expected, especially when dealing with unique object instances.

When you try to add objects to a Set in JavaScript, you may notice that the uniqueness of objects is not determined as you might anticipate. Unlike with primitive values such as numbers or strings, where each value is unique, objects are compared by reference, not by their content. This means that even if two objects have the same properties and values, they are considered different if they refer to different memory locations.

To illustrate this behavior, consider the following example:

const mySet = new Set();

const obj1 = { name: 'Alice' };
const obj2 = { name: 'Alice' };

mySet.add(obj1);
mySet.add(obj2);

console.log(mySet.size); // Output: 2

In this code snippet, even though `obj1` and `obj2` have the same properties and values, they are two distinct objects in memory. Therefore, both objects are added to the Set independently, resulting in a Set with a size of 2.

To work around this behavior and ensure that Set only stores unique objects based on their content, one common approach is to convert objects into a unique identifier that reflects their content. This can be achieved by serializing the objects into a string format that represents their content in a standardized way.

Here's how you can modify the previous example to use object serialization for uniqueness:

const mySet = new Set();

const obj1 = { name: 'Alice' };
const obj2 = { name: 'Alice' };

mySet.add(JSON.stringify(obj1));
mySet.add(JSON.stringify(obj2));

console.log(mySet.size); // Output: 1

By serializing the objects using `JSON.stringify()`, you convert the objects into strings that represent their content. As a result, when you add these serialized objects to the Set, duplicates are automatically removed since their string representations are the same.

It's worth noting that this approach has limitations, especially when dealing with complex objects or objects that contain non-serializable properties like functions. In such cases, you may need to implement custom logic to compare object properties and determine uniqueness based on specific criteria.

In conclusion, while JavaScript's Set object is an efficient way to store unique values, handling unique objects requires careful consideration of how object uniqueness is determined. By understanding the comparison behavior of objects in JavaScript, you can implement strategies like object serialization to ensure that Sets work as expected when dealing with object instances.