js 去重

方法一:

?

1 2 3 4 5 6 7 8 9 10 11 12 13

//两个for循环 Array.prototype.delRepeat1 = function () {   var r = new Array();   label: for (var i = 0, n = this.length; i < n; i++) {     for (var x = 0, y = r.length; x < y; x++) {       if (r[x] == this[i]) {         continue label;       }     }     r[r.length] = this[i];   }   return r; }

这是我最先接触到的去重，相信很多人也是最先接触这个方法，这种方法运行时用到的循环太多了，效率太低，如果数据量少还行，如果是大量数据的话，那就只能说呵呵了。

方法二:

?

1 2 3 4 5 6 7 8 9 10

Array.prototype.delRepeat2 = function () {   this.sort();//排序   var n = [this[0]];   for (var i = 1; i < this.length; i++) {     if (this[i] !== n[n.length - 1]) {       n.push(this[i]);     }   }   return n; }

这种是我比较喜欢用的，效率也不错，先用sort排序，加一个临时数组，然后循环遍历，将去重的数组和临时数组末进行比较，不同就加入临时数组。

方法三：

?

1 2 3 4 5 6 7 8 9

Array.prototype.delRepeat3 = 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; }

方法三虽然只有一个for循环，但indexof函数会从头检索n数组，同样效率不行。

方法四：

?

1 2 3 4 5 6 7 8 9 10 11 12

Array.prototype.delRepeat4 = 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; }

这种方法去重效率很快，但是有个很大的缺点，就是内存占用多。不推荐使用。

方法五：

?

1 2 3 4 5 6 7 8 9 10

Array.prototype.delRepeat5 = 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; }

这种方法和方法三一样用到了indexof。

方法六：

?

1 2 3

Array.prototype.delRepeat6 = function () {   return this.sort().join(",,").replace(/(,|^)([^,]+)(,,\2)+(,|$)/g, "$1$2$4").replace(/,,+/g, ",").replace(/,$/, "").split(","); }

这个不用说，用了正则，o(╯□╰)o，感觉好复杂，我也没懂Σ( ° △ °|||)︴。

方法七：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Array.prototype.delRepeat7 = function () {   var temp = {}, len = this.length;   for (var i = 0; i < len; i++) {     var tmp = this[i];     if (!temp.hasOwnProperty(tmp)) {//hasOwnProperty用来判断一个对象是否有你给出名称的属性或对象       temp[this[i]] = "yes";     }   }     len = 0;   var tempArr = [];   for (var i in temp) {     tempArr[len++] = i;   }   return tempArr; }

这你是用到了hasOwnProperty，这种效率也不错.

 

下面是我的测试代码：

?

1 2 3 4 5 6 7 8 9 10 11

function delRepeatExample () {   var arr = [];//测试的数组   for (var i = 0; i < 10000; i++) {     var t = parseInt(Math.random() * 1000);     arr[i] = (t.toString());   }   var s = new Date();//定义开始的时间！   var a=arr.delRepeat();     var dd = new Date() - s;//执行时间=当前时间-开始的时间 }

分别测试了10000和100000长的数组，测试结果如下：

方法一：  242ms（10000长度的）     2240ms（100000长度的)

方法二：  6ms                               39ms

方法三：  255ms                            2138ms

方法四：  4ms                                19ms

方法五：  416ms                             4492ms

方法六：  9ms                                 50ms

方法七：  2ms                                 8ms

我个人比较倾向于方法二、方法七。