Wie bekomme ich einen Variablennamen als String in PHP?

Angenommen, ich habe diesen PHP-Code:

$FooBar = "a string";

Ich brauche dann eine Funktion wie diese:

print_var_name($FooBar);

welche druckt:

FooBar

Irgendwelche Ideen, wie man das erreicht? Ist das überhaupt in PHP möglich?

Sie könnten get_defined_vars () verwenden , um den Namen einer Variablen zu ermitteln, die denselben Wert hat wie die, deren Namen . Natürlich wird dies nicht immer funktionieren, da verschiedene Variablen oft die gleichen Werte haben, aber es ist die einzige Möglichkeit, die ich mir vorstellen kann, dies zu tun.

Bearbeiten: get_defined_vars () scheint nicht richtig zu funktionieren, es gibt 'var' zurück, da $ var in der Funktion selbst verwendet wird. $ GLOBALS scheint zu funktionieren, also habe ich es geändert.

function print_var_name($var) {
    foreach($GLOBALS as $var_name => $value) {
        if ($value === $var) {
            return $var_name;
        }
    }

    return false;
}

Bearbeiten: Um klar zu sein, gibt es keine gute Möglichkeit, dies in PHP zu tun, was wahrscheinlich daran liegt, dass Sie es nicht tun sollten. Es gibt wahrscheinlich bessere Möglichkeiten, das zu tun, was Sie versuchen.

Ich konnte mir auch keinen Weg vorstellen, dies effizient zu tun, aber ich habe mir das ausgedacht. Es funktioniert für die unten angegebenen begrenzten Verwendungszwecke.

zucken

<?php

function varName( $v ) {
    $trace = debug_backtrace();
    $vLine = file( __FILE__ );
    $fLine = $vLine[ $trace[0]['line'] - 1 ];
    preg_match( "#\\$(\w+)#", $fLine, $match );
    print_r( $match );
}

$foo = "knight";
$bar = array( 1, 2, 3 );
$baz = 12345;

varName( $foo );
varName( $bar );
varName( $baz );

?>

// Returns
Array
(
    [0] => $foo
    [1] => foo
)
Array
(
    [0] => $bar
    [1] => bar
)
Array
(
    [0] => $baz
    [1] => baz
)

Es funktioniert basierend auf der Zeile, die die Funktion aufgerufen hat, in der das von Ihnen übergebene Argument gefunden wird. Ich nehme an, es könnte erweitert werden, um mit mehreren Argumenten zu arbeiten, aber wie andere gesagt haben, würde es wahrscheinlich eine andere Lösung geben, wenn Sie die Situation besser erklären könnten arbeite besser.

Sie könnten erwägen, Ihren Ansatz zu ändern und einen variablen Variablennamen zu verwenden?

$var_name = "FooBar";
$$var_name = "a string";

dann könntest du einfach

print($var_name);

bekommen

FooBar

Hier ist der Link zum PHP-Handbuch zu Variablenvariablen

Niemand scheint die fundamentalen Gründe genannt zu haben, warum dies a) schwer und b) unklug ist:

• Eine "Variable" ist nur ein Symbol, das auf etwas anderes zeigt. In PHP verweist es intern auf etwas, das als "zval" bezeichnet wird und tatsächlich für mehrere Variablen gleichzeitig verwendet werden kann, entweder weil sie denselben Wert haben (PHP implementiert etwas, das als "Copy-on-Write" bezeichnet wird, so dass $foo = $bardies nicht erforderlich ist zusätzlichen Speicher sofort zuweisen) oder weil sie durch Referenz zugewiesen (oder an eine Funktion übergeben) wurden (z $foo =& $bar. B. ). Ein Zval hat also keinen Namen.
• Wenn Sie einen Parameter an eine Funktion übergeben, erstellen Sie eine neue Variable (auch wenn es sich um eine Referenz handelt). Sie könnten etwas anonymes übergeben, "hello"aber sobald Sie sich in Ihrer Funktion befinden, ist es die Variable, als die Sie es bezeichnen. Dies ist für die Codetrennung ziemlich grundlegend: Wenn sich eine Funktion auf das stützt, was eine Variable früher aufgerufen hat, ist sie eher eine gotoals eine ordnungsgemäß getrennte Funktion.
• Globale Variablen werden im Allgemeinen als schlechte Idee angesehen. In vielen Beispielen wird davon ausgegangen, dass die Variable, die Sie "reflektieren" möchten, in gefunden werden $GLOBALSkann. Dies gilt jedoch nur, wenn Sie Ihren Code schlecht strukturiert haben und Variablen nicht auf eine Funktion oder ein Objekt beschränkt sind.
• Variablennamen helfen Programmierern beim Lesen ihres Codes. Das Umbenennen von Variablen, um sie besser an ihren Zweck anzupassen, ist eine weit verbreitete Refactoring-Praxis, und der springende Punkt ist, dass es keinen Unterschied macht.

