Funciones y llamada de funciones — parte 1

Declaración y llamada de funciones

En PHP, una función es un bloque de código que realiza una tarea específica y puede ser reutilizado en diferentes partes del programa. Para declarar una función, se utiliza la palabra clave function seguida del nombre de la función y un par de paréntesis que pueden contener parámetros opcionales.

La sintaxis básica para declarar una función es la siguiente:

function nombreDeLaFuncion() {
    // Código a ejecutar
}

Por ejemplo, si deseamos crear una función que salude al usuario, podríamos declararla de la siguiente manera:

function saludar()
{
    echo "¡Hola, bienvenido!\n";
}

Para llamar o invocar a una función, simplemente escribimos su nombre seguido de paréntesis:

saludar(); // Esto imprimirá: ¡Hola, bienvenido!

Las funciones en PHP ayudan a organizar y estructurar el código, facilitando su mantenimiento y mejorando la reusabilidad. Es importante seguir buenas prácticas al nombrar funciones, utilizando nombres descriptivos y siguiendo una convención consistente, como el uso de lowerCamelCase o snake_case.

Cabe destacar que los nombres de las funciones en PHP no distinguen entre mayúsculas y minúsculas, es decir, la función saludar() es equivalente a SALUDAR(). Sin embargo, por motivos de legibilidad y coherencia, es recomendable mantener un estilo uniforme en el código.

Además, en PHP es posible declarar funciones dentro de estructuras de control, lo que permite crear funciones de manera condicional. Por ejemplo:

$usuarioLogueado = true;

if ($usuarioLogueado) {
    function mostrarPanel()
    {
        echo "Bienvenido al panel de usuario.\n";
    }
}


if ($usuarioLogueado) {
    mostrarPanel(); // Imprime: Bienvenido al panel de usuario.
}

En este caso, la función mostrarPanel() solo será declarada si la variable $usuarioLogueado es verdadera. Sin embargo, es importante usar esta característica con precaución para evitar complicaciones en la estructura del código.

Otra característica de PHP es que permite retornar valores desde una función utilizando la palabra clave return. Aunque este aspecto se profundizará en secciones posteriores, es fundamental entender que return finaliza la ejecución de la función y devuelve un valor al llamante.

Finalmente, es posible definir funciones con parámetros para recibir datos de entrada. Aunque este tema se abordará en detalle más adelante, aquí hay un ejemplo sencillo:

function saludarUsuario($nombre)
{
    echo "¡Hola, $nombre!\n";
}	

saludarUsuario("María"); // Imprime: ¡Hola, María!

Esto demuestra cómo las funciones pueden interactuar con el exterior a través de parámetros, aumentando su flexibilidad y utilidad en diferentes contextos.

Parámetros y argumentos (por valor y referencia)

Las funciones en PHP pueden recibir parámetros que permiten pasar datos desde el contexto de llamada hacia la función. Al invocar una función, los argumentos son los valores que se proporcionan a esos parámetros. Por defecto, PHP pasa los argumentos por valor, pero es posible pasarlos por referencia para modificar directamente la variable original.

Paso de parámetros por valor

Cuando se pasa un argumento por valor, la función recibe una copia del valor original. Esto significa que cualquier modificación realizada dentro de la función no afectará a la variable externa. Este es el comportamiento predeterminado en PHP.

function incrementarPorValor($numero)
{
    $numero += 1;
    echo "Valor dentro de la función: $numero\n";
}

$valor = 5;
incrementar($valor);
echo "Fuera de la función: $valor\n";

Salida:

Dentro de la función: 6
Fuera de la función: 5

En este ejemplo, la variable $valor permanece sin cambios fuera de la función porque se pasó por valor, creando una copia independiente.

Paso de parámetros por referencia

Para que una función pueda modificar la variable original, se debe pasar el argumento por referencia. Esto se logra anteponiendo el símbolo & al nombre del parámetro en la declaración de la función.

function incrementarPorReferencia(&$numero)
{
    $numero += 1;
    echo "Valor dentro de la función: $numero\n";
}

$valor = 5;
incrementar($valor);
echo "Fuera de la función: $valor\n";

Salida:

Dentro de la función: 6
Fuera de la función: 6

Ahora, al pasar $valor por referencia, la función modifica directamente el valor de la variable original.

Consideraciones sobre el uso de referencias

El paso de argumentos por referencia puede ser útil cuando se necesita que la función altere el estado de una variable externa. Sin embargo, es importante usar esta técnica con cautela para mantener la claridad y evitar efectos secundarios no deseados.

Es recomendable utilizar parámetros por referencia en situaciones específicas, como:

