PHP设计模式之解释器（Interpreter）模式入门与应用详解

<?php
//解释器模式 用于分析一个实体的关键元素，并且针对每个元素提供自己的解释或相应动作
//解释器模式非常常用，比如PHP的模板引擎 就是非常常见的一种解释器模式
class template {
 
 private $left = '<!--{';
 private $right = '}-->';
 
 public function run($str) {
 return $this->init($str, $this->left, $this->right);
 }
 
 /**
 * 模板驱动-默认的驱动
 * @param string $str 模板文件数据
 * @return string
 */
 private function init($str, $left, $right) {
 $pattern = array('/'.$left.'/', '/'.$right.'/');
 $replacement = array('', '');
 return preg_replace($pattern, $replacement, $str);
 }
}
$str = "这是一个模板类，简单的模板类，标题为：<!--{Hello World}-->";
$template = new template;
echo $template->run($str);

/** 
 * AbstractExpression. All implementations of this interface 
 * are ConcreteExpressions. 
 */ 
interface MathExpression 
{ 
 /** 
  * Calculates the value assumed by the expression. 
  * Note that $values is passed to all expression but it 
  * is used by Variable only. This is required to abstract 
  * away the tree structure. 
  */ 
 public function evaluate(array $values); 
} 
 
/** 
 * A terminal expression which is a literal value. 
 */ 
class Literal implements MathExpression 
{ 
 private $_value; 
 
 public function __construct($value) 
 { 
  $this->_value = $value; 
 } 
 
 public function evaluate(array $values) 
 { 
  return $this->_value; 
 } 
} 
 
/** 
 * A terminal expression which represents a variable. 
 */ 
class Variable implements MathExpression 
{ 
 private $_letter; 
 
 public function __construct($letter) 
 { 
  $this->_letter = $letter; 
 } 
 
 public function evaluate(array $values) 
 { 
  return $values[$this->_letter]; 
 } 
} 
 
/** 
 * Nonterminal expression. 
 */ 
class Sum implements MathExpression 
{ 
 private $_a; 
 private $_b; 
 
 public function __construct(MathExpression $a, MathExpression $b) 
 { 
  $this->_a = $a; 
  $this->_b = $b; 
 } 
 
 public function evaluate(array $values) 
 { 
  return $this->_a->evaluate($values) + $this->_b->evaluate($values); 
 } 
} 
 
/** 
 * Nonterminal expression. 
 */ 
class Product implements MathExpression 
{ 
 private $_a; 
 private $_b; 
 
 public function __construct(MathExpression $a, MathExpression $b) 
 { 
  $this->_a = $a; 
  $this->_b = $b; 
 } 
 
 public function evaluate(array $values) 
 { 
  return $this->_a->evaluate($values) * $this->_b->evaluate($values); 
 } 
} 
 
// 10(a + 3) 
$expression = new Product(new Literal(10), new Sum(new Variable('a'), new Literal(3))); 
echo $expression->evaluate(array('a' => 4)), "n"; 
// adding new rules to the grammar is easy: 
// e.g. Power, Subtraction... 
// thanks to the Composite, manipulation is even simpler: 
// we could add substitute($letter, MathExpression $expr) 
// to the interface... 

<?php
header("Content-type:text/html;Charset=utf-8");
 
//环境角色，定义要解释的全局内容
class Expression{
 public $content;
 function getContent(){
  return $this->content;
 }
}
 
//抽象解释器
abstract class AbstractInterpreter{
 abstract function interpret($content);
}
 
//具体解释器,实现抽象解释器的抽象方法
class ChineseInterpreter extends AbstractInterpreter{
 function interpret($content){
  for($i=1;$i<count($content);$i++){
   switch($content[$i]){
   case '0': echo "没有人<br>";break;
   case "1": echo "一个人<br>";break;
   case "2": echo "二个人<br>";break;
   case "3": echo "三个人<br>";break;
   case "4": echo "四个人<br>";break;
   case "5": echo "五个人<br>";break;
   case "6": echo "六个人<br>";break;
   case "7": echo "七个人<br>";break;
   case "8": echo "八个人<br>";break;
   case "9": echo "九个人<br>";break;
   default:echo "其他";
   }
  }
 }
}
class EnglishInterpreter extends AbstractInterpreter{
 function interpret($content){
  for($i=1;$i<count($content);$i++){
    switch($content[$i]){
    case '0': echo "This is nobody<br>";break;
    case "1": echo "This is one people<br>";break;
    case "2": echo "This is two people<br>";break;
    case "3": echo "This is three people<br>";break;
    case "4": echo "This is four people<br>";break;
    case "5": echo "This is five people<br>";break;
    case "6": echo "This is six people<br>";break;
    case "7": echo "This is seven people<br>";break;
    case "8": echo "This is eight people<br>";break;
    case "9": echo "This is nine people<br>";break;
    default:echo "others";
   }
  }
 }
}
 
//封装好的对具体解释器的调用类,非解释器模式必须的角色
class Interpreter{
  private $interpreter;
  private $content;
  function __construct($expression){
  $this->content = $expression->getContent();
  if($this->content[0] == "Chinese"){
    $this->interpreter = new ChineseInterpreter();
   }else{
    $this->interpreter = new EnglishInterpreter();
   }
  }
  function execute(){
   $this->interpreter->interpret($this->content);
  }
}
 
//测试
$expression = new Expression();
$expression->content = array("Chinese",3,2,4,4,5);
$interpreter = new Interpreter($expression);
$interpreter->execute();
 
$expression = new Expression();
$expression->content = array("English",1,2,3,0,0);
$interpreter = new Interpreter($expression);
$interpreter->execute();
?>