There are the following methods for calling functions dynamically in PHP: 1. Use variable functions, assign the function name to the variable and then call it through $func(); 2. Dynamically call the instance method through object methods and -> operators, or call static methods through class names and :: operators; 3. Use call_user_func() and call_user_func_array() to flexibly pass parameters and execute them. When using it, you should pay attention to verifying whether the function exists, avoid directly using user input as function name to ensure safety, and language constructs such as echo cannot be used for variable functions. These methods are suitable for building plug-in systems, callback mechanisms, or writing flexible code logic.

In PHP, if you have a function name stored in a variable and want to call that function dynamically, it's totally doable. This technique is especially useful when working with callbacks, plugins, or dynamic dispatching logic.

Let's dive into the most common ways to achieve this.

Using Variable Functions

PHP supports variable functions , which means you can assign a function name as a string to a variable and then use that variable followed by parentsthes to call the function.

 function saysHello() {
    echo "Hello!";
}

$func = 'sayHello';
$func(); // Outputs: Hello!

This works for both user-defined functions and built-in PHP functions (as long as they're not language constructs like echo , isset , etc.).

?? Make sure the function exists before calling it dynamically. You can use function_exists() to check:

 if (function_exists($func)) {
    $func();
} else {
    echo "Function not found.";
}

Calling Methods from Variables

If you're dealing with object-oriented code and want to call a method dynamically, you can store the method name in a variable and use the -> operator:

 class Greeter {
    public function greet() {
        echo "Hi there!";
    }
}

$obj = new Greeter();
$method = 'greet';
$obj->$method(); // Outputs: Hi there!

For static methods, you can use the scope resolution operator ( :: ) with a variable class name:

 class StaticGreeter {
    public static function greet() {
        echo "Static greeting!";
    }
}

$class = 'StaticGreeter';
$class::greet(); // Outputs: Static greeting!

Again, consider checking if the method exists using method_exists() to avoid runtime errors:

 if (method_exists($obj, $method)) {
    $obj->$method();
}

Using call_user_func() and call_user_func_array()

Sometimes you might want more flexibility, especially when passing arguments. That's where call_user_func() and call_user_func_array() come in handy.

call_user_func() takes a callable and optional parameters:

 function add($a, $b) {
    return $a $b;
}

$func = 'add';
$result = call_user_func($func, 3, 5);
echo $result; // Outputs: 8

If you have an array of arguments, use call_user_func_array() :

 $args = [3, 5];
$result = call_user_func_array($func, $args);
echo $result; // Outputs: 8

These functions also work with methods:

 // For object methods
call_user_func([$obj, 'methodName'], $arg1, $arg2);

// For static methods
call_user_func(['ClassName', 'methodName'], $arg1, $arg2);

They're especially useful when you don't know how many arguments you'll need to pass ahead of time.

A Few Things to Watch Out For

• Avoid calling functions based on user input without sanitization — it's a security risk.
• Variable functions won't work with language constructs like echo , print , unset() , etc.
• Always validate that the function/method exists before calling it.
• If performance matters, direct calls are faster than using call_user_func .

Basically that's it. Whether you're building a plugin system, implementing callbacks, or just writing flexible code, knowing how to dynamically call functions in PHP gives you a powerful tool.

The above is the detailed content of How to call a PHP function from a variable?. For more information, please follow other related articles on the PHP Chinese website!