Using GroupBy on an array of objects in JavaScript

Array grouping is a fairly common operation in any project. Until recently, we had to resort to either writing our own implementation or using third-party libraries when wanting to GroupBy on an array of objects in JavaScript.

That will soon no longer be needed since a native implementation has been introduced in the form of Array.prototype.groupBy. And it is in stage 3 now!

- Advertisement -

To start using it today, we can use the polyfill provided by core-js

Array.prototype.groupBy

Array.groupBy returns an object where each property has the key as the value returned by the arrow function and value as an array of objects matching the criteria.

const groupedObject = array.groupBy((item, index, array) => {
  // ...
  return groupNameAsString;
});

The callback must return a string which would be the group name (JavaScript objects need to have keys as names or Symbols can be used as well).

Examples

Let us assume we have the following array of objects:

const people = [
   { name: 'Saransh', age: 21 },
   { name: 'Wisdom', age: 20 },
   { name: 'Geek', age: 20 }
];

And we want to group them by their age:

const groupByAge = people.groupBy(person => {
  return person.age;
});

console.log(groupByAge); 

// {
//   '20': [
//     { name: 'Wisdom', age: 20 },
//     { name: 'Geek', age: 20 },
//   ],
//   '21': [
//     { name: 'Saransh', age: 21 },
//   ]
// }

An example of grouping a simple array of numbers into odd and even numbers:

const array = [1, 2, 3, 4, 5];

const oddEvenGroups = array.groupBy((num, index, array) => {
  return num % 2 === 0 ? 'even': 'odd';
});

console.log(oddEvenGroups);

// { odd: [1, 3, 5], even: [2, 4] }

Array.prototype.groupByToMap

There are instances where you want a Map instead of a plain JavaScript object. The major benefit is that the keys are then not forced to be strings. The keys of the Map can be of any data type.

groupByToMap works exactly like the groupBy method, the only difference is that it returns a Map.

const groupByAge = people.groupByToMap(person => {
  return person.age;
});

console.log(groupByAge); 

// Map([
//   [20, [
//     { name: 'Wisdom', age: 20 }, 
//     { name: 'Geek', age: 20 },
//   ]],
//   [21, [
//     { name: 'Saransh', age: 21 }
//   ]
// ])

And that is it!

Note: The TypeScript definitions for these methods have not been written yet. Follow this issue for further updates on it.

That is as simple as it gets in terms of implementation and this should land in ES2022 soon and hopefully, the TypeScript definitions are done soon too.

Recent Articles

Overriding nested dependencies in NPM

Whenever we install a particular package, it is common to come across a problem with a dependency's dependency. With the release of...

Automatic batching in React 18 helps avoid re-rendering

Remember the earlier versions of React that used to batch multiple state updates inside event handlers such as click or change to...

Flatten Arrays in Vanilla JavaScript with flat() and flatMap()

ES2019 introduced two methods on the array prototype that would make life so much simpler for developers. These are flat() and flatmap()...

Using GroupBy on an array of objects in JavaScript

Array grouping is a fairly common operation in any project. Until recently, we had to resort to either writing our own implementation...

Node.js introduces node: protocol imports

Node.js recently introduced a node: protocol for built-in modules. Built-in node modules can now be imported by prefixing the node: protocol prefix.

Related Stories

Leave A Reply

Please enter your comment!
Please enter your name here

Hi there! Want some more knowledge?

Think that the knowledge shared is helpful? You might want to give our mailing list a try. We'll send you 2-4 emails a month, right when new posts come out.

Hi there! Want some more knowledge?

Think that the knowledge shared is helpful? You might want to give our mailing list a try. We'll send you 2-4 emails a month, right when new posts come out.