variables.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<!-- EN-Revision: 22583751fbfdaa3eaa41aeb6470d1343f5cb2c78 Maintainer: Marqitos Status: ready -->
<!-- Reviewed: no Maintainer: andresdzphp -->
 <chapter xml:id="language.variables" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
  <title>Variables</title>

  <sect1 xml:id="language.variables.basics">
   <title>Conceptos básicos</title>

   <simpara>
    En PHP las variables se representan con un signo de dólar seguido por el
    nombre de la variable. El nombre de la variable es sensible a minúsculas y mayúsculas.
   </simpara>

   <para>
    Un nombre de variable válido tiene que empezar con una letra
    (<literal>A-Z</literal>, <literal>a-z</literal>, o los bytes del 128 al 255)
    o un carácter de subrayado (underscore), seguido
    de cualquier número de letras, números y caracteres de subrayado. Como 
    expresión regular se podría expresar como:
    <code>^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$</code>
   </para>

   <note>
    <simpara>
     PHP no soporta Unicode en el nombre de las variables, sin embargo, algunas codificaciones
     de caracteres (como UTF-8) codifican caracteres de tal manera que todos los bytes
     de un carácter multibyte están dentro del rango permitido, convirtiéndolo así
     en un nombre de variable válido.
    </simpara>
   </note>

   <note>
    <simpara>
     <literal>$this</literal> es una variable especial que no puede ser
     asignada.
     Antes de PHP 7.1.0, era posible la asignación indirecta (por ejemplo,
     mediante el uso de <link linkend="language.variables.variable">variables variables</link>).
    </simpara>
   </note>

   &tip.userlandnaming;

   <example>
    <title>Valid variable names</title>
    <programlisting role="php">
<![CDATA[
<?php
$var = 'Roberto';
$Var = 'Juan';
echo "$var, $Var";      // Imprime "Roberto, Juan"

$_4site = 'aún no';     // Válido; comienza con un carácter de subrayado
$täyte = 'mansikka';    // Válido; 'ä' es ASCII (Extendido) 228
?>
]]>
    </programlisting>
   </example>

   <example>
    <title>Invalid variable names</title>
    <programlisting role="php">
<![CDATA[
<?php
$4site = 'aún no';     // Inválido; comienza con un número
]]>
    </programlisting>
   </example>

   <simpara>
    PHP acepta una secuencia de bytes como nombre de variable. Los nombres de
    variables que no siguen las reglas de nombres mencionadas anteriormente
    solo pueden accederse de forma dinámica en tiempo de ejecución. Consulte
    <link linkend="language.variables.variable">variables variables</link>
    para obtener información sobre cómo acceder a ellas.
   </simpara>

   <example>
    <title>Cómo acceder a nombres de variables con caracteres no válidos</title>
    <programlisting role="php">
<![CDATA[
<?php
${'invalid-name'} = 'bar';
$name = 'invalid-name';
echo ${'invalid-name'}, " ", $$name;
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
bar bar
]]>
    </screen>
   </example>

   <para>
    Por omisión, las variables siempre se asignan por valor. Esto
    significa que cuando se asigna una expresión a una variable, el valor
    completo de la expresión original se copia en la variable de destino.
    Esto quiere decir que, por ejemplo, después de asignar el valor de una
    variable a otra, los cambios que se efectúen a una de esas variables no
    afectará a la otra. Para más información sobre este tipo de asignación,
    vea  el capítulo sobre <link linkend="language.expressions">Expresiones</link>.
   </para>
   <para>
    PHP también ofrece otra forma de asignar valores a las variables:
    <link linkend="language.references">asignar por referencia</link>. Esto
    significa que la nueva variable simplemente referencia (en otras
    palabras, "se convierte en un alias de" ó "apunta a") la variable
    original. Los cambios a la nueva variable afectan a la original, y
    viceversa.
   </para>
   <para>
    Para asignar por referencia, simplemente se antepone un signo ampersand
    (&amp;) al comienzo de la variable cuyo valor se está asignando (la
    variable fuente). Por ejemplo, el siguiente segmento de código produce la
    salida '<literal>Mi nombre es Bob</literal>' dos veces:

    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$foo = 'Bob';                // Asigna el valor 'Bob' a $foo
