前端去重大全

一，单个数组去重

方法一：

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

如果有相同的值则跳过，不相同则push进数组

Array.prototype.distinct = function(){

 var arr = this,

  result = [],

  i,

  j,

  len = arr.length;

 for(i = 0; i < len; i++){

  for(j = i + 1; j < len; j++){

   if(arr[i] === arr[j]){

    j = ++i;

   }

  }

  result.push(arr[i]);

 }

 return result;

}

var arra = [1,2,3,4,4,1,1,2,1,1,1];

arra.distinct();    //返回[3,4,2,1]

 

方法二：

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

值相同时，则删去这个值

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

Array.prototype.distinct = function (){

 var arr = this,

  i,

  j,

  len = arr.length;

 for(i = 0; i < len; i++){

  for(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.toString()); //1,2,3,4,5,6,56

 

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

Array.prototype.distinct = function (){

 var arr = this,

  i,

  obj = {},

  result = [],

  len = arr.length;

 for(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,];

var b = a.distinct();

console.log(b.toString()); //1,2,3,4,5,6,56

 

方法四：数组递归去重

运用递归的思想

先排序，然后从最后开始比较，遇到相同，则删除

Array.prototype.distinct = function (){

 var arr = this,

  len = arr.length;

 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(len-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];

var b = a.distinct();

console.log(b.toString());  //1,2,3,4,5,6,45,56

 

方法五：数组递归去重

 

Array.prototype.distinct = function (){

 var arr = this,

  result = [],

  len = arr.length;

 arr.forEach(function(v, i ,arr){  //这里利用map，filter方法也可以实现

  var bool = arr.indexOf(v,i+1);  //从传入参数的下一个索引值开始寻找是否存在重复

  if(bool === -1){

   result.push(v);

  }

 })

 return result;

};

var a = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,3,2,3,3,2,2,1,23,1,23,2,3,2,3,2,3];

var b = a.distinct();

console.log(b.toString()); //1,23,2,3

 

方法六：利用ES6的set

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

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

function dedupe(array){

 return Array.from(new Set(array));

}

dedupe([1,1,2,3]) //[1,2,3]

 

拓展运算符(...)内部使用for...of循环

let arr = [1,2,3,3];

let resultarr = [...new Set(arr)];

console.log(resultarr); //[1,2,3]

 

二，多个数组去重

方法一：concat()方法

思路：concat() 方法将传入的数组或非数组值与原数组合并,组成一个新的数组并返回。该方法会产生一个新的数组。

function concatArr(arr1, arr2){

  var arr = arr1.concat(arr2);

  arr = unique1(arr);//再引用上面的任意一个去重方法

  return arr;

}

 

方法二：Array.prototype.push.apply()

var a = [1, 2, 3];

var b = [4, 5, 6];

Array.prototype.push.apply(a, b);//a=[1,2,3,4,5,6]

//等效于:a.push.apply(a, b);

//也等效于[].push.apply(a, b);

function concatArray(arr1,arr2){

  Array.prototype.push.apply(arr1, arr2);

  arr1 = unique1(arr1);

  return arr1;

}

 

三，数组对象去重

单个数组

情况一：根据数组对象的某个属性去重（单个数组）

1.采用对象访问属性的方法，判断属性值是否存在

  let newArr = [];

  let obj = {};

  for (var i = 0; i < arr.length; i++) {

    if (!obj[arr[i].key]) {

      newArr.push(arr[i]);

      obj[arr[i].key] = true;

    }

  }

  console.log(newArr);

 

2.采用数组中的reduce方法，遍历数组，其实也是通过对象访问属性

let obj = {}; arr = arr.reduce((item, next) => { if (!obj[next.key]) { item.push(next); obj[next.key] = true; } return item; }, []); console.log(arr);

 

3.find方法

let newArr = []

for (let index = 0; index < arra.length; index++) {

     let state = newArr.find(f=>f == arra[index] ); 

     if(state){

         continue

     }

     newArr.push(arra[index])

}

console.log(newArr)

 

情况二：数组对象里面是否有相同的对象

function process(arr) {

    // 缓存用于记录

    const cache = [];

    for (const t of arr) {

      // 检查缓存中是否已经存在(此处只有比较key值相同和value相同的情况)

      let state = cache.find(c => c.key === t.key && c.value === t.value)

      if (state) {

        // 已经存在说明以前记录过，现在这个就是多余的，直接忽略

        continue;

      }

      // 不存在就说明以前没遇到过，把它记录下来

      cache.push(t);

    }

    // 记录结果就是过滤后的结果

    return cache;

  }

console.log(process(arr));

 

情况三：两个数组去重合并

let a = [

    { a: 1, b: 'haha' },

    { a: 2, b: '222' },

    { a: 3, b: '333' },

    { a: 5, b: '555' },

  ]

  let b = [

    { a: 1, b: 'b1111' },

    { a: 2, b: 'b2222' },

    { a: 3, b: 'aaa333' },

    { a: 4, b: 'aaa444' },

  ]

首先根据a属性去重，另要求当a属性相同时，将b数组的b属性赋值给a数组b属性

  let tmpArr = [...b,...a];

  let finallyArr = [];

  for(let i =0;i<tmpArr.length;i++){

    let curItem = tmpArr[i];

    let exsistItem = tmpArr.find(f=>f.a==curItem.a);

    let hasAddItem = finallyArr.find(f=>f.a==exsistItem.a);

    // 过滤已经添加的项

    if(hasAddItem) continue;

 

    if(exsistItem){

      finallyArr.push(exsistItem);

      continue;

    }

    finallyArr.push(curItem);

  }

  console.log(finallyArr)