@babel/types

此模块包含用于手动构建 AST 以及检查 AST 节点类型的方法。

安装

npm
Yarn
pnpm

npm install --save-dev @babel/types

yarn add --dev @babel/types

pnpm add --save-dev @babel/types

API

节点构建器

anyTypeAnnotation

JavaScript
t.anyTypeAnnotation();

另请参阅 t.isAnyTypeAnnotation(node, opts) 和 t.assertAnyTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

argumentPlaceholder

JavaScript
t.argumentPlaceholder();

另请参阅 t.isArgumentPlaceholder(node, opts) 和 t.assertArgumentPlaceholder(node, opts)。

arrayExpression

JavaScript
t.arrayExpression(elements);

另请参阅 t.isArrayExpression(node, opts) 和 t.assertArrayExpression(node, opts)。

AST 节点 ArrayExpression 形状

elements: Array<null | Expression | SpreadElement>（默认值：[]）

别名：Standardized、Expression

arrayPattern

JavaScript
t.arrayPattern(elements);

另请参阅 t.isArrayPattern(node, opts) 和 t.assertArrayPattern(node, opts)。

AST 节点 ArrayPattern 形状

elements: Array<null | PatternLike | LVal>（必需）
decorators: Array<Decorator>（默认值：null，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop（默认值：null，从构建器函数中排除）

别名：Standardized、Pattern、PatternLike、LVal

arrayTypeAnnotation

JavaScript
t.arrayTypeAnnotation(elementType);

另请参阅 t.isArrayTypeAnnotation(node, opts) 和 t.assertArrayTypeAnnotation(node, opts)。

AST 节点 ArrayTypeAnnotation 形状

elementType：FlowType（必需）

别名：Flow、FlowType

arrowFunctionExpression

JavaScript
t.arrowFunctionExpression(params, body, async);

另请参阅 t.isArrowFunctionExpression(node, opts) 和 t.assertArrowFunctionExpression(node, opts)。

AST 节点 ArrowFunctionExpression 形状

params：Array<Identifier | Pattern | RestElement>（必需）
body：BlockStatement | Expression（必需）
async：boolean（默认：false）
expression：boolean（必需）
generator：boolean（默认：false，从构建器函数中排除）
predicate：DeclaredPredicate | InferredPredicate（默认：null，从构建器函数中排除）
returnType：TypeAnnotation | TSTypeAnnotation | Noop（默认：null，从构建器函数中排除）
typeParameters：TypeParameterDeclaration | TSTypeParameterDeclaration | Noop（默认：null，从构建器函数中排除）

别名：Standardized、Scopable、Function、BlockParent、FunctionParent、Expression、Pureish

assignmentExpression

JavaScript
t.assignmentExpression(operator, left, right);

另请参阅 t.isAssignmentExpression(node, opts) 和 t.assertAssignmentExpression(node, opts)。

AST 节点 AssignmentExpression 形状

operator：string（必需）
left：LVal | OptionalMemberExpression（必需）
right：Expression（必需）

别名：Standardized、Expression

assignmentPattern

JavaScript
t.assignmentPattern(left, right);

另请参阅 t.isAssignmentPattern(node, opts) 和 t.assertAssignmentPattern(node, opts)。

AST 节点 AssignmentPattern 形状

left：Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression（必需）
right：Expression（必需）
decorators: Array<Decorator>（默认值：null，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop（默认值：null，从构建器函数中排除）

别名：Standardized、Pattern、PatternLike、LVal

awaitExpression

JavaScript
t.awaitExpression(argument);

另请参阅 t.isAwaitExpression(node, opts) 和 t.assertAwaitExpression(node, opts)。

AST 节点 AwaitExpression 形状

argument：Expression（必需）

别名：Standardized、Expression、Terminatorless

bigIntLiteral

JavaScript
t.bigIntLiteral(value);

另请参阅 t.isBigIntLiteral(node, opts) 和 t.assertBigIntLiteral(node, opts)。

AST 节点 BigIntLiteral 形状

value：string（必需）

别名：Standardized、Expression、Pureish、Literal、Immutable

binaryExpression

JavaScript
t.binaryExpression(operator, left, right);

另请参阅 t.isBinaryExpression(node, opts) 和 t.assertBinaryExpression(node, opts)。

AST 节点 BinaryExpression 形状

operator："+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>"（必需）
left：Expression | PrivateName（必需）
right：Expression（必需）

别名：Standardized、Binary、Expression

bindExpression

JavaScript
t.bindExpression(object, callee);

另请参阅 t.isBindExpression(node, opts) 和 t.assertBindExpression(node, opts)。

AST 节点 BindExpression 形状

object: Expression（必需）
callee: Expression（必需）

别名：Expression

blockStatement

JavaScript
t.blockStatement(body, directives);

另请参阅 t.isBlockStatement(node, opts) 和 t.assertBlockStatement(node, opts)。

AST 节点 BlockStatement 形状

body: Array<Statement>（必需）
directives: Array<Directive>（默认值：[]）

别名：Standardized、Scopable、BlockParent、Block、Statement

booleanLiteral

JavaScript
t.booleanLiteral(value);

另请参阅 t.isBooleanLiteral(node, opts) 和 t.assertBooleanLiteral(node, opts)。

AST 节点 BooleanLiteral 形状

value: boolean（必需）

别名：Standardized、Expression、Pureish、Literal、Immutable

booleanLiteralTypeAnnotation

JavaScript
t.booleanLiteralTypeAnnotation(value);

另请参阅 t.isBooleanLiteralTypeAnnotation(node, opts) 和 t.assertBooleanLiteralTypeAnnotation(node, opts)。

AST 节点 BooleanLiteralTypeAnnotation 形状

value: boolean（必需）

别名：Flow、FlowType

booleanTypeAnnotation

JavaScript
t.booleanTypeAnnotation();

另请参阅 t.isBooleanTypeAnnotation(node, opts) 和 t.assertBooleanTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

breakStatement

JavaScript
t.breakStatement(label);

另请参阅 t.isBreakStatement(node, opts) 和 t.assertBreakStatement(node, opts)。

AST 节点 BreakStatement 形状

label: Identifier（默认值：null）

别名：Standardized、Statement、Terminatorless、CompletionStatement

callExpression

JavaScript
t.callExpression(callee, arguments);

另请参阅 t.isCallExpression(node, opts) 和 t.assertCallExpression(node, opts)。

AST 节点 CallExpression 形状

callee: Expression | Super | V8IntrinsicIdentifier（必需）
arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>（必需）
optional: true | false（默认值：null，从生成器函数中排除）
typeArguments: TypeParameterInstantiation（默认值：null，从生成器函数中排除）
typeParameters: TSTypeParameterInstantiation（默认值：null，从生成器函数中排除）

别名：Standardized、Expression

catchClause

JavaScript
t.catchClause(param, body);

另请参阅 t.isCatchClause(node, opts) 和 t.assertCatchClause(node, opts)。

AST 节点 CatchClause 形状

param: Identifier | ArrayPattern | ObjectPattern（默认值：null）
body: BlockStatement（必需）

别名：Standardized、Scopable、BlockParent

classAccessorProperty

JavaScript
t.classAccessorProperty(key, value, typeAnnotation, decorators, computed, static);

另请参阅 t.isClassAccessorProperty(node, opts) 和 t.assertClassAccessorProperty(node, opts)。

AST 节点 ClassAccessorProperty 形状

key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName（必需）
value: Expression（默认值：null）
typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop（默认值：null）
decorators: Array<Decorator>（默认值：null）
computed: boolean（默认值：false）
static: boolean（默认值：false）
abstract: boolean（默认值：null，从构建器函数中排除）
accessibility: "public" | "private" | "protected"（默认值：null，从构建器函数中排除）
declare: boolean（默认值：null，从构建器函数中排除）
definite: boolean（默认值：null，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
override: boolean（默认值：false，从构建器函数中排除）
readonly: boolean（默认值：null，从构建器函数中排除）
variance: Variance（默认值：null，从构建器函数中排除）

别名：Standardized、Property、Accessor

classBody

JavaScript
t.classBody(body);

另请参阅 t.isClassBody(node, opts) 和 t.assertClassBody(node, opts)。

AST 节点 ClassBody 形状

body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock>（必需）

别名：Standardized

classDeclaration

JavaScript
t.classDeclaration(id, superClass, body, decorators);

另请参阅 t.isClassDeclaration(node, opts) 和 t.assertClassDeclaration(node, opts)。

AST 节点 ClassDeclaration 形状

id: Identifier（默认值：null）
superClass: Expression（默认值：null）
body: ClassBody（必需）
decorators: Array<Decorator>（默认值：null）
abstract: boolean（默认值：null，从构建器函数中排除）
declare: boolean（默认值：null，从构建器函数中排除）
implements: Array<TSExpressionWithTypeArguments | ClassImplements>（默认值：null，从构建器函数中排除）
mixins: InterfaceExtends（默认值：null，从构建器函数中排除）
superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation（默认值：null，从构建器函数中排除）
typeParameters：TypeParameterDeclaration | TSTypeParameterDeclaration | Noop（默认：null，从构建器函数中排除）

别名：Standardized、Scopable、Class、Statement、Declaration

classExpression

JavaScript
t.classExpression(id, superClass, body, decorators);

另请参阅 t.isClassExpression(node, opts) 和 t.assertClassExpression(node, opts)。

AST 节点 ClassExpression 形状

id: Identifier（默认值：null）
superClass: Expression（默认值：null）
body: ClassBody（必需）
decorators: Array<Decorator>（默认值：null）
implements: Array<TSExpressionWithTypeArguments | ClassImplements>（默认值：null，从构建器函数中排除）
mixins: InterfaceExtends（默认值：null，从构建器函数中排除）
superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation（默认值：null，从构建器函数中排除）
typeParameters：TypeParameterDeclaration | TSTypeParameterDeclaration | Noop（默认：null，从构建器函数中排除）

别名：Standardized、Scopable、Class、Expression

classImplements

JavaScript
t.classImplements(id, typeParameters);

另请参阅 t.isClassImplements(node, opts) 和 t.assertClassImplements(node, opts)。

AST 节点 ClassImplements 形状

id: Identifier（必需）
typeParameters: TypeParameterInstantiation（默认值：null）

别名：Flow

classMethod

JavaScript
t.classMethod(kind, key, params, body, computed, static, generator, async);

另请参阅 t.isClassMethod(node, opts) 和 t.assertClassMethod(node, opts)。

AST 节点 ClassMethod 形状

kind: "get" | "set" | "method" | "constructor"（默认值：'method'）
key: 如果计算则为 Expression，否则为 Identifier | Literal（必需）
params: Array<Identifier | Pattern | RestElement | TSParameterProperty>（必需）
body: BlockStatement（必需）
computed: boolean（默认值：false）
static: boolean（默认值：false）
generator: boolean（默认值：false）
async：boolean（默认：false）
abstract: boolean（默认值：null，从构建器函数中排除）
access: "public" | "private" | "protected"（默认值：null，从构建器函数中排除）
accessibility: "public" | "private" | "protected"（默认值：null，从构建器函数中排除）
decorators: Array<Decorator>（默认值：null，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
override: boolean（默认值：false，从构建器函数中排除）
returnType：TypeAnnotation | TSTypeAnnotation | Noop（默认：null，从构建器函数中排除）
typeParameters：TypeParameterDeclaration | TSTypeParameterDeclaration | Noop（默认：null，从构建器函数中排除）

别名：Standardized、Function、Scopable、BlockParent、FunctionParent、Method

classPrivateMethod

JavaScript
t.classPrivateMethod(kind, key, params, body, static);

另请参阅 t.isClassPrivateMethod(node, opts) 和 t.assertClassPrivateMethod(node, opts)。

AST 节点 ClassPrivateMethod 形状

kind："get" | "set" | "method"（默认：'method'）
key：PrivateName（必需）
params: Array<Identifier | Pattern | RestElement | TSParameterProperty>（必需）
body: BlockStatement（必需）
static: boolean（默认值：false）
abstract: boolean（默认值：null，从构建器函数中排除）
access: "public" | "private" | "protected"（默认值：null，从构建器函数中排除）
accessibility: "public" | "private" | "protected"（默认值：null，从构建器函数中排除）
async：boolean（默认：false，从构建器函数中排除）
computed：'false'（默认：false，从构建器函数中排除）
decorators: Array<Decorator>（默认值：null，从构建器函数中排除）
generator：boolean（默认：false，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
override: boolean（默认值：false，从构建器函数中排除）
returnType：TypeAnnotation | TSTypeAnnotation | Noop（默认：null，从构建器函数中排除）
typeParameters：TypeParameterDeclaration | TSTypeParameterDeclaration | Noop（默认：null，从构建器函数中排除）

别名：Standardized、Function、Scopable、BlockParent、FunctionParent、Method、Private

classPrivateProperty

JavaScript
t.classPrivateProperty(key, value, decorators, static);

另请参阅 t.isClassPrivateProperty(node, opts) 和 t.assertClassPrivateProperty(node, opts)。

AST 节点 ClassPrivateProperty 形状

key：PrivateName（必需）
value: Expression（默认值：null）
decorators: Array<Decorator>（默认值：null）
static: boolean（默认值：false）
definite: boolean（默认值：null，从构建器函数中排除）
readonly: boolean（默认值：null，从构建器函数中排除）
typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop（默认值：null，从构建器函数中排除）
variance: Variance（默认值：null，从构建器函数中排除）

别名：Standardized、Property、Private

classProperty

JavaScript
t.classProperty(key, value, typeAnnotation, decorators, computed, static);

历史记录

版本	更改
`v7.6.0`	支持 `static`

另请参阅 t.isClassProperty(node, opts) 和 t.assertClassProperty(node, opts)。

AST 节点 ClassProperty 形状

key：Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression（必需）
value: Expression（默认值：null）
typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop（默认值：null）
decorators: Array<Decorator>（默认值：null）
computed: boolean（默认值：false）
static: boolean（默认值：false）
abstract: boolean（默认值：null，从构建器函数中排除）
accessibility: "public" | "private" | "protected"（默认值：null，从构建器函数中排除）
declare: boolean（默认值：null，从构建器函数中排除）
definite: boolean（默认值：null，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
override: boolean（默认值：false，从构建器函数中排除）
readonly: boolean（默认值：null，从构建器函数中排除）
variance: Variance（默认值：null，从构建器函数中排除）

别名：Standardized、Property

conditionalExpression

JavaScript
t.conditionalExpression(test, consequent, alternate);

另请参阅 t.isConditionalExpression(node, opts) 和 t.assertConditionalExpression(node, opts)。

AST 节点 ConditionalExpression 形状

test：Expression（必需）
consequent：Expression（必需）
alternate：Expression（必需）

别名：Standardized、Expression、Conditional

