JS中数组去重并统计个数

总结了几个简单的数组去重，和统计重复数据的方法

数组去重

最基础的（但不高效 不推荐使用 ）

用两个for循环进行比较，如果数组中存在相同的属性，那么删掉后出现的重复属性，因为在JS中如果用delete删除的仅仅是属性值，并没有将这个属性全部删除，其标签还在，其值变为empty（undefine），故需要再加入一个判断。

   var arr = [2,4,1,2,4,5,9,9,5,9,5];
         var ary=[];
            for(let i=0;i<arr.length;i++){         
             for(let b=i+1;b<arr.length;b++){
                 if(arr[i]==arr[b]){
                    delete arr[b]
                 }           
             }
             if(arr[i]!=undefined){
                 ary.push(arr[i])      
             }   
           }
           console.log(ary)

用indexOf方法实现（进阶）

indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。在JS中用arr.indexOf(a),其作用为，进行判断a是否是数组arr中的属性，如果不是返回-1，如果是就返回该属性的位置（该属性的key）
整个例子

 var arr = ["a","b","c","a","d","c","e","d","c","a","c"];
        var ary=[];
        for(let i=0;i<arr.length;i++){
              var d=arr[i] 
              if(ary.indexOf(d)==-1){
                  ary.push(arr[i])
              }  
            
        }
        console.log(ary)

Es6中的去重的做法

    var arr=[1,2,3,4,1,2,5,6,7,2,8,3,1,8]
    var newArr=[...new Set(arr)];

给属性添加一个标记（进阶）

这个比较简单，直接上代码。

 var a = [1,1,2,3,4,5,5,6];
       var newArr = [];
       var o = {};  // { 1:true, 2:true}
       for (let i = 0; i < a.length; i++) {
           var t = a[i];
           if(o[t]){  // 标记是否处理过
   
           }else{
               newArr.push(a[i]);
               o[t] = true;
           }
       }

3

统计属性重复个数

两个for循环（最基础，执行速度慢，不推荐使用）

先用sort（）方法将数组中的数进行排序，然后用for循环去重并统计。代码如下

          var arr = [2,4,1,2,4,5,9]; 
           var ary=[];  
           arr.sort(); //排个序
           for (var i = 0; i < arr.length;) {  
                var count = 0;  
           for (var b = i; b < arr.length; b++) {  
                   if (arr[i] == arr[b]) {  
                        count++;  
            }  
           }   
                ary.push([arr[i], count]); 
                     i += count;  
       }  
           var are = [];  
           for (var i = 0; i < ary.length; i++) {  
               are.push(ary[i][0] + ":" + ary[i][1]);  
       }  

用foreach方法（进阶）

代码看着简单但实际上在执行时并没有那么的高效，比两个for循环强一点，上代码

var arr = ["a","b","c","a","d","c","e","d","c","a","c"];
function f(arr){
		var ary={}
              arr.forEach(function(v,k){
                  if(ary[v]){
                      ary[v]++;
                  }else{
                      ary[v]=1;
                  }
              })    
              return ary;
          }

结果如下

用in方法（高效，简单，推荐使用

JS中的in方法，a in ary：判断a是否存在数组（或者对象）中，需要注意的是这里的a为键而不是属性的值 不多bb直接上代码

      var arr = ["a","b","c","a","d","c","e","d","c","a","c"];
       var ary={};
       for(let i=0;i<arr.length;i++){
             if(arr[i] in ary){
               ary[arr[i]]=ary[arr[i]]+1; 
             }else{          
                 ary[arr[i]]=1;
             }          
       }

结果如下

用hasOwnProperty方法

JS中的hasOwnProperty方法，用法 obj.hasOwnProperty(t):判断t是否在obj中，这里的t为键，而不是属性值代码如下

  var a = [1,1,2,3,4,5,5,6];
       function f(a) {
           var obj = {};
           for (let i = 0; i < a.length; i++) {
               var t = a[i];
               if (obj.hasOwnProperty(t)){
                   obj[t] = obj[t]+1;
               }else{
                   obj[t] = 1;
               }
           }
           return obj;
       }

扩展数组的一个功能

可以将数组去重并统计的方法写到数组的原型对象上，然后调用这个方法

Array.prototype.count=function(){
    var obj={},
        i=0,
        t,
        len =this.length;
        for(i=0;i<len;i++){
            t=this[i];
            obj[t]= obj[t] === undefined ? 1 : ( obj[t]+1 );
        }
        return obj;
}
 var arr=["a","b","c","d","b","c"]; 
 console.log(arr.count())

但须要注意的是这个只适用于数组对象，如果创建的是Object对象，那么就不会找到这个方法。因为这个方法是写到了数组（Array）构造器的原型对象上了