Argumentos de Funciones en PHP: Guía Práctica y Profesional

Argumentos por valor y por referencia
Argumentos con valores predeterminados
Determinación de tipos (type hinting)
Function handling Functions

Ya vimos anteriormente en Funciones en PHP explicadas de forma simple cómo se define y se utiliza una función en PHP. También estudiamos la diferencia entre argumentos y parámetros.

Sin embargo, vamos a profundizar un poco más en el tema de los argumentos. Queremos ser profesionales, y para ello es fundamental entender bien cómo funcionan.

Los argumentos son un cúmulo de valores separados por comas que se revisan de izquierda a derecha, su propósito es pasar información a las funciones.

// Estos son los parámetros 
function example($name, $age, $is_admin) {
    // ...
}

// Estos son los argumentos
example('Administrador', 36, true);

Vamos a profundizar...

Argumentos por valor y por referencia

Por valor, es la forma predeterminada y básica de pasar argumentos a una función. Estos significa pasar una copia del valor a la función. Si el valor cambia dentro de la función, se mantiene igual fuera de la función. Es decir, no afecta al valor original (únicamente la copia).

function changeValue($value) {
    $value = 10; 

    return $value;
}

$originalValue = 5;

echo changeValue($originalValue); // Imprime 10
echo $originalValue; // Imprime 5

Por referencia, en cambio, modificamos el valor original (en nuestro caso $originalValue). Aquí usamos el símbolo & antes del nombre del parámetro en la definición de la función, es decir, &$value, veamos el ejemplo.

function changeValue(&$value) {
    $value = 10; 

    return $value;
}

$originalValue = 5;

echo changeValue($originalValue); // Imprime 10
echo $originalValue; // Imprime 10

Esto es exageradamente útil en soluciones avanzadas, algoritmos complejos y también en pruebas técnicas. Conocer este concepto le dice al reclutador que sabes de lo que hablas.

Ejemplo práctico 1:

function addItemToArray(array &$array, $item): void {
    $array[] = $item;
}

$items = ['laptop', 'phone'];

addItemToArray($items, 'keyboard');

print_r($items); // Imprime ['laptop', 'phone', 'keyboard']

Ejemplo práctico 2:

function sanitizeArray(array &$data): void {
    foreach ($data as &$value) {
        $value = trim($value);        
        $value = htmlspecialchars($value);
    }
}

$input = [
    "  Italo Morales Fantone      ",
    "[email protected]",
    "     I love PHP! <script>alert('Te he hackeado ;)');</script>   ",
];

sanitizeArray($input);

print_r($input);

/* Imprime:
Array
(
    [0] => Italo Morales Fantone
    [1] => [email protected]
    [2] => I love PHP! &lt;script&gt;alert(&#039;Te he hackeado ;)&#039;);&lt;/script&gt;
)
*/

trim: Elimina espacios en blanco al inicio y al final de un string.
htmlspecialchars: Convierte caracteres especiales en entidades HTML para evitar inyecciones de código.
print_r: Imprime de manera legible una variable (es muy útil para hacer debugging de arrays y objetos).

Aquí hicimos dos referencias, una para (&$data) y otra en el foreach para (&$value). La razón es que queremos modificar el array original y también cada valor dentro del array.

Es decir:

&$data: Referencia al array completo (así evitamos copiar todo el array en memoria).
&$value: Referencia a cada elemento dentro del foreach (esto nos permite modificar los valores directamente).

Al trabajar por referencia, seguro te preguntas lo siguiente:

¿Por qué queremos evitar un return?
¿Por qué quiero evitar copiar el valor en memoria?
¿Por qué quiero modificar el valor original?

La respuesta es simple: se trata de eficiencia. Cuando trabajamos con grandes estructuras de datos, pasar por referencia evita la sobrecarga en memoria. Vamos a estudiar este y otros puntos importantes:

Ganas eficiencia en memoria y velocidad:

Permíteme profundizar. Con referencias modificamos el valor original, así evitamos la creación de copias en memoria y ganamos velocidad. Esto debe ser estratégico y pensado. Si abusas de las referencias, puedes hacer que el código sea más difícil de entender. En otras palabras, úsalo con criterio porque no todo debe ser por valor ni todo debe ser por referencia.

Evitas asignaciones innecesarias:

Con return, es decir, por valor:

$items = addItemToArray($items, 'keyboard');

Por referencia:

addItemToArray($items, 'keyboard');

El segundo es más limpio cuando lo que quieres es un efecto directo y no un valor nuevo.

Es compatible con funciones void:

Muchas veces necesitamos hacer algo y simplemente no devolver nada. Esto se conoce como : void. Mi función lo hace, y funciones propias de PHP como sort() funcionan así. No devuelven nada, solo modifican el valor original.

$nums = [9, 3, 5, 1, 7];

sort($nums);

print_r($nums); // Imprime [1, 3, 5, 7, 9]

Argumentos con valores predeterminados

Este es el concepto más sencillo de todos pero es muy útil. Imagina registrar usuarios en un sistema, y que el rol predeterminado sea "usuario". Si no se especifica el rol, se asigna "usuario" por defecto.

function registerUser(string $username, string $role = 'user'): string {
    // Aquí iría la lógica de la base de datos

    return "Registered $username with role $role";
}

echo registerUser('valentina'); // Imprime "Registered valentina with role user"

