运用js 实现数组的去重

一、数组的去重

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

二、数组的去重实现

1. 遍历数组的方法

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));

2. 数组下标判断法

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));

3. 排序后相邻去重法

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));

4. 优化遍历数组法

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));

5. 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));

6. 利用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));

7. 利用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));

8. 利用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));