continueStatement

JavaScript
t.continueStatement(label);

另请参阅 t.isContinueStatement(node, opts) 和 t.assertContinueStatement(node, opts)。

AST 节点 ContinueStatement 形状

label: Identifier（默认值：null）

别名：Standardized、Statement、Terminatorless、CompletionStatement

debuggerStatement

JavaScript
t.debuggerStatement();

另请参阅 t.isDebuggerStatement(node, opts) 和 t.assertDebuggerStatement(node, opts)。

别名：Standardized、Statement

decimalLiteral

JavaScript
t.decimalLiteral(value);

另请参阅 t.isDecimalLiteral(node, opts) 和 t.assertDecimalLiteral(node, opts)。

AST 节点 DecimalLiteral 形状

value：string（必需）

别名：Expression、Pureish、Literal、Immutable

declareClass

JavaScript
t.declareClass(id, typeParameters, extends, body);

另请参阅 t.isDeclareClass(node, opts) 和 t.assertDeclareClass(node, opts)。

AST 节点 DeclareClass 形状

id: Identifier（必需）
typeParameters：TypeParameterDeclaration（默认：null）
extends：Array<InterfaceExtends>（默认：null）
body: ObjectTypeAnnotation（必需）
implements: Array<ClassImplements>（默认值：null，从构建器函数中排除）
mixins: Array<InterfaceExtends>（默认值：null，从构建器函数中排除）

别名：Flow、FlowDeclaration、Statement、Declaration

declareExportAllDeclaration

JavaScript
t.declareExportAllDeclaration(source);

另请参阅 t.isDeclareExportAllDeclaration(node, opts) 和 t.assertDeclareExportAllDeclaration(node, opts)。

AST 节点 DeclareExportAllDeclaration 形状

source: StringLiteral（必需）
exportKind: "type" | "value"（默认值：null，从构建器函数中排除）

别名：Flow、FlowDeclaration、Statement、Declaration

declareExportDeclaration

JavaScript
t.declareExportDeclaration(declaration, specifiers, source);

另请参阅 t.isDeclareExportDeclaration(node, opts) 和 t.assertDeclareExportDeclaration(node, opts)。

AST 节点 DeclareExportDeclaration 形状

declaration: Flow（默认值：null）
specifiers: Array<ExportSpecifier | ExportNamespaceSpecifier>（默认值：null）
source: StringLiteral（默认值：null）
default: boolean（默认值：null，从构建器函数中排除）

别名：Flow、FlowDeclaration、Statement、Declaration

declareFunction

JavaScript
t.declareFunction(id);

另请参阅 t.isDeclareFunction(node, opts) 和 t.assertDeclareFunction(node, opts)。

AST 节点 DeclareFunction 形状

id: Identifier（必需）
predicate: DeclaredPredicate（默认值：null，从构建器函数中排除）

别名：Flow、FlowDeclaration、Statement、Declaration

declareInterface

JavaScript
t.declareInterface(id, typeParameters, extends, body);

另请参阅 t.isDeclareInterface(node, opts) 和 t.assertDeclareInterface(node, opts)。

AST 节点 DeclareInterface 形状

id: Identifier（必需）
typeParameters：TypeParameterDeclaration（默认：null）
extends：Array<InterfaceExtends>（默认：null）
body: ObjectTypeAnnotation（必需）

别名：Flow、FlowDeclaration、Statement、Declaration

declareModule

JavaScript
t.declareModule(id, body, kind);

另请参阅 t.isDeclareModule(node, opts) 和 t.assertDeclareModule(node, opts)。

AST 节点 DeclareModule 形状

id: Identifier | StringLiteral（必需）
body: BlockStatement（必需）
kind: "CommonJS" | "ES"（默认值：null）

别名：Flow、FlowDeclaration、Statement、Declaration

declareModuleExports

JavaScript
t.declareModuleExports(typeAnnotation);

另请参阅 t.isDeclareModuleExports(node, opts) 和 t.assertDeclareModuleExports(node, opts)。

AST 节点 DeclareModuleExports 形状

typeAnnotation: TypeAnnotation（必需）

别名：Flow、FlowDeclaration、Statement、Declaration

declareOpaqueType

JavaScript
t.declareOpaqueType(id, typeParameters, supertype);

另请参阅 t.isDeclareOpaqueType(node, opts) 和 t.assertDeclareOpaqueType(node, opts)。

AST 节点 DeclareOpaqueType 形状

id: Identifier（必需）
typeParameters：TypeParameterDeclaration（默认：null）
supertype: FlowType（默认值：null）
impltype: FlowType（默认值：null，从构建器函数中排除）

别名：Flow、FlowDeclaration、Statement、Declaration

declareTypeAlias

JavaScript
t.declareTypeAlias(id, typeParameters, right);

另请参阅 t.isDeclareTypeAlias(node, opts) 和 t.assertDeclareTypeAlias(node, opts)。

AST 节点 DeclareTypeAlias 形状

id: Identifier（必需）
typeParameters：TypeParameterDeclaration（默认：null）
right: FlowType（必需）

别名：Flow、FlowDeclaration、Statement、Declaration

declareVariable

JavaScript
t.declareVariable(id);

另请参阅 t.isDeclareVariable(node, opts) 和 t.assertDeclareVariable(node, opts)。

AST 节点 DeclareVariable 形状

id: Identifier（必需）

别名：Flow、FlowDeclaration、Statement、Declaration

declaredPredicate

JavaScript
t.declaredPredicate(value);

另请参阅 t.isDeclaredPredicate(node, opts) 和 t.assertDeclaredPredicate(node, opts)。

AST 节点 DeclaredPredicate 形状

value: Flow（必需）

别名：Flow、FlowPredicate

装饰器

JavaScript
t.decorator(expression);

另请参见 t.isDecorator(node, opts) 和 t.assertDecorator(node, opts)。

AST 节点 Decorator 形状

expression：Expression（必需）

指令

JavaScript
t.directive(value);

另请参见 t.isDirective(node, opts) 和 t.assertDirective(node, opts)。

AST 节点 Directive 形状

value：DirectiveLiteral（必需）

别名：Standardized

指令文本

JavaScript
t.directiveLiteral(value);

另请参见 t.isDirectiveLiteral(node, opts) 和 t.assertDirectiveLiteral(node, opts)。

AST 节点 DirectiveLiteral 形状

value：string（必需）

别名：Standardized

do 表达式

JavaScript
t.doExpression(body, async);

另请参见 t.isDoExpression(node, opts) 和 t.assertDoExpression(node, opts)。

AST 节点 DoExpression 形状

body: BlockStatement（必需）
async：boolean（默认：false）

别名：Expression

do while 语句

JavaScript
t.doWhileStatement(test, body);

另请参见 t.isDoWhileStatement(node, opts) 和 t.assertDoWhileStatement(node, opts)。

AST 节点 DoWhileStatement 形状

test：Expression（必需）
body：Statement（必需）

别名：Standardized、Statement、BlockParent、Loop、While、Scopable

空语句

JavaScript
t.emptyStatement();

另请参见 t.isEmptyStatement(node, opts) 和 t.assertEmptyStatement(node, opts)。

别名：Standardized、Statement

空类型注释

JavaScript
t.emptyTypeAnnotation();

另请参见 t.isEmptyTypeAnnotation(node, opts) 和 t.assertEmptyTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

枚举布尔正文

JavaScript
t.enumBooleanBody(members);

另请参见 t.isEnumBooleanBody(node, opts) 和 t.assertEnumBooleanBody(node, opts)。

AST 节点 EnumBooleanBody 形状

members：Array<EnumBooleanMember>（必需）
explicitType：boolean（必需）
hasUnknownMembers：boolean（必需）

别名：Flow、EnumBody

枚举布尔成员

JavaScript
t.enumBooleanMember(id);

另请参见 t.isEnumBooleanMember(node, opts) 和 t.assertEnumBooleanMember(node, opts)。

AST 节点 EnumBooleanMember 形状

id: Identifier（必需）
init：BooleanLiteral（必需）

别名：Flow、EnumMember

枚举声明

JavaScript
t.enumDeclaration(id, body);

另请参见 t.isEnumDeclaration(node, opts) 和 t.assertEnumDeclaration(node, opts)。

AST 节点 EnumDeclaration 形状

id: Identifier（必需）
body：EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody（必需）

别名：Flow、Statement、Declaration

枚举默认成员

JavaScript
t.enumDefaultedMember(id);

另请参见 t.isEnumDefaultedMember(node, opts) 和 t.assertEnumDefaultedMember(node, opts)。

AST 节点 EnumDefaultedMember 形状

id: Identifier（必需）

别名：Flow、EnumMember

枚举数字正文

JavaScript
t.enumNumberBody(members);

另请参见 t.isEnumNumberBody(node, opts) 和 t.assertEnumNumberBody(node, opts)。

AST 节点 EnumNumberBody 形状

members：Array<EnumNumberMember>（必需）
explicitType：boolean（必需）
hasUnknownMembers：boolean（必需）

别名：Flow、EnumBody

enumNumberMember

JavaScript
t.enumNumberMember(id, init);

另请参阅 t.isEnumNumberMember(node, opts) 和 t.assertEnumNumberMember(node, opts)。

AST 节点 EnumNumberMember 形状

id: Identifier（必需）
init: NumericLiteral（必需）

别名：Flow、EnumMember

enumStringBody

JavaScript
t.enumStringBody(members);

另请参阅 t.isEnumStringBody(node, opts) 和 t.assertEnumStringBody(node, opts)。

AST 节点 EnumStringBody 形状

members: Array<EnumStringMember | EnumDefaultedMember>（必需）
explicitType：boolean（必需）
hasUnknownMembers：boolean（必需）

别名：Flow、EnumBody

enumStringMember

JavaScript
t.enumStringMember(id, init);

另请参阅 t.isEnumStringMember(node, opts) 和 t.assertEnumStringMember(node, opts)。

AST 节点 EnumStringMember 形状

id: Identifier（必需）
init: StringLiteral（必需）

别名：Flow、EnumMember

enumSymbolBody

JavaScript
t.enumSymbolBody(members);

另请参阅 t.isEnumSymbolBody(node, opts) 和 t.assertEnumSymbolBody(node, opts)。

AST 节点 EnumSymbolBody 形状

members: Array<EnumDefaultedMember>（必需）
hasUnknownMembers：boolean（必需）

别名：Flow、EnumBody

existsTypeAnnotation

JavaScript
t.existsTypeAnnotation();

另请参阅 t.isExistsTypeAnnotation(node, opts) 和 t.assertExistsTypeAnnotation(node, opts)。

别名：Flow、FlowType

exportAllDeclaration

JavaScript
t.exportAllDeclaration(source);

另请参阅 t.isExportAllDeclaration(node, opts) 和 t.assertExportAllDeclaration(node, opts)。

AST 节点 ExportAllDeclaration 形状

source: StringLiteral（必需）
assertions: Array<ImportAttribute>（默认值：null，从构建器函数中排除）
attributes: Array<ImportAttribute>（默认值：null，从构建器函数中排除）
exportKind: "type" | "value"（默认值：null，从构建器函数中排除）

别名：Standardized、Statement、Declaration、ImportOrExportDeclaration、ExportDeclaration

exportDefaultDeclaration

JavaScript
t.exportDefaultDeclaration(declaration);

另请参阅 t.isExportDefaultDeclaration(node, opts) 和 t.assertExportDefaultDeclaration(node, opts)。

AST 节点 ExportDefaultDeclaration 形状

declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression（必需）
exportKind: "value"（默认值：null，从构建器函数中排除）

别名：Standardized、Statement、Declaration、ImportOrExportDeclaration、ExportDeclaration

exportDefaultSpecifier

JavaScript
t.exportDefaultSpecifier(exported);

另请参阅 t.isExportDefaultSpecifier(node, opts) 和 t.assertExportDefaultSpecifier(node, opts)。

AST 节点 ExportDefaultSpecifier 形状

exported: Identifier（必需）

别名：ModuleSpecifier

exportNamedDeclaration

JavaScript
t.exportNamedDeclaration(declaration, specifiers, source);

另请参阅 t.isExportNamedDeclaration(node, opts) 和 t.assertExportNamedDeclaration(node, opts)。

AST 节点 ExportNamedDeclaration 形状

declaration: Declaration（默认值：null）
specifiers: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>（默认值：[]）
source: StringLiteral（默认值：null）
assertions: Array<ImportAttribute>（默认值：null，从构建器函数中排除）
attributes: Array<ImportAttribute>（默认值：null，从构建器函数中排除）
exportKind: "type" | "value"（默认值：null，从构建器函数中排除）

别名：Standardized、Statement、Declaration、ImportOrExportDeclaration、ExportDeclaration

exportNamespaceSpecifier

JavaScript
t.exportNamespaceSpecifier(exported);

另请参阅 t.isExportNamespaceSpecifier(node, opts) 和 t.assertExportNamespaceSpecifier(node, opts)。

AST 节点 ExportNamespaceSpecifier 形状

exported: Identifier（必需）

别名：Standardized、ModuleSpecifier

exportSpecifier

JavaScript
t.exportSpecifier(local, exported);

另请参阅 t.isExportSpecifier(node, opts) 和 t.assertExportSpecifier(node, opts)。

AST 节点 ExportSpecifier 形状

local: Identifier（必需）
exported: 标识符 | 字符串字面量（必需）
exportKind: "type" | "value"（默认值：null，从构建器函数中排除）

别名：Standardized、ModuleSpecifier

expressionStatement

JavaScript
t.expressionStatement(expression);

另请参阅 t.isExpressionStatement(node, opts) 和 t.assertExpressionStatement(node, opts)。

AST 节点 ExpressionStatement 形状

expression：Expression（必需）

别名：Standardized、Statement、ExpressionWrapper

file

JavaScript
t.file(program, comments, tokens);

另请参阅 t.isFile(node, opts) 和 t.assertFile(node, opts)。

AST 节点 File 形状

program: Program（必需）
comments: Array<CommentBlock | CommentLine>（默认值：null）
tokens: Array<any>（默认值：null）

别名：Standardized

forInStatement

JavaScript
t.forInStatement(left, right, body);

另请参阅 t.isForInStatement(node, opts) 和 t.assertForInStatement(node, opts)。

AST 节点 ForInStatement 形状

left: VariableDeclaration | LVal（必需）
right：Expression（必需）
body：Statement（必需）

别名：Standardized、Scopable、Statement、For、BlockParent、Loop、ForXStatement

forOfStatement

JavaScript
t.forOfStatement(left, right, body, await);

另请参阅 t.isForOfStatement(node, opts) 和 t.assertForOfStatement(node, opts)。

AST 节点 ForOfStatement 形状

left: VariableDeclaration | LVal（必需）
right：Expression（必需）
body：Statement（必需）
await: boolean（默认值：false）

