数组去重的几种算法

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

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

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

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

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

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

1 Array.prototype.deleteRepeat3=function (){
2         var newArray=[];
3         newArray=this.filter(function(ele,i,arr) {
4             return arr.indexOf(ele) === i;
5         });
6         return newArray;
7     }

 1 //es6
 2     function deleteRepeat(arr){
 3         const seen=new Map(){
 4             return arr.filter((a)=>!seen.has(a)&&seen.set(a,1));
 5         }
 6     }
 7     //or
 8     function deleteRepeat2(arr){
 9         return Array.form(new Set(arr))
10     }