?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;$icount($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;$icount($content);$i++){
    switch($content[$i]){
    case '0': echo "This is nobodybr>";break;
    case "1": echo "This is one peoplebr>";break;
    case "2": echo "This is two peoplebr>";break;
    case "3": echo "This is three peoplebr>";break;
    case "4": echo "This is four peoplebr>";break;
    case "5": echo "This is five peoplebr>";break;
    case "6": echo "This is six peoplebr>";break;
    case "7": echo "This is seven peoplebr>";break;
    case "8": echo "This is eight peoplebr>";break;
    case "9": echo "This is nine peoplebr>";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();
?>