Jetzt verstehe ich den Wunsch nach Debugging (obwohl einige der vorgeschlagenen Verwendungen weit darüber hinausgehen), aber als allgemeine Lösung ist es nicht so hilfreich, wie Sie vielleicht denken: Wenn Ihre Debug-Funktion besagt, dass Ihre Variable "$ file" heißt ", das kann immer noch eine von Dutzenden von" $ file "-Variablen in Ihrem Code sein oder eine Variable, die Sie" $ filename "genannt haben, aber an eine Funktion übergeben, deren Parameter" $ file "heißt.

Eine weitaus nützlichere Information ist, woher in Ihrem Code die Debug-Funktion aufgerufen wurde. Da Sie dies schnell in Ihrem Editor finden, können Sie sehen, welche Variable Sie für sich selbst ausgegeben haben, und sogar ganze Ausdrücke auf einmal übergeben (zdebug('$foo + $bar = ' . ($foo + $bar)) . ).

Dafür können Sie dieses Snippet oben in Ihrer Debug-Funktion verwenden:

$backtrace = debug_backtrace();
echo '# Debug function called from ' . $backtrace[0]['file'] . ' at line ' . $backtrace[0]['line'];

Dies ist genau das, was Sie wollen - es ist eine gebrauchsfertige "Kopieren und Ablegen" -Funktion, die den Namen einer bestimmten Variablen wiedergibt:

function print_var_name(){
    // read backtrace
    $bt   = debug_backtrace();
    // read file
    $file = file($bt[0]['file']);
    // select exact print_var_name($varname) line
    $src  = $file[$bt[0]['line']-1];
    // search pattern
    $pat = '#(.*)'.__FUNCTION__.' *?\( *?(.*) *?\)(.*)#i';
    // extract $varname from match no 2
    $var  = preg_replace($pat, '$2', $src);
    // print to browser
    echo trim($var);
}

VERWENDUNG: print_var_name ($ FooBar)

DRUCKEN: FooBar

TIPP Jetzt können Sie die Funktion umbenennen und sie funktioniert weiterhin und wird auch mehrmals in einer Zeile verwendet! Vielen Dank an @Cliffordlife

Lucas auf PHP.net bot eine zuverlässige Möglichkeit, um zu überprüfen, ob eine Variable vorhanden ist. In seinem Beispiel durchläuft er eine Kopie des globalen Variablenarrays (oder eines Bereichsarrays) von Variablen, ändert den Wert in einen zufällig generierten Wert und überprüft den generierten Wert im kopierten Array.

function variable_name( &$var, $scope=false, $prefix='UNIQUE', $suffix='VARIABLE' ){
    if($scope) {
        $vals = $scope;
    } else {
        $vals = $GLOBALS;
    }
    $old = $var;
    $var = $new = $prefix.rand().$suffix;
    $vname = FALSE;
    foreach($vals as $key => $val) {
        if($val === $new) $vname = $key;
    }
    $var = $old;
    return $vname;
}

Dann versuche es:

$a = 'asdf';
$b = 'asdf';
$c = FALSE;
$d = FALSE;

echo variable_name($a); // a
echo variable_name($b); // b
echo variable_name($c); // c
echo variable_name($d); // d

Überprüfen Sie unbedingt seinen Beitrag auf PHP.net: http://php.net/manual/en/language.variables.php

