前言

数组去重是我们开发中必不可少的，那么你知道几种方法呢，它们之间又有何优缺点，效率又是怎样的，以下就是我个人拙见~

双层for循环+splice

双层for循环，两两比较，如果两个数相同，则删除一个，这是种笨方法哦！

const arr = [1,1,2,'a','b','a',true,true,false]
function unique(arr) {
    for (var i = 0; i < arr.length; i++) {
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[i] == arr[j]) { //第一个等同于第二个，splice方法删除第二个
                arr.splice(j, 1);
                j--;
            }
        }
    }
    return arr
}
console.log(unique(arr)) // [1, 2, 'a', 'b', false]

for循环+indexOf

indexOf() 方法查找元素索引找不到就返回-1， 接着判断，如果是-1，说明没找到，就往新数组里面添加元素

const arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1]
function unique(arr) {
  let newArr = []
  for(let i = 0;i<arr.length;i++){
    newArr.indexOf(arr[i]) === -1 ? newArr.push(arr[i]) : newArr
  };
  return newArr
}
console.log(unique(arr))

reduce+includes

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值 includes() 方法用于判断字符串是否包含指定的子字符串,或者判断数组中是否有指定的元素

const arr = [1,1,2,'a','b','a',true,true,false]
// 第一个参数pre是上一次循环的结果，第二个参数item是当前的元素
const result = arr.reduce((pre, cur) => {
    // 判断上次的结果包不包含当前元素 包含直接返回pre 不包含用展开运算符后在加进去
    return pre.includes(cur) ? pre : [...pre, cur]
}, []) //初始值是个空数组
console.log(result)  // [1, 2, 'a', 'b', true, false]

ES6中的Set方法

适配范围广，但是存在兼容性问题

const arr = [1,1,2,'a','b','a',true,true,false]
function unique(arr) {
      return [...new Set(arr)]
}
console.log(unique(arr)) // [1, 2, 'a', 'b', true, false]

ES6 filter方法

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

const arr = [1,1,2,'a','b','a',true,true,false]
const result = arr.filter((item, index) => {
    // indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
    return arr.indexOf(item) === index
})
console.log(result) // [1, 2, 'a', 'b', true, false]

总结

去重的方法有好多种，以上列出的只是几种方法而已，开发的时候可以根据自己的需求来选择哦！