数组去重的7种方案

1. 基础算法

首先，声明一个_arr变量存储最后的结果，两层for循环嵌套查重，将我们要筛选的数组和_arr里的值进行对比，如果一样就停止循环，不一样就加入到_arr当中

let originalArr = [1, 2, 2, 3, 4, 4];

function uniqueArr(arr) {
  let _arr = [];
  let isRepeat = false;

  for (let i = 0; i < arr.length; i++) {
    isRepeat = false;
    for(let j = 0; j < _arr.length; j++) {
      if (arr[i] === _arr[j]) {
        isRepeat = true;
        break;
      }
    }
    if (!isRepeat) {
      _arr.push(arr[i])
    }
  }
  return _arr;
}

console.log(uniqueArr(originalArr))

2. indexOf

indexOf方法返回第一次出现一个值的下标

声明一个_arr变量存储最后的结果，forEach循环遍历需要筛选的数组，如果indexOf找的下标和当前index值相同，说明是第一次出现，push到_arr中

function uniqueArr(arr) {
  var _arr = [];

  arr.forEach((item, index) => {
    if (arr.indexOf(item) === index) {
      _arr.push(item)
    }
  })
  return _arr;
}

3. filter

filter方法筛选数组，通过indexOf方法找到当前项第一次出现的下标，如果和当前遍历的index值一样的话，说明是第一次出现，返回结果

function uniqueArr(arr) {
  return arr.filter((item, index) => {
    return arr.indexOf(item) === index;
  })
}

比上一种写法更简单一点

4. sort相邻元素去重

声明一个_arr变量存储最后的结果，对需要需要筛选的数组进行排序，遍历比较当前项和下一个项，如果不一致，说明没有重复，push到_arr中

function uniqueArr(arr) {
  let _arr = [];
  arr.sort();
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] !== arr[i + 1]) {
      _arr.push(arr[i]);
    }
  }
  return _arr;
}

5. includes

声明一个_arr变量存储最后的结果，遍历需要筛选的数组，通过includes方法查找_arr中是否存在当前项，不存在就push到_arr中

function uniqueArr(arr) {
  let _arr = [];
  arr.forEach(item => {
    if (!_arr.includes(item)) {
      _arr.push(item);
    }
  });
  return _arr;
}

6. Set

set里面所有的值都是唯一的，去重后转成数组返回即可

function uniqueArr(array){
  return Array.from(new Set(array));
}

7. Map

声明两个变量，一个存储最后的结果，一个使用Map结果进行缓存，forEach遍历需要筛选的数组，Map键名存储当前项，添加之前通过Map.get()方法判断是否存在当前项对应的值，不存在就推入到缓存和结果当中

function uniqueArr(arr) {
  let _arr = [];
  let _temp = new Map();
  arr.forEach(item => {
    if (!_temp.get(item)) {
      _temp.set(item, 1);
      _arr.push(item)
    }
  });
  console.log(_temp)
  return _arr;
}