Aggregate the array of objects into a new array and calculate the total sum of values

Question

Aggregate the array of objects into a new array and calculate the total sum of values

I have an array with the following structure, and I am attempting to separate objects into a new array by grouping two values.

Array:

[
 {
    "year": "202003",
    "cost": 11194.55,
    "type": "A"
  },
  {
    "year": "202003",
    "cost": 60.2,
    "type": "B"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "C"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202004",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202003",
    "cost": 4674.59,
    "type": "D"
  }
]

The desired output should be as follows;

Output

[
 [
  {
   "year": "202003",
   "cost": 11194.55,
   "type": "A"
  }
 ],
 [ 
  {
    "year": "202003",
    "cost": 60.2,
    "type": "B"
  }
 ],
 [
  {
    "year": "202003",
    "cost": 747.12,
    "type": "C"
  }
 ],
 [
  {
    "year": "202003",
    "cost": 1494.24,     // sum of the COST value when year and type are the same.
    "type": "D"
  },
  {
     "year": "202004",
     "cost": 4674.59,
     "type": "D"
  }
 ]
];

Approach Attempted:

<script src="//cdnjs.cloudflare.com/ajax/libs/linq.js/2.2.0.2/linq.min.js"></script>
let aggregatedObject = Enumerable.From(data)
            .GroupBy("$.type", "$.year",
                function (key, g) {
                    return {
                        label: key,
                        value: g.Sum("$.cost"),
                    }
                })
            .ToArray();

How can I achieve this data grouping? Are there any libraries or functions available for this task that I may have yet to discover? Your assistance would be greatly appreciated!

javascript json

Answer 1

Answer №1

Upon analyzing your original array and the desired output structure you provided, here are examples that yield the exact same structure as per your inquiry - an array of arrays of objects

One approach using find & for of loop:

let arr = [
 {
    "year": "202003",
    "cost": 11194.55,
    "type": "A"
  },
  {
    "year": "202003",
    "cost": 60.2,
    "type": "B"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "C"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202004",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202003",
    "cost": 4674.59,
    "type": "D"
  }
]

let sortedArray = []
for (let [index, el] of arr.entries()) {
  if(sortedArray.find(elInner => (elInner[0].type === el.type && elInner[0].year !== el.year))) {
    sortedArray.find(elInner => elInner[0].type === el.type).push(arr[index])
  }else if (sortedArray.find(elInner => (elInner[0].type === el.type && elInner[0].year == el.year))) {
    sortedArray.find(elInner => (elInner[0].type === el.type && elInner[0].year == el.year))[0].cost += arr[index].cost
  }else {
    sortedArray.push([el])
  }
}
console.log(sortedArray)

Another more concise method utilizing reduce & map

let arr = [
 {
    "year": "202003",
    "cost": 11194.55,
    "type": "A"
  },
  {
    "year": "202003",
    "cost": 60.2,
    "type": "B"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "C"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202004",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202003",
    "cost": 4674.59,
    "type": "D"
  }
]

let sortedArray = arr.reduce((acc, obj) => {
  const key = obj.type, year = obj.year
  !!acc[key] 
  ? (!!acc[key][year] ? acc[key][year].cost += obj.cost : acc[key][year] = obj) 
  : (acc[key] = [], acc[key][year] = obj)
    return acc
}, [])

sortedArray = Object.values(sortedArray).map((val) => Object.values(val))

console.log(sortedArray)

Answer 2

Upon analyzing your original array and the desired output structure you provided, here are examples that yield the exact same structure as per your inquiry - an array of arrays of objects

One approach using find & for of loop:

let arr = [
 {
    "year": "202003",
    "cost": 11194.55,
    "type": "A"
  },
  {
    "year": "202003",
    "cost": 60.2,
    "type": "B"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "C"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202004",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202003",
    "cost": 4674.59,
    "type": "D"
  }
]

