JSON

Serializes a number to its JSON text. Integers and floats both round-trip through the type-directed path.

string — The JSON representation.

const n: number = 42
console.log(JSON.stringify(n))       // 42

Serializes a string with the JSON escaping rules (double-quoted, embedded quotes escaped).

string — The quoted, escaped JSON string.

const esc: string = "say 'hi'"
console.log(JSON.stringify(esc))     // 'say \"hi\"'

Serializes a numeric array to a JSON array. An empty array renders as [].

string — A JSON array.

const nums: number[] = [1, 2, 3]
console.log(JSON.stringify(nums))    // [1,2,3]

Serializes a string array, each element quoted and escaped.

string — A JSON array of strings.

const words: string[] = ['foo', 'bar', 'baz']
console.log(JSON.stringify(words))   // ['foo','bar','baz']

Serializes an object's fields, including nested object literals. Date fields serialize as an ISO string via their own toISOString path.

string — A JSON object.

const person = { name: 'Alexandros', address: { city: 'Thessaloniki', zip: 10001 } }
console.log(JSON.stringify(person))
// {"name":"Alexandros","address":{"city":"Thessaloniki","zip":10001}}

Serializes a boolean array to true/false JSON literals.

string — A JSON array of booleans.

const flags: boolean[] = [true, false, true]
console.log(JSON.stringify(flags))   // [true,false,true]

Serializes an array of objects, each object rendered by its field set.

string — A JSON array of objects.

const points: Point[] = [{ x: 1, y: 2 }, { x: 3, y: 4 }]
console.log(JSON.stringify(points))  // [{"x":1,"y":2},{"x":3,"y":4}]

Pretty-prints with an indent unit and a space after each colon. A numeric space indents with N spaces (capped at 10); a string space is used literally as the indent unit (its first 10 characters). The space and a replacer — a function called with each key and value, or a property list — may be values known only at run time. Empty containers stay inline even when pretty-printing.

string — Indented JSON text.

console.log(JSON.stringify(user, null, 2))
// {
//   "name": "bob",
//   "active": true,
//   ...
// }

A class with a toJSON() method serializes its result instead of its own fields, matching JS — same override dispatch as toString(). A toJSON() returning its own type is bounded against compile-time infinite recursion. Date keeps its own toISOString-based path rather than being unified.

string — The JSON of the toJSON() result.

class Money {
  amount: number = 42
  currency: string = 'EUR'
  toJSON(): string { return this.amount + this.currency }
}
console.log(JSON.stringify(new Money()))              // "42EUR"

A mixed literal is an array of the union of its element types, as TypeScript infers it; each element serializes by its run-time kind, class instances and plain objects included.

class P { x = 1 }
console.log(JSON.stringify([new P(), 2, null]))   // [{"x":1},2,null]

Parses a numeric JSON string. Integers go through atoll, floats (including a float64/float32-typed variable) through strtod on the node's raw lexeme, via the type-directed projection.

number — The parsed number.

const parsed: number = JSON.parse('123')
console.log(parsed)                  // 123

Type-directed projection off the parse tree: nested objects, array-typed fields, and object-array fields (Item[]) all project through one path. A nullable-scalar field keeps its null-vs-value boxing; a missing field falls back to its type's default.

T — An instance of the annotated target type.

interface Member { name: string; addr: Addr; tags: string[] }
const m: Member = JSON.parse('{"name":"Nikos","addr":{"city":"Thessaloniki","zip":54600},"tags":["admin","dev"]}')
console.log(m.addr.city)            // Thessaloniki

Projects the tree's array node into the standard {ptr,i64} aggregate, reusing the array-literal build path, including object and nested arrays.

T[] — The parsed array in an annotated position.

const members: Member[] = JSON.parse('[{"name":"A","addr":{"city":"X","zip":1},"tags":[]},{"name":"B","addr":{"city":"Y","zip":2},"tags":["x"]}]')
console.log(members.length)         // 2

A real recursive-descent parser builds and validates a tagged value tree. Strict JSON only (double quotes, no trailing commas/leading zeros/trailing junk), with \uXXXX + surrogate decoding and a 512-deep runtime depth guard on untrusted input. A malformed input throws a catchable SyntaxError; Response.json() inherits the same parser.

T — The parsed value, or throws SyntaxError.

try {
  const bad: number = JSON.parse("{oops}")
} catch (e) {
  console.log(e.name)                // SyntaxError
}

Untyped (or any-annotated) JSON.parse keeps the whole tree as dynamic values: objects become runtime property bags, arrays real dynamic arrays with .length, index reads/writes, and for...in — so member chains like data.server.ports[0] work without a declared shape. JSON.stringify serializes the dynamic tree back (round-trip clean): undefined values are skipped in objects and become null in arrays, and a circular structure throws the Node-matching TypeError. The space argument pretty-prints a dynamic value byte-identically to the typed path. Operations beyond property access on the dynamic values follow the normal any limits until narrowed.