Uzyskaj nazwę funkcji dzwoniącego w PHP?

Czy istnieje funkcja PHP, aby znaleźć nazwę funkcji wywołującej w danej funkcji?

Zobacz debug_backtrace - to może prześledzić twój stos wywołań aż do samego początku.

Oto, jak możesz zdobyć dzwoniącego:

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

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

Xdebug zapewnia kilka fajnych funkcji.

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

zwróci ślad

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

Aby zainstalować Xdebug na Ubuntu, najlepszym sposobem jest

sudo aptitude install php5-xdebug

Być może będziesz musiał najpierw zainstalować php5-dev

sudo aptitude install php5-dev

więcej informacji

To bardzo późno, ale chciałbym udostępnić funkcję, która poda nazwę funkcji, z której jest wywoływana bieżąca funkcja.

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

Mam nadzieję, że to się przyda.

debug_backtrace() dostarcza szczegóły parametrów, wywołań funkcji / metod w bieżącym stosie wywołań.

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

Działa od PHP 5.4 .

Lub zoptymalizowany (np. Dla przypadków użycia innych niż debugowanie):

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

Pierwszy argument zapobiega wypełnianiu nieużywanych argumentów funkcji, drugi ogranicza śledzenie do dwóch poziomów (potrzebujemy drugiego).

Zrobiłem to i używając tego sam

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

Chciałem tylko powiedzieć, że sposób flori nie będzie działał jako funkcja, ponieważ zawsze zwróci nazwę wywoływanej funkcji zamiast wywołującego, ale nie mam reputacji komentowania. Stworzyłem bardzo prostą funkcję opartą na odpowiedzi flori, która działa dobrze w moim przypadku:

class basicFunctions{

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

}

PRZYKŁAD:

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

Możesz wyodrębnić te informacje z tablicy zwróconej przez debug_backtrace

Ten działał najlepiej dla mnie: var_dump(debug_backtrace());

Właściwie myślę, że debug_print_backtrace () robi to, czego potrzebujesz. http://php.net/manual/en/function.debug-print-backtrace.php

To powinno działać:

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

To ładnie to zrobi:

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