A modern one-liner using .filter()

arr.filter((e, i, a) => e !== a[i - 1]);

I'm very surprised by the complexity of other answers here, even those that use .filter()

Even using old-school ES5 syntax with no arrow functions:

arr.filter(function (e, i, a) { return e !== a[i - 1] });

Example:

let a = [0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 7, 8, 9, 9, 9];

let b = arr.filter((e, i, a) => e !== a[i - 1]);

console.log(b); // [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

If you need to mutate the array in place then just use:

arr = arr.filter((e, i, a) => e !== a[i - 1]);

Personally I would recommend against using such complex solutions as the ones in other answers here.

This is a one-liner:

uniquify( myArray.filter(function(x){return true}) )

If you don't already have uniquify written (the function you wrote to remove duplicates), you could also use this two-liner:

var newArray = [];
myArray.forEach(function(x) {
    if (newArray.length==0 || newArray.slice(-1)[0]!==x)
        newArray.push(x)
})

Elaboration:

var a=[];
a[0]=1; a[1]=undefined; a[2]=undefined;
a[10]=2; a[11]=2;

According to OP, array has "five elements" even though a.length==12. Even though a[4]===undefined, it is not an element of the array by his definition, and should not be included.

a.filter(function(x){return true}) will turn the above array into [1, undefined, undefined, 2, 2].

edit: This was originally written with .reduce() rather than .forEach(), but the .forEach() version is much less likely to introduce garbage-collector and pass-by-value issues on inefficient implements of javascript.

