陣列去重，一般都是在面試的時候才會碰到，一般是要求手寫陣列去重方法的程式碼。如果是被提問到，陣列去重的方法有哪些？你能答出其中的10種，面試官很有可能對你刮目相看。

在真實的專案中碰到的陣列去重，一般都是後臺去處理，很少讓前端處理陣列去重。雖然日常專案用到的概率比較低，但還是需要了解一下，以防面試的時候可能回被問到。

一、利用ES6 Set去重（ES6中最常用）

1.    function unique (arr) {

2.      return Array.from(new Set(arr))

3.    }

4.    var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];

5.    console.log(unique(arr))

6.     //[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]

不考慮相容性，這種去重的方法程式碼最少。這種方法還無法去掉“{}”空物件，後面的高階方法會新增去掉“{}”空物件。

二、利用for巢狀for，然後splice去重（ES5中最常用）

1.    function unique(arr){            

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

3.                for(var j=i+1; j<arr.length; j++){

4.                    if(arr[i]==arr[j]){         //第一個等同於第二個，splice方法刪除第二個

5.                        arr.splice(j,1);

6.                        j--;

7.                    }

8.                }

9.            }

10.    return arr;

11.    }

12.    var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];

13.        console.log(unique(arr))

14.        //[1, "true", 15, false, undefined, NaN, NaN, "NaN", "a", {…}, {…}]

雙層迴圈，外層迴圈元素，內層迴圈時比較值。值相同時，則刪去這個值。

想快速學習更多常用的ES6語法，可以看我之前的文章《學習ES6筆記──工作中常用到的ES6語法》（https://segmentfault.com/a/1190000016068235）。

三、利用indexOf去重

1.    function unique(arr) {

2.        if (!Array.isArray(arr)) {

3.            console.log('type error!')

4.            return

5.        }

6.        var array = [];

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

8.            if (array .indexOf(arr[i]) === -1) {

9.                array .push(arr[i])

10.            }

11.        }

12.        return array;

13.    }

新建一個空的結果陣列，for 迴圈原陣列，判斷結果陣列是否存在當前元素，如果有相同的值則跳過，不相同則push進陣列。

四、利用sort()

1.    function unique(arr) {

2.        if (!Array.isArray(arr)) {

3.            console.log('type error!')

4.            return;

5.        }

6.        arr = arr.sort()

7.        var arrry= [arr[0]];

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

9.            if (arr[i] !== arr[i-1]) {

10.                arrry.push(arr[i]);

11.            }

12.        }

13.        return arrry;

14.    }

利用sort()排序方法，然後根據排序後的結果進行遍歷及相鄰元素比對。

五、利用物件的屬性不能相同的特點進行去重

1.    function unique(arr) {

2.        if (!Array.isArray(arr)) {

3.            console.log('type error!')

4.            return

5.        }

6.        var arrry= [];

7.         var  obj = {};

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

9.            if (!obj[arr[i]]) {

10.                arrry.push(arr[i])

11.                obj[arr[i]] = 1

12.            } else {

13.                obj[arr[i]]++

14.            }

15.        }

16.        return arrry;

17.    }

六、利用includes

1.    function unique(arr) {

2.        if (!Array.isArray(arr)) {

3.            console.log('type error!')

4.            return

5.        }

6.        var arrry=[];

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

8.                if( !arrry.includes( arr[i]) ) {//includes 檢測陣列是否有某個值

9.                        arrry.push(arr[i]);

10.                  }

11.        }

12.    }

七、利用hasOwnProperty

1.    function unique(arr) {

2.        var obj = {};

3.        return arr.filter(function(item, index, arr){

4.            return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)

5.        })

6.    }

利用hasOwnProperty 判斷是否存在物件屬性。

八、利用filter

1.    function unique(arr) {

2.      return arr.filter(function(item, index, arr) {

3.        //當前元素，在原始陣列中的第一個索引==當前索引值，否則返回當前元素

4.        return arr.indexOf(item, 0) === index;

5.      });

6.    }

九、利用遞迴去重

1.    function unique(arr) {

2.            var arrry= arr;

3.            var len = arrry.length;

4.        arrry.sort(function(a,b){   //排序後更加方便去重

5.            return a - b;

6.        })

7.        function loop(index){

8.            if(index >= 1){

9.                if(arrry[index] === arrry[index-1]){

10.                    arrry.splice(index,1);

11.                }

12.                loop(index - 1);    //遞迴loop，然後陣列去重

13.            }

14.        }

15.        loop(len-1);

16.        return arrry;

17.    }

十、利用Map資料結構去重

1.    function arrayNonRepeatfy(arr) {

2.      let map = new Map();

3.      let array = new Array();  // 陣列用於返回結果

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

5.        if(map .has(arr[i])) {  // 如果有該key值

6.          map .set(arr[i], true);

7.        } else {

8.          map .set(arr[i], false);   // 如果沒有該key值

9.          array .push(arr[i]);

10.        }

11.      }

12.      return array ;

13.    }

建立一個空Map資料結構，遍歷需要去重的陣列，把陣列的每一個元素作為key存到Map中。由於Map中不會出現相同的key值，所以最終得到的就是去重後的結果。

十一、利用reduce

1.    Array.prototype.unique = function() {

2.      var sortArr = this.sort();

3.      var array = [];

4.      sortArr.reduce((s1,s2) => {

5.        if(s1 !== s2){

6.          array .push(s1);

7.        }

8.        return s2;

9.      })

10.      array .push(sortArr[sortArr.length - 1]);

11.      return array ;

12.    }

十二、[...new Set(arr)]

1.    [...new Set(arr)]

2.    //程式碼就是這麼少----（其實，嚴格來說並不算是一種，相對於第一種方法來說只是簡化了程式碼）

PS：有些文章提到了 foreach+indexOf 陣列去重的方法，個人覺得都是大同小異，所以沒有寫上去。