从零构建你的脚本语言：解释器核心与AST的第二天实战！67

嗨，各位语言爱好者，编程探索者们！我是你们的中文知识博主，再次和大家见面，继续我们的“两周自制脚本语言”宏伟计划！
---
#

昨天，我们激情澎湃地迈出了第一步，探讨了为什么要自制一门语言，以及它可能带给我们的巨大成就感和深刻理解。我们初步勾勒出了脑海中那门“麻雀虽小五脏俱全”的脚本语言的轮廓，并对解释器的工作流程有了一个高屋建景的认识。

如果说第一天是“立志篇”，那么今天，就是我们真正撸起袖子，深入“内脏”的“实战篇”！从今天开始，我们将正式进入解释器的核心构建环节，亲手打造出支撑语言运行的基石——词法分析器（Lexer）、语法分析器（Parser）以及它们共同的产物：抽象语法树（Abstract Syntax Tree, AST）。准备好了吗？让我们一起踏上这场激动人心的旅程！

重温第一天：我们为什么自制语言？

在深入今天的主题之前，让我们快速回顾一下自制语言的初心。我们不是为了取代Python或JavaScript，而是为了：

深入理解编程语言的运作机制：从用户视角到设计者视角，彻底揭开语言的神秘面纱。

满足特定领域需求：定制化解决问题，创造更贴合业务场景的DSL（领域特定语言）。

纯粹的学习乐趣与成就感：这本身就是一项极具挑战性和创造性的工程。

我们设想中的这门脚本语言，将是轻量级的、解释执行的，拥有基本的数据类型（数字、字符串、布尔值），支持变量定义、条件判断、循环和函数调用。这正是大多数入门级脚本语言的起点。

揭开解释器的面纱：核心工作流

在宏观层面，解释器的工作流程可以概括为：

源代码 -> 词法分析器 -> 语法分析器 -> 抽象语法树 (AST) -> 解释器/执行器 -> 结果

而今天，我们的重点就是前三个环节：词法分析、语法分析和AST的构建。它们是任何编程语言处理的“前端”，负责将人类可读的代码转换为计算机可理解并执行的结构。

脚本语言的眼睛：词法分析器（Lexer / Scanner）

想象一下，你拿到一篇用你自创语言写成的代码文件，这对于计算机来说，只是一串无意义的字符流。词法分析器（通常也称为扫描器 Scanner）就像是编程语言的“眼睛”，它负责第一步的解读：将输入的字符流分解成一系列有意义的“词法单元”（Token）。

什么是Token？

Token是程序中最小的、具有独立含义的语言单位。你可以把它类比为自然语言中的“单词”。例如，在英语中，“the”、“cat”、“sits”都是单词。在编程语言中，关键字（如`if`, `else`, `while`, `let`）、标识符（变量名、函数名）、运算符（`+`, `-`, `*`, `/`, `=`）、数字、字符串和分隔符（`;`, `(`, `)`）等等，都是Token。

词法分析器的工作原理：

词法分析器会从源代码的第一个字符开始，逐个读取字符，并根据预设的规则（通常是正则表达式或有限状态机）来识别出Token。每当识别出一个完整的Token，它就会将其封装成一个结构体或对象，包含Token的类型（如`TOKEN_KEYWORD_LET`，`TOKEN_NUMBER`）和它的值（Lexeme，如`"let"`，`"123"`）。

举个例子：

假设我们有这样一行代码： `let x = 10 + y;`

词法分析器会将其分解成以下Token序列：

Token { Type: KEYWORD_LET, Lexeme: "let" }

Token { Type: IDENTIFIER, Lexeme: "x" }

Token { Type: ASSIGN, Lexeme: "=" }

Token { Type: NUMBER, Lexeme: "10" }

Token { Type: PLUS, Lexeme: "+" }

Token { Type: IDENTIFIER, Lexeme: "y" }

Token { Type: SEMICOLON, Lexeme: ";" }

词法分析器还会负责忽略空白字符（空格、制表符、换行符）和注释，因为它们对于程序的结构和语义通常不重要。

Day 2 实践建议（Lexer）：

今天你可以尝试：

定义Token类型：用枚举（Enum）或其他方式定义你语言中所有可能出现的Token类型，例如`TOKEN_IDENTIFIER`, `TOKEN_NUMBER`, `TOKEN_STRING`, `TOKEN_KEYWORD_IF`, `TOKEN_PLUS`, `TOKEN_LPAREN`等等。

创建Token结构：定义一个Token结构体/类，包含`Type`和`Lexeme`（原始字符串值）字段。

实现核心函数：编写一个`next_token()`或`scan_token()`函数，它能从输入源代码中读取字符，并返回下一个Token。这会涉及到逐字符检查、根据字符特性（字母、数字、符号）来判断Token的边界和类型。

这是一个循序渐进的过程。先从最简单的Token（如单个运算符`+`, `-`，数字，标识符）开始，逐步增加复杂性（如字符串、关键字、多字符运算符`==`, `!=`）。

脚本语言的大脑：语法分析器（Parser）

词法分析器为我们提供了一串有序的Token。但这串Token本身并不能直接告诉我们程序的结构和逻辑。这就需要语法分析器（Parser）登场了。它就像是编程语言的“大脑”，负责根据语言的语法规则，将Token序列组织成有意义的句法结构。

语法规则与文法：

编程语言的语法规则通常用“文法”（Grammar）来描述，常见的表示方法有BNF（巴科斯范式）或EBNF（扩展巴科斯范式）。这些文法定义了语言中不同结构（如表达式、语句、函数定义）如何由Token组合而成。