• Funciones que modifican objetos grandes: Evita la duplicación innecesaria de datos, mejorando el rendimiento.
• Algoritmos que requieren modificar múltiples valores: Permite retornar múltiples resultados modificando los argumentos.

Combinación de parámetros por valor y referencia

Una función puede tener una combinación de parámetros que se pasan por valor y por referencia. Cada parámetro se define de manera independiente en la declaración.

function procesarDatos($dato1, &$dato2)
{
    $dato1 *= 2;
    $dato2 *= 3;
    echo "Dato 1 dentro de la función: $dato1\n";
    echo "Dato 2 dentro de la función: $dato2\n";
}

$a = 4;
$b = 5;
procesarDatos($a, $b);
echo "Dato1 fuera de la función: $a\n";
echo "Dato2 fuera de la función: $b\n";

Salida:

Dato1 dentro de la función: 8
Dato2 dentro de la función: 15
Dato1 fuera de la función: 4
Dato2 fuera de la función: 15

En este caso, $dato1 se pasa por valor y no afecta a $a fuera de la función, mientras que $dato2 se pasa por referencia y modifica a $b.

Parámetros por referencia en funciones anónimas y closures

En PHP, las funciones anónimas y los closures también pueden utilizar parámetros por referencia. Se sigue la misma sintaxis que en las funciones normales.

$duplicar = function(&$numero) {
    $numero *= 2;
};

$valor = 7;
$duplicar($valor);
echo "Valor duplicado: $valor\n";

Salida:

Valor duplicado: 14

Pasar parámetros por referencia en funciones anónimas es especialmente útil en procedimientos que requieren modificar variables en un contexto más amplio.

Mejores prácticas y novedades recientes

Con las mejoras introducidas en las versiones más recientes de PHP, es importante seguir buenas prácticas al usar parámetros por referencia:

• Claridad del código: Evitar el abuso de referencias puede mejorar la legibilidad y mantenimiento del código.
• Documentación adecuada: Indicar en los comentarios o documentación cuándo una función modifica sus argumentos.
• Uso de tipos: Combinado con el tipado estricto, se puede especificar el tipo de datos esperado, mejorando la robustez.

Ejemplo práctico integrando referencias

A continuación, un ejemplo que muestra una función que intercambia los valores de dos variables utilizando parámetros por referencia:

function intercambiar(&$x, &$y)
{
    $temp = $x;
    $x = $y;
    $y = $temp;
}

$a = 10;
$b = 20;
intercambiar($a, $b);
echo "a: $a, b: $b\n";

Salida:

a: 20, b: 10

La función intercambiar() modifica directamente los valores de $a y $b al recibirlos por referencia.

Valores de retorno

En PHP, las funciones pueden devolver valores utilizando la palabra clave return. Esta permite que una función envíe un resultado al contexto desde el cual fue llamada, lo que es fundamental para la reutilización de código y la construcción de aplicaciones modulares.

La sintaxis básica para retornar un valor es:

function obtenerMensaje()
{
    return "¡Bienvenido a PHP!";
}

Al invocar la función, podemos capturar el valor retornado:

$mensaje = obtenerMensaje();
echo $mensaje; // Imprime: ¡Bienvenido a PHP!

Devolución de diferentes tipos de datos

Las funciones en PHP pueden retornar cualquier tipo de dato, como enteros, cadenas de texto, booleanos, arrays, objetos e incluso funciones anónimas.

Retornando tipos escalares

function multiplicar($a, $b)
{
    return $a * $b;
}

$resultado = multiplicar(4, 5);
echo $resultado; // Imprime: 20

En este ejemplo, la función multiplicar() devuelve un entero producto de los parámetros proporcionados.

Retornando arrays

function obtenerDatosUsuario()
{
    return ['nombre' => 'Ana', 'email' => 'ana@example.com'];
}

$datos = obtenerDatosUsuario();
echo $datos['email']; // Imprime: ana@example.com

Aquí, la función devuelve un array asociativo que contiene información del usuario.

Retornando objetos

function crearObjetoUsuario($nombre)
{
    $usuario = new stdClass();
    $usuario->nombre = $nombre;
    return $usuario;
}

$usuario = crearObjetoUsuario('Luis');
echo $usuario->nombre; // Imprime: Luis

La función crearObjetoUsuario() devuelve un objeto con una propiedad asignada.

Efecto de return en el flujo de ejecución

La instrucción return no solo devuelve un valor, sino que también detiene la ejecución de la función. Cualquier código después de return no será ejecutado.

function comprobarNumero($numero)
{
    if ($numero > 0) {
        return "El número es positivo";
    }

    if ($numero < 0) {
        return "El número es negativo";
    }

    return "El número es cero";
}

echo comprobarNumero(-3); // Imprime: El número es negativo

