PHP'de değişken adı dize olarak nasıl alınır?

Diyelim ki bu PHP kodu var:

$FooBar = "a string";

sonra böyle bir fonksiyona ihtiyacım var:

print_var_name($FooBar);

hangi baskılar:

FooBar

Bunu başarmak için herhangi bir fikir? PHP'de bu mümkün mü?

Adını bulmaya çalıştığınız değerle aynı değere sahip bir değişkenin adını bulmak için get_defined_vars () yöntemini kullanabilirsiniz . Açıkçası bu her zaman işe yaramayacaktır, çünkü farklı değişkenler genellikle aynı değerlere sahiptir, ancak bunu yapmayı düşünebilmemin tek yolu budur.

Edit: get_defined_vars () düzgün çalışmıyor gibi görünüyor, $ var fonksiyonun kendisinde kullanıldığından 'var' döndürür. $ GLOBALS çalışıyor gibi gözüktüm.

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

    return false;
}

Düzenleme: net olmak gerekirse, muhtemelen bunu yapmak zorunda olmamalıdır çünkü PHP, bunu yapmak için iyi bir yolu yoktur. Muhtemelen yapmaya çalıştığınız şeyi yapmanın daha iyi yolları vardır.

Bunu da verimli bir şekilde yapmanın bir yolunu düşünemedim ama bunu buldum. Aşağıdaki sınırlı kullanımlar için çalışır.

omuz silkme

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

İşlevin geçtiği argümanı bulduğu fonksiyon olarak adlandırılan çizgiye göre çalışır. Sanırım birden fazla argümanla çalışmak için genişletilebilir, ancak diğerlerinin söylediği gibi, durumu daha iyi açıklayabilirseniz, başka bir çözüm muhtemelen daha iyi çalış.

Yaklaşımınızı değiştirmeyi ve değişken değişken adı kullanmayı düşünebilirsiniz.

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

o zaman sadece

print($var_name);

almak

FooBar

İşte Değişken değişkenler hakkındaki PHP kılavuzunun bağlantısı

Hiç kimse bunun a) zor ve b) akılsız olmasının temel nedenlerinden bahsetmemiş gibi görünüyor :

• "Değişken" yalnızca başka bir şeye işaret eden bir semboldür. PHP, bu içten bir şeye işaret onlar aynı değere sahip olduğundan ya (PHP uygular şey denilen, aslında aynı anda birden fazla değişkenler için kullanılabilecek bir "zval" olarak adlandırılan "kopya üzerinde yazma" böylece $foo = $bargerekmez ek belleği hemen ayırın) veya referans olarak atanmış (veya bir işleve iletilmiş $foo =& $bar) (ör. ). Yani zval'in adı yok.
• Bir işleve bir parametre ilettiğinizde yeni bir değişken oluşturursunuz (bu bir referans olsa bile). Anonim bir şey aktarabilirsiniz "hello", ancak, bir kez işlevinizin içine, adını verdiğiniz değişken ne olursa olsun. Bu kod ayrılık oldukça esastır: bir işlev değişken itibar etseydim kullanılan çağrılacak, daha çok bir gibi olurdu gotodüzgün ayrı fonksiyonu daha.
• Global değişkenler genellikle kötü bir fikir olarak kabul edilir. Buradaki örneklerin çoğu, "yansıtmak" istediğiniz değişkenin bulunabileceğini varsayar $GLOBALS, ancak bu yalnızca kodunuzu kötü yapılandırdıysanız ve değişkenler bir işlev veya nesneye dahil edilmediğinde geçerli olacaktır.
• Değişken isimleri programcıların kodlarını okumalarına yardımcı olmak için vardır. Değişkenleri amaçlarına daha iyi uyacak şekilde yeniden adlandırmak çok yaygın bir yeniden düzenleme uygulamasıdır ve asıl mesele herhangi bir fark yaratmamasıdır.

Şimdi, bunun hata ayıklama isteğini anlıyorum (önerilen kullanımların bazıları bunun ötesine geçmesine rağmen), ancak genelleştirilmiş bir çözüm olarak aslında düşündüğünüz kadar yararlı değil: hata ayıklama işleviniz değişkeninize "$ file denirse ", kodunuzdaki düzinelerce" $ file "değişkeninden herhangi biri veya" $ dosyaadı "olarak adlandırdığınız ancak parametresi" $ file "olarak adlandırılan bir işleve iletilen bir değişken olabilir.

