数组去重的9种方法

1、利用ES6中Set去重和解构赋值

ES6提供了新的数据结构Set，Set函数可以接受一个数组（或类数组对象）作为参数来初始化。

…扩展运算符 （…可用来转换为数组对象）

let arr = [1,1,2,4,true,true,false,false,null,null,"af","he","af",undefined,undefined,{},{},NaN,NaN]
let newArr = new Set(arr)
console.log(...newArr)
// 1 2 4 true false null af he undefined {} {} NaN

问题：因为js是判断对象地址是否相同，而不是对象内容，所以每个空对象都是不相等的。

缺点：存在兼容性问题，不支持IE

2、双重for嵌套循环，然后splice去重(ES5中常用)

splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组，并以数组形式返回被修改的内容。此方法会改变原数组。
splice()方法可删除从index处开始的零个或多个元素

for(let i = 0 ; i < arr.length ; i++){
  for(let j = i+1; j < arr.length ; j++){     // j = i + 1 也就是第一个数加1=第二个数
    if(arr[i] == arr[j] ){                    // 判断第二个数是否和第一个数相等
      arr.splice(j,1)                         // 如果相等则用splice删除第二个数,删除一个
      j--
    }
  }
}
console.log(...arr)           // 两个等1 2 4 false null af he {} {} NaN NaN

问题：NaN和 {} 没有去重，两个true和两个undefined直接消失了
解决：改为===即可

for(let i = 0 ; i < arr.length ; i++){
  for(let j = i+1; j < arr.length ; j++){     // j = i + 1 也就是第一个数加1=第二个数
    if(arr[i] === arr[j] ){                    // 判断第二个数是否和第一个数相等
      arr.splice(j,1)                         // 如果相等则用splice删除第二个数,删除一个
      j--
    }
  }
}
console.log(...arr)       // 三个等 1 2 4 true false null af he undefined {} {} NaN NaN

严格相等===：两个被比较的值类型相同，值也相同，两个被比较的值在比较前都不进行隐式转换
非严格相等==：在比较前将两个被比较的值转换为相同类型

3、利用sort()去重

sort() 方法对数组的元素进行排序，并返回数组

arr = arr.sort()
let array = [arr[0]]
for(let i = 1 ; i < arr.length ; i++){
  if(arr[i] !== arr[i - 1]){      //判断相邻元素是否相等
    array.push(arr[i])
  }
}
console.log(...array)   //展开数组  
// 1 2 4 NaN NaN {} {} af false he null true undefined

4、利用数组原型对象中的includes方法

includes方法可用来检测数组是否含有某个值

let array = []
for(let i = 0 ; i < arr.length ; i++){
  if(!array.includes(arr[i])){
    array.push(arr[i])
  }
}
console.log(...array)
// 1 2 4 true false null af he undefined {} {} NaN

此时NaN也去重了

5、利用数组原型对象中的filter+includes

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

filter不会改变原始数组。利用fifter进行遍历

let newArr = []
newArr = arr.filter(item=>{
  return newArr.includes(item) ? '' : newArr.push(item)
})
console.log(...newArr)//1 2 4 true false null af he undefined {} {} NaN

6、利用数组原型对象中的forEach+includes

forEach方法：循环遍历数组中的每一项。

forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。

map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

map()方法按照原始数组元素顺序依次处理元素

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。没有符合条件的元素时返回空数组。

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值

let newArr = []
arr.forEach(item => {
  return newArr.includes(item) ? '' : newArr.push(item)
})
console.log(...newArr)//1 2 4 true false null af he undefined {} {} NaN

7、利用filter

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

let newArr = arr.filter((item,index,array)=>{
  return arr.indexOf(item,0) === index
})
console.log(...newArr)//1 2 4 true false null af he undefined {} {}

8、利用Map数据结构去重

map是ES提供的一种字典数据结构
字典结构——用来存储不重复key的hash结构。不同于集合（set）的是，字典使用的是键值对的形式来存储数据

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])
  }
}
console.log(...array)//1 2 4 true false null af he undefined {} {} NaN

9、利用reduce+includes去重

let newArr = arr.reduce((prev,item)=>
  prev.includes(item) ? prev : [...prev ,item ],[]
)
console.log(...newArr)//1 2 4 true false null af he undefined {} {} NaN