Referencias en PHP: & a fondo y el bug del foreach

Dos nombres, una caja

Recuerda: cada variable es un nombre en la tabla de símbolos que apunta a una caja (zval). Hasta ahora, cada nombre tenía su propia caja: $b = $a copiaba el valor.

Con & creas una referencia:

$b = &$a;

Esto NO copia nada: hace que el nombre $b apunte a la misma caja que $a. Ahora son dos nombres para un único valor: cambia uno y "cambia" el otro, porque en realidad solo hay una caja.

Avanza paso a paso y observa cómo $b se une a la caja de $a, mientras que $c tiene su propia copia.

<?php
$a = 1;
$c = $a;    // copia el valor
$b = &$a;   // comparte la caja
$b = 99;
echo "a=$a b=$b c=$c\n";

a=99 b=99 c=1

Una referencia no es un puntero

Si vienes de C, olvida los punteros. Una referencia en PHP no es una dirección de memoria: no puedes sumarle 1 ni imprimirla. Es simplemente otro nombre para la misma caja.

¿Qué hace unset($b)? Borra el nombre, no la caja. La caja sigue viva mientras le quede algún nombre (su refcount sea mayor que 0). Cuando nadie la usa, PHP la libera.

Y si después haces $b = 5, se crea un $b nuevo con su propia caja: el vínculo se ha roto.

<?php
$a = "luz";
$b = &$a;
unset($b);
echo "a sigue siendo: $a\n";
$b = "sombra";
echo "a=$a b=$b\n";
$c = &$a;
$c = "eco";
echo "a=$a\n";

a sigue siendo: luz
a=luz b=sombra
a=eco

Paso por referencia

Normalmente una función recibe copias de sus argumentos. Pero si el parámetro lleva &, recibe la caja original:

function subir(&$nivel) {
    $nivel++;
}

Dentro de la función, $nivel y la variable que le pasaste comparten caja: modificar uno es modificar la otra.

Así funcionan sort(), array_push(), shuffle()... Por eso modifican tu array y devuelven true: ¡reciben tu array por referencia!

Solo puedes pasar variables a un parámetro por referencia: subir(5) es un error, porque un 5 no tiene caja que compartir.

<?php
function subir(&$nivel) {
    $nivel++;
}
function subir_copia($nivel) {
    $nivel++;
}
$x = 1;
subir($x);
subir($x);
subir_copia($x);
echo $x, "\n";

3

¿Referencias para ir más rápido? No.

Un mito muy extendido: "pasa los arrays por referencia para no copiarlos y ganar velocidad". Es falso en PHP.

Regla de oro: usa & solo cuando quieras modificar el original a propósito. Si solo quieres leer, pasa por valor.

<?php
function total(array $numeros) {
    // solo leemos: PHP no copia el array
    return array_sum($numeros);
}
function vaciar(array $numeros) {
    // escribimos: se copia (separa) SOLO en este momento
    $numeros = [];
    return count($numeros);
}
$grande = range(1, 1000);
echo total($grande), "\n";
echo vaciar($grande), " ", count($grande), "\n";

500500
0 1000

foreach por referencia

foreach ($array as &$v) hace que $v sea una referencia a cada elemento del array, uno tras otro. Así puedes modificar el array mientras lo recorres:

foreach ($precios as &$p) {
    $p = $p * 2;
}
unset($p);   // ¡IMPORTANTE!

¿Por qué ese unset($p)? Porque al terminar el bucle, $p sigue siendo una referencia al último elemento. Si más adelante usas $p para otra cosa... cambiarás el último elemento del array sin darte cuenta.

Míralo en la página siguiente: es uno de los bugs más famosos de PHP.

<?php
$precios = [10, 20, 30];
foreach ($precios as &$p) {
    $p = $p * 2;
}
print_r($precios);
var_dump($precios);

Array
(
    [0] => 20
    [1] => 40
    [2] => 60
)
array(3) {
  [0]=>
  int(20)
  [1]=>
  int(40)
  [2]=>
  &int(60)
}

El bug del foreach

Este código parece inofensivo: dobla los números y luego los recorre para mostrarlos. Pero el último elemento sale mal.

Qué pasa, paso a paso (compruébalo con la Lupa):

