JavaScript AST解析实战：从代码到抽象语法树的完整操作指南-育师

这次我们来看一个前端开发、代码分析和工具链构建中的核心技术：如何将 JavaScript 代码解析成抽象语法树（AST）。对于很多开发者来说，AST 听起来很“底层”，似乎只在 Babel、Webpack、ESLint 这些工具的内部才会用到。但实际上，理解 AST 的生成过程，能让你在代码格式化、语法检查、自定义转译、甚至构建领域特定语言（DSL）时，拥有直接操作代码结构的能力，而不仅仅是处理字符串。

这篇文章的重点不是复述 AST 的概念，而是提供一套可落地、可验证的实操方案。我们会从最流行的解析器@babel/parser入手，同时对比acorn、espree等方案，带你完成从一段简单的 JavaScript 代码到完整 AST 的转换、遍历和修改全过程。无论你是想为团队定制代码规范检查工具，还是希望深入理解现代前端构建工具的原理，这篇文章都能提供直接的代码示例和清晰的实现路径。

下面，我们将按照“环境准备 -> 核心解析器对比 -> 动手生成 AST -> 遍历与修改节点 -> 实际应用场景”的顺序，一步步拆解。整个过程不需要复杂的 GPU 或特定硬件，只需要 Node.js 环境，对初学者友好，但涉及的知识点足够深入，适合中高级前端开发者深化技术栈。

1. 核心能力速览：JavaScript AST 解析方案对比

在深入代码之前，我们先快速了解市面上主流的 JavaScript AST 解析方案及其特点，这能帮助你根据项目需求快速选型。

能力项	说明
主流解析器	`@babel/parser`(Babel),`acorn`,`espree`(ESLint 默认),`typescript`编译器 API
核心功能	将 JavaScript/TypeScript 源代码字符串转换为符合 ESTree 规范的 AST 对象
语法支持	均支持 ES2022 及更早标准。`@babel/parser`对实验性语法（如装饰器、管道操作符）支持最好；`acorn`需插件；`espree`紧跟 ECMAScript 标准。
输出规范	大部分遵循 ESTree 规范，保证了不同工具间 AST 结构的互操作性。
生态与集成	`@babel/parser`是 Babel 生态核心，插件体系丰富；`acorn`轻量，被 Webpack 使用；`espree`深度集成于 ESLint。
启动与使用	纯 Node.js 库，通过 npm 安装，API 简单，通常只需几行代码即可生成 AST。
性能与内存	对于常规项目文件（几百KB以内），解析速度极快（毫秒级），内存占用很小。万行级别代码需注意。
适合场景	代码转换（Babel插件）、静态分析（ESLint规则）、代码格式化（Prettier）、源码打包优化、自定义代码生成工具。

从上表可以看出，选择哪个解析器通常取决于你的生态绑定。如果你在做 Babel 插件，自然选@babel/parser；如果编写 ESLint 规则，espree更直接；如果追求轻量或需要高度定制，acorn是很好的起点。本文将以功能最全面、生态最活跃的@babel/parser作为主要示例。

2. 适用场景与使用边界

理解 AST 解析的能力边界，能帮助你判断它是否是你当前问题的正确解决方案。

适合谁用？

前端工具链开发者：开发 Babel 插件、ESLint 规则、Prettier 插件或 Webpack Loader。
架构师与团队负责人：需要定制团队内部的代码规范检查工具，实现自动化代码质量卡点。
全栈或 Node.js 开发者：需要分析项目代码结构，自动生成文档、依赖图或进行代码重构。
对编译原理感兴趣的学习者：希望通过 JavaScript 这一熟悉语言，实践词法分析、语法分析等概念。

能解决什么问题？

静态代码分析：在不执行代码的情况下，找出代码中的模式（如未使用的变量、特定的函数调用模式）。
代码转换：将代码从一种形式转换为另一种形式（如 ES6+ 转 ES5， JSX 转React.createElement）。
代码格式化：根据 AST 精确地调整代码缩进、换行、空格，比正则表达式更可靠。
自定义代码生成：根据模板和规则，自动生成重复性的代码片段。
语法高亮与错误检查：IDE 和编辑器的语法高亮、智能提示背后都有 AST 解析的身影。

不适合什么场景？

