When would you reach for Map.groupBy() instead of Object.groupBy(), and what problem does it solve with non-string keys?

Q: When would you reach for Map.groupBy() instead of Object.groupBy(), and what problem does it solve with non-string keys?

**Target Audience:** Engineers preparing for JavaScript fundamentals interviews. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every claim below was actually run with real, distinct object keys — not asserted from documentation. ## 1. Why This Even Matters — A Story First Sorting mail into pigeonholes labeled by the SENDER'S NAME works fine when every sender's name is unique text. But if you tried to label pigeonholes by handing the postal worker each sender's actual PHOTOGRAPH and asking them to label the slot by writing "a person" on it every single time, every photograph would land in the exact same "a person" slot — the photographs never got compared by who they actually are, only by the same generic label written on all of them. That is exactly what happens when `Object.groupBy()` is given non-string keys: every distinct object gets the identical generic label, `"[object Objec

Tricky JavaScript Scenario #42: Map.groupBy | Interview Question

The problem

Question presented to candidate: "You are grouping calendar events by the Date object representing their start day. You reach for Object.groupBy() and every event ends up in ONE group. What went wrong, and how would you fix it?"

What a strong answer should cover:

📌 Interview term: the real, direct answer to the prompt — verified directly: Object.groupBy() uses its grouping key as a real OBJECT property key, which means any non-string, non-symbol key (like a Date object, or any plain object) is genuinely coerced to a string first — and every distinct object genuinely coerces to the SAME string, "[object Object]" — silently merging every group into one.
📌 Interview term: Map.groupBy() — the real fix — groups into a genuine Map, which (covered in more depth in this bank's own dedicated Map-vs-object question) can use ANY value, including an object or a Date instance, as a real, distinct key with no coercion at all — verified directly, two distinct object keys stayed genuinely separate, with correct per-key group counts.
📌 Interview term: the real decision rule — a precise answer names the actual decision criterion: if the grouping key is (or ever COULD be) a non-string, non-symbol value — an object, a Date, a class instance — reach for Map.groupBy(); if the key is always a plain string (a status label, a category name), Object.groupBy()'s plain-object result is simpler to consume with dot-access and JSON.stringify.
A precise answer names that this bank's own dedicated Object.groupBy-vs-Map.groupBy question covers the core ES2024 mechanism and null-prototype-result distinction in depth — this question's own value-add is the specific, real, silent-data-loss FAILURE MODE with non-string keys, and the practical "which one do I reach for" decision it drives.
A precise answer names the fix does not require restructuring the grouping logic at all — only swapping Object.groupBy(items, fn) for Map.groupBy(items, fn), since both share an identical callback signature.

Clarifying questions expected:

None — this is a definitional/practical question; directly diagnosing the prompt's own described bug (verified via real reproduction) is the strong signal.

Code / implementation expected: Yes — a real, direct reproduction of the merging bug with distinct object keys, and the Map.groupBy() fix, both genuinely executed.

es2024
tricky
real-world

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals interviews. Difficulty: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every claim below was actually run with real, distinct object keys — not asserted from documentation.

1. Why This Even Matters — A Story First

Sorting mail into pigeonholes labeled by the SENDER'S NAME works fine when every sender's name is unique text. But if you tried to label pigeonholes by handing the postal worker each sender's actual PHOTOGRAPH and asking them to label the slot by writing "a person" on it every single time, every photograph would land in the exact same "a person" slot — the photographs never got compared by who they actually are, only by the same generic label written on all of them. That is exactly what happens when Object.groupBy() is given n

The solution is hidden so you can try first

6 min read · 8 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: Object.groupBy() silently merges distinct object keys into one group; Map.groupBy() keeps them genuinely distinct — verified directly