Summary of methods to remove duplicates from javascript array_javascript skills

Four algorithms to achieve this:

First type:

Array.prototype.unique1 = function () {
 var n = []; //一个新的临时数组
 for (var i = 0; i < this.length; i++) //遍历当前数组
 {
  //如果当前数组的第i已经保存进了临时数组，那么跳过，
  //否则把当前项push到临时数组里面
  if (n.indexOf(this[i]) == -1) n.push(this[i]);
 }
 return n;
}

Second type:

Array.prototype.unique2 = function()
{
    var n = {},r=[]; //n为hash表，r为临时数组
    for(var i = 0; i < this.length; i++) //遍历当前数组
    {
        if (!n[this[i]]) //如果hash表中没有当前项
        {
            n[this[i]] = true; //存入hash表
            r.push(this[i]); //把当前数组的当前项push到临时数组里面
        }
    }
    return r;
} //此方法比较推荐 ，但不能呢过考虑到“222”和222的问题

The second improved version:

//类hash方法的改进版
Array.prototype.unique2 = function () {
  var n = {}, r = [];
  for (var i = 0; i < this.length; i++) {
    if (!n[typeof (this[i]) + this[i]]) {
      n[typeof (this[i]) + this[i]] = true;
      r.push(this[i])
    }
  }
  return r
};

var arr=["222",222,2,2,3];
var newarry=arr.unique2();
console.log(newarry[newarry.length-1]); 

Third type:

Array.prototype.unique3 = function()
{
    var n = [this[0]]; //结果数组
    for(var i = 1; i < this.length; i++) //从第二项开始遍历
    {
        //如果当前数组的第i项在当前数组中第一次出现的位置不是i，
        //那么表示第i项是重复的，忽略掉。否则存入结果数组
        if (this.indexOf(this[i]) == i) n.push(this[i]);
    }
    return n;
}

The first and third methods both use the indexOf method of the array. The purpose of this method is to find the first occurrence of the stored parameter in the array. Obviously, the js engine will traverse the array until it finds the target when implementing this method. So this function wastes a lot of time. The second method uses a hash table. Store the occurrences in an object in the form of subscripts. Subscripted references are much faster than searching the array using indexOf.

In order to judge the efficiency of these three methods, I made a test program to generate an array of random numbers with a length of 10,000, and then used several methods to test the execution time. The results show that the second method is much faster than the other two methods. However, in terms of memory usage, the second method is more likely to be used because there is an additional hash table. This is what is called space for time. This is the test page, you can also check it out.

The fourth method:

Array.prototype.unique4 = function()
{
    this.sort();
    var re=[this[0]];
    for(var i = 1; i < this.length; i++)
    {
        if( this[i] !== re[re.length-1])
        {
            re.push(this[i]);
        }
    }
    return re;
}

The idea of ​​this method is to sort the array first, and then compare two adjacent values. The JS native sort method is used when sorting. The JS engine should use quick sort internally. The final test result is that the running time of this method is about three times that of the second method on average, but it is much faster than the first and third methods.

The above is the entire content of this article, I hope you all like it.