For those concerned about compatibility with the 6-year-old MIE8 browser, which does not support the last two editions of the ECMAScript standard (and isn't even fully compliant with the one before that), you can include the code at https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach However if one is that concerned about browser compatibility, one ought to program via a cross-compiler like GWT. If you use jQuery, you can also rewrite the above with only a few extra characters, like $.forEach(array, ...).

Perhaps something like this:

var out = [],
    prev;

for(var i = 0; i < arr.length; i++) {
   if (!(i in arr))
      continue;

   if (arr[i] !== prev || out.length === 0) {
      out.push(arr[i]);
      prev = arr[i];
   }
}

The out.length check is to allow for the first defined array element having a value of undefined when prev also starts out initially as undefined.

Note that unlike your original algorithm, if arr is empty this will not push an undefined value into your out array.

Or if you have a new enough browser, you could use the Array.forEach() method, which iterates only over array elements that have been assigned a value.

An explicit way would be to pack the array (remove the undefined) values and use your existing algorithm for the duplicates on that..

function pack(_array){
    var temp = [],
        undefined;
    for (i=0, len = _array.length; i< len; i++){
        if (_array[i] !== undefined){
            temp.push(_array[i]);
        }   
    }
    return temp;
}

I think this is what you want. It's a pretty simple algorithm.

var out = [], previous;
for(var i = 0; i < arr.length; i++) {
  var current = arr[i];
  if(!(i in arr)) continue;
  if(current !== previous) out.push(current);
  previous = arr[i];
}

This will run in O(N) time.

A very simple function, the input array must be sorted:

function removeDupes(arr) {
  var i = arr.length - 1;
  var o;
  var undefined = void 0;

  while (i > 0) {
    o = arr[i];

    // Remove elided or missing members, but not those with a 
    // value of undefined 
    if (o == arr[--i] || !(i in arr)) {
      arr.splice(i, 1);
    }
  }
  return arr;
}

It can probably be more concise, but might become obfuscated. Incidentally, the input array is modified so it doesn't need to return anything but it's probably more convenient if it does.

Here's a forward looping version:

function removeDupes2(arr) {
  var noDupes = [],
      o;

  for (var i=0, j=0, iLen=arr.length; i<iLen; i++) {
    o = arr[i];
    if (o != noDupes[j] && i in arr) {
       noDupes.push(o);
       j = noDupes.length - 1;
    }
  }
  return noDupes;
}

PS

Should work on any browser that supports javascript, without any additional libraries or patches.

This solution removes duplicates elements in-place. not recommended for functional programming

const arr =[0,0,1,1,2,2,2,3,4,5,5,6,7,7,8,9,9,9];

const removeDuplicates = (nums) => {
  nums.forEach((element, idx) => {
    nums.splice(idx, nums.lastIndexOf(element) - idx)
  })
}

removeDuplicates(arr)

console.log(arr);

//sort the array
B.sort(function(a,b){ return a  - b});
//removing duplicate characters
    for(var i=0;i < B.length; i ++){
        if(B[i]==B[i + 1])
            B.splice(i,1)
    }

if element in next index and current position is same remove the element at current position

splice(targetPosition,noOfElementsToBeRemoved)

I believe what you are trying to achieve is not quite possible, but I could be wrong.

It's like one of those classic CS problems like the one where a barber in a village only shaves the one who don't shave themselves. If you set the value of an array's index item as undefined, it's not really undefined. Isn't that the case? A value can only be undefined when it hasn't been initialized.

What you should be checking for is whether a value is null or undefined. If null or duplicate skip the value, else retain it.

If null values and duplicates are what you are trying to skip then below function will do the trick.

function  removeDuplicateAndNull(array){

    if(array.length==0)
        return [];

    var processed = [], previous=array[0];
    processed.push(array[0]);

    for(var i = 1; i < array.length; i++) {

        var value = array[i];

        if( typeof value !== 'undefined' && value ==null) 
            continue;

        if(value !== previous || typeof value === 'undefined')
            processed.push(value);

        previous = array[i];
    }
    return processed;
}

Test cases:

1. array=[,5,5,6,null,7,7] output =[ ,5,6,7]

2. array=[ 5,5,,6,null,,7,7] output=[5,,6,,7]

3. array=[7,7,,] output=[7,]

But even with this function there's a caveat. IF you check third test, the output is [7,] instead of [7,,] ! If you check the length of the input and output arrays, array.length =3 and output.length=2. The caveat is not with the function but with JavaScript itself.

This code is written in javascript. Its very simple.

Code:

function remove_duplicates(arr) {
        newArr = [];
        if (arr.length - 1 >= 0) {
            for (i = 0; i < arr.length - 1; i++) {
                // if current element is not equal to next
                // element then store that current element
                if (arr[i] !== arr[i + 1]) {
                    newArr.push(arr[i]);
                }
            }
            newArr.push(arr[arr.length - 1]);
        }
        return newArr
    }
    arr=[0,1,1,2,2,3,4,5,5,6,7,7,8,9,9,9];
    console.log(remove_duplicates(arr));

Here is the simple JavaScript solution without using any extra space.

function removeDuplicates(A) {
   let i = 0;
   let j = i + 1;
   while (i < A.length && j < A.length) {
      if (A[i] === A[j]) {
         A.splice(i, 1);
         j=i+1;
       } else {
         i++;
         j++;
        }
     }
    return A;
   }
console.log('result', removeDuplicates([0,1,1,2,2,2,2,3,4,5,6,6,7]))

You can try the simple way

function hello(a: [], b: []) {
     return [...a, ...b];
}
let arr = removeDuplicates(hello([1, 3, 7], [1, 5, 10]));
arr = removeDuplicates(arr);
function removeDuplicates(array) {
  return array.filter((a, b) => array.indexOf(a) === b);
}
let mainarr = arr.sort((a, b) => parseInt(a) - parseInt(b));
console.log(mainarr); //1,3,5,7,10

One liner code

[1,3,7,1,5,10].filter((a, b) => [1,3,7,1,5,10].indexOf(a) === b).sort((a, b) => parseInt(a) - parseInt(b))

Here is simple solution to remove duplicates from sorted array.

Time Complexity O(n)

function removeDuplicate(arr) {
        let i=0;
        let newArr= [];
        while(i < arr.length) {
            if(arr[i] < arr[i+1]) {
                newArr.push(arr[i])
            } else if (i === (arr.length-1)) {
                newArr.push(arr[i])
            }
            i++;
        }
        return newArr;
    }
    var arr = [1,2,3,4,4,5,5,5,6,7,7]
    console.log(removeDuplicate(arr))

Let's suppose that you have a sorted array and you can't use additional array to find and delete duplicates:

In Python

def findDup(arr, index=1, _index=0):

    if index >= len(arr):
        return

    if arr[index] != arr[_index]:

        findDup(arr, index+1, _index+1)

    if arr[index] == arr[_index]:
        arr = deletedup(arr, index)
        findDup(arr, index, _index) #Has to remain same here, because length has changed now



def deletedup(arr, del_index):
    del arr[del_index]
    return arr

arr = [1, 2, 3, 4, 4, 4, 5, 6, 7, 7, 7, 7, 7]

findDup(arr)
print arr