别名：Standardized、Scopable、Statement、For、BlockParent、Loop、ForXStatement

forStatement

JavaScript
t.forStatement(init, test, update, body);

另请参阅 t.isForStatement(node, opts) 和 t.assertForStatement(node, opts)。

AST 节点 ForStatement 形状

init: VariableDeclaration | Expression（默认值：null）
test: Expression（默认值：null）
update: Expression（默认值：null）
body：Statement（必需）

别名：Standardized、Scopable、Statement、For、BlockParent、Loop

functionDeclaration

JavaScript
t.functionDeclaration(id, params, body, generator, async);

另请参阅 t.isFunctionDeclaration(node, opts) 和 t.assertFunctionDeclaration(node, opts)。

AST 节点 FunctionDeclaration 形状

id: Identifier（默认值：null）
params：Array<Identifier | Pattern | RestElement>（必需）
body: BlockStatement（必需）
generator: boolean（默认值：false）
async：boolean（默认：false）
declare: boolean（默认值：null，从构建器函数中排除）
predicate：DeclaredPredicate | InferredPredicate（默认：null，从构建器函数中排除）
returnType：TypeAnnotation | TSTypeAnnotation | Noop（默认：null，从构建器函数中排除）
typeParameters：TypeParameterDeclaration | TSTypeParameterDeclaration | Noop（默认：null，从构建器函数中排除）

别名：Standardized、Scopable、Function、BlockParent、FunctionParent、Statement、Pureish、Declaration

functionExpression

JavaScript
t.functionExpression(id, params, body, generator, async);

另请参阅 t.isFunctionExpression(node, opts) 和 t.assertFunctionExpression(node, opts)。

AST 节点 FunctionExpression 形状

id: Identifier（默认值：null）
params：Array<Identifier | Pattern | RestElement>（必需）
body: BlockStatement（必需）
generator: boolean（默认值：false）
async：boolean（默认：false）
predicate：DeclaredPredicate | InferredPredicate（默认：null，从构建器函数中排除）
returnType：TypeAnnotation | TSTypeAnnotation | Noop（默认：null，从构建器函数中排除）
typeParameters：TypeParameterDeclaration | TSTypeParameterDeclaration | Noop（默认：null，从构建器函数中排除）

别名：Standardized、Scopable、Function、BlockParent、FunctionParent、Expression、Pureish

functionTypeAnnotation

JavaScript
t.functionTypeAnnotation(typeParameters, params, rest, returnType);

另请参阅 t.isFunctionTypeAnnotation(node, opts) 和 t.assertFunctionTypeAnnotation(node, opts)。

AST 节点 FunctionTypeAnnotation 形状

typeParameters：TypeParameterDeclaration（默认：null）
params: Array<FunctionTypeParam>（必需）
rest: FunctionTypeParam（默认值：null）
returnType: FlowType（必需）
this: FunctionTypeParam（默认值：null，从生成器函数中排除）

别名：Flow、FlowType

functionTypeParam

JavaScript
t.functionTypeParam(name, typeAnnotation);

另请参阅 t.isFunctionTypeParam(node, opts) 和 t.assertFunctionTypeParam(node, opts)。

AST 节点 FunctionTypeParam 形状

name: Identifier（默认值：null）
typeAnnotation: FlowType（必需）
optional: boolean（默认值：null，从构建器函数中排除）

别名：Flow

genericTypeAnnotation

JavaScript
t.genericTypeAnnotation(id, typeParameters);

另请参阅 t.isGenericTypeAnnotation(node, opts) 和 t.assertGenericTypeAnnotation(node, opts)。

AST 节点 GenericTypeAnnotation 形状

id: Identifier | QualifiedTypeIdentifier（必需）
typeParameters: TypeParameterInstantiation（默认值：null）

别名：Flow、FlowType

identifier

JavaScript
t.identifier(name);

另请参阅 t.isIdentifier(node, opts) 和 t.assertIdentifier(node, opts)。

AST 节点 Identifier 形状

name: string（必需）
decorators: Array<Decorator>（默认值：null，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop（默认值：null，从构建器函数中排除）

别名：Standardized、Expression、PatternLike、LVal、TSEntityName

ifStatement

JavaScript
t.ifStatement(test, consequent, alternate);

另请参阅 t.isIfStatement(node, opts) 和 t.assertIfStatement(node, opts)。

AST 节点 IfStatement 形状

test：Expression（必需）
consequent: Statement（必需）
alternate: Statement（默认值：null）

别名：Standardized、Statement、Conditional

import

JavaScript
t.import();

另请参阅 t.isImport(node, opts) 和 t.assertImport(node, opts)。

别名：Standardized、Expression

importAttribute

JavaScript
t.importAttribute(key, value);

另请参阅 t.isImportAttribute(node, opts) 和 t.assertImportAttribute(node, opts)。

AST 节点 ImportAttribute 形状

key: Identifier | StringLiteral（必需）
value: StringLiteral（必需）

importDeclaration

JavaScript
t.importDeclaration(specifiers, source);

历史记录

版本	更改
`v7.20.0`	支持 `module`

另请参阅 t.isImportDeclaration(node, opts) 和 t.assertImportDeclaration(node, opts)。

AST 节点 ImportDeclaration 形状

specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>（必需）
source: StringLiteral（必需）
assertions: Array<ImportAttribute>（默认值：null，从构建器函数中排除）
attributes: Array<ImportAttribute>（默认值：null，从构建器函数中排除）
importKind: "type" | "typeof" | "value"（默认值：null，从生成器函数中排除）
module: boolean（默认值：null，从生成器函数中排除）
phase: "source" | "defer"（默认值：null，从生成器函数中排除）

别名：Standardized、Statement、Declaration、ImportOrExportDeclaration

importDefaultSpecifier

JavaScript
t.importDefaultSpecifier(local);

另请参阅 t.isImportDefaultSpecifier(node, opts) 和 t.assertImportDefaultSpecifier(node, opts)。

AST 节点 ImportDefaultSpecifier 形状

local: Identifier（必需）

别名：Standardized、ModuleSpecifier

importExpression

JavaScript
t.importExpression(source, options);

另请参阅 t.isImportExpression(node, opts) 和 t.assertImportExpression(node, opts)。

AST 节点 ImportExpression 形状

source: Expression（必需）
options: Expression（默认值：null）
phase: "source" | "defer"（默认值：null，从生成器函数中排除）

别名：Standardized、Expression

importNamespaceSpecifier

JavaScript
t.importNamespaceSpecifier(local);

另请参阅 t.isImportNamespaceSpecifier(node, opts) 和 t.assertImportNamespaceSpecifier(node, opts)。

AST 节点 ImportNamespaceSpecifier 形状

local: Identifier（必需）

别名：Standardized、ModuleSpecifier

importSpecifier

JavaScript
t.importSpecifier(local, imported);

另请参见 t.isImportSpecifier(node, opts) 和 t.assertImportSpecifier(node, opts)。

AST 节点 ImportSpecifier 形状

local: Identifier（必需）
imported: Identifier | StringLiteral（必需）
importKind: "type" | "typeof" | "value"（默认值：null，从生成器函数中排除）

别名：Standardized、ModuleSpecifier

indexedAccessType

JavaScript
t.indexedAccessType(objectType, indexType);

另请参见 t.isIndexedAccessType(node, opts) 和 t.assertIndexedAccessType(node, opts)。

AST 节点 IndexedAccessType 形状

objectType: FlowType（必需）
indexType: FlowType（必需）

别名：Flow、FlowType

inferredPredicate

JavaScript
t.inferredPredicate();

另请参见 t.isInferredPredicate(node, opts) 和 t.assertInferredPredicate(node, opts)。

别名：Flow、FlowPredicate

interfaceDeclaration

JavaScript
t.interfaceDeclaration(id, typeParameters, extends, body);

另请参见 t.isInterfaceDeclaration(node, opts) 和 t.assertInterfaceDeclaration(node, opts)。

AST 节点 InterfaceDeclaration 形状

id: Identifier（必需）
typeParameters：TypeParameterDeclaration（默认：null）
extends：Array<InterfaceExtends>（默认：null）
body: ObjectTypeAnnotation（必需）

别名：Flow、FlowDeclaration、Statement、Declaration

interfaceExtends

JavaScript
t.interfaceExtends(id, typeParameters);

另请参见 t.isInterfaceExtends(node, opts) 和 t.assertInterfaceExtends(node, opts)。

AST 节点 InterfaceExtends 形状

id: Identifier | QualifiedTypeIdentifier（必需）
typeParameters: TypeParameterInstantiation（默认值：null）

别名：Flow

interfaceTypeAnnotation

JavaScript
t.interfaceTypeAnnotation(extends, body);

另请参见 t.isInterfaceTypeAnnotation(node, opts) 和 t.assertInterfaceTypeAnnotation(node, opts)。

AST 节点 InterfaceTypeAnnotation 形状

extends：Array<InterfaceExtends>（默认：null）
body: ObjectTypeAnnotation（必需）

别名：Flow、FlowType

interpreterDirective

JavaScript
t.interpreterDirective(value);

另请参见 t.isInterpreterDirective(node, opts) 和 t.assertInterpreterDirective(node, opts)。

AST 节点 InterpreterDirective 形状

value：string（必需）

别名：Standardized

intersectionTypeAnnotation

JavaScript
t.intersectionTypeAnnotation(types);

另请参见 t.isIntersectionTypeAnnotation(node, opts) 和 t.assertIntersectionTypeAnnotation(node, opts)。

AST 节点 IntersectionTypeAnnotation 形状

types: Array<FlowType>（必需）

别名：Flow、FlowType

jsxAttribute

JavaScript
t.jsxAttribute(name, value);

另请参见 t.isJSXAttribute(node, opts) 和 t.assertJSXAttribute(node, opts)。

AST 节点 JSXAttribute 形状

name: JSXIdentifier | JSXNamespacedName（必需）
value: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer（默认值：null）

别名：JSX，Immutable

jsxClosingElement

JavaScript
t.jsxClosingElement(name);

另请参见 t.isJSXClosingElement(node, opts) 和 t.assertJSXClosingElement(node, opts)。

AST 节点 JSXClosingElement 形状

name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName（必需）

别名：JSX，Immutable

jsxClosingFragment

JavaScript
t.jsxClosingFragment();

另请参见 t.isJSXClosingFragment(node, opts) 和 t.assertJSXClosingFragment(node, opts)。

别名：JSX，Immutable

jsxElement

JavaScript
t.jsxElement(openingElement, closingElement, children, selfClosing);

另请参见 t.isJSXElement(node, opts) 和 t.assertJSXElement(node, opts)。

AST 节点 JSXElement 形状

openingElement: JSXOpeningElement（必需）
closingElement: JSXClosingElement（默认值：null）
children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>（必需）
selfClosing: boolean（默认值：null）

别名：JSX、Immutable、Expression

jsxEmptyExpression

JavaScript
t.jsxEmptyExpression();

另请参阅 t.isJSXEmptyExpression(node, opts) 和 t.assertJSXEmptyExpression(node, opts)。

别名：JSX

jsxExpressionContainer

JavaScript
t.jsxExpressionContainer(expression);

另请参阅 t.isJSXExpressionContainer(node, opts) 和 t.assertJSXExpressionContainer(node, opts)。

AST 节点 JSXExpressionContainer 形状

expression: Expression | JSXEmptyExpression（必需）

别名：JSX，Immutable

jsxFragment

JavaScript
t.jsxFragment(openingFragment, closingFragment, children);

另请参阅 t.isJSXFragment(node, opts) 和 t.assertJSXFragment(node, opts)。

AST 节点 JSXFragment 形状

openingFragment: JSXOpeningFragment（必需）
closingFragment: JSXClosingFragment（必需）
children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>（必需）

别名：JSX、Immutable、Expression

jsxIdentifier

JavaScript
t.jsxIdentifier(name);

另请参阅 t.isJSXIdentifier(node, opts) 和 t.assertJSXIdentifier(node, opts)。

AST 节点 JSXIdentifier 形状

name: string（必需）

别名：JSX

jsxMemberExpression

JavaScript
t.jsxMemberExpression(object, property);

另请参阅 t.isJSXMemberExpression(node, opts) 和 t.assertJSXMemberExpression(node, opts)。

AST 节点 JSXMemberExpression 形状

object: JSXMemberExpression | JSXIdentifier（必需）
property: JSXIdentifier（必需）

别名：JSX

jsxNamespacedName

JavaScript
t.jsxNamespacedName(namespace, name);

另请参阅 t.isJSXNamespacedName(node, opts) 和 t.assertJSXNamespacedName(node, opts)。

AST 节点 JSXNamespacedName 形状

namespace: JSXIdentifier（必需）
name: JSXIdentifier（必需）

别名：JSX

jsxOpeningElement

JavaScript
t.jsxOpeningElement(name, attributes, selfClosing);

另请参阅 t.isJSXOpeningElement(node, opts) 和 t.assertJSXOpeningElement(node, opts)。

AST 节点 JSXOpeningElement 形状

name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName（必需）
attributes: Array<JSXAttribute | JSXSpreadAttribute>（必需）
selfClosing: boolean（默认值：false）
typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation（默认值：null，从构建器函数中排除）

别名：JSX，Immutable

jsxOpeningFragment

JavaScript
t.jsxOpeningFragment();

另请参阅 t.isJSXOpeningFragment(node, opts) 和 t.assertJSXOpeningFragment(node, opts)。

别名：JSX，Immutable

jsxSpreadAttribute

JavaScript
t.jsxSpreadAttribute(argument);

另请参阅 t.isJSXSpreadAttribute(node, opts) 和 t.assertJSXSpreadAttribute(node, opts)。

AST 节点 JSXSpreadAttribute 形状

argument：Expression（必需）

别名：JSX

jsxSpreadChild

JavaScript
t.jsxSpreadChild(expression);

另请参阅 t.isJSXSpreadChild(node, opts) 和 t.assertJSXSpreadChild(node, opts)。

AST 节点 JSXSpreadChild 形状

expression：Expression（必需）

别名：JSX，Immutable

jsxText

JavaScript
t.jsxText(value);

另请参阅 t.isJSXText(node, opts) 和 t.assertJSXText(node, opts)。

AST 节点 JSXText 形状

value：string（必需）

别名：JSX，Immutable

labeledStatement

JavaScript
t.labeledStatement(label, body);

另请参阅 t.isLabeledStatement(node, opts) 和 t.assertLabeledStatement(node, opts)。

AST 节点 LabeledStatement 形状

label: Identifier（必需）
body：Statement（必需）

别名：Standardized、Statement

逻辑表达式

JavaScript
t.logicalExpression(operator, left, right);

另请参阅 t.isLogicalExpression(node, opts) 和 t.assertLogicalExpression(node, opts)。

