Javascript實現數組去重方法及效率對比

tulayang 發布于2019-08-26 10:28 / 1300人閱讀

摘要：前言其實網上搜索這些方法一堆堆的，之所以還來寫一遍主要是因為自己習慣一種之后就忘了其他方法怎么實現，就寫一寫總結一下，順便做個測試看看哪個效率最高，為了更好展示效果，我會先總結認為比較好的方法，后面統一測試。

前言

其實網上搜索這些方法一堆堆的，之所以還來寫一遍主要是因為自己習慣一種之后就忘了其他方法怎么實現，就寫一寫總結一下，順便做個測試看看哪個效率最高，為了更好展示效果，我會先總結認為比較好的方法，后面統一測試。（溫馨提示：下文衹是為了簡便，一般情況下不建議寫在原型上，容易污染全局）

一，通過尋找對象屬性

var ary = [14, 12, 2, 2, 2, 5, 32, 2, 59, 5, 6, 33, 12, 32, 6];
function sortFun1(ary) {
  var obj = {},
    i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (!obj[this[i]]) {
      obj[this[i]] = 1;
      ary.push(this[i]);
    }
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}
console.log(sortFun1(ary));
// [ 2, 2, 2, 2, 5, 5, 6, 6, 12, 12, 14, 32, 32, 33, 59 ]

二，通過尋找數組位置

var ary = [14, 12, 2, 2, 2, 5, 32, 2, 59, 5, 6, 33, 12, 32, 6];
function sortFun2(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (ary.indexOf(this[i]) == -1)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}
console.log(sortFun2(ary));
// [ 2, 2, 2, 2, 5, 5, 6, 6, 12, 12, 14, 32, 32, 33, 59 ]

三，跟尋找數組位置類似，搜索數字第一次出現的位置是不是跟當前位置一樣

var ary = [14, 12, 2, 2, 2, 5, 32, 2, 59, 5, 6, 33, 12, 32, 6];
function sortFun3(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this.indexOf(this[i]) == i)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}
console.log(sortFun3(ary));
// [ 2, 2, 2, 2, 5, 5, 6, 6, 12, 12, 14, 32, 32, 33, 59 ]

四，比較常規，先排序，再比較前后兩個數字是不是相等

var ary = [14, 12, 2, 2, 2, 5, 32, 2, 59, 5, 6, 33, 12, 32, 6];
function sortFun4(ary) {
  ary.sort(function (a, b) {
    return a - b
  });
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this[i] !== this[i - 1])
      ary.push(this[i]);
  }
  return ary;
}
console.log(sortFun4(ary));
// [ 2, 2, 2, 2, 5, 5, 6, 6, 12, 12, 14, 32, 32, 33, 59 ]

接下來是網上比較少的效率比較了，也是本文重點，我們先生成一個隨機數組函數和計時函數統一比較
(溫馨提示:隨機數組執行一次之后就保存在一個變量,而每次執行函數花費時間都會有幾毫秒偏差,你們想看多幾種結果就狠狠地按按F5就好了,也只能這么搞..)

首先生成一個一千個數字的數組

function sortFun1(ary) {
  var obj = {},
    i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (!obj[this[i]]) {
      obj[this[i]] = 1;
      ary.push(this[i]);
    }
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}

function sortFun2(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (ary.indexOf(this[i]) == -1)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun3(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this.indexOf(this[i]) == i)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun4(ary) {
  ary.sort(function (a, b) {
    return a - b
  });
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this[i] !== this[i - 1])
      ary.push(this[i]);
  }
  return ary;
}

function randomAry(n) {
  var ary = [], i = 0;
  for (; i < n; i++) {
    ary.push(Math.ceil(Math.random() * 10000));
  }
  return ary;
}

function useTime(fn, ary) {
  var start = new Date();
  fn(ary);
  var end = new Date();
  console.log("本次函數運行花了：" + (end - start) + "毫秒");
}


var ary = randomAry(1000000);
useTime(sortFun1, ary);
useTime(sortFun2, ary);
useTime(sortFun3, ary);
useTime(sortFun4, ary);

本次函數運行花了：1毫秒
本次函數運行花了：1毫秒
本次函數運行花了：0毫秒
本次函數運行花了：1毫秒
（嗯，果然現代瀏覽器強大無比，不吐槽舊瀏覽器了）

看看十萬個數字

function sortFun1(ary) {
  var obj = {},
    i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (!obj[this[i]]) {
      obj[this[i]] = 1;
      ary.push(this[i]);
    }
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}

function sortFun2(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (ary.indexOf(this[i]) == -1)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun3(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this.indexOf(this[i]) == i)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun4(ary) {
  ary.sort(function (a, b) {
    return a - b
  });
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this[i] !== this[i - 1])
      ary.push(this[i]);
  }
  return ary;
}

function randomAry(n) {
  var ary = [], i = 0;
  for (; i < n; i++) {
    ary.push(Math.ceil(Math.random() * 10000));
  }
  return ary;
}

