JavaScript Map and Set – Modern Data Collections

// Create a Map
const map = new Map();

// set(key, value) – add or update entries
map.set('name', 'Alice');
map.set(42, 'the answer');
map.set(true, 'boolean key');

const objKey = { id: 1 };
map.set(objKey, 'object as key'); // objects can be keys!

// get(key) – retrieve a value
console.log(map.get('name'));    // 'Alice'
console.log(map.get(42));        // 'the answer'
console.log(map.get(objKey));    // 'object as key'
console.log(map.get('missing')); // undefined

// has(key) – check existence
console.log(map.has(true));      // true
console.log(map.has('absent'));  // false

// size – number of entries (not .length)
console.log(map.size); // 4

// delete(key) – remove one entry
map.delete(42);
console.log(map.size); // 3

// clear() – remove all entries
// map.clear();

// Initialize from array of pairs
const roles = new Map([
  ['Alice', 'admin'],
  ['Bob', 'editor'],
  ['Carol', 'viewer']
]);

const scores = new Map([
  ['Alice', 95],
  ['Bob', 82],
  ['Carol', 88]
]);

// for...of with destructuring (most common)
for (const [name, score] of scores) {
  console.log(`${name}: ${score}`);
}

// forEach
scores.forEach((value, key) => {
  console.log(`${key} scored ${value}`);
});

// keys(), values(), entries()
console.log([...scores.keys()]);    // ['Alice', 'Bob', 'Carol']
console.log([...scores.values()]);  // [95, 82, 88]
console.log([...scores.entries()]); // [['Alice', 95], ['Bob', 82], ...]

// Convert Map → Array of objects
const arr = Array.from(scores, ([name, score]) => ({ name, score }));
// [{ name: 'Alice', score: 95 }, ...]

// Convert plain object → Map
const obj = { x: 1, y: 2 };
const mapFromObj = new Map(Object.entries(obj));
console.log(mapFromObj.get('x')); // 1

const set = new Set();

// add(value)
set.add(1);
set.add(2);
set.add(2); // duplicate – silently ignored
set.add('hello');
set.add({ id: 1 }); // different object reference → added

console.log(set.size); // 4

// has(value)
console.log(set.has(2));       // true
console.log(set.has('world')); // false

// delete(value)
set.delete(1);
console.log(set.size); // 3

// Initialize from array (automatic deduplication!)
const unique = new Set([1, 2, 2, 3, 3, 3, 4]);
console.log(unique.size); // 4

// Set deduplication pattern (most common use case)
const numbers = [1, 2, 2, 3, 3, 4];
const deduped = [...new Set(numbers)];
console.log(deduped); // [1, 2, 3, 4]

// Deduplicate strings
const tags = ['js', 'html', 'js', 'css', 'html'];
const uniqueTags = [...new Set(tags)];
console.log(uniqueTags); // ['js', 'html', 'css']

const colors = new Set(['red', 'green', 'blue']);

// for...of (most common)
for (const color of colors) {
  console.log(color);
}

// forEach
colors.forEach(color => console.log(color));

// Convert to Array
const arr = [...colors];         // spread
const arr2 = Array.from(colors); // Array.from

// Set operations (manual implementations)
const a = new Set([1, 2, 3, 4]);
const b = new Set([3, 4, 5, 6]);

// Union
const union = new Set([...a, ...b]);
console.log([...union]); // [1, 2, 3, 4, 5, 6]

// Intersection
const intersection = new Set([...a].filter(x => b.has(x)));
console.log([...intersection]); // [3, 4]

// Difference (a minus b)
const difference = new Set([...a].filter(x => !b.has(x)));
console.log([...difference]); // [1, 2]

// WeakMap – keys must be objects; values can be anything
const cache = new WeakMap();

function process(obj) {
  if (cache.has(obj)) {
    return cache.get(obj); // return cached result
  }
  const result = /* expensive computation */ { computed: true };
  cache.set(obj, result);
  return result;
}

let domNode = document.getElementById('app');
cache.set(domNode, { clicks: 0 });
// If domNode is set to null and removed from DOM,
// the WeakMap entry is garbage-collected automatically

// WeakSet – stores objects (no primitives), weak references
const seen = new WeakSet();
function visitOnce(obj) {
  if (seen.has(obj)) return 'already visited';
  seen.add(obj);
  return 'first visit';
}

// Key differences from Map/Set:
// - Keys/values must be objects (WeakMap keys, WeakSet values)
// - Not iterable (no forEach, no for...of, no .size)
// - Automatically cleaned up when references are lost