PHP7.0 introduces some new reflection features, making it easier for us to process meta-information of PHP classes and objects. Reflection is the ability to dynamically obtain and operate classes, interfaces, functions, methods and properties. It can be used to automatically generate documents, debugging tools, plug-in frameworks, etc.
In this article, we will introduce how to perform reflection processing in PHP7.0, including the acquisition and operation of reflection classes, methods and properties.
The reflection class is the basis of reflection. We can use the ReflectionClass
class to obtain the meta-information of the class. Here is an example:
class Foo { public $prop1; private $prop2; protected $prop3; function __construct($arg) { // ... } public static function bar() { // ... } private function baz($arg) { // ... } } $ref = new ReflectionClass('Foo'); echo $ref->getName(); // 输出 Foo
In the above example, we use new ReflectionClass('Foo')
to get the reflection object of class Foo
, and then use getName()
Method to get the class name.
Through reflection classes, we can obtain other meta-information of the class, such as attributes, methods, constants, etc. Here are some examples:
// 获取类的属性 $props = $ref->getProperties(); foreach ($props as $prop) { echo $prop->getName(); } // 获取类的方法 $methods = $ref->getMethods(); foreach ($methods as $method) { echo $method->getName(); } // 获取类的常量 $consts = $ref->getConstants(); foreach ($consts as $name => $value) { echo $name . ' => ' . $value; }
In addition to this, we can also use reflection classes to create instances of classes as follows:
$instance = $ref->newInstanceArgs([$arg1, $arg2]);
Reflection method It is part of the reflection class. We can use the ReflectionMethod
class to obtain the metainformation of the method. Here is an example:
class Foo { public static function bar() { // ... } private function baz($arg) { // ... } } $ref = new ReflectionMethod('Foo', 'bar'); echo $ref->getName(); // 输出 bar
In the above example, we use new ReflectionMethod('Foo', 'bar')
to get the # in the Foo
class The reflection object of the ##bar() method, and then use the
getName() method to get the method name.
// 获取方法的参数 $params = $ref->getParameters(); foreach ($params as $param) { echo $param->getName(); } // 获取方法的返回值 $return = $ref->getReturnType(); echo $return->getName(); // 获取方法的修饰符 $modifiers = $ref->getModifiers(); echo $modifiers;
$instance = new Foo(); $args = ['arg1', 'arg2']; $result = $ref->invokeArgs($instance, $args);
ReflectionProperty class to obtain the meta-information of the properties. Here is an example:
class Foo { public $prop1; private $prop2; protected static $prop3; } $ref = new ReflectionProperty('Foo', 'prop1'); echo $ref->getName(); // 输出 prop1
new ReflectionProperty('Foo', 'prop1') to get the # in the
Foo class ##prop1
The reflection object of the property, and then use the getName()
method to get the property name. We can also use reflection properties to obtain property modifiers, default values and other information:
// 获取属性的修饰符 $modifiers = $ref->getModifiers(); echo $modifiers; // 获取属性的默认值 $default = $ref->getDefaultValue(); echo $default;
In addition, we can also use reflection properties to set and get property values:
$instance = new Foo(); $ref->setValue($instance, 'new value'); $value = $ref->getValue($instance);
Conclusion
, ReflectionMethod
and ReflectionProperty
classes to obtain and manipulate class, method and property information. These reflection features make PHP more flexible and extensible.
The above is the detailed content of How to do reflection processing in PHP7.0?. For more information, please follow other related articles on the PHP Chinese website!