JavaScript Program to Find Duplicate Elements in an Array

Here are the different methods to find duplicate elements in the array

1. Using Nested For In Loop

The for...in loop is typically used to iterate over the keys of an object or the indices of an array.

const a  = [1, 2, 3, 4, 5, 2, 3, 6];
let dupli = [];

for (let i in a) {
    for (let j in a) {
        if (i !== j && a[i] === a[j] && !dupli.includes(a[i])) {
            dupli.push(a[i]);
        }
    }
}

console.log(dupli); 

[ 2, 3 ]

In this example

• The code uses nested for...in loops to compare each element in the array with all others.
• If a duplicate is found (and not already in the duplicates array), it is added to the list, resulting in [2, 3].

2. Using Sort() Method

The array.sort() method is provided by Javascript by which we can sort our array, and after sorting the array, we are checking that the element at the last index is the same or not.

const a = [1, 2, 3, 4, 5, 2, 3, 6];
let dupli = [];
arr.sort();

for (let i = 0; i < a.length - 1; i++) {
    if (a[i] === a[i + 1] && !dupli.includes(a[i])) {
        dupli.push(a[i]);
    }
}
console.log(dupli); 

[ 1, 2, 3 ]

 In this example

• The sort() method is used to sort the array in ascending order.
• After sorting, we simply check if any consecutive elements are the same.
• If a duplicate is found and it's not already in the duplicates array, it is added.

3. Using filter() and indexOf() Method

In JavaScript, array methods such as filter() and indexOf() can be used to find duplicates in a concise way.

const a = [1, 2, 3, 4, 5, 2, 3, 6];
let dupli = a.filter((value, index) => 
	a.indexOf(value) !== index && a.lastIndexOf(value) === index);

console.log(dupli);

[ 2, 3 ]

In this example

• filter() creates a new array containing elements that satisfy a condition.
• arr.indexOf(value) returns the first occurrence index of value.
• arr.indexOf(value) !== index checks if the current element's first occurrence is not at the current index (indicating a duplicate).
• arr.indexOf(value) === index ensures that we don’t filter elements that are encountered for the first time.

4. Using a Set

A Set in JavaScript is a collection of unique values. Using this property, we can easily identify duplicates by comparing the current element with the values already stored in the set.

const a = [1, 2, 3, 4, 5, 2, 3, 6];
let seen = new Set();
let dupli = [];
for (let i = 0; i < a.length; i++) {
    if (seen.has(a[i])) {
        dupli.push(a[i]);
    } else {
        seen.add(a[i]);
    }
}
console.log(dupli);

[ 2, 3 ]

In this example

• We use a Set called seen to store unique elements as we iterate over the array.
• When an element is encountered that already exists in the Set, it is a duplicate, so we add it to the duplicates array.
• If the element is not in the Set, we add it to seen.

5. Using reduce() and includes() Method

The reduce() method can also be used to find duplicates. It iterates over the array and accumulates the result in an array, checking for duplicates along the way.

const a = [1, 2, 3, 4, 5, 2, 3, 6];
let dupli = [];

a.reduce((acc, curr) => {
    if (acc.indexOf(curr) === -1 && a.indexOf(curr) !== a.lastIndexOf(curr)) {
        acc.push(curr);
    }
    return acc;
}, dupli);

console.log(dupli); 

[ 2, 3 ]

In this example

• The code uses reduce() to accumulate duplicates in the dupli array by checking if an element appears more than once in the array (a.indexOf(curr) !== a.lastIndexOf(curr)) and ensuring it's added only once (acc.indexOf(curr) === -1). The result is [2, 3].

6. Using a Map Data Structure

Map() method is used to store the frequency of each element in the array. Elements with a frequency greater than 1 are considered duplicates.

const a = [1, 2, 3, 4, 5, 2, 3, 6];
let map = new Map();
let dupli = [];
for (let i = 0; i < a.length; i++) {
    if (map.has(a[i])) {
        map.set(a[i], map.get(a[i]) + 1);
    } else {
        map.set(a[i], 1);
    }
}
for (let [key, val] of map) {
    if (val > 1) {
        dupli.push(key);
    }
}
console.log(dupli); 

[ 2, 3 ]

In this example

• We use a Map to store each element of the array as the key and its frequency as the value.
• If the element is already in the Map, we increment its count. If it’s not in the Map, we add it with a count of 1.
• After iterating through the array, we check the Map to find elements with a frequency greater than 1, indicating duplicates.