mirror of
https://github.com/php/doc-es.git
synced 2026-03-23 23:12:09 +01:00
1209 lines
36 KiB
XML
1209 lines
36 KiB
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
|
|
(&) 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>&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><input name="a.b" /></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><input name="foo[bar]baz"></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>
|
|
Dado que HTTP es un protocolo de texto, la mayoría, si no todo, el contenido que llega en
|
|
<link linkend="language.variables.superglobals">arrays superglobales</link>,
|
|
como <varname>$_POST</varname> y <varname>$_GET</varname>, permanecerá
|
|
como cadenas de texto. PHP no intentará convertir los valores a un tipo específico.
|
|
En el ejemplo siguiente, <varname>$_GET["var1"]</varname> contendrá la
|
|
cadena "null" y <varname>$_GET["var2"]</varname>, la cadena "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
|
|
-->
|