JSON.parse and JSON.stringify.
Read and write JSON.

What the round-trip preserves:

✅ Objects, arrays, strings, numbers, booleans, null
✅ Nested structures
✅ Object property order (in modern browsers)

What the round-trip does NOT preserve:

❌ undefined (dropped from objects, becomes null in arrays)
❌ functions (dropped entirely)
❌ Symbol keys (dropped)
❌ BigInt (throws)
❌ Dates (converted to ISO strings)
❌ Map, Set (become {})
❌ RegExp (becomes {})
❌ Class instances (lose their prototype)
❌ Circular references (throw)
❌ NaN, Infinity (become null)

The most important asymmetry:

  const obj = { d: new Date() };
  const str = JSON.stringify(obj);
  // '{"d":"2026-11-07T12:00:00.000Z"}'
  const back = JSON.parse(str);
  // { d: '2026-11-07T12:00:00.000Z' }  ← string, not Date

  Date → string via stringify.
  string does not become Date via parse.
  The asymmetry is by design — JSON has no Date.

For lossless serialization, use a library:
  superjson, devalue, flatted — all preserve
  Dates, Maps, Sets, and other types.

Why JSON.parse throws:

JSON is a strict format.
  → Double quotes for strings: {"key":"value"}
  → No trailing commas: {"a":1,"b":2} not {"a":1,"b":2,}
  → No comments
  → No single quotes
  → No unquoted keys
  → No functions, undefined, Date, Map

If the input is any of these, JSON.parse throws:
  → JavaScript object literal (single quotes)
  → HTML (a 404 page served with 200 status)
  → Empty string
  → Already-parsed object (parse expects a string)
  → Truncated response (network dropped mid-stream)

The most common production bug:

❌ const res = await fetch(url);
   const data = await res.json();   // throws on 404
   
✅ const res = await fetch(url);
   if (!res.ok) throw new Error(res.status);
   const data = await res.json();

Always check res.ok before .json().
A 404 returns HTML, and .json() throws on HTML.

For localStorage:

❌ const data = JSON.parse(localStorage.getItem('key'));
   // throws if item is null

✅ const data = safeParse(localStorage.getItem('key'));
   // or check for null first

localStorage.getItem returns null for missing keys.
JSON.parse(null) throws.

Rule: wrap JSON.parse in try/catch,
      or know that the source is always valid.
      The second is rare — data from the network,
      from localStorage, from user input —
      is rarely guaranteed.

The replacer signature:

  JSON.stringify(value, (key, val) => transformedVal)
  JSON.stringify(value, (key, val) => transformedVal, indent)

Called for every key-value pair in the object.
The `key` is the property name, or '' for the root.
Return the transformed value, or undefined to omit.

Common uses:

✅ Convert Dates to a custom format
✅ Omit sensitive fields (passwords, tokens)
✅ Convert Sets and Maps to arrays
✅ Convert BigInt to strings
✅ Redact circular references

The reviver signature:

  JSON.parse(str, (key, val) => transformedVal)

Called for every parsed key-value pair.
Return the transformed value, or undefined to omit.

Common uses:

✅ Convert date strings back to Date objects
✅ Restore Sets and Maps
✅ Hydrate class instances
✅ Validate the parsed shape

The two together give you lossless serialization:

  stringify(obj, replacer)
  → parse(str, reviver)

For complex types (Map, Set, custom classes),
use a library: superjson, devalue, or flatted.
They handle the edge cases (nested types,
circular references, type collisions) that
custom replacers often miss.