Como obter um nome de variável como uma string no PHP?

Digamos que eu tenho esse código PHP:

$FooBar = "a string";

então eu preciso de uma função como esta:

print_var_name($FooBar);

que imprime:

FooBar

Alguma idéia de como conseguir isso? Isso é possível em PHP?

Você pode usar get_defined_vars () para encontrar o nome de uma variável que tenha o mesmo valor daquele que você está tentando encontrar o nome. Obviamente, isso nem sempre funcionará, pois variáveis ​​diferentes geralmente têm os mesmos valores, mas é a única maneira em que posso pensar em fazer isso.

Edit: get_defined_vars () não parece estar funcionando corretamente, ele retorna 'var' porque $ var é usado na própria função. $ GLOBALS parece funcionar, então eu mudei para isso.

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

    return false;
}

Edit: para ficar claro, não há uma boa maneira de fazer isso no PHP, provavelmente porque você não deveria ter que fazer isso. Provavelmente, existem maneiras melhores de fazer o que você está tentando fazer.

Também não consegui pensar em uma maneira de fazer isso de forma eficiente, mas vim com isso. Funciona para os usos limitados abaixo.

dar de ombros

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

Funciona com base na linha que chamou a função, onde encontra o argumento que você passou. Suponho que poderia ser expandido para trabalhar com vários argumentos, mas, como outros já disseram, se você pudesse explicar melhor a situação, outra solução provavelmente trabalhe melhor.

Você pode mudar sua abordagem e usar um nome de variável variável?

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

então você poderia apenas

print($var_name);

para obter

FooBar

Aqui está o link para o manual do PHP sobre Variáveis ​​variáveis

Ninguém parece ter mencionado as razões fundamentais pelas quais isso é a) difícil eb) imprudente:

• Uma "variável" é apenas um símbolo apontando para outra coisa. No PHP, ele aponta internamente para algo chamado "zval", que pode realmente ser usado para várias variáveis ​​simultaneamente, seja porque elas têm o mesmo valor (o PHP implementa algo chamado "copy-on-write" para que $foo = $barnão precise ser alocar memória extra imediatamente) ou porque foram atribuídos (ou passados ​​para uma função) por referência (por exemplo $foo =& $bar). Portanto, um zval não tem nome.
• Quando você passa um parâmetro para uma função, está criando uma nova variável (mesmo que seja uma referência). Você poderia passar algo anônimo, "hello"mas, uma vez dentro da sua função, é qualquer variável que você nomear como. Isso é bastante fundamental para a separação de código: se uma função dependesse do que uma variável costumava ser chamada, seria mais como umgoto que uma função adequadamente separada.
• Variáveis ​​globais são geralmente consideradas uma má ideia. Muitos exemplos aqui assumem que a variável que você deseja "refletir" pode ser encontrada em$GLOBALS , mas isso só será verdade se você estruturar mal o seu código e as variáveis ​​não tiverem escopo definido para alguma função ou objeto.
• Os nomes de variáveis ​​existem para ajudar os programadores a ler seu código. Renomear variáveis ​​para melhor atender a sua finalidade é uma prática de refatoração muito comum, e o ponto principal é que isso não faz nenhuma diferença.

Agora, entendo o desejo disso para depuração (embora alguns dos usos propostos vão muito além disso), mas como uma solução generalizada não é tão útil quanto você imagina: se sua função de depuração diz que sua variável se chama "$ file ", ainda pode ser qualquer uma das dezenas de variáveis" $ file "no seu código ou uma variável que você chamou" $ filename ", mas que está passando para uma função cujo parâmetro é chamado" $ file ".

Uma informação muito mais útil é de onde no seu código a função de depuração foi chamada. Como você pode encontrar isso rapidamente no seu editor, pode ver qual variável estava produzindo para si mesmo e pode até passar expressões inteiras para ela de uma só vez (por exemplo debug('$foo + $bar = ' . ($foo + $bar))).

Para isso, você pode usar este snippet na parte superior da sua função de depuração:

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

É exatamente isso que você deseja - está pronta para usar a função "copiar e soltar" que ecoa o nome de uma determinada 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)

PRINT: FooBar

DICA Agora você pode renomear a função e ela ainda funcionará e também poderá usá-la várias vezes em uma linha! Obrigado a @Cliffordlife

Lucas no PHP.net forneceu uma maneira confiável de verificar se existe uma variável. Em seu exemplo, ele itera através de uma cópia da matriz global variável (ou de uma matriz com escopo), altera o valor para um valor gerado aleatoriamente e verifica o valor gerado na matriz copiada.

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

Então tente:

$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

Não deixe de conferir o post dele no PHP.net: http://php.net/manual/en/language.variables.php

Eu criei uma função de inspeção por razões de depuração. É como print_r () em esteróides, muito parecido com o Krumo, mas um pouco mais eficaz em objetos. Eu queria adicionar a detecção de nome var e surgiu com isso, inspirado no post de Nick Presta nesta página. Ele detecta qualquer expressão passada como argumento, não apenas nomes de variáveis.

Essa é apenas a função do wrapper que detecta a expressão passada. Funciona na maioria dos casos. Não funcionará se você chamar a função mais de uma vez na mesma linha de código.

Isso funciona bem: die ( inspecione ($ this-> getUser () -> hasCredential ("excluir")) );

inspecionar () é a função que detectará a expressão passada.

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

}

