Map vs Object — when do you use which?

Object and Map both store key-value pairs, but they have different design contracts. Junior code uses Object for everything; the senior signal is knowing when Map is the better choice and why.

Key differences.

When to use Map.

• Dictionaries with arbitrary keys — especially keys you don't control (user-provided strings could collide with __proto__, constructor).
• Object keys — caching/memoization keyed by an object reference, WeakMap for the same with GC.
• Frequent add/remove — Map is implemented for this; Object reshaping triggers V8 deopts.
• Insertion-order matters always — Object's integer-key reordering surprises people: {2:"a", 1:"b"} iterates 1,2.
• You need .size cheaply — Map gives it in O(1).

When to use Object.

• Records with a known shape — { id, name, email }. V8 generates hidden classes; access is faster.
• JSON I/O — APIs and storage round-trip Object naturally.
• Function arguments / config bags — destructuring works directly.
• Shorthand syntax — { a, b } is more concise than new Map([["a", a], ["b", b]]).

The prototype-pollution gotcha.

const cache = {};
cache["__proto__"] = "owned";       // doesn't actually set the key — modifies prototype
cache["hasOwnProperty"] = false;    // breaks future calls if you do cache.hasOwnProperty(k)

Defenses: Object.create(null) (no prototype), Object.hasOwn(obj, key) (modern), or just use Map which has no prototype.

Iteration:

// Map (clean)
for (const [k, v] of map) { ... }

// Object (need to choose what you want)
for (const k of Object.keys(obj)) { ... }
for (const [k, v] of Object.entries(obj)) { ... }

Performance reality. For 100k entries with frequent add/delete, Map is meaningfully faster than Object. For 100 stable-shape records, Object wins on memory and access. Don't optimize without a profile.

Sets vs Map. Set is the value-only equivalent of Map. Use it for "is this in the collection?" — replaces ad-hoc { [key]: true } patterns.

Weak variants. WeakMap / WeakSet hold object keys weakly so they can be garbage-collected. Useful for: tagging DOM elements without leaking when removed, caches keyed by component instance, private-data patterns. Trade-off: not iterable, no .size.

Decision shortcut.

• Plain record? → Object.
• Hash table / dictionary with dynamic keys? → Map.
• Object as key, want GC? → WeakMap.
• Set membership? → Set.