答案：在Golang中通过定义Expression接口及Interpret方法实现解释器模式，将文法规则映射为对象结构，如VariableExpression、AndExpression等，构建表达式树解析布尔或算术表达式，适用于简单DSL场景。
在Golang中实现解释器模式解析表达式，核心是把语言的文法规则映射为对象结构，每个规则对应一个类（或接口实现），通过组合这些对象来解释语句。适用于简单语法、可预见的表达式场景，比如布尔逻辑、算术表达式等。
定义表达式接口
解释器模式的基础是定义统一的表达式接口，所有具体表达式都实现该接口的 Interpret 方法。
- 接口接收上下文（如变量值）作为参数
- 返回解释结果，例如 bool、int 或 interface{}
示例：定义一个用于布尔表达式的接口：
type Expression interface {
Interpret(context map[string]bool) bool
}
实现具体表达式节点
将文法中的每种操作抽象为结构体，比如变量、常量、逻辑与、逻辑或、非等。
立即学习“go语言免费学习笔记（深入）”；
- VariableExpression：表示变量，根据上下文返回其布尔值
- AndExpression：组合两个表达式，返回它们的逻辑与
- OrExpression：返回两个子表达式的逻辑或
- NotExpression：对一个表达式取反
代码示例：
type VariableExpression struct {
name string
}
func (v *VariableExpression) Interpret(context map[string]bool) bool {
return context[v.name]
}
type AndExpression struct {
left, right Expression
}
func (a *AndExpression) Interpret(context map[string]bool) bool {
return a.left.Interpret(context) && a.right.Interpret(context)
}
type OrExpression struct {
left, right Expression
}
func (o *OrExpression) Interpret(context map[string]bool) bool {
return o.left.Interpret(context) || o.right.Interpret(context)
}
type NotExpression struct {
expr Expression
}
func (n *NotExpression) Interpret(context map[string]bool) bool {
return !n.expr.Interpret(context)
}
构建表达式树
手动或通过解析器构造表达式对象树。对于复杂输入，可结合词法分析和递归下降解析器生成 AST。
以表达式 (A AND B) OR (NOT C) 为例：
func main() {
// 构建子表达式
A := &VariableExpression{name: "A"}
B := &VariableExpression{name: "B"}
C := &VariableExpression{name: "C"}
andExpr := &AndExpression{left: A, right: B}
notExpr := &NotExpression{expr: C}
orExpr := &OrExpression{left: andExpr, right: notExpr}
// 上下文赋值
ctx := map[string]bool{
"A": true,
"B": false,
"C": true,
}
result := orExpr.Interpret(ctx)
fmt.Println("Result:", result) // 输出: false
}
扩展：支持算术表达式
解释器模式也可用于数值计算。例如，加减乘除表达式：
- 定义返回 int 的 Interpret 方法
- 使用 NumberExpression 表示常量
- AddExpression、MultiplyExpression 等执行运算
示例片段：
type ArithmeticExpression interface {
Interpret() int
}
type NumberExpression struct {
value int
}
func (n *NumberExpression) Interpret() int {
return n.value
}
type AddExpression struct {
left, right ArithmeticExpression
}
func (a *AddExpression) Interpret() int {
return a.left.Interpret() + a.right.Interpret()
}
基本上就这些。解释器模式让语法规则变得可读且易于扩展，适合小型 DSL 设计。但性能不如编译型方案，复杂语法建议用 parser generator 工具辅助构建。关键在于清晰划分表达式类型，保持解释逻辑独立。
