Reflexion und Verwendung von PHP-Variablen und Typerweiterung

1. Übersicht und Installation

PHP 5 verfügt über eine vollständige Reflection-API, die die Möglichkeit zum Reverse Engineering von Klassen, Schnittstellen, Funktionen, Methoden und Erweiterungen bietet. Darüber hinaus stellt die Reflection-API Methoden zum Extrahieren von Dokumentationskommentaren aus Funktionen, Klassen und Methoden bereit.

Bitte beachten Sie, dass einigen internen APIs Code fehlt, der für die Funktion von Reflection-Erweiterungen erforderlich ist. Beispielsweise könnten einer integrierten PHP-Klasse Daten für eine reflektierte Eigenschaft fehlen. Diese seltenen Fälle gelten jedoch als Fehler und sollten daher entdeckt und behoben werden.

Für die Nutzung dieser Funktionen ist keine Installation erforderlich, sie sind Teil des PHP-Kerns.

2. Anwendungsbeispiele

Es gibt viele Beispiele in der Reflexionsdokumentation, normalerweise in der __construct-Dokumentation jeder Klasse.

Beispiel Ein Reflexionsbeispiel in Shell (einem Terminal)

$ php --rf strlen
$ php --rc finfo
$ php --re json
$ php --ri dom

Die Ausgabe der obigen Routine ist ähnlich wie:

Function [ <internal:Core> function strlen ] {
  - Parameters [1] {
    Parameter #0 [ <required> $str ]
  }
}
Class [ <internal:fileinfo> class finfo ] {
  - Constants [0] {
  }
  - Static properties [0] {
  }
  - Static methods [0] {
  }
  - Properties [0] {
  }
  - Methods [4] {
    Method [ <internal:fileinfo, ctor> public method finfo ] {
      - Parameters [2] {
        Parameter #0 [ <optional> $options ]
        Parameter #1 [ <optional> $arg ]
      }
    }
    Method [ <internal:fileinfo> public method set_flags ] {
      - Parameters [1] {
        Parameter #0 [ <required> $options ]
      }
    }
    Method [ <internal:fileinfo> public method file ] {
      - Parameters [3] {
        Parameter #0 [ <required> $filename ]
        Parameter #1 [ <optional> $options ]
        Parameter #2 [ <optional> $context ]
      }
    }
    Method [ <internal:fileinfo> public method buffer ] {
      - Parameters [3] {
        Parameter #0 [ <required> $string ]
        Parameter #1 [ <optional> $options ]
        Parameter #2 [ <optional> $context ]
      }
    }
  }
}
Extension [ <persistent> extension #23 json version 1.2.1 ] {
  - Constants [10] {
    Constant [ integer JSON_HEX_TAG ] { 1 }
    Constant [ integer JSON_HEX_AMP ] { 2 }
    Constant [ integer JSON_HEX_APOS ] { 4 }
    Constant [ integer JSON_HEX_QUOT ] { 8 }
    Constant [ integer JSON_FORCE_OBJECT ] { 16 }
    Constant [ integer JSON_ERROR_NONE ] { 0 }
    Constant [ integer JSON_ERROR_DEPTH ] { 1 }
    Constant [ integer JSON_ERROR_STATE_MISMATCH ] { 2 }
    Constant [ integer JSON_ERROR_CTRL_CHAR ] { 3 }
    Constant [ integer JSON_ERROR_SYNTAX ] { 4 }
  }
  - Functions {
    Function [ <internal:json> function json_encode ] {
      - Parameters [2] {
        Parameter #0 [ <required> $value ]
        Parameter #1 [ <optional> $options ]
      }
    }
    Function [ <internal:json> function json_decode ] {
      - Parameters [3] {
        Parameter #0 [ <required> $json ]
        Parameter #1 [ <optional> $assoc ]
        Parameter #2 [ <optional> $depth ]
      }
    }
    Function [ <internal:json> function json_last_error ] {
      - Parameters [0] {
      }
    }
  }
}
dom
DOM/XML => enabled
DOM/XML API Version => 20031129
libxml Version => 2.7.3
HTML Support => enabled
XPath Support => enabled
XPointer Support => enabled
Schema Support => enabled
RelaxNG Support => enabled

3 Verwandte Erweiterungen

Wenn Sie integrierte In klassenspezialisierten Versionen (z. B. Ersetzen von Methoden durch leicht zugängliche Mitgliedsvariablen oder Verwenden von Hilfsmethoden beim Erstellen und Exportieren von hervorgehobenem HTML) können Sie diese fortsetzen und erweitern.

Beispiel #1 Erweitern einer integrierten Klasse

<?php
/**
* My Reflection_Method class
*/
class My_Reflection_Method extends ReflectionMethod
{
public $visibility = array();
public function __construct($o, $m)
{
parent::__construct($o, $m);
$this->visibility = Reflection::getModifierNames($this->getModifiers());
}
}
/**
* Demo class #1
*
*/
class T {
protected function x() {}
}
/**
* Demo class #2
*
*/
class U extends T {
function x() {}
}
// 输出信息
var_dump(new My_Reflection_Method(&#39;U&#39;, &#39;x&#39;));
?>
以上例程的输出类似于：
object(My_Reflection_Method)#1 (3) {
 ["visibility"]=>
 array(1) {
   [0]=>
   string(6) "public"
 }
 ["name"]=>
 string(1) "x"
 ["class"]=>
 string(1) "U"
}

Wenn Sie den Konstruktor überschreiben, denken Sie daran, den Konstruktor der übergeordneten Klasse aufzurufen, bevor Sie eingefügten Code schreiben. Andernfalls kommt es zu den folgenden Ergebnissen: Schwerwiegender Fehler: Interner Fehler: Das Reflexionsobjekt konnte nicht abgerufen werden

4. Reflexionsklasse

Reflexionsklasse

ReflectionClass – ReflectionClass-Klasse

ReflectionZendExtension – ReflectionZendExtension-Klasse

ReflectionExtension – ReflectionExtension-Klasse

ReflectionFunction – ReflectionFunction-Klasse

ReflectionFunctionAbstract – ionFunctionAbstract Klasse

ReflectionMethod – ReflectionMethod-Klasse

ReflectionObject – ReflectionObject-Klasse

ReflectionParameter – ReflectionParameter-Klasse

ReflectionProperty – ReflectionProperty-Klasse

Reflector – Reflector-Schnittstelle

ReflectionException – ReflectionException-Klasse