JavaScript: Removing Same Elements in an Array without Sorting It

Basic algorithm

For instance we have an object array: [10, 1, 1, 2, 1, 2]. Then we want to remove all the same occurrences to be just [10, 1, 2] without changing the original sequence.

Here's what I did. First of all, I used my fingers to imagine it. Then, I "translated" it to JavaScript.

1. About the comparing (pairing), it uses combinatoric pattern.
   If you have 3 fruits and you wanna compare each of them, then you'll need 3 steps.
   If you have five fingers, then you'll need 10 steps to compare them all.
   Combination(total_number, 2)
   That's the basic idea.
   In this "translation", for instance that 3 fruits example, I created object of pairs. But not actually creating an object, just imaginary.
   As such:

   fruit 1 compared to fruit 1, fruit 2, and fruit 3.
   fruit 2 compared to fruit 1, fruit 2, and fruit 3.
   fruit 3 compared to fruit 1, fruit 2, and fruit 3.

   As you can see, there are repetitions.
   Without conditional statement, it will compare to itself and everything'll be broken.
   You can read about that below, about the if statement.
2. About the array manipulation, I use splice(index, how_many, elm_1, ..., elm_n) method to remove the element.
   And to keep the first element (the comparison reference) intact and only the next occurrence gets deleted, I put less than operator. The first index (denoted by i or m in the script below) is the array element reference, and the next one (denoted by j or n) is the other element besides that reference element.
3. The array reconstruction has stages, so I put "flag" to indicate whether it should re-invoke itself or not. The "stages" occur because whenever an array element gets deleted, the length of the array will change, thus the index shifting.
4. This function won't change the original array because it uses slice() method to clone it first.

---

JavaScript

This can be copied then paste it directly to your browser console or script editor, run it (hit enter/return), and observe the output.

Updated April 19, 2015

function r_d(a) { var b = a.slice(), //copy array i = 0, flag = 1, length = b.length, j; //splicing same elements //this has two dimensional tracing. Pairing. for (i; i < length; i++) { j = 0; //keep this "local" for (j; j < length; j++) { if (i < j && b[j] === b[i]) { b.splice(j, 1); } } } //re-test SAME ELEMENTS //"flag switcher" function check(b, f) { var m = 0, n; //"length" is a global variable within "r_d" function //it will dynamically change if the array gets spliced for (m; m < length; m++) { n = 0; //keep this "local" for (n; n < length; n++) { if (m < n && b[m] === b[n]) { f = 0; //same elements found break; } } } //return flag return f; } //if flag is false, repeat from the beginning if (!check(b, flag)) { b = r_d(b); } //return reconstructed array return b; } //====================================================== var original_ar = [0, 1, 2, 3, "meh", "strontium", "meh", 3, 5, 55, 30, 201, "zebra", "meh", "zebra", 0, 2, 3, 2, 3, 100, 55, 30, 30, 20, 0, 0, "strontium"], filtered_ar = r_d(original_ar); //using the function above //output console.log("*******************************"); console.log("Original array:\n" + original_ar.join(", ")); console.log("Filtered array:\n" + filtered_ar.join(", ")); console.log("*******************************");

---

Usage

var filtered_array = r_d(your_original_array);

---

The shorter version at GitHub

In that shorter version, instead of completely deleting the array element, I substitute it with "array_element (*)" string. You can put other type of dummy element so that it won't mix with the actual array elements.

---

Different version at GitHub

In this version, I use the actual Object dilly. It's one line shorter than the shortened version of the 1^st snippet.

This object construction method will return the sorted array. So you probably do not want to use this version.
But if... Hm.
...
That is all.