从 Javascript 中的多个对象数组中返回相似的值

Question

伙计们，我做了一个简单的例子来说明我的问题。我有 3 个对象数组，datasOne、datasTwo 和 datasThree，我想要的是只返回一个包含 3 个数组中的对象的新数组。例如，如果 3 个数组中只有 Gustavo，则返回他。但是有一个细节是，如果datasThree 是一个空数组，那么它只会带来来自datasOne 和datasTwo 的共同数据，并且如果只有datasTwo 有数据并且其他两个数组有空, 那么它将只返回来自datasTwo 的数据。换句话说，它只从有数据的数组中返回相似的数据。我设法做到了这个算法，它按照我想要的方式工作，但我想知道另一种方法来使它不那么冗长，也许更简单，并且在我添加更多数组进行比较的情况下也可以工作，例如dataFour。我感谢任何可以帮助我的人。

我的代码如下：

let datasOne = [
  { id: 1, name: 'Gustavo' },
  { id: 2, name: 'Ana' },
  { id: 3, name: 'Luiz' },
  { id: 8, name: 'Alice' }
]

let datasTwo = [
  { id: 1, name: 'Gustavo' },
  { id: 3, name: 'Luiz' },
  { id: 8, name: 'Alice' }
]

let datasThree = [
  { id: 1, name: 'Gustavo' },
  { id: 3, name: 'Luiz' },
  { id: 2, name: 'Ana' },
  { id: 5, name: 'Kelly' },
  { id: 4, name: 'David' }
]

let filtered

if (datasOne.length > 0 && datasTwo.length > 0 && datasThree.length > 0) {
  filtered = datasOne.filter(firstData => {
    let f1 = datasThree.filter(
      secondData => firstData.id === secondData.id
    ).length
    let f2 = datasTwo.filter(
      secondData => firstData.id === secondData.id
    ).length
    if (f1 && f2) {
      return true
    }
  })
} else if (datasOne.length > 0 && datasTwo.length > 0) {
  filtered = datasOne.filter(firstData => {
    return datasTwo.filter(secondData => firstData.id === secondData.id).length
  })
} else if (datasOne.length > 0 && datasThree.length > 0) {
  filtered = datasOne.filter(firstData => {
    return datasThree.filter(secondData => firstData.id === secondData.id)
      .length
  })
} else if (datasTwo.length > 0 && datasThree.length > 0) {
  filtered = datasTwo.filter(firstData => {
    return datasThree.filter(secondData => firstData.id === secondData.id)
      .length
  })
} else if (datasThree.length > 0) {
  filtered = datasThree
} else if (datasTwo.length > 0) {
  filtered = datasTwo
} else if (datasOne.length) {
  filtered = datasOne
}

console.log(filtered)

Answer 1

1)你可以先filterarrs中不为空的数组。

const arrs = [datasOne, datasTwo, datasThree].filter((a) => a.length);

2) 使用flat() 展平arrs 数组。

arrs.flat()

3) 循环扁平化数组并使用Map统计所有对象的出现次数

const map = new Map();
for (let o of arrs.flat()) {
  map.has(o.id)
    ? (map.get(o.id).count += 1)
    : map.set(o.id, { ...o, count: 1 });
}

4) 循环map 并仅在等于arrs.length 时收集结果

if (count === arrs.length) result.push(rest);

---

let datasOne = [
  { id: 1, name: "Gustavo" },
  { id: 2, name: "Ana" },
  { id: 3, name: "Luiz" },
  { id: 8, name: "Alice" },
];

let datasTwo = [
  { id: 1, name: "Gustavo" },
  { id: 3, name: "Luiz" },
  { id: 8, name: "Alice" },
];

let datasThree = [
  { id: 1, name: "Gustavo" },
  { id: 3, name: "Luiz" },
  { id: 2, name: "Ana" },
  { id: 5, name: "Kelly" },
  { id: 4, name: "David" },
];

const arrs = [datasOne, datasTwo, datasThree].filter((a) => a.length);

const map = new Map();
for (let o of arrs.flat()) {
  map.has(o.id)
    ? (map.get(o.id).count += 1)
    : map.set(o.id, { ...o, count: 1 });
}

const result = [];
for (let [, obj] of map) {
  const { count, ...rest } = obj;
  if (count === arrs.length) result.push(rest);
}

console.log(result);

/* This is not a part of answer. It is just to give the output fill height. So IGNORE IT */
.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

不是 100% 确定它涵盖了所有边缘情况，但这可能会让您走上正确的道路：

function filterArrays(...args) {
  const arraysWithData = args.filter((array) => array.length > 0);
  const [firstArray, ...otherArrays] = arraysWithData;

  return firstArray.filter((item) => {
    for (const array of otherArrays) {
      if (!array.some((itemTwo) => itemTwo.id === item.id)) {
        return false;
      }
    }
    return true;
  });
}

用法：

const filtered = filterArrays(datasOne, datasTwo, datasThree);
console.log(filtered)

我相信代码相当可读，但如果有不清楚的地方，我很乐意澄清。

Answer 3

function merge(arr){
  arr = arr.filter(item=>item.length>0)
  const map = {};
  arr.forEach(item=>{
    item.forEach(obj=>{
      if(!map[obj.id]){
        map[obj.id]=[0,obj];
      }
      map[obj.id][0]++;
    })
  })
  const len = arr.length;
  const ret = [];
  Object.keys(map).forEach(item=>{
    if(map[item][0]===len){
      ret.push(map[item][1])
    }
  })
  return ret;
}
merge([datasOne,datasTwo,datasThree])