echo registerUser('administradora', 'admin'); // Imprime "Registered administradora with role admin"

Como norma general, los valores predeterminados deben ir después de los que no los tienen. Esto evita confusiones al llamar a la función. Y como puedes imaginar el tipo y el valor predeterminado puede ser array, null, string, int, float, bool, etc.

Determinación de tipos (type hinting)

En cada ejemplo lo hago, para que se haga costumbre trabajar con buenas prácticas. A veces lo llamo "determinación de tipos", "type hinting" o "tipos de parámetros y retorno". Es lo mismo.

function greet(string $name = 'Sr./Sra. Guest'): string {
    return "Hello, $name!";
}

Aquí qué vemos:

string $name: El parámetro $name debe ser de tipo string.
= 'Sr./Sra. Guest': Si no se pasa un valor, se usará el valor predeterminado.
: string: La función debe devolver un valor de tipo string.

Recuerda lo que estudiamos en (Funciones en PHP explicadas de forma simple):

Un parámetro es la variable que se define en la función, en nuestro ejemplo $name.
Un argumento es el valor que se pasa a la función cuando se llama, en nuestro ejemplo cualquier string como 'Valentina' o el string por defecto 'Sr./Sra. Guest'.

Esto en realidad es exigir un tipo determinado y si no se cumple, se generará un error. Es una capa extra de seguridad y profesionalismo.

Function handling Functions

En español se traduce como "manejo de funciones con funciones" o "funciones que manejan funciones". Es un tema avanzado. Las explicaré todas en otro artículo, pero aquí te dejo una introducción rápida de las que aplican a los argumentos.

Vamos a enfocarnos en la frase "número variable de argumentos". Así que imagina que tienes una función que puede recibir cualquier cantidad de argumentos, y quieres procesarlos todos. Ok, es donde entran en juego:

func_get_args(): Obtiene un array con todos los argumentos pasados a la función.

function exampleFuncGetArgs($param1, $param2) {
    return func_get_args();
}

print_r(exampleFuncGetArgs('first', 'second')); // Imprime ['first', 'second']

func_num_args(): Devuelve el número de argumentos pasados a la función.

function exampleFuncNumArgs($param1, $param2) {
    return func_num_args();
}

echo exampleFuncNumArgs('first', 'second'); // Imprime 2

func_get_arg(): Devuelve un argumento específico según su index.

function exampleFuncGetArg($param1, $param2) {
    return func_get_arg(0);
}

echo exampleFuncGetArg('first', 'second'); // Imprime 'first'

Como puedes ver son bloques simples, y mi proposito es enseñar código profesional con ejemplos reales, no solo sintaxis (para ello existe la web oficial de PHP). Por eso, ademas de enseñar estos ejemplos simples de sumas, multiplicaciones y saludos, te preparé un bloque de código real que junta lo aprendido en este y otros artículos.

function logger(string $type, string $text): string {
    $num_args = func_num_args();

    if ($num_args > 2) {
        $args = func_get_args();

        $extra_values = array_slice($args, 2);

        $text = vsprintf($text, $extra_values);
    }

    return strtoupper($type) . ': ' . $text . PHP_EOL;
}

// Sin argumentos adicionales
echo logger('info', 'Inicio de sesión en proceso');

// Con argumentos adicionales
echo logger('debug', 'La variable PI tiene el valor: "%.2f"', 3.14159);
echo logger('error', 'Proceso fallido: %s, (%s)', 'Conexión rechazada', 'Intentando reconectar...');
echo logger('error', 'Archivo no encontrado: "%s"', './file.txt');
echo logger('info', 'El usuario "%s" ha iniciado sesión a las "%s"', 'admin', date('H:i:s'));
echo logger('warning', 'Espacio en disco bajo: "%d%%" restante', 5);
echo logger('warning', 'Memoria usada: "%dMB" de "%dMB"', 512, 1024);

/* Imprime:
INFO: Inicio de sesión en proceso
DEBUG: La variable PI tiene el valor: "3.14"
ERROR: Proceso fallido: Conexión rechazada, (Intentando reconectar...)
ERROR: Archivo no encontrado: "./file.txt"
INFO: El usuario "admin" ha iniciado sesión a las "16:30:45"
WARNING: Espacio en disco bajo: "5%" restante
WARNING: Memoria usada: "512MB" de "1024MB"
*/

De hecho, aquí en logger() se ve claramente la diferencia entre parámetros y argumentos: tenemos dos parámetros obligatorios ($type y $text) y un número variable de argumentos adicionales que se manejan con func_get_args().

Definiciones:

array_slice(): Extrae una porción de un array, en nuestro caso desde el index 2 (es decir, los argumentos adicionales).
vsprintf(): Da formato a un string.
strtoupper(): Convierte un string en mayúsculas.
PHP_EOL: Constante (End Of Line) que representa el final de línea (lo usamos mucho en terminales).
.2f: Formato para números flotantes con 2 decimales, la f significa float.
%s: Formato para strings.
%d: Formato para enteros (decimales).

Respecto a vsprintf(), la v significa "vector", la s significa "string" y el printf significa "print formatted" (imprimir con formato). Es una función muy útil cuando trabajamos con placeholders dentro de un string (como %s, %d, %.2f, etc.) y quieres reemplazarlos con valores específicos.