JS数组对象去重及求差值

前言

之前文章有对数组去重及求差值做总结，可以参考文章js数组并集，交集，差集的计算方式汇总，去重的方式面试中经常提到，可以参考。 数组是这么操作，有小伙伴问数组对象应该如何操作呢？ 显然，数组对象和数组的操作方式还是有点区别的。这篇文章简单总结一下。

去重

之前纯数组去重的方式，对数组对象来说，显然不是很合适。提供2中思路

1、利用临时对象存储key的方式

这种方式之前我是经常这么用，包括处理数据的时候。

方式如下：

  let result = [];
    let obj = {};
    for(let i =0; i<arr.length; i++){
       if(!obj[arr[i].key]){
          result.push(arr[i]);
          obj[arr[i].key] = true;
       }
    }

result就是去重之后的结果。

当然，你也可以封装成函数

function removeArrayRepaetObj(arr){
      let result = [];
        let obj = {};
        for(let i =0; i<arr.length; i++){
           if(!obj[arr[i].key]){
              result.push(arr[i]);
              obj[arr[i].key] = true;
           }
        }
    return result
}

2、利用数组reduce方法

function removeArrayRepaetObj(arr){
  let obj = {};
  arr = arr.reduce(function(item, next) {
  obj[next.key] ? '' : obj[next.key] = true && item.push(next);
  return item;
 }, []);
 return arr
}

数组对象求差值

数组对象求差值的方法有很对，基于原来文章数组求差值，我们可以用JSON. stringify的方式，当时这种方式是有弊端的。方法如下：

1、JSON.stringify对象的方式

 function diffrence(a,b){
      a = a.map(JSON.stringify);
      b = b.map(JSON.stringify);
      return a.concat(b).filter(v => !a.includes(v) || !b.includes(v)).map(JSON.parse)
  }
  diffrence(arr1,arr2);

2、reduce的方式

function getDifference(arr1,arr2,typeName){
                return Object.values(arr1.concat(arr2).reduce((acc,cur) => {
                    if (acc[cur[typeName]] && acc[cur[typeName]][typeName] === cur[typeName]) {
                        delete acc[cur[typeName]];
                    }else{
                        acc[cur[typeName]] = cur;
                    }
                    return acc ;
                },{}));
            }

注意：typeName是对象中的唯一值。

方法三，采用辅助判断方法

function getDiffCollection(arr1, arr2) {
    if(!Array.isArray(arr1) || !Array.isArray(arr2)) return null;

    const longArr = arr1.length > arr2.length ? arr1 : arr2;

    const diffCollect = longArr.reduce((acc, cv, index, arr) => {
        if(!arr1[index] || !arr2[index]) acc.push(cv)
        if(arr1[index] && arr2[index] && !equalObject(arr1[index], arr2[index])) acc.push(cv)
        return acc

    }, [])
    return diffCollect;
}

function equalObject(o1, o2) {
    for(const attr in o1) {
        if(o1.hasOwnProperty(attr)) {

            if(o1[attr] !== o2[attr]) return false
        }
    }
    return true
}

这个方法比较麻烦。

小结

暂时总结这么多，交集和并集比较好操作，暂时就不总结了。