In JavaScript, removing duplicates from an array is commonly done with the Set object, but in interview settings, you might be asked to do this without using Set. Here are a few alternative methods to get unique values from an array:

1. Using `filter` and `indexOf`

The filter method creates a new array with all elements that pass a particular test. By combining filter with indexOf, we can ensure that only the first occurrence of each element is included in the resulting array, thus removing duplicates.

Example:

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

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

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

Explanation:

indexOf returns the first index at which a given element can be found in the array.
By comparing the current index with array.indexOf(item), we ensure that only the first occurrence of each element is added to uniqueArray.

2. Using `reduce`

The reduce method can accumulate values in a new array while checking for duplicates. We’ll start with an empty array and add items only if they aren’t present.

Example:

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

const uniqueArray = array.reduce((acc, item) => {

if (!acc.includes(item)) {

acc.push(item);

}

return acc;

}, []);

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

Explanation:

reduce takes a callback and an initial value ([] here).
Inside the callback, we check if acc (the accumulator array) already includes the current item. If it doesn’t, the item is pushed to acc, giving us a final array without duplicates.

3. Using `forEach` and an Object as a Map

In this approach, we iterate over the array and store unique items in an object. We then use Object.keys to retrieve the unique items from the object.

Example:

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

const uniqueObj = {};

const uniqueArray = [];

array.forEach(item => {

if (!uniqueObj[item]) {

uniqueObj[item] = true;

uniqueArray.push(item);

}

});

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

Explanation:

We use an object uniqueObj to track whether an item has been encountered.
If the item is not in uniqueObj, we add it and push it to uniqueArray.
Object.keys(uniqueObj) will return an array of unique items, such as strings, if needed.

4. Using `sort` and Looping Through Sorted Array

We can skip adding duplicate items to a new array by sorting the array and then looping through it.

Example:

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

array.sort((a, b) => a - b);

const uniqueArray = [];

for (let i = 0; i < array.length; i++) {

if (array[i] !== array[i - 1]) {

uniqueArray.push(array[i]);

}

}

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

Explanation:

After sorting, duplicates are adjacent.
By comparing each item to the previous one (array[i] !== array[i - 1]), we ensure only unique items are added to uniqueArray.

5. Using a `for` Loop

With a for loop, we can iterate over each element in the array and add it to a new array only if it’s not already present.

Example:

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

const uniqueArray = [];

for (let i = 0; i < array.length; i++) {

if (!uniqueArray.includes(array[i])) {

uniqueArray.push(array[i]);

}

}

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

Explanation:

We initialize an empty uniqueArray.
For each item in array, we check if it’s already in uniqueArray with includes.
If it’s not, we push it to uniqueArray.

While this method works well, keep in mind that includes inside a loop can slow things down if the array is very large, as it’s an O(n^2) operation in the worst case.

6. Using a `while` Loop

With a while loop, we can use a slightly different approach to iterate until we reach the end of the array. We’ll maintain an index to track the current item and push items into uniqueArray only if they haven’t been encountered before.

Example:

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

const uniqueArray = [];

let i = 0;

while (i < array.length) {

if (!uniqueArray.includes(array[i])) {

uniqueArray.push(array[i]);

}

i++;

}

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

Explanation:

We initialize i as 0 and loop until i reaches the array’s length.
Inside the loop, we check if the current item at array[i] is already in uniqueArray.
If it’s not present, we add it to uniqueArray and increment i for the next iteration.

Optimizing with an Object (Map)

Both for and while loop solutions can become inefficient with larger arrays since includes has to search through uniqueArray each time. To improve performance, we can use an object to track seen values.

Example using `for loop` with an object:

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

const uniqueArray = [];

const seen = {}; // Object to track encountered values

for (let i = 0; i < array.length; i++) {

if (!seen[array[i]]) { // Check if value has been added to uniqueArray

seen[array[i]] = true;

uniqueArray.push(array[i]);

}

}

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

Explanation:

We use the object seen to keep track of elements we’ve already added to uniqueArray.
Each time we encounter a new item in array, we add it to uniqueArray and mark it as seen by setting seen[array[i]] = true.

Using an object like this makes it an O(n) operation, improving performance for large datasets.

Conclusion

In JavaScript, removing duplicates from an array without using Set can be achieved through various methods, each with a unique approach and efficiency. The techniques discussed here—using filter with indexOf, reduce, forEach with an object as a map, sorting with a loop, and simple for or while loops—illustrate different ways to approach this problem. For smaller arrays, any of these methods will work well, while for larger datasets, approaches like using an object for tracking duplicates offer better performance by reducing the time complexity to O(n).