Conceptos básicos
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.
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: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
Nota:
Para los propósitos de este manual, una letra es a-z, A-Z, y los bytes
del 127 al 255 (0x7f-0xff).
Nota:
$this es una variable especial que no puede ser
asignada.
Para más información sobre funciones relacionadas con variables, vea la
Referencia de Funciones de Variables.
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 Expresiones.
PHP también ofrece otra forma de asignar valores a las variables:
asignar por referencia. 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 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 'Mi nombre es Bob' dos veces:
Algo importante a tener en cuenta es que sólo las variables con nombre
pueden ser asignadas por referencia.
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 echo) se
establecen como una cadena vacía y los arrays se convierten en un array vacío.
Ejemplo #1 Valores predeterminados en variables sin inicializar
<?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);
?>
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.
Un error de nivel E_NOTICE 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 isset()
puede ser usada para detectar si una variable ya ha sido inicializada.
