概念
解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。
模式的场景和优缺点
使用场景
对于一些固定文法构建一个解释句子的解释器
优点
- 可扩展性比较好，灵活
- 增加了新的解释表达式的方式
- 易于实现简单文法
缺点
- 可利用场景比较少
- 对于复杂的文法比较难维护
- 解释器模式会引起类膨胀
代码实现
package main
import (
"fmt"
"strconv"
"strings"
)
// Node ...
type Node interface {
Interpret() int
}
// ValNode ...
type ValNode struct {
val int
}
// Interpret ...
func (n *ValNode) Interpret() int {
return n.val
}
// AddNode ...
type AddNode struct {
left, right Node
}
// Interpret ...
func (n *AddNode) Interpret() int {
return n.left.Interpret() + n.right.Interpret()
}
// MinNode ...
type MinNode struct {
left, right Node
}
// Interpret ...
func (n *MinNode) Interpret() int {
return n.left.Interpret() - n.right.Interpret()
}
// Parser ...
type Parser struct {
exp []string
index int
prev Node
}
// Parse ...
func (p *Parser) Parse(exp string) {
p.exp = strings.Split(exp, " ")
for {
if p.index >= len(p.exp) {
return
}
// p.prev = p.newXXX, AddNode MinNode left， 一级一级存储上层的地址，最后调用 p.Result的时候， 会依次拿到上层存储的地址， 拿到每一层的数据。
switch p.exp[p.index] {
case "+":
p.prev = p.newAddNode()
case "-":
p.prev = p.newMinNode()
default:
p.prev = p.newValNode()
}
}
}
// newAddNode ...
func (p *Parser) newAddNode() Node {
p.index++
return &AddNode{
left: p.prev,
right: p.newValNode(),
}
}
// newMinNode ...
func (p *Parser) newMinNode() Node {
p.index++
return &MinNode{
left: p.prev,
right: p.newValNode(),
}
}
// newValNode ...
func (p *Parser) newValNode() Node {
v, _ := strconv.Atoi(p.exp[p.index])
p.index++
return &ValNode{
val: v,
}
}
// Result ...
func (p *Parser) Result() Node {
return p.prev
}
func main() {
p := &Parser{}
p.Parse("1 + 2 + 3 - 4 + 5 - 6")
// 调用 p.Result的时候， 会依次调用每一层的Interpret(), Interpret调用 left，拿到left存储的上层地址， 拿到每一层的数据。
res := p.Result().Interpret()
fmt.Printf("res:%d\n", res)
}
