estraverse vs esprima vs acorn-walk vs estree-walker vs recast
JavaScript AST (Abstract Syntax Tree) Manipulation Comparison
Search packages..
1 Year
estraverseesprimaacorn-walkestree-walkerrecastSimilar Packages:
What's JavaScript AST (Abstract Syntax Tree) Manipulation?

JavaScript AST (Abstract Syntax Tree) Manipulation libraries provide tools for analyzing, transforming, and generating JavaScript code by working with its syntactic structure. These libraries parse JavaScript code into a tree-like representation (the AST), allowing developers to traverse, modify, or generate code programmatically. They are useful for tasks like code analysis, linting, transpiling, and building tools like formatters and minifiers. Each library has its own strengths, such as performance, ease of use, and support for specific AST specifications, making them suitable for different use cases in the JavaScript ecosystem.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
estraverse126,869,365960-394 years agoBSD-2-Clause
esprima74,535,7607,105-1487 years agoBSD-2-Clause
acorn-walk57,183,30611,02052.3 kB1710 months agoMIT
estree-walker52,358,99641417.6 kB112 years agoMIT
recast15,720,3225,146246 kB2075 months agoMIT
Feature Comparison: estraverse vs esprima vs acorn-walk vs estree-walker vs recast

AST Traversal

  • estraverse:

    estraverse is designed specifically for traversing ESTree-compliant ASTs. It offers a comprehensive API for both simple and complex traversals, including the ability to skip nodes, replace them, or perform actions at specific points in the traversal. Its flexibility makes it suitable for a wide range of traversal tasks.

  • esprima:

    esprima focuses on parsing JavaScript code and generating a detailed AST. While it does not provide built-in traversal methods, its AST structure is well-defined and can be easily traversed using external libraries like estraverse or acorn-walk. This separation of concerns allows for more specialized traversal implementations.

  • acorn-walk:

    acorn-walk provides a simple and efficient way to traverse ASTs generated by Acorn. It supports both pre-order and post-order traversal, allowing you to visit nodes in a flexible manner. The API is straightforward, making it easy to integrate into projects that require basic tree walking.

  • estree-walker:

    estree-walker provides a lightweight and efficient way to traverse ESTree-compliant ASTs. It uses a simple walker pattern that allows for easy customization of traversal behavior. The library is minimalistic, which makes it fast and easy to use for projects that require quick and straightforward tree walking.

  • recast:

    recast integrates AST traversal with code transformation and pretty-printing. It allows you to traverse the AST while also modifying it and generating new code from the transformed tree. This dual functionality makes it a powerful tool for refactoring and transforming JavaScript code while maintaining its original structure.

Code Transformation

  • estraverse:

    estraverse is a traversal library that facilitates code transformation by allowing you to visit and modify nodes in the AST. While it does not perform transformations itself, it provides the necessary hooks and structure to implement custom transformations, making it a valuable tool for developers working on AST manipulation and code refactoring projects.

  • esprima:

    esprima focuses on parsing and generating ASTs rather than transforming them. It provides a detailed representation of the code structure, which can be used by other libraries for transformation tasks. Esprima’s role is to provide accurate and compliant ASTs that can be manipulated by external tools and frameworks.

  • acorn-walk:

    acorn-walk is primarily a traversal library and does not provide built-in support for code transformation. However, it allows you to visit and manipulate nodes during traversal, enabling custom transformations to be implemented as needed. For more complex transformations, you may need to combine it with other libraries that handle AST manipulation.

  • estree-walker:

    estree-walker is designed for traversal and does not include built-in transformation capabilities. However, it allows for easy manipulation of nodes during traversal, enabling developers to implement custom transformations as they walk the tree. Its simplicity and efficiency make it a good choice for projects that require lightweight transformation logic.

  • recast:

    recast excels at code transformation while preserving the original formatting. It allows you to modify the AST and generate new code from it, making it ideal for refactoring tasks. Recast handles the complexities of maintaining code style and structure during transformations, which is a significant advantage for projects that require high-quality output.

