数组去重方法总结

一、利用ES6方法去重

//基本用法
const arr=[true,false,true,undefined, null,NaN, 0,null, 1, {}, {}, 'a', 'a', NaN];
const result=[...new Set(arr)];
console.log(result);//[true, false, undefined, null, NaN, 0, 1, {}, {}, "a"]；

es6的第一种方法，利用js扩展运算符和new Set()方法实现去重，缺点是无法去掉重复的{}

//封装成数组方法
Array.prototype.uniq = function () {
　　return Array.from(new Set(this))
};
const arr=[true,false,true,undefined, null,NaN, 0,null, 1, {}, {}, 'a', 'a', NaN];
const result=arr.uniq();
console.log(result);//[true, false, undefined, null, NaN, 0, 1, {}, {}, "a"]

es6的第二种方法，利用Array.from()和new Set()方法实现去重，缺点是无法去掉重复的{}

//封装成数组方法
Array.prototype.uniq = function () {
  const res = new Map();
  return arr.filter((a) => !res.has(a) && res.set(a, 1))
};
const arr=[true,false,true,undefined, null,NaN, 0,null, 1, {}, {}, 'a', 'a', NaN];
const result=arr.uniq();
console.log(result);// [true, false, undefined, null, NaN, 0, 1, {…}, {…}, "a"]

es6的第三种方法，利用new Map()和filter()方法实现去重，缺点是无法去掉重复的{}，Map对象的详细解释看https://www.sohu.com/a/258843230_464962

二、利用for嵌套for，然后splice去重

Array.prototype.uniq = function () {
    for(var i=0;i<this.length;i++){
        for(var j=i+1;j<this.length;j++){
            if(this[i]===this[j]){
                this.splice(j,1);
                j--
            }
        }
    }
    return this
};
var arr=[true,false,true,undefined, null,NaN, 0,null, 1, {}, {}, 'a', 'a', NaN];
var result=arr.uniq();
console.log(result);//[true, false, undefined, null, NaN, 0, 1, {…}, {…}, "a", NaN]

解析：双层循环，外层循环元素，内层循环时比较值。值相同时，则删去这个值。但是如上所示，并没有去掉重复的{}和NaN（去不掉NaN的原因是NaN===NaN和{}==={}返回的结果是都是false）

三、利用includes去重

Array.prototype.uniq = function () {
    var array=[];
    for(var i=0;i<this.length;i++){
        if(!array.includes(this[i])){
           array.push(this[i])
        }
     }
     return array
};
var arr =[true,false,true,undefined, null,NaN, 0,null, 1, {}, {}, 'a', 'a', NaN];
var result=arr.uniq();
console.log(result)//[true, false, undefined, null, NaN, 0, 1, {…}, {…}, "a"]

解析：[NaN].includes(NaN)返回true，所以数组中是否存在NaN是可以用indludes来进行判断；但是[{}].includes({})返回的是false,所以数组中是否存在{}不能用includes进行判断

四、利用indexOf去重

Array.prototype.uniq = function () {
    var array=[];
    for(var i=0;i<this.length;i++){
        if((array.indexOf(this[i]))===-1){
            array.push(this[i])
        }
    }
    return array
};
var arr =[true,false,true,undefined, null,NaN, 0,null, 1, {}, {}, 'a', 'a', NaN];
var result=arr.uniq();
console.log(result)// [true, false, undefined, null, NaN, 0, 1, {…}, {…}, "a", NaN]

解析：[NaN].indexOf(NaN)和[{}].indexOf({})返回-1，所以数组中是否存在NaN和{}是不能用indexOf来进行判断的，那么如果用indexOf去重的话，这两者都是无法去掉的

五、利用sort()去重

Array.prototype.uniq = function () {
    var arr=this.sort();
    var newArr=[arr[0]];
    for(var i=1;i<arr.length;i++){
        if(arr[i]!==arr[i-1]){
            newArr.push(arr[i])
        }
    }
    return newArr
};
var arr =[true,false,true,undefined, null,NaN, 0,null, 1, {}, {}, 'a', 'a', NaN];
var result=arr.uniq();
console.log(result);//[0, 1, NaN, NaN, {…}, {…}, "a", false, null, true, undefined]

解析：因为同样是要判断NaN和{}各自与自身相等的判断，所以是无法去重的。

六、利用hasOwnProperty去重

Array.prototype.uniq = function () {
    var obj = {};
    return arr.filter(function(item, index, arr){
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
    })
};
var arr =[true,false,true,undefined, null,NaN, 0,null, 1, {a:1}, {b:3}, 'a', 'a', NaN];
var result=arr.uniq();
console.log(result);//[true, false, undefined, null, NaN, 0, 1, {…}, "a"]

解析：优点是之前不容易去掉的NaN和{}都通过去重去掉了，缺点是不同的{}即使内部内容不同也会被去重去掉。

总结：总结下来无非是两类，第一类是双重循环法，第二类是利用语法自身键不可重复性

注意：本文参考了文章https://segmentfault.com/a/1190000016418021，谢谢原作者分享，如有侵权，立马删除。