数组去重，对象去重，数组对象去重

一、数组去重

let srcArray = [1, 2, 3, 4, 1, 2, 3, 4]

1.  双层循环+splice

注： splice删除了一个元素，下标要减一，否则循环会漏掉一个元素(多个相邻的元素 可能会漏掉删除元素)

for(let i=0;i<srcArray.length - 1;i++){
    for(let  j = i+1;j<srcArray.length;j++){
        if(srcArray[i]  === srcArray[j] ){
            srcArray.splice(j,1);
            j--;
        }
    }
}   // srcArray=[1, 2, 3, 4]

2. forEach+indexOf (利用对象属性key排除重复项)

注：遍历数组，每次判断新数组中是否存在该属性，不存在就存储在新数组中

srcArray.forEach((key,index)=>{

    if(newArr.indexOf(key) === -1){ newArr.push(key) }

}) //newArr=[1, 2, 3, 4]

这个方法的优点是效率高，缺点是使用了额外空间

3. new Set(数组)

注：Set是一系列无序、没有重复值的数据集合，传入一个需要去重的数组，Set会自动删除重复的

let tarArray = new Set(srcArray )

// tarArray = [1, 2, 3, 4]

4. filter() + indexOf()

let tarArray = srcArray.filter((item, index, array) => {
  return array.indexOf(item) === index
})  // tarArray = [1, 2, 3, 4]

5. reduce() + includes

 注：利用reduce()的 “累加器”原理，保存一个唯一项的运行列表。

利用reduce遍历和传入一个空数组作为去重后的新数组，然后内部判断新数组中是否存在当前遍历的元素，不存在就插入新数组

let tarArray = srcArray.reduce((unique, item) => { unique.includes(item) ? unique : [...unique, item] }, [])

// tarArray = [1, 2, 3, 4]

二、对象去重

对象不用去重的！！！对象的属性的一个特点就是元素不能相同， 甚至还可以利用这个特性来去重。

三、对象数组去重

const arr = [{"id":1,"name":"张三"},{"id":2,"name":"李四"},{"id":3,"name":"王五"},{"id":2,"name":"张三"}];

1. 双层循环

for (let i = 0; i < arr.length; i++) {
      for (let j = i + 1; j < arr.length; j++) {
        if (arr[i].id === arr[j].id) {
          arr.splice(j, 1);
          j - - ;
        }
      }
    }   // arr= [{"id":1,"name":"张三"},{"id":2,"name":"李四"},{"id":3,"name":"王五"}]

2. for循环+新数组

    let result = [];

    for ( let i = 0; i < arr.length; i++) {
      var flag = true;
      for ( let j = 0; j < result.length; j++) {
        if (arr[i].id=== result[j].id) {
          flag = false;
        }
      }
      if (flag) {
        result.push(arr[i]);
      }
    } // result = [{"id":1,"name":"张三"},{"id":2,"name":"李四"},{"id":3,"name":"王五"}]

3. 利用对象属性

    let result = [];
    let obj = {};
    for (let i = 0; i < arr.length; i++) {
      if (!obj[arr[i].id]) {
        result.push(arr[i]);
        obj[arr[i].id] = true;
      }
    }  // result = [{"id":1,"name":"张三"},{"id":2,"name":"李四"},{"id":3,"name":"王五"}]

4.reduce()

注： reduce第一个参数是遍历需要执行的函数，第二个参数是item的初始值

let obj = {};
newarr = arr.reduce(function(item, next) { 
       obj[next.id] ? '  ' : obj[next.id] = true && item.push(next);
       return item;
    }, []); // newarr = [{"id":1,"name":"张三"},{"id":2,"name":"李四"},{"id":3,"name":"王五"}]

5. Map（）

注： has方法可以判断Map对象中是否存在指定元素,有则返回true，否则返回false

        set方法可以向Map对象添加新元素 map.set(key, value)

         values方法可以返回Map对象值的遍历器对象

let res = new Map();
    for (let i of arr) {
        if (!res.has(i.id)) {
            res.set(i.id, i);
        }
    }
 arr = [...res.values()]; 

 // arr = [{"id":1,"name":"张三"},{"id":2,"name":"李四"},{"id":3,"name":"王五"}]

总结：对象数组的去重，大多是在数组去重的基础上处理的，掌握了数组的去重，对象数组的去重基本一个套路，也就好弄了。