数组去重的几种方式

1.reduce实现数组去重

var myArray = [1,2,2,3,4,4];
var myOrderedArray = myArray.reduce(function (accumulator, currentValue) {
    //accumulator有初始值 赋值为空数组   空数组中没有1 indexOf为-1 进入循环   
    console.log(accumulator.indexOf(currentValue) )
  if (accumulator.indexOf(currentValue) === -1) {
      //[1] => 在执行 数组变为[1,2]  indexOf 是返回数组当前值得下标 2第一次进去得时候不存在是-1进入循环
      //push进去数组 第二个2存在 返回下标 return出去 以此类推 实现数组去重
    accumulator.push(currentValue);
  }
  return accumulator
}, [])
console.log(myOrderedArray);
================================================================
let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
let result = arr.sort().reduce((init, current) => {
    if(init.length === 0 || init[init.length-1] !== current) {
        init.push(current);
    }
    return init;
}, []);
console.log(result); //[1,2,3,4,5]

2.includes 去重

let myArray = [1, 2, 2, 3, 4, 4];
let newArr = [];
for (let i = 0; i < myArray.length; i++) {
    let item = myArray[i];
    //验证新数组中是否存在这一项
    if(newArr.includes(item)){continue}
    //新数组中不存在这一项，直接加入到新数组中
    newArr.push(item)
}
console.log(newArr) //原数组未去重，新数组去重了

======================================================================
let myArray = [1, 2, 2, 3, 4, 4];
let newArr = [];
myArray.forEach((item)=>{
     //验证新数组中是否存在这一项
    if(newArr.includes(item)){
        return
    }
    newArr.push(item)
})
console.log(newArr) //原数组未去重，新数组去重了
//ie  6 7 8 不兼容

3.双重for循环去重

一张图了解数组塌陷问题

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--;//数组塌陷了 j后面得每一项索引都提前了一位，下一次要比较得应该还是j这个索引得内容
                }
            }
        }
return arr;
}

4.indexOf去重

function bb(arr){
    let newArr = [];
    for(let i = 0;i<arr.length;i++){
        if(newArr.indexOf(arr[i]) === -1){
            newArr.push(arr[i])//indexOf  不存在返回-1  满足条件加进去
        }
    }
    return newArr;
}//ie  6 7 8 不兼容function bb(arr){
    let newArr = [];
    for(let i = 0;i<arr.length;i++){
        if(newArr.indexOf(arr[i]) === -1){
            newArr.push(arr[i])//indexOf  不存在返回-1  满足条件加进去
        }
    }
    return newArr;
}//ie  6 7 8 不兼容

5.对象去重

    let arr = [1, 2, 2, 1, 3, 5,6,25];
    let obj = {};
    let newArr = [];
    for (let i = 0; i < arr.length; i++) {
        //对象获取数字对象  用中括号得方法
        if (obj[arr[i]] === arr[i]) {
            //说明值已经存在
            arr.splice(i,1); 
            i--;    //数组塌陷问题 索引向前提一位
            continue
        } else {
            obj[arr[i]] = arr[i]  //对象赋值
            newArr.push(arr[i])
        }
    }
    console.log(obj)// {1: 1, 2: 2, 3: 3, 5: 5, 6: 6, 25: 25}
    console.log(newArr)// [1, 2, 3, 5, 6, 25] 
//缺陷  对象类得值不能处理
============================较好的方法 不使用splice数组去重=====================
  let arr = [1, 2, 2, 1, 3, 5, 6, 25];
let obj = {};
let newArr = [];
for (let i = 0; i < arr.length; i++) {
  if (obj[arr[i]] === arr[i]) {
    arr[i] = arr[arr.length - 1];
    arr.length--;
    i--;
    continue
  } else {
    obj[arr[i]] = arr[i]
    newArr.push(arr[i])
  }
}
==============封装函数方式=======================================
  function uniue(arr) {
  let obj = {};
  let newArr = [];
  for (let i = 0; i < arr.length; i++) {
    if (obj[arr[i]] === arr[i]) {
      //如果已经存在 将数组的最后一位移到当前位置
      arr[i] = arr[arr.length - 1]; 
      arr.length--; //然后 删除最后一项
      i--;  //并将对应得数组长度-1
      continue
    } 
    newArr.push( arr[i])
    obj[arr[i]] = arr[i];
  }
  return newArr;
}
let arr1 = [1, 2, 2, 1, 3, 5, 6, 25];
;
console.log(uniue(arr1))

6.ES6 Set去重

 let arr1 = [1, 2, 2, 1, 3, 5, 6];
 let arr = [...new Set(arr1)];
 console.log(arr)  // [1, 2, 3, 5, 6]

7.在原型上封装去重

8.利用Map

const unique5 = arr => {
  const map = new Map();
  const res = [];
  for (let i = 0; i < arr.length; i++) {
    if (!map.has(arr[i])) {
      map.set(arr[i], true)
      res.push(arr[i]);
    }
  }
  return res;
}

9.利用filter

const unique4 = arr => {
  return arr.filter((item, index) => {
    return arr.indexOf(item) === index;
  });
}