Come ottenere un nome di variabile come stringa in PHP?

Di 'che ho questo codice PHP:

$FooBar = "a string";

ho quindi bisogno di una funzione come questa:

print_var_name($FooBar);

che stampa:

FooBar

Qualche idea su come raggiungere questo obiettivo? È possibile anche in PHP?

È possibile utilizzare get_defined_vars () per trovare il nome di una variabile che ha lo stesso valore di quella di cui si sta tentando di trovare il nome. Ovviamente questo non funzionerà sempre, poiché variabili diverse spesso hanno gli stessi valori, ma è l'unico modo in cui riesco a pensare di farlo.

Modifica: get_defined_vars () non sembra funzionare correttamente, restituisce 'var' perché $ var viene usato nella funzione stessa. $ GLOBALS sembra funzionare, quindi l'ho cambiato in questo.

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

    return false;
}

Modifica: per essere chiari, non esiste un buon modo per farlo in PHP, probabilmente perché non dovresti farlo. Probabilmente ci sono modi migliori per fare ciò che stai cercando di fare.

Non riuscivo nemmeno a pensare a un modo per farlo in modo efficiente, ma mi sono inventato questo. Funziona, per gli usi limitati di seguito.

alzata di spalle

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

Funziona in base alla linea che ha chiamato la funzione, dove trova l'argomento che hai passato. Suppongo che potrebbe essere espanso per funzionare con più argomenti ma, come altri hanno già detto, se tu potessi spiegare meglio la situazione, probabilmente un'altra soluzione lavorare meglio.

Potresti considerare di cambiare il tuo approccio e usare un nome variabile variabile?

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

allora potresti solo

print($var_name);

ottenere

FooBar

Ecco il link al manuale di PHP sulle variabili delle variabili

Nessuno sembra aver menzionato i motivi fondamentali per cui questo è a) difficile eb) poco saggio:

• Una "variabile" è solo un simbolo che punta a qualcos'altro. In PHP, punta internamente a qualcosa chiamato "zval", che può effettivamente essere utilizzato per più variabili contemporaneamente, sia perché hanno lo stesso valore (PHP implementa qualcosa chiamato "copia su scrittura" in modo che $foo = $barnon sia necessario allocare memoria aggiuntiva immediatamente) o perché sono stati assegnati (o passati a una funzione) per riferimento (ad es $foo =& $bar.). Quindi uno zval non ha nome.
• Quando si passa un parametro a una funzione, si crea una nuova variabile (anche se è un riferimento). Potresti passare qualcosa di anonimo, come "hello", ma una volta dentro la tua funzione, è qualunque variabile la chiami come. Questo è abbastanza fondamentale per la separazione del codice: se una funzione si basava su ciò che una variabile veniva chiamata, sarebbe più simile gotoa una funzione propriamente separata.
• Le variabili globali sono generalmente considerate una cattiva idea. Molti degli esempi qui presuppongono che la variabile che si desidera "riflettere" possa essere trovata $GLOBALS, ma ciò sarà vero solo se il codice è stato strutturato in modo errato e le variabili non sono comprese in alcuna funzione o oggetto.
• I nomi delle variabili sono lì per aiutare i programmatori a leggere il loro codice. Rinominare le variabili per adattarle meglio al loro scopo è una pratica di refactoring molto comune e il punto è che non fa alcuna differenza.

Ora capisco il desiderio di questo per il debug (anche se alcuni degli usi proposti vanno ben oltre), ma come soluzione generalizzata non è effettivamente così utile come potresti pensare: se la tua funzione di debug dice che la tua variabile si chiama "$ file ", potrebbe trattarsi di una qualsiasi delle dozzine di variabili" $ file "nel codice o di una variabile che hai chiamato" $ nomefile "ma che passa a una funzione il cui parametro è chiamato" $ file ".

