Compare two array of objects and modify original array of object

Question

Let we have two array of objects as,

let oldArrayOfObject = [
    {
      Item: "ACC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "BCC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "CCC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "DCC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "ECC",
      Price: "",
      hasPrice: false,
    },
  ];

let newArrayOfObject = [
  {
    Item: "ACC",
    Price: 12,
  },
  {
    Item: "BCC",
    Price: 50,
  },
  {
    Item: "ECC",
    Price: 21,
  }
];

Compare two array of objects and if price exists in newArrayOfObject for particular Item insert price into oldArrayOfObject for that particular item and set hasPrice: true.

Expected O/P:

console.log(oldArrayOfObject)

[
    {
      Item: "ACC",
      Price: 12,
      hasPrice: true,
    },
    {
      Item: "BCC",
      Price: 50,
      hasPrice: true,
    },
    {
      Item: "CCC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "DCC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "ECC",
      Price: 21,
      hasPrice: true,
    },
  ];

For this I tried as,

const modifiedArrayOfObject = newArrayOfObject.map((node) => {
  const oldInfo = oldArrayOfObject.find((item) => item.Item === node.Item);
  if (oldInfo) {
    return { ...node, hasPrice: oldInfo.Price !==  node.Price }
  } else {
     return { ...node, hasPrice: true };
  }
});

But I am unable to move forward from here. Please let me know if anyone needs any further explanation or further clearance.

Nitheesh · Accepted Answer · 2021-10-19 03:47:24Z

The issue with your code were

You have to find the nodes from oldArrayOfObject in newArrayOfObject. Your oldInfo should be defined as oldInfo = newArrayOfObject.find((item) => item.Item === node.Item);
Also if oldInfo is found, you should reurn the Price as Price: oldInfo.Price
Incase if the oldInfo is not found, you have to return the current node itself. Dont set hasPrice: true manually in that.

Working Fiddle

const oldArrayOfObject = [{ Item: "ACC", Price: "", hasPrice: false, }, { Item: "BCC", Price: "", hasPrice: false, }, { Item: "CCC", Price: "", hasPrice: false, }, { Item: "DCC", Price: "", hasPrice: false, }, { Item: "ECC", Price: "", hasPrice: false, }];

const newArrayOfObject = [{ Item: "ACC", Price: 12, }, { Item: "BCC", Price: 50, }, { Item: "ECC", Price: 21 }];

const modifiedArrayOfObject = oldArrayOfObject.map((node) => {
    const oldInfo = newArrayOfObject.find((item) => item.Item === node.Item);
    if (oldInfo) {
        return { ...node, Price: oldInfo.Price, hasPrice: oldInfo.Price !== node.Price }
    } else {
        return { ...node };
    }
});
console.log(modifiedArrayOfObject);

Array.map always create a new array from an existing array.

If you want to update the original array itself instead of creating a new array, you could run a loop on oldArrayOfObject and check if each node from oldArrayOfObject is there in newArrayOfObject. Then update hasPrice and Price if the matching node is found.

Working Fiddle

const oldArrayOfObject = [{ Item: "ACC", Price: "", hasPrice: false, }, { Item: "BCC", Price: "", hasPrice: false, }, { Item: "CCC", Price: "", hasPrice: false, }, { Item: "DCC", Price: "", hasPrice: false, }, { Item: "ECC", Price: "", hasPrice: false, }];

const newArrayOfObject = [{ Item: "ACC", Price: 12, }, { Item: "BCC", Price: 50, }, { Item: "ECC", Price: 21 }];

oldArrayOfObject.forEach((node) => {
    const oldInfo = newArrayOfObject.find((item) => item.Item === node.Item);
    if (oldInfo) {
        node.hasPrice = oldInfo.Price !== node.Price;
        node.Price = oldInfo.Price;
    }
});
console.log(oldArrayOfObject);

JulioHenrique97 · Accepted Answer · 2021-10-19 02:42:25Z

You can try use this function in example:

let oldArrayOfObject = [
    {
      Item: "ACC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "BCC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "CCC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "DCC",
      Price: "",
      hasPrice: false,
    },
    {
      Item: "ECC",
      Price: "",
      hasPrice: false,
    },
  ];

let newArrayOfObject = [
  {
    Item: "ACC",
    Price: 12,
  },
  {
    Item: "BCC",
    Price: 50,
  },
  {
    Item: "ECC",
    Price: 21,
  }
];

function modifiedArrayOfObject(item) {
   newArrayOfObject.map(v => {
    if(v.Item === item){
      const index = oldArrayOfObject.findIndex(obj => obj.Item === v.Item);
      oldArrayOfObject[index] = { Item: v.Item, Price: v.Price, hasPrice: true };
    }
   })
 console.log("oldArrayOfObject:", oldArrayOfObject)
}
modifiedArrayOfObject("ACC")

Mulan · Accepted Answer · 2021-10-19 02:43:36Z

0

If you plan to modify oldArrayOfObject then I would not suggest using map for this. Instead use a simple for loop -

const oldArrayOfObject = ...

const newArrayOfObject = ...

for (const t of newArrayOfObject) {
  const q = oldArrayOfObject.find(o => o.Item=== t.Item)
  if (q == null) continue
  q.Price = t.Price
  q.hasPrice = true
}

console.log(oldArrayofObject)

answered Oct 19, 2021 at 2:43

community wiki

Mulan

Comments

Doan Thai · Accepted Answer · 2021-10-19 03:02:12Z

0

I think you confuse newArrayOfObjects and oldArrayOfObjects. This is solution for your way:

const modifiedArrayOfObject = oldArrayOfObject.map((node) => {
    const newInfo = newArrayOfObject.find((item) => item.Item === node.Item);
    if (newInfo) return { ...node, hasPrice: true, Price: newInfo.Price };
    return node;
});

answered Oct 19, 2021 at 3:02

Doan Thai

6955 silver badges12 bronze badges

Comments

Francisco de lima · Accepted Answer · 2021-10-19 03:03:14Z

0

I wouldn't recommend you to change any of the arrays, leave them immutable and create a new array unifying them. You were on the right track, however, as your oldest list has more items, you should go through it instead of the new one, and if that scenario changes, your code would break.

const modifiedArrayOfObject = oldArrayOfObject.map((oldInfo) => {
  const newInfo = newArrayOfObject.find((newInfo) =>  newInfo.Item === oldInfo.Item);
  if (newInfo && newInfo.Price) {
    return { ...oldInfo, Price: newInfo.Price, hasPrice: true };
  }

  return { ...oldInfo, hasPrice: false };
});


console.log("modifiedArrayOfObject:", modifiedArrayOfObject);

Also, don't use map without return.

answered Oct 19, 2021 at 3:03

Francisco de lima

1

Collectives™ on Stack Overflow

Compare two array of objects and modify original array of object

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related