数组去重的方法总结

一、利用ES6方法去重

1.

var a=[1,2,3,1,3,1,45,2,1];
console.log([...new Set(a)]);//[1，2，3，45]

2.

Array.prototype.uniq = function () {
　　return Array.from(new Set(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"]

解析：两个方法其实大致原理是一致的，都是利用es6中的Set方法去重，然后重新转化成数组来实现的。相比于es5的代码实现，这两种方法确实简单。但是需要考虑兼容性，而且这种方法无法去掉“{}”空对象

二、利用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，谢谢原作者总结，如有侵权，立马删除。