父节点相关

1
findParent(callback): ?NodePath

从当前节点的父节点（不包括当前节点自己）开始向上查找并调用 callback，如果 callback 返回一个真值，那么返回那个父节点；都没有找到，返回 null。

1
find(callback): ?NodePath

同findParent，唯一的区别是从当前节点（包括自己）开始查找。

1
getFunctionParent(): ?NodePath

找到满足 callback 的函数父节点。

1
getStatementParent(): NodePath

向上遍历节点树，直到命中一个处于list中的父节点。

1
2
3
getEarliestCommonAncestorFrom(
  paths: Array<NodePath>,
): NodePath
1
2
3
4
getDeepestCommonAncestorFrom(
  paths: Array<NodePath>,
  filter?: Function,
): NodePath
1
getAncestry(): Array<NodePath>
1
isAncestor(maybeDescendant: NodePath): boolean

判断当前的path是否是maybeDescendant的祖先节点。

1
isDescendant(maybeAncestor: NodePath): boolean

判断当前的path是否是maybeAncestor的后代。

1
inType(): boolean

向上查找，直到一个节点的type在提供的type列表中为止，此时返回 ture，否则 false。

兄弟节点相关

1
getOpposite(): ?NodePath

得到一个对立的节点。

1
getCompletionRecords(): Array

得到一个完整到的记录。

1
2
// key: 即为path.key
getSibling(key): NodePath

根据key得到一个兄弟节点。

1
getPrevSibling(): NodePath

得到当前节点的前一个节点。

1
getNextSibling(): NodePath

得到当前节点的下一个节点。

1
getAllNextSiblings(): Array<NodePath>
1
getAllPrevSiblings(): Array<NodePath>
1
2
3
4
get(
  key: string,
  context?: boolean | TraversalContext,
): NodePath

根据字符串路径得到一个节点，类似于lodash中的get方法：path.get('body.0')。

1
getBindingIdentifiers(duplicates?): Object

获取绑定的标示，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
var a = 1, { d } = b, [c] = e
//       ⬇
//
{ a:
   Node {
     type: 'Identifier',
     start: 4,
     end: 5,
     loc:
      SourceLocation { start: [Position], end: [Position], identifierName: 'a' },
     name: 'a' },
  d:
   Node {
     type: 'Identifier',
     start: 27,
     end: 28,
     loc:
      SourceLocation { start: [Position], end: [Position], identifierName: 'd' },
     name: 'd' },
  b:
   Node {
     type: 'Identifier',
     start: 15,
     end: 16,
     loc:
      SourceLocation { start: [Position], end: [Position], identifierName: 'b' },
     name: 'b' } }
1
getOuterBindingIdentifiers(duplicates?): Object

获取函数外层绑定的标识符，如：

1
2
3
4
5
6
7
8
9
10
11
function f () {}
// ⬇
//
{ f:
   Node {
     type: 'Identifier',
     start: 43,
     end: 44,
     loc:
      SourceLocation { start: [Position], end: [Position], identifierName: 'f' },
     name: 'f' } }
1
getBindingIdentifierPaths((duplicates = false), (outerOnly = false))
1
getOuterBindingIdentifierPaths(duplicates?)

当前节点自身相关

1
2
3
4
matchesPattern(
  pattern: string,
  allowPartial?: boolean,
): boolean
1
has(key): boolean

别名：is

1
isnt(key): boolean

has的否定操作。

1
equals(key, value): boolean

检查当前节点的key是否等于给定的value。

1
isNodeType(type: string): boolean
1
canHaveVariableDeclarationOrExpression()
1
canSwapBetweenExpressionAndStatement(replacement)
1
isStatic()
1
isCompletionRecord(allowInsideFunction?)
1
isStatementOrBlock()
1
referencesImport(moduleSource, importName)
1
getSource()

获取当前节点的 souce 内容。

1
willIMaybeExecuteBefore(target)
1
resolve(dangerous, resolved)
1
isConstantExpression()
1
isInStrictMode()

判断一个模块或者函数是否处于严格模式。
ES6 模块默认是处于严格模式，其实情况看是否使用use strict指令。

修改当前节点相关

1
insertBefore(nodes)

在当前节点的前面插入节点。

1
insertAfter(nodes)

在当前节点的后面插入节点。

1
updateSiblingKeys(fromIndex, incrementBy)
1
unshiftContainer(listKey, nodes)
1
2
// listKey: path.listKey => "body" | "params"
pushContainer(listKey, nodes)

将nodes放入到指定的listKey容器中，如：

1
2
3
4
5
6
7
8
9
10
function test(a) {}
path.pushContainer('params', t.identifier('b'))
// ⬇
function test(a, b) {}

path.pushContainer('body', t.expressionStatement(t.identifier('b')))
// ⬇
function test(a) {
  b
}
1
hoist((scope = this.scope))

删除当前节点相关

1
remove()

替换当前节点相关

1
replaceWithMultiple(nodes: Array<Object>)

用多个节点替换当前节点。

1
replaceWithSourceString(replacement)

不推荐使用
将replacement作为一个表达式去解析，然后用解析的结果替换当前节点。

1
replaceWith(replacement)

用一个节点替换当前节点。

1
replaceExpressionWithStatements(nodes: Array<Object>)
1
replaceInline(nodes: Object | Array<Object>)

注释相关

1
shareCommentsWithSiblings()
1
addComment(type: string, content: string, line?: boolean)
1
addComments(type: string, comments: Array)

上下文相关

维护TraversalContext相关的方法。

1
call(key): boolean
1
isBlacklisted(): boolean
1
visit(): boolean
1
skip()
1
skipKey(key)
1
stop()

停止继续往上或者往下遍历一个节点。

1
setScope()
1
setContext(context)
1
resync()
1
popContext()
1
pushContext(context)
1
setup(parentPath, container, listKey, key)
1
setKey(key)
1
requeue((pathToQueue = this))

节点类型转化

1
ensureBlock()

将可以转化的节点（函数，for 循环等）转换成块节点，如：() => true => () => { return true }。

1
2
3
arrowFunctionToExpression(
  ({ allowInsertArrow = true, specCompliant = false } = {})
)

将一个箭头函数转化为 ES5 的函数表达式。