$bar = &$foo;                // Referenciar $foo vía $bar.
$bar = "Mi nombre es $bar";  // Modifica $bar...
echo $bar;
echo $foo;                   // $foo también se modifica.
?>
]]>
     </programlisting>
    </informalexample>
   </para>

   <para>
    Algo importante a tener en cuenta es que sólo las variables con nombre
    pueden ser asignadas por referencia.
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$foo = 25;
$bar = &$foo;      // Esta es una asignación válida.
$bar = &(24 * 7);  // Inválida; referencia una expresión sin nombre.

function test()
{
   return 25;
}

$bar = &test();    // Inválido porque test() no devuelve una variable por referencia.
?>
]]>
     </programlisting>
    </informalexample>
   </para>
   
   <para>
    No es necesario inicializar variables en PHP, sin embargo, es una muy buena práctica.
    El acceso a una variable no definida generará un <constant>E_WARNING</constant>
    (en versiones anteriores a PHP 8.0.0, <constant>E_NOTICE</constant>).
    Una variable no definida tiene un valor predeterminado de &null;.
    Se puede utilizar la construcción del lenguaje <function>isset</function>
    para detectar si una variable ya se ha inicializado.
   </para>
   <para>
    <example>
     <title>Valores predeterminados en variables sin inicializar</title>
     <programlisting role="php">
<![CDATA[
<?php
// Una variable no definida Y no referenciada (sin contexto de uso).
var_dump($variable_indefinida);
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
Warning: Undefined variable $unset_var in ...
NULL
]]>
     </screen>
    </example>
   </para>

   <simpara>
    PHP permite la autovivificación de array (creación automática de un nuevo array)
    a partir de una variable no definida.
    Añadidiendo un elemento a una variable no definida creará un nuevo array y
    no producirá ninguna advertencia.
   </simpara>
   <example>
    <title>Autovivification de un array a partir de una variable no definida</title>
    <programlisting role="php">
<![CDATA[
<?php
$unset_array[] = 'valor'; // No producirá ninguna advertencia.
?>
]]>
    </programlisting>
   </example>

   <warning>
    <simpara>
     Depender del valor predeterminado de una variable sin inicializar
     es problemático al incluir un archivo en otro que use el mismo
     nombre de variable.
    </simpara>
   </warning>

   <simpara>
    Una variable puede ser destruida, utilizando la construcción del lenguaje
    <function>unset</function>.
   </simpara>

   <simpara>
    Para información con funciones relativas a variables, mira la
    <link linkend="ref.var">Referencia de funciones de variables</link>.
   </simpara>
  </sect1>

  <sect1 xml:id="language.variables.predefined">
   <title>Variables Predefinidas</title>

   <para>
    PHP proporciona una gran cantidad de
    <link linkend="reserved.variables">variables predefinidas</link>.
    PHP ofrece un conjunto adicional de arrays predefinidas que contienen
    variables del servidor web (cuando es aplicable), el entorno y entradas del
    usuario. Estos arrays están automáticamente disponibles en cualquier
    entorno. Por esa razón, a veces son conocidas como "superglobales".
    (No existe mecanismo en PHP para crear superglobales definidas por el
    usuario). Referencia de la 
    <link linkend="language.variables.superglobals">lista de superglobales</link>
    para más detalles.
   </para>

   <note>
    <title>Variables variables</title>
    <para>
     Las superglobales no pueden ser usadas como <link
     linkend="language.variables.variable">variables variables</link>
     en el interior de funciones o métodos de clase.
    </para>
   </note>

   <para>
    Si ciertas variables no son definidas en <link
    linkend="ini.variables-order">variables_order</link>, los arrays de PHP
    predefinidos asociados a estas, estarán vacíos.
   </para>
  </sect1>


  <sect1 xml:id="language.variables.scope">
   <title>Ámbito de las variables</title>

   <simpara>
    El ámbito de una variable es el contexto en el cual la variable está
    definida.
    PHP tiene un ámbito de función y un ámbito global.
    Cualquier variable difinida fuera de una función está limitada al ámbito global.
    Cuando se incluye un archivo, el código contenido hereda el ámbito de la
    variable de la línea en la cual se incluye el archivo.
   </simpara>
   <example>
    <title>Ejemplo de una variable de ámbito global</title>
    <programlisting role="php">
