How to do reflection processing in PHP7.0?

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.

Reflection class

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

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.

We can also use the reflection method to obtain the parameters, return values, modifiers and other information of the method:

// 获取方法的参数
$params = $ref->getParameters();
foreach ($params as $param) {
    echo $param->getName();
}

// 获取方法的返回值
$return = $ref->getReturnType();
echo $return->getName();

// 获取方法的修饰符
$modifiers = $ref->getModifiers();
echo $modifiers;

In addition, we can also use the reflection method to call the method:

$instance = new Foo();
$args = ['arg1', 'arg2'];
$result = $ref->invokeArgs($instance, $args);

Reflection properties

Reflection properties are another important part of the reflection class. We can use the

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

In the above example, we use

new ReflectionProperty('Foo', 'prop1') to get the # in the Foo class ##prop1The 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

Reflection is a powerful function that can help us process meta-information of classes and objects more conveniently. In PHP7.0, we can use the

ReflectionClass

, 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!