AST 节点 LogicalExpression 形状

operator: "||" | "&&" | "??"（必需）
left: Expression（必需）
right：Expression（必需）

别名：Standardized、Binary、Expression

成员表达式

JavaScript
t.memberExpression(object, property, computed, optional);

另请参阅 t.isMemberExpression(node, opts) 和 t.assertMemberExpression(node, opts)。

AST 节点 MemberExpression 形状

object: Expression | Super（必需）
property: 如果计算则为 Expression，否则为 Identifier（必需）
computed: boolean（默认值：false）
optional: true | false（默认值：null）

别名：Standardized、Expression、LVal

元属性

JavaScript
t.metaProperty(meta, property);

另请参阅 t.isMetaProperty(node, opts) 和 t.assertMetaProperty(node, opts)。

AST 节点 MetaProperty 形状

meta: Identifier（必需）
property: Identifier（必需）

别名：Standardized、Expression

混合类型注解

JavaScript
t.mixedTypeAnnotation();

另请参阅 t.isMixedTypeAnnotation(node, opts) 和 t.assertMixedTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

模块表达式

JavaScript
t.moduleExpression(body);

另请参阅 t.isModuleExpression(node, opts) 和 t.assertModuleExpression(node, opts)。

AST 节点 ModuleExpression 形状

body: Program（必需）

别名：Expression

新表达式

JavaScript
t.newExpression(callee, arguments);

另请参阅 t.isNewExpression(node, opts) 和 t.assertNewExpression(node, opts)。

AST 节点 NewExpression 形状

callee: Expression | Super | V8IntrinsicIdentifier（必需）
arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>（必需）
optional: true | false（默认值：null，从生成器函数中排除）
typeArguments: TypeParameterInstantiation（默认值：null，从生成器函数中排除）
typeParameters: TSTypeParameterInstantiation（默认值：null，从生成器函数中排除）

别名：Standardized、Expression

空操作

JavaScript
t.noop();

另请参阅 t.isNoop(node, opts) 和 t.assertNoop(node, opts)。

别名：Miscellaneous

空文字

JavaScript
t.nullLiteral();

另请参阅 t.isNullLiteral(node, opts) 和 t.assertNullLiteral(node, opts)。

别名：Standardized、Expression、Pureish、Literal、Immutable

空文字类型注解

JavaScript
t.nullLiteralTypeAnnotation();

另请参阅 t.isNullLiteralTypeAnnotation(node, opts) 和 t.assertNullLiteralTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

可空类型注解

JavaScript
t.nullableTypeAnnotation(typeAnnotation);

另请参阅 t.isNullableTypeAnnotation(node, opts) 和 t.assertNullableTypeAnnotation(node, opts)。

AST 节点 NullableTypeAnnotation 形状

typeAnnotation: FlowType（必需）

别名：Flow、FlowType

数字文字类型注解

JavaScript
t.numberLiteralTypeAnnotation(value);

另请参阅 t.isNumberLiteralTypeAnnotation(node, opts) 和 t.assertNumberLiteralTypeAnnotation(node, opts)。

AST 节点 NumberLiteralTypeAnnotation 形状

value: number（必需）

别名：Flow、FlowType

数字类型注解

JavaScript
t.numberTypeAnnotation();

另请参阅 t.isNumberTypeAnnotation(node, opts) 和 t.assertNumberTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

数字文字

JavaScript
t.numericLiteral(value);

另请参阅t.isNumericLiteral(node, opts)和t.assertNumericLiteral(node, opts)。

AST 节点NumericLiteral形状

value：非负有限number（必需）

别名：Standardized、Expression、Pureish、Literal、Immutable

对象表达式

JavaScript
t.objectExpression(properties);

另请参阅t.isObjectExpression(node, opts)和t.assertObjectExpression(node, opts)。

AST 节点ObjectExpression形状

properties：Array<ObjectMethod | ObjectProperty | SpreadElement>（必需）

别名：Standardized、Expression

对象方法

JavaScript
t.objectMethod(kind, key, params, body, computed, generator, async);

另请参阅t.isObjectMethod(node, opts)和t.assertObjectMethod(node, opts)。

AST 节点ObjectMethod形状

kind："method" | "get" | "set"（默认：'method'）
key: 如果计算则为 Expression，否则为 Identifier | Literal（必需）
params：Array<Identifier | Pattern | RestElement>（必需）
body: BlockStatement（必需）
computed: boolean（默认值：false）
generator: boolean（默认值：false）
async：boolean（默认：false）
decorators: Array<Decorator>（默认值：null，从构建器函数中排除）
returnType：TypeAnnotation | TSTypeAnnotation | Noop（默认：null，从构建器函数中排除）
typeParameters：TypeParameterDeclaration | TSTypeParameterDeclaration | Noop（默认：null，从构建器函数中排除）

别名：Standardized、UserWhitespacable、Function、Scopable、BlockParent、FunctionParent、Method、ObjectMember

对象模式

JavaScript
t.objectPattern(properties);

另请参阅t.isObjectPattern(node, opts)和t.assertObjectPattern(node, opts)。

AST 节点ObjectPattern形状

properties：Array<RestElement | ObjectProperty>（必需）
decorators: Array<Decorator>（默认值：null，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop（默认值：null，从构建器函数中排除）

别名：Standardized、Pattern、PatternLike、LVal

对象属性

JavaScript
t.objectProperty(key, value, computed, shorthand, decorators);

另请参阅t.isObjectProperty(node, opts)和t.assertObjectProperty(node, opts)。

AST 节点ObjectProperty形状

key: 如果计算则为 Expression，否则为 Identifier | Literal（必需）
value：Expression | PatternLike（必需）
computed: boolean（默认值：false）
shorthand：boolean（默认：false）
decorators: Array<Decorator>（默认值：null）

别名：Standardized、UserWhitespacable、Property、ObjectMember

对象类型注释

JavaScript
t.objectTypeAnnotation(properties, indexers, callProperties, internalSlots, exact);

另请参阅t.isObjectTypeAnnotation(node, opts)和t.assertObjectTypeAnnotation(node, opts)。

AST 节点ObjectTypeAnnotation形状

properties：Array<ObjectTypeProperty | ObjectTypeSpreadProperty>（必需）
indexers：Array<ObjectTypeIndexer>（默认：[]）
callProperties：Array<ObjectTypeCallProperty>（默认：[]）
internalSlots：Array<ObjectTypeInternalSlot>（默认：[]）
exact：boolean（默认：false）
inexact：boolean（默认：null，从生成器函数中排除）

别名：Flow、FlowType

对象类型调用属性

JavaScript
t.objectTypeCallProperty(value);

另请参阅t.isObjectTypeCallProperty(node, opts)和t.assertObjectTypeCallProperty(node, opts)。

AST 节点ObjectTypeCallProperty形状

value：FlowType（必需）
static：boolean（必需）

别名：Flow、UserWhitespacable

对象类型索引器

JavaScript
t.objectTypeIndexer(id, key, value, variance);

另请参阅t.isObjectTypeIndexer(node, opts)和t.assertObjectTypeIndexer(node, opts)。

AST 节点ObjectTypeIndexer形状

id: Identifier（默认值：null）
key：FlowType（必需）
value：FlowType（必需）
variance：Variance（默认：null）
static：boolean（必需）

别名：Flow、UserWhitespacable

对象类型内部槽

JavaScript
t.objectTypeInternalSlot(id, value, optional, static, method);

另请参阅t.isObjectTypeInternalSlot(node, opts)和t.assertObjectTypeInternalSlot(node, opts)。

AST 节点ObjectTypeInternalSlot形状

id: Identifier（必需）
value：FlowType（必需）
optional：boolean（必需）
static：boolean（必需）
method: boolean（必需）

别名：Flow、UserWhitespacable

objectTypeProperty

JavaScript
t.objectTypeProperty(key, value, variance);

另请参阅 t.isObjectTypeProperty(node, opts) 和 t.assertObjectTypeProperty(node, opts)。

AST 节点 ObjectTypeProperty 形状

key: Identifier | StringLiteral（必需）
value：FlowType（必需）
variance：Variance（默认：null）
kind: "init" | "get" | "set"（必需）
method: boolean（必需）
optional：boolean（必需）
proto: boolean（必需）
static：boolean（必需）

别名：Flow、UserWhitespacable

objectTypeSpreadProperty

JavaScript
t.objectTypeSpreadProperty(argument);

另请参阅 t.isObjectTypeSpreadProperty(node, opts) 和 t.assertObjectTypeSpreadProperty(node, opts)。

AST 节点 ObjectTypeSpreadProperty 形状

argument: FlowType（必需）

别名：Flow、UserWhitespacable

opaqueType

JavaScript
t.opaqueType(id, typeParameters, supertype, impltype);

另请参阅 t.isOpaqueType(node, opts) 和 t.assertOpaqueType(node, opts)。

AST 节点 OpaqueType 形状

id: Identifier（必需）
typeParameters：TypeParameterDeclaration（默认：null）
supertype: FlowType（默认值：null）
impltype: FlowType（必需）

别名：Flow、FlowDeclaration、Statement、Declaration

optionalCallExpression

JavaScript
t.optionalCallExpression(callee, arguments, optional);

另请参阅 t.isOptionalCallExpression(node, opts) 和 t.assertOptionalCallExpression(node, opts)。

AST 节点 OptionalCallExpression 形状

callee: Expression（必需）
arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>（必需）
optional：boolean（必需）
typeArguments: TypeParameterInstantiation（默认值：null，从生成器函数中排除）
typeParameters: TSTypeParameterInstantiation（默认值：null，从生成器函数中排除）

别名：Standardized、Expression

optionalIndexedAccessType

JavaScript
t.optionalIndexedAccessType(objectType, indexType);

另请参阅 t.isOptionalIndexedAccessType(node, opts) 和 t.assertOptionalIndexedAccessType(node, opts)。

AST 节点 OptionalIndexedAccessType 形状

objectType: FlowType（必需）
indexType: FlowType（必需）
optional：boolean（必需）

别名：Flow、FlowType

optionalMemberExpression

JavaScript
t.optionalMemberExpression(object, property, computed, optional);

另请参阅 t.isOptionalMemberExpression(node, opts) 和 t.assertOptionalMemberExpression(node, opts)。

AST 节点 OptionalMemberExpression 形状

object: Expression（必需）
property: Expression | Identifier（必需）
computed: boolean（默认值：false）
optional：boolean（必需）

别名：Standardized、Expression

parenthesizedExpression

JavaScript
t.parenthesizedExpression(expression);

另请参阅 t.isParenthesizedExpression(node, opts) 和 t.assertParenthesizedExpression(node, opts)。

AST 节点 ParenthesizedExpression 形状

expression：Expression（必需）

别名：Standardized、Expression、ExpressionWrapper

pipelineBareFunction

JavaScript
t.pipelineBareFunction(callee);

另请参阅 t.isPipelineBareFunction(node, opts) 和 t.assertPipelineBareFunction(node, opts)。

AST 节点 PipelineBareFunction 形状

callee: Expression（必需）

别名：Expression

pipelinePrimaryTopicReference

JavaScript
t.pipelinePrimaryTopicReference();

另请参阅 t.isPipelinePrimaryTopicReference(node, opts) 和 t.assertPipelinePrimaryTopicReference(node, opts)。

别名：Expression

pipelineTopicExpression

JavaScript
t.pipelineTopicExpression(expression);

另请参阅 t.isPipelineTopicExpression(node, opts) 和 t.assertPipelineTopicExpression(node, opts)。

AST 节点 PipelineTopicExpression 形状

expression：Expression（必需）

别名：Expression

placeholder

JavaScript
t.placeholder(expectedNode, name);

另请参阅 t.isPlaceholder(node, opts) 和 t.assertPlaceholder(node, opts)。

AST 节点 Placeholder 形状

expectedNode: "标识符" | "字符串字面量" | "表达式" | "语句" | "声明" | "块语句" | "类主体" | "模式" (必需)
name: 标识符 (必需)

别名：Miscellaneous

privateName

JavaScript
t.privateName(id);

另请参阅 t.isPrivateName(node, opts) 和 t.assertPrivateName(node, opts)。

AST 节点 PrivateName 形状

id: Identifier（必需）

别名：Standardized，Private

program

JavaScript
t.program(body, directives, sourceType, interpreter);

另请参阅 t.isProgram(node, opts) 和 t.assertProgram(node, opts)。

AST 节点 Program 形状

body: Array<Statement>（必需）
directives: Array<Directive>（默认值：[]）
sourceType: "script" | "module" (默认：'script')
interpreter: InterpreterDirective (默认：null)

别名：Standardized，Scopable，BlockParent，Block

qualifiedTypeIdentifier

JavaScript
t.qualifiedTypeIdentifier(id, qualification);

另请参阅 t.isQualifiedTypeIdentifier(node, opts) 和 t.assertQualifiedTypeIdentifier(node, opts)。

AST 节点 QualifiedTypeIdentifier 形状

id: Identifier（必需）
qualification: 标识符 | QualifiedTypeIdentifier (必需)

别名：Flow

recordExpression

JavaScript
t.recordExpression(properties);

另请参阅 t.isRecordExpression(node, opts) 和 t.assertRecordExpression(node, opts)。

AST 节点 RecordExpression 形状

properties: Array<ObjectProperty | SpreadElement> (必需)

别名：Expression

regExpLiteral

JavaScript
t.regExpLiteral(pattern, flags);

另请参阅 t.isRegExpLiteral(node, opts) 和 t.assertRegExpLiteral(node, opts)。

AST 节点 RegExpLiteral 形状

pattern: string (必需)
flags: string (默认：'')

别名：Standardized，Expression，Pureish，Literal

restElement

JavaScript
t.restElement(argument);

另请参阅 t.isRestElement(node, opts) 和 t.assertRestElement(node, opts)。

AST 节点 RestElement 形状

argument: LVal (必需)
decorators: Array<Decorator>（默认值：null，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop（默认值：null，从构建器函数中排除）

别名：Standardized，LVal，PatternLike

returnStatement

JavaScript
t.returnStatement(argument);

另请参阅 t.isReturnStatement(node, opts) 和 t.assertReturnStatement(node, opts)。

AST 节点 ReturnStatement 形状

argument: Expression (默认：null)

别名：Standardized、Statement、Terminatorless、CompletionStatement

sequenceExpression

JavaScript
t.sequenceExpression(expressions);

另请参阅 t.isSequenceExpression(node, opts) 和 t.assertSequenceExpression(node, opts)。

AST 节点 SequenceExpression 形状

expressions: Array<Expression> (必需)

别名：Standardized、Expression

spreadElement

JavaScript
t.spreadElement(argument);

另请参阅 t.isSpreadElement(node, opts) 和 t.assertSpreadElement(node, opts)。