Çok daha kullanışlı bir bilgi, kodunuzda hata ayıklama işlevinin nereden çağrıldığıdır. Bunu düzenleyicinizde hızlı bir şekilde bulabildiğiniz için, hangi değişkeni kendiniz için çıktı aldığınızı görebilir ve hatta tüm ifadeleri tek seferde ona aktarabilirsiniz (örn. debug('$foo + $bar = ' . ($foo + $bar))).

Bunun için hata ayıklama işlevinizin üst kısmında bu snippet'i kullanabilirsiniz:

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

Bu tam olarak istediğiniz şeydir - verilen bir varlığın adını yansıtan kullanıma hazır bir "kopyala ve bırak" işlevi:

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

KULLANIM: print_var_name ($ FooBar)

BASKI: FooBar

İPUCU Artık işlevi yeniden adlandırabilirsiniz ve yine de çalışır ve işlevi bir satırda birkaç kez kullanır! @Cliffordlife sayesinde

PHP.net üzerindeki Lucas, bir değişken olup olmadığını kontrol etmek için güvenilir bir yol sağlamıştır. Örneğinde, değişkenlerin genel değişken dizisinin (veya kapsamlandırılmış dizisinin) bir kopyasını yineler, değeri rastgele oluşturulan bir değere değiştirir ve kopyalanan dizide oluşturulan değeri denetler.

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

O zaman dene:

$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'teki yayınını kontrol ettiğinizden emin olun: http://php.net/manual/en/language.variables.php

Hata ayıklama nedenleriyle bir inceleme işlevi yaptım. Steroidlerde print_r () gibidir, Krumo'ya çok benzer, ancak nesneler üzerinde biraz daha etkilidir. Var ad algılamasını eklemek istedim ve Nick Presta'nın bu sayfadaki gönderisinden esinlenerek çıktı. Yalnızca değişken adları değil, bağımsız değişken olarak iletilen herhangi bir ifadeyi algılar.

Bu yalnızca iletilen ifadeyi algılayan sarmalayıcı işlevidir. Vakaların çoğunda çalışır. İşlevi aynı kod satırında bir kereden fazla çağırırsanız çalışmaz.

Bu iyi çalışıyor: ölmek ( inceleyin ($ This-> GetUser () -> hasCredential ( "delete")) );

inspect (), iletilen ifadeyi algılayacak işlevdir.

Şunu elde ediyoruz: $ 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);

}

İşte müfettiş işlevinin (ve benim dInspect sınıfım) bir örneği:

http://inspect.ip1.cc

Metinler bu sayfada İspanyolca, ancak kod özlü ve anlaşılması gerçekten kolay.

itibaren php.net

@Alexandre - kısa çözüm

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

@Lucas - kullanım

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

Birçok yanıt, bunun yararlılığını sorgulamaktadır. Bununla birlikte, bir değişken için referans almak çok faydalı olabilir. Özellikle nesneler ve $ $ olan durumlarda . Çözümüm nesnelerle ve özellik tanımlı nesneler olarak da çalışır:

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

Yukarıdakilere örnek:

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

Birçok değişken için yukarıdaki yanıtlardan uyarlanmış, iyi performansla, birçokları için sadece bir $ GLOBALS tarama

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
        )

)

Değişken değiştirilebilir ise, hangi değişkenin kullanılacağını belirleyen bir yerde mantığınız olmalıdır . Tek yapmanız gereken değişken ismini koymak$variable diğer her şeyi yaparken bu mantığın .

Sanırım hepimiz bunun için neye ihtiyacınız olduğunu anlamakta zorlanıyoruz. Örnek kod veya aslında çalıştığınız şeyin bir açıklama yapmak kudreti yardıma, ama sana şeklin şüpheli yolu bu overthinking.

Aslında bunun için geçerli bir kullanım durumum var.

Bir işlev cacheVariable ($ var) var (Tamam, bir işlev önbelleği var ($ anahtar, $ değeri), ama belirtildiği gibi bir işlevi var istiyorum).

Amaç:

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

...

// another session

...

$myColour = getCachedVariable('colour');

İle denedim

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
}

Ben de denedim

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

Ama bu da başarısız oluyor ... :(

Tabii, önbellek yapmaya devam edebilirim ('renk', $ renk), ama tembelim, biliyorsun ...;)

