给定一个语言, 定义它的文法的一种表示，并定义一个解释器, 该解释器使用该表示来解释语言中的句子。
此例来自心谭博客

  1. class Context {
  2.     constructor() {
  3.       this._list = []; // 存放 终结符表达式
  4.       this._sum = 0; // 存放 非终结符表达式(运算结果)
  5.     }
  7.     get sum() {
  8.       return this._sum;
  9.     }
  10.     set sum(newValue) {
  11.       this._sum = newValue;
  12.     }
  13.     add(expression) {
  14.       this._list.push(expression);
  15.     }
  16.     get list() {
  17.       return [...this._list];
  18.     }
  19.   }
  21.   class PlusExpression {
  22.     interpret(context) {
  23.       if (!(context instanceof Context)) {
  24.         throw new Error("TypeError");
  25.       }
  26.       context.sum = ++context.sum;
  27.     }
  28.   }
  29.   class MinusExpression {
  30.     interpret(context) {
  31.       if (!(context instanceof Context)) {
  32.         throw new Error("TypeError");
  33.       }
  34.       context.sum = --context.sum;
  35.     }
  36.   }
  38.   /** 以下是测试代码 **/
  39.   const context = new Context();
  41.   // 依次添加: 加法 | 加法 | 减法 表达式
  42.   context.add(new PlusExpression());
  43.   context.add(new PlusExpression());
  44.   context.add(new MinusExpression());
  46.   // 依次执行: 加法 | 加法 | 减法 表达式
  47.   context.list.forEach(expression => expression.interpret(context));
  48.   console.log(context.sum);

优点

  • 易于改变和扩展文法。

  • 由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法

    缺点

  • 执行效率较低，在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度慢

  • 对于复杂的文法比较难维护