There are three methods to obtain the current executing function name in PHP: 1.\_\_FUNCTION\_\_The name of the magic constant when returning the function definition is suitable for ordinary functions; 2.\_\_METHOD\_\_ is used to return "class name:: method name" in class methods, which can extract the method name through string processing; 3.debug\_backtrace() can dynamically obtain the call stack information to obtain the current executing function name but the performance is low, and it is recommended to be used in debug scenarios. \_\_FUNCTION\_\_ and \_\_METHOD\_ are simpler and more efficient in their respective contexts and debug\_backtrace() provides a more flexible but heavier solution.

In PHP, if you want to know which function is currently executing, or want to get the function name dynamically, there are several ways to implement it. Although PHP does not provide a direct "built-in variable" to get the current function name, this can be done easily through some language features and debugging functions.

1. Use __FUNCTION__ Magic Constant

This is the most commonly used and easiest way. PHP provides several magic constants, where __FUNCTION__ can return the name of the current function.

 function demoFunction() {
    echo __FUNCTION__; // Output: demoFunction
}

demoFunction();

? Note : This constant returns the name when the function is defined, not the name called at runtime. That is, if you assign a function to a variable and then call it, it will still return the original function name.

 function demo() {
    echo __FUNCTION__;
}

$func = 'demo';
$func(); // Output: demo

2. Use __METHOD__ in class methods

If you need to get the current function name in the class method, you can use __METHOD__ , which will return "Class name::Method name".

 class MyClass {
    public function myMethod() {
        echo __METHOD__; // Output: MyClass::myMethod
    }
}

$obj = new MyClass();
$obj->myMethod();

If you want to get only the method name part, you can use strings to process:

 list($class, $method) = exploit('::', __METHOD__);
echo $method; // Output: myMethod

3. Use debug_backtrace() to get more flexible information

If you need more complex control, such as determining which function is currently executing in a nested call, or if you want to know who called it in a general logging function, you can use debug_backtrace() .

 function getCurrentFunctionName() {
    $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2);
    return $backtrace[1]['function'] ?? null;
}

function testFunc() {
    echo getCurrentFunctionName(); // Output: testFunc
}

testFunc();

? illustrate :

• debug_backtrace() returns the call stack information.
• Setting the second parameter to 2 means that we only need the last two layers of calls.
• $backtrace[1] is the function that calls getCurrentFunctionName .

?? This method has a slightly lower performance and is recommended to be used only for debugging or logging scenarios.

Let's summarize

• If you just want to print your name inside the function, it is most convenient to use __FUNCTION__ ;
• It is recommended to use __METHOD__ or combine explode() extract the method name in class methods;
• When you need to dynamically obtain caller information, using debug_backtrace() is more flexible but heavier.

Basically, these methods are not complicated but are easy to ignore. The behavioral differences in different contexts, such as __FUNCTION__ will not change with the method of calling.

The above is the detailed content of How to get the name of the current function in PHP?. For more information, please follow other related articles on the PHP Chinese website!