AST 节点 SpreadElement 形状

argument：Expression（必需）

别名：Standardized，UnaryLike

staticBlock

JavaScript
t.staticBlock(body);

另请参阅 t.isStaticBlock(node, opts) 和 t.assertStaticBlock(node, opts)。

AST 节点 StaticBlock 形状

body: Array<Statement>（必需）

别名：Standardized、Scopable、BlockParent、FunctionParent

stringLiteral

JavaScript
t.stringLiteral(value);

另请参阅 t.isStringLiteral(node, opts) 和 t.assertStringLiteral(node, opts)。

AST 节点 StringLiteral 形状

value：string（必需）

别名：Standardized、Expression、Pureish、Literal、Immutable

stringLiteralTypeAnnotation

JavaScript
t.stringLiteralTypeAnnotation(value);

另请参阅 t.isStringLiteralTypeAnnotation(node, opts) 和 t.assertStringLiteralTypeAnnotation(node, opts)。

AST 节点 StringLiteralTypeAnnotation 形状

value：string（必需）

别名：Flow、FlowType

stringTypeAnnotation

JavaScript
t.stringTypeAnnotation();

另请参阅 t.isStringTypeAnnotation(node, opts) 和 t.assertStringTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

super

JavaScript
t.super();

另请参阅 t.isSuper(node, opts) 和 t.assertSuper(node, opts)。

别名：Standardized、Expression

switchCase

JavaScript
t.switchCase(test, consequent);

另请参阅 t.isSwitchCase(node, opts) 和 t.assertSwitchCase(node, opts)。

AST 节点 SwitchCase 形状

test: Expression（默认值：null）
consequent: Array<Statement>（必需）

别名：Standardized

switchStatement

JavaScript
t.switchStatement(discriminant, cases);

另请参阅 t.isSwitchStatement(node, opts) 和 t.assertSwitchStatement(node, opts)。

AST 节点 SwitchStatement 形状

discriminant: Expression（必需）
cases: Array<SwitchCase>（必需）

别名：Standardized、Statement、BlockParent、Scopable

symbolTypeAnnotation

JavaScript
t.symbolTypeAnnotation();

另请参阅 t.isSymbolTypeAnnotation(node, opts) 和 t.assertSymbolTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

tsAnyKeyword

JavaScript
t.tsAnyKeyword();

另请参阅 t.isTSAnyKeyword(node, opts) 和 t.assertTSAnyKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsArrayType

JavaScript
t.tsArrayType(elementType);

另请参阅 t.isTSArrayType(node, opts) 和 t.assertTSArrayType(node, opts)。

AST 节点 TSArrayType 形状

elementType: TSType（必需）

别名：TypeScript、TSType

tsAsExpression

JavaScript
t.tsAsExpression(expression, typeAnnotation);

另请参阅 t.isTSAsExpression(node, opts) 和 t.assertTSAsExpression(node, opts)。

AST 节点 TSAsExpression 形状

expression：Expression（必需）
typeAnnotation: TSType（必需）

别名：TypeScript、Expression、LVal、PatternLike

tsBigIntKeyword

JavaScript
t.tsBigIntKeyword();

另请参阅 t.isTSBigIntKeyword(node, opts) 和 t.assertTSBigIntKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsBooleanKeyword

JavaScript
t.tsBooleanKeyword();

另请参见 t.isTSBooleanKeyword(node, opts) 和 t.assertTSBooleanKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsCallSignatureDeclaration

JavaScript
t.tsCallSignatureDeclaration(typeParameters, parameters, typeAnnotation);

另请参见 t.isTSCallSignatureDeclaration(node, opts) 和 t.assertTSCallSignatureDeclaration(node, opts)。

AST 节点 TSCallSignatureDeclaration 形状

typeParameters: TSTypeParameterDeclaration（默认值：null）
parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>（必需）
typeAnnotation: TSTypeAnnotation（默认值：null）

别名：TypeScript，TSTypeElement

tsConditionalType

JavaScript
t.tsConditionalType(checkType, extendsType, trueType, falseType);

另请参见 t.isTSConditionalType(node, opts) 和 t.assertTSConditionalType(node, opts)。

AST 节点 TSConditionalType 形状

checkType: TSType（必需）
extendsType: TSType（必需）
trueType: TSType（必需）
falseType: TSType（必需）

别名：TypeScript、TSType

tsConstructSignatureDeclaration

JavaScript
t.tsConstructSignatureDeclaration(typeParameters, parameters, typeAnnotation);

另请参见 t.isTSConstructSignatureDeclaration(node, opts) 和 t.assertTSConstructSignatureDeclaration(node, opts)。

AST 节点 TSConstructSignatureDeclaration 形状

typeParameters: TSTypeParameterDeclaration（默认值：null）
parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>（必需）
typeAnnotation: TSTypeAnnotation（默认值：null）

别名：TypeScript，TSTypeElement

tsConstructorType

JavaScript
t.tsConstructorType(typeParameters, parameters, typeAnnotation);

另请参见 t.isTSConstructorType(node, opts) 和 t.assertTSConstructorType(node, opts)。

AST 节点 TSConstructorType 形状

typeParameters: TSTypeParameterDeclaration（默认值：null）
parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>（必需）
typeAnnotation: TSTypeAnnotation（默认值：null）
abstract: boolean（默认值：null，从构建器函数中排除）

别名：TypeScript、TSType

tsDeclareFunction

JavaScript
t.tsDeclareFunction(id, typeParameters, params, returnType);

另请参见 t.isTSDeclareFunction(node, opts) 和 t.assertTSDeclareFunction(node, opts)。

AST 节点 TSDeclareFunction 形状

id: Identifier（默认值：null）
typeParameters: TSTypeParameterDeclaration | Noop（默认值：null）
params：Array<Identifier | Pattern | RestElement>（必需）
returnType: TSTypeAnnotation | Noop（默认值：null）
async：boolean（默认：false，从构建器函数中排除）
declare: boolean（默认值：null，从构建器函数中排除）
generator：boolean（默认：false，从构建器函数中排除）

别名：TypeScript，Statement，Declaration

tsDeclareMethod

JavaScript
t.tsDeclareMethod(decorators, key, typeParameters, params, returnType);

另请参见 t.isTSDeclareMethod(node, opts) 和 t.assertTSDeclareMethod(node, opts)。

AST 节点 TSDeclareMethod 形状

decorators: Array<Decorator>（默认值：null）
key：Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression（必需）
typeParameters: TSTypeParameterDeclaration | Noop（默认值：null）
params: Array<Identifier | Pattern | RestElement | TSParameterProperty>（必需）
returnType: TSTypeAnnotation | Noop（默认值：null）
abstract: boolean（默认值：null，从构建器函数中排除）
access: "public" | "private" | "protected"（默认值：null，从构建器函数中排除）
accessibility: "public" | "private" | "protected"（默认值：null，从构建器函数中排除）
async：boolean（默认：false，从构建器函数中排除）
computed: boolean（默认值：false，从构建器函数中排除）
generator：boolean（默认：false，从构建器函数中排除）
kind: "get" | "set" | "method" | "constructor"（默认值：'method'，从构建器函数中排除）
optional: boolean（默认值：null，从构建器函数中排除）
override: boolean（默认值：false，从构建器函数中排除）
static: boolean（默认值：false，从构建器函数中排除）

别名：TypeScript

tsEnumDeclaration

JavaScript
t.tsEnumDeclaration(id, members);

另请参见 t.isTSEnumDeclaration(node, opts) 和 t.assertTSEnumDeclaration(node, opts)。

AST 节点 TSEnumDeclaration 形状

id: Identifier（必需）
members: Array<TSEnumMember>（必需）
const: boolean（默认值：null，从构建器函数中排除）
declare: boolean（默认值：null，从构建器函数中排除）
initializer: Expression（默认值：null，从构建器函数中排除）

别名：TypeScript，Statement，Declaration

tsEnumMember

JavaScript
t.tsEnumMember(id, initializer);

另请参见 t.isTSEnumMember(node, opts) 和 t.assertTSEnumMember(node, opts)。

AST 节点 TSEnumMember 形状

id: Identifier | StringLiteral（必需）
initializer: Expression（默认值：null）

别名：TypeScript

tsExportAssignment

JavaScript
t.tsExportAssignment(expression);

另请参见 t.isTSExportAssignment(node, opts) 和 t.assertTSExportAssignment(node, opts)。

AST 节点 TSExportAssignment 形状

expression：Expression（必需）

别名：TypeScript，Statement

tsExpressionWithTypeArguments

JavaScript
t.tsExpressionWithTypeArguments(expression, typeParameters);

另请参阅 t.isTSExpressionWithTypeArguments(node, opts) 和 t.assertTSExpressionWithTypeArguments(node, opts)。

AST 节点 TSExpressionWithTypeArguments 形状

expression: TSEntityName（必需）
typeParameters: TSTypeParameterInstantiation（默认值：null）

别名：TypeScript、TSType

tsExternalModuleReference

JavaScript
t.tsExternalModuleReference(expression);

另请参阅 t.isTSExternalModuleReference(node, opts) 和 t.assertTSExternalModuleReference(node, opts)。

AST 节点 TSExternalModuleReference 形状

expression: StringLiteral（必需）

别名：TypeScript

tsFunctionType

JavaScript
t.tsFunctionType(typeParameters, parameters, typeAnnotation);

另请参阅 t.isTSFunctionType(node, opts) 和 t.assertTSFunctionType(node, opts)。

AST 节点 TSFunctionType 形状

typeParameters: TSTypeParameterDeclaration（默认值：null）
parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>（必需）
typeAnnotation: TSTypeAnnotation（默认值：null）

别名：TypeScript、TSType

tsImportEqualsDeclaration

JavaScript
t.tsImportEqualsDeclaration(id, moduleReference);

另请参阅 t.isTSImportEqualsDeclaration(node, opts) 和 t.assertTSImportEqualsDeclaration(node, opts)。

AST 节点 TSImportEqualsDeclaration 形状

id: Identifier（必需）
moduleReference: TSEntityName | TSExternalModuleReference（必需）
importKind: "type" | "value"（默认值：null，从构建器函数中排除）
isExport: boolean（必需）

别名：TypeScript，Statement

tsImportType

JavaScript
t.tsImportType(argument, qualifier, typeParameters);

另请参阅 t.isTSImportType(node, opts) 和 t.assertTSImportType(node, opts)。

AST 节点 TSImportType 形状

argument: StringLiteral（必需）
qualifier: TSEntityName（默认值：null）
typeParameters: TSTypeParameterInstantiation（默认值：null）
options: Expression（默认值：null，从构建器函数中排除）

别名：TypeScript、TSType

tsIndexSignature

JavaScript
t.tsIndexSignature(parameters, typeAnnotation);

另请参阅 t.isTSIndexSignature(node, opts) 和 t.assertTSIndexSignature(node, opts)。

AST 节点 TSIndexSignature 形状

parameters: Array<Identifier>（必需）
typeAnnotation: TSTypeAnnotation（默认值：null）
readonly: boolean（默认值：null，从构建器函数中排除）
static: boolean（默认值：null，从构建器函数中排除）

别名：TypeScript，TSTypeElement

tsIndexedAccessType

JavaScript
t.tsIndexedAccessType(objectType, indexType);

另请参阅 t.isTSIndexedAccessType(node, opts) 和 t.assertTSIndexedAccessType(node, opts)。

AST 节点 TSIndexedAccessType 形状

objectType: TSType（必需）
indexType: TSType（必需）

别名：TypeScript、TSType

tsInferType

JavaScript
t.tsInferType(typeParameter);

另请参阅 t.isTSInferType(node, opts) 和 t.assertTSInferType(node, opts)。

AST 节点 TSInferType 形状

typeParameter: TSTypeParameter（必需）

别名：TypeScript、TSType

tsInstantiationExpression

JavaScript
t.tsInstantiationExpression(expression, typeParameters);

另请参阅 t.isTSInstantiationExpression(node, opts) 和 t.assertTSInstantiationExpression(node, opts)。

AST 节点 TSInstantiationExpression 形状

expression：Expression（必需）
typeParameters: TSTypeParameterInstantiation（默认值：null）

别名：TypeScript，Expression

tsInterfaceBody

JavaScript
t.tsInterfaceBody(body);

另请参见 t.isTSInterfaceBody(node, opts) 和 t.assertTSInterfaceBody(node, opts)。

AST 节点 TSInterfaceBody 形状

body: Array<TSTypeElement>（必需）

别名：TypeScript

tsInterfaceDeclaration

JavaScript
t.tsInterfaceDeclaration(id, typeParameters, extends, body);

另请参见 t.isTSInterfaceDeclaration(node, opts) 和 t.assertTSInterfaceDeclaration(node, opts)。

AST 节点 TSInterfaceDeclaration 形状

id: Identifier（必需）
typeParameters: TSTypeParameterDeclaration（默认值：null）
extends: Array<TSExpressionWithTypeArguments>（默认值：null）
body: TSInterfaceBody（必需）
declare: boolean（默认值：null，从构建器函数中排除）

别名：TypeScript，Statement，Declaration

tsIntersectionType

JavaScript
t.tsIntersectionType(types);

另请参见 t.isTSIntersectionType(node, opts) 和 t.assertTSIntersectionType(node, opts)。

AST 节点 TSIntersectionType 形状

types: Array<TSType>（必需）

别名：TypeScript、TSType

tsIntrinsicKeyword

JavaScript
t.tsIntrinsicKeyword();

另请参见 t.isTSIntrinsicKeyword(node, opts) 和 t.assertTSIntrinsicKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsLiteralType

JavaScript
t.tsLiteralType(literal);

另请参见 t.isTSLiteralType(node, opts) 和 t.assertTSLiteralType(node, opts)。

AST 节点 TSLiteralType 形状

literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression（必需）

别名：TypeScript、TSType、TSBaseType

tsMappedType

JavaScript
t.tsMappedType(typeParameter, typeAnnotation, nameType);

另请参见 t.isTSMappedType(node, opts) 和 t.assertTSMappedType(node, opts)。

AST 节点 TSMappedType 形状

typeParameter: TSTypeParameter（必需）
typeAnnotation: TSType（默认值：null）
nameType: TSType（默认值：null）
optional: true | false | "+" | "-"（默认值：null，从构建器函数中排除）
readonly: true | false | "+" | "-"（默认值：null，从构建器函数中排除）

别名：TypeScript、TSType

tsMethodSignature

JavaScript
t.tsMethodSignature(key, typeParameters, parameters, typeAnnotation);

另请参见 t.isTSMethodSignature(node, opts) 和 t.assertTSMethodSignature(node, opts)。

AST 节点 TSMethodSignature 形状

