数组去重方法总结

方法一.for循环（两次嵌套）

　　两层循环，外层用于循环数组，内层用于循环result数组中的值，将result数组中的值和数组中的值判断是否相等。

Array.prototype.distinct = function (){
    var arr = this;
    var flag = 0;
    var result = new Array();
    for(var i = 0; i < arr.length; i++) {
        flag = 0;
        for(var j = 0; j < result.length; j++) {
            if(result[j] == arr[i]) {
                flag = 1;break;
            }
        }
        if(flag == 0)
            result.push(arr[i]);
    }
    return result;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
console.log(a.distinct());//结果为[1, 2, 3, 4, 5, 6, 56]

方法二.利用splice直接在原数组进行操作

　　两层循环，外层循环元素，内层循环时比较值。

　　值相同时，则删去这个值。

　　注意点:删除元素之后，需要将数组的长度也减1。

Array.prototype.distinct = function (){
    var arr = this,
        len = arr.length;
    for(var i = 0; i < len; i++){
        for(var j = i + 1; j < len; j++){
            if(arr[i] == arr[j]){
                arr.splice(j,1);
                len--;
                j--;
            }
        }
    }
    return arr;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b);//结果为 [1, 2, 3, 4, 5, 6, 56]

方法三.利用对象的属性不能相同的特点进行去重

　  obj是一个对象，obj[arr[0]]一开始为false，满足if的条件，给obj[arr[0]]赋值为1，并且push到result中，然后继续下一个数。

　　如果遇到重复的数字，obj[arr[i]]为1，不满足if的条件，不能push到result中。

 Array.prototype.distinct = function (){
     var arr = this,
           obj = {},
          result = [];
     for(var i = 0; i< arr.length; i++){
          if(!obj[arr[i]]){
          obj[arr[i]] = 1;
          result.push(arr[i]);
                 }
            }
            return result;
        };
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
console.log(a.distinct());//结果为[1, 2, 3, 4, 5, 6, 56]

方法四.数组递归去重

　　先对数组进行排序，然后从最后开始比较，遇到相同的数，则删除。

Array.prototype.distinct = function (){
      var arr = this;
      //对数组进行排序才能方便比较
      arr.sort(function (a,b) {
           return a-b;
       })
      function loop (index) {
           if(index >=1){
                 if(arr[index] ===arr[index-1]){
                     arr.splice(index,1);
                 }
                 loop(index-1);//递归调用loop方法
             }
       }
      loop(arr.length-1);
      return arr;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,56,45,56];
console.log(a.distinct());//结果为[1, 2, 3, 4, 5, 6, 45, 56]

方法五.利用indexOf以及forEach

　　indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。如果要检索的字符串值没有出现，则该方法返回 -1。

　　代码用于检测数组中的值在result中有没有出现，如果没有出现，push到result中。

Array.prototype.distinct = function (){
    var arr = this,
        result = [];
    for(let i = 0; i<arr.length; i++){
        if(result.indexOf(arr[i]) === -1){
            result.push(arr[i]);
        }
    }
    return result;
};
var a = [1,1,1,1,1,2,2,2,2,3,3,3,2,2,2,1,23,1,23];
console.log(a.distinct());//结果为[1, 2, 3, 23]

　　 也可以用forEach() 进行循环。

　　forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。

Array.prototype.distinct = function () {
    var arr = this,
        result = [];
    arr.forEach((item,index,array)=>{
        if(result.indexOf(item) === -1){
            result.push(item);
        }
    })
    return result;
}
var a = [1,1,1,1,1,2,2,2,2,3,3,3,2,2,2,1,23,1,23];
console.log(a.distinct());//结果为[1, 2, 3, 23]

方法六.利用filter以及 indexOf

　　filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

　　indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。如果要检索的字符串值没有出现，则该方法返回 -1。

Array.prototype.distinct = function (){
    var arr = this;
    return arr.filter((item, index, array) =>  array.indexOf(item) === index);

};
var a = [1,1,1,2,2,2,3,3,3,3,3,2,3,2,2,1,23,1,23,2,3,2,3];
var b = a.distinct();
console.log(b);//结果为[1, 2, 3, 23]

方法七.利用ES6的set

　　set数据结构，它类似于数组，但是其成员的值都是唯一的。

　　利用Array.from将Set结构转换成数组。

function distinct(array){
    return Array.from(new Set(array));
}
var a = distinct([1,1,2,3,1,2,3,2,1,4,1,4,5,1]);
console.log(a);//结果为[1, 2, 3, 4, 5]

　　扩展运算符（ . . . ）内部调用的是数据结构的 Iterator 接口.

　　因此只要具有 Iterator 接口的对象，都可以使用扩展运算符，比如 Map 和 Set 结构。

 var a = [1,1,2,3,1,2,3,2,1,4,1,4,5,1];
 var b = [...new Set(a)];
 console.log(b);//结果为[1, 2, 3, 4, 5]