Un'informazione molto più utile è da dove nel tuo codice è stata chiamata la funzione di debug. Dal momento che puoi trovarlo rapidamente nel tuo editor, puoi vedere quale variabile stavi producendo per te stesso e puoi persino passare intere espressioni in esso in una sola volta (ad esempio debug('$foo + $bar = ' . ($foo + $bar))).

Per questo, è possibile utilizzare questo frammento nella parte superiore della funzione di debug:

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

Questo è esattamente quello che vuoi - è una funzione "copia e rilascia" pronta per l'uso che fa eco al nome di una data var:

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

USO: print_var_name ($ FooBar)

STAMPA: FooBar

SUGGERIMENTO Ora è possibile rinominare la funzione che funzionerà ancora e che la utilizzerà anche più volte in una riga! Grazie a @Cliffordlife

Lucas su PHP.net ha fornito un modo affidabile per verificare l'esistenza di una variabile. Nel suo esempio, scorre una copia dell'array di variabili globale (o un array con ambito) di variabili, cambia il valore in un valore generato casualmente e verifica il valore generato nell'array copiato.

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

Quindi prova:

$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

Assicurati di controllare il suo post su PHP.net: http://php.net/manual/en/language.variables.php

Ho effettuato una funzione di ispezione per motivi di debug. È come print_r () sugli steroidi, molto simile a Krumo ma un po 'più efficace sugli oggetti. Volevo aggiungere il rilevamento del nome var e ne sono uscito, ispirato al post di Nick Presta su questa pagina. Rileva qualsiasi espressione passata come argomento, non solo nomi di variabili.

Questa è solo la funzione wrapper che rileva l'espressione passata. Funziona sulla maggior parte dei casi. Non funzionerà se si chiama la funzione più di una volta nella stessa riga di codice.

Funziona bene: die ( inspect ($ This-> getUser () -> hasCredential ( "Elimina")) );

inspect () è la funzione che rileverà l'espressione passata.

Otteniamo: $ 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);

}

Ecco un esempio della funzione inspector (e della mia classe dInspect) in azione:

http://inspect.ip1.cc

I testi sono in spagnolo in quella pagina, ma il codice è conciso e davvero facile da capire.

Da php.net

@Alexandre - soluzione breve

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

@Lucas - utilizzo

<?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
?>

Molte risposte mettono in dubbio l'utilità di questo. Tuttavia, ottenere un riferimento per una variabile può essere molto utile. Soprattutto nei casi con oggetti e $ questo . La mia soluzione funziona con oggetti e anche come oggetti definiti dalla proprietà:

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

Esempio per quanto sopra:

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

Adattato dalle risposte sopra per molte variabili, con buone prestazioni, solo una scansione $ GLOBALS per molte

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
        )

)

Se la variabile è intercambiabile, è necessario disporre di una logica da qualche parte che determini quale variabile viene utilizzata. Tutto quello che devi fare è inserire il nome della variabile $variableall'interno di quella logica mentre stai facendo tutto il resto.

Penso che stiamo tutti facendo fatica a capire di cosa hai bisogno. Codice di esempio o una spiegazione di ciò che si sta effettivamente cercando di fare potrebbe aiutare, ma ho il sospetto Non Sei modo, modo overthinking questo.

In realtà ho un caso d'uso valido per questo.

Ho una funzione cacheVariable ($ var) (ok, ho una cache di funzione ($ chiave, $ valore), ma vorrei avere una funzione come menzionato).

Lo scopo è di fare:

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

...

// another session

...

$myColour = getCachedVariable('colour');

Ci ho provato

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
}

Ho anche provato con

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

Ma anche questo fallisce ... :(

Certo, potrei continuare a fare cache ('color', $ color), ma sono pigro, sai ...;)

