• Ejemplo en funciones
• Referencias en arrays
• Notas finales

Hay varias formas de explicar este concepto, pero la más sencilla es pensar en las referencias como alias de variables.

Imagina que tienes dos variables que hagan referencia al mismo contenido. Esto significa que si se modifica el contenido de una de las variables, la otra también reflejará ese cambio. El concepto oficial dice que una referencia no es una copia del valor, sino otro nombre para el mismo espacio en memoria.

Otra forma de decirlo sería la siguiente: dos variables que apuntan al mismo espacio en memoria (es decir, ambas cuentan con el mismo contenido).

$x = 3;
$y = &$x; // Creamos una referencia de $x

$y = 5;

echo $x; // Imprime 5
echo $y; // Imprime 5

En este caso, $y es una referencia a $x. Quiere decir que cuando cambiamos el valor de $y, también cambiamos el valor de $x, ahí es donde se evidencia que ambos apuntan al mismo espacio en memoria.

Y si cambiamos el valor de $x, también veremos ese cambio reflejado en $y:

// ...

$x = 9;

echo $x; // Imprime 9
echo $y; // Imprime 9

Las referencias se activan usando el signo & llamado ampersand.

En nuestro ejemplo, con $y = &$x; hemos creado una referencia de $x en $y. Y básicamente indica que $y es un alias de $x, o que $y y $x apuntan al mismo espacio en memoria como mencioné antes.

Recuerda, no hay duplicación de datos, ambas variables comparten el mismo valor porque apuntan al mismo espacio. Esto es todo. Son muchas formas de decir lo mismo, algunas de ellas te ayudarán a entender mejor el concepto.

# Ejemplo en funciones

El ejemplo clásico es el de incrementar un valor dentro de una función:

function addOne(int &$num) {
    $num++;
}

$number = 5;

addOne($number);

echo $number; // Imprime 6

En este caso, addOne es la función que recibe una referencia a la variable $number. Cuando incrementamos $num dentro de la función, también estamos incrementando el valor de $number que está fuera de la función.

Veamos este otro ejemplo interesante que vi en la universidad:

function addIVA(float &$price) {
    $price += ($price * 9) / 100;
}

$originalPrice = 100;

addIVA($originalPrice);

echo "Precio con IVA: $originalPrice"; // Imprime "Precio con IVA: 109"

Aquí está lo que sucede:

• &$price indica que $price se pasa por referencia, no por valor.
• Significa que la función modifica directamente la variable original llamada $originalPrice.
• El cálculo $price += ($price * 9) / 100; añade el 9% al precio original. En nuestro ejemplo, el precio es 100, así que el precio con IVA será 109.

# Referencias en arrays

Este tipo de casos suele evaluarse en entrevistas técnicas o pruebas de DSA, pueden pedirte que uses referencias dentro de un foreach, o mediante funciones diseñadas para modificar los valores de un array.

Respecto al foreach, el enunciado podría ser algo como esto: "Duplica cada valor en el array usando referencias".

$numbers = [3, 6, 7, 9];

foreach ($numbers as &$number) {
    $number *= 2;
}

// unset($number);

print_r($numbers); // Imprime: 6, 12, 14, 18

DSA significa Data Structures and Algorithms (Estructuras de Datos y Algoritmos).

Respecto a las funciones, el enunciado podría ser el siguiente: "Crea una función que reciba un array y duplique cada valor usando referencias".

function doubleValues(array &$array) {
    foreach ($array as &$number) {
        $number *= 2;
    }

    // unset($number);
}

$numbers = [3, 6, 7, 9];

doubleValues($numbers);

print_r($numbers); // Imprime: 6, 12, 14, 18

Aquí es importante mencionar que al crear este estilo de código, es recomendable liberar la referencia después de usarla, básicamente para evitar efectos secundarios no deseados en futuras operaciones con la variable.

En ambos ejemplos, puedes notar que después del foreach incluí una línea comentada con unset($number);:

foreach () {
    // ...
}

unset($number);

Si no lo haces, $number seguirá con el último elemento del array. Esto puede causar problemas si reutilizas la variable más adelante. En los ejemplos anteriores he comentado dicha línea para que puedas ver el concepto principal sin distracciones, pero en código real es una buena práctica incluirla.

# Notas finales

La moraleja es que las referencias en PHP son una herramienta poderosa para manipular datos directamente en memoria sin necesidad de crear copias adicionales. Esto puede ser especialmente útil para optimizar el rendimiento en operaciones con grandes conjuntos de datos.

Pero también hay que tener cuidado al usarlas, ya que pueden hacer que el código sea más difícil de entender y mantener si no se tratan con precaución. En el código moderno, directamente se consideran una mala práctica, a menos que te consigas con una situación en la que sea absolutamente necesario. Veamos un par de ejemplos:

1. Ejemplo de un código innecesario: solución con referencias.

<?php

function addPrefix(&$text) {
    $text = "Example: $text";
}

$original = 'Esto es un texto original';

addPrefix($original);

echo $original; // Imprime "Example: Esto es un texto original"

2. Veamos ahora el mismo ejemplo, pero sin usar referencias: la misma funcionalidad, pero de una forma más limpia y predecible.

function addPrefix(string $text): string {
    return "Example: $text";
}

$original = 'Esto es un texto original';

echo addPrefix($original); // Imprime "Example: Esto es un texto original"

Las referencias en PHP son una herramienta poderosa, pero recuerda, deben usarse con conciencia y moderación. Pienso que la mayoría de los casos pueden resolverse sin ellas, y el código resultante será más limpio y fácil de mantener. Al final, el objetivo siempre debe ser mantener un código más predecible y menos propenso a errores.

Dominar este concepto te brinda mayor pensamiento crítico y te ayuda a entender lo que se conoce como abstracción en programación. Por ello lo toman en cuenta en entrevistas técnicas.

Veamos un ejemplo final:

Título del reto: "Reemplaza los valores nulos en un array por el integer 0 usando referencias".

$values = [1, 2, null, 4, null, 6];

foreach ($values as &$value) {
    if (is_null($value)) {
        $value = 0;
    }
}

unset($value);

print_r($values); // Imprime: [1, 2, 0, 4, 0, 6]

Aunque también podrían darte un código inicial que incluya funciones:

function replaceNulls(array &$array) {
    foreach ($array as &$value) {
        if (is_null($value)) {
            $value = 0;
        }
    }

    unset($value);
}

$values = [1, 2, null, 4, null, 6];

replaceNulls($values);

print_r($values); // Imprime: [1, 2, 0, 4, 0, 6]

Se parece muchos a lo visto anteriormente, son buenos ejercicios para practicar las referencias en PHP. Podemos continuar con ejemplos más complejos como return by reference y luego extendernos a objetos, pero sinceramente no creo que valga la pena ahondar más en este tema.

De momento, solo para que veas cómo se ve un return by reference, aquí tienes un ejemplo:

function &getValue(&$value) {
    return $value;
}

$number = 10;

$ref = &getValue($number);
$ref = 20;

echo $number; // Imprime 20
echo $ref;    // Imprime 20

Como mencioné antes, no es nada común ver este tipo de código en proyectos modernos.