动态代码执行：AST 解析是静态分析，如果你需要知道一段代码执行后的结果，应该使用eval()或new Function()（需极度谨慎安全风险）。
简单的字符串替换：如果只是修改标识符名称或简单的字符串模板，使用字符串方法或正则表达式可能更直接高效。
混淆代码的逆向工程：经过严重混淆和压缩的代码，生成的 AST 节点名称可能已被修改，可读性差，分析难度大。

安全与合规边界：

代码来源：仅解析你有权访问和修改的源代码。未经授权解析他人代码可能涉及知识产权问题。
eval的替代：AST 解析可以安全地分析代码结构，是动态执行eval的一种更安全的替代方案，但本身不执行代码。
隐私：避免将包含敏感信息（如密钥、个人信息）的源代码上传至不受控的第三方解析服务。

3. 环境准备与前置条件

开始操作前，请确保你的本地开发环境已就绪。

1. 操作系统

支持 Windows (建议使用 WSL2 或 PowerShell)、macOS 和 Linux。本文命令以 macOS/Linux 的 bash 为例，Windows 用户可在 Git Bash 或 WSL 中运行。

2. Node.js 环境

需要安装 Node.js，版本建议 >= 14.0.0。你可以使用nvm(Node Version Manager) 来管理多个版本。
打开终端，验证安装：

node --version npm --version

3. 项目初始化

mkdir ast-demo && cd ast-demo npm init -y

这会生成一个package.json文件。

4. 安装核心依赖

我们将安装 Babel 生态的解析器和遍历工具，以及一个用于打印 AST 的实用工具。

npm install @babel/parser @babel/traverse @babel/generator @babel/types --save-dev

@babel/parser: 核心解析器，将代码字符串转为 AST。
@babel/traverse: 用于遍历和修改 AST 节点。
@babel/generator: 将修改后的 AST 转回代码字符串。
@babel/types: 用于构建和校验 AST 节点类型的工具库。

至此，基础环境已准备完成。

4. 安装部署与启动方式：引入解析器

与需要启动后台服务的项目不同，AST 解析器是一个库，我们通过编写 Node.js 脚本来“启动”它的功能。下面创建一个最简单的解析示例。

1. 创建示例代码文件

在项目根目录创建一个名为demo.js的文件，内容如下：

// demo.js - 我们将要解析的源代码 function greet(name) { return `Hello, ${name}!`; } const message = greet('World'); console.log(message);

2. 创建解析脚本

在项目根目录创建一个名为parse-demo.js的文件。
我们将在这个脚本中加载解析器，并读取demo.js的内容进行解析。

// parse-demo.js const fs = require('fs'); const path = require('path'); const parser = require('@babel/parser'); // 1. 读取源代码文件 const code = fs.readFileSync(path.join(__dirname, 'demo.js'), 'utf-8'); // 2. 配置解析器选项 const parseOptions = { sourceType: 'module', // 解析模式：'script' | 'module' plugins: [ // 启用你需要的语法插件 'jsx', // 如果需要解析 JSX // 'typescript', // 如果需要解析 TS // 'decorators-legacy', // 如果需要解析装饰器 ] }; try { // 3. 执行解析，生成 AST const ast = parser.parse(code, parseOptions); // 4. 将 AST 对象转换为 JSON 字符串并输出（前两层，避免过长） console.log(JSON.stringify(ast, null, 2).substring(0, 2000) + '...'); } catch (error) { console.error('解析失败:', error.message); }

3. 运行脚本

在终端中执行：

node parse-demo.js

如果一切顺利，你将在控制台看到一个庞大的 JSON 对象输出，这就是demo.js代码对应的抽象语法树。开头部分可能类似这样：

{ "type": "File", "start": 0, "end": 119, "loc": { ... }, "errors": [], "program": { "type": "Program", "start": 0, "end": 119, "loc": { ... }, "sourceType": "module", "interpreter": null, "body": [ { "type": "FunctionDeclaration", ... }, { "type": "VariableDeclaration", ... }, { "type": "ExpressionStatement", ... } ], "directives": [] }, "comments": [] }

恭喜，你已经成功将 JavaScript 代码解析成了 AST！这个 JSON 结构完整地描述了源代码的语法构成。

5. 功能测试与效果验证：深入 AST 结构

仅仅生成 AST 还不够，我们需要理解其结构并学会从中提取信息。让我们设计几个测试来验证解析的准确性和深度。

5.1 测试一：验证基础节点类型

目标：确认解析器能正确识别函数声明、变量声明、表达式语句等基础节点。

