Erweiterte Verwendung des PHP-Typoperators „instanceof“-Operator

Der

-Operator „instanceof“ eignet sich gut für die Typprüfung von Eingabeobjekten, die direkt in die -Generatorklasse der Seite eingefügt werden. Gehen wir nun noch einen Schritt weiter und fügen dem Konstruktor und der Methode „getHTML()“ der (X)HTML-Widget-Klasse eine Prüfroutine hinzu, damit diese andere Widgets als Eingabeparameter akzeptieren können. Bitte schauen Sie sich die verbesserten Klassen unten an:

class Div extends HTMLElement{
　private $output='＜div ';
　private $data;
　public function construct($attributes=array()，$data){
　　if(!$data instanceof HTMLElement&&!is_string($data)){
　　　throw new Exception('Invalid parameter type');
　　}
　　parent::construct($attributes);
　　$this-＞data=$data;
　}
　//'getHTML()'方法的具体实现
　public function getHTML(){
　　foreach($this-＞attributes as $attribute=＞$value){
　　　$this-＞output.=$attribute.'="'.$value.'" ';
　　}
　　$this-＞output=substr_replace($this-＞output，'＞'，-1);
　　$this-＞output.=($this-＞data instanceof HTMLElement)?
　　$this-＞data-＞getHTML():$this-＞data;
　　$this-＞output.='＜/div＞';
　　return $this-＞output;
　}
}
class Header1 extends HTMLElement{
　private $output='＜h1 ';
　private $data;
　public function construct($attributes=array()，$data){
　　if(!$data instanceof HTMLElement&&!is_string($data)){
　　　throw new Exception('Invalid parameter type');
　　}
　　parent::construct($attributes);
　　$this-＞data=$data;
　}
　//'getHTML()'方法的具体实现
　public function getHTML(){
　　foreach($this-＞attributes as $attribute=＞$value){
　　　$this-＞output.=$attribute.'="'.$value.'" ';
　　}
　　$this-＞output=substr_replace($this-＞output，'＞'，-1);
　　$this-＞output.=($this-＞data instanceof HTMLElement)?
　　$this-＞data-＞getHTML():$this-＞data;
　　$this-＞output.='＜/h1＞';
　　return $this-＞output;
　}
}
class Paragraph extends HTMLElement{
　private $output='＜p ';
　private $data;
　public function construct($attributes=array()，$data){
　　if(!$data instanceof HTMLElement&&!is_string($data)){
　　　throw new Exception('Invalid parameter type');
　　}
　　parent::construct($attributes);
　　$this-＞data=$data;
　}
　//'getHTML()'方法的具体实现
　public function getHTML(){
　　foreach($this-＞attributes as $attribute=＞$value){
　　　$this-＞output.=$attribute.'="'.$value.'" ';
　　}
　　$this-＞output=substr_replace($this-＞output，'＞'，-1);
　　$this-＞output.=($this-＞data instanceof HTMLElement)?
　　$this-＞data-＞getHTML():$this-＞data;
　　$this-＞output.='＜/p＞';
　　return $this-＞output;
　}
}
class UnorderedList extends HTMLElement{
　private $output='＜ul ';
　private $items=array();
　public function construct($attributes=array()，$items=array()){
　　parent::construct($attributes);
　　if(!is_array($items)){
　　　throw new Exception('Invalid parameter for list items');
　}
　$this-＞items=$items;
}
//'getHTML()'方法的具体实现
public function getHTML(){
　foreach($this-＞attributes as $attribute=＞$value){
　　$this-＞output.=$attribute.'="'.$value.'" ';
　}
　$this-＞output=substr_replace($this-＞output，'＞'，-1);
　foreach($this-＞items as $item){
　　$this-＞output.=($item instanceof
　　HTMLElement)?'＜li＞'.$item-＞getHTML().'＜/li＞':'＜li＞'.$item.'＜/li＞';
　}
　$this-＞output.='＜/ul＞';
　return $this-＞output;
}
}

Wie in den obigen Klassen gezeigt, um die Implementierung verschachtelter (X)HTML-Elemente beim Generieren der entsprechenden Webseite zu ermöglichen, das jeweilige Construct seinen Konstruktor und die „getHTML()“-Methode. Bitte beachten Sie, dass der folgende bedingte Block im Konstruktor jeder Klasse enthalten ist:

if(!$data instanceof HTMLElement&&!is_string($data)){
throw new Exception('Invalid parameter type');
}

An diesem Punkt wird tatsächlich sichergestellt, dass nur Zeichenfolgendaten und Objekte vom Typ „HTMLElement“ vorhanden sind als Eingabeparameter für jede Klasse zulässig. Andernfalls wird von der jeweiligen Methode eine Ausnahme ausgelöst, die dazu führen kann, dass die Anwendung die Ausführung stoppt. Dies ist also der Prozess der Überprüfung der Eingabedaten. Schauen wir uns nun die neue Signatur der Methode „getHTML()“ an, die auch den Operator „instanceof“ verwendet:

$this-＞output.=($this-＞data instanceof HTMLElement)?$this-＞data-
＞getHTML():$this-＞data;

