【解释器设计模式详解】C/Java/Go/JS/TS/Python不同语言实现

简介

解释器模式（Interpreter Pattern）是一种行为型设计模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式常被用在 SQL 解析、符号处理引擎等。
解释器模式常用于对简单语言的编译或分析实例中，为了掌握好它的结构与实现，必须先了解编译原理中的“文法、句子、语法树”等相关概念。
 
作用

• 可扩展性比较好，灵活，增加了新的解释表达式的方式，易于实现简单文法。
  
• 在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易。
  

 
实现步骤

• 创建抽象表达式接口（Expression），各种表达式都要实现该接口。
  
• 分别创建最终表达式和非最终表达式。最终表达式（这里是VarExpression）没有子级，直接解释表达式。非最终表达式（这里是AddExpression和SubtractExpression）是维护子表达式的容器，并将解释请求转发给这些表达式。
  
• 创建上下文环境类（这里是Context），用来表达式求值时构建执行环境。
  
• 客户端调用时先建立执行上下文环境，然后声明变量，再进行计算。
  

 
UML

 
 
Java代码

 
抽象表达式接口

3. // Expression.java 抽象表达式接口，根据业务场景规范表达式
4. public interface Expression {
5.   public int interpret(Context context);
6. }

复制代码

 
 
具体表达式实现

 

1. // AddExpression.java 具体表达式，实现了抽象表达式接口
2. public class AddExpression implements Expression {
4.     private Expression exprOne = null;
5.     private Expression exprTwo = null;
7.     public AddExpression(Expression exprOne, Expression exprTwo) {
8.         this.exprOne = exprOne;
9.         this.exprTwo = exprTwo;
10.     }
12.     // 覆盖表达式，执行context对象
13.     @Override
14.     public int interpret(Context context) {
15.         System.out.println(this.getClass().getName() + "::interpret() [context = " + context.getClass().getName() + "]");
16.         return exprOne.interpret(context) + exprTwo.interpret(context);
17.     }
18. }
21. // SubtractExpression.java 具体表达式，实现了抽象表达式接口
22. public class SubtractExpression implements Expression {
24.   private Expression exprOne = null;
25.   private Expression exprTwo = null;
27.   public SubtractExpression(Expression exprOne, Expression exprTwo) {
28.     this.exprOne = exprOne;
29.     this.exprTwo = exprTwo;
30.   }
32.   // 覆盖表达式，执行context对象
33.   @Override
34.   public int interpret(Context context) {
35.     System.out.println(this.getClass().getName() + "::interpret() [context = " + context.getClass().getName() + "]");
36.     return exprOne.interpret(context) - exprTwo.interpret(context);
37.   }
38. }
41. // VarExpression.java 变量表达式，或者叫终端表达式，其他表达式求值时通过层层追溯最后指向这里
42. // 变量与执行环境的Key对应，最终会通过key获取传入的值
43. public class VarExpression implements Expression {
44.   private String key;
46.   public VarExpression(String key) {
47.     this.key = key;
48.   }
50.   @Override
51.   // 覆盖表达式，根据key获取变量
52.   public int interpret(Context context) {
53.     return context.get(key);
54.   }
55. }

复制代码

 
执行环境类

 

1. // Context.java 构建可执行环境上下文
2. public class Context {
4.    private Map<String, Integer> map = new HashMap<>();
6.    public Context(String key, int value) {
7.       this.add(key, value);
8.    }
10.    public Context() {
11.    }
13.    public void add(String key, int value) {
14.       map.put(key, value);
15.    }
17.    public int get(String key) {
18.       return map.get(key);
19.    }
20. }
23. // Application.java 调用程序，组织各种解释器
24.     /*
25.      * 解释器模式先构建执行上下文Context，然后构建一个最终的获取值的表达式VarExpression，这就构成了含上下文和变量-值的基本环境。
26.      * 再将基本环境放到工具表达式里AddExpression或SubtractExpreesion进行计算，最终得到结果。
27.      */
29.    // 构建两个数相加的例子
30.    public static int addTwo(int one, int two) {
31.       // 构建执行上下文环境
32.       Context context = new Context();
33.       context.add("one", one);
34.       context.add("two", two);
36.       // 构建表达式
37.       VarExpression varOne = new VarExpression("one");
38.       VarExpression varTwo = new VarExpression("two");
40.       // 再构建变量来进行计算，看起来啰嗦，但这样构建多种不同表达式计算就变得简单
41.       Expression result = new AddExpression(varOne, varTwo);
42.       return result.interpret(context);
43.    }
45.    // 构建连加计算的例子
46.    public static int addMore(int... numbers) {
47.       if (numbers.length <= 1) {
48.          return numbers[0];
49.       }
51.       Context context = new Context();
52.       // 构建执行环境
53.       for (int num : numbers) {
54.          context.add("num" + num, num);
55.       }
57.       // 先取出前两个作为计算基础
58.       VarExpression varOne = new VarExpression("num" + numbers[0]);
59.       VarExpression varTwo = new VarExpression("num" + numbers[1]);
60.       // 再构建表达式，先赋值前两个
61.       Expression expression = new AddExpression(varOne, varTwo);
63.       // 如果只有两个数则直接返回计算结果
64.       if (numbers.length == 2) {
65.          return expression.interpret(context);
66.       }
68.       // 如果数量超过两个则累加表达式再求值
69.       for (int i = 2; i < numbers.length; i++) {
70.          Expression nextExpression = new VarExpression("num" + numbers[i]);
71.          // 表达式不断累加
72.          expression = new AddExpression(expression, nextExpression);
73.       }
75.       return expression.interpret(context);
76.    }
78.    // 计算前两个数相加，再减去后一个数的计算例子
79.    public static int addAndSubtract(int one, int two, int three) {
80.       // 构建执行上下文环境，有3个可操作的域
81.       Context context = new Context();
82.       context.add("one", one);
83.       context.add("two", two);
84.       context.add("three", three);
86.       // 构建表达式，有3个变量
87.       VarExpression varOne = new VarExpression("one");
88.       VarExpression varTwo = new VarExpression("two");
89.       VarExpression varThree = new VarExpression("three");
92.       // 再构建计算步骤，前两个用加法
93.       Expression result = new AddExpression(varOne, varTwo);
94.       result = new SubtractExpression(result, varThree);
95.       // 第3个用减法
96.       return result.interpret(context);
97.    }

复制代码

 
执行环境类

 

3.     /**
4.      * 解释器模式实现了一个表达式接口，该接口可以解释一个特定的上下文的变量和语句。
5.      * 也就是先定义上下文，然后定义变量，再使用表达式进行求值。相当可以构造一个简单的语法解析器。
6.      */
8.     int result1 = Application.addTwo(1, 2);
9.     System.out.println("result1: " + result1);
11.     int result2 = Application.addMore(1, 2, 3, 4, 5);
12.     System.out.println("result2: " + result2);
14.     int result3 = Application.addAndSubtract(3, 4, 5);
15.     System.out.println("result3: " + result3);

复制代码

 
测试调用

3. // Expression.go 抽象表达式接口，根据业务场景规范表达式
4. type Expression interface {
5.   Interpret(context Context) int
6. }

复制代码

 
 
更多语言版本

不同语言实现设计模式，请关注：https://github.com/microwind/design-pattern

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！