说我有这个PHP代码：
$FooBar = "a string";
然后我需要这样的功能：
print_var_name($FooBar);
打印：
FooBar
任何想法如何实现这一目标？这在PHP中甚至可能吗？
答案 0 :(得分：42)
我想不出有效地做到这一点的方法，但我想出了这个。它适用于下面的有限用途。
耸肩
<?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
)
它基于调用函数的行来工作，它在那里找到你传入的参数。我想它可以扩展为使用多个参数但是，就像其他人说的那样，如果你能更好地解释这个情况，另一个解决方案可能会更好。
答案 1 :(得分：35)
您可以使用get_defined_vars()查找与您尝试查找名称的变量名称相同的变量名称。显然这并不总是有效，因为不同的变量通常具有相同的值，但这是我能想到的唯一方法。
编辑：get_defined_vars（）似乎没有正常工作，它返回'var'，因为$ var在函数本身中使用。 $ GLOBALS似乎有效，所以我把它改成了。
function print_var_name($var) {
foreach($GLOBALS as $var_name => $value) {
if ($value === $var) {
return $var_name;
}
}
return false;
}
编辑：要清楚，在PHP中没有好办法，这可能是因为你不应该这样做。可能有更好的方法来做你想做的事。
答案 2 :(得分：26)
您可以考虑更改方法并使用变量名称吗？
$var_name = "FooBar";
$$var_name = "a string";
然后你可以
print($var_name);
获取
FooBar
答案 3 :(得分：18)
似乎没有人提到为什么这是a）硬性和b）不明智的根本原因：
$foo = $bar不需要直接分配额外的内存）或者因为它们已经通过引用分配（或传递给函数）（例如$foo =& $bar）。所以zval没有名字。"hello"，但是一旦进入你的函数，它就是你命名的变量。这对于代码分离来说是相当基础的：如果函数依赖于调用使用的变量，那么它将更像是goto而不是正确分离的函数。$GLOBALS中找到，但只有在您的代码结构严重且变量没有作用于某个函数或对象。现在，我理解这种调试的愿望（尽管一些提议的用法远不止于此），但作为一种通用的解决方案，它实际上并不像你想象的那样有用：如果你的调试函数说你的变量被调用了“$ file”，可能仍然是代码中的几十个“$ file”变量中的任何一个，或者是一个名为“$ filename”的变量，但是传递给一个参数名为“$ file”的函数。 / p>
更有用的信息是在代码中调用调试函数的位置。由于您可以在编辑器中快速找到它，因此您可以查看自己输出的变量，甚至可以一次性将整个表达式传递给它（例如debug('$foo + $bar = ' . ($foo + $bar))）。
为此，您可以在调试功能的顶部使用此代码段：
$backtrace = debug_backtrace();
echo '# Debug function called from ' . $backtrace[0]['file'] . ' at line ' . $backtrace[0]['line'];
答案 4 :(得分：13)
我出于调试原因制作了检查功能。它就像类固醇上的print_r（），就像Krumo一样，但对物体更有效。我想添加var名称检测，并在此页面上受到Nick Presta帖子的启发。它会检测作为参数传递的任何表达式，而不仅仅是变量名称。
这只是检测传递表达式的包装函数。 适用于大多数情况。 如果您在同一行代码中多次调用该函数，它将无法工作。
这很好用： 死亡（的检查（ $这 - ＆GT;的getUser（） - ＆GT; hasCredential（ “删除”）的 <强>））;
inspect（）是检测传递表达式的函数。
我们得到： $ this-＆gt; getUser（） - ＆gt; 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);
}
以下是检查函数（和我的dInspect类）的实例：
该页面中的文本是西班牙文，但代码简洁，易于理解。
答案 5 :(得分：10)
PHP.net上的Lucas提供了一种检查变量是否存在的可靠方法。在他的示例中，他遍历变量的全局变量数组（或范围数组）的副本，将值更改为随机生成的值，并检查复制的数组中生成的值。
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;
}
然后尝试：
$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
请务必在PHP.net上查看他的帖子：http://php.net/manual/en/language.variables.php
答案 6 :(得分：8)
这正是你想要的 - 它可以随时使用＆＃34;复制和放入＆＃34;回显给定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);
}
USAGE：print_var_name（$ FooBar）
打印：FooBar
<强> HINT 现在您可以重命名该功能，它仍然可以工作，并且可以在一行中多次使用该功能！感谢@Cliffordlife
答案 7 :(得分：5)
来自php.net
@Alexandre - 简短解决方案
<?php
function vname(&$var, $scope=0)
{
$old = $var;
if (($key = array_search($var = 'unique'.rand().'value', !$scope ? $GLOBALS : $scope)) && $var = $old) return $key;
}
?>
@Lucas - 用法
<?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
?>
答案 8 :(得分：4)
许多回复质疑这一点的用处。但是，获取变量的引用可能非常有用。特别是在包含对象和 $ this 的情况下。我的解决方案适用于对象，也适用于属性定义的对象：
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}";
}
上述示例：
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
答案 9 :(得分：2)
根据上面的答案改编了许多变量，性能良好，只有一个$ GLOBALS扫描很多
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
)
)
答案 10 :(得分：1)
我有这个：
debug_echo(array('$query'=>$query, '$nrUsers'=>$nrUsers, '$hdr'=>$hdr));
我更喜欢这个：
debug_echo($query, $nrUsers, $hdr);
现有功能显示带有红色轮廓的黄色框，并按名称和值显示每个变量。阵列解决方案可以工作，但在需要时可以进行输入。
这是我的用例，是的，它确实与调试有关。我同意那些质疑其用法的人。
答案 11 :(得分：1)
我实际上有一个有效的用例。
我有一个函数cacheVariable（$ var）（好吧，我有一个函数缓存（$ key，$ value），但是我想要一个如上所述的函数。）
目的是：
$colour = 'blue';
cacheVariable($colour);
...
// another session
...
$myColour = getCachedVariable('colour');
我试过
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
}
我也试过
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));
}
但这也失败了...... :(
当然，我可以继续做缓存（'颜色'，$ color），但我很懒，你知道......;）
所以，我想要的是一个函数，它获取变量的ORIGINAL名称，因为它被传递给一个函数。在功能内部，我似乎无法知道这一点。在上面的第二个例子中通过引用传递get_defined_vars（）帮助了我（感谢Jean-Jacques Guegan的那个想法）。后一个函数开始工作，但它仍然只保留返回局部变量（'变量'，而不是'颜色'）。
我还没有尝试过使用get_func_args（）和get_func_arg（），$ {} - constructs和key（）组合，但我认为它也会失败。
答案 12 :(得分：1)
如果变量是可互换的，则必须具有逻辑某处，以确定使用哪个变量。您需要做的就是在执行其他所有操作时将变量名称放在$variable中。
我认为我们很难理解你需要的东西。示例代码或您实际尝试做的解释可能会有所帮助，但我怀疑您的方式，方式过度思考。
答案 13 :(得分：1)
这是我做到的方式
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;
}
用法
$city = "San Francisco";
echo getVar($city); // city
注意：由于array_search与$GLOBALS中的错误，某些PHP 7版本无法正常工作，但是所有其他版本都可以工作。
答案 14 :(得分：1)
PHP 中没有预定义的函数可以输出变量的名称。但是，您可以使用 get_defined_vars() 的结果，它返回作用域中定义的所有变量，包括名称和值。下面是一个例子：
<?php
// Function for determining the name of a variable
function getVarName(&$var, $definedVars=null) {
$definedVars = (!is_array($definedVars) ? $GLOBALS : $definedVars);
$val = $var;
$rand = 1;
while (in_array($rand, $definedVars, true)) {
$rand = md5(mt_rand(10000, 1000000));
}
$var = $rand;
foreach ($definedVars as $dvName=>$dvVal) {
if ($dvVal === $rand) {
$var = $val;
return $dvName;
}
}
return null;
}
// the name of $a is to be determined.
$a = 1;
// Determine the name of $a
echo getVarName($a);
?>
答案 15 :(得分：0)
为什么不构建一个简单的函数并告诉它呢？
/**
* 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' );
答案 16 :(得分：0)
以下是基于Jeremy Ruten
class DebugHelper {
function printVarNames($systemDefinedVars, $varNames) {
foreach ($systemDefinedVars as $var=>$value) {
if (in_array($var, $varNames )) {
var_dump($var);
var_dump($value);
}
}
}
}
使用它
DebugHelper::printVarNames(
$systemDefinedVars = get_defined_vars(),
$varNames=array('yourVar00', 'yourVar01')
);
答案 17 :(得分：0)
我一直在寻找这个，但只是决定将名字传递给我，我通常在剪贴板中都有这个名字。
function VarTest($my_var,$my_var_name){
echo '$'.$my_var_name.': '.$my_var.'<br />';
}
$fruit='apple';
VarTest($fruit,'fruit');
答案 18 :(得分：0)
您可以使用compact（）来实现此目的。
$FooBar = "a string";
$newArray = compact('FooBar');
这将创建一个以变量名作为键的关联数组。然后，您可以使用您需要的密钥名称遍历数组。
foreach($newarray as $key => $value) {
echo $key;
}
答案 19 :(得分：0)
我想你想知道变量名的价值。您可以使用关联数组来实现此目的。
为数组键使用变量名：
$vars = array('FooBar' => 'a string');
如果要获取变量名称，请使用array_keys($vars)，它会返回$vars数组中使用的变量名称数组作为其键。
答案 20 :(得分：0)
我知道这是旧的并且已经回答了，但是我实际上正在寻找这个。我发布此答案是为了节省人们一些时间来完善一些答案。
选项1：
$data = array('$FooBar');
$vars = [];
$vars = preg_replace('/^\\$/', '', $data);
$varname = key(compact($vars));
echo $varname;
打印：
FooBar
无论出于何种原因，您都会发现自己处于这种情况，它确实起作用。
。
选项2：
$FooBar = "a string";
$varname = trim(array_search($FooBar, $GLOBALS), " \t.");
echo $varname;
如果$FooBar拥有唯一值，它将打印'FooBar'。如果$FooBar为空或null，它将打印找到的第一个空或null字符串的名称。
它可以这样使用：
if (isset($FooBar) && !is_null($FooBar) && !empty($FooBar)) {
$FooBar = "a string";
$varname = trim(array_search($FooBar, $GLOBALS), " \t.");
}
答案 21 :(得分：-1)
此时使用此选项可将用户变量从全局分离到检查变量。
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 ;
}
}
答案 22 :(得分：-2)
它可能被认为是快速和肮脏的，但我个人的偏好是使用这样的功能/方法：
public function getVarName($var) {
$tmp = array($var => '');
$keys = array_keys($tmp);
return trim($keys[0]);
}
基本上它只是创建一个包含一个null / empty元素的关联数组，使用你想要名称的变量作为键。
然后我们使用array_keys获取该键的值并返回它。
显然，这会很快变得混乱，在生产环境中不可取，但它适用于所提出的问题。答案 23 :(得分：-3)
为什么我们必须使用全局变量来获取变量名...我们可以像下面一样使用。
$variableName = "ajaxmint";
echo getVarName('$variableName');
function getVarName($name) {
return str_replace('$','',$name);
}
答案 24 :(得分：-4)
我真的没有看到用例...如果你输入print_var_name（$ foobar），那么输入print（“foobar”）会有什么困难（和不同）？
因为即使你在函数中使用它，你也会得到变量的本地名称......
无论如何，这里是reflection manual，以防你需要的东西。