Ich habe aus Debugging-Gründen eine Inspektionsfunktion erstellt. Es ist wie print_r () bei Steroiden, ähnlich wie Krumo, aber bei Objekten etwas effektiver. Ich wollte die Var-Namenserkennung hinzufügen und kam damit heraus, inspiriert von Nick Prestas Beitrag auf dieser Seite. Es erkennt jeden als Argument übergebenen Ausdruck, nicht nur Variablennamen.

Dies ist nur die Wrapper-Funktion, die den übergebenen Ausdruck erkennt. Funktioniert in den meisten Fällen. Es funktioniert nicht, wenn Sie die Funktion mehrmals in derselben Codezeile aufrufen.

Das funktioniert gut: sterben ( inspizieren ($ this-> getUser () -> hasCredential ("delete")) );

inspect () ist die Funktion, die den übergebenen Ausdruck erkennt.

Wir erhalten: $ this-> getUser () -> hasCredential ("delete")

function inspect($label, $value = "__undefin_e_d__")
{
    if($value == "__undefin_e_d__") {

        /* The first argument is not the label but the 
           variable to inspect itself, so we need a label.
           Let's try to find out it's name by peeking at 
           the source code. 
        */

        /* The reason for using an exotic string like 
           "__undefin_e_d__" instead of NULL here is that 
           inspected variables can also be NULL and I want 
           to inspect them anyway.
        */

        $value = $label;

        $bt = debug_backtrace();
        $src = file($bt[0]["file"]);
        $line = $src[ $bt[0]['line'] - 1 ];

        // let's match the function call and the last closing bracket
        preg_match( "#inspect\((.+)\)#", $line, $match );

        /* let's count brackets to see how many of them actually belongs 
           to the var name
           Eg:   die(inspect($this->getUser()->hasCredential("delete")));
                  We want:   $this->getUser()->hasCredential("delete")
        */
        $max = strlen($match[1]);
        $varname = "";
        $c = 0;
        for($i = 0; $i < $max; $i++){
            if(     $match[1]{$i} == "(" ) $c++;
            elseif( $match[1]{$i} == ")" ) $c--;
            if($c < 0) break;
            $varname .=  $match[1]{$i};
        }
        $label = $varname;
    }

    // $label now holds the name of the passed variable ($ included)
    // Eg:   inspect($hello) 
    //             => $label = "$hello"
    // or the whole expression evaluated
    // Eg:   inspect($this->getUser()->hasCredential("delete"))
    //             => $label = "$this->getUser()->hasCredential(\"delete\")"

    // now the actual function call to the inspector method, 
    // passing the var name as the label:

      // return dInspect::dump($label, $val);
         // UPDATE: I commented this line because people got confused about 
         // the dInspect class, wich has nothing to do with the issue here.

    echo("The label is: ".$label);
    echo("The value is: ".$value);

}

Hier ist ein Beispiel für die Inspektorfunktion (und meine dInspect-Klasse) in Aktion:

http://inspect.ip1.cc

Die Texte auf dieser Seite sind spanisch, aber der Code ist präzise und sehr leicht zu verstehen.

Von php.net

@Alexandre - kurze Lösung

<?php
function vname(&$var, $scope=0)
{
    $old = $var;
    if (($key = array_search($var = 'unique'.rand().'value', !$scope ? $GLOBALS : $scope)) && $var = $old) return $key;  
}
?>

@ Lucas - Verwendung

<?php
//1.  Use of a variable contained in the global scope (default):
  $my_global_variable = "My global string.";
  echo vname($my_global_variable); // Outputs:  my_global_variable

//2.  Use of a local variable:
  function my_local_func()
  {
    $my_local_variable = "My local string.";
    return vname($my_local_variable, get_defined_vars());
  }
  echo my_local_func(); // Outputs: my_local_variable

//3.  Use of an object property:
  class myclass
  {
    public function __constructor()
    {
      $this->my_object_property = "My object property  string.";
    }
  }
  $obj = new myclass;
  echo vname($obj->my_object_property, $obj); // Outputs: my_object_property