操作步骤：

修改parse-demo.js，在成功解析后，遍历ast.program.body。
打印每个节点的类型和关键信息。

// parse-demo.js (修改部分) try { const ast = parser.parse(code, parseOptions); console.log('=== 文件中的顶级语句 ==='); ast.program.body.forEach((node, index) => { console.log(`[${index}] 类型: ${node.type}`); switch (node.type) { case 'FunctionDeclaration': console.log(` 函数名: ${node.id.name}`); console.log(` 参数: ${node.params.map(p => p.name).join(', ')}`); break; case 'VariableDeclaration': node.declarations.forEach(decl => { if (decl.id.type === 'Identifier') { console.log(` 变量名: ${decl.id.name}`); } // 可以进一步查看初始化表达式 }); break; case 'ExpressionStatement': console.log(` 表达式类型: ${node.expression.type}`); break; } console.log('---'); }); } catch (error) { console.error('解析失败:', error.message); }

预期输出：

=== 文件中的顶级语句 === [0] 类型: FunctionDeclaration 函数名: greet 参数: name --- [1] 类型: VariableDeclaration 变量名: message --- [2] 类型: ExpressionStatement 表达式类型: CallExpression ---

判断成功：输出结果与demo.js中的三条语句（函数定义、变量声明、函数调用）一一对应，且节点类型和关键属性正确。

5.2 测试二：提取特定信息（如所有函数调用）

目标：从 AST 中找出所有的函数调用表达式（CallExpression），并打印函数名和参数。

操作步骤：

我们需要遍历整个 AST 树，而不仅仅是顶级节点。这里引入@babel/traverse。
创建一个新的脚本extract-calls.js。

// extract-calls.js const fs = require('fs'); const path = require('path'); const parser = require('@babel/parser'); const traverse = require('@babel/traverse').default; // 注意 .default const code = fs.readFileSync(path.join(__dirname, 'demo.js'), 'utf-8'); const ast = parser.parse(code, { sourceType: 'module' }); console.log('=== 查找所有函数调用 ==='); traverse(ast, { CallExpression(path) { const node = path.node; let calleeName = '匿名'; if (node.callee.type === 'Identifier') { calleeName = node.callee.name; } else if (node.callee.type === 'MemberExpression') { // 处理 console.log 这种成员表达式调用 calleeName = `${node.callee.object.name}.${node.callee.property.name}`; } const args = node.arguments.map(arg => { if (arg.type === 'StringLiteral') return `"${arg.value}"`; if (arg.type === 'Identifier') return arg.name; return `[${arg.type}]`; }).join(', '); console.log(` 函数名: ${calleeName}`); console.log(` 参数: [${args}]`); console.log(` 位置: ${node.start} - ${node.end}`); console.log('---'); } });

运行与输出：

node extract-calls.js

输出应包含greet('World')和console.log(message)这两个调用。

判断成功：脚本准确识别了源代码中两处函数调用，并提取了函数名和参数值。

5.3 测试三：修改 AST 并生成新代码

目标：将代码中所有的字符串'World'替换为'AST'，并生成新的代码字符串。

操作步骤：

使用@babel/traverse定位StringLiteral节点。
使用@babel/types辅助修改节点值。
使用@babel/generator将修改后的 AST 转换回代码。

// transform-demo.js const fs = require('fs'); const path = require('path'); const parser = require('@babel/parser'); const traverse = require('@babel/traverse').default; const generate = require('@babel/generator').default; const t = require('@babel/types'); const code = fs.readFileSync(path.join(__dirname, 'demo.js'), 'utf-8'); const ast = parser.parse(code, { sourceType: 'module' }); console.log('=== 原始代码 ==='); console.log(code); console.log('\n'); // 遍历并修改 traverse(ast, { StringLiteral(path) { if (path.node.value === 'World') { // 使用 @babel/types 创建一个新的字符串字面量节点进行替换 path.replaceWith(t.stringLiteral('AST')); } } }); console.log('=== 修改后的 AST 转成的代码 ==='); const output = generate(ast, { /* 选项 */ }, code); console.log(output.code);

预期输出：修改后的代码中，greet('World')应变为greet('AST')。

判断成功：新生成的代码正确反映了修改，且格式基本保持原样。这证明了我们具备了“解析 -> 分析 -> 修改 -> 生成”的完整能力。

