
`Map` is a keyed collection where keys can be any value, not just strings. `Set` is a collection of unique values where duplicates are ignored automatically. Plain objects coerce all keys to strings; arrays don't deduplicate. Both are built into modern JavaScript.

<ExamplePair>
<ExampleProse>

`Map` works like a dictionary. You add entries with `.set(key, value)`, retrieve them with `.get(key)`, and check for a key with `.has(key)`. Iteration follows insertion order, which plain objects don't guarantee on all runtimes.

</ExampleProse>
<ExampleCode>

```js
const scores = new Map();

scores.set("alice", 95);
scores.set("bob", 87);
scores.set("carol", 92);

console.log(scores.get("alice")); // 95
console.log(scores.has("bob"));   // true
console.log(scores.has("dave"));  // false
console.log(scores.size);         // 3

// Iteration order matches insertion order
for (const [name, score] of scores) {
  console.log(`${name}: ${score}`);
}
// alice: 95
// bob: 87
// carol: 92
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`Map` accepts any value as a key, including objects, functions, and even `NaN`. A plain object coerces every key to a string, so using an object as a key silently collapses all such keys to `"[object Object]"`.

</ExampleProse>
<ExampleCode>

```js
const userCache = new Map();

const user1 = { id: 1, name: "Alice" };
const user2 = { id: 2, name: "Bob" };

userCache.set(user1, { lastSeen: "2026-04-27" });
userCache.set(user2, { lastSeen: "2026-04-26" });

console.log(userCache.get(user1)); // { lastSeen: "2026-04-27" }
console.log(userCache.get(user2)); // { lastSeen: "2026-04-26" }

// The same attempt on a plain object
const plainObj = {};
plainObj[user1] = "alice data";
plainObj[user2] = "bob data";

// Both keys stringify to "[object Object]" and clobber each other
console.log(Object.keys(plainObj)); // ["[object Object]"]
console.log(plainObj[user1]);       // "bob data" - wrong
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`Set` stores unique values in insertion order. Adding a duplicate is silently ignored. Spreading a `Set` back into an array (`[...new Set(arr)]`) is the shortest idiom for deduplicating.

</ExampleProse>
<ExampleCode>

```js
const tags = new Set();

tags.add("javascript");
tags.add("web");
tags.add("javascript"); // duplicate - ignored
tags.add("node");

console.log(tags.size);              // 3
console.log(tags.has("javascript")); // true
console.log(tags.has("python"));     // false

tags.delete("web");
console.log([...tags]); // ["javascript", "node"]

// One-liner dedup of an array
const nums = [1, 2, 3, 2, 1, 4];
const unique = [...new Set(nums)];
console.log(unique); // [1, 2, 3, 4]
```

</ExampleCode>
</ExamplePair>

<InProduction>
Reach for `Map` whenever keys aren't string literals or insertion order matters, and reach for `Set` whenever you'd otherwise write `arr.includes(x)` inside a loop (a linear scan each call). A `Set.has()` check is O(1). Plain objects also walk the prototype chain, so keys like `toString` or `constructor` collide with inherited properties - `Map` has no such issue.
</InProduction>


Keyed collections that accept any value as a key (Map) and deduplicated collections (Set) - when to reach for them instead of plain objects and arrays.

Maps and Sets


`Date` represents a single moment in time as the number of milliseconds since January 1, 1970 UTC (the Unix epoch). The object itself carries no timezone. The browser or runtime locale is only applied when you format the date as human-readable text.

<ExamplePair>
<ExampleProse>

You create a `Date` with `new Date()` for the current moment, `new Date(milliseconds)` for a specific instant, or `new Date("YYYY-MM-DD")` for an ISO date string. ISO 8601 strings are safe to parse across environments. Locale-formatted strings like `"April 27, 2026"` are not. `.getTime()` returns the raw epoch millisecond value.

</ExampleProse>
<ExampleCode>

```js
const now = new Date();
console.log(now);              // e.g. 2026-04-27T12:34:56.789Z

const fromMs = new Date(0);
console.log(fromMs);           // 1970-01-01T00:00:00.000Z

const fromISO = new Date("2026-04-27");
console.log(fromISO.getTime()); // epoch milliseconds for that date

// Avoid locale-formatted strings - parsing varies by runtime
const risky = new Date("April 27, 2026"); // not reliable everywhere
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`<` and `>` work between two `Date` objects because JavaScript coerces them to numbers (epoch ms) for the comparison. `===` does not work for equality because it compares object identity. Two separate `Date` objects representing the same moment are never `===` each other.

</ExampleProse>
<ExampleCode>

```js
const a = new Date("2026-04-27");
const b = new Date("2026-04-27");

