2010-08-19 12 views

Respuesta

4

Su propósito, supongo, es permitir que los programadores novatos cambien datos dinámicamente sin usar "cosas complicadas" como tipos compuestos (matrices y objetos).

Nunca los uso.

+0

// permiten a los programadores novatos para cambiar dinámicamente los datos sin utilizar "cosas complicadas" como tipos compuestos (arrays y objetos) // No es complicado una vez que se ha aprendido. – dreftymac

+1

Creo que ese es el significado de las comillas. – user151841

+1

¿Cómo se votó esta votación tantas veces y se aceptó? – jasonszhao

1

Piense en ello para su uso en un sistema de plantillas en la que utiliza archivos PHP y la necesidad de establecer en las variables:

function fetch_template($file, $vars){ 
    $ret = 'File not loaded.'; 
    if(file_exists(TEMPLATE_PATH.$file)){ 
     //could do this with extract() but I am showing you 
     foreach($vars as $varName => $value){ 
      ${$varName} = $value; 
     } 
     ob_start(); 
     include(TEMPLATE_PATH.$file); 
     $ret = ob_get_contents(); 
     ob_end_clean(); 
    } 
    return $ret; 
} 

Ahora, suponiendo que utilizó estos nombres de variables en su plantilla, que se podría llamar y pase variables en él para su uso.

echo fetch_template('hi_there.tpl', array('name'=>'JJ')); 

Luego, en su plantilla:

Hello <?php echo $name; ?>! 
+0

Esto mismo se puede hacer con ['extract'] (http://ca.php.net/manual/en/function.extract.php) –

+2

Y ahora tiene un error' $ vars' tiene una clave '" archivo "'. Esta es la razón por la cual las variables variables (y 'extract', para el caso) son peligrosas. ¿Sería mucho más difícil usar algo como '$ m ['var']' en la plantilla? – Artefacto

+0

@Daniel: el ejemplo de código dice explícitamente que se puede hacer con extract(). Este fue un ejemplo. @Artefecto: esto no se produjo para demostrar la seguridad, sino el uso de variables variables. Nunca abogué por pasar variables ciegamente como cualquier cosa en la matriz $ _GET. – Jage

1

En lo personal, yo los utilizo bastante a menudo. Todas las llamadas de los siguientes tipos utilizan variables variables:

$foo->$bar = 'test'; 
$foo->$bar(); 
$bar(); 

Así que cada vez que hagas una llamada al método/función dinámica, que está utilizando variables variables ...

Un uso común para esto es acceder a propiedades protegidas a través del método mágico __get. He visto a la siguiente con bastante frecuencia:

public function __get($name) { 
    return isset($this->$name) ? $this->$name : null; 
} 

que por definición es el uso de variables variables para proporcionar a los miembros protected acceso de lectura y ...

nunca he utilizado directamente la sintaxis $$var (y no creo que lo haga nunca). Lo he visto utilizado para acceder a las variables globales por nombre global $$name; echo $$name;, pero lo mismo se puede hacer con la sintaxis $_GLOBALS[$name], por lo que no es un buen caso de uso (sin mencionar que el uso de variables globales suele considerarse una mala práctica).

+1

No son variables variables. Los métodos no son variables – Artefacto

+0

Aunque pueden ser (algo así) si esto sigue adelante: http://wiki.php.net/rfc/closures/object-extension#status_as_of_august_10_2010 – Artefacto

+0

Es una función variable. Tienes razón. Sin embargo, todavía funciona con el mismo principio (donde se desreferencia la variable para determinar la ruta de ejecución) ... – ircmaxell

1

Lo encontré útil en un único escenario. Estaba teniendo YouTube resultados de la API en formato JSON, como este

$obj->media$title => Video title 

Así lo utilicé como

$mt = 'media$title'; 
$obj->$mt ; 

por lo que funcionó para mí aquí :)

+0

Puedes hacer '$ obj -> {'media $ title'}'. – Artefacto

2

Una variable variable es básicamente un array (mapa/diccionario). Las siguientes son las ideas equivalentes:

<?php 
$foo = array('a' => 1); 
$bar = 'a'; 
echo $foo[$bar]."\n"; 

$foo_a = 1; 
$bar = 'a'; 
$vv = "foo_$bar"; 
echo $$vv."\n"; 
?> 

Por lo tanto, si usted envuelve sus "variables variables" en una matriz padre, puede acabar con ellos.

gente que he visto usan propiedades de las variables dentro de las clases:

<?php 
class Foo 
{ 
    private $a = 1; 

    public function __get($key) 
    { 
    if (isset($this->$key)) return $this->$key; 
    } 
} 

$foo = new Foo(); 
echo $foo->a; 
?> 

Pero, de nuevo, se puede utilizar una matriz:

<?php 
class Foo 
{ 
    private $props = array('a' => 1); 

    public function __get($key) 
    { 
    if (array_key_exists($key, $this->props)) 
     return $this->props[$key]; 
    } 
} 

$foo = new Foo(); 
echo $foo->a; 
?> 

Y fuera de las clases:

<?php 
class Foo 
{ 
    public $a = 1; 
} 

$foo = new Foo(); 
$prop = 'a'; 
echo $foo->{$prop}; 
?> 

Así nunca "tiene" que usar variables variables o propiedades de variables al escribir su propio código controlado. Mi preferencia personal es nunca usar variables variables. De vez en cuando uso propiedades de variables, pero prefiero usar matrices cuando voy a acceder a los datos de esa manera.

0

uso principalmente para reducir copiar y pegar en la desinfección de datos GET/POST en el inicio de un archivo PHP: Hace que las variables desinfectados con los nombres propios:

$fields=array('age','name','gender','email','username'); 

foreach($fields as $field) { 
    if (empty($_REQUEST[$field] === false) 
     ${$field} = sanitize($_REQUEST[$field]); 
    else 
     ${$field} = ''; 
} 

en lugar de todas estas líneas:

if (empty($_GET['age']) === false) 
    $age= sanitize($_GET['age']); 
else 
    $age= ''; 

if (empty($_GET['name']) === false) 
    $name= sanitize($_GET['name']); 
else 
    $name = ''; 

if (empty($_GET['gender']) === false) 
    $gender= sanitize($_GET['gender']); 
else 
    $gender= ''; 

if (empty($_GET['email']) === false) 
    $email= sanitize($_GET['email']); 
else 
    $email= ''; 

if (empty($_GET['username']) === false) 
    $username= sanitize($_GET['username']); 
else 
    $username= ''; 

espero que ayude

+0

¿Por qué no simplemente 'array_map'? – user151841

Cuestiones relacionadas