解释器模式通过定义表达式接口和上下文环境，将语法单元抽象为可解释对象，在Go中结合AST实现安全的表达式解析与求值，适用于规则引擎等场景。
在Go语言中实现表达式解析，通常会借助解释器模式（Interpreter Pattern）来处理简单的语法结构。虽然Go没有内置的动态代码执行机制（如Python的eval），但通过构建抽象语法树（AST）并结合解释器模式，可以安全地解析和求值数学、逻辑或自定义领域表达式。
什么是解释器模式？
解释器模式属于行为型设计模式，适用于需要对特定语言或表达式进行解析与求值的场景。它通过定义一个表达式接口，让每种语法规则对应一个具体类，并由上下文环境驱动解释过程。
在Go中，我们可以用接口和结构体组合的方式实现该模式：
type Expression interface {
Interpret(ctx map[string]interface{}) (interface{}, error)
}构建基本表达式类型
以解析类似 "(a + b) * 2" 的数学表达式为例，需定义常量、变量、加法、乘法等节点类型：
立即学习“go语言免费学习笔记（深入）”；
- NumberExpression：表示常量数字
- VariableExpression：从上下文中获取变量值
- AddExpression 和 MultiplyExpression：组合两个子表达式进行运算
示例实现：
type NumberExpression struct {
Value float64
}
func (n *NumberExpression) Interpret(ctx map[string]interface{}) (interface{}, error) {
return n.Value, nil
}
type VariableExpression struct {
Name string
}
func (v *VariableExpression) Interpret(ctx map[string]interface{}) (interface{}, error) {
if val, ok := ctx[v.Name]; ok {
if f, ok := val.(float64); ok {
return f, nil
}
return 0.0, fmt.Errorf("variable %s is not a number", v.Name)
}
return 0.0, fmt.Errorf("undefined variable %s", v.Name)
}
type AddExpression struct {
Left, Right Expression
}
func (a *AddExpression) Interpret(ctx map[string]interface{}) (interface{}, error) {
leftVal, err := a.Left.Interpret(ctx)
if err != nil {
return nil, err
}
rightVal, err := a.Right.Interpret(ctx)
if err != nil {
return nil, err
}
return leftVal.(float64) + rightVal.(float64), nil
}
type MultiplyExpression struct {
Left, Right Expression
}
func (m MultiplyExpression) Interpret(ctx map[string]interface{}) (interface{}, error) {
leftVal, err := m.Left.Interpret(ctx)
if err != nil {
return nil, err
}
rightVal, err := m.Right.Interpret(ctx)
if err != nil {
return nil, err
}
return leftVal.(float64) rightVal.(float64), nil
}
手动构建AST并解释执行
假设我们要解析表达式 (a + b) * 2，可手动构造其语法树：
a := &VariableExpression{Name: "a"}
b := &VariableExpression{Name: "b"}
add := &AddExpression{Left: a, Right: b}
two := &NumberExpression{Value: 2}
expr := &MultiplyExpression{Left: add, Right: two}
ctx := map[string]interface{}{"a": 3.0, "b": 5.0}
result, err := expr.Interpret(ctx)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Result: %v\n", result) // 输出: Result: 16
这种方式清晰可控，适合规则固定的小型DSL或配置条件判断。
如何支持字符串输入？引入简单解析器
上面是手动建树，实际应用中往往需要从字符串解析。可用go/parser + go/ast处理Go表达式，或使用第三方库如peg、participle构建自定义文法解析器。
若只处理简单算术表达式，也可手写递归下降解析器。例如识别1 + 2 * a，按优先级拆分加减与乘除。
简化版思路：
- 词法分析：将输入切分为token（数字、变量名、操作符、括号）
- 语法分析：根据优先级生成AST节点
- 调用Interpret方法求值
对于更复杂需求，推荐使用github.com/PaesslerAG/gval，它支持动态表达式求值，语法接近Go：
result, err := gval.Evaluate(`(a + b) * 2`, map[string]interface{}{"a": 3, "b": 5})
// result == 16基本上就这些。Go虽不支持直接eval，但通过解释器模式+AST能优雅实现表达式解析。关键是把每个语法单元抽象为可解释对象，再交由上下文运行。适合权限判断、规则引擎、模板条件等场景。
