這篇文章主要為大家詳細介紹了javascript實現(xiàn)數組去重的多種方法，感興趣的小伙伴們可以參考一下

先說說這個實例的要求：寫一個方法實現(xiàn)數組的去重。（要求：執(zhí)行方法，傳遞一個數組，返回去重后的新數組，原數組不變，實現(xiàn)過程中只能用一層循環(huán)，雙層嵌套循環(huán)也可寫，只做參考）；

先給初學者解釋一下什么叫數組去重（老鳥跳過）：意思就是講數組里面重復的元素去掉，比如說var arr = [3,2,4,2,1,2]; 數組去重得到的新數組是 [3,2,4,1]，就是這么一個功能。

實現(xiàn)方法比較簡單，實現(xiàn)的方式也比較多，很多大牛也寫過相關的文章，之所以寫這邊博客，旨在一是備忘，二是給初學者能更好的理解其實現(xiàn)的原理，好，我們看第一種實現(xiàn)方式：

第一種，通過遍歷新數組來去重

var arr = [1,'b','b',4,3,3,4,5,1];

    //第一種

    Array.prototype.unique1 = function(){

      var arr1 = []; //定義一個新數組

      for(var i=0;i<this.length;i++){

        if(arr1.indexOf(this[i]) == -1){//判斷目標數組中在原數組里是否存在

          arr1.push(this[i]);

        } 

      } 

      return arr1;

    }

    console.log(arr); //[1,'b','b',4,3,3,4,5,1]

    console.log(arr.unique1()); //[1, "b", 4, 3, 5]

    //這種方法的主要思路就是，新建一個數組，然后在原數組中，從第一個開始，看看新數組里面有沒有這個元素，如果有，就忽略，然后進行下一個，如果沒有，則把這個元素存到新數組里面，

    //也就是說，每一次比較，都會遍歷新數組，直到找到相同元素為止，比較耗性能

如果大家不習慣這個寫法，可以改成下面的寫法，效果是一樣的：

var arr = [1,'b','b',4,3,3,4,5,1];

function unique1(arr){

      var arr1 = [];

      for(var i=0;i<arr.length;i++){

        if(arr1.indexOf(arr[i]) == -1){//判斷目標數組中在原數組里是否存在

          arr1.push(arr[i]); 

        } 

      } 

      return arr1;

    }

    console.log(arr); //[1,'b','b',4,3,3,4,5,1]

    console.log(unique1(arr)); //[1, "b", 4, 3, 5]

下面的方法我就不改寫法了，你們可以按照上面的格式來改寫一下，結果我也不輸出了，因為結果是一樣的，注釋寫在代碼中，慢慢體會一下

第二種，通過hash表（這個概念有點大，具體原理就不在這里細說了，有時間我會單獨寫一遍，這是好東西）實現(xiàn)

var arr = [1,'b','b',4,3,3,4,5,1];

Array.prototype.unique2 = function(){

      var hash = {}; //定義一個hash表

      var arr1 = []; //定義一個新數組

      for(var i=0;i<this.length;i++){

        /*

          這里比較難理解，我們一步一步來看：

          hash是一個對象，則存在鍵值對（key：value），只不過現(xiàn)在是為空的,所以hash[key] = value;

          第一步：i=0;this[i]=this[0]=1; hash[this[0]] = hash[1] , 因為hash初始為空，沒有找到key=1的值，所以然后undefined，

          執(zhí)行下一步：hash[1] = true(此時hash對象就有了第一組鍵值對)，將原數組的第一個數添加到新數組中，重復第一步

          因為不重復的判斷hash的值都是undefined，而重復的都為true了,所以不重復都被添加到新數組中

          因為hash表存的值是存的地址，放在堆內存中，所以有多少個不重復的元素，就要分多少個內存來存放，所以這種方法比較占內存，但是相比之下，這種的運算運動是最快的，

          這也就是用空間來換取時間了，數據量比較小，推薦用此方法

        */

        if(! hash[this[i]]){

          hash[this[i]] = true;

          arr1.push(this[i]);

        }

      }

      return arr1;  

    }

    console.log(arr);

    console.log(arr.unique2());

第三種，通過遍歷自身的位置是否一致來實現(xiàn)

var arr = [1,'b','b',4,3,3,4,5,1];

Array.prototype.unique3 = function(){

      var arr1 = []; //定義一個新數組

      for(var i=0;i<this.length;i++){

        if(this.indexOf(this[i])==i){

        //這里也是indexOf遍歷，看從第一個元素在原數組中的位置，如果第一次出現(xiàn)的位置和下標相等，說明當前元素的不重復的，如果不等，說明該元素前面已經出現(xiàn)過

          arr1.push(this[i]);

        }

      }

      return arr1;  

    }

    console.log(arr);

    console.log(arr.unique3());

第四種，這個有點意思，只能運用到特殊場合，就是先跟數組排序，然后22比較，輸出一個排序過的新數組

Array.prototype.unique4 = function(){

      /*

        這里是思路是，先排序（默認從小到大），然后將原數組的第一個給新數組，

        因為是經過排序的，所以重復的只會存在在相鄰位置

        這里就相當于是做22比較，如果相等，則進行下一組，如果不相等，則把這個數存到新數組中，用這個數再進行比較

      */

      this.sort();

      var arr1 = [this[0]];

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

        if(this[i] !== arr1[arr1.length-1]){

          arr1.push(this[i]);

        } 

      }

      return arr1;  

    }

    console.log(arr);

    console.log(arr.unique4());

完結！

要求里面還說，可以使用雙層嵌套循環(huán)來實現(xiàn)，無法就是用2層for循環(huán)，讓每一個與原數組去比較

Array.prototype.unique5 = function(){

      //雙層循環(huán)，一一比較

      for(var i=0;i<this.length;i++){ //從0開始

        for(j= i+1;j<this.length;j++){ //從1開始，逐個比較

          if(this[i] === this[j]){ //如果恒定

            this.splice(j,1);  //就將這個元素刪掉

          } 

        } 

      }

      return this;  

    }

    console.log(arr);

    console.log(arr.unique5());

這種寫法的循環(huán)次數太多，不推薦，有人會說，第一種和第三種不也是每次都遍歷一遍嗎?跟第5種感覺也差不多呢？是的，你能這么理解，說明你理解了，但是呢，又不是特別的理解，我們說差不多那可就差太多了，indexOf（）表示的是找到第一個匹配的元素就會停止遍歷，而第5種則是不管找不找得到，都會把整個數組遍歷一遍，如果數據量大，那你覺得哪個性能要好一點？

特別注意的一點：如果在比較兩兩之間的值是全等或不等的時候，一定要用恒定（===）和不恒定（！==），因為這會涉及到元素的類型上，如 1與'1'是不恒等的！

上面的可真是干貨了，一點水分都沒有，只能靠大家自己領悟了！