<![CDATA[
<?php
$a = 1;
include 'b.inc'; // La variable $a estará disponible en el interior de b.inc
?>
]]>
    </programlisting>
   </example>

   <simpara>
    Cualquier variable declarada dentro de una función o una
    <link linkend="functions.anonymous">funcíón anónima</link>
    está limitada al ámbito del cuerpo de dicha función.
    Sin embargo, las <link linkend="functions.arrow">funciones de flecha</link>
    vinculan las variables desde el ámbito padre haciendo que
    estén disponibles dentro de la función.
    Si se incluye un archivo dentro de una función, las variables
    contenidas en el archivo llamado estarán disponibles como si
    se hubieran definido dentro de la función que realiza la llamada.
   </simpara>
    
   <example>
    <title>Ejemplo de una variable de ámbito local</title>
    <programlisting role="php"> 
<![CDATA[
<?php
$a = 1; // ámbito global

function test()
{
    echo $a; // La variable $a no está definida ya que se refiere a una versión local de $a
}
?>
]]>
    </programlisting>
   </example>

  <simpara>
   El ejemplo anterior producirá un <constant>E_WARNING</constant> por una
   variable no definida (o un <constant>E_NOTICE</constant> antes de PHP 8.0.0).
   Esto se debe a la expresión echo hace referencia a una versión local de
   la variable <varname>$a</varname>, a la cual no se le ha asignado un valor
   dentro de su ámbito.
   Puede que usted note que hay una pequeña diferencia con el lenguaje C,
   en el que las variables globales están disponibles automáticamente dentro
   de la función a menos que sean expresamente sobreescritas por una
   definición local. Esto puede causar algunos problemas, ya que la gente
   podría cambiar variables globales sin darse cuenta.
   En PHP, las variables globales deben ser declaradas globales dentro de la
   función si van a ser utilizadas dentro de dicha función.
  </simpara>

  <sect2 xml:id="language.variables.scope.global">
   <title>La palabra clave <literal>global</literal></title>
   <simpara>
    La palabra clave <literal>global</literal> se usa para vincular una
    variable desde el ámbito global a un ámbito local. La palabra clave
    puede ser usada con una lista de variables o con una sola variable.
    Una variable local será creada haciendo referendia a una variable global
    con el mismo nombre. Si no existe la variable global, la variable será
    creada en el ámbito global y asignado el valor &null;.
   </simpara>
   <para>
    <example>
     <title>Uso de <literal>global</literal></title>
     <programlisting role="php">
<![CDATA[
<?php
$a = 1;
$b = 2;

function Suma()
{
    global $a, $b;

    $b = $a + $b;
}

Suma();
echo $b;
?>
]]>
     </programlisting>
      &example.outputs;
      <screen>
<![CDATA[
3
]]>
      </screen>
    </example>
   </para>

   <simpara>
    Al declarar las variables
    <varname>$a</varname> y <varname>$b</varname> globales dentro de la
    función, todas las referencias a tales variables se referirán a la
    versión global. No hay límite al número de variables globales que se
    pueden manipular dentro de una función.
   </simpara>

   <simpara>
    Un segundo método para acceder a las variables desde un ámbito global es
    usando el array especial definido por PHP <varname>$GLOBALS</varname>.
    El ejemplo anterior se puede reescribir así:
   </simpara>
   <para>
    <example>
     <title>Uso de <varname>$GLOBALS</varname> en lugar de global</title>
     <programlisting role="php">
<![CDATA[
<?php
$a = 1;
$b = 2;

function Suma()
{
    $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}

Suma();
echo $b;
?>
]]>
     </programlisting>
    </example>
   </para>

   <simpara>
    El array <varname>$GLOBALS</varname> es un array asociativo con el
    nombre de la variable global como clave y los contenidos de dicha
    variable como el valor del elemento del array.
    <varname>$GLOBALS</varname> existe en cualquier ámbito, esto ocurre ya
    que <varname>$GLOBALS</varname> es una <link
    linkend="language.variables.superglobals">superglobal</link>. Aquí hay un
    ejemplo que demuestra el poder de las superglobales:
   </simpara>
   <para>
    <example>
     <title>Ejemplo que demuestra las superglobales y el ámbito</title>
     <programlisting role="php">
