Using PHP Reflection Functions: Basics and Code Examples

In PHP programming, reflection is a powerful technique that allows runtime access to information about classes, interfaces, methods, properties, and more. Using reflection, developers can dynamically inspect and modify code structure, enabling advanced programming tricks and functionality.

What are reflection functions

Reflection functions are a built‑in class in PHP that provides a set of methods to inspect and manipulate function information. With them you can obtain a function’s parameters, return type, access level, doc comments, and invoke the function dynamically.

Basic usage of reflection functions

The first step is to create a reflection object by passing a function name or a function object. For example, the code below demonstrates how to create a reflection object:

<code>$reflection = new ReflectionFunction('myFunction');</code>

After creating the reflection object, you can use its methods to retrieve and manipulate function information. For instance, getName() returns the function name, getParameters() returns the parameter list, and invoke() calls the function.

Getting function parameter information

ReflectionFunction provides the getParameters() method, which returns an array of parameter objects. By iterating this array you can obtain each parameter’s name, default value, and type hint.

The following code demonstrates how to retrieve parameter information:

<code>$parameters = $reflection->getParameters();

foreach ($parameters as $parameter) {
    $name = $parameter->getName();
    $defaultValue = $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : 'no default';
    $typeHint = $parameter->hasType() ? $parameter->getType()->getName() : 'no type hint';

    echo "Parameter name: $name\n";
    echo "Default value: $defaultValue\n";
    echo "Type hint: $typeHint\n";
}</code>

This code outputs each parameter’s name, default value, and type hint, which is useful for dynamic function calls and generic code.

Calling a function

Using reflection functions, you can dynamically invoke a function. ReflectionFunction offers the invoke() method to call the function and pass arguments.

The following example shows how to invoke a function with reflection:

<code>$reflection = new ReflectionFunction('myFunction');
$reflection->invoke($arg1, $arg2);</code>

With this code you can invoke myFunction and pass $arg1 and $arg2 as arguments.

In summary, the article covered the basic usage of PHP reflection functions, including retrieving function metadata, parameters, return values, access levels, and doc comments, and demonstrated how to use them for advanced programming techniques that improve code maintainability and extensibility.

PHP learning recommendations

Vue3+Laravel8+Uniapp beginner to practical development tutorial

Vue3+TP6+API social e‑commerce system development teaching

Swoole from beginner to mastery recommended course

Workerman+TP6 instant messaging chat system limited‑time sale