1. Tras el primer bucle, $v es una referencia a $datos[2] (misma caja).
2. El segundo bucle asigna cada elemento a $v... ¡pero $v ES $datos[2]!
3. Vuelta 1: $v = $datos[0] → escribe 2 en $datos[2].
4. Vuelta 2: $v = $datos[1] → escribe 4 en $datos[2].
5. Vuelta 3: $v = $datos[2] → que ahora vale 4.

Resultado: el último elemento es una copia del penúltimo. La solución: unset($v) después del primer bucle (o usar otro nombre de variable).

<?php
$datos = [1, 2, 3];
foreach ($datos as &$v) {
    $v = $v * 2;
}
foreach ($datos as $v) {
    echo $v, " ";
}
echo "\n";
print_r($datos);

2 4 4 
Array
(
    [0] => 2
    [1] => 4
    [2] => 4
)

La rareza: referencias dentro de arrays

Ahora algo que casi nadie sabe. Si un elemento de un array forma parte de una referencia, esa casilla sigue siendo compartida aunque copies el array:

$a = [1, 2, 3];
$r = &$a[0];     // la casilla 0 pasa a ser una referencia
$b = $a;         // "copia"...
$b[0] = "X";     // ¡cambia también $a[0]!

var_dump marca esas casillas con &. Moraleja: las referencias tienen efectos a distancia. Úsalas con mucho cuidado y deshazlas (unset) cuando termines.

<?php
$a = [1, 2, 3];
$r = &$a[0];
$b = $a;
$b[0] = "X";
echo "a[0] = ", $a[0], "\n";
var_dump($a);
unset($r);
$c = [1, 2];
$c2 = $c;
$c2[0] = "Y";
echo "c[0] = ", $c[0], "\n";

a[0] = X
array(3) {
  [0]=>
  &string(1) "X"
  [1]=>
  int(2)
  [2]=>
  int(3)
}
c[0] = 1

Objetos: handles, no referencias

Un último espejo. Los objetos (que verás en el Gremio) se comportan de forma parecida a las referencias... pero no son lo mismo.

Una variable con un objeto NO guarda el objeto: guarda un identificador (handle), algo como "el objeto número 1". Al hacer $b = $a se copia el identificador: los dos apuntan al mismo objeto.

• Si la función modifica el objeto recibido ($o->valor = 5), el cambio se ve fuera: es el mismo objeto.
• Si la función reasigna su parámetro ($o = new ...), fuera no cambia nada: solo cambió su copia del identificador.
• Con &, reasignar SÍ afecta al original: comparten la caja que contiene el identificador.

Mira en la Lupa el montón de objetos: las variables solo guardan #1.

<?php
$dron = new stdClass();
$dron->bateria = 100;
function gastar($d) {
    $d->bateria = 50;
    $d = new stdClass();
    $d->bateria = 0;
}
function cambiar(&$d) {
    $d = new stdClass();
    $d->bateria = 7;
}
gastar($dron);
echo $dron->bateria, "\n";
cambiar($dron);
echo $dron->bateria, "\n";

50
7

Ejercicios de Referencias en PHP resueltos

Intenta resolverlos antes de mirar la solución. En el juego puedes ejecutarlos y comprobarlos automáticamente.

<?php
$precios = [10, 20, 30];
foreach ($precios as &$p) {
    $p = $p * 2;
}
foreach ($precios as $p) {
}
echo implode(", ", $precios);

20, 40, 40

<?php
$a = "sol";
$b = &$a;
$c = $a;
$b = "luna";
unset($a);
echo $b, " ", $c, " ", isset($a) ? "a existe" : "a no existe";

luna sol a no existe

<?php
function intercambiar(&$a, &$b) {
    [$a, $b] = [$b, $a];
}

<?php
foreach ($precios as &$p) {
    $p += 5;
}
unset($p);

<?php
$nombres = ["ana", "luis", "eva"];
foreach ($nombres as &$n) {
    $n = ucfirst($n);
}
foreach ($nombres as $n) {
    echo $n, " ";
}

<?php
$nombres = ["ana", "luis", "eva"];
foreach ($nombres as &$n) {
    $n = ucfirst($n);
}
unset($n);
foreach ($nombres as $n) {
    echo $n, " ";
}

<?php
function cosechar_columna(&$total) {
    for ($i = 0; $i < 3; $i++) {
        if (puede_cosechar()) {
            cosechar();
            $total++;
        }
        mover(NORTE);
    }
}

$total = 0;
for ($col = 0; $col < 3; $col++) {
    cosechar_columna($total);
    mover(ESTE);
}
echo "Total: $total";