Aqui está um exemplo da função do inspetor (e minha classe dInspect) em ação:

http://inspect.ip1.cc

Os textos estão em espanhol nessa página, mas o código é conciso e realmente fácil de entender.

Do php.net

@Alexandre - solução curta

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

@Lucas - use

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

Muitas respostas questionam a utilidade disso. No entanto, obter uma referência para uma variável pode ser muito útil. Especialmente em casos com objetos e $ this . Minha solução funciona com objetos e também como objetos definidos por propriedade:

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

Exemplo para o acima:

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

Adaptado das respostas acima para muitas variáveis, com bom desempenho, apenas uma varredura do $ GLOBALS para muitas

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 a variável for intercambiável, você deverá ter lógica em algum lugar para determinar qual variável será usada. Tudo o que você precisa fazer é colocar o nome da variável em$variable nessa lógica enquanto faz todo o resto.

Acho que todos estamos tendo dificuldades para entender o que você precisa disso. Código de amostra ou uma explicação sobre o que você está realmente tentando fazer pode ajudar, mas eu suspeito que você é maneira, maneira cismar isso.

Na verdade, tenho um caso de uso válido para isso.

Eu tenho uma função cacheVariable ($ var) (ok, eu tenho uma função de cache ($ key, $ value), mas eu gostaria de ter uma função conforme mencionado).

O objetivo é fazer:

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

...

// another session

...

$myColour = getCachedVariable('colour');

Eu tentei com

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
}

Eu também tentei com

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

Mas isso também falha ... :(

Claro, eu poderia continuar fazendo cache ('color', $ color), mas sou preguiçoso, você sabe ...;)

Então, o que eu quero é uma função que obtém o nome ORIGINAL de uma variável, pois foi passada para uma função. Dentro da função, não há como saber disso, ao que parece. Passar get_defined_vars () por referência no segundo exemplo acima me ajudou (obrigado a Jean-Jacques Guegan por essa ideia). A última função começou a funcionar, mas ainda continuava retornando a variável local ('variável', não 'cor').

Ainda não tentei usar get_func_args () e get_func_arg (), $ {} - constructos e key () combinados, mas presumo que ele também falhará.

Eu tenho isto:

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

Eu preferiria isso:

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

A função existente exibe uma caixa amarela com um contorno vermelho e mostra cada variável por nome e valor. A solução de matriz funciona, mas é um pouco complicada de digitar quando é necessária.

Esse é o meu caso de uso e, sim, tem a ver com a depuração. Eu concordo com aqueles que questionam seu uso de outra forma.

Aqui está minha solução baseada em Jeremy Ruten

class DebugHelper {

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

usando isso

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

Por que você simplesmente não cria uma função simples e a diz?

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

Eu estava procurando por isso, mas apenas decidi passar o nome, normalmente tenho o nome na área de transferência.

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

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

Você pode usar compact () para conseguir isso.

$FooBar = "a string";

$newArray = compact('FooBar');

Isso criaria uma matriz associativa com o nome da variável como chave. Em seguida, você pode percorrer a matriz usando o nome da chave onde for necessário.

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

Eu acho que você quer saber o nome da variável com o seu valor. Você pode usar uma matriz associativa para conseguir isso.

use nomes de variáveis ​​para chaves de matriz:

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

Quando você deseja obter nomes de variáveis, use array_keys($vars), ele retornará uma matriz desses nomes de variáveis ​​que foram usados ​​em sua $varsmatriz como chaves.

Eu sei que isso é antigo e já respondeu, mas eu estava realmente procurando por isso. Estou postando esta resposta para economizar um pouco de tempo para as pessoas refinarem algumas das respostas.

Opção 1:

$data = array('$FooBar');  

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

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

Impressões:

FooBar

Por qualquer motivo que você se encontre em uma situação como essa, ele realmente funciona.

.
Opção 2:

$FooBar = "a string";  

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

Se $FooBarpossuir um valor único, ele imprimirá 'FooBar'. E se$FooBar estiver vazio ou nulo, imprimirá o nome da primeira cadeia vazia ou nula que encontrar.

Pode ser usado como tal:

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

Foi assim que eu fiz

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: alguns PHP 7 versões não funcionará corretamente devido a um bug no array_searchcom $GLOBALS, no entanto todas as outras versões funcionará.

Veja este https://3v4l.org/UMW7V

Use isso para desanexar variáveis ​​do usuário de global para verificar variáveis ​​no 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 ; 
    }
}

Pode ser considerado rápido e sujo, mas minha preferência pessoal é usar uma função / método como este:

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

basicamente, apenas cria uma matriz associativa contendo um elemento nulo / vazio, usando como chave a variável para a qual você deseja o nome.

então obtemos o valor dessa chave usando array_keys e retornamos.

Obviamente, isso fica confuso rapidamente e não seria desejável em um ambiente de produção, mas funciona para o problema apresentado.

por que temos que usar globais para obter o nome da variável ... podemos usar simplesmente como abaixo.

    $variableName = "ajaxmint";

    echo getVarName('$variableName');

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

Eu realmente não consigo ver o caso de uso ... Se você digitar print_var_name ($ foobar), o que há de tão difícil (e diferente) em digitar print ("foobar")?

Porque, mesmo que você usasse isso em uma função, obteria o nome local da variável ...

De qualquer forma, aqui está o manual de reflexão , caso haja algo que você precisa.