Question

首先，感谢您阅读我的问题，并尝试帮助我并为我的英语道歉。

我的问题是我想实现一个不错的解决方案，在数组内使用更少的数组。

我有n个带有n个对象的数组，每个对象都有两个属性：name和type。我想知道如何重复获取所有数组中的对象。

这是我的代码：

let arraysNoEmpties = [...res].filter(array => array.length > 0);
let attributes = arraysNoEmpties[0].map(p => {
   return { name: p.name, type: p.type };
});

let items = getAtributeInAllArrays(attributes, arraysNoEmpties);
console.log('items: ', items);


const getAtributeInAllArrays = (properties, list) => {
    let items = [];
    for (let i = 0; i < properties.length; i++) {
        const property = properties[i];
        let numTimes = 0;
        for (let j = 0; j< list.length; j++) {
            const array = list[j];
            let propsOfarray = array.map(atr => atr.name);
            if (propsOfarray.indexOf(property.name) !== -1) {
                numTimes++;
                if (numTimes === list.length) {
                    items.push(property);
                }
            }
        }
    }
    items.sort((a,b) => (a.name > b.name) ? 1 : ((b.name > a.name) ? -1 : 0));
    return items;
};

Answer 1

您要过滤在提供的每个数组中找不到的每个对象。我们可以利用一些和所有功能来实现这一点：

let arrays = [[{name:"1"}, {name:"2"}], [{name:"1"}]]
let objects = [{name:"1"}, {name:"2"}] // only the first object is found in each array
const objectsInEachArray = objects.filter(o => arrays.every(arr => arr.some(r => r.name == o.name && r.type == o.type)))

让我们刹车一下：

要检查数组中是否包含对象，我们可以使用array.some（）函数。在这里，我们返回一个布尔值以声明是否匹配。在这种情况下，我想您想检查每个属性。在这里，您可以进行完全相等性检查（深层或浅层），或者在这种简单情况下，只需显式检查每个属性即可：
```
arr.some(r => r.name == o.name && r.type == o.type)
```
由于我们有多个数组，并且要求在每个对象中至少找到一次该对象，因此必须在2维数组上调用every方法：
```
arrays.every(arr => arr.some(r => r.name == o.name && r.type == o.type))))
```
由于我们有多个对象，并且希望结果是一个只有匹配对象的数组，因此我们在对象数组上调用filter。
```
objects.filter(o => arrays.every(arr => arr.some(r => r.name == o.name && r.type == o.type)))))
```
objectsInEachArray现在仅包含在arrays

因此：

console.log(objectsInEachArray) -> [{name: "1"}]

Answer 2

如果数组的长度相似或全部很小（<〜20个元素），则可以使用类似的方法。修改predicate函数以指定两个对象匹配的条件。例如，如果您添加另一个元素或决定name是唯一的，即使没有type。

function commonElements(arrays...) {
  const predicate = (obj1, obj2) => {
    return obj1.name == obj2.name && obj1.type == obj2.type;
  };

  return arrays[0].filter(e1 => !arrays.map(array => array.map(e2 => predicate(e1, e2)).includes(true)).includes(false));
}

如果您的数组可能更长一些，请首先选择最短的数组作为过滤器的基础：

function commonElements(arrays...) {
  const predicate = (obj1, obj2) => {
    return obj1.name == obj2.name && obj1.type == obj2.type;
  };

  const lengths = arrays.map(arr => arr.length);
  const shortestArray = arrays[lengths.indexOf(lengths.sort((a, b) => a - b)[0])];

  return shortestArray.filter(e1 => !arrays.map(array => array.map(e2 => predicate(e1, e2)).includes(true)).includes(false));
}

两个示例的最后一行基本相同，并且形式稍长一些：

shortestArray.filter(e1 => {
  return !arrays.map(array => {
    return array.map(e2 => {
      return predicate(e1, e2);
    }).includes(true);
  }).includes(false);
});

对于过滤器数组的每个元素，使用predicate函数将其与其他数组中的每个元素进行比较。如果至少一个元素匹配（.includes(true)），则该数组将映射到true。如果每个数组都映射到true（! (...) .includes(false)），则该元素将被.filter(...)接受。

如何检查对象是否存在于多个数组中

2 个答案: