Obtener el nombre de la función de llamada en PHP?

¿Existe una función PHP para averiguar el nombre de la función de llamada en una función determinada?

Vea debug_backtrace : esto puede rastrear su pila de llamadas hasta la parte superior.

Así es como obtendría su llamada:

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

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

Xdebug proporciona algunas funciones agradables.

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

devolverá rastro

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

Para instalar Xdebug en ubuntu, la mejor manera es

sudo aptitude install php5-xdebug

Es posible que primero necesite instalar php5-dev

sudo aptitude install php5-dev

más información

Esto es muy tarde, pero me gustaría compartir la función que dará el nombre de la función desde la que se llama la función actual.

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 esto sea útil.

debug_backtrace() proporciona detalles de parámetros, llamadas de función / método en la pila de llamadas actual.

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

Funciona desde PHP 5.4 .

O optimizado (por ejemplo, para casos de uso sin depuración):

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

El primer argumento impide llenar argumentos de funciones no utilizadas, el segundo limita la traza a dos niveles (necesitamos el segundo).

Hice esto y lo uso yo mismo

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

Solo quería decir que la forma de Flori no funcionará como una función porque siempre devolverá el nombre de la función llamada en lugar de la persona que llama, pero no tengo reputación de comentar. Hice una función muy simple basada en la respuesta de Flori que funciona bien para mi caso:

class basicFunctions{

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

}

EJEMPLO:

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

Puede extraer esta información de la matriz devuelta por debug_backtrace

Este funcionó mejor para mí: var_dump(debug_backtrace());

En realidad, creo que debug_print_backtrace () hace lo que necesita. http://php.net/manual/en/function.debug-print-backtrace.php

Esto debería funcionar:

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

Esto lo hará 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()
**/```