key: Expression（必需）
typeParameters: TSTypeParameterDeclaration（默认值：null）
parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>（必需）
typeAnnotation: TSTypeAnnotation（默认值：null）
computed: boolean（默认值：false，从构建器函数中排除）
kind: "method" | "get" | "set"（必需）
optional: boolean（默认值：null，从构建器函数中排除）

别名：TypeScript，TSTypeElement

tsModuleBlock

JavaScript
t.tsModuleBlock(body);

另请参见 t.isTSModuleBlock(node, opts) 和 t.assertTSModuleBlock(node, opts)。

AST 节点 TSModuleBlock 形状

body: Array<Statement>（必需）

别名：TypeScript、Scopable、Block、BlockParent、FunctionParent

tsModuleDeclaration

JavaScript
t.tsModuleDeclaration(id, body);

另请参见 t.isTSModuleDeclaration(node, opts) 和 t.assertTSModuleDeclaration(node, opts)。

AST 节点 TSModuleDeclaration 形状

id: Identifier | StringLiteral（必需）
body: TSModuleBlock | TSModuleDeclaration（必需）
declare: boolean（默认值：null，从构建器函数中排除）
global: boolean（默认值：null，从构建器函数中排除）

别名：TypeScript，Statement，Declaration

tsNamedTupleMember

JavaScript
t.tsNamedTupleMember(label, elementType, optional);

另请参见 t.isTSNamedTupleMember(node, opts) 和 t.assertTSNamedTupleMember(node, opts)。

AST 节点 TSNamedTupleMember 形状

label: Identifier（必需）
elementType: TSType（必需）
可选：布尔值（默认：false）

别名：TypeScript

tsNamespaceExportDeclaration

JavaScript
t.tsNamespaceExportDeclaration(id);

另请参阅 t.isTSNamespaceExportDeclaration(node, opts) 和 t.assertTSNamespaceExportDeclaration(node, opts)。

AST 节点 TSNamespaceExportDeclaration 形状

id: Identifier（必需）

别名：TypeScript，Statement

tsNeverKeyword

JavaScript
t.tsNeverKeyword();

另请参阅 t.isTSNeverKeyword(node, opts) 和 t.assertTSNeverKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsNonNullExpression

JavaScript
t.tsNonNullExpression(expression);

另请参阅 t.isTSNonNullExpression(node, opts) 和 t.assertTSNonNullExpression(node, opts)。

AST 节点 TSNonNullExpression 形状

expression：Expression（必需）

别名：TypeScript、Expression、LVal、PatternLike

tsNullKeyword

JavaScript
t.tsNullKeyword();

另请参阅 t.isTSNullKeyword(node, opts) 和 t.assertTSNullKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsNumberKeyword

JavaScript
t.tsNumberKeyword();

另请参阅 t.isTSNumberKeyword(node, opts) 和 t.assertTSNumberKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsObjectKeyword

JavaScript
t.tsObjectKeyword();

另请参阅 t.isTSObjectKeyword(node, opts) 和 t.assertTSObjectKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsOptionalType

JavaScript
t.tsOptionalType(typeAnnotation);

另请参阅 t.isTSOptionalType(node, opts) 和 t.assertTSOptionalType(node, opts)。

AST 节点 TSOptionalType 形状

typeAnnotation: TSType（必需）

别名：TypeScript、TSType

tsParameterProperty

JavaScript
t.tsParameterProperty(parameter);

另请参阅 t.isTSParameterProperty(node, opts) 和 t.assertTSParameterProperty(node, opts)。

AST 节点 TSParameterProperty 形状

parameter：标识符 | 赋值模式（必需）
accessibility: "public" | "private" | "protected"（默认值：null，从构建器函数中排除）
decorators: Array<Decorator>（默认值：null，从构建器函数中排除）
override：布尔值（默认：null，从生成器函数中排除）
readonly: boolean（默认值：null，从构建器函数中排除）

别名：TypeScript，LVal

tsParenthesizedType

JavaScript
t.tsParenthesizedType(typeAnnotation);

另请参阅 t.isTSParenthesizedType(node, opts) 和 t.assertTSParenthesizedType(node, opts)。

AST 节点 TSParenthesizedType 形状

typeAnnotation: TSType（必需）

别名：TypeScript、TSType

tsPropertySignature

JavaScript
t.tsPropertySignature(key, typeAnnotation);

另请参阅 t.isTSPropertySignature(node, opts) 和 t.assertTSPropertySignature(node, opts)。

AST 节点 TSPropertySignature 形状

key: Expression（必需）
typeAnnotation: TSTypeAnnotation（默认值：null）
computed: boolean（默认值：false，从构建器函数中排除）
kind："get" | "set"（必需）
optional: boolean（默认值：null，从构建器函数中排除）
readonly: boolean（默认值：null，从构建器函数中排除）

别名：TypeScript，TSTypeElement

tsQualifiedName

JavaScript
t.tsQualifiedName(left, right);

另请参阅 t.isTSQualifiedName(node, opts) 和 t.assertTSQualifiedName(node, opts)。

AST 节点 TSQualifiedName 形状

left：TSEntityName（必需）
right：标识符（必需）

别名：TypeScript，TSEntityName

tsRestType

JavaScript
t.tsRestType(typeAnnotation);

另请参阅 t.isTSRestType(node, opts) 和 t.assertTSRestType(node, opts)。

AST 节点 TSRestType 形状

typeAnnotation: TSType（必需）

别名：TypeScript、TSType

tsSatisfiesExpression

JavaScript
t.tsSatisfiesExpression(expression, typeAnnotation);

历史记录

版本	更改
`v7.20.0`	已引入

另请参见t.isTSSatisfiesExpression(node, opts)和t.assertTSSatisfiesExpression(node, opts)。

AST 节点 TSSatisfiesExpression 形状

expression：Expression（必需）
typeAnnotation: TSType（必需）

别名：TypeScript、Expression、LVal、PatternLike

tsStringKeyword

JavaScript
t.tsStringKeyword();

另请参见t.isTSStringKeyword(node, opts)和t.assertTSStringKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsSymbolKeyword

JavaScript
t.tsSymbolKeyword();

另请参见t.isTSSymbolKeyword(node, opts)和t.assertTSSymbolKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsThisType

JavaScript
t.tsThisType();

