How to go through an array of objects, add specific properties and unify those objects where it has a specific property equal to another?

Question

I have an array of objects that have this structure below:

listaProdutos = 
[
      {nome:'Teclado',preco:28.00},
      {nome:'Mouse',preco:36.00},
      {nome:'Monitor',preco:500.00},
      {nome:'CPU',preco:800.00},
      {nome:'Teclado',preco:28.00},
      {nome:'Monitor',preco:500.00},
];

My intention would be to generate an array of objects with the result below:

novoLista = 
[
    {nome:'Teclado',preco:56.00},
    {nome:'Mouse',preco:36.00},
    {nome:'Monitor',preco:1000.00},
    {nome:'CPU',preco:800.00} 
];

You could help me with the best approach to this situation ?

Answer 1

One can use the method reduce() to iterate on each element of the array, remove duplicates and add. For example:

listaProdutos = 
[
      {nome:'Teclado',preco:28.00},
      {nome:'Mouse',preco:36.00},
      {nome:'Monitor',preco:500.00},
      {nome:'CPU',preco:800.00},
      {nome:'Teclado',preco:28.00},
      {nome:'Monitor',preco:500.00},
];

const novoLista = listaProdutos.reduce((soma, cur) => {
  // guarda o nome atual e verifica se existe repetido
  let nome = cur.nome;
  let repetido = soma.find(elem => elem.nome === nome)
  // se for repetido soma, caso contrário adiciona o elemento ao novo array
  if (repetido) repetido.preco += cur.preco;
  else soma.push(cur);
  // retorna o elemento agrupado e somado
  return soma;
}, []);

console.log(novoLista);

Answer 2

You can accumulate each nome single and go adding the preco of each object by nome corresponding. Once the map has been completed, the new array is generated. One way to keep objects from a single key is to use the data structure Map javascript.

Something like that:

function sumByPropName(nameProp, sumProp, arr) {
  const map = new Map();

  for (const obj of arr) {
    // Chave que utilizaremos para o mapa. A `key` corresponde a cada "nome" único.
    const key = obj[nameProp];

    // Caso nenhum objeto já tiver sido registrado para a chave atual, devemos o
    // inserir pela primeira vez.
    if (!map.has(key)) {
      map.set(key, obj);

      // Podemos pular para a próxima iteração, já que o valor correspondente
      // já está incluído no `obj`.
      continue;
    }

    // Caos já tenha sido registrado, é só somar ao valor já armazenado.
    map.get(key)[sumProp] += obj[sumProp];
  }

  // Converter o mapa em array:
  return [...map.values()];
}

const original = [
  { nome: 'Teclado', preco: 28.0 },
  { nome: 'Mouse', preco: 36.0 },
  { nome: 'Monitor', preco: 500.0 },
  { nome: 'CPU', preco: 800.0 },
  { nome: 'Teclado', preco: 28.0 },
  { nome: 'Monitor', preco: 500.0 }
];

// Queremos identificar elementos únicos pela propriedade `nome` (1º arg.)
// O somatório corresponde à propriedade `preco` (2º arg.)
console.log(sumByPropName('nome', 'preco', original));

The complexity of the above function would be something like O(n + m), being n the number of elements of the original array and m the number of nomes only.

• The n comes from for (which is indispensable in this type of situation).
• The m (which is often tiny and can be disregarded) comes from the need to convert the map to array at the end of the function.

If Map cannot be used (was introduced in Ecmascript 2015), can be used Object.create(null) as a substitute.

I already tried to explain directly by the code, any doubt leave in the comments I try to edit to clarify.

Answer 3

I will share my solution, this being, in my view, a decent alternative to the other answers.

Code:

const listaProdutos = [
  { nome: 'Teclado', preco: 28.0 },
  { nome: 'Mouse', preco: 36.0 },
  { nome: 'Monitor', preco: 500.0 },
  { nome: 'CPU', preco: 800.0 },
  { nome: 'Teclado', preco: 28.0 },
  { nome: 'Monitor', preco: 500.0 },
];

const resObject = {};

listaProdutos.forEach((elem) => {
  const valorAnterior = resObject[elem.nome] || 0;

  resObject[elem.nome] = valorAnterior + elem.preco;
});

const novoLista = Object.keys(resObject).map((key) => {
  return { nome: key, preco: resObject[key] };
});

console.log(novoLista);

The explanations:

• const resObject = {}; is a temporary object to save the value of nome as a key of this object, in addition to maintaining an accumulated value of each preco from the list of products.

• forEach to iterate on the list elements.

• valorAnterior receives the value already saved on resObject according to the key (Teclado, Mouse, etc...). If the key does not exist, we adopt the value 0.

