Collections And Typed Arrays

// object as a map vs Map, for dynamic string keys
const counts = {}; for (const w of words) counts[w] = (counts[w] ?? 0) + 1
// each new key: internalise w (hash + table probe), then a transition or (soon) dictionary mode. ~1000 distinct keys → dictionary
// each read: internalise w again, hash lookup in the NameDictionary. plus: "constructor", "__proto__" are keys you did not expect

const counts = new Map(); for (const w of words) counts.set(w, (counts.get(w) ?? 0) + 1)
// each op: hash w (cached on the string after the first time), bucket, chain. no internalisation, no shape, no prototype pollution

// object-as-map is right when: keys are a known small set (a record), or you need JSON.stringify directly, or it is a literal config
// Map is right when: keys are dynamic, many, deleted, or objects; you need insertion order or size; or it is hot

// an LRU cache in one Map, because deletion + reinsertion moves the entry to the end of the order
class LRU {
  #map = new Map(); #max
  constructor(max) { this.#max = max }
  get(k) { if (!this.#map.has(k)) return undefined; const v = this.#map.get(k); this.#map.delete(k); this.#map.set(k, v); return v }
  set(k, v) { if (this.#map.has(k)) this.#map.delete(k); else if (this.#map.size >= this.#max) this.#map.delete(this.#map.keys().next().value); this.#map.set(k, v) }
}
// cost per get: has + get + delete + set = 4 hash ops; the delete leaves a hole that the next rehash compacts.
// for a hot path with a small max, a ring buffer over two typed arrays (keys as ids) beats it; for everything else this is fine.