console.log(a === b); // false - different objects in memory
console.log(a < b);   // false
console.log(a > b);   // false

// Compare for equality using epoch milliseconds
console.log(a.getTime() === b.getTime()); // true

const later = new Date("2026-12-31");
console.log(a < later); // true
console.log(a > later); // false
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`Intl.DateTimeFormat` formats a date for a specific locale and timezone - use it for what users read. `.toISOString()` produces a UTC string that is safe for storage, logs, and APIs. The two serve different purposes: one for humans, one for machines.

</ExampleProse>
<ExampleCode>

```js
const date = new Date("2026-04-27T15:30:00Z");

// For users: locale-aware output
const formatter = new Intl.DateTimeFormat("en-US", {
  year: "numeric",
  month: "long",
  day: "numeric",
  timeZone: "America/New_York",
});
console.log(formatter.format(date)); // "April 27, 2026"

// Short form
console.log(date.toLocaleDateString("en-US")); // "4/27/2026"

// For storage and APIs: UTC, always consistent
console.log(date.toISOString()); // "2026-04-27T15:30:00.000Z"
```

</ExampleCode>
</ExamplePair>

<InProduction>
Store epoch milliseconds or ISO strings in databases and APIs, never wall-clock strings like `"April 27, 2026"` - those are ambiguous outside the locale that produced them. `Date` is mutable, and `===` between two instances is always `false`, so treat dates as values you compare with `.getTime()`. For anything beyond rendering today's date (date arithmetic, relative formatting, timezone logic) reach for date-fns or Luxon, or wait for the `Temporal` API once your runtime ships it.
</InProduction>


Creating, comparing, and formatting dates with the built-in Date object, and why you should store epoch milliseconds or ISO strings and format at the edge.

Dates


A recursive function is one that calls itself. Every recursion needs a base case (the condition where the function stops calling itself) and a recursive step that shrinks the problem toward that base case.

<ExamplePair>
<ExampleProse>

Factorial is the textbook example. The base case is `n <= 1` (return 1). The recursive step multiplies `n` by the factorial of `n - 1`, which is a smaller version of the same problem.

</ExampleProse>
<ExampleCode>

```js
function factorial(n) {
  if (n <= 1) return 1;       // base case: stop here
  return n * factorial(n - 1); // recursive step: smaller problem
}

console.log(factorial(1)); // 1
console.log(factorial(4)); // 24  (4 * 3 * 2 * 1)
console.log(factorial(6)); // 720

// Call stack for factorial(4):
// factorial(4) -> 4 * factorial(3)
//                     -> 3 * factorial(2)
//                            -> 2 * factorial(1)
//                                   -> 1  (base case)
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Recursion is the natural shape for traversing nested structures like trees or deeply nested objects. Each level of nesting becomes one level of recursion. An iterative loop would need to track depth manually.

</ExampleProse>
<ExampleCode>

```js
const fileTree = {
  name: "src",
  children: [
    { name: "index.js", children: [] },
    {
      name: "utils",
      children: [
        { name: "math.js", children: [] },
        { name: "string.js", children: [] },
      ],
    },
  ],
};

function printTree(node, depth = 0) {
  const indent = "  ".repeat(depth);
  console.log(indent + node.name);
  for (const child of node.children) {
    printTree(child, depth + 1); // same function, smaller problem
  }
}

printTree(fileTree);
// src
//   index.js
//   utils
//     math.js
//     string.js
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

For bounded inputs, an iterative loop and a recursive function are equally readable. The loop version avoids function call overhead and is sometimes clearer when the problem is simply counting down.

</ExampleProse>
<ExampleCode>

```js
// Recursive factorial
function factorialRecursive(n) {
  if (n <= 1) return 1;
  return n * factorialRecursive(n - 1);
}

// Iterative equivalent - no stack frames, same result
function factorialIterative(n) {
  let result = 1;
  for (let i = 2; i <= n; i++) {
    result *= i;
  }
  return result;
}

console.log(factorialRecursive(6));  // 720
console.log(factorialIterative(6));  // 720
```

</ExampleCode>
</ExamplePair>

<InProduction>
V8 does not optimize tail calls, so every recursive call adds a stack frame. In practice, Node.js and most browsers throw a `RangeError: Maximum call stack size exceeded` at around 10,000 to 15,000 frames. If the input comes from a user (a deeply nested JSON document, a large file tree, user-submitted HTML), recursion will blow the stack. Convert to an iterative approach using an explicit stack (`const stack = [root]; while (stack.length) { ... }`) whenever depth is unbounded. Recursion is safe for compile-time-bounded structures like AST visitors over a grammar you control.
</InProduction>


Functions that call themselves - the natural fit for tree traversal, with a hard stack limit that matters on user-supplied data.