Map, Set and WeakMap: when a plain object is the wrong tool

A plain object works as a lookup table until the keys come from data you do not control. Then three things go wrong:

• Inherited keys. {} inherits from Object.prototype, so lookup["constructor"] already exists — it is the Object function — and "constructor" in lookup is true before anything was stored.
• Keys become strings. obj[1] and obj["1"] are the same entry, and every object used as a key becomes "[object Object]".
• Order is not insertion order. Integer-like keys ("2", "10") are listed first, in numeric order, before every other key.

A Map has none of these problems. Keys can be any value — objects, numbers, NaN — and are compared by SameValueZero (like ===, except NaN equals NaN). Nothing is inherited. Iteration follows insertion order exactly, and size is a property, not a count you compute.

1export function run() {2  const words = ["b", "constructor", "a", "10", "2", "a"];3 4  const firstAt = {};5  words.forEach((w, i) => {6    if (!(w in firstAt)) firstAt[w] = i;7  });8 9  const map = new Map();10  words.forEach((w, i) => {11    if (!map.has(w)) map.set(w, i);12  });13 14  const byObject = {};15  byObject[{ id: 1 }] = "first";16  byObject[{ id: 2 }] = "second";17 18  const numberAndString = new Map([[1, "number"], ["1", "string"]]);19 20  return {21    objectKeyOrder: Object.keys(firstAt),22    objectConstructorEntry: typeof firstAt.constructor,23    mapKeyOrder: [...map.keys()],24    mapConstructorEntry: map.get("constructor"),25    mapSize: map.size,26    objectKeysFromObjects: Object.keys(byObject),27    mapKeepsNumberAndString: numberAndString.size,28  };29}

An object is still the right choice for a record with fixed, known field names — a user, a config — and it serialises to JSON directly, which a Map does not.

Set

A Set holds each value once, compared the same way as Map keys. [...new Set(items)] is the idiomatic de-duplication, and it keeps the first occurrence's order. Two objects with the same contents are still two different values: a Set compares references, not shapes. Recent engines, Node 22 included, also have set algebra built in: union, intersection, difference, symmetricDifference, isSubsetOf, isSupersetOf and isDisjointFrom.

WeakMap

A WeakMap only accepts objects (and non-registered symbols) as keys and holds them weakly: if nothing else references the key object, it can be garbage-collected and its entry disappears. The price is that a WeakMap cannot be iterated and has no size — its contents depend on the garbage collector. Use it to attach data to objects you do not own, such as caching a computed value per DOM node or per request object, without keeping those objects alive. WeakSet is the same idea for membership.

1export function run() {2  const team = new Set(["ana", "gio", "nino"]);3  const onCall = new Set(["gio", "lika"]);4 5  const meta = new WeakMap();6  const request = { url: "/home" };7  meta.set(request, { startedAt: "t0" });8  let primitiveKey;9  try {10    meta.set("/home", {});11  } catch (e) {12    primitiveKey = `${e.name}: ${e.message}`;13  }14 15  return {16    unique: [...new Set([3, 1, 3, 2, 1])],17    nanOnce: new Set([NaN, NaN]).size,18    sameShapeObjects: new Set([{ id: 1 }, { id: 1 }]).size,19    inExactlyOne: [...team.symmetricDifference(onCall)],20    onCallIsSubset: onCall.isSubsetOf(team),21    noOverlapWithInterns: team.isDisjointFrom(new Set(["sandro"])),22    weakGet: meta.get(request),23    primitiveKey,24    weakSize: typeof meta.size,25    weakIterable: typeof meta[Symbol.iterator],26  };27}

Map order makes an LRU cache easy

A least-recently-used cache evicts the entry that was used longest ago. Because a Map iterates in insertion order, map.keys().next().value is the oldest key; to mark a key as just used, delete it and set it again so it moves to the end. That is the exercise.

Common mistakes

• A plain object as a lookup table for data keys. Keys such as "constructor" or "toString" already exist on it, as the first example shows.
• Expecting Set to remove duplicate objects. { id: 1 } twice is two entries; de-duplicate by a key (new Map(items.map((x) => [x.id, x]))).
• map[key] = value on a Map. That sets an ordinary property on the Map object; get, has and size never see it. Use set.
• Updating a Map entry and expecting it to move. set on an existing key keeps its original position; delete it first.

What interviewers ask