Obtenir le nom de la fonction appelante en PHP?

Existe-t-il une fonction PHP pour connaître le nom de la fonction appelante dans une fonction donnée?

Voir debug_backtrace - cela peut tracer votre pile d'appels jusqu'en haut.

Voici comment attirer votre interlocuteur:

$trace = debug_backtrace();
$caller = $trace[1];

echo "Called by {$caller['function']}";
if (isset($caller['class']))
    echo " in {$caller['class']}";

Xdebug fournit quelques fonctions intéressantes.

<?php
  Class MyClass
  {
    function __construct(){
        $this->callee();
    }
    function callee() {
        echo sprintf("callee() called @ %s: %s from %s::%s",
            xdebug_call_file(),
            xdebug_call_line(),
            xdebug_call_class(),
            xdebug_call_function()
        );
    }
  }
  $rollDebug = new MyClass();
?>

retournera trace

callee() called @ /var/www/xd.php: 16 from MyClass::__construct

Pour installer Xdebug sur ubuntu, le meilleur moyen est

sudo aptitude install php5-xdebug

Vous devrez peut-être d'abord installer php5-dev

sudo aptitude install php5-dev

Plus d'informations

C'est très tard mais je voudrais partager la fonction qui donnera le nom de la fonction à partir de laquelle la fonction courante est appelée.

public function getCallingFunctionName($completeTrace=false)
    {
        $trace=debug_backtrace();
        if($completeTrace)
        {
            $str = '';
            foreach($trace as $caller)
            {
                $str .= " -- Called by {$caller['function']}";
                if (isset($caller['class']))
                    $str .= " From Class {$caller['class']}";
            }
        }
        else
        {
            $caller=$trace[2];
            $str = "Called by {$caller['function']}";
            if (isset($caller['class']))
                $str .= " From Class {$caller['class']}";
        }
        return $str;
    }

J'espère que cela sera utile.

debug_backtrace() fournit des détails sur les paramètres, les appels de fonction / méthode dans la pile d'appels actuelle.

echo debug_backtrace()[1]['function'];

Fonctionne depuis PHP 5.4 .

Ou optimisé (par exemple pour les cas d'utilisation sans débogage):

echo debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]['function'];

Le premier argument empêche de remplir les arguments de fonction inutilisés, le second limite la trace à deux niveaux (nous avons besoin du second).

J'ai fait ceci et je l'ai utilisé moi-même

/**
 * Gets the caller of the function where this function is called from
 * @param string what to return? (Leave empty to get all, or specify: "class", "function", "line", "class", etc.) - options see: http://php.net/manual/en/function.debug-backtrace.php
 */
function getCaller($what = NULL)
{
    $trace = debug_backtrace();
    $previousCall = $trace[2]; // 0 is this call, 1 is call in previous function, 2 is caller of that function

    if(isset($what))
    {
        return $previousCall[$what];
    }
    else
    {
        return $previousCall;
    }   
}

Je voulais juste dire que la méthode de flori ne fonctionnera pas en tant que fonction car elle retournera toujours le nom de la fonction appelée au lieu de l'appelant, mais je n'ai pas la réputation de commenter. J'ai créé une fonction très simple basée sur la réponse de flori qui fonctionne bien pour mon cas:

class basicFunctions{

    public function getCallerFunction(){
        return debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS, 3)[2]['function'];
    }

}

EXEMPLE:

function a($authorisedFunctionsList = array("b")){
    $ref = new basicFunctions;
    $caller = $ref->getCallerFunction();

    if(in_array($caller,$authorisedFunctionsList)):
        echo "Welcome!";
        return true;
    else:
        echo "Unauthorised caller!";
        return false; 
    endif;
}

function b(){
    $executionContinues = $this->a();
    $executionContinues or exit;

    //Do something else..
}

Vous pouvez extraire ces informations du tableau retourné par debug_backtrace

Celui-ci a fonctionné le mieux pour moi: var_dump(debug_backtrace());

En fait, je pense que debug_print_backtrace () fait ce dont vous avez besoin. http://php.net/manual/en/function.debug-print-backtrace.php

Cela devrait fonctionner:

$caller = next(debug_backtrace())['function'];

Cela le fera bien:

// Outputs an easy to read call trace
// Credit: https://www.php.net/manual/en/function.debug-backtrace.php#112238
// Gist: https://gist.github.com/UVLabs/692e542d3b53e079d36bc53b4ea20a4b

Class MyClass{

public function generateCallTrace()
{
    $e = new Exception();
    $trace = explode("\n", $e->getTraceAsString());
    // reverse array to make steps line up chronologically
    $trace = array_reverse($trace);
    array_shift($trace); // remove {main}
    array_pop($trace); // remove call to this method
    $length = count($trace);
    $result = array();
   
    for ($i = 0; $i < $length; $i++)
    {
        $result[] = ($i + 1)  . ')' . substr($trace[$i], strpos($trace[$i], ' ')); // replace '#someNum' with '$i)', set the right ordering
    }
   
    return "\t" . implode("\n\t", $result);
}

}

// call function where needed to output call trace

/**
Example output:
1) /var/www/test/test.php(15): SomeClass->__construct()
2) /var/www/test/SomeClass.class.php(36): SomeClass->callSomething()
**/```