json-to-ast

What is json-to-ast?

The json-to-ast npm package is a utility that parses JSON strings into an Abstract Syntax Tree (AST). This can be useful for various tasks such as analyzing, transforming, or validating JSON data programmatically.

What are json-to-ast's main functionalities?

Parsing JSON to AST

This feature allows you to parse a JSON string into an AST. The resulting AST can be used for further analysis or transformation.

const parse = require('json-to-ast');
const jsonString = '{"key": "value"}';
const ast = parse(jsonString);
console.log(JSON.stringify(ast, null, 2));

Handling Errors

This feature demonstrates how to handle errors that may occur during the parsing process. The parser will throw an error if the JSON string is malformed.

const parse = require('json-to-ast');
const jsonString = '{"key": "value"'; // Missing closing brace
try {
  const ast = parse(jsonString);
} catch (error) {
  console.error('Parsing error:', error.message);
}

Customizing Parse Options

This feature shows how to customize the parsing process by providing options. For example, you can include location information in the AST nodes or specify the source of the JSON string.

const parse = require('json-to-ast');
const jsonString = '{"key": "value"}';
const options = { loc: true, source: 'example.json' };
const ast = parse(jsonString, options);
console.log(JSON.stringify(ast, null, 2));

Other packages similar to json-to-ast

esprima

Esprima is a high-performance, standard-compliant ECMAScript parser that can parse JavaScript code into an AST. While json-to-ast is specialized for JSON, Esprima is more general-purpose and can handle full JavaScript syntax.

acorn

Acorn is a small, fast JavaScript parser written in JavaScript. It generates an AST for JavaScript code, similar to Esprima. Acorn is highly modular and can be extended with plugins, making it more versatile for JavaScript parsing compared to json-to-ast, which is focused solely on JSON.

json-ast

json-ast is another package that parses JSON into an AST. It provides similar functionality to json-to-ast but may have different performance characteristics or additional features. It is worth comparing both to see which better fits your needs.

README

JSON AST parser

About usage

  var Parser = require('json-to-ast');

  console.log(new Parser('{"a": 1}'))
  /*
  =>
  {
    type: 'object',
    properties: [
      {
        type: 'property',
        key: {
          type: 'key',
          value: 'a',
          position: {
            start: {
              line: 1,
              column: 2,
              char: 1
            },
            end: {
              line: 1,
              column: 9,
              char: 8
            }
          }
        },
        value: {
          type: 'number',
          value: '1',
          position: {
            start: {
              line: 1,
              column: 11,
              char: 10
            },
            end: {
              line: 1,
              column: 12,
              char: 11
            }
          }
        }
      }
    ],
    position: {
      start: {
        line: 1,
        column: 1,
        char: 0,
      },
      end: {
        line: 1,
        column: 13,
        char: 12
      }
    }
  }
  */

Output

AST format for object

{
  type: 'object',
  properties: [
    {
      type: 'property',
      key: {
        type: 'key',
        value: 'keyName',
        position: {
          start: {
            line: ...,
            column: ...,
            char: ...
          },
          end: {
            line: ...,
            column: ...,
            char: ...
          }
        }
      },
      value: ...
    }
  ],
  position: {...}
}

for array

{
  type: 'array',
  items: [
    ...
  ],
  position: {...}
}

for primitive type

{
  type: 'string|number|true|false|null',
  value: ...,
  position: {...}
}

Try out in online (Look at console)

License

ISC