我的设计模式之旅 ④ 解释器模式.

一个菜鸟的设计模式之旅，文章可能会有不对的地方，恳请大佬指出错误。
编程旅途是漫长遥远的，在不同时刻有不同的感悟，本文会一直更新下去。
程序介绍


本程序实现解释器模式。程序可按需加载用户自定义的.work后缀文件，将每行的命令解释为具体行为。喵叫几次、进程休眠几秒、输出范围内随机数、运行另外的work文件。

1. Meow载入额外配置信息-----> 额外的配置信息
2. 喵~喵~喵~喵~喵~
3. Sleep载入额外配置信息-----> 额外的配置信息
4. 开始睡眠 3 s
5. Rand载入额外配置信息-----> 额外的配置信息
6. 获取 5~10 随机数 -> 9
7. Sleep载入额外配置信息-----> 额外的配置信息
8. 开始睡眠 5 s
9. Rand载入额外配置信息-----> 额外的配置信息
10. 获取 100~200 随机数 -> 276
11. 找不到该条指令的规则 疯狂星期四
12. Call载入额外配置信息-----> 额外的配置信息
13. Meow载入额外配置信息-----> 额外的配置信息
14. 喵~喵~
15. 找不到该条指令的规则 rand
16. 程序执行结束
17. Meow载入额外配置信息-----> 额外的配置信息
18. 喵~
19. 程序执行结束

复制代码

程序代码

data/duty.work

1. meow 5
2. sleep 3
3. random 5~10
4. sleep 5
5. random 100~200
6. 疯狂星期四 v我50
7. call ./data/test.work
8. meow 1

复制代码

data/test.work

1. meow 2
2. rand 0~1

复制代码

methods.go

1. package main
3. import (
4.         "fmt"
5.         "io"
6.         "math/rand"
7.         "strings"
8.         "time"
9. )
11. func meow(count int) {
12.         fmt.Println(strings.Repeat("喵~", count))
13. }
15. func sleep(count int) {
16.         fmt.Printf("开始睡眠 %v s\n", count)
17.         time.Sleep(time.Second * time.Duration(count))
18. }
20. func random(start, end int) {
21.         fmt.Printf("获取 %v~%v 随机数 -> %v\n", start, end, rand.Intn(end)+start)
22. }
24. func doWork(path string) {
25.         c := &context{comment: "额外的配置信息"}
26.         c.Open(path)
27.         for {
28.                 method, err := c.Read()
29.                 if err != io.EOF {
30.                         switch method {
31.                         case "meow":
32.                                 var meow expression = &MeowExpression{}
33.                                 meow.Interpret(c)
34.                         case "sleep":
35.                                 var sleep expression = &SleepExpression{}
36.                                 sleep.Interpret(c)
37.                         case "random":
38.                                 var random expression = &RandomExpression{}
39.                                 random.Interpret(c)
40.                         case "call":
41.                                 var call expression = &CallExpression{}
42.                                 call.Interpret(c)
43.                         default:
44.                                 fmt.Println("找不到该条指令的规则", method)
45.                         }
46.                 } else {
47.                         break
48.                 }
49.         }
50.         fmt.Println("程序执行结束")
51. }

复制代码

doWork()函数用于创建上下文对象，并遍历行，采用了简单工厂模式。（略有违背单一职责原则，在这里只做案例演示）
事实上每添加一种文法，就需要添加一个类，同时修改这个简单工厂，对分支判断进行修改。在这里可以用反射改进，可以参考 “我的设计模式编程之旅 ①” 来动态生成实例对象，从而符合封闭-开放原则。
interpreter.go