<![CDATA[
<?php
function test_superglobal()
{
    echo $_POST['name'];
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <note>
    <para>
     Utilizar una clave <literal>global</literal> fuera de una función no es un
     error. Esta puede ser utilizada aún si el fichero está incluido desde el interior de una función.
    </para>
   </note>
  </sect2>

  <sect2 xml:id="language.variables.scope.static">
   <title>Uso de variables <literal>static</literal></title>

   <simpara>
    Otra característica importante del ámbito de las variables es la variable
    <emphasis>estática</emphasis>. Una variable estática existe sólo en el
    ámbito local de la función, pero no pierde su valor cuando la ejecución
    del programa abandona este ámbito. Consideremos el siguiente ejemplo:
   </simpara>
   <para>
    <example>
     <title>Ejemplo que demuestra la necesidad de variables
      estáticas</title>
     <programlisting role="php">
<![CDATA[
<?php
function test()
{
    $a = 0;
    echo $a;
    $a++;
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <simpara>
    Esta función tiene poca utilidad ya que cada vez que es llamada asigna a
    <varname>$a</varname> el valor <literal>0</literal> e imprime un
    <literal>0</literal>.  La sentencia <varname>$a</varname>++, que incrementa la
    variable, no sirve para nada, ya que en cuanto la función finaliza, la
    variable <varname>$a</varname> desaparece.  Para hacer una función útil
    para contar, que no pierda la pista del valor actual del conteo, la
    variable <varname>$a</varname> debe declararse como estática:
   </simpara>
   <para>
    <example>
     <title>Ejemplo del uso de variables estáticas</title>
     <programlisting role="php">
<![CDATA[
<?php
function test()
{
    static $a = 0;
    echo $a;
    $a++;
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <simpara>
    Ahora, <varname>$a</varname> se inicializa únicamente en la primera
    llamada a la función, y cada vez que la función <literal>test()</literal> es llamada,
    imprimirá el valor de <varname>$a</varname> y lo incrementa.
   </simpara>

   <simpara>
    Las variables estáticas también proporcionan una forma de manejar
    funciones recursivas. La siguiente función cuenta recursivamente
    hasta 10, usando la variable estática <varname>$count</varname>
    para saber cuándo parar:
   </simpara>
   <para>
    <example>
     <title>Variables estáticas con funciones recursivas</title>
     <programlisting role="php">
<![CDATA[
<?php
function test()
{
    static $count = 0;

    $count++;
    echo $count;
    if ($count < 10) {
        test();
    }
    $count--;
}
?>
]]>
     </programlisting>
    </example>
   </para>

   <para>
    Antes de PHP 8.3.0, las variables estáticas solo podían ser inicializadas
    usando expresiones constantes. A partir de PHP 8.3.0, expresiones dinámicas
    (por ejemplo, llamadas a funciones) también están permitidas:
   </para>
   <para>
    <example>
     <title>Declarando variables estáticas</title>
     <programlisting role="php">
<![CDATA[
<?php
function foo(){
    static $int = 0;          // correcto
    static $int = 1+2;        // correcto
    static $int = sqrt(121);  // correcto a partir de PHP 8.3.0

    $int++;
    echo $int;
}
?>
]]>
     </programlisting>
    </example>
   </para>

   <simpara>
    Las variables estáticas dentro de funiones anónimas también persisten
    solo dentro de esa instancia específica de la función. Si la función
    anónima es recreada en cada llamada, la variable estática será
    reinicializada.
   </simpara>
   <example>
    <title>Variables estáticas en funciones anónimas</title>
    <programlisting role="php">
<![CDATA[
<?php
function exampleFunction($input) {
    $result = (static function () use ($input) {
        static $counter = 0;
        $counter++;
        return "Entrada: $input, Contador: $counter\n";
    });

    return $result();
}

// Las llamadas a exampleFunction recrearán la función anónima, por tanto
// la variable estática no retendrá su valor.
echo exampleFunction('A'); // Devolverá: Entrada: A, Contador: 1
echo exampleFunction('B'); // Devolverá: Entrada: B, Contador: 1
?>
]]>
    </programlisting>
   </example>

   <para>
    A partir de PHP 8.1.0, cuando un método que usa variables estáticas es
    heredado (pero no sobrescrito), el método heredado compartirá ahora las
    variables estáticas con el método padre. Esto significa que las variables
    estáticas en los métodos ahora se comportan de la misma manera que las
    propiedades estáticas.
   </para>

   <simpara>
    A partir de PHP 8.3.0, las variables estáticas pueden ser inicializadas con
    expresiones arbitrarias. Esto significa que las llamadas a métodos, por
    ejemplo, pueden ser usadas para inicializar variables estáticas.
   </simpara>

   <example>
    <title>Uso de variables estáticas en métodos heredados</title>
    <programlisting role="php">
<![CDATA[
<?php
class Foo {
    public static function counter() {
        static $counter = 0;
        $counter++;
        return $counter;
    }
}
class Bar extends Foo {}
var_dump(Foo::counter()); // int(1)
var_dump(Foo::counter()); // int(2)
var_dump(Bar::counter()); // int(3), antes de PHP 8.1.0 int(1)
var_dump(Bar::counter()); // int(4), antes de PHP 8.1.0 int(2)
?> 
]]>
    </programlisting>
   </example>
  </sect2>


  <sect2 xml:id="language.variables.scope.references">
   <title>Referencias con variables <literal>global</literal> y <literal>static</literal></title>
   <simpara>
    PHP implementa los modificadores
    <link linkend="language.variables.scope.static">static</link> y <link
    linkend="language.variables.scope.global">global</link> para variables
    en términos de <link linkend="language.references">referencias</link>.
    Por ejemplo, una variable global verdadera importada dentro del ámbito
    de una función con <literal>global</literal> crea una referencia a la
    variable global. Esto puede ser causa de un comportamiento inesperado,
    tal y como podemos comprobar en el siguiente ejemplo:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
function test_global_ref() {
    global $obj;
    $new = new stdClass;
    $obj = &$new;
}

function test_global_noref() {
    global $obj;
    $new = new stdClass;
    $obj = $new;
}

test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>
]]>
    </programlisting>
   </informalexample>

   &example.outputs;

   <screen>
<![CDATA[
NULL
object(stdClass)#1 (0) {
}
]]>
   </screen>

   <simpara>
    Un comportamiento similar se aplica a <literal>static</literal>. Las
    referencias no son almacenadas estáticamente.
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
function &get_instance_ref() {
    static $obj;

    echo 'Objeto estático: ';
    var_dump($obj);
    if (!isset($obj)) {
        $new = new stdClass;
        // Asignar una referencia a la variable estática
        $obj = &$new;
    }
    if (!isset($obj->property)) {
        $obj->property = 1;
    } else {
        $obj->property++;
    }
    return $obj;
}

function &get_instance_noref() {
    static $obj;

    echo 'Objeto estático: ';
    var_dump($obj);
    if (!isset($obj)) {
        $new = new stdClass;
        // Asignar el objeto a la variable estática
        $obj = $new;
    }
    if (!isset($obj->property)) {
        $obj->property = 1;
    } else {
        $obj->property++;
    }
    return $obj;
}

$obj1 = get_instance_ref();
$aun_obj1 = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$aun_obj2 = get_instance_noref();
?>
]]>
    </programlisting>
   </informalexample>
   &example.outputs;
   <screen>
<![CDATA[
Objeto estático: NULL
Objeto estático: NULL

Objeto estático: NULL
Objeto estático: object(stdClass)#3 (1) {
  ["property"]=>
  int(1)
}
]]>
   </screen>

   <simpara>
    Este ejemplo demuestra que al asignar una referencia a una variable
    estática, esta no es <emphasis>recordada</emphasis> cuando se invoca la
    funcion <literal>&amp;obtener_instancia_ref()</literal> por segunda vez.
   </simpara>
  </sect2>
 </sect1>

 <sect1 xml:id="language.variables.variable">
  <title>Variables variables</title>

  <simpara>
   A veces es conveniente tener nombres de variables variables. Dicho de
   otro modo, son nombres de variables que se pueden definir y usar
   dinámicamente. Una variable normal se establece con una sentencia como:
  </simpara>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
$a = 'hola';
?>
]]>
   </programlisting>
  </informalexample>

  <simpara>
   Una variable variable toma el valor de una variable y lo trata como el
   nombre de una variable. En el ejemplo anterior,
   <emphasis>hola</emphasis>, se puede usar como el nombre de una variable
   utilizando dos signos de dólar. Es decir:
  </simpara>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
$$a = 'mundo';
?>
]]>
   </programlisting>
  </informalexample>

  <simpara>
   En este momento se han definido y almacenado dos variables en el árbol de
   símbolos de PHP: <varname>$a</varname>, que contiene "hola", y
   <varname>$hola</varname>, que contiene "mundo". Es más, esta
   sentencia:
  </simpara>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
