JS数组对象去重及求差值

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}

这个方法比较麻烦。

小结

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