Obter o nome da função de chamada em PHP?

Existe uma função PHP para descobrir o nome da função chamadora em uma determinada função?

Veja debug_backtrace - isso pode rastrear sua pilha de chamadas até o topo.

Veja como você chamaria o chamador:

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

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

O Xdebug fornece algumas funções interessantes.

<?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();
?>

retornará rastreio

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

Para instalar o Xdebug no ubuntu, a melhor maneira é

sudo aptitude install php5-xdebug

Você pode precisar instalar o php5-dev primeiro

sudo aptitude install php5-dev

mais informações

É muito tarde, mas gostaria de compartilhar a função que fornecerá o nome da função a partir da qual a função atual é chamada.

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;
    }

Espero que isso seja útil.

debug_backtrace() fornece detalhes de parâmetros, chamadas de função / método na pilha de chamadas atual.

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

Funciona desde o PHP 5.4 .

Ou otimizado (por exemplo, para casos de uso sem depuração):

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

O primeiro argumento impede o preenchimento de argumentos de função não utilizados, o segundo limita o rastreamento a dois níveis (precisamos do segundo).

Feito isso e usando isso sozinho

/**
 * 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;
    }   
}

Eu só queria afirmar que o caminho de flori não funcionará como uma função, pois sempre retornará o nome da função chamada em vez do chamador, mas não tenho reputação de comentar. Fiz uma função muito simples com base na resposta de flori que funciona bem no meu caso:

class basicFunctions{

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

}

EXEMPLO:

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..
}

Você pode extrair essas informações da matriz retornada por debug_backtrace

Este funcionou melhor para mim: var_dump(debug_backtrace());

Na verdade, acho que debug_print_backtrace () faz o que você precisa. http://php.net/manual/en/function.debug-print-backtrace.php

Isso deve funcionar:

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

Isso fará muito bem:

// 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()
**/```