Wie Sie sehen können, handelt es sich in diesem Fall um diesen Operator Sehr nützlich, um die polymorphe -Funktion der (X)HTML-Widget-Klasse zu nutzen. Wenn das Attribut $data auch ein Widget ist, wird dessen Methode „getHTML()“ korrekt aufgerufen, was dazu führt, dass das verschachtelte Webelement angezeigt wird. Wenn es sich hingegen nur um eine Zeichenfolge handelt, wird sie direkt zu allen Ausgaben der aktuellen Klasse hinzugefügt.

Um sicherzustellen, dass bestimmte Objekte zu einem bestimmten Typ gehören, haben Sie an dieser Stelle möglicherweise die Verwendung des „instanceof“-Operators in PHP 5 verstanden. Wie Sie in diesem Artikel sehen können, ist das Erzwingen von Objekttypen in PHP 5 eigentlich eine ziemlich einfache Aufgabe. Um Ihr Verständnis zu vertiefen, sollten Sie zunächst ein Beispiel für die Verwendung dieser Methode zum Filtern von Objekten in Ihrer PHP-Anwendung entwickeln.

<?php
//定义一个抽像类HTMLElement
abstract class HTMLElement
{
    protected  $attributes;
    protected  function construct($_attributes)
    {
        if(!is_array($_attributes))
        {
           throw new Exception("attributes not is array"); 
        }
        $this->attributes = $_attributes;
    }
    //定义一个虚函数
    abstract function getHTML();
}
 
 
//定义具体的类"Div"扩展HTMLElement
class Div extends HTMLElement
{
    private $_output = "<div";
    private $_data;
    public function construct($_attributes=array(), $data)
    {
        //扩展"instanceof"操作符的使用：嵌套(X)HTML widget
        if(!$data instanceof HTMLElement && !is_string($data)) {
            throw new Exception("data type error");
        }      
        parent::construct($_attributes);
        $this->_data = $data;
    }
    public function getHTML()
    {
        foreach ($this->attributes as $key=>$val)
        {
             $this->_output.=  " ".$key."=&#39;".$val."&#39; ";
        }
        $this->_output =substr_replace($this->_output,">",-1);
        $this->_output .= $this->_data instanceof HTMLElement ? $this->_data->getHTML()."</div>" : $this->_data."</div>";
        return $this->_output;
    }
}
 
//定义具体的类"H1"扩展
class h1 extends HTMLElement
{
    private $_output="<h1";
    private $_data;
    public function construct($_attributes=array(), $data)
    {
        parent::construct($_attributes);
        $this->_data = $data;
    }
     
    public function getHTML()
    {
        foreach($this->attributes as $key=>$val)
        {
            $this->_output.=  " ".$key."=&#39;".$val."&#39; ";
        }
        $this->_output = substr_replace($this->_output, ">", -1);
        $this->_output .= $this->_data."<h1>";
        return $this->_output;
    }
}
 
//定义具体的类"ul"
class ul extends HTMLElement
{
    public $output = "<ul";
    private $ulitem=array();
    public function construct($_attributes=array(), $_ulitem=array())
    {  
        parent::construct($_attributes);
        $this->ulitem = $_ulitem;
    }
     
    public function getHTML()
    {
        foreach($this->attributes as $key=>$val)
        {
            $this->_output.=  " ".$key."=&#39;".$val."&#39; ";
        }
        $this->output = substr_replace($this->output, ">",-1);
        foreach($this->ulitem as $ukey=>$uval){
            $this->output .="<li>".$uval."</li>";
        }
        $this->output.="</ul>";
        return $this->output;       
    }
}
 
 
//生成页面的类
class PageGenerator
{
    private $_output;
    private $_title;
    public function construct($title=" Default page")
    {
        $this->_title = $title;
    }
     
    public function doHead()
    {
        $this->_output.="<html><head><title>".$this->_title."</title></head><body>";
    }
     
//  public function addHTMLElement($HTMLElement)
//  {
//      $this->_output.= $HTMLElement->getHTML();
//  }
    //对addHTMLElement进行改进
    //可以保证传入的不是HTMLElement类对像直接报错
    public function addHTMLElement($HTMLElement)
    {
         if(!$HTMLElement instanceof HTMLElement)
         {
            throw new Exception(&#39;Invalid (X)HTML element&#39;);
         }
         $this->_output.= $HTMLElement->getHTML();
    }
 
    public function doFooter()
    {
        $this->_output.="</body></html>";
    }
     
    public function fetchHTML()
    {
        return $this->_output;
    }
}
 
try{   
    $attribute = array("class"=>"className", "style"=>"color:#000");
    $h1 = new H1($attribute, "h1内容");
    $attribute = array("class"=>"className", "style"=>"color:#000");
    $ul = new ul($attribute, array("li第一行内容","li第二行内容","li第三行内容"));
     
     
    $attribute = array("class"=>"className", "style"=>"color:red");
    $div = new Div($attribute, $ul);
    $page = new PageGenerator();
//  $str="我是个字符串";
//  $page->addHTMLElement($str);
    $page->addHTMLElement($h1);
    $page->addHTMLElement($div);
    //  $page->addHTMLElement($ul);
    echo $page->fetchHTML();    
}
catch(Exception $e){
    echo $e->getMessage();
    die();
}
?>

Das obige ist der detaillierte Inhalt vonErweiterte Verwendung des PHP-Typoperators „instanceof“-Operator. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!