• resObject[elem.nome] = valorAnterior + elem.preco; basically add a key to the object resObject with an initial value according to elem.preco. If the key already exists, it already has a value, then we will make a sum.

At this point, if you give a console.log, will see the object resObject with the keys with the names of the listed product names and their values already summed.

const listaProdutos = [
  { nome: 'Teclado', preco: 28.0 },
  { nome: 'Mouse', preco: 36.0 },
  { nome: 'Monitor lcd', preco: 500.0 },
  { nome: 'CPU', preco: 800.0 },
  { nome: 'Teclado', preco: 28.0 },
  { nome: 'Monitor', preco: 500.0 },
];

const resObject = {};

listaProdutos.forEach((elem) => {
  const valorAnterior = resObject[elem.nome] || 0;

  resObject[elem.nome] = valorAnterior + elem.preco;
});

console.log(resObject)

From now on, what we do is associate the key to the resObject for an object with the property nome:

 return { nome: key, ...}

and the preco will be the value of this key using resObject[key]:

return { nome: key, preco: resObject[key] };

---

I added a toFixed just to stay as you wish to novoLista:

const listaProdutos = [
  { nome: 'Teclado', preco: 28.0 },
  { nome: 'Mouse', preco: 36.0 },
  { nome: 'Monitor lcd', preco: 500.0 },
  { nome: 'CPU', preco: 800.0 },
  { nome: 'Teclado', preco: 28.0 },
  { nome: 'Monitor', preco: 500.0 },
];

const resObject = {};

listaProdutos.forEach((elem) => {
  const valorAnterior = resObject[elem.nome] || 0;

  resObject[elem.nome] = valorAnterior + elem.preco;
});

const novoLista = Object.keys(resObject).map((key) => {
  return { nome: key, preco: parseFloat(resObject[key]).toFixed(2) };
});


console.log(novoLista);

Answer 4

Still on the subject Map another approach may be used.

Make it an instance of Map an index for the elements of Array novoLista which will initially be populated with a copy of the first object in the list listaProdutos whose property nome has not yet been indexed. If an index is already owned nome just add up preço at the preço of the already indexed element.

let listaProdutos = 
[
      {nome:'Teclado',preco:28.00},
      {nome:'Mouse',preco:36.00},
      {nome:'Monitor',preco:500.00},
      {nome:'CPU',preco:800.00},
      {nome:'Teclado',preco:28.00},
      {nome:'Monitor',preco:500.00},
];

let novoLista = [];

let m = new Map();

//Para todos os elementos de listaProdutos...
for(let prod of listaProdutos){
  //Verifica se índice contiver a chave prod.nome...
  if (m.has(prod.nome)){
    //No item indexado por prod.nome no array novoLista incrementa o preço registrado com o novo preço.
    novoLista[m.get(prod.nome)].preco += prod.preco;                          
  } else {
    //Cria um índice nomeado pelo valor de prod.nome apontando para o mais novo elemento do array novoLista
    m.set(prod.nome, novoLista.push({nome:prod.nome,preco:prod.preco}) - 1);  
  }
}

console.log(novoLista);

Thank you to Luiz Felipe which put the above code in the form of a function:

let listaProdutos = 
[
  {nome:'Teclado',preco:28.00},
  {nome:'Mouse',preco:36.00},
  {nome:'Monitor',preco:500.00},
  {nome:'CPU',preco:800.00},
  {nome:'Teclado',preco:28.00},
  {nome:'Monitor',preco:500.00},
];

function somar(arr) {
  let novoLista = [];
  let m = new Map();
  for (let prod of arr) {
    if (m.has(prod.nome)) {
      novoLista[m.get(prod.nome)].preco += prod.preco;
    } else {
      m.set(prod.nome, novoLista.push({
        nome: prod.nome,
        preco: prod.preco
      }) - 1);
    }
  }
  return novoLista;
}

console.log(somar(listaProdutos))

Answer 5

const listaProdutos = [{
    nome: 'Teclado',
    preco: 28.00
  },
  {
    nome: 'Mouse',
    preco: 36.00
  },
  {
    nome: 'Monitor',
    preco: 500.00
  },
  {
    nome: 'CPU',
    preco: 800.00
  },
  {
    nome: 'Teclado',
    preco: 28.00
  },
  {
    nome: 'Monitor',
    preco: 500.00
  },
];

// Agrupe
const groups = listaProdutos.reduce((acc, current) => {
  if (!acc[current.nome]) {
    acc[current.nome] = { ...current
    }

    return acc
  }

  acc[current.nome].preco = acc[current.nome].preco + current.preco

  return acc
}, {})

// Extraia a lista 
const newList = Object.values(groups)
console.log(newList)