运用js 实现数组的去重-蒲公英云

运用js 实现数组的去重

一、数组的去重

数组的去重是将一个数组中重复的元素去除，保证数组中的元素都是唯一的，没有重复的

二、数组的去重实现

遍历数组的方法

1）实现思路：新建一个数组，遍历要去重的数组，当值不在新数组的时候，也就是indeOf 为-1的时候，就加入到新的数组当中
2）实现代码：

var arr1 = [3,6,4,9,4,8,8,5,6,8,9]; 
     function uniquel (arr) { 
        var hash = [];
        for( var i=0; i<arr.length; i++){ 
            if( hash.indexOf(arr[i]) == -1){ 
                hash.push(arr[i]);
            }
        }
        return hash;
     }
     console.log(uniquel(arr1));

数组下标判断法

1）实现思路：如果当前数组的第i项在当前数组中第一次出现的位置不是i, 那么第i项是重复的，
忽略掉，否则存入新的数组当中
2）实现代码：

var arr2 = [3,6,4,9,4,8,8,5,6,8,9]; 
      function unique2 (arr) { 
         var hash = [];
         for( var i=0; i<arr.length; i++){ 
            if( arr.indexOf(arr[i]) == i){ 
               hash.push(arr[i]);
            }
         }
         return hash;
      }
      console.log(unique2(arr2));

排序后相邻去重法

1）实现思路：给传入的数组排序，排序后相同的值会相邻，然后遍历排序后的数组，当不与前一值
重复，那么就加入到新的数组当中
2）实现代码：

var arr3 = [3,6,4,9,4,8,8,5,6,8,9]; 
       function unique3 (arr) { 
          arr.sort();
          var hash = [arr[0]];
          for( var i=0; i<arr.length; i++){ 
            if(arr[i] != hash[hash.length-1]){ 
               hash.push(arr[i]);
            }
          }
          return hash;
       }
       console.log(unique3(arr3));

优化遍历数组法

1）实现思路：新建一个空的数组，遍历需要去重的数组，外层循环表示从0到arr.length，内层循环表示从i+1 到arr.lenth，将没重复的右边值放入到新数组当中，有重复就终止当前循环进入外层循环
2）实现代码：

var arr4 = [3,6,4,9,4,8,8,5,6,8,9];
        function unique4 (arr) { 
           var hash = [];
           for(var i=0; i<arr.length; i++){ 
              for(var j=i+1; j<arr.length; j++){ 
                 if( arr[i] === arr[j]){ 
                    ++i;
                 }
              }
              hash.push(arr[i]);
           }
           return hash;
        }
        console.log(unique4(arr4));

ES6的set方法

1）实现思路：通过ES6的set数据结构，类似于数组，但是成员的值都是唯一的，没有重复的值，
set函数可以接受一个数组或者是类数组的对象作为参数，用来初始化
2）实现代码：

var arr5 = [3,6,4,9,4,8,8,5,6,8,9]; 
        function unique5 (arr) {  
            var hash = new Set(arr);
            return [...hash];
        }
        console.log(unique5(arr5));

利用includes 方法

1）实现思路：新建一个空的数组，遍历数组，通过includes()的方法检测新数组中是否含有这个值，
如果没有，那么就添加到新的数组当中
2）实现代码：

var arr6 = [3,6,4,9,4,8,8,5,6,8,9]; 
         function unique6 (arr){ 
            var hash = [];
            for( var i=0; i<arr.length; i++){ 
               if( !hash.includes( arr[i])){ 
                  hash.push(arr[i]);
               }
            }
            return hash;
         }
         console.log(unique6(arr6));

利用hasOwnProperty 方法

1）实现思路：新建一个空对象，通过hasOwnProperty() 判断是否存在对象的属性
2）实现思路：

var arr7 = [3,6,4,9,4,8,8,5,6,8,9];
         function unique7 (arr) { 
            var obj = { };
            return arr.filter( function(item, index, arr){ 
               return obj.hasOwnProperty( typeof item + item ) ? false : (obj [typeof item + item] = true)
            })
         }
         console.log(unique7(arr7));

利用filter 方法

1）实现思路：通过filter() 的方法找到数组中符合条件的所有元素，在当前元素中，在原始数组中的第一个索引等于当前索引值，否则返回当前元素
2）实现代码：

var arr8 = [3,6,4,9,4,8,8,5,6,8,9];
          function unique8 (arr) { 
             return arr.filter( function(item, index, arr){ 
                 return arr.indexOf(item, 0) == index;
             })
          }
          console.log(unique8(arr8));