Funciones

• Ejemplo en funciones
• Referencias en arrays
• Notas finales

Referencias en PHP

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

Imagina tener 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 valor en memoria.

Otra forma de decirlo: dos variables apuntan al mismo espacio en memoria (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 porque ambos apuntan al mismo valor 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.

No hay duplicación de datos, ambas variables comparten el mismo valor. 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, en realidad estamos incrementando el valor de $number fuera de la función, aquí de nuevo se evidencia que ambos apuntan al mismo espacio en memoria.

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"

• &$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. Un ejemplo sencillo de uso de referencias en PHP consiste en aplicarlas directamente 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: "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: "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 casos, puedes notar que después del foreach, es buena práctica liberar la referencia:

foreach () {
    // ...
}

unset($number);

Si no lo haces, $number seguirá con el último elemento del array. Y como puedes imaginar esto podría causar problemas si la reutilizas más adelante en el código. En los ejemplos anteriores he comentado la línea unset($number); para que puedas ver cómo se usa sin que te distraiga del objetivo principal.

# 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 usan con precaución.

Directamente se considera una mala práctica usar referencias en código moderno, a menos que sea absolutamente necesario.

Ejemplo de un código innecesario:

<?php

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

$original = 'Esto es un texto original';

addPrefix($original);

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

Veamos ahora el mismo ejemplo, pero sin usar referencias:

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 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 y pruebas de DSA. 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;
    }
}

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;
        }
    }
}

$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, pero es un buen ejercicio para practicar 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. Sin embargo, su sintaxis es la siguiente:

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

$number = 10;

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

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

Pero como mencioné antes, no es común ver este tipo de código en proyectos modernos. Así que lo dejo aquí para no extenderme más.