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

一、数组去重

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":"王五"}]

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