6. 接口 API 与批量任务

在实际项目中，我们很少只解析单个文件。更常见的场景是批量处理整个目录下的.js文件。下面我们构建一个简单的批量分析脚本。

6.1 构建批量解析函数

目标：扫描src目录下的所有.js文件，统计每个文件中函数声明的数量。

操作步骤：

创建src目录，并放入几个示例.js文件。
编写批量处理脚本batch-analyze.js。

// batch-analyze.js const fs = require('fs').promises; const path = require('path'); const parser = require('@babel/parser'); const traverse = require('@babel/traverse').default; async function analyzeFile(filePath) { try { const code = await fs.readFile(filePath, 'utf-8'); const ast = parser.parse(code, { sourceType: 'module', plugins: ['jsx'] }); let functionCount = 0; const functionNames = []; traverse(ast, { FunctionDeclaration(path) { functionCount++; functionNames.push(path.node.id?.name || '(anonymous)'); }, // 也可以统计函数表达式、箭头函数等 // FunctionExpression(path) { ... }, // ArrowFunctionExpression(path) { ... } }); return { filePath, functionCount, functionNames, success: true }; } catch (error) { return { filePath, error: error.message, success: false }; } } async function analyzeDirectory(dirPath) { const results = []; const files = await fs.readdir(dirPath, { withFileTypes: true }); for (const file of files) { const fullPath = path.join(dirPath, file.name); if (file.isDirectory()) { // 递归处理子目录 const subResults = await analyzeDirectory(fullPath); results.push(...subResults); } else if (file.name.endsWith('.js')) { const result = await analyzeFile(fullPath); results.push(result); } } return results; } // 执行批量分析 (async () => { const srcDir = path.join(__dirname, 'src'); try { await fs.access(srcDir); } catch { console.log(`目录 ${srcDir} 不存在，正在创建示例文件...`); await fs.mkdir(srcDir, { recursive: true }); await fs.writeFile(path.join(srcDir, 'utils.js'), `export function add(a,b){return a+b;}\nexport const multiply = (x,y) => x*y;`); await fs.writeFile(path.join(srcDir, 'main.js'), `import { add } from './utils.js';\nconsole.log(add(1,2));`); } const analysisResults = await analyzeDirectory(srcDir); console.log('=== 批量分析报告 ==='); analysisResults.forEach(result => { if (result.success) { console.log(`文件: ${result.filePath}`); console.log(` 函数数量: ${result.functionCount}`); if (result.functionCount > 0) { console.log(` 函数列表: ${result.functionNames.join(', ')}`); } } else { console.log(`文件: ${result.filePath} - 解析失败: ${result.error}`); } console.log('---'); }); })();

运行与输出：

node batch-analyze.js

脚本会创建示例src目录并分析其中的文件，输出每个文件的函数统计信息。

6.2 通用 API 服务示例（可选）

如果你需要将 AST 解析能力封装成 HTTP API 供其他服务调用，可以结合 Express.js 快速搭建。

// api-server.js const express = require('express'); const parser = require('@babel/parser'); const traverse = require('@babel/traverse').default; const app = express(); const port = 3000; app.use(express.json({ limit: '10mb' })); // 支持接收 JSON 体 app.post('/api/parse', (req, res) => { const { code, options = {} } = req.body; if (!code || typeof code !== 'string') { return res.status(400).json({ error: 'Invalid request: `code` field (string) is required.' }); } const defaultOptions = { sourceType: 'module', plugins: [] }; const parseOptions = { ...defaultOptions, ...options }; try { const ast = parser.parse(code, parseOptions); // 安全考虑：移除可能过大的 loc 和 tokens 信息 const sanitizedAst = JSON.parse(JSON.stringify(ast, (key, value) => { if (key === 'loc' || key === 'start' || key === 'end' || key === 'tokens' || key === 'comments') { return undefined; // 过滤掉这些字段以减小响应体积 } return value; })); res.json({ success: true, ast: sanitizedAst }); } catch (error) { res.status(400).json({ success: false, error: error.message }); } }); app.listen(port, () => { console.log(`AST 解析 API 服务运行在 http://localhost:${port}`); });

使用curl测试：

curl -X POST http://localhost:3000/api/parse \ -H "Content-Type: application/json" \ -d '{"code": "const x = 1 + 2;"}'

这个 API 服务接收代码字符串，返回其 AST 结构，可以方便地集成到自动化流程中。

