数组去重十大法

1. 最简单的: ES6的new Set方法

利用了在ES6中引入的Set对象的能力。集合保证保留插入项的顺序，并且只包含唯一值。因此，根据定义，集合不可能包含重复项！

（注意：用new Set()方法时返回的是伪数组 要结合Array.from()方法或者展开运算符转换为真正的数组）

        let a = [1,2,3,2,3,4,5]
        let b = Array.from(new Set(a)) 
        // 或 let b = [...new Set(a)]
        console.log(b); //[1,2,3,4,5]

2. for循环或者forEach循环 + indexOf( )：

步骤：声明新数组，for循环，push方法

        let a=[1,2,3,2,3,4,5]
        let b=[]
        for(let i=0;i<a.length;i++){
            if(b.indexOf(a[i])===-1){
                b.push(a[i])
            }
        }
        console.log(b);//[1,2,3,4,5]

3. filter( ) + indexOf( )

基本策略是遍历原数组 并检查我们当前检查的项的索引是否与原数组中的项的索引相同。

因为indexOf返回它为给定值找到的第一个索引，如果它不是重复值，那么该项的索引必须相同！

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

let uniqueArray = a.filter((item, index, array) => {
  return array.indexOf(item) === index
})

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

4. reduce( )+ includes( )

在reducer函数的“累加器”中保存一个唯一项的运行列表。对于原始列表中的每个项目，我们检查累加器是否包括正在考虑的项目。还要注意reducer函数之后传入的空数组是累加器的起始值，因此第一次通过reduce，unique是一个空数组。

通过includes返回的布尔值驱动我们的条件决定如何处理这个值，如果已经有了就"跳过"。

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

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

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

5. 简单粗暴：双重for循环

第一层从索引0开始循环，第二层从索引1开始循环，判断第一层循环的数组与第二层循环的数组是否相同，如果相同就删除第二层循环的数值

let arr = [1, 2, 3, 4, 1, 2, 3, 4]
for(let i = 0; i <= arr.length - 1 - 1; i++){
    for(let j = i+1; j <= arr.length; j++){
        if(arr[i] === arr[j]{
            arr.splice(i,1);
            j--; // 防止数组坍塌，删除数据后，后面的数据会进行补位，需要再退一位进行比较
        }
    }
}
// arr === [1, 2, 3, 4]

6. 利用空对象判断已经存储在空数组的数据数值 

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

let obj = {};
let newArr = [];
for(let i = 0; i <= arr.length - 1; i++){
    if(!obj[arr[i]){
        obj[arr[i]] = true;
        newArr.push(arr[i]);
    }
}
// newArr === [1, 2, 3, 4]

7. for循环 + includes( ) 

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

for(let i = 0; i <= arr.length - 1; i++){
    if(!newArr.includes(arr[i])){
        newArr.push(arr[i]);
    }
}
// newArr === [1, 2, 3, 4]

8. 声明一个临时变量存储要比较的值，声明空数组存储数值

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

let newArr = [];
let end;
arr.sort();
end = arr[0];
newArr.push(arr[0]);
for(let i = 1; i <= arr.length - 1; i++){
    if(arr[i] !== end){
        newArr.push(arr[i]);
        end = arr[i];
    }
}
// newArr === [1, 2, 3, 4]

9. 基本同8，不利用新数组，遇到相同的直接删除即可 

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

let end;
arr.sort(a,b) => (a - b));
end = arr[0];
for(let i = 1; i <= arr.length - 1; i++){
    if(arr[i] === end){
        arr.splice(i,1);
        i--;
    }else{
        end = arr[i];
    }
}
// newArr === [1, 2, 3, 4]

10. 声明变量存储重复数据的下标 

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

let newArr = [];
for(let i = 0; i <= arr.length - 1; i++){
    let repArr = []; // 接收重复数据的下标
    for(let j = i + 1; j <= arr.length; j++){
        if(arr[i] === arr[j]){
            repArr.push(j);  // 找出后面重复数据的下标
            i--;
        }   
    } 
   if(repArr.length === 0){ // 重复数组没有值则说明不是重复数据
        newArr.push(arr[i]);
    }
}
// newArr === [1, 2, 3, 4]