echo "$a ${$a}";
?>
]]>
   </programlisting>
  </informalexample>

  <simpara>
   produce el mismo resultado que:
  </simpara>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
echo "$a $hola";
?>
]]>
   </programlisting>
  </informalexample>

  <simpara>
   esto quiere decir que ambas producen el resultado: <computeroutput>hola mundo</computeroutput>.
  </simpara>

  <simpara>
   Para usar variables variables con arrays hay que
   resolver un problema de ambigüedad. Si se escribe
   <varname>$$a[1]</varname>, el intérprete necesita saber si nos
   referimos a utilizar <varname>$a[1]</varname> como una variable, o si
   se pretendía utilizar <varname>$$a</varname> como variable y el índice [1]
   como índice de dicha variable. La sintaxis para resolver esta ambigüedad
   es: <varname>${$a[1]}</varname> para el primer caso y
   <varname>${$a}[1]</varname> para el segundo.
  </simpara>

  <simpara>
   También se puede acceder a las propiedades de una clase usando el nombre de propiedad variable.
   Este será resuelto dentro del ámbito del cual se hizo
   la llamada. Por ejemplo, en la expresión
   <varname>$foo->$bar</varname>, se buscará <varname>$bar</varname> en el ámibto
   local y se empleará su valor será como el nombre de la propiedad
   de <varname>$foo</varname>. Esto también es cierto
   si <varname>$bar</varname> es un acceso a un array.
  </simpara>

  <simpara>
   También se pueden usar llaves para delimitar de forma clara el nombre de la
   propiedad. Son muy útila al acceder a valores dentro una propiedad que
   contiene un array, cuando el nombre de la propiedad está compuesto de múltiples partes,
   o cuando el nombre de la propiedad contiene caracteres que de otro modo no son
   válidos (p.ej. desde <function>json_decode</function>
   o <link linkend="book.simplexml">SimpleXML</link>).
  </simpara>

  <para>
   <example>
    <title>Ejemplo de propiedad variable</title>
    <programlisting role="php">