1. package main
3. import (
4.         "bufio"
5.         "fmt"
6.         "io"
7.         "log"
8.         "os"
9.         "strconv"
10.         "strings"
11. )
13. type context struct {
14.         file    *os.File
15.         scanner *bufio.Scanner
16.         line    string // ^ 当前行
17.         comment string // ^ 额外配置信息
18. }
20. // 打开文件并转换成 bufio.Scanner
21. func (c *context) Open(path string) {
22.         file, err := os.Open(path)
23.         if err != nil {
24.                 log.Fatal(err)
25.         }
26.         c.file = file
27.         scanner := bufio.NewScanner(file)
28.         c.scanner = scanner
29. }
31. // 关闭 bufio.Scanner
32. func (c *context) Close() {
33.         c.file.Close()
34.         c.file = nil
35.         c.scanner = nil
36. }
38. // 获取当前行并将光标移到下一行
39. func (c *context) Read() (string, error) {
40.         if c.scanner == nil {
41.                 log.Fatal("no scanner")
42.         }
43.         if c.scanner.Scan() {
44.                 c.line = c.scanner.Text()
45.                 return strings.Split(c.line, " ")[0], nil
46.         } else {
47.                 return "", io.EOF
48.         }
49. }
51. type expression interface {
52.         Interpret(c *context)
53. }
55. type MeowExpression struct{}
56. type SleepExpression struct{}
57. type RandomExpression struct{}
58. type CallExpression struct{}
60. func (e MeowExpression) Interpret(c *context) {
61.         fmt.Println("Meow载入额外配置信息----->", c.comment)
62.         params := strings.Split(c.line, " ")[1]
63.         i, err := strconv.Atoi(params)
64.         if err != nil {
65.                 log.Fatal(err)
66.         }
67.         meow(i)
68. }
70. func (e SleepExpression) Interpret(c *context) {
71.         fmt.Println("Sleep载入额外配置信息----->", c.comment)
72.         params := strings.Split(c.line, " ")[1]
73.         i, err := strconv.Atoi(params)
74.         if err != nil {
75.                 log.Fatal(err)
76.         }
77.         sleep(i)
78. }
80. func (e RandomExpression) Interpret(c *context) {
81.         fmt.Println("Rand载入额外配置信息----->", c.comment)
82.         params := strings.Split(c.line, " ")
83.         params = strings.Split(params[1], "~")
84.         start, err := strconv.Atoi(params[0])
85.         if err != nil {
86.                 log.Fatal(err)
87.         }
88.         end, err := strconv.Atoi(params[1])
89.         if err != nil {
90.                 log.Fatal(err)
91.         }
92.         random(start, end)
93. }
95. func (e CallExpression) Interpret(c *context) {
96.         fmt.Println("Call载入额外配置信息----->", c.comment)
97.         params := strings.Split(c.line, " ")
98.         doWork(params[1])
99. }

复制代码

main.go

1. package main
3. import (
4.         "math/rand"
5.         "time"
6. )
8. func main() {
9.         rand.Seed(time.Now().Unix())
10.         doWork("./data/duty.work")
11. }

复制代码

Console

1. Meow载入额外配置信息-----> 额外的配置信息
2. 喵~喵~喵~喵~喵~
3. Sleep载入额外配置信息-----> 额外的配置信息
4. 开始睡眠 3 s
5. Rand载入额外配置信息-----> 额外的配置信息
6. 获取 5~10 随机数 -> 9
7. Sleep载入额外配置信息-----> 额外的配置信息
8. 开始睡眠 5 s
9. Rand载入额外配置信息-----> 额外的配置信息
10. 获取 100~200 随机数 -> 276
11. 找不到该条指令的规则 疯狂星期四
12. Call载入额外配置信息-----> 额外的配置信息
13. Meow载入额外配置信息-----> 额外的配置信息
14. 喵~喵~
15. 找不到该条指令的规则 rand
16. 程序执行结束
17. Meow载入额外配置信息-----> 额外的配置信息
18. 喵~
19. 程序执行结束

复制代码

思考总结

什么是解释器模式

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。解决的是一种类型的问题发生的频率足够高，可以将各个实例表述为简单语言中的句子。

解释器模式：给定一个语言，定义它的文法（书写规则结构）的一种表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。

意图：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。
主要解决：对于一些固定文法构建一个解释句子的解释器。
何时使用：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。
如何解决：构建语法树，定义终结符与非终结符。
关键代码：构建环境类，包含解释器之外的一些全局信息，一般是 HashMap。
应用实例：编译器、运算表达式计算。
优点：

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

缺点：

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

解释器为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。建议当文法复杂时，使用其他的技术如语法分析程序或编译器生成器来处理。
使用场景：

• 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
  
• 一些重复出现的问题可以用一种简单的语言来进行表达。
  
• 一个简单语法需要解释的场景。
  

扩展应用场景


参考资料

• 《Go语言核心编程》李文塔
  
• 《Go语言高级编程》柴树彬、曹春辉
  
• 《大话设计模式》程杰
  
• 单例模式 | 菜鸟教程
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！