Golang如何使用解释器解析表达式_Golang 解释器模式表达式解析实践

type Expression interface {
    Interpret(ctx map[string]interface{}) (interface{}, error)
}

type NumberExpression struct {
    Value float64
}
<p>func (n *NumberExpression) Interpret(ctx map[string]interface{}) (interface{}, error) {
return n.Value, nil
}</p><p>type VariableExpression struct {
Name string
}</p><p>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)
}</p><p>type AddExpression struct {
Left, Right Expression
}</p><p>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
}</p><p>type MultiplyExpression struct {
Left, Right Expression
}</p><p>func (m <em>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) </em> rightVal.(float64), nil
}

a := &VariableExpression{Name: "a"}
b := &VariableExpression{Name: "b"}
add := &AddExpression{Left: a, Right: b}
two := &NumberExpression{Value: 2}
expr := &MultiplyExpression{Left: add, Right: two}
<p>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

result, err := gval.Evaluate(`(a + b) * 2`, map[string]interface{}{"a": 3, "b": 5})
// result == 16