GO设计模式——17、解释器模式(行为型)

目录

[解释器模式(Interpreter Pattern)](#解释器模式(Interpreter Pattern))

解释器模式的核心角色:

优缺点

代码实现


解释器模式(Interpreter Pattern)

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

解释器模式核心角色

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

优缺点

(1)优点:

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

(2)缺点:

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

代码实现

Go 复制代码
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())
}
相关推荐
程序员爱钓鱼5 小时前
Go语言实战案例——进阶与部署篇:编写Makefile自动构建Go项目
后端·算法·go
该用户已不存在5 小时前
别再用 if err != nil 了,学会这几个技巧,假装自己是Go大神
后端·go
李广坤6 小时前
状态模式(State Pattern)
设计模式
n8n7 小时前
Go语言操作Redis全面指南
go
李广坤8 小时前
观察者模式(Observer Pattern)
设计模式
李广坤8 小时前
中介者模式(Mediator Pattern)
设计模式
李广坤9 小时前
迭代器模式(Iterator Pattern)
设计模式
李广坤9 小时前
解释器模式(Interpreter Pattern)
设计模式
会跑的葫芦怪9 小时前
Go语言操作Redis
开发语言·redis·golang
静谧之心11 小时前
在 K8s 上可靠运行 PD 分离推理:RBG 的设计与实现
云原生·容器·golang·kubernetes·开源·pd分离