查看: 2362|回复: 0

[PHP学习] 老生常谈PHP面向对象之解释器模式

发表于 2018-3-31 08:00:03

最近在看 “深入PHP面向对象模式与实践” ,学习书中的内容后瞬间觉得自己有点高大上了,哈 ! 其实还是个菜B。相信也会有新手朋友在看这本(我自己也是新手),对书中我个人认为比较难的内容的学习心得就想拿出来分享和交流,1是希望对自己所学知识能够起到巩固和加深理解的作用 2是希望对看到本文且感兴趣的新手朋友一些帮助。

这部分内容看了好几遍了代码也跟着敲了几遍,估计本文想要实现的功能大概就是用户在web页面上输入一些内容,然后通过后台程序解析后进行回复(感觉就是在废话)。例如我在前台web页面输入框里输入:

  1. $input = "4";
  2. $input equals "4" or $input equals "four";
复制代码

然后提交,系统就会回复类似 “条件成立” 或者 “条件不成立”的结果(有点类似直接在前台写代码并运行,后台解析后会返回一个结果。原书中虽然没有讲解整个前台输入到后台解析的过程但我猜这个后台解析应该还有一个使用正则表达式提取类似上面2行代码中关键字的过程)

上面这二行代码虽然是作者发明的语言,但根据字面含义也不难理解,第一行是定义一个变量并赋值,第二行是对变量进行一个判断(变量等于4或者等于four)。

废话不多说来看看这个模式定义的这几个类 (类图请自行看原文):

一、interpreterContext 这个类就像一个容器 主要是用来存放和获取需要进行比较的值和比较的结果的,例如上述代码中的4, four,和比较结果 “true”或“false”,保存的形式是数组即类的属性$expressionstore,代码如下:

  1. class InterpreterContext{
  2. private $expressionstore = array(); //存放比较的值和结果
  3. function replace(Expression $exp,$value){    // 设置值
  4. $this->expressionstore[$exp->getKey()] = $value;
  5. }
  6. function lookup(Expression $exp){        //获取值
  7. return $this->expressionstore[$exp->getKey()];
  8. }
  9. }
复制代码

这个类就像一个工具,供其他类来使用(它和其他类不存在继承、组合或聚合的关系)。

二、Expression 这是一个表达式的抽象类,定义了抽象方法interpret() 和方法getKey()

代码如下:

  1. abstract class Expression {
  2. private static $keycount = 0;  //计数用的
  3. private $key;          //存放一个唯一值
  4. //主要实现将前台获取到的数据存放到上述InterpreterContext类中的功能,看到下面的内容就会发现继承他的类调用了InterpreterContext类的replace()方法
  5. abstract function interpret (InterpreterContext $context); 
  6.  //获取一个唯一值
  7. function getKey(){       
  8. if(!isset($this->key)){
  9. self::$keycount++;
  10. $this->key= self::$keycount;
  11. }
  12. return $this->key;
  13. }
  14. }
复制代码

下面将要讲到的类都将继承这个类,并且他和OperatorExpression(操作符表达式抽象类)是一个组合的关系,也就是说OperatorExpression在初始化时可以包含所有继承了Expression的子类(这也是本书一直在强调的要面向接口编程,这个Expression就是个接口,利用这个接口可以实现多态,不知道自己装B说的对不对,哈! 具体可以在看看原书的类图)

三、LiteralExpression 文字表达式类,作用就是将一个字符串保存到InterpreterContext这个小容器里,保存成一个索引数组,例如保存开头那二句自创代码中的 4 或者 four

代码如下:

  1. class LiteralExpression extends Expression{
  2. private $value;
  3. function __construct ($value){      //初始化时传入要保存的值
  4. $this->value= $value;
  5. }
  6. function interpret(InterpreterContext $context){    //调用InterpreterContext类的replace()将$value保存到InterpreterContext这个小容器里
  7. $context->replace($this,$this->value);
  8. }
  9. }
复制代码

四、VariableExpression 变量表达式类,和上面类的作用是一样的只不过数据将被保存成关联数组,关联数组中的健是变量名,值呢就是变量的值,例如开头二句中的变量"input" 和值 "4",

代码如下:

  1. class VariableExpression extends Expression{
  2. private $name;    //变量名
  3. private $val;      //变量值
  4. function __construct ($name,$val=null){
  5. $this->name = $name;
  6. $this->val = $val;
  7. }
  8. function interpret(InterpreterContext $context){
  9. if(!is_null($this->val)){
  10. $context->replace($this,$this->val);
  11. $this->val = null;
  12. }
  13. }
  14. function setValue($value){  //用于设置变量的值
  15. $this->val = $value;
  16. }
  17. function getKey(){    //这个复写了父类的getKey()方法,在小容器InterpreterContext的lookup()方法调用这个类的实例的getKey()方法时 它将返回一个字符串(即变量名)而不是数字索引
  18. return $this->name;
  19. }
  20. }
复制代码

