How to Find Unique Objects in an Array in JavaScript by Object Reference or Key-Value Pairs

I’ll use Set to remove duplicate objects from an array by object reference. Then I’ll find objects by looking at key-value pairs.

8 min readDec 19, 2020

Finding Unique Objects in a JavaScript Array

The powerful ES6 feature Set only accepts one copy of each value added to it, making it perfect for finding distinct objects in JavaScript.

“The Set object lets you store unique values of any type, whether primitive values or object references.”
— MDN docs

In this tutorial, you’ll learn exactly how best to use Set when working with an array containing JavaScript objects that may be duplicates.

I’ll be exploring using Set to remove any duplicate objects from the array. First, I’ll find unique objects based on the objects’ variable name (objects with the same object reference). Then, I’ll filter for objects with identical key-value pairs (that have the same content but different object references).

Using Set to Find Unique Objects

You may already be familiar with the basic idea of Set — you can only add each value to a Set once, leaving a list of only the unique items.

However, Set works differently with primitive values compared to when working with JavaScript objects.

That’s because JavaScript objects, even those with the exact same contents, have different object references, also known as pointers in memory.

Set is still very useful for removing duplicate objects from an array since it’s possible to add an object stored in a variable multiple times to an array. In that case, where the same exact object has been added multiple times, Set will help you remove the nonunique object references, leaving just one copy.

However, you can also filter an array of objects while comparing their contents using Set. In doing so, you can find the distinct objects by removing any that have duplicate key-value pairs. I refer to this as finding unique objects by content, where content means key-value pairs (also called entries).

Find Unique JavaScript Objects by Object Reference

Every variable in JavaScript lives in some portion of the computer’s memory, whether that computer is a server (running Node.js) or a web browser.

When you define a variable with a given name that name becomes associated with a place in memory. For objects stored as variables, these places in memory are called object references— and each object has a unique one.

You’re nevertheless able to add that unique object reference multiple times to a given array. That’s probably not the behavior you want in your code, so here’s how to remove duplicate object references from an array.

Using Set makes solving this problem much simpler than needing to loop through the array yourself, comparing every object.

Find Unique Objects by Content (Key-Value Pairs)

Since Set wants to compare object references by default, we need to convert our objects into a format that Set will be able to compare.

To extract the objects’ contents for comparison, you can take advantage of JSON.stringify() and JSON.parse(). These great methods turn JavaScript objects into JSON format (JavaScript object notation) strings.

Set works great for finding unique strings in an array so we’ll be able to convert the unique JSON strings back into JavaScript objects.

You do want to be aware here of how JSON handles converting data because certain values are not JSON-safe.

“undefined, Functions, and Symbols are not valid JSON values […]
Date [objects] are treated as strings.
The numbers Infinity and NaN, as well as the value null, are all considered null.”
— MDN docs

For primitive types like numbers, strings, and boolean values, though, you’ll find this method of using Set with JSON.stringify and JSON.parse works great for finding distinct objects by their contents, even for nested objects.

Conclusion: Finding Distinct JavaScript Objects

When you have an array of objects in JavaScript, you usually want to work with the unique objects — you don’t want any duplicate objects that could cause bugs or a poor user experience.

However, JavaScript has two definitions of what makes a unique object:

An object’s reference (its variable name or location in memory)

An object’s contents (its key-value pairs or entries)

Objects with unique references are different objects in memory, even if they have the exact same contents, like a deep clone of a JavaScript object. To find objects with unique references, you need to make a Set from the array. Comparing objects by reference is the default behavior of Set.

To get Set to compare objects by their contents, you’ll need to take advantage of JSON.stringify() and JSON.parse() in order to turn the objects into string primitives in JSON format that can be compared by Set. If your objects are JSON-safe, then this will work great, even for nested objects. Pretty sweet!

Hopefully this article has helped you understand the difference between object references versus the contents of those objects when trying to find the distinct objects in a JavaScript array.

To learn more about Set, please refer to my complete guide to using Set in JavaScript.

Happy coding! 🎄🎁🎅🥂🎇