The Standardization of JSON and Its Effect on Formatting Tools

Key aspects defined by RFC 8259:

• Data Types: Defines the primitive types (string, number, boolean true/false, null) and structured types (object, array).
• Syntax Rules: Specifies the use of braces `` for objects, brackets `[]` for arrays, colons `:` for key-value separation, and commas `,` for element separation.
• String Encoding: Requires strings to be sequence of Unicode characters, wrapped in double quotes (`"`), with specific rules for escaping special characters (like `\"`, `\\`, `\/`, `\b`, `\f`, `\n`, `\r`, `\t`, and `\uXXXX` for Unicode characters).
• Number Format: Specifies how numbers (integers and floating-point) should be represented, explicitly disallowing non-finite values like NaN or Infinity.
• Comments: Explicitly states that comments are NOT allowed in standard JSON.
• Trailing Commas: Explicitly states that trailing commas after the last element in an array or object are NOT allowed.

Impact on JSON Formatting Tools:

• Guaranteed Validity: A primary role of a good formatter is to output *valid* JSON according to the standard. It enforces the syntax rules, preventing errors like mismatched quotes, missing commas, or incorrect nesting.
• Consistent Structure: While whitespace doesn't affect the data itself, the standard defines the basic elements. Formatters add consistent indentation and spacing, making the JSON human-readable and easy to compare, without altering the data or violating the core syntax.
• Reliable Validation: Formatters often include validation checks. Standardization provides a clear definition of "valid," allowing tools to accurately identify and flag syntax errors (like missing brackets, invalid characters, trailing commas, comments, etc.).
• Interoperability: Tools that comply with the standard produce JSON that can be reliably consumed by any other standard-compliant parser or system, regardless of the programming language or platform.
• Predictable Behavior: Developers can trust that formatting a JSON document with a standard-compliant tool will result in a predictable output format and structure (apart from potential key ordering which the spec doesn't strictly define for object equivalence).

The Process:

1. Lexical Analysis: The input string is broken down into tokens (like `, `, `[`, `]`, `:`, `,`, strings, numbers, booleans, null).
2. Syntactic Analysis (Parsing): The parser checks if the sequence of tokens follows the grammar rules specified by RFC 8259 (e.g., an object starts with {, contains zero or more key-value pairs separated by ,, and ends with }, a key-value pair is a string followed by : followed by a value). If syntax errors are found (like a missing comma or a comment), the parser fails, and the tool reports an error.
3. Structure Building: If the parsing is successful, an internal data structure (like an AST or native object/array) is created, representing the hierarchy of the JSON data.
4. Formatting (Serialization): The tool then generates a new string representation of the internal structure. During this process, it adds whitespace (indentation, newlines) according to user-defined or default settings, while ensuring the generated string strictly adheres to the RFC 8259 syntax rules.

Invalid JSON (pre-standard or non-standard features):

{
  // This is a comment - Invalid in standard JSON
  'name': "Alice", // Single quotes for key - Invalid
  "age": 30,
  "isStudent": true, // Trailing comma - Invalid
}

A standard-compliant formatter/validator will flag errors for the comment, single quotes, and trailing comma.

Valid JSON (RFC 8259 compliant):

{
  "name": "Alice",
  "age": 30,
  "isStudent": true
}

This structure adheres strictly to RFC 8259 and will be processed without errors by compliant tools.

Key Differences (JSON vs. JSON5):

• Comments: Allowed in JSON5, forbidden in JSON.
• Trailing Commas: Allowed in JSON5 arrays/objects, forbidden in JSON.
• Unquoted Keys: Allowed in JSON5 (for valid identifiers), must be double-quoted strings in JSON.
• Single Quotes: Allowed for strings in JSON5, must be double quotes in JSON.
• Control Characters: JSON5 allows unescaped newline/paragraph separators, JSON requires escaping.