解释器模式

问题：
解释器模式就是用“迷你语言”来表现程序要解决的问题，以“迷你语言”写成“迷你程序”来表现具体的问题，例如正则表达式就是一个很好的例子。所以，通常当有一个语言需要解释执行，并且可以将该语言中的句子表示为一个抽象语法树时，就可以使用解释器模式了。

概念：
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

实现：
1. 类图示例：

2. 代码示例：（实现一个迷你语言解释器）

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141

//表达文本类 class InterpreterContext {     private $expressionstore = [];       public function replace(Expression $exp, $value)     {         $this->expressionstore[$exp->getKey()] = $value;     }       public function lookup(Expression $exp)     {         return $this->expressionstore[$exp->getKey()];     } } //表达式基类 abstract class Expression {     private static $keycount = 0;     private $key;     abstract public function interpret(InterpreterContext $context);       public function getKey()     {         if(!isset($this->key)) {             self::$keycount ++;             $this->key = self::$keycount;         }         return $this->key;     } } //字符串表达式类 class LiteralExpression extends Expression {     private $value;       public function __construct($value)     {         $this->value = $value;     }       public function interpret(InterpreterContext $context)     {         $context->replace($this, $this->value);     } } //变量表达式类 class VariableExpression extends Expression {     private $name;     private $val;       public function __construct($name, $val = null)     {         $this->name = $name;         $this->val = $val;     }       public function interpret(InterpreterContext $context)     {         if(!is_null($this->val)) {             $context->replace($this, $this->val);             $this->val = null;         }     }       public function setValue($value)     {         $this->val = $value;     }       public function getKey()     {         return $this->name;     } } //操作符表达式基类 abstract class OperatorExpression extends Expression {     protected $l_op;     protected $r_op;       public function __construct(Expression $l_op, Expression $r_op)     {         $this->l_op = $l_op;         $this->r_op = $r_op;     }       public function interpret(InterpreterContext $context)     {         $this->l_op->interpret($context);         $this->r_op->interpret($context);         $result_l = $context->lookup($this->l_op);         $result_r = $context->lookup($this->r_op);         $this->doInterpret($context, $result_l, $result_r);     }       abstract protected function doInterpret(InterpreterContext $context, $result_l, $result_r); } //相等表达式类 class EqualsExpression extends OperatorExpression {     protected function doInterpret(InterpreterContext $context, $result_l, $result_r)     {         $context->replace($this, $result_l == $result_r);     } } //布尔或表达式类 class BooleanOrExpression extends OperatorExpression {     protected function doInterpret(InterpreterContext $context, $result_l, $result_r)     {         $context->replace($this, $result_l || $result_r);     } } //布尔与表达式类 class BooleanAndExpression extends OperatorExpression {     protected function doInterpret(InterpreterContext $context, $result_l, $result_r)     {         $context->replace($this, $result_l && $result_r);     } }   //应用：$input equals "4" or $input equals "four" $context = new InterpreterContext(); $input = new VariableExpression('input'); $statement = new BooleanOrExpression(     new EqualsExpression($input, new LiteralExpression('four')),     new EqualsExpression($input, new LiteralExpression('4')) ); foreach(['four', '4', '52'] as $val) {     $input->setValue($val);     echo $val, '：';     $statement->interpret($context);     if($context->lookup($statement)) {         echo 'Yes<br>';     } else {         echo 'No<br>';     } }

注：示例代码中同时也使用了模板方法模式和组合模式。

效果：
创建了解释器的核心类后，解释器很容易进行扩展。但是解释器模式为文法中的每一条规则至少定义了一个类，当语言变得复杂，文法包含的规则很多时，需要创建的类的数量会很快增加，因此解释器模式最好应用于相对小的语言。