?>

Viele Antworten stellen die Nützlichkeit dieser Frage in Frage. Das Abrufen einer Referenz für eine Variable kann jedoch sehr nützlich sein. Besonders in Fällen mit Objekten und $ this . Meine Lösung funktioniert mit Objekten und auch als eigenschaftsdefinierte Objekte:

function getReference(&$var)
{
    if(is_object($var))
        $var->___uniqid = uniqid();
    else
        $var = serialize($var);
    $name = getReference_traverse($var,$GLOBALS);
    if(is_object($var))
        unset($var->___uniqid);
    else
        $var = unserialize($var);
    return "\${$name}";    
}

function getReference_traverse(&$var,$arr)
{
    if($name = array_search($var,$arr,true))
        return "{$name}";
    foreach($arr as $key=>$value)
        if(is_object($value))
            if($name = getReference_traverse($var,get_object_vars($value)))
                return "{$key}->{$name}";
}

Beispiel für das Obige:

class A
{
    public function whatIs()
    {
        echo getReference($this);
    }
}

$B = 12;
$C = 12;
$D = new A;

echo getReference($B)."<br/>"; //$B
echo getReference($C)."<br/>"; //$C
$D->whatIs(); //$D

Angepasst an die obigen Antworten für viele Variablen, mit guter Leistung, nur ein $ GLOBALS-Scan für viele

function compact_assoc(&$v1='__undefined__', &$v2='__undefined__',&$v3='__undefined__',&$v4='__undefined__',&$v5='__undefined__',&$v6='__undefined__',&$v7='__undefined__',&$v8='__undefined__',&$v9='__undefined__',&$v10='__undefined__',&$v11='__undefined__',&$v12='__undefined__',&$v13='__undefined__',&$v14='__undefined__',&$v15='__undefined__',&$v16='__undefined__',&$v17='__undefined__',&$v18='__undefined__',&$v19='__undefined__'
) {
    $defined_vars=get_defined_vars();

    $result=Array();
    $reverse_key=Array();
    $original_value=Array();
    foreach( $defined_vars as $source_key => $source_value){
        if($source_value==='__undefined__') break;
        $original_value[$source_key]=$$source_key;
        $new_test_value="PREFIX".rand()."SUFIX";
        $reverse_key[$new_test_value]=$source_key;
        $$source_key=$new_test_value;

    }
    foreach($GLOBALS as $key => &$value){
        if( is_string($value) && isset($reverse_key[$value])  ) {
            $result[$key]=&$value;
        }
    }
    foreach( $original_value as $source_key => $original_value){
        $$source_key=$original_value;
    }
    return $result;
}


$a = 'A';
$b = 'B';
$c = '999';
$myArray=Array ('id'=>'id123','name'=>'Foo');
print_r(compact_assoc($a,$b,$c,$myArray) );

//print
Array
(
    [a] => A
    [b] => B
    [c] => 999
    [myArray] => Array
        (
            [id] => id123
            [name] => Foo
        )

)

Wenn die Variable austauschbar ist, müssen Sie irgendwo eine Logik haben , die bestimmt, welche Variable verwendet wird. Sie müssen lediglich den Variablennamen eingeben$variable diese Logik einzufügen, während Sie alles andere tun.

Ich denke, es fällt uns allen schwer zu verstehen, wofür Sie das brauchen. Beispielcode oder eine Erklärung, was Sie versuchen , tatsächlich zu tun könnte helfen, aber ich vermute , du bist Art und Weise, Art und Weise dieses Grübeln.

Ich habe tatsächlich einen gültigen Anwendungsfall dafür.

Ich habe eine Funktion cacheVariable ($ var) (ok, ich habe einen Funktionscache ($ key, $ value), aber ich möchte eine Funktion wie erwähnt haben).

Der Zweck ist zu tun:

$colour = 'blue';
cacheVariable($colour);

...

// another session

...

$myColour = getCachedVariable('colour');

Ich habe es mit versucht

function cacheVariable($variable) {
   $key = ${$variable}; // This doesn't help! It only gives 'variable'.
   // do some caching using suitable backend such as apc, memcache or ramdisk
}

