设计模式——解释器模式

什么是解释器模式？

给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

实现

// Context 环境角色
type Context struct {
}

func NewContext() *Context {
    return &Context{}
}

// 抽象表达式类
type Expression interface {
    Interpreter(ctx Context)
}

// 终端解析器
type TerminalExpression struct {
}

func NewTerminalExpression() *TerminalExpression {
    return &TerminalExpression{}
}

func (this *TerminalExpression) Interpreter(ctx Context) {
    fmt.Println("终端解释器")
}

// 非终端解析器
type NonterminalExpression struct {
}

func NewNonterminalExpression() *NonterminalExpression {
    return &NonterminalExpression{}
}

func (this *NonterminalExpression) Interpreter(ctx Context) {
    fmt.Println("非终端解释器")
}

func TestNewTerminalExpression(t *testing.T) {
    ctx := NewContext()
    expList := []Expression{}
    expList = append(expList, NewTerminalExpression())
    expList = append(expList, NewNonterminalExpression())
    expList = append(expList, NewTerminalExpression())
    expList = append(expList, NewNonterminalExpression())
    expList = append(expList, NewNonterminalExpression())

    for _, exp := range expList {
        exp.Interpreter(*ctx)
    }
}
/*
=== RUN   TestNewTerminalExpression
终端解释器
非终端解释器
终端解释器
非终端解释器
非终端解释器
--- PASS: TestNewTerminalExpression (0.00s)
PASS
*/

优点

• 可扩展性好。

缺点

• 解释器模式会引起类膨胀；

• 解释器模式采用递归调用方法，将会导致调试非常复杂；

• 使用了大量的循环和递归，效率是一个不容忽视的问题。

使用场景

• 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树；
• 一些重复出现的问题可以用一种简单的语言来表达；
• 一个简单语法需要解释的场景。

注意

• 尽量不要在重要的模块中使用解释器模式，否则维护会是一个很大的问题。