Performance

  • estraverse:

    estraverse is designed to be efficient for traversing ESTree-compliant ASTs, but its performance can vary based on the complexity of the traversal and the number of nodes being processed. It is generally fast for most use cases, but developers should be mindful of potential performance bottlenecks when implementing complex traversal logic.

  • esprima:

    esprima is known for its fast parsing capabilities, but the performance of AST traversal and manipulation depends on how the generated AST is used. Esprima is optimized for quick parsing, making it a good choice for applications that need to analyze code quickly. However, for large-scale AST manipulation, performance will also depend on the algorithms and techniques used by external libraries.

  • acorn-walk:

    acorn-walk is lightweight and optimized for performance, especially when traversing ASTs generated by the Acorn parser. Its minimalistic design ensures that traversal operations are fast and efficient, making it suitable for applications where performance is critical.

  • estree-walker:

    estree-walker is designed for performance, with a focus on minimal overhead during traversal. Its lightweight nature makes it one of the fastest options for walking ESTree-compliant ASTs, making it ideal for applications that require quick and efficient tree traversal without unnecessary complexity.

  • recast:

    recast is more resource-intensive than simple traversal libraries due to its capabilities for parsing, transforming, and pretty-printing code. While it provides powerful transformation features, developers should be aware of the potential performance implications when working with large codebases or performing complex transformations.

Ease of Use: Code Examples

  • estraverse:

    estraverse Example

    import { parse } from 'acorn';
import estraverse from 'estraverse';

const code = `const x = 1;`;
const ast = parse(code);

estraverse.traverse(ast, {
  enter(node) {
    console.log('Visiting node:', node.type);
  },
});
  • esprima:

    esprima Example

    import esprima from 'esprima';

const code = `const x = 1;`;
const ast = esprima.parseScript(code);
console.log(JSON.stringify(ast, null, 2));
  • acorn-walk:

    acorn-walk Example

    import { parse } from 'acorn';
import { simple } from 'acorn-walk';

const code = `const x = 1;`;
const ast = parse(code);

simple(ast, {
  VariableDeclaration(node) {
    console.log('Found a variable declaration:', node);
  },
});
  • estree-walker:

    estree-walker Example

    import { parse } from 'acorn';
import { walk } from 'estree-walker';

const code = `const x = 1;`;
const ast = parse(code);

walk(ast, {
  enter(node) {
    console.log('Entering node:', node.type);
  },
});
  • recast:

    recast Example

    import recast from 'recast';

const code = `const x = 1;`;
const ast = recast.parse(code);

recast.types.visit(ast, {
  visitVariableDeclaration(path) {
    console.log('Found a variable declaration:', path.node);
    this.traverse(path);
  },
});

const transformedCode = recast.print(ast).code;
console.log(transformedCode);
How to Choose: estraverse vs esprima vs acorn-walk vs estree-walker vs recast
  • estraverse:

    Choose estraverse if you need a flexible and extensible library for traversing and manipulating ESTree-compliant ASTs. It provides a simple API for walking the tree and allows for easy customization of traversal behavior.

  • esprima:

    Choose esprima if you need a standards-compliant, fast JavaScript parser that generates a detailed AST. It is suitable for projects that require accurate parsing and analysis of JavaScript code, including support for ES6 and beyond.

  • acorn-walk:

    Choose acorn-walk if you need a lightweight and fast library for traversing ASTs generated by Acorn. It is ideal for simple traversal and manipulation tasks without the overhead of a full-featured framework.

  • estree-walker:

    Choose estree-walker if you want a minimalistic and efficient walker for ESTree-compliant ASTs. It is designed for performance and simplicity, making it a great choice for projects that require fast and lightweight tree traversal.

  • recast:

    Choose recast if you need a powerful tool for parsing, transforming, and pretty-printing JavaScript code while preserving the original formatting. It is ideal for complex code transformations and refactoring tasks, as it integrates well with existing code and supports custom transformations.

Similar Npm Packages to esprima

esprima is a high-performance, standard-compliant JavaScript parser that can analyze JavaScript code and produce an Abstract Syntax Tree (AST). It is widely used in various tools and libraries for tasks such as code analysis, linting, and transformation. Esprima is known for its speed and accuracy, making it a popular choice among developers who need to parse JavaScript code efficiently.

While Esprima is a powerful tool, there are alternatives that also serve the purpose of parsing JavaScript. Here are a couple of notable options:

  • acorn is a small, fast, and efficient JavaScript parser that is designed to be easy to extend. It is particularly well-suited for projects that require a lightweight solution for parsing JavaScript. Acorn supports the latest ECMAScript features and can be easily integrated into various tools and workflows. Its modular architecture allows developers to customize the parser to fit their specific needs, making it a flexible option for those who want to create their own tools or integrate parsing capabilities into existing projects.

  • typescript is primarily known as a superset of JavaScript that adds static typing to the language. However, TypeScript also includes a powerful compiler that can parse JavaScript code and produce an AST. This makes it a viable alternative for projects that already use TypeScript and want to leverage its parsing capabilities. TypeScript's parser is designed to handle modern JavaScript features and provides type information, which can be beneficial for developers looking to perform static analysis or transformations on their code.

