Map
Toolbox

const prices = new Map();

prices.set("tea", 20);           // add a key and its value
prices.set("coffee", 45).set("juice", 60); // set gives the map back, so you can chain

console.log(prices.get("coffee"));   // read a value
console.log(prices.get("soda"));     // a missing key gives undefined
console.log(prices.has("tea"));      // check a key exists
console.log(prices.size);            // how many entries
console.log(prices);

// start with a list of [key, value] pairs
const roles = new Map([
  ["asha", "admin"],
  ["ravi", "editor"],
]);
console.log(roles.get("asha"), roles.size);

// keys can be any type, not just text
const labels = new Map([
  [1, "number one"],
  ["1", "text one"],
  [true, "a boolean"],
]);
console.log(labels.get(1), "|", labels.get("1"), "|", labels.get(true));

// an object turns every key into text
const obj = {};
obj[1] = "number";
obj["1"] = "text";           // overwrites, because 1 became "1"
console.log(Object.keys(obj), obj[1]);

// a map keeps 1 and "1" apart
const map = new Map();
map.set(1, "number").set("1", "text");
console.log(map.size, map.get(1), map.get("1"));

// objects as keys: the object version breaks, the map works
const user = { id: 7 };
const seen = {};
seen[user] = "visited";
console.log(Object.keys(seen));      // the key became "[object Object]"
const visits = new Map([[user, "visited"]]);
console.log(visits.get(user));

const cart = new Map([["pen", 2], ["book", 1]]);

cart.set("pen", 5);              // same key again: the value is replaced
console.log(cart.get("pen"), cart.size);

console.log(cart.delete("book")); // true: it was there and is now gone
console.log(cart.delete("bag"));  // false: nothing to remove
console.log(cart);

cart.clear();                    // empty the whole map
console.log(cart.size);

const scores = new Map([["asha", 91], ["ravi", 78], ["meera", 85]]);

// for...of gives [key, value] pairs, in the order you added them
for (const [name, score] of scores) {
  console.log(`${name}: ${score}`);
}

console.log([...scores.keys()]);     // just the keys
console.log([...scores.values()]);   // just the values

// forEach hands you the value first, then the key
scores.forEach((score, name) => {
  if (score > 80) console.log(name, "passed with", score);
});

const settings = { theme: "dark", size: 16 };

const asMap = new Map(Object.entries(settings));   // object to map
console.log(asMap.get("theme"));

const backToObject = Object.fromEntries(asMap);   // map to object
console.log(backToObject);

console.log([...asMap]);                           // map to array of pairs

// JSON does not understand maps
console.log(JSON.stringify(asMap));                // {} : the data is lost
console.log(JSON.stringify([...asMap]));           // save it as pairs instead
const restored = new Map(JSON.parse('[["theme","dark"],["size",16]]'));
console.log(restored.get("size"));

const words = "the cat saw the dog and the cat ran".split(" ");

const counts = new Map();
for (const word of words) {
  counts.set(word, (counts.get(word) ?? 0) + 1);   // start at 0 if new
}
console.log(counts.get("the"), counts.get("cat"), counts.get("bird"));

// sort by count, biggest first, and keep the top three
const top = [...counts].sort((a, b) => b[1] - a[1]).slice(0, 3);
console.log(top);

const orders = [
  { id: 1, status: "paid" },
  { id: 2, status: "pending" },
  { id: 3, status: "paid" },
];

// Map.groupBy puts each item in a bucket named by what your helper returns
const byStatus = Map.groupBy(orders, (o) => o.status);
console.log([...byStatus.keys()]);
console.log(byStatus.get("paid").map((o) => o.id));

// a WeakMap only takes objects as keys, and forgets them
// when nothing else in your program is using that object
const lastSeen = new WeakMap();

let session = { user: "asha" };
lastSeen.set(session, "10:42");
console.log(lastSeen.get(session), lastSeen.has(session));

try {
  lastSeen.set("asha", "10:42");      // text is not allowed as a key
} catch (err) {
  console.log(err.constructor.name + ":", err.message);
}

session = null;  // the entry can now be cleaned up by the garbage collector
console.log(typeof lastSeen.size, typeof lastSeen.keys); // no size, no looping

// a small "least recently used" cache that keeps only the newest items
class LruCache {
  constructor(limit) {
    this.limit = limit;
    this.items = new Map();          // a map remembers insertion order
  }
  get(key) {
    if (!this.items.has(key)) return undefined;
    const value = this.items.get(key);
    this.items.delete(key);          // move it to the end: most recent
    this.items.set(key, value);
    return value;
  }
  set(key, value) {
    this.items.delete(key);
    this.items.set(key, value);
    if (this.items.size > this.limit) {
      const oldest = this.items.keys().next().value; // the first key is the oldest
      this.items.delete(oldest);
    }
  }
}

const cache = new LruCache(2);
cache.set("user:1", "Asha");
cache.set("user:2", "Ravi");
cache.get("user:1");                 // user:1 is now the most recent
cache.set("user:3", "Meera");        // full, so the oldest (user:2) goes
console.log([...cache.items.keys()]);
console.log(cache.get("user:2"), cache.get("user:3"));