As vezes, é conveniente possuir nome variáveis para variáveis. Isto é, o nome de uma variável que pode ser definido e utilizado dinamicamente. Uma variável normal é definida com uma instrução como:
<?php
$a = 'hello';
?>Uma variável variável obtém o valor de uma variável e a trata como o nome de uma variável. No exemplo acima, hello pode ser utilizado como o nome de uma variável utilizando dois sinais de cifrão:
<?php
$$a = "world";
?>Neste ponto, duas variáveis foram definidas e armazenadas na árvore de símbolos do PHP: $a que contém "hello" e $hello que contém "world". Assim, esta instrução:
<?php
echo "$a {$$a}";
?>produz a mesma saída que:
<?php
echo "$a $hello";
?>assim sendo, as duas produzem: hello world.
Para poder utilizar variáveis variáveis com arrays, é necessário
resolver um problema de ambiguidade. Isso é, se for escrito
$$a[1], o interpretador precisa saber se a
intenção é utilizar $a[1] como uma variável ou se
a intenção é usar $$a como uma variável e [1]
como o índice dessa variável. A sintaxe para resolver essa ambiguidade
é ${$a[1]} para o primeiro caso e
${$a}[1] para o segundo.
Propriedades de classes também podem ser acessadas utilizando-se nomes de propriedades variáveis. O nome de propriedade variável será resolvido dentro do escopo em que a chamada foi feita. Por exemplo, se houver uma expressão como $foo->$bar, o escopo local será examinado procurando por $bar e seu valor será utilizado como o nome da propriedade $foo. Isso também funciona se $bar for um array.
Chaves também podem ser utilizadas para delimitar claramente os nomes de propriedade. São muito úteis ao acessar valores de uma propriedade que contenham um array, quando o nome da propriedade tem várias partes, ou quando o nome da propriedade contém caracteres que não são válidos (por exemplo, em saídas da função json_decode() ou SimpleXML).
Exemplo #1 Exemplo de propriedade variável
<?php
class Foo {
public $bar = 'Eu sou bar.';
public $arr = ['Eu sou A.', 'Eu sou B.', 'Eu sou C.'];
public $r = 'Eu sou r.';
}
$foo = new Foo();
$bar = 'bar';
$baz = ['foo', 'bar', 'baz', 'quux'];
echo $foo->$bar . "\n";
echo $foo->{$baz[1]} . "\n";
$start = 'b';
$end = 'ar';
echo $foo->{$start . $end} . "\n";
$arr = 'arr';
echo $foo->{$arr[1]} . "\n";
echo $foo->{$arr}[1] . "\n";
?>O exemplo acima produzirá:
Observe que variáveis variáveis não podem ser utilizadas nos
arrays superglobais
dentro de funções ou métodos de classe. A variável $this
também é uma variável especial que não pode ser referenciada dinamicamente.
<?php
//You can even add more Dollar Signs
$Bar = "a";
$Foo = "Bar";
$World = "Foo";
$Hello = "World";
$a = "Hello";
$a; //Returns Hello
$$a; //Returns World
$$$a; //Returns Foo
$$$$a; //Returns Bar
$$$$$a; //Returns a
$$$$$$a; //Returns Hello
$$$$$$$a; //Returns World
//... and so on ...//
?>In addition, it is possible to use associative array to secure name of variables available to be used within a function (or class / not tested).
This way the variable variable feature is useful to validate variables; define, output and manage only within the function that receives as parameter
an associative array :
array('index'=>'value','index'=>'value');
index = reference to variable to be used within function
value = name of the variable to be used within function
<?php
$vars = ['id'=>'user_id','email'=>'user_email'];
validateVarsFunction($vars);
function validateVarsFunction($vars){
//$vars['id']=34; <- does not work
// define allowed variables
$user_id=21;
$user_email='email@mail.com';
echo $vars['id']; // prints name of variable: user_id
echo ${$vars['id']}; // prints 21
echo 'Email: '.${$vars['email']}; // print email@mail.com
// we don't have the name of the variables before declaring them inside the function
}
?>It may be worth specifically noting, if variable names follow some kind of "template," they can be referenced like this:
<?php
// Given these variables ...
$nameTypes = array("first", "last", "company");
$name_first = "John";
$name_last = "Doe";
$name_company = "PHP.net";
// Then this loop is ...
foreach($nameTypes as $type)
print ${"name_$type"} . "\n";
// ... equivalent to this print statement.
print "$name_first\n$name_last\n$name_company\n";
?>
This is apparent from the notes others have left, but is not explicitly stated.The feature of variable variable names is welcome, but it should be avoided when possible. Modern IDE software fails to interpret such variables correctly, regular find/replace also fails. It's a kind of magic :) This may really make it hard to refactor code. Imagine you want to rename variable $username to $userName and try to find all occurrences of $username in code by checking "$userName". You may easily omit:
$a = 'username';
echo $$a;If you want to use a variable value in part of the name of a variable variable (not the whole name itself), you can do like the following:
<?php
$price_for_monday = 10;
$price_for_tuesday = 20;
$price_for_wednesday = 30;
$today = 'tuesday';
$price_for_today = ${ 'price_for_' . $today};
echo $price_for_today; // will return 20
?>One interesting thing I found out: You can concatenate variables and use spaces. Concatenating constants and function calls are also possible.
<?php
define('ONE', 1);
function one() {
return 1;
}
$one = 1;
${"foo$one"} = 'foo';
echo $foo1; // foo
${'foo' . ONE} = 'bar';
echo $foo1; // bar
${'foo' . one()} = 'baz';
echo $foo1; // baz
?>
This syntax doesn't work for functions:
<?php
$foo = 'info';
{"php$foo"}(); // Parse error
// You'll have to do:
$func = "php$foo";
$func();
?>
Note: Don't leave out the quotes on strings inside the curly braces, PHP won't handle that graciously.While not relevant in everyday PHP programming, it seems to be possible to insert whitespace and comments between the dollar signs of a variable variable. All three comment styles work. This information becomes relevant when writing a parser, tokenizer or something else that operates on PHP syntax.
<?php
$foo = 'bar';
$
/*
I am complete legal and will compile without notices or error as a variable variable.
*/
$foo = 'magic';
echo $bar; // Outputs magic.
?>
Behaviour tested with PHP Version 5.6.19PHP actually supports invoking a new instance of a class using a variable class name since at least version 5.2
<?php
class Foo {
public function hello() {
echo 'Hello world!';
}
}
$my_foo = 'Foo';
$a = new $my_foo();
$a->hello(); //prints 'Hello world!'
?>
Additionally, you can access static methods and properties using variable class names, but only since PHP 5.3
<?php
class Foo {
public static function hello() {
echo 'Hello world!';
}
}
$my_foo = 'Foo';
$my_foo::hello(); //prints 'Hello world!'
?>Variable Class Instantiation with Namespace Gotcha:
Say you have a class you'd like to instantiate via a variable (with a string value of the Class name)
<?php
class Foo
{
public function __construct()
{
echo "I'm a real class!" . PHP_EOL;
}
}
$class = 'Foo';
$instance = new $class;
?>
The above works fine UNLESS you are in a (defined) namespace. Then you must provide the full namespaced identifier of the class as shown below. This is the case EVEN THOUGH the instancing happens in the same namespace. Instancing a class normally (not through a variable) does not require the namespace. This seems to establish the pattern that if you are using an namespace and you have a class name in a string, you must provide the namespace with the class for the PHP engine to correctly resolve (other cases: class_exists(), interface_exists(), etc.)
<?php
namespace MyNamespace;
class Foo
{
public function __construct()
{
echo "I'm a real class!" . PHP_EOL;
}
}
$class = 'MyNamespace\Foo';
$instance = new $class;
?>These are the scenarios that you may run into trying to reference superglobals dynamically. Whether or not it works appears to be dependent upon the current scope.
<?php
$_POST['asdf'] = 'something';
function test() {
// NULL -- not what initially expected
$string = '_POST';
var_dump(${$string});
// Works as expected
var_dump(${'_POST'});
// Works as expected
global ${$string};
var_dump(${$string});
}
// Works as expected
$string = '_POST';
var_dump(${$string});
test();
?>