Go设计模式--解释器模式-51CTO.COM

大家好，这里是每周都在陪你一起进步的网管～！今天继续学习设计模式—解释器模式

解释器模式是一种行为设计模式，可以用来在程序里创建针对一个特点领域语言的解释器，用于处理解释领域语言中的语句。换句话说，该模式定义了领域语言的抽象语法树以及用示来解释语法树的解释器。

模式使用场景

解释器模式，用于解决需要解释语言中的句子或表达式的问题。以下是一些可以在程序中使用解释器模式的真实场景：

处理配置文件

许多应用程序使用配置文件来指定应用程序的行为方式。这些配置文件可以用 YAML 或 JSON 等 DSL 编写。解释器可用于解析这些配置文件并以应用编程语言对象的形式向应用程序提供配置信息。

模板引擎
模板引擎处理模板和一组变量以产生输出。模板是DSL的一个例子，可以使用Interpreter来解析和处理模板。
数学表达式计算器
数学表达式是我们日常都能接触到的，使用了一种特定领域语言语法书写语句或者叫表达式的实例
这些表达式在程序里可以使用解释器模式进行解析和解释。例如，计算器应用程序可以使用解释器来解析和评估用户输入的数学表达式。
自然语言处理
在更高级的情况下，解释器模式可用于解析和解释自然语言，不过这通常会涉及想机器学习这样的更复杂的技术。

虽然解释器模式可以用来解决这些问题，但它并不总是最好的解决方案。对于复杂的语言，使用特定的解析库或工具或其他设计模式可能更有效。

下面我们先来学习一下解释器模式的结构组成，然后再尝试用代码自己实现一个解释器。

模式构成

解释器模式中的关键组件有：

表达式接口：表示抽象语法树的元素并定义解释表达式的方法。
具体表达式：实现表达式接口的结构，表示语言语法的各种规则或元素。
上下文对象：用于保存解释过程中所需的任何必要信息或状态。
Parser 或 Builder：负责根据输入表达式构建抽象语法树的组件。

下面是解释器模式构成的UML类图：

看完解释器模式的结构组成后，我们接下来尝试应用解释器模式，用代码实现一个加法运算的解释器。

实现解释器模式

看了上面解释器的结构组成后我们结下来通过代码一步步实现其核心组件来演示怎么用代码实现解释器模式。

以下是如何在 Go 中实现解释器模式的步骤。

定义表示抽象语法树中元素的表达式接口。
创建实现 Expression 接口的具体表达式结构，例如 TerminalExpression 和 NonTerminalExpression。
定义一个上下文结构来保存解释过程中可能需要的任何必要数据或状态（这一步可选）。
创建解析器或构建器以根据输入表达式构造抽象语法树。使用创建的抽象语法树和上下文解释表达式。

这里简单实现一个加减的运算器，我们对每种运算定义对应的Expression对象，在方法里实现具体的运算规则，避免所有的运算操作放到一个函数中，这体现了解释器模式的核心思想，将语法解析的工作拆分到各个小类中，以此来避免大而全的解析类。

我们先按照上面的步骤一，定义数学运算这一领域语言里表示抽象语法树中元素的表达式接口：

type Expression interface {
 Interpret() int
}

接下来创建Expression接口的具体实现类，在我们的加减法运算中需要实现操作数、加法、减法对应的实现类。

"本文使用的完整可运行源码
去公众号「网管叨bi叨」发送【设计模式】即可领取"
type NumberExpression struct {
 val int
}
// 解释--返回其整数值
func (n *NumberExpression) Interpret() int {
 return n.val
}

// 加法运算
type AdditionExpression struct {
 left, right Expression
}
// 解释--进行加法操作
func (n *AdditionExpression) Interpret() int {
 return n.left.Interpret() + n.right.Interpret()
}
// 减法运算
type SubtractionExpression struct {
 left, right Expression
}
// 解释--进行减法运算
func (n *SubtractionExpression) Interpret() int {
 return n.left.Interpret() - n.right.Interpret()
}

最后我们创建一个表达式解析器，它会根据输入表达式构造抽象语法树，使用创建的抽象语法树和上下文解释表达式。

"本文使用的完整可运行源码
去公众号「网管叨bi叨」发送【设计模式】即可领取"
type Parser struct {
 exp   []string
 index int
 prev  Expression
}

func (p *Parser) Parse(exp string) {
 p.exp = strings.Split(exp, " ")

 for {
  if p.index >= len(p.exp) {
   return
  }
  switch p.exp[p.index] {
  case "+":
   p.prev = p.newAdditionExpression()
  case "-":
   p.prev = p.newSubtractionExpression()
  default:
   p.prev = p.newNumberExpression()
  }
 }
}

func (p *Parser) newAdditionExpression() Expression {
 p.index++
 return &AdditionExpression{
  left:  p.prev,
  right: p.newNumberExpression(),
 }
}

func (p *Parser) newSubtractionExpression() Expression {
 p.index++
 return &SubtractionExpression{
  left:  p.prev,
  right: p.newNumberExpression(),
 }
}

func (p *Parser) newNumberExpression() Expression {
 v, _ := strconv.Atoi(p.exp[p.index])
 p.index++
 return &NumberExpression{
  val: v,
 }
}
// 返回Expression实例
// 调用Interpret方法会从右向左递归计算出公式结果
func (p *Parser) Result() Expression {
 return p.prev
}

最后，我们用使用 Parse 把客户端传递过来的加减法表达式解析成抽象语法树，然后运行解释器计算加减法表达式的结果。

"本文使用的完整可运行源码
去公众号「网管叨bi叨」发送【设计模式】即可领取"
func main() {
 p := &Parser{}
 p.Parse("1 + 3 + 3 + 3 - 3")
 res := p.Result().Interpret()
 expect := 7
 if res != expect {
  log.Fatalf("error: expect %d got %d", expect, res)
 }

 fmt.Printf("expect: %d, got: %d", expect, res)
}

总结

在程序中使用解释器模式的目标是：定义特定于领域的语言及其语法，使用 AST（抽象语法树）表示语言中的表达式或句子，好让程序能够根据一组规则或操作解释或评估表达式

最后我们再来列举一下解释器模式的优缺点。使用解释器模式的优点是：

关注点分离：该模式将解释逻辑与数据表示分开。
可扩展性：可以通过添加新的表达式结构轻松地扩展模式。
可重用性：解释器模式可以在需要解析或解释特定领域语言的不同项目或上下文中重用。

使用解释器模式的缺点是：

复杂性：随着语法规则数量的增加，模式会变得复杂。
性能：对于大型表达式，抽象语法树的递归遍历可能很慢。