En este ejemplo, la función devuelve un mensaje dependiendo del valor del número y finaliza su ejecución en cada caso.

Funciones sin valor de retorno

Una función no está obligada a devolver un valor. Si no se específica return, o se utiliza sin un valor, la función devolverá NULL por defecto.

function saludar($nombre) {
    echo "Hola, $nombre";
    // No hay return explícito
}

$saludo = saludar('Carlos'); // Imprime: Hola, Carlos
var_dump($saludo); // Imprime: NULL

La variable $saludo contendrá NULL porque la función saludar() no devuelve ningún valor explícito.

Retorno por referencia

Además de pasar parámetros por referencia, es posible retornar referencias desde una función. Esto se logra colocando un & antes del nombre de la función en su declaración. De esta forma, la función devuelve una referencia a una variable en lugar de su valor.

$contador = 10;

function &obtenerContador()
{
    global $contador;
    return $contador;
}

$contadorReferencia = &obtenerContador();
$contadorReferencia++;
echo $contador; // Imprime: 11

En este caso, $contadorReferencia es una referencia a $contador, por lo que al incrementarla, también se incrementa $contador.

Retorno de funciones anónimas (closures)

Una función puede retornar una función anónima, lo que es útil para crear comportamientos dinámicos.

function generarMultiplicador($factor)
{
    return function ($numero) use ($factor) {
        return $numero * $factor;
    };
}

$duplicar = generarMultiplicador(2);
echo $duplicar(5); // Imprime: 10

La función generarMultiplicador() devuelve un closure que multiplica un número por el factor proporcionado.

Emulación de múltiples valores de retorno

PHP no permite retornar múltiples valores directamente, pero se puede emular este comportamiento retornando un array o un objeto que contenga varios elementos.

Usando arrays

function calcular($a, $b) {
    $suma = $a + $b;
    $producto = $a * $b;
    return [$suma, $producto];
}

list($suma, $producto) = calcular(3, 4);
echo "Suma: $suma, Producto: $producto"; // Imprime: Suma: 7, Producto: 12

Usando objetos

function obtenerCoordenadas()
{
    return (object) ['x' => 10, 'y' => 20];
}

$coordenadas = obtenerCoordenadas();
echo "X: {$coordenadas->x}, Y: {$coordenadas->y}"; // Imprime: X: 10, Y: 20

Al retornar objetos, se pueden manejar resultados más complejos de manera estructurada.

Declaración de tipos de retorno

A partir de PHP 7, se puede declarar el tipo de retorno de una función, lo que permite especificar el tipo de dato esperado.

function obtenerTotal(array $precios): float
{
    return array_sum($precios);
}

$total = obtenerTotal([10.5, 20.75, 15.30]);
echo $total; // Imprime: 46.55

La función obtenerTotal() declara que retornará un float, asegurando que el valor devuelto cumpla con el tipo especificado.

Tipado estricto

Para hacer cumplir estrictamente los tipos de retorno, se puede activar el tipado estricto al inicio del archivo.

declare(strict_types=1);

function dividir(int $dividendo, int $divisor): float {
    return $dividendo / $divisor;
}

$resultado = dividir(10, 3);
echo $resultado; // Imprime: 3.3333333333333

Con strict_types=1, PHP no realizará conversiones automáticas de tipos, lo que mejora la robustez del código.

Buenas prácticas al retornar valores

• Consistencia en los tipos: Es importante que las funciones retornen el mismo tipo de datos en todas las rutas de ejecución para evitar comportamientos inesperados.
• Documentación clara: Detallar en los comentarios qué valores y tipos retorna la función facilita el mantenimiento y comprensión del código.
• Gestión de errores: En lugar de retornar NULL o false ante errores, es recomendable utilizar excepciones para manejar situaciones excepcionales.

Uso de void como tipo de retorno

Desde PHP 7.1, se puede especificar que una función no debe retornar ningún valor utilizando el tipo de retorno void.

function registrarEvento(string $mensaje): void
{
    // Código para registrar el evento
    echo "Evento: $mensaje";
}

registrarEvento("Usuario autenticado");
// Imprime: Evento: Usuario autenticado

Si la función intenta retornar un valor cuando se ha declarado void, PHP generará un error.

Ejemplo práctico: función con tipos de retorno y excepciones

function dividirNumeros(float $numerador, float $denominador): float
{
    if ($denominador === 0.0) {
        throw new Exception('El denominador no puede ser cero');
    }
    return $numerador / $denominador;
}

try {
    $resultado = dividirNumeros(10.0, 0.0);
    echo $resultado;
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage(); // Imprime: Error: El denominador no puede ser cero
}

En este ejemplo, la función dividirNumeros() declara un retorno de tipo float y utiliza una excepción para manejar el caso de división por cero.