数组去重方法总结

时间:2022-11-18 19:01:16

方法一.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]