JavaScript数组去重的11种方式

数组去重是我们在工作和面试中经常问的问题，所以，自己也总结了一下，与大家分享。由于作者本人水平有限，难免会出现错误，请大家指正。

var arr = [{}, {},1, 1, 'true', 'true', true, true, 16, 16, false, false, undefined, undefined, null, null, NaN, NaN,'NaN', 0, 0, 'a', 'a', 0,69.3];

1. 用indexOf去重 缺点:NaN、{}没有去重。

   function uniArray(arr) {
      if (Array.isArray(arr)) {
         let tempArr = [];
         arr.forEach((item,index)=>{
         if(tempArr.indexOf(item) === -1){
             tempArr.push(item);
         }
      })
      return tempArr;
      } else {
         console.log("请传入一个数组!");
         return;
      }
   };
   

2. 利用ES6 Set去重. 缺点: 无法去掉“{}”空对象

   function uniArray(arr){
      return [...new Set(arr)]
   }
   function uniArray(arr){
      return Array.from(new Set(arr));
   }
   

3. 利用for嵌套for，然后splice去重. 缺点: NaN和{}没有去重, 如果是if(arr[i] == arr[j])会出现 两个null消失的情况

   function uniArray(arr) {
         for(let i = 0; i <arr.length;i++){
             for(let j = i + 1; j <arr.length;j++){
                 if(arr[i] === arr[j]){
                    arr.splice(j,1);
                     j--;
                 }
           }
      }
      return arr;
   }
   

4. 用filter去重 缺点:{}没有去重，NaN没了.

   function uniArray(arr) {
        return arr.filter(function (currentValue, index, arr) {
           return arr.indexOf(currentValue) === index;
       })
    }
   

5. 用sort去重 缺点:NaN、{}没有去重.

   function uniArray(arr) {
          arr = arr.sort();
           var array = [arr[0]];
           for (var i = 1; i < arr.length; i++) {
           if (arr[i] !== arr[i - 1]) {
              array.push(arr[i]);
           }
      }
      return array;
   }
   

6. includes去重， 缺点： {}没有去重.

   function uniArray(arr) {
         var array=[]
         for (var i = 0; i < arr.length; i++) {
         if(!array.includes(arr[i])){
              array.push(arr[i]);
         }
     }
      return array;
   }
   

7. map去重，缺点： {}未去重。

   function uniArray(arr) {
        let map = new Map();
        let array = new Array();
        for (let i = 0; i < arr.length; i++) {
               if(map.has(arr[i])){
                   map.set(arr[i],true);
               }else{
                   map.set(arr[i],false);
                   array.push(arr[i]);
           }
       }
       return array;
   }
   

8. 用数组和对象去重。 缺点:对象的键值因为具有唯一性，所以可以将数组成员作为key保存起来，在数组全部循环过一次后，再循环取出对象的key添加到一个空白数组中，但是这种方法会导致取出的数组成员数据类型全部转换为文本类型。

   function uniArray(arr) {
           var array = [];
           var obj = {};
           for (var i = 0; i < arr.length; i++) {
               if (!obj[arr[i]]) {
                   array.push(arr[i])
                   obj[arr[i]] = 1;
               }else{
                   obj[arr[i]]++
               }
      }
       return array;
   }
   

9. 递归去重

   function uniArray(arr) {
            var array = arr;
            var len = array.length;
            array.sort(function (a, b) { 
                return a - b;
            })
            loop(len - 1);
            function loop(index) {
                if (index >= 1) {
                if (array[index] === array[index - 1]) {
                    array.splice(index, 1);
                }
                loop(index - 1);
            }
        }
        return array;
   }
   

10. 利用hasOwnProperty 缺点：无

    function uniArray(arr) {
       var obj = {};
       return arr.filter(function(item,index,arr){
              return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true);
       })
    }
    

11. 利用reduce,缺点:{}未去重。

    function uniArray(arr) {
       return arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);
    }
    

    总结：以上就是本人总结的数组去重的11种方法，与大家分享，全部经过作者测试过，可放心使用。