Quindi, quello che voglio è una funzione che ottiene il nome ORIGINALE di una variabile, poiché è stata passata a una funzione. All'interno della funzione non c'è modo di saperlo, come sembra. Passare get_defined_vars () come riferimento nel secondo esempio sopra mi ha aiutato (grazie a Jean-Jacques Guegan per quell'idea) in qualche modo. Quest'ultima funzione ha iniziato a funzionare, ma ha continuato a restituire solo la variabile locale ('variabile', non 'colore').

Non ho ancora provato a usare get_func_args () e get_func_arg (), $ {} - costrutti e key () combinati, ma presumo che fallirà anche.

Ho questo:

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

Preferirei questo:

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

La funzione esistente visualizza una casella gialla con un contorno rosso e mostra ogni variabile per nome e valore. La soluzione array funziona ma è un po 'contorta da digitare quando è necessario.

Questo è il mio caso d'uso e sì, ha a che fare con il debug. Sono d'accordo con coloro che mettono in dubbio il suo utilizzo altrimenti.

Ecco la mia soluzione basata su Jeremy Ruten

class DebugHelper {

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

usandolo

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

Perché non costruisci semplicemente una funzione e la dici?

/**
 * 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' );

Stavo cercando questo, ma ho appena deciso di passare il nome, di solito ho comunque il nome negli Appunti.

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

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

È possibile utilizzare compact () per raggiungere questo obiettivo.

$FooBar = "a string";

$newArray = compact('FooBar');

Ciò creerebbe un array associativo con il nome della variabile come chiave. È quindi possibile eseguire il ciclo attraverso l'array utilizzando il nome della chiave in cui era necessario.

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

Penso che tu voglia conoscere il nome della variabile con il suo valore. È possibile utilizzare un array associativo per raggiungere questo obiettivo.

usa i nomi delle variabili per le chiavi dell'array:

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

Quando vuoi ottenere nomi di variabili, usa array_keys($vars), restituirà una matrice di quei nomi di variabili che sono stati usati nella tua $varsmatrice come chiavi.

So che è vecchio e ha già risposto, ma in realtà stavo cercando questo. Sto pubblicando questa risposta per risparmiare un po 'di tempo alle persone affinando alcune delle risposte.

Opzione 1:

$data = array('$FooBar');  

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

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

stampe:

FooBar

Per qualsiasi motivo ti ritrovi in ​​una situazione come questa, in realtà funziona.

.
Opzione 2:

$FooBar = "a string";  

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

Se $FooBarha un valore univoco, stamperà 'FooBar'. Se $FooBarè vuoto o nullo, stamperà il nome della prima stringa vuota o nulla che trova.

Potrebbe essere usato come tale:

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

Questo è il modo in cui l'ho fatto

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

uso

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

Nota: alcune versioni di PHP 7 non funzionerà correttamente a causa di un bug in array_searchcon $GLOBALS, ma tutte le altre versioni funzionerà.

Vedi questo https://3v4l.org/UMW7V

Usalo per staccare le variabili utente dal globale per controllare la variabile al momento.

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

Può essere considerato veloce e sporco, ma la mia preferenza personale è quella di utilizzare una funzione / metodo come questo:

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

fondamentalmente crea solo un array associativo contenente un elemento null / vuoto, usando come chiave la variabile per la quale si desidera il nome.

otteniamo quindi il valore di quella chiave usando array_keys e lo restituiamo.

ovviamente questo diventa molto veloce e non sarebbe desiderabile in un ambiente di produzione, ma funziona per il problema presentato.

perché dobbiamo usare i globi per ottenere il nome della variabile ... possiamo usare semplicemente come sotto.

    $variableName = "ajaxmint";

    echo getVarName('$variableName');

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

Non riesco davvero a vedere il caso d'uso ... Se digiterai print_var_name ($ foobar), cosa c'è di così difficile (e diverso) nel digitare print ("foobar") invece?

Perché anche se dovessi usarlo in una funzione, otterrai il nome locale della variabile ...

In ogni caso, ecco il manuale di riflessione nel caso in cui ci sia qualcosa di cui hai bisogno.