To explore how Esprima compares with Acorn and TypeScript, check out the comparison: Comparing acorn vs esprima vs typescript.

Similar Npm Packages to acorn-walk

acorn-walk is a utility library designed to work with the Acorn parser, which is a small, fast JavaScript parser written in JavaScript. Acorn-walk allows developers to traverse and manipulate the abstract syntax tree (AST) generated by Acorn, making it easier to analyze and transform JavaScript code. This library is particularly useful for building tools like linters, code analyzers, and transpilers.

While acorn-walk is a powerful tool for working with JavaScript ASTs, there are several alternatives that provide similar functionality. Here are a few notable options:

  • acorn is the underlying parser that acorn-walk relies on. It is a fast and efficient JavaScript parser that generates an AST from JavaScript code. While acorn itself does not provide traversal capabilities, it serves as the foundation for acorn-walk and other libraries that build upon it. If you need a lightweight and performant parser for JavaScript, acorn is an excellent choice.
  • esprima is another popular JavaScript parser that generates an AST. It is known for its compliance with the ECMAScript specification and provides a robust parsing solution for JavaScript code. Esprima also allows for easy traversal of the generated AST, making it a suitable alternative for developers looking for a comprehensive parsing and traversal solution.
  • estraverse is a library specifically designed for traversing and manipulating ASTs in JavaScript. It works with ASTs generated by various parsers, including Acorn and Esprima. Estraverse provides a simple API for walking through the tree and applying transformations, making it a great choice for developers who need to analyze or modify JavaScript code at the AST level.
  • recast is a powerful tool for working with JavaScript code that allows for parsing, transforming, and printing code. It uses the Babel parser under the hood and provides a rich API for manipulating the AST. Recast is particularly useful for code transformations and refactoring, making it a strong alternative for developers looking to work with JavaScript code in a more comprehensive manner.

To see how these packages compare, check out the comparison: Comparing acorn vs acorn-walk vs esprima vs estraverse vs recast.

Similar Npm Packages to estree-walker

estree-walker is a library designed for traversing and transforming Abstract Syntax Trees (ASTs) that conform to the ESTree specification. It provides a simple and efficient way to walk through the nodes of an AST, allowing developers to perform various operations such as analysis, transformation, or code generation. While estree-walker is a powerful tool for working with ESTree-compliant ASTs, there are several alternatives in the JavaScript ecosystem that offer similar functionalities. Here are a few notable alternatives:

  • acorn-walk is a utility for traversing the AST generated by the Acorn parser. It provides a straightforward API for walking through the nodes of the AST, allowing developers to easily implement custom transformations or analyses. If you are using Acorn for parsing JavaScript code and need a simple way to traverse its AST, acorn-walk is a solid choice.
  • esprima is a high-performance, standard-compliant JavaScript parser that produces an AST. While esprima itself is primarily focused on parsing, it can be used in conjunction with other libraries to traverse and manipulate the resulting AST. If you need a robust parser along with the ability to work with the AST, esprima is a great option.
  • estraverse is a library specifically designed for traversing ESTree-compliant ASTs. It provides a flexible API for walking through nodes and allows for easy manipulation of the AST. If you are looking for a dedicated solution for traversing ESTree ASTs, estraverse is a well-established choice that offers a range of features for node manipulation.
  • recast is a powerful library for working with JavaScript code that allows for parsing, transforming, and printing code. It uses an AST to represent the code structure and provides a rich API for manipulating it. If you need to perform complex transformations on JavaScript code while preserving its original formatting, recast is an excellent option.

To see how estree-walker compares with acorn-walk, esprima, estraverse, and recast, check out the comparison: Comparing acorn-walk vs esprima vs estraverse vs estree-walker vs recast.

Similar Npm Packages to recast

recast is a powerful JavaScript syntax tree transformer that allows developers to manipulate and transform JavaScript code programmatically. It is particularly useful for code refactoring, linting, and generating code in a structured manner. By using recast, developers can parse JavaScript code into an abstract syntax tree (AST), apply transformations, and then generate the modified code back into a readable format. This makes it an essential tool for projects that require code analysis and transformation.

