How to Remove Duplicates from a JavaScript Array

By the end of this page, you will understand how to remove duplicate values from a JavaScript array, why some older looping patterns fail when values like 0 appear, and which modern approaches are safest and easiest to use. You will also learn how truthy and falsy values affect loop conditions and how to choose the right deduplication technique in real code.

The main concept behind this question is array deduplication and the related idea of truthy and falsy values in JavaScript.

The bug in the original code is not really about duplicates. It is about this loop condition:

for (i = 0; (e = this[i]); i++)

This code assigns this[i] to e, and then uses the assigned value as the loop condition. That means the loop continues only while e is truthy.

In JavaScript, these are examples of falsy values:

• 0
• ""
• false
• null
• undefined
• NaN

So if the array contains 0, then e = this[i] becomes 0, which is falsy, and the loop stops early.

Why this matters

In real programming, data often includes valid falsy values:

Think of a for loop condition like a security guard checking whether work should continue.

In the broken version, the guard says:

"Keep going only if the current value looks truthy."

That sounds okay until the value is 0. Even though 0 is a perfectly valid array element, the guard treats it like a stop signal.

A better mental model is:

"Keep going while the index is still inside the array."

That means you should check the position in the array, not the value stored there.

So this is fragile:

for (i = 0; (e = this[i]); i++)

And this is reliable:

for (i = 0; i < this.length; i++)

The first asks, "Is this value truthy?" The second asks, "Is this index valid?"

That is the key difference.

Modern way: use Set

const numbers = [1, 2, 2, 3, 0, 0, 4];
const uniqueNumbers = [...new Set(numbers)];

console.log(uniqueNumbers); // [1, 2, 3, 0, 4]

Why this works

• new Set(numbers) creates a set of unique values
• ... spreads the set back into an array
• 0 is kept correctly because Set does not depend on truthiness

Older but valid approach: use filter

const numbers = [1, 2, 2, 3, 0, 0, 4];
const uniqueNumbers = numbers.filter( {
   array.(value) === index;
});

.(uniqueNumbers); 

Consider this broken example:

const arr = [5, 2, 0, 9];

for (let i = 0, e; (e = arr[i]); i++) {
  console.log("value:", e);
}

Step-by-step trace

Start

• i = 0
• e = arr[0] → 5
• 5 is truthy, so the loop runs
• Output: value: 5

Next iteration

• i = 1
• e = arr[1] → 2
• 2 is truthy, so the loop runs
• Output: value: 2

Next iteration

• i = 2

Removing duplicates from arrays is common in real applications.

Common scenarios

• User IDs: remove repeated IDs before querying a database
• Tags or categories: keep only unique labels from user input
• API results: merge data from multiple endpoints without duplicates
• Analytics: count unique page paths, events, or product IDs
• Form processing: clean repeated values from checkbox submissions
• Configuration lists: avoid duplicate feature flags or allowed roles

Example: unique tags

const tags = ["js", "css", "js", "html", "css"];
const uniqueTags = [...new Set(tags)];

console.log(uniqueTags); // ["js", "css", "html"]

Example: unique numeric IDs

const ids = [101, 203, 101, 404, 0, 404];
const uniqueIds = [...new Set(ids)];

console.log(uniqueIds); 

In real codebases, developers usually avoid extending built-in prototypes unless there is a strong reason. So instead of this:

Array.prototype.getUnique = function () {
  // ...
};

it is more common to write a reusable utility function:

function getUniqueValues(array) {
  return [...new Set(array)];
}

Why utility functions are preferred

• They are easier to test
• They do not affect all arrays globally
• They reduce the risk of naming conflicts
• They are easier for teams to read and maintain

Common patterns in real projects

Validation before deduplication

function getUniqueValues(array) {
  if (!Array.isArray(array)) {
    throw new TypeError("Expected an array");
  }

  return [...new (array)];
}

1. Using the array value as the loop condition

Broken code:

for (let i = 0, e; (e = arr[i]); i++) {
  console.log(e);
}

Why it fails

The loop stops at falsy values like 0, false, or "".

Fix

for (let i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

2. Forgetting that object keys become strings

Broken expectation:

const o = {};
o[1] = true;
o[2] = true;

console.log(Object.keys(o)); // ["1", "2"]

Why it matters

If you use an object for deduplication, numeric values come back as strings unless you convert them.

Remove duplicates

const unique = [...new Set(array)];

Safe classic loop

for (let i = 0; i < array.length; i++) {
  const value = array[i];
}

Avoid this pattern

for (let i = 0, value; (value = array[i]); i++) {
  // breaks on 0, false, "", null, undefined, NaN
}

Falsy values in JavaScript

• 0
• ""
• false
• null
• undefined
• NaN

Alternative deduplication

const unique = array.filter( arr.(value) === index);

Why does 0 break the original loop?

Because 0 is a falsy value in JavaScript. The loop uses the assigned value itself as the condition, so it stops when the value is 0.

What is the easiest way to remove duplicates from a JavaScript array?

Use Set:

const unique = [...new Set(array)];

Is Set better than using an object?

Usually yes. Set is clearer, preserves types, and is designed specifically for unique values.

Why does the object-based method return strings?

Object keys are stored as strings, so numeric values like 1 and 2 come back as "1" and "2".

Should I add getUnique to Array.prototype?

Usually no. It is safer and more maintainable to use a normal function instead.

Does also work for removing duplicates?

• Truthy and falsy values — directly explains why 0 stops the original loop.
• for loops in JavaScript — helps you understand safe loop conditions.
• for...of loops — a cleaner way to iterate through array values.
• Arrays in JavaScript — foundational for storing and processing lists of values.
• Set in JavaScript — the modern built-in structure for unique values.
• filter() — a common array method used in older deduplication patterns.
• indexOf() — often paired with filter() to detect first occurrences.
• Objects vs Maps vs Sets — useful for choosing the right data structure.
• Prototype inheritance — relevant because the original code extends Array.prototype.