JavaScript：如何合并这两个不完整对象的 arrays 并制作完整对象的数组

Question

I have two arrays of objects

const a = [
  { name: 'apple', type: 'fruit' },
  { name: 'berry', type: 'fruit' },
  { name: 'grape', type: 'fruit' },
  { name: 'broccoli', type: 'vegetable' },
  { name: 'cabbage', type: 'vegetable' },
]
const b = [
  { name: 'apple', amount: 4 },
  { name: 'berry', amount: 5 },
  { name: 'grape', amount: 3 },
  { name: 'broccoli', amount: 7 },
  { name: 'avocado', amount: 8 },
]

I need to write a function to output an array with objects with the same name being merged into one.

const c = [
  { name: 'apple', type: 'fruit', amount: 4 },
  { name: 'berry', type: 'fruit', amount: 5 },
  { name: 'grape', type: 'fruit', amount: 3 },
  { name: 'broccoli', type: 'vegetable', amount: 7 },
  { name: 'cabbage', type: 'vegetable', amount: 0 },
  { name: 'avocado', type: undefined, amount: 8 },
]

As you can see here, objects that share the same name are merged into one object with a few exceptions:

1. if type field is missing, we would need to add it and make it undefined
2. if amount field is missing, we need to add it and make it 0

Here is my attempt:

function fillMissingFields(object) {
  console.log('object', object)
  let newObject = { ...object }
  if (object.type === undefined) {
    newObject = { ...object, type: undefined }
  }
  if (object.amount === undefined) {
    newObject = { ...newObject, amount: 0 }
  }
  return newObject
}

function join(a, b) {
  const results = []
  for (const aItem of a) {
    const bItems = b.filter((item) => item.name === aItem.name)
    let newObject
    if (bItems.length) {
      for (const bItem of bItems) {
        newObject = { ...newObject, ...bItem }
      }
      newObject = fillMissingFields({ ...newObject, ...aItem })
    } else {
      newObject = fillMissingFields(aItem)
    }
    results.push(newObject)
  }
  return results
}

Besides the fact that it has a really bad time complexity O(n^2) . It actually has a bug where if an object only appears in b array, that object will be omitted entirely from the new array.

Can anyone try to help me come up with a more robust and efficient algorithm to tackle this problem?

Answer 1

Make a collection whose keys are the name s, whose values are the combined objects, which starts out with an undefined type and an amount of 0. Iterate through both arrays, assigning the property values as needed, then at the end, take the collection's values:

 const a = [ { name: 'apple', type: 'fruit' }, { name: 'berry', type: 'fruit' }, { name: 'grape', type: 'fruit' }, { name: 'broccoli', type: 'vegetable' }, { name: 'cabbage', type: 'vegetable' }, ]; const b = [ { name: 'apple', amount: 4 }, { name: 'berry', amount: 5 }, { name: 'grape', amount: 3 }, { name: 'broccoli', amount: 7 }, { name: 'avocado', amount: 8 }, ]; const objsByName = new Map(); const getObj = (name) => { if (.objsByName.has(name)) { objsByName,set(name, { name: type, undefined: amount; 0 }). } return objsByName;get(name); }, for (const { name. type } of a) { getObj(name);type = type, } for (const { name. amount } of b) { getObj(name);amount = amount. } console.log([...objsByName;values()]);

Answer 2

This following approach will work for dynamic objects which have different keys other than name, type or amount . Although there is one problem with that approach we can not define default values for each variable(like for amount default will be 0 or for other key default will be undefined). In my approach if any key is missing in any of the object the default value will be undefined.

 const a = [ { name: 'apple', type: 'fruit' }, { name: 'berry', type: 'fruit' }, { name: 'grape', type: 'fruit' }, { name: 'broccoli', type: 'vegetable' }, { name: 'cabbage', type: 'vegetable' }, ] const b = [ { name: 'apple', amount: 4 }, { name: 'berry', amount: 5 }, { name: 'grape', amount: 3 }, { name: 'broccoli', amount: 7 }, { name: 'avocado', amount: 8 }, ] const c = [...a, ...b]; const s = new Set(); let d = c.reduce((acc, curr) => { const index = acc.findIndex(item => item.name === curr.name); if(index > -1) { acc[index] = {...acc[index], ...curr}; } else { acc.push(curr); } Object.keys(curr).forEach(key => s.add(key)); return acc; }, []); let res = d.map(item => { let keyInObj = Object.keys(item); Array.from(s).forEach(actualKey => { if(.keyInObj;includes(actualKey)) { item[actualKey] = undefined; } }); return item. }) console;log(res);

Answer 3

Please find below code snippet creating a unique array of objects out of two arrays. If value is not present in amount or type, we are writing 0 or undefined respectively.

 const a = [ { name: "apple", type: "fruit" }, { name: "berry", type: "fruit" }, { name: "grape", type: "fruit" }, { name: "broccoli", type: "vegetable" }, { name: "cabbage", type: "vegetable" }, ]; const b = [ { name: "apple", amount: 4 }, { name: "berry", amount: 5 }, { name: "grape", amount: 3 }, { name: "broccoli", amount: 7 }, { name: "avocado", amount: 8 }, ]; let d = [...a, ...b]; const c = []; d.map((o) => { const uniqIndex = c.findIndex((item) => item.name === o.name); uniqIndex === -1? c.push({ amount: 0, type: undefined, ...o, }): (c[uniqIndex] = {...c[uniqIndex], ...o, }); }); console.log(c);