JS数组去重

一、es6中去重

最常用的利用Set去重

 可以对基本类型（包括NaN）和引用变量进行去重（对比的引用地址，不是内容）（空对象默认两个对象的引用地址不一致）

 function unique(arr) {
      var arr1 = [...new Set(arr)];
   // var arr1=Array.from(new Set(arr))
      console.log(arr1);
    }

 var a = {
      name: 1,
      age: "2"
    }
    var a = [true, "true", true, false, null, null, undefined, undefined, NaN, "NaN",
      0, 1, 1, 2, {}, {}, 'a', 'a', NaN, a, a, {
        name: 1
      }
    ];
    unique(a);

 

利用map去重

可以对基本类型（包括NaN）和引用变量进行去重（对比的引用地址，不是内容）（空对象默认两个对象的引用地址不一致）

 //  也可以用Map去重，但是比set麻烦（不建议使用） 
    function unique1(arr) {
      var map = new Map();
      var arr1 = [];
      for (let i = 0; i < arr.length; i++) {
        if (map.has(arr[i])) {
          map.set(arr[i], false);
        } else {
          map.set(arr[i], true); 
          arr1.push(arr[i]);
        }
      }
      console.log(arr1);
      var arr2 = [];
      // 可以找出不重复的值(只出现一次的值)(麻烦不建议使用)(可以对NaN做判断，但是对引用类型只判断地址，不判断内容)
      for ([key, value] of map.entries()) {
        if (value === true) {
          arr2.push(key);
        }
      }
      console.log(arr2);
    }
    var a = {
      name: 1,
      age: "2"
    }
    var a = [true, "true", true, false, null, null, undefined, undefined, NaN, "NaN",
      0, 1, 1, 2, {}, {}, 'a', 'a', NaN, a, a, {
        name: 1
      }
    ];
    unique1(a);

二、es5中的去重方法

         双重循环去重

注意：全等（===）对于引用类型一样只是对地址进行判断，对于NaN,他们默认他们是不同的。不能进行去重。

 
 // 可以对基本类型和引用变量进行去重（对比的引用地址，不是内容）（NaN不可以去重，空对象默认两个对象的引用地址不一致，）
function unique(arr) {
      for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length; j++) {
          if (i != j && arr[i] === arr[j]) {
            arr.splice(j, 1);
            j--;
          }
        }
      }
      console.log(arr);
    }
 var a = {
      name: 1,
      age: "2"
    }
    var a = [true, "true", true, false, null, null, undefined, undefined, NaN, "NaN",
      0, 1, 1, 2, {}, {}, 'a', 'a', NaN, a, a, {
        name: 1
      }
    ];
    unique(a);

 

利用数组indexOf进行数组去重

        利用好数组自身就有的API进行去重，减少重复造轮子的操作

       indexOf 可以和forEach，filter， for in，等等组合进行数组去重。

        注意：indexOf和全等（===）一样对于引用类型一样只是对地址进行判断，对于NaN,他们默认他们是不同的。

// indexOf 可以对基本类型和引用变量进行去重（对比的引用地址，不是内容）（NaN不可以去重，空对象默认两个对象的引用地址不一致，）
    function unique1(arr) {
      var arr1 = [];
      for (let i in arr) {
        if (arr1.indexOf(arr[i]) === -1) {
          arr1.push(arr[i]);
        }
      }
      console.log(arr1);
    }
    // indexOf 和filter应用
      function unique(arr) {
        return arr.filter(function (item, index, arr) {
          //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
          return arr.indexOf(item, 0) === index;
        });
      } 
 var a = {
      name: 1,
      age: "2"
    }
    var a = [true, "true", true, false, null, null, undefined, undefined, NaN, "NaN",
      0, 1, 1, 2, {}, {}, 'a', 'a', NaN, a, a, {
        name: 1
      }
    ];
    unique(a);
    unique1(a);

 

利用includes 进行去重

         includes 可以和forEach，filter， for in，reduce等等数组的api组合进行数组去重。(只要能循环出整个数组就可以利用includes和indexOf 对数组进行去重)

注意：利用includes 是可以对NaN进行去重的

// 利用includes  可以对基本类型和引用变量进行去重（对比的引用地址，不是内容）（空对象默认两个对象的引用地址不一致，）
    // 可以对NaN去重 
    function unique2(arr) {
      var arr1 = [];
      for (let i in arr) {
        if (!arr1.includes(arr[i])) { //检测数组是否有某个值
          arr1.push(arr[i]);
        }
      }
      console.log(arr1);
    }
    // 代码少 和上面这个一样的效果
    /*  function unique2(arr) {
       arr1 = arr.reduce((prev, cur) => {
         return prev.includes(cur) ? prev : [...prev, cur];
       }, [])
       console.log(arr1);
     } */

 var a = {
      name: 1,
      age: "2"
    }
    var a = [true, "true", true, false, null, null, undefined, undefined, NaN, "NaN",
      0, 1, 1, 2, {}, {}, 'a', 'a', NaN, a, a, {
        name: 1
      }
    ];
 unique2(a);

 

利用对象属性hasOwnProperty()去重

   利用对象属性hasOwnProperty可以和forEach，filter， for in，reduce等等数组的api组合进行数组去重。(只要能循环出整个数组就可以利用includes和indexOf 对数组进行去重)

注意：对引用类型的去重只会留下一个，(有问题不建议使用)

 // 利用hasOwnProperty()去重   可以对基本类型 ,对引用类型的去重只会留下一个(有问题，不建议使用)
    function unique3(arr) {
      var obj = {};
      return arr.filter((item, index, arr) => {
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true);
      })
    }
 var a = {
      name: 1,
      age: "2"
    }
    var a = [true, "true", true, false, null, null, undefined, undefined, NaN, "NaN",
      0, 1, 1, 2, {}, {}, 'a', 'a', NaN, a, a, {
        name: 1
      }
    ];
 console.log(unique3(a));// true, "true", false, null, undefined, NaN, "NaN", 0, 1, 2,object{},'a'

利用递归去重

 function unique4(arr) {
      var array = arr;
      var len = array.length;

      array.sort(function (a, b) { //排序后更加方便去重
        return a - b;
      })

      function loop(index) {
        if (index >= 1) {
          if (array[index] === array[index - 1]) {
            array.splice(index, 1);
          }
          loop(index - 1); //递归loop，然后数组去重
        }
      }
      loop(len - 1);
      return array;
    }
    var a = {
      name: 1,
      age: "2"
    }
    var a = [true, "true", true, false, null, null, undefined, undefined, NaN, "NaN",
      0, 1, 1, 2, {}, {}, 'a', 'a', NaN, a, a, {
        name: 1
      }
    ];
 console.log(unique4(a));

         对于上面这些数组去重的方法set是最简单和代码最少的（但是set有兼容性问题，但是现在的浏览器基本上都支持了es6语法，所以set是最好用的）。其他的方法可以延展许多不同的方法，但是总的还是用到了indexOf 、includes、双重循环等等。

        总之一句话，有可以用的api就用api,减少重复造轮子的操作。