GO设计模式——17、解释器模式（行为型）

目录

解释器模式（Interpreter Pattern）

解释器模式的核心角色：

优缺点

代码实现

---

解释器模式（Interpreter Pattern）

        解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

解释器模式的核心角色：

• 抽象表达式（Abstract Expression）：定义了抽象的解释器接口，用来解释语言中的元素，可以是终止符，也可以是非终止符。
• 终止符表达式（Terminal Expression）：实现了抽象表达式中的解释器接口，用来存储语言中的终止符，它们不需要再次解释，通常会返回具体的结果。
• 非终止符表达式（Nonterminal Expression）：也实现了抽象表达式中的解释器接口，用来存储语言中的非终止符。
• 上下文（Context）：存储解释器解释的信息，并调用解释器进行解释。

优缺点

（1）优点：

• 可扩展性比较好，灵活。
• 增加了新的解释表达式的方式。
• 易于实现简单文法。

（2）缺点：

• 可利用场景比较少。
• 对于复杂的文法比较难维护。
• 解释器模式会引起类膨胀。
• 解释器模式采用递归调用方法。

代码实现

package main

import (
    "fmt"
    "strconv"
    "strings"
)

// 解释器接口
type Node interface {
    Interpret() int //解释方法
}

// 数据节点
type ValNode struct {
    val int
}

func (vn *ValNode) Interpret() int {
    return vn.val
}

// =============加法节点=============
type AddNode struct {
    left, right Node
}

func (an *AddNode) Interpret() int {
    return an.left.Interpret() + an.right.Interpret()
}

// =============减法节点=============
type SubNode struct {
    left, right Node
}

func (an *SubNode) Interpret() int {
    return an.left.Interpret() - an.right.Interpret()
}

// =============解释对象=============
type Parser struct {
    exp   []string //表达式
    index int      //索引
    prev  Node     //前序节点
}

func (p *Parser) newValNode() Node { //执行数据操作
    v, _ := strconv.Atoi(p.exp[p.index])
    p.index++
    return &ValNode{val: v}
}
func (p *Parser) newAddNode() Node { //执行加法操作( + )
    p.index++
    return &AddNode{
       left:  p.prev,
       right: p.newValNode(),
    }
}
func (p *Parser) newSubNode() Node { //执行减法操作( - )
    p.index++
    return &SubNode{
       left:  p.prev,
       right: p.newValNode(),
    }
}
func (p *Parser) Result() Node { //返回结果
    return p.prev
}
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.newAddNode()
       case "-":
          p.prev = p.newSubNode()
       default:
          p.prev = p.newValNode()

       }
    }
}
func main() {
    p := Parser{}
    p.Parse("1 + 2 + 3 - 4 + 10") //是通过空格进行解释的
    fmt.Println(p.Result().Interpret())
}