1、介绍
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
解释器模式（Interpreter）是一种针对特定问题设计的一种解决方案。例如，匹配字符串的时候，由于匹配条件非常灵活，使得通过代码来实现非常不灵活。
举个例子，针对以下的匹配条件：
- 以+开头的数字表示的区号和电话号码，如+861012345678；
- 以英文开头，后接英文和数字，并以.分隔的域名，如www.liaoxuefeng.com；
- 以/开头的文件路径，如/path/to/file.txt；
- ...
因此，需要一种通用的表示方法——正则表达式来进行匹配。正则表达式就是一个字符串，但要把正则表达式解析为语法树，然后再匹配指定的字符串，就需要一个解释器。
实现一个完整的正则表达式的解释器非常复杂，但是使用解释器模式却很简单：
String s = "+861012345678";
System.out.println(s.matches("^\\+\\d+$"));
类似的，当我们使用JDBC时，执行的SQL语句虽然是字符串，但最终需要数据库服务器的SQL解释器来把SQL“翻译”成数据库服务器能执行的代码，这个执行引擎也非常复杂，但对于使用者来说，仅仅需要写出SQL字符串即可。
解释器模式的结构
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())
}
UML图：