Yani, istediğim bir işleve geçirildiği gibi bir değişken ORİJİNAL adını alır bir işlevdir. Fonksiyonun içinde göründüğü gibi bilmem mümkün değil. Yukarıdaki ikinci örnekte referans olarak get_defined_vars () iletmek bana yardımcı oldu (bu fikir için Jean-Jacques Guegan'a teşekkürler). İkinci işlev çalışmaya başladı, ancak yine de yalnızca yerel değişkeni döndürmeye devam etti ('renk' değil, 'değişken').

Ben get_func_args () ve get_func_arg (), $ {} - yapıları ve key () kombine kullanmak için henüz denemedim, ama aynı zamanda başarısız olacağını varsayıyorum.

Bu bende var:

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

Bunu tercih ederim:

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

Mevcut işlev, kırmızı anahatlı sarı bir kutu görüntüler ve her değişkeni ada ve değere göre gösterir. Dizi çözümü çalışır, ancak gerektiğinde yazmak için biraz kıvrıktır.

Bu benim kullanım durumum ve evet, hata ayıklama ile ilgili. Aksi takdirde kullanımını sorgulayanlara katılıyorum.

İşte benim çözüm dayalı Jeremy Ruten

class DebugHelper {

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

onu kullanarak

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

Neden basit bir fonksiyon oluşturup anlatmıyorsunuz?

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

Bunu arıyordum ama sadece adı geçmeye karar verdim, genellikle panoda adı zaten var.

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

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

Bunu başarmak için compact () kullanabilirsiniz.

$FooBar = "a string";

$newArray = compact('FooBar');

Bu, anahtar olarak değişken adıyla ilişkilendirilebilir bir dizi oluşturur. Daha sonra, ihtiyacınız olan anahtar adını kullanarak dizi arasında geçiş yapabilirsiniz.

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

Değişken adını değeriyle bilmek istediğinizi düşünüyorum. Bunu başarmak için ilişkilendirilebilir bir dizi kullanabilirsiniz.

dizi anahtarları için değişken adları kullanın:

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

Değişken adları almak istediğinizde, kullanın array_keys($vars), $varsdizinizde anahtar olarak kullanılan değişken adlarının bir dizisini döndürür .

Bunun eski olduğunu ve zaten cevaplandığını biliyorum ama aslında bunu arıyordum. Bu cevabı, bazı cevapları iyileştirmek için biraz zaman kazanmak için gönderiyorum.

Seçenek 1:

$data = array('$FooBar');  

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

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

Baskılar:

filanca

Herhangi bir nedenle kendinizi böyle bir durumda bulursanız, aslında işe yarıyor.

.
Seçenek 2:

$FooBar = "a string";  

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

$FooBarBenzersiz bir değere sahipse , 'FooBar' yazdıracaktır. $FooBarBoş veya null olursa , bulduğu ilk boş veya null dizenin adını yazdırır.

Bu şekilde kullanılabilir:

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

Ben böyle yaptım

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

kullanım

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

Not: Bazı PHP 7 sürümleri içinde bir hata nedeniyle düzgün çalışmaz array_searchile $GLOBALSancak tüm diğer sürümleri çalışacaktır.

Bkz. Https://3v4l.org/UMW7V

Şu anda değişkeni kontrol etmek için kullanıcı değişkenlerini globalden ayırmak için bunu kullanın.

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

Hızlı ve kirli olarak kabul edilebilir, ancak kendi kişisel tercihim böyle bir işlev / yöntem kullanmaktır:

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

temelde sadece adını istediğiniz değişkeni bir anahtar olarak kullanarak bir null / boş eleman içeren bir ilişkisel dizi oluşturur.

sonra dizi_anahtarlarını kullanarak o anahtarın değerini alırız ve geri veririz.

Açıkçası bu çok çabuk dağınık hale gelir ve bir üretim ortamında arzu edilmez, ancak sunulan sorun için işe yarar.

neden değişken ismi almak için globalleri kullanmak zorundayız ... aşağıdaki gibi kullanabiliriz.

    $variableName = "ajaxmint";

    echo getVarName('$variableName');

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

Gerçekten kullanım durumunu göremiyorum ... print_var_name ($ foobar) yazacaksanız bunun yerine print ("foobar") yazmanın ne kadar zor (ve farklı) olduğunu?

Çünkü bunu bir işlevde kullansanız bile, değişkenin yerel adını alırsınız ...

Her durumda, burada ihtiyacınız olan bir şey olması durumunda yansıma kılavuzu .