While recast is a robust option for code transformation, several alternatives can also be considered:

  • acorn is a small, fast, and efficient JavaScript parser that produces an abstract syntax tree (AST) from JavaScript code. It is designed to be lightweight and can be easily integrated into various projects. Acorn is particularly useful for developers who need a straightforward parsing solution without the overhead of additional features. However, it does not provide built-in transformation capabilities, so it is often used in conjunction with other libraries for code manipulation.
  • babel is a widely-used JavaScript compiler that allows developers to transform modern JavaScript code into a backward-compatible version for older environments. Babel can also be used for code transformation and manipulation through its plugin system, making it a versatile tool for developers. It supports a wide range of plugins and presets, enabling extensive customization for various use cases, including code refactoring and optimization.
  • esprima is another high-performance, standard-compliant JavaScript parser that produces an AST. It is known for its speed and accuracy, making it a popular choice for developers who need to analyze and manipulate JavaScript code. While esprima focuses primarily on parsing, it can be combined with other libraries for transformation tasks.
  • jscodeshift is a toolkit for running codemods, which are scripts that help automate code transformations. Built on top of recast, jscodeshift provides a higher-level API for performing common code modifications, making it easier for developers to apply large-scale changes across codebases. It is particularly useful for migrating code or applying consistent style changes.
  • typescript is a superset of JavaScript that adds static typing to the language. While primarily known for its type-checking capabilities, TypeScript also includes a powerful compiler that can parse and transform code. Developers can leverage TypeScript's AST for various code manipulation tasks, making it a viable alternative for those working in TypeScript environments.

To see how recast compares with acorn, babel, esprima, jscodeshift, and typescript, check out the comparison: Comparing acorn vs babel vs esprima vs jscodeshift vs recast vs typescript.

README for estraverse

Estraverse Build Status

Estraverse (estraverse) is ECMAScript traversal functions from esmangle project.

Documentation

You can find usage docs at wiki page.

Example Usage

The following code will output all variables declared at the root of a file.

estraverse.traverse(ast, {
    enter: function (node, parent) {
        if (node.type == 'FunctionExpression' || node.type == 'FunctionDeclaration')
            return estraverse.VisitorOption.Skip;
    },
    leave: function (node, parent) {
        if (node.type == 'VariableDeclarator')
          console.log(node.id.name);
    }
});

We can use this.skip, this.remove and this.break functions instead of using Skip, Remove and Break.

estraverse.traverse(ast, {
    enter: function (node) {
        this.break();
    }
});

And estraverse provides estraverse.replace function. When returning node from enter/leave, current node is replaced with it.

result = estraverse.replace(tree, {
    enter: function (node) {
        // Replace it with replaced.
        if (node.type === 'Literal')
            return replaced;
    }
});

By passing visitor.keys mapping, we can extend estraverse traversing functionality.

// This tree contains a user-defined `TestExpression` node.
var tree = {
    type: 'TestExpression',

    // This 'argument' is the property containing the other **node**.
    argument: {
        type: 'Literal',
        value: 20
    },

    // This 'extended' is the property not containing the other **node**.
    extended: true
};
estraverse.traverse(tree, {
    enter: function (node) { },

    // Extending the existing traversing rules.
    keys: {
        // TargetNodeName: [ 'keys', 'containing', 'the', 'other', '**node**' ]
        TestExpression: ['argument']
    }
});

By passing visitor.fallback option, we can control the behavior when encountering unknown nodes.

// This tree contains a user-defined `TestExpression` node.
var tree = {
    type: 'TestExpression',

    // This 'argument' is the property containing the other **node**.
    argument: {
        type: 'Literal',
        value: 20
    },

    // This 'extended' is the property not containing the other **node**.
    extended: true
};
estraverse.traverse(tree, {
    enter: function (node) { },

    // Iterating the child **nodes** of unknown nodes.
    fallback: 'iteration'
});

When visitor.fallback is a function, we can determine which keys to visit on each node.

// This tree contains a user-defined `TestExpression` node.
var tree = {
    type: 'TestExpression',

    // This 'argument' is the property containing the other **node**.
    argument: {
        type: 'Literal',
        value: 20
    },

    // This 'extended' is the property not containing the other **node**.
    extended: true
};
estraverse.traverse(tree, {
    enter: function (node) { },

    // Skip the `argument` property of each node
    fallback: function(node) {
        return Object.keys(node).filter(function(key) {
            return key !== 'argument';
        });
    }
});

License

Copyright (C) 2012-2016 Yusuke Suzuki (twitter: @Constellation) and other contributors.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

  • Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

  • Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.