function useTime(fn, ary) {
  var start = new Date();
  fn(ary);
  var end = new Date();
  console.log("本次函數運行花了：" + (end - start) + "毫秒");
}


var ary = randomAry(100000);
useTime(sortFun1, ary);
useTime(sortFun2, ary);
useTime(sortFun3, ary);
useTime(sortFun4, ary);

現在開始出現明顯差距了
本次函數運行花了：65毫秒
本次函數運行花了：4毫秒
本次函數運行花了：4毫秒
本次函數運行花了：5毫秒

看看一百萬個數字（數據龐大，開始吃不消了，等個五六秒吧）

function sortFun1(ary) {
  var obj = {},
    i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (!obj[this[i]]) {
      obj[this[i]] = 1;
      ary.push(this[i]);
    }
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}

function sortFun2(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (ary.indexOf(this[i]) == -1)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun3(ary) {
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this.indexOf(this[i]) == i)
      ary.push(this[i]);
  }
  return ary.sort(function (a, b) {
    return a - b
  });
}


function sortFun4(ary) {
  ary.sort(function (a, b) {
    return a - b
  });
  var i = 0,
    len = this.length;
  for (; i < len; i++) {
    if (this[i] !== this[i - 1])
      ary.push(this[i]);
  }
  return ary;
}

function randomAry(n) {
  var ary = [], i = 0;
  for (; i < n; i++) {
    ary.push(Math.ceil(Math.random() * 10000));
  }
  return ary;
}

function useTime(fn, ary) {
  var start = new Date();
  fn(ary);
  var end = new Date();
  console.log("本次函數運行花了：" + (end - start) + "毫秒");
}


var ary = randomAry(1000000);
useTime(sortFun1, ary);
useTime(sortFun2, ary);
useTime(sortFun3, ary);
useTime(sortFun4, ary);

本次函數運行花了：661毫秒
本次函數運行花了：24毫秒
本次函數運行花了：20毫秒
本次函數運行花了：27毫秒

總結

數據說話,

云服務器 GPU云服務器數組去重高效率 javascript數組方法 javascript實現方法 js 去重效率

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/106243.html

最全的數組去重方法對比

摘要：本文最早發布于，為原創常規方法兩種數組深拷貝，為不了影響原來的數組第一種方法常用但是有坑碰到這種情況就出問題了第二種方法使用，方法返回的結果并不一定是升序，主要目的是將重復的數字排到一起使用的方法兩種簡潔優雅版奇技淫巧更新看到評論本文最早發布于csdn，為原創常規方法兩種 let json = arr => { let res = [], obj = {};...

BlackHole1 2019-08-19 18:44 評論0 收藏0
跟underscore一起學數組去重

摘要：引子數組去重是一個老生常談的話題，在面試中也經常會被問道。其中如果數組是排序的，去重運算效率更高，因為排序能夠將相同的數排列在一起，方便前后比較。當數組有序對于對象的去重，我們知道為，所以使用比較對象在實際場景中沒有意義。引子數組去重是一個老生常談的話題，在面試中也經常會被問道。對于去重，有兩種主流思想：先排序，線性遍歷后去重，時間復雜度O(n*log2n)；使用哈希，空間換...

flybywind 2019-08-23 15:54 評論0 收藏0
JS中的數組去重方法總結

摘要：第一種常規法最直觀的思路創建一個新數組如果新數組中已經包含了當前的第個元素，那么跳過否則把當前項到新數組中輸出這種方法用到了方法。特殊情況當數組中既有數字又有字符串的時候，如此時希望和都保留，那么上述的方法無法達到要求。第一種：常規法（最直觀的思路） function unique(arr){ var n = []; //創建一個新數組 for(var i = 0; ...

Aldous 2019-08-20 10:40 評論0 收藏0
JavaScript 實現數組更多的高階函數

摘要：實現數組更多的高階函數吾輩的博客原文場景雖說人人平等，但有些人更加平等。若是有一篇適合萌新閱讀的自己實現數組更多操作的文章，情況或許會發生一些變化。類似于的初始值，但它是一個函數，避免初始值在所有分組中進行累加。 JavaScript 實現數組更多的高階函數吾輩的博客原文: https://blog.rxliuli.com/p/fc... 場景雖說人人平等，但有些人更加平等。為...

aervon 2019-08-23 18:31 評論0 收藏0
JS程序

摘要：設計模式是以面向對象編程為基礎的，的面向對象編程和傳統的的面向對象編程有些差別，這讓我一開始接觸的時候感到十分痛苦，但是這只能靠自己慢慢積累慢慢思考。想繼續了解設計模式必須要先搞懂面向對象編程，否則只會讓你自己更痛苦。 JavaScript 中的構造函數學習總結。知識只有分享才有存在的意義。是時候替換你的 for 循環大法了~ 《小分享》JavaScript中數組的那些迭代方法~ ...

melody_lql 2019-08-22 11:22 評論0 收藏0