7. 资源占用与性能观察

对于 AST 解析，性能瓶颈主要在于解析超大文件或处理海量小文件。

1. 单文件解析性能

使用 Node.js 的console.time和console.timeEnd进行简单测量。

// benchmark-single.js const parser = require('@babel/parser'); const largeCode = `const arr = [];\n` + `for(let i=0;i<10000;i++) arr.push(i);\n` + `console.log(arr.length);`; console.time('parse-large-file'); const ast = parser.parse(largeCode, { sourceType: 'script' }); console.timeEnd('parse-large-file'); console.log(`AST 节点数估算（通过遍历）: 需要进一步统计`);

对于万行级别的 JavaScript 文件，解析通常在几百毫秒内完成。性能主要受代码结构复杂度影响。

2. 内存占用观察

解析大型文件时，生成的 AST 对象会占用可观的内存。可以使用 Node.js 的process.memoryUsage()来观察。

// memory-usage.js const parser = require('@babel/parser'); const fs = require('fs'); function printMemory(label) { const used = process.memoryUsage(); console.log(`${label}:`); console.log(` RSS ${Math.round(used.rss / 1024 / 1024)} MB`); console.log(` Heap总 ${Math.round(used.heapTotal / 1024 / 1024)} MB`); console.log(` Heap已用 ${Math.round(used.heapUsed / 1024 / 1024)} MB`); } printMemory('解析前'); const hugeCode = fs.readFileSync('./some-large-bundle.js', 'utf-8'); // 一个很大的打包文件 const ast = parser.parse(hugeCode, { sourceType: 'script' }); printMemory('解析后'); // 注意：为了释放内存，需要确保 ast 变量超出作用域或被置为 null

关键点：在批量处理中，避免将成千上万个完整的 AST 对象长期保存在内存中。应该处理完一个文件后，及时丢弃其 AST，再处理下一个。

3. 性能优化建议

增量解析：对于像 IDE 这样的场景，每次按键后重新解析整个文件是低效的。可以考虑使用acorn的acorn-loose或 Babel 的解析器在出错时的容错能力，或者研究编辑器的增量解析接口。
缓存：如果文件未改变，可以缓存其 AST，避免重复解析。
选择性遍历：使用@babel/traverse时，只注册你关心的节点类型，减少回调函数的执行开销。
Worker 线程：对于 CPU 密集型的批量解析任务，可以考虑使用 Node.js 的 Worker Threads 将任务分配到多个线程，避免阻塞主事件循环。

8. 常见问题与排查方法

在操作 AST 解析的过程中，你可能会遇到以下典型问题。

问题现象	可能原因	排查方式	解决方案
解析失败，抛出语法错误	1. 代码包含解析器不支持的语法（如最新的 ES 提案）。 2.`sourceType`配置错误（模块 vs 脚本）。 3. 代码本身存在语法错误。	1. 检查错误信息，定位出错行和列。 2. 确认代码在浏览器或 Node 中是否能正常执行。 3. 使用在线 AST 浏览器（如 astexplorer.net ）验证。	1. 根据语法，添加对应的 Babel 插件（如`'decorators-legacy'`）。 2. 切换`sourceType: 'module'`或`'script'`。 3. 先修复源代码的语法错误。
`@babel/traverse`报错`Cannot read property 'xxx' of undefined`	通常是因为导入方式错误。从 Babel 7 开始，许多包需要访问`.default`属性。	检查导入语句。	使用`const traverse = require('@babel/traverse').default;`
遍历时修改 AST 导致无限循环或意外行为	在遍历器 visitor 中直接修改当前正在访问的节点或其父节点，可能干扰遍历过程。	审查`traverse`中的 visitor 函数，避免在遍历中做可能改变树结构的操作。	使用`path.skip()`、`path.stop()`或在遍历完成后统一修改。优先使用`path.replaceWith()`等安全方法。
生成的代码格式混乱	`@babel/generator`默认只保证语法正确，不保证格式美观。	对比输入和输出的代码格式。	1. 使用 Prettier 或 ESLint 对生成的代码进行二次格式化。 2. 调整`@babel/generator`的选项（如`retainLines`），但效果有限。
处理 JSX 或 TypeScript 时报错	未启用对应的语法插件。	查看错误信息是否提示不认识`JSXElement`或`TSType`。	在`parser.parse`的`plugins`选项中添加`'jsx'`或`'typescript'`。
批量处理时内存占用过高	同时将太多文件的完整 AST 保存在内存中。	使用`process.memoryUsage()`监控内存变化。	采用流式或分批处理，处理完一个文件后立即释放对其 AST 的引用（设为`null`）。
API 服务解析大代码时超时或崩溃	请求体过大或解析耗时太长，阻塞了事件循环。	查看服务日志，监控请求响应时间。	1. 在 API 层添加代码大小限制 (`limit: '10mb'`)。 2. 对于解析任务，考虑放入任务队列异步处理，立即返回一个任务 ID。

