Reflection and use of PHP variables and type expansion

1. Overview and installation

PHP 5 has a complete reflection API, adding the ability to reverse engineer classes, interfaces, functions, methods and extensions. Additionally, the Reflection API provides methods to extract documentation comments from functions, classes, and methods.

Please note that some internal APIs are missing code required for reflection extensions to work. For example, a built-in PHP class may be missing data for a reflected property. These rare cases are considered bugs, however, and as such, they should be discovered and fixed.

No installation is required to use these functions, they are part of the PHP core.

2. Usage examples

There are many examples in the reflection documentation, usually in the __construct documentation of each class.

Example A reflection example in Shell (a terminal)

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

The output of the above routine Similar to:

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. Related extensions

If you want to create specialized versions of built-in classes (for example, when creating and exporting highlighted HTML, replace methods with easily accessible member variables or use utility methods) , you can continue and extend them.

Example #1 Extending a built-in class

<?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"
}

If you override the constructor, remember to call the parent class's constructor before writing any inserted code. Failure to do so will result in the following results: Fatal error: Internal error: Failed to retrieve the reflection object

4. Reflection class

Reflection — Reflection class

ReflectionClass — ReflectionClass class

ReflectionZendExtension — ReflectionZendExtension class

ReflectionExtension — ReflectionExtension class

ReflectionFunction — ReflectionFunction class

ReflectionFunctionAbstract — ReflectionFunctionAbstract class

ReflectionMethod — ReflectionMethod class

ReflectionObject — ReflectionObject class

ReflectionParameter — ionParameter class

ReflectionProperty — ReflectionProperty class

Reflector — Reflector interface

ReflectionException — ReflectionException class