Ich habe es auch mit versucht

function varName(&$var) {
   $definedVariables = get_defined_vars();
   $copyOfDefinedVariables = array();
   foreach ($definedVariables as $variable=>$value) {
      $copyOfDefinedVariables[$variable] = $value;
   }
   $oldVar = $var;
   $var = !$var;
   $difference = array_diff_assoc($definedVariables, $copyOfDefinedVariables);
   $var = $oldVar;
   return key(array_slice($difference, 0, 1, true));
}

Aber das scheitert auch ... :(

Sicher, ich könnte weiterhin Cache machen ('Farbe', $ Farbe), aber ich bin faul, weißt du ...;)

Ich möchte also eine Funktion, die den ORIGINAL-Namen einer Variablen erhält, wie er an eine Funktion übergeben wurde. Innerhalb der Funktion kann ich das auf keinen Fall wissen, wie es scheint. Das Übergeben von get_defined_vars () als Referenz im zweiten Beispiel oben hat mir etwas geholfen (Dank an Jean-Jacques Guegan für diese Idee). Die letztere Funktion begann zu funktionieren, gab aber immer noch nur die lokale Variable zurück ('Variable', nicht 'Farbe').

Ich habe noch nicht versucht, get_func_args () und get_func_arg (), $ {} - Konstrukte und key () zusammen zu verwenden, aber ich gehe davon aus, dass dies ebenfalls fehlschlagen wird.

Ich habe das:

  debug_echo(array('$query'=>$query, '$nrUsers'=>$nrUsers, '$hdr'=>$hdr));

Ich würde das vorziehen:

  debug_echo($query, $nrUsers, $hdr);

Die vorhandene Funktion zeigt ein gelbes Feld mit einem roten Umriss an und zeigt jede Variable nach Name und Wert an. Die Array-Lösung funktioniert, ist jedoch etwas kompliziert, wenn sie benötigt wird.

Das ist mein Anwendungsfall und ja, es hat mit Debugging zu tun. Ich stimme denen zu, die seine Verwendung anders in Frage stellen.

Hier ist meine Lösung basierend auf Jeremy Ruten

class DebugHelper {

    function printVarNames($systemDefinedVars, $varNames) {
        foreach ($systemDefinedVars as $var=>$value) {
            if (in_array($var, $varNames )) {
                var_dump($var);
                var_dump($value);
            }
        }
    }
}

es benutzen

DebugHelper::printVarNames(
    $systemDefinedVars = get_defined_vars(),
    $varNames=array('yourVar00', 'yourVar01')
);

Warum bauen Sie nicht einfach eine einfache Funktion und sagen es?

/**
 * Prints out $obj for debug
 *
 * @param any_type $obj
 * @param (string) $title
 */
function print_all( $obj, $title = false )
{
    print "\n<div style=\"font-family:Arial;\">\n";
    if( $title ) print "<div style=\"background-color:red; color:white; font-size:16px; font-weight:bold; margin:0; padding:10px; text-align:center;\">$title</div>\n";
    print "<pre style=\"background-color:yellow; border:2px solid red; color:black; margin:0; padding:10px;\">\n\n";
    var_export( $obj );
    print "\n\n</pre>\n</div>\n";
}

print_all( $aUser, '$aUser' );

Ich habe danach gesucht, aber nur beschlossen, den Namen weiterzugeben. Normalerweise habe ich den Namen sowieso in der Zwischenablage.

function VarTest($my_var,$my_var_name){
    echo '$'.$my_var_name.': '.$my_var.'<br />';
}

$fruit='apple';
VarTest($fruit,'fruit');

Sie können compact () verwenden, um dies zu erreichen.

$FooBar = "a string";

$newArray = compact('FooBar');

Dies würde ein assoziatives Array mit dem Variablennamen als Schlüssel erstellen. Sie können dann das Array mit dem Schlüsselnamen durchlaufen, in dem Sie es benötigt haben.

foreach($newarray as $key => $value) {
    echo $key;
}

Ich denke, Sie möchten den Variablennamen mit seinem Wert kennen. Sie können ein assoziatives Array verwenden, um dies zu erreichen.

Verwenden Sie Variablennamen für Array-Schlüssel:

$vars = array('FooBar' => 'a string');

Wenn Sie Variablennamen abrufen möchten array_keys($vars), wird ein Array der Variablennamen zurückgegeben, die in Ihrem $varsArray als Schlüssel verwendet wurden.

Ich weiß, dass dies alt ist und bereits beantwortet wurde, aber ich habe tatsächlich danach gesucht. Ich poste diese Antwort, um den Leuten ein wenig Zeit zu sparen und einige der Antworten zu verfeinern.

Option 1:

$data = array('$FooBar');  

$vars = [];  
$vars = preg_replace('/^\\$/', '', $data); 

$varname = key(compact($vars));  
echo $varname;

Drucke:

FooBar

Aus welchem ​​Grund auch immer Sie sich in einer solchen Situation befinden würden, es funktioniert tatsächlich.

.
Option 2:

$FooBar = "a string";  

$varname = trim(array_search($FooBar, $GLOBALS), " \t.");  
echo $varname;

Wenn $FooBarein eindeutiger Wert vorhanden ist, wird "FooBar" gedruckt. Wenn$FooBar leer oder null, wird der Name der ersten gefundenen leeren oder null-Zeichenfolge ausgegeben.

Es könnte als solches verwendet werden:

if (isset($FooBar) && !is_null($FooBar) && !empty($FooBar)) {
    $FooBar = "a string";
    $varname = trim(array_search($FooBar, $GLOBALS), " \t.");
}

So habe ich es gemacht

function getVar(&$var) {
    $tmp = $var; // store the variable value
    $var = '_$_%&33xc$%^*7_r4'; // give the variable a new unique value
    $name = array_search($var, $GLOBALS); // search $GLOBALS for that unique value and return the key(variable)
    $var = $tmp; // restore the variable old value
    return $name;
}

Verwendung

$city  = "San Francisco";
echo getVar($city); // city

Hinweis: einige Versionen PHP 7 nicht richtig auf einen Fehler aufgrund arbeiten array_searchmit$GLOBALS , aber alle anderen Versionen funktionieren.

Siehe diese https://3v4l.org/UMW7V

Verwenden Sie diese Option, um Benutzervariablen von global zu trennen und die Variable im Moment zu überprüfen.

function get_user_var_defined () 
{
    return array_slice($GLOBALS,8,count($GLOBALS)-8);     
}

function get_var_name ($var) 
{
    $vuser = get_user_var_defined(); 
    foreach($vuser as $key=>$value) 
    {
        if($var===$value) return $key ; 
    }
}

Es kann als schnell und schmutzig angesehen werden, aber meine persönliche Präferenz ist es, eine Funktion / Methode wie diese zu verwenden:

public function getVarName($var) {      
  $tmp = array($var => '');
  $keys = array_keys($tmp);
  return trim($keys[0]);
}

Im Grunde wird nur ein assoziatives Array erstellt, das ein null / leeres Element enthält, wobei die Variable, für die Sie den Namen möchten, als Schlüssel verwendet wird.

Wir erhalten dann den Wert dieses Schlüssels mit array_keys und geben ihn zurück.

Offensichtlich wird dies schnell chaotisch und wäre in einer Produktionsumgebung nicht wünschenswert, aber es funktioniert für das vorgestellte Problem.

Warum wir Globals verwenden müssen, um den Variablennamen zu erhalten ... können wir einfach wie unten verwenden.

    $variableName = "ajaxmint";

    echo getVarName('$variableName');

    function getVarName($name) {
        return str_replace('$','',$name);
    }

Ich sehe den Anwendungsfall wirklich nicht ... Wenn Sie print_var_name ($ foobar) eingeben, was ist dann so schwierig (und anders) daran, stattdessen print ("foobar") einzugeben?

Denn selbst wenn Sie dies in einer Funktion verwenden würden, würden Sie den lokalen Namen der Variablen erhalten ...

In jedem Fall finden Sie hier das Reflexionshandbuch für den Fall, dass Sie etwas benötigen.