A cutting-edge ES2024 method for grouping by name

To begin, utilize the Map.groupBy function to group your array based on the name attribute into a Map. Each key in the map corresponds to a distinct name from your objects, while the associated value is an array of objects with that specific name attribute. Subsequently, apply Array.from() on the grouped Map to convert it into an array of objects. For each object in this new array, you can sum up the values with matching name keys using .reduce():

const sumByKey = (arr, key, value) => {
  const grouped = Map.groupBy(arr, o => o[key]);
  return Array.from(
    grouped.values(),
    group => group.reduce((acc, obj) => ({...obj, [value]: (acc[value] ?? 0) + obj[value]}), {})
  );
}

const arr = [ { 'name': 'P1', 'value': 150 }, { 'name': 'P1', 'value': 150 }, { 'name': 'P2', 'value': 200 }, { 'name': 'P3', 'value': 450 } ];
console.log(sumByKey(arr, 'name', 'value')); // [ { "name": "P1", "value": 300 }, { "name": "P2", "value": 200 }, { "name": "P3", "value": 450 } ]

An innovative ES6 tactic for grouping by name:

You can transform your object array into a Map using .reduce() technique. The resultant Map contains key-value pairs where each key represents the name, and the corresponding value signifies the accumulated sum of values for that particular name key. Thereafter, effortlessly convert the Map back into an array utilizing Array.from(), enabling you to execute a mapping function that will convert the keys/values of the Map into objects:

const arr = [ { 'name': 'P1', 'value': 150 }, { 'name': 'P1', 'value': 150 }, { 'name': 'P2', 'value': 200 }, { 'name': 'P3', 'value': 450 } ];

const res = Array.from(arr.reduce(
  (m, {name, value}) => m.set(name, (m.get(name) || 0) + value), new Map
), ([name, value]) => ({name, value}));
console.log(res);

The above process may appear concise and slightly complex. To enhance clarity, consider encapsulating it within a function for better understanding. If code readability is a priority, employing for...of can simplify comprehension. The following function also proves beneficial for grouping or summing keys with spaces within them:

const arr = [ { 'name': 'P1', 'value': 150 }, { 'name': 'P1', 'value': 150 }, { 'name': 'P2', 'value': 200 }, { 'name': 'P3', 'value': 450 } ];

const sumByKey = (arr, key, value) => {
  const map = new Map();
  for(const obj of arr) {
    const currSum = map.get(obj[key]) || 0;
    map.set(obj[key], currSum + obj[value]);
  }
  const res = Array.from(map, ([k, v]) => ({[key]: k, [value]: v}));
  return res;
}

console.log(sumByKey(arr, 'name', 'value')); // 'name' = value to group by, 'value' = value to sum

Enhanced Grouping beyond just name:

Consider this strategy capable of handling other interconnected properties apart from solely name (ensuring identical keys and values in both objects for effective "grouping"). This method involves iterating through the array and reducing it to a Map containing key-value pairs. Each key in the fresh Map represents a string composed of all property values intended for grouping. Therefore, detecting existing object keys indicates duplicates, thereby allowing addition of the current object's value to the stored object. Finally, leverage Array.from() to transition from a Map of key-value pairs to exclusively an array of values:

const arr = [{'name':'P1','value':150},{'name':'P1','value':150},{'name':'P2','value':200},{'name':'P3','value':450}];

const res = Array.from(arr.reduce((acc, {value, ...r}) => {
  const key = JSON.stringify(r);
  const current = acc.get(key) || {...r, value: 0};  
  return acc.set(key, {...current, value: current.value + value});
}, new Map).values());
console.log(res);

You can utilize the Array.reduce() method to aggregate results in each iteration.

var items = [{'name':'P1','value':150},{'name':'P1','value':150},{'name':'P2','value':200},{'name':'P3','value':450}];

var total = items.reduce(function(accumulator, currentValue){
    var existingItem = accumulator.filter(function(obj){
        return obj.name == currentValue.name;
    }).pop() || {name:currentValue.name, value: 0};
    
    existingItem.value += currentValue.value;
    accumulator.push(existingItem);
    return accumulator;
}, []);

console.log(total);

The process of simplifying complex reduce functions with Array, Map, and Set can be achieved in a more straightforward way as shown below:

const summed = arr.reduce((acc, cur, i) => {
  const item = i > 0 && acc.find(({name}) => name === cur.name)
  if (item) item.value += cur.value;
  else acc.push({ name: cur.name, value: cur.value }); // do not include current element here
  return acc;
}, [])
console.log(arr); // input array remains unchanged
console.log(summed);