<![CDATA[
<?php
class foo {
    var $bar = 'Soy bar.';
    var $arr = array('Soy A.', 'Soy B.', 'Soy C.');
    var $r   = 'Soy r.';
}

$foo = new foo();
$bar = 'bar';
$baz = array('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";

?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
Soy bar.
Soy bar.
Soy bar.
Soy r.
Soy B.
    </screen>
   </example>
  </para>

  <warning>
   <simpara>
    Por favor tenga en cuenta que las variables variables no pueden usarse
    con los <link linkend="language.variables.superglobals">Arrays
    superglobales</link> de PHP al interior de funciones o métodos de
    clase. La variable <literal>$this</literal> es también una variable
    especial que no puede ser referenciada dinámicamente.
   </simpara>
  </warning>

 </sect1>

 <sect1 xml:id="language.variables.external">
  <title>Variables desde fuentes externas</title>

  <sect2 xml:id="language.variables.external.form">
   <title>Formularios HTML (GET y POST)</title>

   <simpara>
    Cuando se envía un formulario a un script de PHP, la información de dicho
    formulario pasa a estar automáticamente disponible en el script. Existen
    algunas formas de acceder a esta información, por ejemplo:
   </simpara>

   <para>
    <example>
     <title>Un formulario HTML sencillo</title>
     <programlisting role="php">
<![CDATA[
<form action="foo.php" method="post">
    Nombre usuario: <input type="text" name="username" /><br />
    Email:  <input type="text" name="email" /><br />
    <input type="submit" name="submit" value="¡Enviarme!" />
</form>
]]>
     </programlisting>
    </example>
   </para>

   <para>
    Solamente existen dos maneras de acceder a datos desde formularios HTML.
    Los métodos disponibles actualmente se enumeran a continuación:
   </para>

   <para>
    <example>
     <title>Acceso a datos de un formulario HTML sencillo con POST</title>
     <programlisting role="html">
<![CDATA[
<?php
echo $_POST['username'];
echo $_REQUEST['username'];
?>
]]>
     </programlisting>
    </example>
   </para>

   <para>
    Usar un formulario con GET es similar excepto en el uso de variables
    predefinidas, que en este caso serán del tipo GET. GET también se usa
    con <literal>QUERY_STRING</literal> (la información despues del símbolo '?' en una URL).
    Por ejemplo <literal>http://www.example.com/test.php?id=3</literal>
    contiene datos GET que son accesibles con
    <varname>$_GET['id']</varname>.
    Véase también <varname>$_REQUEST</varname>.
   </para>

   <note>
    <para>
     Puntos y espacios en nombres de variables son convertidos a guiones bajos.
     Por ejemplo <literal>&lt;input name="a.b" /&gt;</literal> se convierte en
     <literal>$_REQUEST["a_b"]</literal>.
    </para>
   </note>

   <simpara>
    PHP también entiende arrays en el contexto de variables de
    formularios (vea la <link linkend="faq.html">faq relacionada</link>).
    Se puede, por ejemplo, agrupar juntas variables relacionadas o usar esta
    característica para obtener valores de una entrada "select" múltiple.
    Por ejemplo, vamos a mandar un formulario a sí mismo y a presentar los
    datos cuando se reciban:
   </simpara>
   <para>
    <example>
     <title>Variables de formulario más complejas</title>
     <programlisting role="php">
<![CDATA[
<?php
if ($_POST) {
    echo '<pre>';
    echo htmlspecialchars(print_r($_POST, true));
    echo '</pre>';
}
?>
<form action="" method="post">
    Nombre:  <input type="text" name="personal[nombre]" /><br />
    Email:   <input type="text" name="personal[email]" /><br />
    Cerveza: <br />
    <select multiple name="cerveza[]">
        <option value="warthog">Warthog</option>
        <option value="guinness">Guinness</option>
        <option value="stuttgarter">Stuttgarter Schwabenbräu</option>
    </select><br />
    <input type="submit" value="¡enviarme!" />
</form>
]]>
     </programlisting>
    </example>
   </para>

    <note>
     <simpara>
      Si una variable externa comienza con una sintaxis de array válida,
      Los caracteres finales se ignoran en silencio. Por ejemplo, 
      <literal>&lt;input name="foo[bar]baz"&gt;</literal>
      se convierte en <literal>$_REQUEST['foo']['bar']</literal>.
     </simpara>
    </note>

    <sect3 xml:id="language.variables.external.form.submit">
     <title>Nombres de variables tipo IMAGE SUBMIT</title>

     <simpara>
      Cuando se envía un formulario, es posible usar una imagen en vez
      del botón estándar "submit":
     </simpara>

     <informalexample>
      <programlisting role="html">
<![CDATA[
<input type="image" src="image.gif" name="sub" />
]]>
      </programlisting>
     </informalexample>

     <simpara>
      Cuando el usuario hace click en cualquier parte de la imagen, el
      formulario que la acompaña se transmitirá al servidor con dos variables
      adicionales, <varname>sub_x</varname> y <varname>sub_y</varname>. Éstas contienen las coordenadas del  clic
      del usuario dentro de la imagen.  Los más experimentados puede notar
      que los nombres de variable enviados por el navegador contienen un
      guión en vez de un subrayado (guión bajo), pero PHP convierte el guión
      en subrayado automáticamente.
     </simpara>
    </sect3>

   </sect2>

   <sect2 xml:id="language.variables.external.cookies">
    <title>Cookies HTTP</title>

    <simpara>
     PHP soporta cookies de HTTP de forma transparente tal y como están
     definidas en <link xlink:href="&url.rfc;6265">RFC 6265</link>. Las cookies son un
     mecanismo para almacenar datos en el navegador y así
     rastrear o identificar a usuarios que vuelven. Se pueden
     crear cookies usando la función <function>setcookie</function>. Las
     cookies son parte de la cabecera HTTP, así que se debe llamar a la
     función SetCookie antes de que se envíe cualquier salida al navegador.
     Es la misma restricción que para la función <function>header</function>.
     Los datos de una cookie están disponibles en el array de datos de la
     cookies apropiada, tal como <varname>$_COOKIE</varname> y <varname>$_REQUEST</varname>.
     Véase la página de <function>setcookie</function> del manual para más
     detalles y ejemplos.
    </simpara>

    <note>
     <simpara>
      A partir de PHP 7.2.34, 7.3.23 y 7.4.11, respectivamente, los
      <emphasis>nombres</emphasis> de las cookies entrantes ya no son con url-decoded
      por razones de seguridad.
     </simpara>
    </note>

   <simpara>
    Si se quieren asignar múltiples valores a una sola cookie, basta con
    asignarlo como un array. Por ejemplo:
   </simpara>

    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
  setcookie("MiCookie[foo]", 'Prueba 1', time()+3600);
  setcookie("MiCookie[bar]", 'Prueba 2', time()+3600);
?>
]]>
     </programlisting>
    </informalexample>

    <simpara>
     Esto creará dos cookies separadas aunque <varname>MiCookie</varname> será un array simple
     en el script. Si se quiere definir una sola cookie con valores
     múltiples, considere el uso de la función <function>serialize</function>
     o <function>explode</function> primero en el valor.
    </simpara>

    <simpara>
     Nótese que una cookie reemplazará a una cookie anterior que tuviese el
     mismo nombre en el navegador a menos que la ruta o el dominio
     fuesen diferentes. Así, para una aplicación de carrito de compras se
     podría querer mantener un contador e ir pasándolo. Es decir:
    </simpara>

    <example>
     <title>Un ejemplo de <function>setcookie</function></title>
     <programlisting role="php">
<![CDATA[
<?php
if (isset($_COOKIE['count'])) {
    $count = $_COOKIE['count'] + 1;
} else {
    $count = 1;
}
setcookie('conteo', $count, time()+3600);
setcookie("Carrito[$count]", $item, time()+3600);
?>
]]>
     </programlisting>
    </example>

   </sect2>

   <sect2 xml:id="language.variables.external.dot-in-names">
    <title>Puntos en los nombres de variables de entrada</title>

    <para>
     Típicamente, PHP no altera los nombres de las variables cuando se pasan
     a un script. Sin embargo, hay que notar que el punto no es un
     carácter válido en el nombre de una variable PHP. Para conocer la razón,
     considere el siguiente ejemplo:
     <programlisting role="php">
<![CDATA[
<?php
$varname.ext;  /* nombre de variable inválido */
?>
]]>
     </programlisting>
     Lo que el intérprete vé es el nombre de una variable <varname>$varname</varname>, seguido
     por el operador de concatenación, y seguido por la cadena pura (es
     decir, una cadena sin entrecomillar que no coincide con ninguna palabra
     clave o reservada conocida) 'ext'. Obviamente, no se pretendía que fuese
     éste el resultado.
    </para>

    <para>
     Por esta razón, es importante hacer notar que PHP reemplazará
     automáticamente cualquier punto en los nombres de variables de entrada
     por guiones bajos (subrayados).
    </para>

   </sect2>

   <sect2 xml:id="language.variables.determining-type-of">
    <title>Determinación de los tipos de variables</title>

    <para>
     Dado que PHP determina los tipos de las variables y los convierte
     (generalmente) según lo que necesita, no siempre resulta obvio de qué tipo
     es una variable dada en un momento concreto. PHP incluye varias
     funciones que descubren de qué tipo es una variable:
     <function>gettype</function>, <function>is_array</function>,
     <function>is_float</function>, <function>is_int</function>,
     <function>is_object</function>, y <function>is_string</function>.  Vea
     también el capítulo sobre <link linkend="language.types">Tipos</link>.
    </para>
    <para>
     HTTP being a text protocol, most, if not all, content that comes in
     <link linkend="language.variables.superglobals">Superglobal arrays</link>, 
     like <varname>$_POST</varname> and <varname>$_GET</varname> will remain
     as strings. PHP will not try to convert values to a specific type.
     In the example below, <varname>$_GET["var1"]</varname> will contain the
     string "null" and <varname>$_GET["var2"]</varname>, the string "123".
     <programlisting>
<![CDATA[
/index.php?var1=null&var2=123
]]>
      </programlisting>
    </para>
   </sect2>

   <sect2 xml:id="language.variables.external.changelog">
    &reftitle.changelog;

    <para>
     <informaltable>
      <tgroup cols="2">
       <thead>
        <row>
         <entry>&Version;</entry>
         <entry>&Description;</entry>
        </row>
       </thead>
       <tbody>
        <row>
         <entry>7.2.34, 7.3.23, 7.4.11</entry>
         <entry>
          Los <emphasis>nombres</emphasis> de las cookies entrantes ya no son con url-decoded
          por razones de seguridad.
         </entry>
        </row>
       </tbody>
      </tgroup>
     </informaltable>
    </para>
   </sect2>

  </sect1>

 </chapter>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->