常用的数组去重方式

数组去重通用做法一般有两种方法：
1、两层循环
2、利用对象属性的不可重复性
还有一种是语言本身 api 特性， js 利用 indexOf 、 includes 、 Set 等方法

将下面合过属性进行去重操作

let arr = [ 1, 1, "true", "true", true, true, 15, 15, false, false, undefined, undefined, null, null, NaN, NaN, "NaN", 0, 0, "a", "a", {}, {}, 1, "true", true, 15, false, 'false', undefined, null, NaN, "NaN", 0, {}];

用 Set 去重

无法对对象去重

const newArr = Array.from(new Set(arr));
// 等价于
const newArr = [...new Set(arr)];

console.log(newArr)

for 循环嵌套 for 循环，用 splice 去重

第一个和第二个相同，用 splice 删掉第二个

对象和 NaN 无法去重

Tips：会改变原数组

for 循环可以用 forEach 、 map 等代替，逻辑都差不多

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);
    }
  }
}
console.log(arr);

indexOf 去重

新建一个数组， for 循环原数组，判断新数组中有没有当前元素，有就跳过，没有就放进去。

对象和 NaN 无法去重

let newArr = [];
for (let i = 0; i < arr.length; i++) {
  if (newArr.indexOf(arr[i]) === -1) {
    newArr.push(arr[i]);
  }
}
console.log(newArr);

includes 去重

使用方法和 indexOf 差不多，但它可以对 NaN 去重

对象无法去重

let newArr = [];
for (let i = 0; i < arr.length; i++) {
  if (!newArr.includes(arr[i])) {
    newArr.push(arr[i]);
  }
}
console.log(newArr);

利用 sort 排序

利用 sort ， for 循环 sort 排序后的数组，比较当前数组和当前数组的前一项，如果相等就跳过

对象和 NaN 无法去重

Tips：如果排序出来相同的有间隔，则间隔的无法去重，比如： [true, 'true', true]

arr = arr.sort();
let newArr = [];
for (let i = 0; i < arr.length; i++) {
  if (arr[i] !== arr[i - 1]) {
    newArr.push(arr[i]);
  }
}
console.log(newArr)

利用 filter 配合 indexOf

和遍历差不多，使用 indexOf 的话 NaN 全部被去掉了（不包括 'NaN' ），因为用 indexOf 找不到 NaN 。

对象不会被去重

const newArr = arr.filter(
  (item, index, array) => array.indexOf(item) === index
);
console.log(newArr);

利用 reduce 配合 includes

const newArr = arr.reduce(
  (prev, cur) => (prev.includes(cur) ? [...prev] : [...prev, cur]),
  []
);
console.log(newArr);

利用 filter 和 hasOwnProperty

定义一个空对象

用 filter 遍历数组，使用 hasOwnProperty 判断 obj 上有没有这个属性，如果有，就返回 false 如果没有返回 true ，并将这个值以属性的方式保存在 obj

Tips：对象无法去重，最后只会保留一个对象

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

以上数组去重的方式，都有一点有缺陷，要写出完美的去重方式需要考虑多种数据类型，这里不做过多讨论，上面几种方式的去重可基本满足日常工作的需要。