<script>
  const arr = [{
      'name': 'P1',
      'value': 150
    },
    {
      'name': 'P1',
      'value': 150
    },
    {
      'name': 'P2',
      'value': 200
    },
    {
      'name': 'P3',
      'value': 450
    }
  ]
</script>

After running the code provided by @Vignesh Raja, I noticed that while I did get the "sum" as expected, there were duplicates in the result. To resolve this issue, I had to eliminate the duplicates using the method outlined below.

Here is the original array:

arr=[{name: "LINCE-01", y: 70}, 
 {name: "LINCE-01", y: 155},
 {name: "LINCE-01", y: 210},
 {name: "MIRAFLORES-03", y: 232},
 {name: "MIRAFLORES-03", y: 267}]

Utilizing @VigneshRaja's code snippet:

var result = arr.reduce(function(acc, val){
    var o = acc.filter(function(obj){
        return obj.name==val.name;
    }).pop() || {name:val.name, y:0};

    o.y += val.y;
    acc.push(o);
    return acc;
},[]);

console.log(result);

The initial output was:

result: [{name: "LINCE-01", y: 435},
 {name: "LINCE-01", y: 435},
 {name: "LINCE-01", y: 435},
 {name: "MIRAFLORES-03", y: 499},
 {name: "MIRAFLORES-03", y: 499}]

To remove the duplicates, the following code was employed:

var finalresult = result.filter(function(itm, i, a) {
                            return i == a.indexOf(itm);
                        });
console.log(finalresult);

Ultimately, the desired outcome was achieved:

finalresult = [{name: "LINCE-01", y: 435},
 {name: "MIRAFLORES-03", y: 657}]

Sincerely,

To enhance Mr Nick Parsons' suggestion, I have modified his answer to efficiently calculate the sum of multiple key values.

var data = [{'name':'P1','value':150,'apple':10},{'name':'P1','value':150,'apple':20},{'name':'P2','value':200,'apple':30},{'name':'P3','value':450,'apple':40}];

var result = Object.values(data.reduce((accumulator, {value, apple , ...rest}) => {
  var key = Object.entries(rest).join('-');
  accumulator[key] = (accumulator[key]  || {...rest, apple:0, value: 0});
  return (accumulator[key].apple += apple, accumulator[key].value += value, accumulator);
}, {}));

console.log(result);

Here's another neat solution I came up with:

    var data =  [
        { 'type': 'A', 'amount': 150 },
        { 'type': 'A', 'amount': 150 },
        { 'type': 'B', 'amount': 200 },
        { 'type': 'C', 'amount': 450 }
    ];

     var finalResult = [];
Array.from(new Set(data.map(x => x.type))).forEach(x => {

    finalResult.push(data.filter(y => y.type === x).reduce((output,item) => {
        let val = output[x] === undefined?0:output[x];
        output[x] =  (item.amount +  val); 
       return output;
    },{}));

 })
      
            console.log(finalResult);

If you want to maintain the same object structure, then check this out:

var data =  [
    { 'type': 'A', 'amount': 150 },
    { 'type': 'A', 'amount': 150 },
    { 'type': 'B', 'amount': 200 },
    { 'type': 'B', 'amount': 1000 },
    { 'type': 'C', 'amount': 450 }
];

let resultArray = [];
let finalOutput = {};
let uniqueTypes = Array.from(new Set(data.map(x => x.type)));
uniqueTypes.forEach(n => {
   resultArray.push(data.filter(x => x.type === n).reduce((a, item) => {
      
       let totalAmount = a['type'] === undefined ? item.amount : a['amount'] + item.amount;
        
        return {type:n, amount:totalAmount};
    },{})
);
});

console.log(resultArray);

In comparison to the sample data, my dataset was not as structured. I encountered certain challenges like calculating the total count of unique strings within a group and dealing with surplus data that was irrelevant for the tally.

I also found it tricky to replace some of the demo data object values with actual real-world values while maintaining code readability. Ultimately, I preferred @NickParsons' solution which can be found here: . I chose to enhance this solution further. It crossed my mind whether this enhancement should warrant a new question, more along the lines of "Summing specific keys or strings within arrays," but I felt that elaborating on this post directly was the most appropriate course of action.

After deliberation, I concluded that utilizing Arrays for string manipulation was optimal. I even added an option in my function to de-duplicate arrays if necessary. This way, by using arr.length, the number of hits can be determined. In my scenario, this array could also serve as a collection based on the group category.

Although I anticipate performing additional iterations over my 'Arr_Of_Objs', having this master function allows me to create smaller logical groups of objects. Given the extensive cross-referencing and tallying required, attempting to consolidate all logic into one large iteration proved chaotic quickly.

