How Do You Remove Duplicates from an Array?

For primitive values the modern answer is a Set. A set keeps only one copy of each value, and spreading it back into an array gives you the result in one line.

const numbers = [1, 2, 2, 3, 3, 3, 4];

console.log([...new Set(numbers)]);   // [1, 2, 3, 4]

// The older filter approach does the same thing:
console.log(numbers.filter((n, i) => numbers.indexOf(n) === i));   // [1, 2, 3, 4]

The Set version is the one to reach for. It runs in linear time because the set does the lookup for you, whereas the filter version calls indexOf for every element, which is quadratic on a large array. The filter version is worth recognising because it is still common in older code, and because it works with the same predicate style.

Two important limits. A Set uses the same-value-zero comparison, so it treats values that are strictly equal, plus the special case where positive zero and negative zero are treated as the same. It does not do anything clever with objects, because two distinct object literals are never the same value, so a set of objects will keep them all.

And when the values are objects, you need to decide what makes two of them duplicates. Usually it is a key, such as an id, and then you need a different approach entirely.

You have to decide what makes two objects duplicates, because the language has no opinion. Two objects are only ever the same value if they are the same reference, so a plain set will keep them all. The usual rule is a key field such as an id, and then you either build a Map keyed by that field or filter with a seen set.

const people = [
  { id: 1, name: "Ada" },
  { id: 2, name: "Bob" },
  { id: 1, name: "Ada" },
];

// A Map keeps the last value for each key.
const unique = [...new Map(people.map((p) => [p.id, p])).values()];
console.log(unique.length);   // 2
console.log(unique[0].name);  // "Ada"

// A seen set keeps the first value for each key.
const seen = new Set();
const keepFirst = people.filter((p) => {
  if (seen.has(p.id)) return false;
  seen.add(p.id);
  return true;
});
console.log(keepFirst.length);   // 2

The choice between the two approaches is a real decision, not a detail. The Map version keeps the last occurrence of each key, because a later entry overwrites an earlier one. The seen-set version keeps the first occurrence, because it skips anything it has already seen. If your data has a later record that is more up to date, the Map version is right. If the first record is authoritative, the filter version is right.

One subtlety with the Map version: it uses the key you give it, so if two records share an id but differ in other fields, the later one wins and the earlier is lost entirely. If you need to merge them, you have to do that explicitly.

For a large data set, doing this once and caching the result in a Map is usually better than deduplicating on every render. Building an index by key once and looking things up is the pattern that scales.

A Set preserves insertion order, so spreading a set back into an array keeps the position of the first occurrence of each value. That is exactly the behaviour you want in most cases: the result reads like the original list with the repeats taken out.

const words = ["pear", "apple", "pear", "fig", "apple"];

const unique = [...new Set(words)];
console.log(unique);   // ["pear", "apple", "fig"]

// The same result with a filter and a seen set:
const seen = new Set();
const kept = words.filter((w) => {
  if (seen.has(w)) return false;
  seen.add(w);
  return true;
});
console.log(kept);     // ["pear", "apple", "fig"]

// The reverse order, keeping the last occurrence:
const lastFirst = [...words].reverse().filter((w, i, arr) => arr.indexOf(w) === i).reverse();
console.log(lastFirst);   // ["pear", "apple", "fig"]

The Set approach is the clearest and the fastest, since it runs in linear time. The filter with a seen set gives you the same result and gives you a place to attach extra logic, such as counting how many times each value appeared, which you can do by incrementing a count in the same pass.

The reverse-and-filter trick in the last example is the standard way to keep the last occurrence of each value while preserving relative order. It is more convoluted than it looks, so prefer the Set unless you specifically need last-wins semantics.

One detail worth knowing about Set: the order it preserves is insertion order, not sorted order. If you want the result sorted, sort the array afterwards with the toSorted method, which returns a new array rather than changing the one you built.