let sortedArray = []
for (let [index, el] of arr.entries()) {
  if(sortedArray.find(elInner => (elInner[0].type === el.type && elInner[0].year !== el.year))) {
    sortedArray.find(elInner => elInner[0].type === el.type).push(arr[index])
  }else if (sortedArray.find(elInner => (elInner[0].type === el.type && elInner[0].year == el.year))) {
    sortedArray.find(elInner => (elInner[0].type === el.type && elInner[0].year == el.year))[0].cost += arr[index].cost
  }else {
    sortedArray.push([el])
  }
}
console.log(sortedArray)

Another more concise method utilizing reduce & map

let arr = [
 {
    "year": "202003",
    "cost": 11194.55,
    "type": "A"
  },
  {
    "year": "202003",
    "cost": 60.2,
    "type": "B"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "C"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202004",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202003",
    "cost": 4674.59,
    "type": "D"
  }
]

let sortedArray = arr.reduce((acc, obj) => {
  const key = obj.type, year = obj.year
  !!acc[key] 
  ? (!!acc[key][year] ? acc[key][year].cost += obj.cost : acc[key][year] = obj) 
  : (acc[key] = [], acc[key][year] = obj)
    return acc
}, [])

sortedArray = Object.values(sortedArray).map((val) => Object.values(val))

console.log(sortedArray)

Answer 3

Answer №2

Utilizing Array.reduce is a great way to aggregate the expenses.

const data = [
  {
    year: '202003',
    cost: 11194.55,
    type: 'A',
  },
  {
    year: '202003',
    cost: 60.2,
    type: 'B',
  },
  {
    year: '202003',
    cost: 747.12,
    type: 'C',
  },
  {
    year: '202003',
    cost: 747.12,
    type: 'D',
  },
  {
    year: '202004',
    cost: 747.12,
    type: 'D',
  },
  {
    year: '202003',
    cost: 4674.59,
    type: 'D',
  },
];

const final = data.reduce((result, current) => {
  const key = `${current.year}-${current.type}`;
  result[key] = result[key] || {...current, cost: 0};
  result[key].cost += current.cost;
  return result;
}, {});

console.log(Object.values(final).map(item => ([item])));

Answer 4

Utilizing Array.reduce is a great way to aggregate the expenses.

const data = [
  {
    year: '202003',
    cost: 11194.55,
    type: 'A',
  },
  {
    year: '202003',
    cost: 60.2,
    type: 'B',
  },
  {
    year: '202003',
    cost: 747.12,
    type: 'C',
  },
  {
    year: '202003',
    cost: 747.12,
    type: 'D',
  },
  {
    year: '202004',
    cost: 747.12,
    type: 'D',
  },
  {
    year: '202003',
    cost: 4674.59,
    type: 'D',
  },
];

const final = data.reduce((result, current) => {
  const key = `${current.year}-${current.type}`;
  result[key] = result[key] || {...current, cost: 0};
  result[key].cost += current.cost;
  return result;
}, {});

console.log(Object.values(final).map(item => ([item])));

Answer 5

Answer №3

If you're looking to streamline your code, consider utilizing array.reduce in place of linq.js. Each callback execution aggregates data based on matching year and type, or inserts a duplicate object into an array that is eventually returned from the function:

let data = [
 {
    "year": "202003",
    "cost": 11194.55,
    "type": "A"
  },
  {
    "year": "202003",
    "cost": 60.2,
    "type": "B"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "C"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202004",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202003",
    "cost": 4674.59,
    "type": "D"
  }
];

let aggregatedObject = data.reduce((acc,cur) => {
   let prev = acc.find(x => x.year === cur.year && x.type === cur.type);
   if(!prev){
       acc.push([{...cur}]);
   } else {
       prev.cost += cur.cost;
   }
   return acc;
}, []);

console.log(aggregatedObject);

Answer 6

If you're looking to streamline your code, consider utilizing array.reduce in place of linq.js. Each callback execution aggregates data based on matching year and type, or inserts a duplicate object into an array that is eventually returned from the function:

let data = [
 {
    "year": "202003",
    "cost": 11194.55,
    "type": "A"
  },
  {
    "year": "202003",
    "cost": 60.2,
    "type": "B"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "C"
  },
  {
    "year": "202003",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202004",
    "cost": 747.12,
    "type": "D"
  },
  {
    "year": "202003",
    "cost": 4674.59,
    "type": "D"
  }
];

let aggregatedObject = data.reduce((acc,cur) => {
   let prev = acc.find(x => x.year === cur.year && x.type === cur.type);
   if(!prev){
       acc.push([{...cur}]);
   } else {
       prev.cost += cur.cost;
   }
   return acc;
}, []);

console.log(aggregatedObject);

Answer 7

Answer №4

To retrieve a combined value, you can use a joined key with linq as the fourth parameter and a merged object.

var info = [{ year: "202003", cost: 11194.55, type: "A" }, { year: "202003", cost: 60.2, type: "B" }, { year: "202003", cost: 747.12, type: "C" }, { year: "202003", cost: 747.12, type: "D" }, { year: "202004", cost: 747.12, type: "D" }, { year: "202003", cost: 4674.59, type: "D" }],
    output = Enumerable
        .From(info)
        .GroupBy(
            null,
            null,
            "{ year: $.year, cost: $$.Sum('$.cost'), type: $.type }",
            "$.year + '|' + $.type"
        )
        .ToArray();

console.log(output);

.as-console-wrapper { max-height: 100% !important; top: 0; }

<script src="https://cdnjs.cloudflare.com/ajax/libs/linq.js/2.2.0.2/linq.js"></script>

Answer 8

To retrieve a combined value, you can use a joined key with linq as the fourth parameter and a merged object.

var info = [{ year: "202003", cost: 11194.55, type: "A" }, { year: "202003", cost: 60.2, type: "B" }, { year: "202003", cost: 747.12, type: "C" }, { year: "202003", cost: 747.12, type: "D" }, { year: "202004", cost: 747.12, type: "D" }, { year: "202003", cost: 4674.59, type: "D" }],
    output = Enumerable
        .From(info)
        .GroupBy(
            null,
            null,
            "{ year: $.year, cost: $$.Sum('$.cost'), type: $.type }",
            "$.year + '|' + $.type"
        )
        .ToArray();

console.log(output);

.as-console-wrapper { max-height: 100% !important; top: 0; }

<script src="https://cdnjs.cloudflare.com/ajax/libs/linq.js/2.2.0.2/linq.js"></script>

Aggregate the array of objects into a new array and calculate the total sum of values

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

What is the best way to set up JSON offline caching?

The toggling feature seems to be malfunctioning as the div section fails to display

JavaScript menu that pops up

"Hidden panels in Sencha Touch only respond to show() and hide() methods after a resize event

Merging a VUE project and a .NET framework project to unleash their full potential

Tips for attaching the Bootstrap 5 dropdown menu to a particular element, especially when the dropdown element is contained within another element that has an overflow property set to hidden

File index with Node.js server for handling files

When I click on the left side menu, it should automatically scroll upwards

Problems with Material UI autocomplete causing destruction of Redux-form values

What is an alternative way to display static images in Rails 5 without relying on the Asset Pipeline?

Create a dynamic pulse line on an HTML5 Canvas

Apply active class to a link element in React JS

Failed to retrieve information using a custom header in the HTTP request

You can't send headers to the client in Express after they have already been set

Is there a way to successfully submit multiple locations, each separated by commas, through the multipart form?

EdgeDriver with Selenium and Java can be interrupted by a modal window dialog box, causing the test script to pause its execution

What is the best way to send extra parameters to an ajax callback function?

Is it possible for search engines like google to index Javascript content that is stored within divs and loaded onto the page?

What is the correct way to incorporate a button into a fullcalendar?

What are the ways to utilize vue-i18n setup within and beyond Vue components when working with Quasar?