In addition, I introduced functionality for totaling strings if the object values happen to have a string representation rather than integer values.

Moreover, the capability to pass toFixed for trimming decimal places became part of the feature set.

The inclusion of Criteria_Objs furthers fine-tuning the sums. Since passing an operator isn't supported, I implemented a single if then statement to check for "==" and use == as an operator. If more operators are necessitated, custom coding would be imperative, although integrating them should be straightforward, such as adding >.

Below is a snippet of the code:

 [Code snippet has been omitted for brevity] 

let myArray = [
    {
        'id': 'A1',
        'value': 150
    },
    {
        'id': 'A1',
        'value': 150
    },
    {
        'id': 'A2',
        'value': 200
    },
    {
        'id': 'A3',
        'value': 450
    }
]

result array let newDataArray = []

for (let i = 0; i < myArray.length; i++) {
    
        for (let j = i + 1; j < myArray.length; j++) {
    
            if (myArray[j].id == myArray[i].id) {
                console.log('match');
                myArray[i].value += myArray[j].value;
                newDataArray = myArray.filter( element => element !== myArray[j]);
    
                newDataArray = myArray.filter(function (element) {
                    return  element !== myArray[j];
                });
    
            }
        }
    }
console.log(newDataArray)

Could you please offer a more generalized version of the solution for this query?

/**
 * @param {(item: T) => string} keyFn
 * @param {(itemA: T, itemB: T) => T} mergeFn
 * @param {number[]} list
 */
function condenseData(keyFn, mergeFn, list) {
  return Array.from(
    list
      .reduce((map, item) => {
        const key = keyFn(item);

        return map.has(key) // if key already existed
          ? map.set(key, mergeFn(map.get(key), item)) // merge two items together
          : map.set(key, item); // save item in map
      }, new Map())
      .values()
  );
}

const dataToCondense = [
  {
    type: "Type1",
    count: 150,
  },
  {
    type: "Type1",
    count: 150,
  },
  {
    type: "Type2",
    count: 200,
  },
  {
    type: "Type3",
    count: 450,
  },
];

console.log(
  condenseData(
    /* user define which is unique key */
    ({ type }) => type,
    /* how to merge two item together */
    (a, b) => ({ type: a.type, count: a.count + b.count }),
    /* array */
    dataToCondense
  )
)

This method really stands out to me in terms of making the code more readable.

const input = [
  { title: 'Book1', pages: 200 },
  { title: 'Book2', pages: 150 },
  { title: 'Book1', pages: 100 },
  { title: 'Book3', pages: 300 },
];

const result = {};
input.forEach((item) => {
  if (result[item.title]) {
    result[item.title].pages += item.pages;
  } else {
    result[item.title] = item;
  }
});


const summary = Object.values(result);

console.log(input)
console.log(result)
console.log(summary);

Expanding on the original answer, here is a more comprehensive solution for anyone in need:

let dataHolder = {};

data.forEach(entry => {

  if (!dataHolder.hasOwnProperty(entry.name)) {
    dataHolder[entry.name] = { name: entry.name, totalInvested: 0, totalReturned: 0, totalNav: 0, totalIRR: 0 };
  }

  dataHolder[entry.name] = {
    name: entry.name,
    totalInvested: dataHolder[name].totalInvested + entry.invested,
    totalReturned: dataHolder[name].totalReturned + entry.returned,
    totalNav: dataHolder[name].totalNav + entry.nav,
    totalIRR: dataHolder[name].totalIRR + entry.irr,
  };
});

return Object.values(dataHolder);

function filterUniqueItems(items) {
  var uniqueList = [];
  for (let index = 0; index < items.length; index++) {
    const currentItem = items[index];
    const isDuplicate = uniqueList.find(i => i.itemId == currentItem.itemId);
    if (isDuplicate) {
      isDuplicate.quantity = isDuplicate.quantity + currentItem.quantity;
    } else {
      uniqueList.push(currentItem);
    }
  }
  return uniqueList;
}

    An effortless approach to achieve it>
    
    const obj1 = {
  x: 3,
  y: 5,
  };
  
  const obj2 = {
  x: 6,
  y: 2,
  }
  
  function combineObjects(...args) {
  const combined = {};
  
  for (const object of args) {
    for (const key in object) {
      if (!combined[key]) {
      combined[key] = 0;
      }
      combined[key] += object[key];
    }
  }
  
  return combined;
  }
  
  const combinedResult = combineObjects(obj1, obj2);
  console.log(combinedResult);