JS数组去重方法知多少

1. 双层循环

  let arr = [1,1,2,3,3];
  
  function unique(arr) {
    // res保存去重之后的数组
    let res = [];
    res[0] = arr[0];  // 放心的把第一个元素放进去
    for(let i=0;i<arr.length;i++) {   // 第一层循环遍历arr的每一个元素
      for(let j=0;j<res.length;j++) {   //第二层循环用arr的每一个元素和res的元素对比
        if(arr[i] === res[j]) {
          break;    // res中有此元素了，不用比了，下一个
        }
        if(j == res.length-1) {
          res.push(arr[i]); // 居然可以走到这，说明res里面没有arr[i]
        }
      }
    }
    return res;
  }

这个可以说是最基础，最暴力的方法了,优点是兼容性好

2. indexOf

arr.indexOf(item):如果arr中有item返回item的索引，如果没有返回 -1

  let arr = [1,1,2,3,4,4];
  function unique(arr) {
    let res = [];
    for(let i=0;i<arr.length;i++) {
      if(res.indexOf(arr[i])=== -1) {   // 如果res中没有arr[i],你说怎么办？？？
        res.push(arr[i]);
      }
    }
    return res;
  }

相对于第一种方法，至少代码少了一点

3. 排序后去重

  let arr = [1,2,3,4,3,3];
  function unique(arr) {
    let res = [];
    let sortedArr = arr.concat().sort();  //arr.concat()复制一份arr出来排序
    res[0] = sortedArr[0];  //第一个放心放进去
    let temp = sortedArr[0]; // 用来表示当前存入的元素，便于下次比较用
    for(let i=1;i<sortedArr.length;i++) {
      if(temp !== sortedArr[i]) {   // 与上一个元素不同的元素
        res.push(sortedArr[i]);
      }
      temp = sortedArr[i];  //更新上一个当前元素作为上一个元素
    }
    return res;
  }

4. filter

filter过滤器，配合indexOf

  let arr = [1,1,2,3,3];

  function unique(arr) {
    let res = arr.filter(function(item, index, arr){
      return arr.indexOf(item) === index; 
    })
    return res;
  }

骚微说一下：filter接收一个函数作为参数，并且返回bool值，为true保留当前item. 由于有多个重复元素时indexOf返回第一个符合的元素的索引，所以，对于重复的元素之后保留第一个.

5. ES6

ES6提供了Set()和map()数据结构,让代码更加简便

  function unique(arr) {
    return Array.from(new Set(arr));
  }
  // 简化一下
  function unique(arr) {
    return [...new Set(arr)];   // 看不懂可以看看es6
  }
  // 再简化一下
  let unique = (a) => [...new Set(arr)];
  // Map
  function unique(arr) {
    const seen = new Map();
    return arr.filter((a) => !seen.has(a) && seen.set(a,1));
  }

不同方法的处理能力

对于对象null,undefiend,NaN等，会出现一些小问题,例如[1,2,NaN].indexOf(NaN)就会返回 -1

方法	能力
for	对象和NaN无法去重
indexOf	对象和NaN无法去重
sort	对象和NaN和1无法去重
filter + indexOf	对象不去重，NaN忽略
Set	对象不去重，NaN去重