另请参见t.isTSThisType(node, opts)和t.assertTSThisType(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsTupleType

JavaScript
t.tsTupleType(elementTypes);

另请参见t.isTSTupleType(node, opts)和t.assertTSTupleType(node, opts)。

AST 节点 TSTupleType 形状

elementTypes: Array<TSType | TSNamedTupleMember>（必需）

别名：TypeScript、TSType

tsTypeAliasDeclaration

JavaScript
t.tsTypeAliasDeclaration(id, typeParameters, typeAnnotation);

另请参见t.isTSTypeAliasDeclaration(node, opts)和t.assertTSTypeAliasDeclaration(node, opts)。

AST 节点 TSTypeAliasDeclaration 形状

id: Identifier（必需）
typeParameters: TSTypeParameterDeclaration（默认值：null）
typeAnnotation: TSType（必需）
declare: boolean（默认值：null，从构建器函数中排除）

别名：TypeScript，Statement，Declaration

tsTypeAnnotation

JavaScript
t.tsTypeAnnotation(typeAnnotation);

另请参见t.isTSTypeAnnotation(node, opts)和t.assertTSTypeAnnotation(node, opts)。

AST 节点 TSTypeAnnotation 形状

typeAnnotation: TSType（必需）

别名：TypeScript

tsTypeAssertion

JavaScript
t.tsTypeAssertion(typeAnnotation, expression);

另请参见t.isTSTypeAssertion(node, opts)和t.assertTSTypeAssertion(node, opts)。

AST 节点 TSTypeAssertion 形状

typeAnnotation: TSType（必需）
expression：Expression（必需）

别名：TypeScript、Expression、LVal、PatternLike

tsTypeLiteral

JavaScript
t.tsTypeLiteral(members);

另请参见t.isTSTypeLiteral(node, opts)和t.assertTSTypeLiteral(node, opts)。

AST 节点 TSTypeLiteral 形状

members: Array<TSTypeElement>（必需）

别名：TypeScript、TSType

tsTypeOperator

JavaScript
t.tsTypeOperator(typeAnnotation);

另请参见t.isTSTypeOperator(node, opts)和t.assertTSTypeOperator(node, opts)。

AST 节点 TSTypeOperator 形状

typeAnnotation: TSType（必需）
operator：string（必需）

别名：TypeScript、TSType

tsTypeParameter

JavaScript
t.tsTypeParameter(constraint, default, name);

历史记录

版本	更改
`v7.21.0`	支持 `const`

另请参见t.isTSTypeParameter(node, opts)和t.assertTSTypeParameter(node, opts)。

AST 节点 TSTypeParameter 形状

constraint: TSType（默认值：null）
default: TSType（默认值：null）
name: string（必需）
const: boolean（默认值：null，从构建器函数中排除）
in: boolean（默认值：null，从构建器函数中排除）
out: boolean（默认值：null，从构建器函数中排除）

别名：TypeScript

tsTypeParameterDeclaration

JavaScript
t.tsTypeParameterDeclaration(params);

另请参见t.isTSTypeParameterDeclaration(node, opts)和t.assertTSTypeParameterDeclaration(node, opts)。

AST 节点 TSTypeParameterDeclaration 形状

params: Array<TSTypeParameter>（必需）

别名：TypeScript

tsTypeParameterInstantiation

JavaScript
t.tsTypeParameterInstantiation(params);

另请参阅 t.isTSTypeParameterInstantiation(node, opts) 和 t.assertTSTypeParameterInstantiation(node, opts)。

AST 节点 TSTypeParameterInstantiation 形状

params: Array<TSType>（必需）

别名：TypeScript

tsTypePredicate

JavaScript
t.tsTypePredicate(parameterName, typeAnnotation, asserts);

另请参阅 t.isTSTypePredicate(node, opts) 和 t.assertTSTypePredicate(node, opts)。

AST 节点 TSTypePredicate 形状

parameterName: Identifier | TSThisType（必需）
typeAnnotation: TSTypeAnnotation（默认值：null）
asserts: boolean（默认值：null）

别名：TypeScript、TSType

tsTypeQuery

JavaScript
t.tsTypeQuery(exprName, typeParameters);

另请参阅 t.isTSTypeQuery(node, opts) 和 t.assertTSTypeQuery(node, opts)。

AST 节点 TSTypeQuery 形状

exprName: TSEntityName | TSImportType（必需）
typeParameters: TSTypeParameterInstantiation（默认值：null）

别名：TypeScript、TSType

tsTypeReference

JavaScript
t.tsTypeReference(typeName, typeParameters);

另请参阅 t.isTSTypeReference(node, opts) 和 t.assertTSTypeReference(node, opts)。

AST 节点 TSTypeReference 形状

typeName: TSEntityName（必需）
typeParameters: TSTypeParameterInstantiation（默认值：null）

别名：TypeScript、TSType

tsUndefinedKeyword

JavaScript
t.tsUndefinedKeyword();

另请参阅 t.isTSUndefinedKeyword(node, opts) 和 t.assertTSUndefinedKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsUnionType

JavaScript
t.tsUnionType(types);

另请参阅 t.isTSUnionType(node, opts) 和 t.assertTSUnionType(node, opts)。

AST 节点 TSUnionType 形状

types: Array<TSType>（必需）

别名：TypeScript、TSType

tsUnknownKeyword

JavaScript
t.tsUnknownKeyword();

另请参阅 t.isTSUnknownKeyword(node, opts) 和 t.assertTSUnknownKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

tsVoidKeyword

JavaScript
t.tsVoidKeyword();

另请参阅 t.isTSVoidKeyword(node, opts) 和 t.assertTSVoidKeyword(node, opts)。

别名：TypeScript、TSType、TSBaseType

taggedTemplateExpression

JavaScript
t.taggedTemplateExpression(tag, quasi);

另请参阅 t.isTaggedTemplateExpression(node, opts) 和 t.assertTaggedTemplateExpression(node, opts)。

AST 节点 TaggedTemplateExpression 形状

tag: Expression（必需）
quasi: TemplateLiteral（必需）
typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation（默认值：null，从构建器函数中排除）

别名：Standardized、Expression

templateElement

JavaScript
t.templateElement(value, tail);

另请参阅 t.isTemplateElement(node, opts) 和 t.assertTemplateElement(node, opts)。

AST 节点 TemplateElement 形状

value: { raw: string, cooked?: string }（必需）
tail: boolean（默认值：false）

别名：Standardized

templateLiteral

JavaScript
t.templateLiteral(quasis, expressions);

另请参阅 t.isTemplateLiteral(node, opts) 和 t.assertTemplateLiteral(node, opts)。

AST 节点 TemplateLiteral 形状

quasis: Array<TemplateElement>（必需）
expressions: Array<Expression | TSType>（必需）

别名：Standardized，Expression，Literal

thisExpression

JavaScript
t.thisExpression();

另请参阅 t.isThisExpression(node, opts) 和 t.assertThisExpression(node, opts)。

别名：Standardized、Expression

thisTypeAnnotation

JavaScript
t.thisTypeAnnotation();

另请参阅 t.isThisTypeAnnotation(node, opts) 和 t.assertThisTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

throwStatement

JavaScript
t.throwStatement(argument);

另请参阅 t.isThrowStatement(node, opts) 和 t.assertThrowStatement(node, opts)。

AST 节点 ThrowStatement 形状

argument：Expression（必需）

别名：Standardized、Statement、Terminatorless、CompletionStatement

topicReference

JavaScript
t.topicReference();

另请参阅 t.isTopicReference(node, opts) 和 t.assertTopicReference(node, opts)。

别名：Expression

tryStatement

JavaScript
t.tryStatement(block, handler, finalizer);

另请参阅 t.isTryStatement(node, opts) 和 t.assertTryStatement(node, opts)。

AST 节点 TryStatement 形状

block: BlockStatement（必需）
handler: CatchClause（默认值：null）
finalizer: BlockStatement（默认值：null）

别名：Standardized、Statement

tupleExpression

JavaScript
t.tupleExpression(elements);

另请参阅 t.isTupleExpression(node, opts) 和 t.assertTupleExpression(node, opts)。

AST 节点 TupleExpression 形状

elements: Array<Expression | SpreadElement>（默认值：[]）

别名：Expression

tupleTypeAnnotation

JavaScript
t.tupleTypeAnnotation(types);

另请参阅 t.isTupleTypeAnnotation(node, opts) 和 t.assertTupleTypeAnnotation(node, opts)。

AST 节点 TupleTypeAnnotation 形状

types: Array<FlowType>（必需）

别名：Flow、FlowType

typeAlias

JavaScript
t.typeAlias(id, typeParameters, right);

另请参阅 t.isTypeAlias(node, opts) 和 t.assertTypeAlias(node, opts)。

AST 节点 TypeAlias 形状

id: Identifier（必需）
typeParameters：TypeParameterDeclaration（默认：null）
right: FlowType（必需）

别名：Flow、FlowDeclaration、Statement、Declaration

typeAnnotation

JavaScript
t.typeAnnotation(typeAnnotation);

另请参阅 t.isTypeAnnotation(node, opts) 和 t.assertTypeAnnotation(node, opts)。

AST 节点 TypeAnnotation 形状

typeAnnotation: FlowType（必需）

别名：Flow

typeCastExpression

JavaScript
t.typeCastExpression(expression, typeAnnotation);

另请参阅 t.isTypeCastExpression(node, opts) 和 t.assertTypeCastExpression(node, opts)。

AST 节点 TypeCastExpression 形状

expression：Expression（必需）
typeAnnotation: TypeAnnotation（必需）

别名：Flow、ExpressionWrapper、Expression

typeParameter

JavaScript
t.typeParameter(bound, default, variance);

另请参阅 t.isTypeParameter(node, opts) 和 t.assertTypeParameter(node, opts)。

AST 节点 TypeParameter 形状

bound: TypeAnnotation（默认值：null）
default: FlowType（默认值：null）
variance：Variance（默认：null）
name: string（必需）

别名：Flow

typeParameterDeclaration

JavaScript
t.typeParameterDeclaration(params);

另请参阅 t.isTypeParameterDeclaration(node, opts) 和 t.assertTypeParameterDeclaration(node, opts)。

AST 节点 TypeParameterDeclaration 形状

params: Array<TypeParameter>（必需）

别名：Flow

typeParameterInstantiation

JavaScript
t.typeParameterInstantiation(params);

另请参阅 t.isTypeParameterInstantiation(node, opts) 和 t.assertTypeParameterInstantiation(node, opts)。

AST 节点 TypeParameterInstantiation 形状

params: Array<FlowType>（必需）

别名：Flow

typeofTypeAnnotation

JavaScript
t.typeofTypeAnnotation(argument);

另请参阅 t.isTypeofTypeAnnotation(node, opts) 和 t.assertTypeofTypeAnnotation(node, opts)。

AST 节点 TypeofTypeAnnotation 形状

argument: FlowType（必需）

别名：Flow、FlowType

unaryExpression

JavaScript
t.unaryExpression(operator, argument, prefix);

另请参阅 t.isUnaryExpression(node, opts) 和 t.assertUnaryExpression(node, opts)。

AST 节点 UnaryExpression 形状

operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof"（必需）
argument：Expression（必需）
prefix: boolean（默认值：true）

别名：Standardized、UnaryLike、Expression

unionTypeAnnotation

JavaScript
t.unionTypeAnnotation(types);

另请参阅 t.isUnionTypeAnnotation(node, opts) 和 t.assertUnionTypeAnnotation(node, opts)。

AST 节点 UnionTypeAnnotation 形状

types: Array<FlowType>（必需）

别名：Flow、FlowType

updateExpression

JavaScript
t.updateExpression(operator, argument, prefix);

另请参阅 t.isUpdateExpression(node, opts) 和 t.assertUpdateExpression(node, opts)。

AST 节点 UpdateExpression 形状

operator: "++" | "--"（必需）
argument：Expression（必需）
prefix: boolean（默认值：false）

别名：Standardized、Expression

v8IntrinsicIdentifier

JavaScript
t.v8IntrinsicIdentifier(name);

另请参阅 t.isV8IntrinsicIdentifier(node, opts) 和 t.assertV8IntrinsicIdentifier(node, opts)。

AST 节点 V8IntrinsicIdentifier 形状

name: string（必需）

别名：Miscellaneous

variableDeclaration

JavaScript
t.variableDeclaration(kind, declarations);

历史记录

版本	更改
`v7.20.0`	`kind` 可以是“using”。

另请参阅 t.isVariableDeclaration(node, opts) 和 t.assertVariableDeclaration(node, opts)。

AST 节点 VariableDeclaration 形状

kind: "var" | "let" | "const" | "using" | "await using"（必需）
declarations: Array<VariableDeclarator>（必需）
declare: boolean（默认值：null，从构建器函数中排除）

别名：Standardized、Statement、Declaration

variableDeclarator

JavaScript
t.variableDeclarator(id, init);

另请参阅 t.isVariableDeclarator(node, opts) 和 t.assertVariableDeclarator(node, opts)。

AST 节点 VariableDeclarator 形状

id: LVal（必需）
init: Expression（默认值：null）
definite: boolean（默认值：null，从构建器函数中排除）

别名：Standardized

variance

JavaScript
t.variance(kind);

另请参阅 t.isVariance(node, opts) 和 t.assertVariance(node, opts)。

AST 节点 Variance 形状

kind: "minus" | "plus"（必需）

别名：Flow

voidTypeAnnotation

JavaScript
t.voidTypeAnnotation();

另请参阅 t.isVoidTypeAnnotation(node, opts) 和 t.assertVoidTypeAnnotation(node, opts)。

别名：Flow、FlowType、FlowBaseAnnotation

whileStatement

JavaScript
t.whileStatement(test, body);

另请参阅 t.isWhileStatement(node, opts) 和 t.assertWhileStatement(node, opts)。

AST 节点 WhileStatement 形状

test：Expression（必需）
body：Statement（必需）

别名：Standardized、Statement、BlockParent、Loop、While、Scopable

withStatement

JavaScript
t.withStatement(object, body);

另请参阅 t.isWithStatement(node, opts) 和 t.assertWithStatement(node, opts)。

AST 节点 WithStatement 形状

object: Expression（必需）
body：Statement（必需）

别名：Standardized、Statement

yieldExpression

JavaScript
t.yieldExpression(argument, delegate);

另请参阅 t.isYieldExpression(node, opts) 和 t.assertYieldExpression(node, opts)。

AST 节点 YieldExpression 形状

argument: Expression (默认：null)
delegate: boolean（默认值：false）

别名：Standardized、Expression、Terminatorless

别名

Accessor

已弃用。将在 Babel 8 中移除。

JavaScript
t.isAccessor(node);

涵盖的节点

ClassAccessorProperty

Binary

BinaryExpression 和 LogicalExpression 的覆盖，它们共享相同的 AST 形状。

JavaScript
t.isBinary(node);

涵盖的节点

BinaryExpression
LogicalExpression

Block

已弃用。将在 Babel 8 中移除。

JavaScript
t.isBlock(node);

涵盖的节点

BlockStatement
Program
TSModuleBlock

BlockParent

AST 节点的覆盖，这些节点以新的 LexicalEnvironment 开始执行上下文。换句话说，它们定义了 let 和 const 声明的范围。

JavaScript
t.isBlockParent(node);

涵盖的节点

ArrowFunctionExpression
BlockStatement
CatchClause
ClassMethod
ClassPrivateMethod
DoWhileStatement
ForInStatement
ForOfStatement
ForStatement
函数声明
函数表达式
对象方法
Program
静态块
Switch 语句
TSModuleBlock
While 语句

类

ClassExpression 和 ClassDeclaration 的一个覆盖，它们共享相同的 AST 形状。

JavaScript
t.isClass(node);

涵盖的节点

类声明
类表达式

完成语句

指示完成记录的语句。换句话说，它们定义了程序的控制流，例如何时应中断循环或操作引发严重错误。

JavaScript
t.isCompletionStatement(node);

涵盖的节点

Break 语句
Continue 语句
Return 语句
Throw 语句

条件

ConditionalExpression 和 IfStatement 的一个覆盖，它们共享相同的 AST 形状。

JavaScript
t.isConditional(node);

涵盖的节点

条件表达式
If 语句

声明

任何声明的覆盖。

JavaScript
t.isDeclaration(node);

涵盖的节点

类声明
声明类
声明导出所有声明
声明导出声明
声明函数
声明接口
声明模块
声明模块导出
声明不透明类型
声明类型别名
声明变量
枚举声明
导出所有声明
导出默认声明
导出命名声明
函数声明
导入声明
接口声明
不透明类型
TS 声明函数
TS 枚举声明
TS 接口声明
TS 模块声明
TSType 别名声明
类型别名
变量声明

枚举主体

Flow 枚举主体的覆盖。

JavaScript
t.isEnumBody(node);

涵盖的节点

枚举布尔主体
枚举数字主体
枚举字符串主体
枚举符号主体

枚举成员

Flow 枚举成员的覆盖。

JavaScript
t.isEnumMember(node);

涵盖的节点

枚举布尔成员
枚举默认成员
枚举数字成员
枚举字符串成员

导出声明

任何导出声明的覆盖。

JavaScript
t.isExportDeclaration(node);

涵盖的节点

导出所有声明
导出默认声明
导出命名声明

表达式

任何表达式的覆盖。

JavaScript
t.isExpression(node);

涵盖的节点

数组表达式
ArrowFunctionExpression
赋值表达式
Await 表达式
BigInt 字面量
BinaryExpression
Bind 表达式
布尔字面量
调用表达式
类表达式
条件表达式
Decimal 字面量
Do 表达式
函数表达式
标识符
导入
导入表达式
JSX 元素
JSX 片段
LogicalExpression
成员表达式
元属性
模块表达式
New 表达式
Null 字面量
数字字面量
对象表达式
可选调用表达式
可选成员表达式
带括号的表达式
管道裸函数
管道主主题引用
管道主题表达式
记录表达式
RegExp 字面量
序列表达式
字符串文字
超级
TSA 表达式
TS 实例化表达式
TS 非空表达式
TS 满足表达式
TS 类型断言
标记模板表达式
模板文字
此表达式
主题引用
元组表达式
类型转换表达式
一元表达式
更新表达式
Yield 表达式

ExpressionWrapper

没有运行时语义的表达式的包装器。

JavaScript
t.isExpressionWrapper(node);

涵盖的节点

表达式语句
带括号的表达式
类型转换表达式

Flow

为 Flow 定义的 AST 节点的覆盖。

JavaScript
t.isFlow(node);

涵盖的节点

AnyTypeAnnotation
ArrayTypeAnnotation
BooleanLiteralTypeAnnotation
BooleanTypeAnnotation
ClassImplements
声明类
声明导出所有声明
声明导出声明
声明函数
声明接口
声明模块
声明模块导出
声明不透明类型
声明类型别名
声明变量
DeclaredPredicate
EmptyTypeAnnotation
枚举布尔主体
枚举布尔成员
枚举声明
枚举默认成员
枚举数字主体
枚举数字成员
枚举字符串主体
枚举字符串成员
枚举符号主体
ExistsTypeAnnotation
FunctionTypeAnnotation
FunctionTypeParam
GenericTypeAnnotation
IndexedAccessType
InferredPredicate
接口声明
InterfaceExtends
InterfaceTypeAnnotation
IntersectionTypeAnnotation
MixedTypeAnnotation
NullLiteralTypeAnnotation
NullableTypeAnnotation
NumberLiteralTypeAnnotation
NumberTypeAnnotation
ObjectTypeAnnotation
ObjectTypeCallProperty
ObjectTypeIndexer
ObjectTypeInternalSlot
ObjectTypeProperty
ObjectTypeSpreadProperty
不透明类型
OptionalIndexedAccessType
QualifiedTypeIdentifier
StringLiteralTypeAnnotation
StringTypeAnnotation
SymbolTypeAnnotation
ThisTypeAnnotation
TupleTypeAnnotation
类型别名
TypeAnnotation
类型转换表达式
TypeParameter
TypeParameterDeclaration
TypeParameterInstantiation
TypeofTypeAnnotation
UnionTypeAnnotation
Variance
VoidTypeAnnotation

FlowBaseAnnotation

主要 Flow 型アノテーションのカバー。

JavaScript
t.isFlowBaseAnnotation(node);

涵盖的节点

AnyTypeAnnotation
BooleanTypeAnnotation
EmptyTypeAnnotation
MixedTypeAnnotation
NullLiteralTypeAnnotation
NumberTypeAnnotation
StringTypeAnnotation
SymbolTypeAnnotation
ThisTypeAnnotation
VoidTypeAnnotation

FlowDeclaration

Flow 宣言のカバー。

JavaScript
t.isFlowDeclaration(node);

涵盖的节点

声明类
声明导出所有声明
声明导出声明
声明函数
声明接口
声明模块
声明模块导出
声明不透明类型
声明类型别名
声明变量
接口声明
不透明类型
类型别名

FlowPredicate

Flow 述語のカバー。

JavaScript
t.isFlowPredicate(node);

涵盖的节点

DeclaredPredicate
InferredPredicate

FlowType

Flow 型アノテーションのカバー。

JavaScript
t.isFlowType(node);

涵盖的节点

AnyTypeAnnotation
ArrayTypeAnnotation
BooleanLiteralTypeAnnotation
BooleanTypeAnnotation
EmptyTypeAnnotation
ExistsTypeAnnotation
FunctionTypeAnnotation
GenericTypeAnnotation
IndexedAccessType
InterfaceTypeAnnotation
IntersectionTypeAnnotation
MixedTypeAnnotation
NullLiteralTypeAnnotation
NullableTypeAnnotation
NumberLiteralTypeAnnotation
NumberTypeAnnotation
ObjectTypeAnnotation
OptionalIndexedAccessType
StringLiteralTypeAnnotation
StringTypeAnnotation
SymbolTypeAnnotation
ThisTypeAnnotation
TupleTypeAnnotation
TypeofTypeAnnotation
UnionTypeAnnotation
VoidTypeAnnotation

For

ForStatement と ForXStatement のカバー。

JavaScript
t.isFor(node);

涵盖的节点

ForInStatement
ForOfStatement
ForStatement

ForXStatement

ForInStatements と ForOfStatements のカバー。

JavaScript
t.isForXStatement(node);

涵盖的节点

ForInStatement
ForOfStatement

Function

関数とメソッドのカバー。body と params が必要です。注: Function は FunctionParent とは異なります。たとえば、StaticBlock は FunctionParent ですが Function ではありません。

JavaScript
t.isFunction(node);

涵盖的节点

ArrowFunctionExpression
ClassMethod
ClassPrivateMethod
函数声明
函数表达式
对象方法

FunctionParent

开始执行上下文的新VariableEnvironment的 AST 节点覆盖。换句话说，它们定义了var声明的范围。从 Babel 7 开始，FunctionParent 不再包含Program。

JavaScript
t.isFunctionParent(node);

涵盖的节点

ArrowFunctionExpression
ClassMethod
ClassPrivateMethod
函数声明
函数表达式
对象方法
静态块
TSModuleBlock

Immutable

不可变对象和 JSX 元素的覆盖。如果创建后无法定义其他属性，则对象是不可变的。

JavaScript
t.isImmutable(node);

涵盖的节点

BigInt 字面量
布尔字面量
Decimal 字面量
JSXAttribute
JSXClosingElement
JSXClosingFragment
JSX 元素
JSXExpressionContainer
JSX 片段
JSXOpeningElement
JSXOpeningFragment
JSXSpreadChild
JSXText
Null 字面量
数字字面量
字符串文字

ImportOrExportDeclaration

历史记录

版本	更改
`v7.21.0`	已引入

ImportDeclaration 和 ExportDeclaration 的覆盖。

JavaScript
t.isImportOrExportDeclaration(node);

涵盖的节点

导出所有声明
导出默认声明
导出命名声明
导入声明

JSX

为 JSX 定义的 AST 节点的覆盖。

JavaScript
t.isJSX(node);

涵盖的节点

JSXAttribute
JSXClosingElement
JSXClosingFragment
JSX 元素
JSXEmptyExpression
JSXExpressionContainer
JSX 片段
JSXIdentifier
JSXMemberExpression
JSXNamespacedName
JSXOpeningElement
JSXOpeningFragment
JSXSpreadAttribute
JSXSpreadChild
JSXText

LVal

赋值表达式和 ForXStatement 的left中使用的左侧表达式覆盖。

JavaScript
t.isLVal(node);

涵盖的节点

ArrayPattern
AssignmentPattern
标识符
成员表达式
ObjectPattern
RestElement
TSA 表达式
TS 非空表达式
TSParameterProperty
TS 满足表达式
TS 类型断言

Literal

Literal、正则表达式 Literal 和 Template Literal 的覆盖。

JavaScript
t.isLiteral(node);

涵盖的节点

BigInt 字面量
布尔字面量
Decimal 字面量
Null 字面量
数字字面量
RegExp 字面量
字符串文字
模板文字

Loop

循环语句的覆盖。

JavaScript
t.isLoop(node);

涵盖的节点

DoWhileStatement
ForInStatement
ForOfStatement
ForStatement
While 语句

Method

对象方法和类方法的覆盖。

JavaScript
t.isMethod(node);

涵盖的节点

ClassMethod
ClassPrivateMethod
对象方法

Miscellaneous

有时对开发有用的非标准 AST 类型的覆盖。

JavaScript
t.isMiscellaneous(node);

涵盖的节点

Noop
Placeholder
V8IntrinsicIdentifier

ModuleDeclaration

历史记录

版本	更改
`v7.21.0`	已弃用

注意

已弃用，请改用ImportOrExportDeclaration。查看 PR #15266 以获取迁移说明。

JavaScript
t.isModuleDeclaration(node);

涵盖的节点

导出所有声明
导出默认声明
导出命名声明
导入声明

ModuleSpecifier

导入和导出说明符的覆盖。注意：它不是规范中定义的 ModuleSpecifier。

JavaScript
t.isModuleSpecifier(node);

涵盖的节点

ExportDefaultSpecifier
ExportNamespaceSpecifier
ExportSpecifier
ImportDefaultSpecifier
ImportNamespaceSpecifier
ImportSpecifier

ObjectMember

对象字面量中成员的覆盖。

JavaScript
t.isObjectMember(node);

涵盖的节点

对象方法
ObjectProperty

Pattern

除了标识符之外，BindingPattern 的覆盖。

JavaScript
t.isPattern(node);

涵盖的节点

ArrayPattern
AssignmentPattern
ObjectPattern

PatternLike

BindingPattern 的一个封面

JavaScript
t.isPatternLike(node);

涵盖的节点

ArrayPattern
AssignmentPattern
标识符
ObjectPattern
RestElement
TSA 表达式
TS 非空表达式
TS 满足表达式
TS 类型断言

Private

私有类元素和私有标识符的一个封面。

JavaScript
t.isPrivate(node);

涵盖的节点

ClassPrivateMethod
ClassPrivateProperty
PrivateName

Property

对象属性和类属性的一个封面。

JavaScript
t.isProperty(node);

涵盖的节点

ClassAccessorProperty
ClassPrivateProperty
ClassProperty
ObjectProperty

Pureish

没有副作用的 AST 节点的封面。换句话说，如果对它们进行多次评估，则没有可观察的行为变化。

JavaScript
t.isPureish(node);

涵盖的节点

ArrowFunctionExpression
BigInt 字面量
布尔字面量
Decimal 字面量
函数声明
函数表达式
Null 字面量
数字字面量
RegExp 字面量
字符串文字

Scopable

FunctionParent 和 BlockParent 的一个封面。

JavaScript
t.isScopable(node);

涵盖的节点

ArrowFunctionExpression
BlockStatement
CatchClause
类声明
类表达式
ClassMethod
ClassPrivateMethod
DoWhileStatement
ForInStatement
ForOfStatement
ForStatement
函数声明
函数表达式
对象方法
Program
静态块
Switch 语句
TSModuleBlock
While 语句

Standardized

属于官方 ECMAScript 规范一部分的 AST 节点的封面。

JavaScript
t.isStandardized(node);

涵盖的节点

数组表达式
ArrayPattern
ArrowFunctionExpression
赋值表达式
AssignmentPattern
Await 表达式
BigInt 字面量
BinaryExpression
BlockStatement
布尔字面量
Break 语句
调用表达式
CatchClause
ClassAccessorProperty
ClassBody
类声明
类表达式
ClassMethod
ClassPrivateMethod
ClassPrivateProperty
ClassProperty
条件表达式
Continue 语句
DebuggerStatement
Directive
DirectiveLiteral
DoWhileStatement
EmptyStatement
导出所有声明
导出默认声明
导出命名声明
ExportNamespaceSpecifier
ExportSpecifier
表达式语句
File
ForInStatement
ForOfStatement
ForStatement
函数声明
函数表达式
标识符
If 语句
导入
导入声明
ImportDefaultSpecifier
导入表达式
ImportNamespaceSpecifier
ImportSpecifier
InterpreterDirective
LabeledStatement
LogicalExpression
成员表达式
元属性
New 表达式
Null 字面量
数字字面量
对象表达式
对象方法
ObjectPattern
ObjectProperty
可选调用表达式
可选成员表达式
带括号的表达式
PrivateName
Program
RegExp 字面量
RestElement
Return 语句
序列表达式
SpreadElement
静态块
字符串文字
超级
SwitchCase
Switch 语句
标记模板表达式
TemplateElement
模板文字
此表达式
Throw 语句
TryStatement
一元表达式
更新表达式
变量声明
VariableDeclarator
While 语句
WithStatement
Yield 表达式

Statement

任何 Statement 的一个封面。

JavaScript
t.isStatement(node);

涵盖的节点

BlockStatement
Break 语句
类声明
Continue 语句
DebuggerStatement
声明类
声明导出所有声明
声明导出声明
声明函数
声明接口
声明模块
声明模块导出
声明不透明类型
声明类型别名
声明变量
DoWhileStatement
EmptyStatement
枚举声明
导出所有声明
导出默认声明
导出命名声明
表达式语句
ForInStatement
ForOfStatement
ForStatement
函数声明
If 语句
导入声明
接口声明
LabeledStatement
不透明类型
Return 语句
Switch 语句
TS 声明函数
TS 枚举声明
TSExportAssignment
TSImportEqualsDeclaration
TS 接口声明
TS 模块声明
TSNamespaceExportDeclaration
TSType 别名声明
Throw 语句
TryStatement
类型别名
变量声明
While 语句
WithStatement

TSBaseType

主要 TypeScript 类型注释的一个封面。

JavaScript
t.isTSBaseType(node);

涵盖的节点

TSAnyKeyword
TSBigIntKeyword
TSBooleanKeyword
TSIntrinsicKeyword
TSLiteralType
TSNeverKeyword
TSNullKeyword
TSNumberKeyword
TSObjectKeyword
TSStringKeyword
TSSymbolKeyword
TSThisType
TSUndefinedKeyword
TSUnknownKeyword
TSVoidKeyword

TSEntityName

ts 实体的一个封面。

JavaScript
t.isTSEntityName(node);

涵盖的节点

标识符
TSQualifiedName

TSType

TypeScript 类型注释的一个封面。

JavaScript
t.isTSType(node);

涵盖的节点

TSAnyKeyword
TSArrayType
TSBigIntKeyword
TSBooleanKeyword
TSConditionalType
TSConstructorType
TSExpressionWithTypeArguments
TSFunctionType
TSImportType
TSIndexedAccessType
TSInferType
TSIntersectionType
TSIntrinsicKeyword
TSLiteralType
TSMappedType
TSNeverKeyword
TSNullKeyword
TSNumberKeyword
TSObjectKeyword
TSOptionalType
TSParenthesizedType
TSRestType
TSStringKeyword
TSSymbolKeyword
TSThisType
TSTupleType
TSTypeLiteral
TSTypeOperator
TSTypePredicate
TSTypeQuery
TSTypeReference
TSUndefinedKeyword
TSUnionType
TSUnknownKeyword
TSVoidKeyword

TSTypeElement

TypeScript 类型声明的一个封面。

JavaScript
t.isTSTypeElement(node);

涵盖的节点

TSCallSignatureDeclaration
TSConstructSignatureDeclaration
TSIndexSignature
TSMethodSignature
TSPropertySignature

Terminatorless

当在运算符和操作数之间插入行终止符时，其语义将发生更改的 AST 节点的封面。

JavaScript
t.isTerminatorless(node);

涵盖的节点

Await 表达式
Break 语句
Continue 语句
Return 语句
Throw 语句
Yield 表达式

TypeScript

为 TypeScript 定义的 AST 节点的封面。

JavaScript
t.isTypeScript(node);

涵盖的节点

TSAnyKeyword
TSArrayType
TSA 表达式
TSBigIntKeyword
TSBooleanKeyword
TSCallSignatureDeclaration
TSConditionalType
TSConstructSignatureDeclaration
TSConstructorType
TS 声明函数
TSDeclareMethod
TS 枚举声明
TSEnumMember
TSExportAssignment
TSExpressionWithTypeArguments
TSExternalModuleReference
TSFunctionType
TSImportEqualsDeclaration
TSImportType
TSIndexSignature
TSIndexedAccessType
TSInferType
TS 实例化表达式
TSInterfaceBody
TS 接口声明
TSIntersectionType
TSIntrinsicKeyword
TSLiteralType
TSMappedType
TSMethodSignature
TSModuleBlock
TS 模块声明
TSNamedTupleMember
TSNamespaceExportDeclaration
TSNeverKeyword
TS 非空表达式
TSNullKeyword
TSNumberKeyword
TSObjectKeyword
TSOptionalType
TSParameterProperty
TSParenthesizedType
TSPropertySignature
TSQualifiedName
TSRestType
TS 满足表达式
TSStringKeyword
TSSymbolKeyword
TSThisType
TSTupleType
TSType 别名声明
TSTypeAnnotation
TS 类型断言
TSTypeLiteral
TSTypeOperator
TSTypeParameter
TSTypeParameterDeclaration
TSTypeParameterInstantiation
TSTypePredicate
TSTypeQuery
TSTypeReference
TSUndefinedKeyword
TSUnionType
TSUnknownKeyword
TSVoidKeyword

UnaryLike

UnaryExpression 和 SpreadElement 的一个封面。

JavaScript
t.isUnaryLike(node);

涵盖的节点

SpreadElement
一元表达式

UserWhitespacable

已弃用。将在 Babel 8 中移除。

JavaScript
t.isUserWhitespacable(node);

涵盖的节点

对象方法
ObjectProperty
ObjectTypeCallProperty
ObjectTypeIndexer
ObjectTypeInternalSlot
ObjectTypeProperty
ObjectTypeSpreadProperty

While

JavaScript

t.isWhile(node);

涵盖的节点

DoWhileStatement
While 语句

安装​

API​

节点构建器​

anyTypeAnnotation​

argumentPlaceholder​

arrayExpression​

arrayPattern​

arrayTypeAnnotation​

arrowFunctionExpression​

assignmentExpression​

assignmentPattern​

awaitExpression​

bigIntLiteral​

binaryExpression​

bindExpression​

blockStatement​

booleanLiteral​

booleanLiteralTypeAnnotation​

booleanTypeAnnotation​

breakStatement​

callExpression​

catchClause​

classAccessorProperty​

classBody​

classDeclaration​

classExpression​

classImplements​

classMethod​

classPrivateMethod​

classPrivateProperty​

classProperty​

conditionalExpression​

continueStatement​

debuggerStatement​

decimalLiteral​

declareClass​

declareExportAllDeclaration​

declareExportDeclaration​

declareFunction​

declareInterface​

declareModule​

declareModuleExports​

declareOpaqueType​

declareTypeAlias​

declareVariable​

declaredPredicate​

装饰器​

指令​

指令文本​

do 表达式​

do while 语句​

空语句​

空类型注释​

枚举布尔正文​

枚举布尔成员​

枚举声明​

枚举默认成员​

枚举数字正文​

enumNumberMember​

enumStringBody​

enumStringMember​

enumSymbolBody​

existsTypeAnnotation​

exportAllDeclaration​

exportDefaultDeclaration​

exportDefaultSpecifier​

exportNamedDeclaration​

exportNamespaceSpecifier​

exportSpecifier​

expressionStatement​

file​

forInStatement​

forOfStatement​

forStatement​

functionDeclaration​

functionExpression​

functionTypeAnnotation​

functionTypeParam​

genericTypeAnnotation​

identifier​

安装

API

节点构建器

anyTypeAnnotation

argumentPlaceholder

arrayExpression

arrayPattern

arrayTypeAnnotation

arrowFunctionExpression

assignmentExpression

assignmentPattern

awaitExpression

bigIntLiteral

binaryExpression

bindExpression

blockStatement

booleanLiteral

booleanLiteralTypeAnnotation

booleanTypeAnnotation

breakStatement

callExpression

catchClause

classAccessorProperty

classBody

classDeclaration

classExpression

classImplements

classMethod

classPrivateMethod

classPrivateProperty

classProperty

conditionalExpression

continueStatement

debuggerStatement

decimalLiteral

declareClass

declareExportAllDeclaration

declareExportDeclaration

declareFunction

declareInterface

declareModule

declareModuleExports

declareOpaqueType

declareTypeAlias

declareVariable

declaredPredicate

装饰器

指令

指令文本

do 表达式

do while 语句

空语句

空类型注释

枚举布尔正文

枚举布尔成员

枚举声明

枚举默认成员

枚举数字正文

enumNumberMember

enumStringBody

enumStringMember

enumSymbolBody

existsTypeAnnotation

exportAllDeclaration

exportDefaultDeclaration

exportDefaultSpecifier

exportNamedDeclaration

exportNamespaceSpecifier

exportSpecifier

expressionStatement

file

forInStatement

forOfStatement

forStatement

functionDeclaration

functionExpression

functionTypeAnnotation

functionTypeParam

genericTypeAnnotation

identifier