五、OperatorExpression 操作符表达式抽象基类,此类继承且组合了Expression抽象基类,实现的interpret()方法主要保存表达式的计算结果

代码如下:

  1. abstract class OperatorExpression extends Expression{
  2. protected $l_op;  //表达式左边的值
  3. protected $r_op;  //表达式右边的值
  4. function __construct (Expression $l_op,Expression $r_op){    //初始化时可组合继承了Expression类的子类实例
  5. $this->l_op = $l_op;
  6. $this->r_op = $r_op;
  7. }
  8. function interpret(InterpreterContext $context){ //主要用于保存表达试的结果(保存到InterpreterContext 类的实例中)
  9. $this->l_op->interpret($context);        //将Expression子类实例的值或计算结果保存到InterpreterContext 类的实例中
  10. $this->r_op->interpret($context);
  11. $result_l = $context->lookup($this->l_op);    //获取上一步的值或计算结果
  12. $result_r = $context->lookup($this->r_op);
  13. $this->doInterpret($context,$result_l,$result_r);  //具体的比较运算由继承的子类来实现
  14. }
  15. protected abstract function doInterpret(InterpreterContext $context,$result_l,$result_r);
  16. }
复制代码

六、EqualsExpression、BooleanOrExpression、BooleanAndExpression,分别为继承了OperatorExpression 抽象基类的相等表达式、或表达式、与表达式只有一个方法doInterpret()内部调用了InterpreterContext类的replace()方法将表达式的计算结果保存到InterpreterContext类的实例中

代码如下:

  1. //相等表达式
  2. class EqualsExpression extends OperatorExpression {
  3. protected function doInterpret(InterpreterContext $context,$result_l,$result_r){
  4. $context->replace($this,$result_l == $result_r);
  5. }
  6. }
  7. //或表达式
  8. class BooleanOrExpression extends OperatorExpression{
  9. protected function doInterpret(InterpreterContext $context,$result_l,$result_r){
  10. $context->replace($this,$result_l || $result_r);
  11. }
  12. }
  13. //与表达式
  14. class BooleanAndExpression extends OperatorExpression{
  15. protected function doInterpret(InterpreterContext $context,$result_l,$result_r){
  16. $context->replace($this,$result_l && $result_r);
  17. }
  18. }
复制代码

到此为止此模式相关的类就介绍完毕,上述代码都是进过测试的,可直接复制粘贴运行来查看结果,现在我们就来看看客户端代码:

客户端代码一:

  1. $context = new InterpreterContext();
  2. $statement = new BooleanOrExpression (  //可尝试将此操作符表达式换成BooleanAndExpression 运行一下 看看执行结果
  3. //可尝试将LiteralExpression中实例化的参数改成其他值看看运算结果,或者直接将EqualsExpression对象换成BooleanOrExpression 或BooleanAndExpression
  4. new EqualsExpression(new LiteralExpression('four'),new LiteralExpression('four')), 
  5. new EqualsExpression(new LiteralExpression('b'),new LiteralExpression('4'))
  6. );
  7. $statement->interpret($context);
  8. if($context->lookup($statement)){
  9. echo '条件成立';
  10. } else {
  11. echo '条件不成立';
  12. }
复制代码

客户端代码二

  1. $context = new InterpreterContext();
  2. $statement = new BooleanOrExpression(
  3. new BooleanAndExpression(
  4. new EqualsExpression(new LiteralExpression('4'),new LiteralExpression('4')),
  5. new EqualsExpression(new LiteralExpression('4'),new LiteralExpression('4'))
  6. ),
  7. new EqualsExpression(new LiteralExpression('b'),new LiteralExpression('4'))
  8. );
  9. $statement->interpret($context);
  10. if($context->lookup($statement)){
  11. echo '条件成立';
  12. } else {
  13. echo '条件不成立';
  14. }
复制代码

客户端代码三:

这是原文的客户端代码实例和上述客户端代码的区别在于使用了变量表达式VariableExpression

  1. $context = new InterpreterContext();    
  2. $input = new VariableExpression('input');  //这里定义了一个变量input 但并未赋值
  3. $statement = new BooleanOrExpression(
  4. new EqualsExpression($input,new LiteralExpression('four')),  //这里变量表达式和文字表达式的值将进行一个是否相等的比较
  5. new EqualsExpression($input,new LiteralExpression('4'))
  6. );
  7. foreach (array("four","4","52") as $val){
  8. $input->setValue($val);        //对input这个变量赋值
  9. print "变量input的值为:$val:<br/>";
  10. $statement->interpret($context);  //进行比较并将比较结果存入InterpreterContext对象实例
  11. if($context->lookup($statement)){  //获取比较的结果
  12. print "条件成立 <br/>";
  13. } else {
  14. print "条件不成立 <br/>";
  15. }
  16. }
复制代码

上述代码经过测试都可以正常运行,有需要的朋友可以复制下来,运行一下看看结果。

以上这篇老生常谈PHP面向对象之解释器模式就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持程序员之家。



回复

使用道具 举报