查找嵌套对象中的相似性

Question

假设我有：

const a = {
  'prkn': {
    tec: [ 'Coding', 'Machine Learning', 'Cloud Development' ],
    des: [ 'Web Design' ]
  },
  'pekn': { cu: [ 'Musica', 'Cinema', 'Arte' ] }
}

const b = {
  'prkn': {
    tec: [
      'Coding',
      'Machine Learning',
      'Cloud Development',
      'IoT Management'
    ],
    des: [ 'UX/UI', 'Web Design', 'Prototyping', 'Design Thinking' ]
  },
  'pekn': { cu: [ 'Cinema', 'Lettura' ] }
}

我想要这些物体的交集：

{
  'prkn': {
    tec: [ 'Coding', 'Machine Learning', 'Cloud Development' ],
    des: [ 'Web Design' ]
  },
  'pekn': { cu: [ 'Cinema' ] }
}

下面是代码，但它不起作用..：

​

const a = {
  'prkn': {
    tec: [ 'Coding', 'Machine Learning', 'Cloud Development' ],
    des: [ 'Web Design' ]
  },
  'pekn': { cu: [ 'Musica', 'Cinema', 'Arte' ] }
}

const b = {
  'prkn': {
    tec: [
      'Coding',
      'Machine Learning',
      'Cloud Development',
      'IoT Management'
    ],
    des: [ 'UX/UI', 'Web Design', 'Prototyping', 'Design Thinking' ]
  },
  'pekn': { cu: [ 'Cinema', 'Lettura' ] }
}

function findSimilarities(obj1, obj2) {
  const bo1 = Object.entries(obj1).reduce((acc1, [l1, v1]) => {
    const bo2 = Object.entries(v1).reduce((acc2, [l2, v2]) => {
      const sim = v2.filter(s => obj2[l1][l2].includes(s))
      acc2[l2] = sim
      return acc2
    })
    acc1[l1] = bo2
    return acc1
  }, {})
 return bo1
}

console.log(findSimilarities(a, b))

​

Answer 1

这里有一个非常简单的示例，适用于您的给定数据。

它首先将传递的对象的Object.keys()相交，并根据typeof (它们与之关联的属性)对它们进行过滤，这样我们就不会浪费时间比较那些不是共享的或类型不匹配的键。然后它迭代这些键，如果它们引用了对象(但不是数组)，它就会递归，否则如果两个数组都与它们相交(这里使用includes()，所以嵌套的对象不起作用)，最后检查基本的相等性。设置acc[key]并返回。

​

const
  a = { 'prkn': { red: 1, bl: null, tec: ['Coding', 'Machine Learning', 'Cloud Development'], des: ['Web Design'] }, 'pekn': { cu: ['Musica', 'Cinema', 'Arte'] } },
  b = { 'prkn': { red: 1, bl: 'Dog', tec: ['Coding', 'Machine Learning', 'Cloud Development', 'IoT Management'], des: ['UX/UI', 'Web Design', 'Prototyping', 'Design Thinking'] }, 'pekn': { cu: ['Cinema', 'Lettura'] } },

  intersectPrimitiveArrays = (a, b) => a.filter(e => b.includes(e)),

  intersectObjects = (a, b) => {
    const keys = intersectPrimitiveArrays(Object.keys(a), Object.keys(b))
      .filter(k => (typeof a[k]) === (typeof b[k]));

    return keys.reduce((acc, key) => {
      const
        _a = a[key],
        _b = b[key];

      let element = _a;

      if (typeof _a === 'object' && (_a !== null || _b !== null) && (!Array.isArray(_a) && !Array.isArray(_b))) {
        element = intersectObjects(_a, _b);
      } else if (Array.isArray(_a) && Array.isArray(_b)) {
        element = intersectPrimitiveArrays(_a, _b);
      } else if (_a !== _b) {
        element = undefined;
      }

      if (element !== undefined) {
        acc[key] = element;
      }

      return acc;
    }, {})
  }

console.log(intersectObjects(a, b));

.as-console-wrapper { max-height: 100% !important; top: 0; }

​