Understanding the Official JSON Specification (ECMA-404)

Key aspects defined by ECMA-404:

• The basic structure of JSON data (objects and arrays).
• The set of allowed primitive values (strings, numbers, boolean literals `true`, `false`, and `null`).
• Strict rules for string representation (using double quotes).
• Strict rules for number representation.
• Rules for whitespace handling.

Benefits of adhering to ECMA-404:

• Interoperability: Data produced according to the spec can be reliably consumed by any spec-compliant parser.
• Predictability: You know exactly how your data will be interpreted.
• Error Prevention: Avoids subtle bugs caused by parsers handling non-standard syntax differently.
• Security: Lenient parsers can sometimes be exploited. Strict parsing is generally safer.

Syntax Rules:

• Starts with an opening curly brace { and ends with a closing curly brace }.
• Key/value pairs are separated by commas ,.
• Each key/value pair is separated by a colon :.
• Keys must be strings (enclosed in double quotes).
• Values can be a string, number, object, array, boolean (true or false), or null.
• Whitespace can appear before or after { }, , and :.

Example:

{
  "name": "Alice",
  "age": 30,
  "isStudent": false,
  "courses": ["Math", "Physics"],
  "address": {
    "street": "123 Main St",
    "city": "Anytown"
  },
  "spouse": null
}

Syntax Rules:

• Starts with an opening square bracket [ and ends with a closing square bracket ].
• Values are separated by commas ,.
• Values can be a string, number, object, array, boolean (true or false), or null.
• Whitespace can appear before or after [ ], and ,.

Example:

[
  "apple",
  123,
  true,
  { "id": 1 },
  [5, 6],
  null
]

• string: A sequence of zero or more Unicode characters, enclosed in double quotes. Specific characters (like double quote, backslash, control characters) must be escaped using a backslash \.
• number: A double-precision floating-point number in the IEEE 754 standard. Includes integers, decimals, and optionally an exponent. Does *not* include NaN or Infinity.
• object: As defined above.
• array: As defined above.
• true: The boolean true literal.
• false: The boolean false literal.
• null: The null literal.

What is NOT valid JSON according to ECMA-404:

• Comments: Single-line (`//`) or multi-line (`/* ... */`) comments are not allowed.

  {
    "name": "Test", // This comment is invalid
    "value": 123
  }

• Trailing Commas: A comma after the last element in an object or array is not allowed.

  {
    "item1": 1,
    "item2": 2, // Trailing comma invalid
  }

• Single Quotes: Both keys and string values must be enclosed in double quotes `"` NOT single quotes `'`.

  {
    'name': 'Charlie' // Single quotes invalid for key and value
  }

• Unquoted Keys: Object keys must always be strings (quoted).

  {
    name: "David" // Unquoted key invalid
  }

• Undefined or NaN/Infinity: These JavaScript specific values are not valid JSON numbers or literals. Only `null`, `true`, `false` are allowed literals beyond strings and numbers.

  {
    "value1": undefined, // Invalid
    "value2": NaN,       // Invalid
    "value3": Infinity   // Invalid
  }

Note: While ECMA-404 does not specify a maximum nesting depth or size, practical limitations exist based on parser implementations and available memory.

• Online JSON Validators: Many websites provide tools to paste your JSON and check its validity against the standard.
• Programming Language Parsers: Standard JSON parsing libraries in most languages (e.g., Python's `json`, JavaScript's `JSON.parse`) are designed to be spec-compliant and will throw errors on invalid JSON.
• Command-line Tools: Utilities like `jq` or others specifically designed for JSON manipulation and validation can check syntax.
• IDEs and Text Editors: Many modern editors have built-in JSON syntax highlighting and validation based on the standard.

• ECMA-404: Defines the *syntax* of a valid JSON document. It tells you *if* a string of text is structurally correct JSON.
• JSON Schema: Defines the *structure and data types* of a JSON document. It tells you *if* a valid JSON document conforms to a specific model or contract (e.g., "this object must have a key 'age' whose value is an integer").

Think of ECMA-404 as grammar rules for sentences, while JSON Schema defines the expected content and types within those sentences for a specific purpose. You need a document that is syntactically valid JSON (per ECMA-404) before you can validate it against a JSON Schema.