例如，一个简单的赋值语句可能遵循这样的规则：

<statement> ::= <identifier> "=" <expression> ";"

这意味着一个语句可以是一个标识符，后面跟着一个等号，再后面跟着一个表达式，最后以分号结束。

语法分析器的工作：

语法分析器会从词法分析器那里获取Token流，然后尝试将这些Token匹配到预定义的语法规则上。如果Token流符合某个语法规则，它就会构建出相应的抽象语法树节点。如果Token流不符合任何规则，它就会报告一个语法错误。

最常见的语法分析器类型包括：

递归下降解析器（Recursive Descent Parser）：对于手工编写的解析器来说，这是一种非常直观且易于理解的方法。它为每条语法规则创建一个函数，这些函数会递归地调用彼此来解析嵌套的结构。

LR/LL解析器：更强大、更通用的解析器，通常由工具（如Yacc/Bison, ANTLR）自动生成，但理解和调试起来相对复杂。

对于我们自制的脚本语言，递归下降解析器是开始的好选择，因为它与我们思考语法的方式非常相似。

Day 2 实践建议（Parser）：

在Day 2，你可以开始规划和实现：

定义文法：写下你语言最核心的几条语法规则。从最简单的开始，例如：

program ::= statement* (一个程序由零个或多个语句组成)

statement ::= var_declaration | expression_statement | print_statement

expression_statement ::= expression ";"

expression ::= literal | unary | binary | group | assignment

规划Parser结构：创建一个Parser类/结构体，它会持有Lexer实例，并提供像`parse()`这样的入口函数。

实现核心解析函数：针对每一条语法规则，你可以编写一个对应的函数。例如，`parse_statement()`会根据当前Token的类型，判断是解析变量声明、表达式语句还是其他类型，并调用相应的子函数。`parse_expression()`会处理各种表达式的解析。

处理运算符优先级：在解析表达式时，要特别注意运算符的优先级（例如，乘除优先于加减）和结合性（左结合或右结合）。这通常通过不同的解析函数层级来实现。

脚本语言的骨架：抽象语法树（Abstract Syntax Tree, AST）

语法分析器的最终产物并不是直接执行代码，而是构建一个“抽象语法树”（AST）。AST是源代码结构的一种抽象表示，它移除了源代码中一些不必要的细节（如括号、分号等），只保留了程序结构和语义上的本质信息。

你可以把AST想象成一棵树状结构，树的每个节点都代表着程序中的一个构造（如一个表达式、一个语句、一个变量声明）。

为什么需要AST？

结构清晰：比原始代码或Token序列更直观地反映程序逻辑。

便于分析：更容易进行语义分析（如类型检查）、优化（如常量折叠）等操作。

解释或编译的基础：解释器可以直接遍历AST并执行，编译器则会把AST转换为中间代码或机器码。

举个例子：

代码 `let x = 10 + y;` 对应的AST可能长这样：

Program
└─ VariableDeclaration (Keyword: "let")
├─ Identifier (Name: "x")
└─ AssignmentExpression (Operator: "=")
├─ Identifier (Name: "x") // 这里是左值
└─ BinaryExpression (Operator: "+")
├─ NumberLiteral (Value: 10)
└─ Identifier (Name: "y")

请注意，AST节点是根据其语义角色来命名的，例如`VariableDeclaration`（变量声明）、`AssignmentExpression`（赋值表达式）、`BinaryExpression`（二元表达式）、`NumberLiteral`（数字字面量）等。每个节点都包含其子节点，从而形成一个树状结构。

Day 2 实践建议（AST）：

在Day 2，你需要：

定义AST节点类型：为你的语言中的每一个核心结构定义一个类或结构体作为AST节点。例如，你可以有一个基类`ASTNode`，然后派生出`Program`, `VariableDeclaration`, `BinaryExpression`, `NumberLiteral`, `Identifier`等子类。这些子类会包含各自特有的字段（如`BinaryExpression`会有`left`, `operator`, `right`）。

Parser与AST的结合：在Parser的各个解析函数中，当识别出符合某个语法规则的Token序列时，不是简单地打印或返回`true`，而是创建相应的AST节点，并将其作为子节点连接起来。例如，当`parse_binary_expression()`成功解析`10 + y`时，它应该返回一个`BinaryExpression`节点，其左子节点是`NumberLiteral(10)`，右子节点是`Identifier("y")`。

Day 2 实战：我们该做些什么？

好了，理论知识已经足够，是时候把手弄脏了！今天我们的核心任务就是：

选择你的编程语言：Python、Java、C++、Go、Rust……选择一门你最熟悉、最顺手的语言来构建你的解释器。Python因为其简洁和强大的字符串处理能力，非常适合快速原型开发。

启动项目骨架：创建一个新的项目文件夹，定义你的Lexer、Parser和AST的初步结构。

实现基本的Lexer：

定义`Token`类型和`Token`结构体。

实现`Lexer`类，包含一个`next_token()`方法，能够识别至少三种Token：数字（如`123`）、标识符（如`x`, `myVar`）和加号运算符（`+`）。

编写简单的测试，确保你的Lexer能正确地将`1 + abc`这样的字符串分解成`NUMBER`, `PLUS`, `IDENTIFIER`的Token序列。

定义基本的AST节点：

定义`ASTNode`基类。

派生出`NumberLiteralNode`（用于数字）、`IdentifierNode`（用于变量名）和`BinaryExpressionNode`（用于二元运算）。

实现初步的Parser：