解释器模式(Interpreter Design Pattern)

解释器模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式常被用在SQL解析、代码编译器、符号处理引擎等，它是一种针对特定问题而设计的解决方案。

代码示例

例如给计算器一个字符串的表达式 "1+10"，计算器要先把数字和操作符解析出来，然后按照操作符的优先级，再由不同的操作符解释器去处理，这里以加法解释器为例：

package interpreter

import (
    "strconv"
    "strings"
)

type Expression interface {
    Interpret() int
}

//加法处理器
type AddExpression struct {
    expr1 Expression
    expr2 Expression
}

func NewAddExpression(expr1, expr2 NumberExpression) *AddExpression {
    return &AddExpression{
        expr1: expr1,
        expr2: expr2,
    }
}
func (add AddExpression) Interpret() int {
    return add.expr1.Interpret() + add.expr2.Interpret()
}

//数字处理器
type NumberExpression struct {
    num int
}

func NewNumberExpression(expression string) *NumberExpression {
    num, _ := strconv.Atoi(strings.Trim(expression, " "))
    return &NumberExpression{
        num: num,
    }
}

func (exp NumberExpression) Interpret() int {
    return exp.num
}

//计算器
type Calculator struct {
    expression string
}

func NewCalculator(expression string) *Calculator {
    return &Calculator{expression: expression}
}

func (c Calculator) Calculate() int {
    var expr1 *NumberExpression
    var expr2 *NumberExpression
    for i, s := range c.expression {
        switch s {
        case '+':
            expr1 = NewNumberExpression(c.expression[0 : i-1])
            expr2 = NewNumberExpression(c.expression[i+1 : len(c.expression)])
        }
    }
    if expr1 != nil && expr2 != nil {
        addExpr := NewAddExpression(*expr1, *expr2)
        return addExpr.Interpret()
    }
    return 0
}

调用：

calc := NewCalculator("1 + 10")
result := calc.Calculate()
fmt.Println(result)

// Output:
// 11