Variables en PHP: declarar, ámbito, global y static

Una variable en PHP es un nombre que empieza por $, y se crea asignándole un valor: $name = "Ada";. No hay palabra clave de declaración ni tipo que indicar, porque el valor decide el tipo. Más adelante puedes asignarle un valor de otro tipo.

<?php
$name = "Ada";
$age = 36;
$height = 1.65;
$isAdmin = true;

echo "$name is $age years old\n";

$age = $age + 1;           // update the value
$age++;                    // add one more
echo "Two birthdays later: $age\n";

$age = "thirty-eight";     // the type can change too
echo "Now a string: $age\n";

Reglas para nombrar variables

El nombre de una variable empieza por $, luego una letra o un guion bajo, y después cualquier combinación de letras, dígitos o guiones bajos. Las letras no ASCII cuentan como letras, así que $名前 es válido, aunque lo normal son nombres ASCII. Los nombres distinguen mayúsculas y minúsculas.

Así que $city, $City y $CITY son tres variables distintas. Usa snake_case ($first_name) o camelCase ($firstName), y mantén un solo estilo por proyecto. Los estándares PSR dejan abierto a propósito el nombre de las variables; el código de Laravel y Symfony usa mayoritariamente camelCase.

Usar variables en cadenas

Dentro de comillas dobles PHP sustituye las variables por sus valores; dentro de comillas simples, no. Envuelve la variable entre llaves cuando le siguen letras directamente o cuando accedes a un elemento de array con una clave de texto:

<?php
$fruit = "apple";
$basket = ["count" => 4];

echo "I like $fruit pie\n";
echo 'I like $fruit pie' . "\n";              // single quotes: printed as written
echo "Two {$fruit}s please\n";                // braces separate the name
echo "There are {$basket['count']} left\n";   // array key inside a string
echo "Joined: " . $fruit . " and pear\n";     // concatenation with .

La página de cadenas explica en detalle las comillas, la concatenación y la interpolación.

Variables no definidas y valores por defecto

Leer una variable a la que nunca se le asignó nada da null, y tu PHP imprime un warning:

Warning: Undefined variable $discount in /home/index.php on line 3

Compruébala antes con isset, o usa el operador de fusión de null ?? para dar un valor por defecto. Ninguno de los dos produce un warning:

<?php
$price = 50;

$discount = $discount ?? 0;    // use 0 when $discount is not set
echo "Price: " . ($price - $discount) . "\n";

if (isset($coupon)) {
    echo "Coupon: $coupon\n";
} else {
    echo "No coupon given\n";
}

$coupon = null;
var_dump(isset($coupon));      // a variable holding null counts as not set

$x ??= 0; es la forma corta de $x = $x ?? 0;. Los valores de formularios y de la URL son el caso habitual: $page = $_GET['page'] ?? 1;.

Ámbito de las variables en funciones

Las variables definidas fuera de una función no son visibles dentro de ella, y las variables creadas dentro de una función desaparecen cuando esta termina. Es la sorpresa más común para quien viene de JavaScript:

<?php
$taxRate = 0.2;

function priceWithTax($price)
{
    // $taxRate does not exist here, so ?? falls back to 0
    return $price * (1 + ($taxRate ?? 0));
}

function priceWithTaxFixed($price, $rate)
{
    return $price * (1 + $rate);   // pass what the function needs
}

echo priceWithTax(100), "\n";
echo priceWithTaxFixed(100, $taxRate), "\n";

Sin el ?? 0, la primera función daría un warning por $taxRate no definida. Pasar los valores como parámetros mantiene las funciones predecibles y fáciles de probar, y es lo primero que deberías usar. La página de funciones explica los parámetros y los valores de retorno.

La palabra clave global y $GLOBALS

Cuando una función realmente necesita usar una variable global, decláralo con global, o accede a través del array $GLOBALS, que contiene todas las variables globales por su nombre:

<?php
$visits = 0;
$siteName = "Bakery";

function countVisit()
{
    global $visits;      // now $visits refers to the global variable
    $visits++;
}

function title()
{
    return "Welcome to " . $GLOBALS['siteName'];
}

countVisit();
countVisit();
echo "Visits: $visits\n";
echo title(), "\n";

Las globales hacen el código más difícil de seguir, porque cualquier función puede modificarlas. Aparecen en código antiguo y en plugins de WordPress (global $wpdb;); en código nuevo, pasa los valores o usa una clase.

Las variables static conservan su valor

Una variable static dentro de una función se crea una vez y conserva su valor entre llamadas. Sigue siendo local: el código de fuera de la función no puede verla.

<?php
function nextTicket(): int
{
    static $number = 100;   // runs only on the first call
    $number++;
    return $number;
}

echo nextTicket(), "\n";
echo nextTicket(), "\n";
echo nextTicket(), "\n";

function expensiveLookup(string $key): string
{
    static $cache = [];
    if (!isset($cache[$key])) {
        echo "(computing $key) ";
        $cache[$key] = strtoupper($key);
    }
    return $cache[$key];
}

echo expensiveLookup("php"), "\n";
echo expensiveLookup("php"), "\n";   // second call uses the cache

Variables variables ($$name)

$$name usa el valor de $name como nombre de otra variable. Funciona, pero casi siempre un array hace lo mismo con más claridad:

<?php
$field = "color";
$$field = "blue";        // creates $color
echo $color, "\n";

// The clearer way to have names chosen at runtime:
$settings = [];
$settings[$field] = "blue";
echo $settings["color"], "\n";

Copia o referencia

Asignar una variable a otra copia el valor, arrays incluidos. Pon & delante para que los dos nombres apunten al mismo valor:

<?php
$a = [1, 2, 3];
$b = $a;          // copy
$b[] = 4;
echo "a has " . count($a) . ", b has " . count($b) . "\n";

$c = &$a;         // reference: $c and $a are the same array
$c[] = 99;
echo "a has " . count($a) . " after changing c\n";

function addBonus(int &$points)
{
    $points += 10;
}
$score = 5;
addBonus($score);
echo "Score: $score\n";

unset($b);
var_dump(isset($b));

Los objetos se comportan de otra forma: asignar un objeto copia un manejador al mismo objeto, así que los cambios hechos a través de una variable se ven a través de la otra. Usa clone para obtener una copia real.

Error frecuente: una variable definida dentro de un if o de un bucle

PHP no tiene ámbito de bloque, así que una variable creada dentro de if, for o foreach sigue existiendo después. Eso ayuda, pero esconde un bug: cuando el bloque no se ejecuta, la variable nunca se creó.

<?php
$orders = [];   // try [120, 80] here

$message = "No orders yet";   // set a default before the loop
foreach ($orders as $amount) {
    $message = "Last order: $amount";
}
echo $message, "\n";

foreach ([1, 2, 3] as $n) {
    $last = $n;
}
echo "Still visible after the loop: $last\n";

Sin la línea del valor por defecto, un $orders vacío dejaría $message sin definir e imprimiría un warning. Da a cada variable un valor antes del bloque que podría asignarlo.