数组去重_原生js对普通数组去重算法的7种方法总结

第一种算法：

算法思想：

1、构建一个新数组，新数组包含一个元素，元素值为目标数组的一个值；

2、从目标数组的第二个元素开始遍历，依次取出每一个元素；

3、将取出的元素与新数组里面的所有元素进行比较，如果没有出现，则将该元素添加到新数组中，如果出现，则处理下一个目标数组的元素；

4、目标数组的所有元素均已处理完。

Array.prototype.deleteRepeat1=function (){
        //构建一个新数组，存放结果,首先给newArray一个初值，初值为调用该函数的数组的第一个值即this[0]
        var newArray=[this[0]];
        //for循环，每次从原数组中取出一个元素
        //用取出的元素循环与结果数组比较
        for(var i=1;i<this.length;i++){
            // 添加一个标记，用于标记当前元素是否在newArray中出现过
            var repeat=false;
            for(var j=0,len=newArray.length;j<len;j++){
                //原数组取出的元素与结果数组元素相同
                if(this[i] == newArray[j]){
                    repeat=true;
                    break;
                }
            }
            //如果原数组中没有该元素，则存放到结果数组中
            if(!repeat){
                newArray.push(this[i]);
            }
        }
        return newArray;
    }
    var array=[1,1,2,2,2,3,3,4,5,6,6,6,6];
    array.deleteRepeat();//1,2,3,4,5,6

对上面算法的改进：

利用forEach，indexOf方法替代上述的循环和检测：

Array.prototype.deleteRepeat1=function (){
        var newArray=[];
        // index是目标数组中的每一个元素
        this.forEach(function(index){
            // indexOf方法返回index在newArray中出现的位置，如果没有出现则返回-1
            if(newArray.indexOf(index) == -1){
                newArray.push(index);
            }
        });
        return newArray;
    }

但是在IE9+以下并不支持forEach函数；可以重写forEach 函数实现兼容。

第二种算法：

算法思想：

1、对目标数组进行排序；

2、遍历目标数组，检测数组中的第 i 个元素与结果数组中最后一个元素是否相同，如果不同，则将该元素添加到结果数组中；

Array.prototype.deleteRepeat2=function (){
        // 首先对目标数组进行排序
        this.sort();
        var newArray=[];
        // index是目标数组中的每一个元素
        for(var i=0,len=this.length;i<len;i++){
            // 将this[i]与newArray中的最后一个元素比较，因为已经排过序，相同的元素肯定在相同的位置了
            if(this[i] !== newArray[newArray.length-1]){
                newArray.push(this[i]);
            }
        }
        return newArray;
    }

这种算法的优缺点：

去重后的数组是排过序的，而且无法区分与数字相同的数字字符比如： “1” 和 1；

第三种算法：

算法思想：

1、创建一个新数组和新对象；

2、遍历目标数组中的每一个元素，将该元素与对象进行比对，如果不重复则添加到结果数组中，同时将该元素的值作为对象的属性，并将该属性值设为1；

Array.prototype.deleteRepeat2=function (){
        var newArray =[];
        // 创建一个空对象
        var object = {};
        // 每次取出一个元素，与对象进行比对，如果这个元素不重复，则添加到结果数组中，同时把这个元素的内存作为对象的一个属性并存入对象中
        for(var i=0,len=this.length;i<len;i++){
            if(!object[typeof(this[i]) + this[i]]){
                newArray.push(this[i]);
                object[typeof(this[i]) + this[i]]=1;
            }
        }
        return newArray;
    }

这种算法的效果最好，速度最快。但是占用内存大。

对这个算法的理解：

这里的对象也可以换成一个数组，每次将不重复的元素作为数组的索引，然后将该索引值设为1，下次再出现时如果array[element]==1;说明此element已经出现过，是重复的。

第四种算法：

算法思想：

1、创建一个新数组保存结果；

2、对目标数组进行排序，将目标数组中的第一个元素存入结果数组中；

3、处理目标数组的第二个元素，如果这个元素和它前面的元素不同，说明是不重复，则添加到结果数组中。

Array.prototype.deleteRepeat3=function (){
        var newArray =[this[0]];
        this.sort();
        for(var i=1;i<this.length;i++){
            比较当前元素和前一个元素是否相同，如果重复，排序后，相同的会在一起。
            if(this[i] !== this[i-1]){
                newArray.push(this[i]);
            }
        }
        return newArray;

第五种算法：

算法思想：

1、利用数组的reduce方法，对数组中的每一个元素进行处理

Array.prototype.deleteRepeat3=function (){
        // 通过数组的reduce方法，对数组中的每一个元素进行处理，原理都一样，只是使用了不同的方法
        return this.reduce(function(newArray,index){
            if(newArray.indexOf(index)<0){
                newArray.push(index);
            }
            return newArray;
        },[]);
    }

第六种算法：

算法思想：

1、和上面相同，不过是使用了filter方法

Array.prototype.deleteRepeat3=function (){
        var newArray=[];
        newArray=this.filter(function(ele,i,arr) {
            return arr.indexOf(ele) === i;
        });
        return newArray;
    }

第七种算法：

这种是利用ES6去重，相对来说更为简单

//es6
    function deleteRepeat(arr){
        const seen=new Map(){
            return arr.filter((a)=>!seen.has(a)&&seen.set(a,1));
        }
    }
    //or
    function deleteRepeat2(arr){
        return Array.form(new Set(arr))
    }

数组去重_原生js对普通数组去重算法的7种方法总结

Array数组相关方法

js数组的迭代

es6之Array.of()和Array.from()

JS取出两个数组中的不同或相同元素

js中的Array

JS中forEach的用法

js 数组方法，包含ES6方法

js判断数组是否包含某个元素

js判断对象、数组是否为空

for in 和 for of的区别详解