Acorn AST walker——模具行业从业者必备知识手册

system 2

<h2>Acorn AST walker</h2>

An abstract syntax tree walker for the
<a href="https://github.com/estree/estree">ESTree</a> format.

<h3>Community</h3>

Acorn is open source software released under an
<a href="https://github.com/acornjs/acorn/blob/master/acorn-walk/LICENSE">MIT license</a>.

You are welcome to
<a href="https://github.com/acornjs/acorn/issues">report bugs</a> or create pull
requests on <a href="https://github.com/acornjs/acorn">github</a>. For questions
and discussion, please use the
<a href="https://discuss.ternjs.net">Tern discussion forum</a>.

<h3>Installation</h3>

The easiest way to install acorn is from <a href="https://www.npmjs.com/"><code>npm</code></a>:

<pre><code>
npm install acorn-walk
</code></pre>

Alternately, you can download the source and build acorn yourself:

<pre><code>
git clone https://github.com/acornjs/acorn.git
cd acorn
npm install
</code></pre>

<h3>Interface</h3>

An algorithm for recursing through a syntax tree is stored as an
object, with a property for each tree node type holding a function
that will recurse through such a node. There are several ways to run
such a walker.

simple<code>(node, visitors, base, state)</code> does a 'simple' walk over a
tree. <code>node</code> should be the AST node to walk, and <code>visitors</code> an object
with properties whose names correspond to node types in the ESTree
spec. The properties should contain
functions that will be called with the node object and, if applicable
the state at that point. The last two arguments are optional. <code>base</code>
is a walker algorithm, and <code>state</code> is a start state. The default
walker will simply visit all statements and expressions and not
produce a meaningful state. (An example of a use of state is to track
scope at each point in the tree.)

<pre><code>
const acorn = require("acorn")
const walk = require("acorn-walk")

walk.simple(acorn.parse("let x = 10"), {
Literal(node) {
console.log(Found a literal: ${node.value})
}
})
</code></pre>

ancestor<code>(node, visitors, base, state)</code> does a 'simple' walk over
a tree, building up an array of ancestor nodes (including the current node)
and passing the array to the callbacks as a third parameter.

<pre><code>
const acorn = require("acorn")
const walk = require("acorn-walk")

walk.ancestor(acorn.parse("foo('hi')"), {
Literal(_, ancestors) {
console.log("This literal's ancestors are:", ancestors.map(n => n.type))
}
})
</code></pre>

recursive<code>(node, state, functions, base)</code> does a 'recursive'
walk, where the walker functions are responsible for continuing the
walk on the child nodes of their target node. <code>state</code> is the start
state, and <code>functions</code> should contain an object that maps node types
to walker functions. Such functions are called with <code>(node, state, c)</code>
arguments, and can cause the walk to continue on a sub-node by calling
the <code>c</code> argument on it with <code>(node, state)</code> arguments. The optional
<code>base</code> argument provides the fallback walker functions for node types
that aren't handled in the <code>functions</code> object. If not given, the
default walkers will be used.

make<code>(functions, base)</code> builds a new walker object by using the
walker functions in <code>functions</code> and filling in the missing ones by
taking defaults from <code>base</code>.

full<code>(node, callback, base, state)</code> does a 'full' walk over a
tree, calling the callback with the arguments (node, state, type) for
each node

fullAncestor<code>(node, callback, base, state)</code> does a 'full' walk
over a tree, building up an array of ancestor nodes (including the
current node) and passing the array to the callbacks as a third
parameter.

<pre><code>
const acorn = require("acorn")
const walk

这个参数你们一般设多少？评论区说说。
</code></pre>