Name der Anruferfunktion in PHP abrufen?

Gibt es eine PHP-Funktion, um den Namen der Aufruferfunktion in einer bestimmten Funktion herauszufinden?

Siehe debug_backtrace - dies kann Ihren Aufrufstapel bis ganz nach oben verfolgen.

So erhalten Sie Ihren Anrufer:

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

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

Xdebug bietet einige nette Funktionen.

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

wird Trace zurückgeben

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

Um Xdebug auf Ubuntu zu installieren, ist der beste Weg

sudo aptitude install php5-xdebug

Möglicherweise müssen Sie zuerst php5-dev installieren

sudo aptitude install php5-dev

Mehr Info

Dies ist sehr spät, aber ich möchte die Funktion teilen, die den Namen der Funktion angibt, von der die aktuelle Funktion aufgerufen wird.

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

Ich hoffe das wird nützlich sein.

debug_backtrace() liefert Details zu Parametern, Funktions- / Methodenaufrufen im aktuellen Aufrufstapel.

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

Funktioniert seit PHP 5.4 .

Oder optimiert (z. B. für Nicht-Debug-Anwendungsfälle):

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

Das erste Argument verhindert das Auffüllen nicht verwendeter Funktionsargumente, das zweite begrenzt die Ablaufverfolgung auf zwei Ebenen (wir benötigen die zweite).

Habe das gemacht und das selbst benutzt

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

Ich wollte nur sagen, dass Floris Weg nicht als Funktion funktioniert, weil er immer den aufgerufenen Funktionsnamen anstelle des Aufrufers zurückgibt, aber ich habe keinen Ruf für Kommentare. Ich habe eine sehr einfache Funktion basierend auf Floris Antwort erstellt, die für meinen Fall gut funktioniert:

class basicFunctions{

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

}

BEISPIEL:

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

Sie können diese Informationen aus dem von debug_backtrace zurückgegebenen Array extrahieren

Dieser hat am besten für mich funktioniert: var_dump(debug_backtrace());

Eigentlich denke ich, dass debug_print_backtrace () das tut, was Sie brauchen. http://php.net/manual/en/function.debug-print-backtrace.php

Das sollte funktionieren:

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

Das wird es gut machen:

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