9. 最佳实践与使用建议

将 AST 解析用于生产环境时，遵循以下建议可以提升效率与稳定性。

1. 项目初始化与配置固化

将解析器配置（如plugins,sourceType）提取为常量或配置文件，确保团队内所有工具使用相同的语法标准。

// ast-config.js module.exports = { parserOptions: { sourceType: 'module', plugins: [ 'jsx', 'typescript', 'decorators-legacy', // ... 根据项目需要添加 ] } };

2. 错误处理与日志

始终用try...catch包裹解析过程，并记录详细的错误上下文（文件路径、错误位置），便于排查。

try { ast = parser.parse(code, options); } catch (parseError) { logger.error(`解析失败 [${filePath}]:`, { message: parseError.message, line: parseError.loc?.line, column: parseError.loc?.column, codeSnippet: code.split('\n')[parseError.loc?.line - 1] }); // 决定是跳过该文件还是终止进程 return null; }

3. 编写可测试的 Visitor

将traverse中复杂的 visitor 逻辑抽离成纯函数，便于单独进行单元测试。

// my-visitor.js function countFunctions() { let count = 0; return { FunctionDeclaration: () => count++, FunctionExpression: () => count++, ArrowFunctionExpression: () => count++, getCount: () => count }; } // 在遍历中使用 const counter = countFunctions(); traverse(ast, counter); console.log(`找到 ${counter.getCount()} 个函数`);

4. 与现有工具链集成

ESLint：如果你在编写自定义 ESLint 规则，直接使用 ESLint 提供的SourceCode对象（其背后就是espree解析的 AST），无需自己调用解析器。
Babel 插件：遵循 Babel 插件规范，直接操作@babel/core传递给你的 AST 和types对象。
Webpack Loader：在 Loader 中，你可以解析源代码，但通常更推荐使用acorn（Webpack 内部使用）以保持一致性，或者直接分析 Webpack 已有的 AST。

5. 版权与合规

代码所有权：确保你的工具只分析和处理你有权处理的代码。在开发公司内部工具时，这一点尤其重要。
依赖审查：如果你开发的工具会作为 npm 包发布，务必审查其依赖的许可证（如 Babel 系列包使用 MIT 许可证）。
敏感信息：避免在日志、错误报告中输出完整的用户源代码片段，尤其是可能包含密钥、密码的代码。

10. 总结与下一步

通过本文的步骤，你应该已经掌握了使用@babel/parser将 JavaScript 代码转换为 AST 的完整流程，并具备了遍历、修改和重新生成代码的能力。这项技能是深入前端工程化世界的敲门砖。

最值得尝试的下一步：

动手写一个简单的 Babel 插件：这是巩固 AST 操作知识的最佳实践。尝试写一个插件，将代码中的console.log自动加上所在的行号信息。
集成到现有工作流：看看你当前的项目，是否有重复性的代码操作（如自动生成 API 类型定义、提取国际化文案）可以通过 AST 解析来自动化？
探索 TypeScript AST：如果你使用 TypeScript，typescript编译器自带的 API 提供了更丰富的类型信息，对于静态分析更为强大。

最容易踩的坑：

节点类型判断：AST 节点类型繁多（如Identifier,MemberExpression,CallExpression），在编写 visitor 时务必对照 AST 浏览器仔细确认。
树形结构修改：直接修改 AST 节点引用很容易破坏树结构，务必使用@babel/types提供的方法（如t.identifier('newName')）来创建新节点，并使用path对象上的方法（如replaceWith,insertBefore）进行替换。

将代码视为可编程的数据（AST）而不仅仅是文本，会为你打开一扇新的大门。从自动化代码检查到智能代码补全，其应用场景非常广泛。建议将本文中的示例代码保存下来，作为你未来开发自定义代码处理工具时的参考模板。