More broadly, this is an example of a utility function for organizing data in a data structure, which JavaScript and all other major programming languages are well-equipped to implement in arbitrary ways, so this is just a convenience function. It's not like a hook into underlying environment APIs that can't be independently shimmed.
https://gist.github.com/ricardobeat/040af80971273f5abd71c2bf...
I got tired, but wouldn't be surprised if the whole thing goes beyond 1000 lines. It's basically a black hole. Better hope you really, really trust their test suite, it's impossible to debug and there must only be a handful of people familiar with the whole codebase.
This is probably missing checking for a bunch of corner cases, but this is the general idea:
// quick & dirty Object.groupBy
function groupBy(iterable, callbackFn) {
const out = {}
for(const [key, value] in Object.entries(iterable)) {
const name = callbackFn(value, key)
(out[name] || (out[name] = [])).push(value)
}
return out
}
I literally wrote something very like this yesterday (after checking & finding it only got added to Node 21, and deciding not to pull in a dependency).Edit: had keyBy impl in here, fixed! Thanks commenters!
I remember me running into the problem of internal dependencies when extracting parts of it into a non-ESM/non-build project some years ago...
Like, the internal consistency of the library probably benefits, and with tree-shaking it works reasonably well but it is still a poster example of DRY vs KISS...
It has its benefits, but its API surface can be annoying, too. When I encounter it, I often have to think for a second and look at the docs, e.g. some cryptic xor or map function with three parameters, one of which being an optional config object.
OTOH, it can be great to have a well-tested implementation at hand for all kinds of higher-order functions, like throttle, debounce etc
Object.from(null), always.
JS standard library is notoriously deficient.
This is a good addition in my view too, especially including Map.
When dealing with DB/API results, one can of course always say that such grouping in the client is an anti-pattern.
But in reality it can be reasonable and useful.
If you write one-off algorithms in JS to transform small amounts of data on the client, you probably habe done this.
And even for data-heavy applications, it could prove to be a performance benefit for functions that use Map instances during computation.
Though that's just wishful thinking until the runtime developers choose to optimize these functions, if possible.
It depends on how many data you're working on. This groupBy is useful for filters in data tables.
If you have to download a zillion of records and filter them, client side filtering is a bad idea. If you have a few thousands of them, it could possibly be the faster solution overall.
Except oddities like C, C++, Perl, PHP, and Go :)