An ES2024 approach to group by name

You can first use Map.groupBy to group your array by name into Map where each key in the map is a name from your objects and the value is an array of objects from your array with that name key. You can then use Array.from() on the grouped Map to convert it into an array of objects, where for each object, you accumulate the objects to sum on value with the same name key using .reduce():

Copyconst 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 ES6 approach to group by name:

You can convert your array of objects to a Map by using .reduce(). The Map has key-value pairs, where each key is the name, and each value is the accumulated sum of values for that particular name key. You can then easily convert the Map back into an array using Array.from(), where you can provide a mapping function that will take the keys/values of the Map and convert them into objects:

Copyconst 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 is quite compact and not necessarily the easiest to read. I would suggest putting it into a function so it's clearer what it's doing. If you're after more self-documenting code, using for...of can make the above easier to understand. The below function is also useful if you want to group or sum on keys with spaces in them:

Copyconst 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

Grouping by more than just name:

Here's an approach that should work if you have other overlapping properties other than just name (the keys/values need to be the same in both objects for them to "group"). It involves iterating through your array and reducing it to Map which holds key-value pairs. Each key of the new Map is a string of all the property values you want to group by, and so, if your object key already exists then you know it is a duplicate, which means you can add the object's current value to the stored object. Finally, you can use Array.from() to transform your Map of key-value pairs, to an array of just values:

Copyconst 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);

I found it useful to ensure that the input data was sanitised to remove the possibility of undefined values before further processing. Much of the verbosity of the code was to do with checking for undefined when the alternate value was always 0, and that even extended to the computeVal function which became redundant.

The sample data was actually 'complete' and didn't include undefined values so I've not tested for outcomes based on imcomplete data. It might also be reasonable to replace || 0 with nullish (?? 0) and to consider if there might be strings or other types that would coerce to falsy and be converted to 0 when something else should happen.

Whilst it would be possible to refactor the nested reduce, it doesn't seem worth it as it now is easier to understand.

I also chose to abbreviate the variable names, again principally to reduce the verbosity without introducing ambiguity.

I suspect that the actual application data doesn't use opaque keys like key1 and key2, I suspect this was used to simplify the question. As a result, this might need a little more work to provide useful defaults, and generally the naming conventions might need aligning with the actual data.

function sanitiseObjects(objects) {
    return objects?.map(obj => {
        return {
            ...obj,
            num: obj.num || 0,
            items: obj.items.map(item => ({
                key1: item.key1 || 0,
                key2: item.key2 || 0,
            }))
        }
    }) || []
}

function sanitizeTotals(totals) {
    return totals?.map(total => ({
        ...total,
        num: total.num || 0,
        gross: total.gross || 0,
        net: total.net || 0,
    })) || []
}

function sumUpKeys(objects, totals = undefined) {

    const defaults = { key1: 0, key2: 0 }

    const totalsSum = sanitizeTotals(totals).reduce((acc, item) => {
        return {
            key1: acc.key1 + (item.num * item.gross),
            key2: acc.key2 + (item.num * item.net),
        };
    }, defaults);

    const objectsSum = sanitiseObjects(objects).reduce((objectsAcc, object) => {
        const itemsSum = object.items.reduce((itemsAcc, item) => {
            return {
                key1: (object.num * item.key1) + itemsAcc.key1,
                key2: (object.num * item.key2) + itemsAcc.key2,
            };
        }, defaults);
        return {
            key1: objectsAcc.key1 + itemsSum.key1,
            key2: objectsAcc.key2 + itemsSum.key2,
        };
    }, defaults);


    // add additional services sum to the monthly charges sum
    return {
        key1: objectsSum.key1 + (totalsSum?.key1 || 0),
        key2: objectsSum.key2 + (totalsSum?.key2 || 0),
    };
}

const objects1 = [
    { num: 3, items: [{ key1: 4, key2: 2, }, { key1: 10, key2: 20, }, ], key3: 'aa', },
    { num: 4, items: [{ key1: 4, key2: 2, }, ], key3: 'aa', },
];

const totals1 = [
    { num: 2, gross: 10, net: 5,},
    { num: 3, gross: 6, net: 12,},
];

// result with totals
const result1 = sumUpKeys(objects1, totals1);
// result without totals
const result2 = sumUpKeys(objects1);
console.log(result1);
console.log(result2);

Either a simple loop

var a = [{level:1},{level:2},{level:3},{level:4}],
        total = 0;
    for (var i=0; i<a.length; i++) {
        total += a[i].level;
    }
console.log('total', total)

or reduce

var a = [{level:1},{level:2},{level:3},{level:4}]
console.log(a.reduce( function(cnt,o){ return cnt + o.level; }, 0))

You can accomplish this using Array.prototype.reduce -

const concat = (a = {}, b = {}) =>
  Object
    .entries(b)
    .reduce
      ( (r, [ k, v ]) =>
          ({ ...r, [k]: (r[k] || 0) + v })
      , a
      )

const main = (...all) =>
  all.reduce(concat, {})
  
var array1 =
  [{'2019-07-13': 1, '2019-07-14': 4, '2019-07-15': 7}]

var array2 =
  [{'2019-07-13': 5, '2019-07-14': 8, '2019-07-15': 6}]

var array3 =
  [{'2019-07-13': 2, '2019-07-14': 1, '2019-07-15': 9}]

console.log(main(...array1, ...array2, ...array3))
// { '2019-07-13': 8
// , '2019-07-14': 13
// , '2019-07-15': 22 
// }

You can use .forEach() here:

var arr = [{ 'credit': 1, 'trash': null }, { 'credit': 2, 'trash': null}];

var total = 0;
arr.forEach(item => {
    total += item.credit;
});
  
console.log(total);

Maybe this is not the pretties solutions but you can do it like this, the function is of course not necessary.

const data = [
  {
    group: "A",
    incomes: {
      "2019-12": 100,
      "2020-12": 200,
      "2021-12": 15,
    },
  },
  {
    group: "B",
    incomes: {
      "2019-12": 25,
      "2020-12": 50,
    },
  },
];

getterInformation(data);

function getterInformation(object) {
  let objectWithCalculatedValues = {};

  object.forEach((items) => {
    for (const key in items.incomes) {
      if (objectWithCalculatedValues[key] === undefined) {
        objectWithCalculatedValues[key] = 0;
      }

      objectWithCalculatedValues[key] += items.incomes[key];
    }
  });

  console.log(objectWithCalculatedValues);
}

If you want to use more of a functional aproach

const sums = {}
Object.values(returnObj).forEach(item => {
  sums[item.page] = (sums[item.page] ?? 0) + item.total_sum
})

Using the lodash lib:

const sums = {}
_.values(returnObj).forEach(item => {
  sums[item.page] = (sums[item.page] ?? 0) + item.total_sum
})