mirror of
https://github.com/php/doc-es.git
synced 2026-03-25 16:02:13 +01:00
08a6f1a85a
git-svn-id: https://svn.php.net/repository/phpdoc/es/trunk@337397 c90b9560-bf6c-de11-be94-00142212c4b1
1159 lines
36 KiB
XML
1159 lines
36 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<!-- $Revision$ -->
|
|
<!-- EN-Revision: c5966670de19d0e3f42021bb5527d54b4a78bfa8 Maintainer: seros 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>
|
|
Los nombres de variables siguen las mismas reglas que otras etiquetas en
|
|
PHP. Un nombre de variable válido tiene que empezar con una letra 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: '<literal>[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*</literal>'
|
|
</para>
|
|
|
|
<note>
|
|
<simpara>
|
|
Para los propósitos de este manual, una letra es a-z, A-Z, y los bytes
|
|
del 127 al 255 (<literal>0x7f-0xff</literal>).
|
|
</simpara>
|
|
</note>
|
|
|
|
<note>
|
|
<simpara>
|
|
<literal>$this</literal> es una variable especial que no puede ser
|
|
asignada.
|
|
</simpara>
|
|
</note>
|
|
|
|
&tip.userlandnaming;
|
|
|
|
<para>
|
|
Para más información sobre funciones relacionadas con variables, vea la
|
|
<link linkend="ref.var">Referencia de Funciones de Variables</link>.
|
|
</para>
|
|
|
|
<para>
|
|
<informalexample>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
$var = 'Roberto';
|
|
$Var = 'Juan';
|
|
echo "$var, $Var"; // imprime "Roberto, Juan"
|
|
|
|
$4site = 'aun no'; // inválido; comienza con un número
|
|
$_4site = 'aun no'; // válido; comienza con un carácter de subrayado
|
|
$täyte = 'mansikka'; // válido; 'ä' es ASCII (Extendido) 228
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
</para>
|
|
|
|
<para>
|
|
De forma predeterminada, 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 <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.
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
</para>
|
|
|
|
<para>
|
|
No es necesario inicializar variables en PHP, sin embargo, es una muy buena práctica.
|
|
Las variables no inicializadas tienen un valor predeterminado de acuerdo a su tipo dependiendo del contexto en el que son usadas
|
|
- las booleanas se asumen como &false;, los enteros y flotantes como cero, las cadenas (p.ej. usadas en <function>echo</function>) se
|
|
establecen como una cadena vacía y los arrays se convierten en un array vacío.
|
|
</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); imprime NULL
|
|
var_dump($variable_indefinida);
|
|
|
|
// Uso booleano; imprime 'false' (Vea operadores ternarios para más información sobre esta sintaxis)
|
|
echo($booleano_indefinido ? "true\n" : "false\n");
|
|
|
|
// Uso de una cadena; imprime 'string(3) "abc"'
|
|
$cadena_indefinida .= 'abc';
|
|
var_dump($cadena_indefinida);
|
|
|
|
// Uso de un entero; imprime 'int(25)'
|
|
$int_indefinido += 25; // 0 + 25 => 25
|
|
var_dump($int_indefinido);
|
|
|
|
// Uso de flotante/doble; imprime 'float(1.25)'
|
|
$flotante_indefinido += 1.25;
|
|
var_dump($flotante_indefinido);
|
|
|
|
// Uso de array; imprime array(1) { [3]=> string(3) "def" }
|
|
$array_indefinida[3] = "def"; // array() + array(3 => "def") => array(3 => "def")
|
|
var_dump($array_indefinida);
|
|
|
|
// Uso de objetos; crea un nuevo objeto stdClass (vea http://www.php.net/manual/en/reserved.classes.php)
|
|
// Imprime: object(stdClass)#1 (1) { ["foo"]=> string(3) "bar" }
|
|
$objeto_indefinido->foo = 'bar';
|
|
var_dump($objeto_indefinido);
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
<para>
|
|
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.
|
|
También es un importante <link
|
|
linkend="security.globals">riesgo de seguridad</link> cuando la opción
|
|
<link linkend="ini.register-globals">register_globals</link> se encuentra habilitada.
|
|
Un error de nivel <link linkend="errorfunc.constants.errorlevels.e-notice">E_NOTICE</link> es
|
|
emitido cuendo se trabaja con variables sin inicializar, con la excepción del caso en
|
|
el que se anexan elementos a un array no inicializado. La construcción del lenguaje <function>isset</function>
|
|
puede ser usada para detectar si una variable ya ha sido inicializada.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1 xml:id="language.variables.predefined">
|
|
<title>Variables Predefinidas</title>
|
|
|
|
<simpara>
|
|
PHP proporciona una gran cantidad de variables predefinidas a cualquier
|
|
script que se ejecute. Muchas de éstas, sin embargo, no pueden ser
|
|
completamente documentadas ya que dependen del servidor que esté
|
|
corriendo, la versión y configuración de dicho servidor, y otros
|
|
factores. Algunas de estas variables no estarán disponibles cuando se
|
|
ejecute PHP desde la <link linkend="features.commandline">línea de
|
|
comandos</link>. Para obtener una lista de estas variables, por favor vea
|
|
la sección sobre <link linkend="reserved.variables">Variables Predefinidas Reservadas</link>.
|
|
</simpara>
|
|
|
|
<warning>
|
|
<simpara>
|
|
A partir de PHP 4.2.0, el valor predeterminado de la directiva PHP <link
|
|
linkend="ini.register-globals">register_globals</link> es
|
|
<emphasis>off</emphasis> (desactivada). Este es un cambio importante en
|
|
PHP. Tener register_globals <emphasis>off</emphasis> afecta el
|
|
conjunto de variables predefinidas disponibles en el sistema. Por
|
|
ejemplo, para obtener <varname>DOCUMENT_ROOT</varname> se usará
|
|
<varname>$_SERVER['DOCUMENT_ROOT']</varname> en vez de
|
|
<varname>$DOCUMENT_ROOT</varname> ó <varname>$_GET['id']</varname> de la
|
|
URL <literal>http://www.example.com/test.php?id=3</literal> en lugar de
|
|
<varname>$id</varname> ó <varname>$_ENV['HOME']</varname> en lugar de
|
|
<varname>$HOME</varname>.
|
|
</simpara>
|
|
<simpara>
|
|
Para más información sobre este cambio, puede consultar el apartado de
|
|
configuración sobre <link linkend="ini.register-globals">register_globals</link>, el capítulo
|
|
sobre seguridad <link linkend="security.globals">Usando "Register Globals" </link>,
|
|
asi como los anuncios de lanzamiento de PHP
|
|
<link xlink:href="&url.php.release4.1.0;">4.1.0 </link>
|
|
y <link xlink:href="&url.php.release4.2.0;">4.2.0</link>
|
|
</simpara>
|
|
<simpara>
|
|
El uso de las variables reservadas predefinidas en PHP, como los <link
|
|
linkend="language.variables.superglobals">arrays superglobales</link>
|
|
es recomendable.
|
|
</simpara>
|
|
</warning>
|
|
|
|
<simpara>
|
|
A partir de PHP 4.1.0, PHP ofrece un conjunto adicional de arrays
|
|
predefinidas que contienen variables del servidor web, el entorno y
|
|
entradas del usuario. Estos nuevos arrays son un poco especiales porque
|
|
son automáticamente globales. Por esta razón, son conocidas a menudo como
|
|
"superglobales". Las superglobales se mencionan más abajo; sin embargo
|
|
para una lista de sus contenidos y más información sobre variables
|
|
predefinidas en PHP, por favor consulte la sección <link
|
|
linkend="reserved.variables">Variables predefinidas reservadas</link>.
|
|
Asimismo, podrá notar cómo las antiguas variables predefinidas
|
|
(<varname>$HTTP_*_VARS</varname>) todavía existen.
|
|
|
|
&avail.register-long-arrays;
|
|
</simpara>
|
|
|
|
<note>
|
|
<title>Variables variables</title>
|
|
<para>
|
|
Las superglobales no pueden ser usadas como <link
|
|
linkend="language.variables.variable">variables variables</link> al
|
|
interior de funciones o métodos de clase.
|
|
</para>
|
|
</note>
|
|
|
|
<note>
|
|
<para>
|
|
Aún cuando las superglobales y <literal>HTTP_*_VARS</literal> pueden existir al mismo
|
|
tiempo; estas variables no son idénticas, así que modificar una no
|
|
cambia la otra.
|
|
</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 dentro del que la variable está
|
|
definida. La mayor parte de las variables PHP sólo tienen un ámbito
|
|
simple. Este ámbito simple también abarca los ficheros incluídos y los
|
|
requeridos. Por ejemplo:
|
|
</simpara>
|
|
<informalexample>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
$a = 1;
|
|
include 'b.inc';
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
<simpara>
|
|
Aquí, la variable <varname>$a</varname> estará disponible al interior del
|
|
script incluido <filename>b.inc</filename>. Sin embargo, al interior de
|
|
las funciones definidas por el usuario se introduce un ámbito local a la
|
|
función. Cualquier variable usada dentro de una función está, por
|
|
omisión, limitada al ámbito local de la función. Por ejemplo:
|
|
</simpara>
|
|
|
|
<informalexample>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
$a = 1; /* ámbito global */
|
|
|
|
function test()
|
|
{
|
|
echo $a; /* referencia a una variable del ámbito local */
|
|
}
|
|
|
|
test();
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
|
|
<simpara>
|
|
Este script no producirá salida, ya que la sentencia echo utiliza una
|
|
versión local de la variable <varname>$a</varname>, a la que no se ha
|
|
asignado ningún valor en 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 puede cambiar variables globales
|
|
inadvertidamente. 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>
|
|
En primer lugar, un ejemplo de uso de <literal>global</literal>:
|
|
</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>
|
|
</para>
|
|
|
|
<simpara>
|
|
El script anterior producirá la salida <literal>3</literal>. Al declarar
|
|
<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 <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_global()
|
|
{
|
|
// La mayoría de variables predefinidas no son "super" y requieren
|
|
// 'global' para estar disponibles al ámbito local de las funciones.
|
|
global $HTTP_POST_VARS;
|
|
|
|
echo $HTTP_POST_VARS['name'];
|
|
|
|
// Las superglobales están disponibles en cualquier ámbito y no
|
|
// requieren 'global'. Las superglobales están disponibles desde
|
|
// PHP 4.1.0, y ahora HTTP_POST_VARS se considera obsoleta.
|
|
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. Una función recursiva es la que se llama a sí
|
|
misma. Se debe tener cuidado al escribir una función recursiva, ya que
|
|
puede ocurrir que se llame a sí misma indefinidamente. Hay que
|
|
asegurarse de implementar una forma adecuada de terminar la recursión.
|
|
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>
|
|
|
|
<note>
|
|
<para>
|
|
Las variables estáticas pueden ser declaradas como se ha visto en los
|
|
ejemplos anteriores. Al tratar de asignar valores a estas variables
|
|
que sean el resultado de expresiones, causará un error de análisis
|
|
sintáctico.
|
|
</para>
|
|
<para>
|
|
<example>
|
|
<title>Declaración de variables estáticas</title>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
function foo(){
|
|
static $int = 0; // correcto
|
|
static $int = 1+2; // incorrecto (ya que es una expresión)
|
|
static $int = sqrt(121); // incorrecto (es una expresión también)
|
|
|
|
$int++;
|
|
echo $int;
|
|
}
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
</note>
|
|
<note>
|
|
<para>
|
|
Las declaraciones estáticas son resueltas en tiempo de compilación.
|
|
</para>
|
|
</note>
|
|
</sect2>
|
|
|
|
<sect2 xml:id="language.variables.scope.references">
|
|
<title>Referencias con variables <literal>global</literal> y <literal>static</literal></title>
|
|
<simpara>
|
|
El motor Zend 1, utilizado por PHP 4, 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 prueba_referencia_global() {
|
|
global $obj;
|
|
$obj = &new stdclass;
|
|
}
|
|
|
|
function prueba_no_referencia_global() {
|
|
global $obj;
|
|
$obj = new stdclass;
|
|
}
|
|
|
|
prueba_referencia_global();
|
|
var_dump($obj);
|
|
prueba_no_referencia_global();
|
|
var_dump($obj);
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
|
|
&example.outputs;
|
|
|
|
<screen>
|
|
NULL
|
|
object(stdClass)(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 &obtener_instancia_ref() {
|
|
static $obj;
|
|
|
|
echo 'Objeto estático: ';
|
|
var_dump($obj);
|
|
if (!isset($obj)) {
|
|
// Asignar una referencia a la variable estática
|
|
$obj = &new stdclass;
|
|
}
|
|
$obj->property++;
|
|
return $obj;
|
|
}
|
|
|
|
function &obtener_instancia_no_ref() {
|
|
static $obj;
|
|
|
|
echo 'Objeto estático: ';
|
|
var_dump($obj);
|
|
if (!isset($obj)) {
|
|
// Asignar el objeto a la variable estática
|
|
$obj = new stdclass;
|
|
}
|
|
$obj->property++;
|
|
return $obj;
|
|
}
|
|
|
|
$obj1 = obtener_instancia_ref();
|
|
$aun_obj1 = obtener_instancia_ref();
|
|
echo "\n";
|
|
$obj2 = obtener_instancia_no_ref();
|
|
$aun_obj2 = obtener_instancia_no_ref();
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
&example.outputs;
|
|
<screen>
|
|
Objeto estático: NULL
|
|
Objeto estático: NULL
|
|
|
|
Objeto estático: NULL
|
|
Objeto estático: object(stdClass)(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>
|
|
|
|
<caution>
|
|
<simpara>
|
|
Además, derreferenciar una propiedad variable que es un array tiene diferente
|
|
semántica entre PHP 5 y PHP 7. La
|
|
<link linkend="migration70.incompatible.variable-handling.indirect">guías de migración de PHP 7.0</link>
|
|
incluye más detalles sobre los tipos de expresiones que han cambiado,
|
|
y cómo colocar llaves para evitar ambigüedades.
|
|
</simpara>
|
|
</caution>
|
|
|
|
<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.
|
|
</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 scrip. 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>
|
|
A partir de PHP 5.4.0, 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>
|
|
Habían otras formas de acceder a la entrada del usuario en versiones antiguas de PHP. Están
|
|
enumeradas abajo. Véase el historial de cambios al final para más detalles.
|
|
<example>
|
|
<title>Old methods of accessing user input</title>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
// OJO: estos métodos ya NO ESTÁN soportados.
|
|
// Los válidos están descritos arriba.
|
|
|
|
// Usar import_request_variables() - esta función ha sido eliminada en PHP 5.4.0
|
|
import_request_variables('p', 'p_');
|
|
echo $p_username;
|
|
|
|
// Estas variables predefinidas fueron eliminadas en PHP 5.4.0
|
|
echo $HTTP_POST_VARS['username'];
|
|
|
|
// Usar register_globals. Esta característica fue eliminada en PHP 5.4.0
|
|
echo $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>
|
|
|
|
<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>
|
|
|
|
<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['conteo'])) {
|
|
$conteo = $_COOKIE['conteo'] + 1;
|
|
} else {
|
|
$conteo = 1;
|
|
}
|
|
setcookie('conteo', $conteo, time()+3600);
|
|
setcookie("Carrito[$conteo]", $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>
|
|
</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>5.4.0</entry>
|
|
<entry>
|
|
Se han eliminado
|
|
<link linkend="security.globals">Register Globals</link>,
|
|
<link linkend="security.magicquotes">Magic Quotes</link> y
|
|
<link linkend="ini.register-long-arrays">register_long_arrays</link>
|
|
</entry>
|
|
</row>
|
|
<row>
|
|
<entry>5.3.0</entry>
|
|
<entry>
|
|
Están obsoletos
|
|
<link linkend="security.globals">Register Globals</link>,
|
|
<link linkend="security.magicquotes">Magic Quotes</link> y
|
|
<link linkend="ini.register-long-arrays">register_long_arrays</link>
|
|
</entry>
|
|
</row>
|
|
<row>
|
|
<entry>4.2.0</entry>
|
|
<entry>
|
|
Ahora, el valor predeterminado de la directiva
|
|
<link linkend="ini.register-globals">register_globals</link> es <emphasis>off</emphasis>.
|
|
</entry>
|
|
</row>
|
|
<row>
|
|
<entry>4.1.0</entry>
|
|
<entry>
|
|
Están disponibles
|
|
<link linkend="language.variables.superglobals">arrays superglobales</link>,
|
|
como <varname>$_POST</varname> y <varname>$_GET</varname> became.
|
|
</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:
|
|
--> |