Method 1: Utilizing the Set Object

One of the most straightforward and effective ways to eliminate duplicates from an array in JavaScript is through the use of the Set object. A Set inherently contains only unique values, so converting an array into a Set automatically removes any duplicates.

const arrayWithDuplicates = [1, 2, 2, 3, 4, 4, 5];

const uniqueArray = [...new Set(arrayWithDuplicates)];

console.log(uniqueArray); // Output: [1, 2, 3, 4, 5]

Here, the spread operator (...) is applied to transform the Set back into an array. This method is succinct and works exceptionally well for arrays composed of primitive types.

Method 2: Employing the Filter Method

The filter method produces a new array filled with elements that meet the criteria defined by a specified function. To remove duplicates, we can implement a function that verifies whether the current element's index is its first occurrence in the array.

const arrayWithDuplicates = [1, 2, 2, 3, 4, 4, 5];

const uniqueArray = arrayWithDuplicates.filter((item, index, array) => array.indexOf(item) === index);

console.log(uniqueArray); // Output: [1, 2, 3, 4, 5]

This method allows for greater flexibility and can be applied to arrays that include complex data types, though it is typically less efficient than using a Set.

Method 3: Using the Reduce Method

The reduce method applies a reducer function to each element of the array, culminating in a single output value. For the purpose of removing duplicates, the reducer can gather only unique values.

const arrayWithDuplicates = [1, 2, 2, 3, 4, 4, 5];

const uniqueArray = arrayWithDuplicates.reduce((accumulator, currentValue) => {

if (!accumulator.includes(currentValue)) {

accumulator.push(currentValue);

}

return accumulator;

}, []);

console.log(uniqueArray); // Output: [1, 2, 3, 4, 5]

While this method offers versatility, enabling complex logic within the reducer function, it may be less readable and slower for larger arrays compared to the Set approach.

Method 4: Implementing a Hash Table

For arrays that consist of complex types or when order preservation is not critical, leveraging a hash table (utilized in JavaScript as an object or Map) can serve as an effective strategy. This approach involves creating a hash table where each unique element becomes a key, effectively discarding duplicates.

const arrayWithDuplicates = [{ id: 1 }, { id: 2 }, { id: 2 }, { id: 3 }];

const uniqueArray = Object.values(arrayWithDuplicates.reduce((acc, current) => {

acc[current.id] = current;

return acc;

}, {}));

console.log(uniqueArray); // Output: [{ id: 1 }, { id: 2 }, { id: 3 }]

While this method is well-suited for complex data structures, it requires a deeper understanding of JavaScript objects and entails a bit more coding effort.