JS数组去重

1.双指针（力扣26）

var removeDuplicates = function(nums) {
    let n=nums.length;
    let slow=0;
    let fast=1;
    while(fast<n){
        if(nums[fast]!=nums[slow]){
            nums[slow+1]=nums[fast];
            slow++;
        }
        fast++;
    }
    return slow+1;
};

2.ES6新增

const arr = [1, 1, 2, 2, 3, 4, 5, 5]
const newArr = [...new Set(arr)]

new Set(arr)接受一个数组参数并生成一个set结构的数据类型。set数据类型的元素不会重复
补充：关于...操作符
多个元素收集起来并“凝聚”为单个元素

let a = [1, 2, 3, 4];
let b = [8, 9, ...a];
let c = [...a];
console.log(c); //[ 1, 2, 3, 4 ]
console.log(b); //[ 8, 9, 1, 2, 3, 4 ]

3.includes 方法 ES6新增

Array.includes() 有没有这个元素

a.forEach(element => {
    if(!newArr.includes(element)){
        newArr.push(element);
    }
});

4.indexOf()

indexOf()查看有没有这个元素的索引，使用严格相等===

a.forEach(element => {
    if(newArr.indexOf(element)===-1){
        newArr.push(element);
    }
});

5.使用了map特性

function unique(arr){
    let ret =[];
    let len=arr.length;
    let temp=new Map();
    for(let i=0;i<len;i++){
        if(!temp.get(arr[i])){
            temp.set(arr[i],i);
            ret.push(arr[i]);
        }
    }
    return ret;
}

6.使用set

function unique(arr){
    var set = new Set(arr);
    return Array.from(set);
    //return [...new Set(arr)]
}

补充相关知识：

补充
NaN它是数字类型
根据规范，比较运算中只要有一个值为NaN，则比较结果为false，所以会有下面这些看起来奇怪的结论：

// 全都是false
0 < NaN;
0 > NaN;
0 == NaN;
0 === NaN;

这意味着任何涉及到NaN的情况都不能简单地使用比较运算来判定是否相等。比较科学的方法只能是使用isNaN()：

var a = NaN;
var b = NaN;
// true
console.log(isNaN(a) && isNaN(b));

let a=[null,undefined,NaN,0];
console.log(a);
console.log(a.includes(null));
console.log(a.includes(undefined));
console.log(a.includes(NaN)); //true,能试别NaN
console.log(a.includes(0));

console.log(a.indexOf(null));
console.log(a.indexOf(undefined));
console.log(a.indexOf(NaN));//-1 indexOf() 无法试别NaN
console.log(a.indexOf(0));