Funciones en PHP: parámetros, retorno y tipado

Hola, ¿cómo están? Continuando con el curso de PHP, hoy veremos las funciones. Esta lección marca un antes y un después: es donde el código deja de ser una lista de instrucciones y empieza a estar organizado.

¡Empecemos!

Qué es una función

Una función es un bloque de código con nombre que realiza una tarea concreta y puede reutilizarse todas las veces que haga falta.

La idea de fondo: escribes la lógica una vez y la usas muchas. Si mañana hay que corregirla, la corriges en un solo lugar.

Declarar y usar una función

<?php
function saludar()
{
    echo "Hola, bienvenido";
}

saludar();   // Hola, bienvenido
saludar();   // se puede llamar cuantas veces quieras

Se declara con la palabra function, seguida del nombre y unos paréntesis. El cuerpo va entre llaves. Para ejecutarla se escribe su nombre con paréntesis.

Sobre el nombre: usa verbos, porque una función hace algo. calcularTotal(), enviarCorreo(), validarEmail(). En PHP lo habitual es camelCase.

Parámetros

Los parámetros permiten que la función trabaje con datos distintos en cada llamada:

<?php
function saludar($nombre)
{
    echo "Hola, $nombre";
}

saludar("Víctor");   // Hola, Víctor
saludar("Ana");      // Hola, Ana

Puedes tener varios, separados por comas:

<?php
function calcularTotal($precio, $cantidad)
{
    echo $precio * $cantidad;
}

calcularTotal(120, 3);   // 360

Valores por defecto

Un parámetro puede tener un valor que se usa si no le pasas nada:

<?php
function saludar($nombre = "invitado")
{
    echo "Hola, $nombre";
}

saludar();           // Hola, invitado
saludar("Víctor");   // Hola, Víctor

Una regla que PHP exige: los parámetros con valor por defecto van al final. Si pones uno obligatorio después de uno opcional, no hay forma de omitir solo el primero.

Devolver valores con return

Hasta ahora las funciones imprimían directamente. Lo habitual es que devuelvan un resultado para que quien la llamó decida qué hacer con él:

<?php
function calcularTotal($precio, $cantidad)
{
    return $precio * $cantidad;
}

$total = calcularTotal(120, 3);
echo $total;                       // 360
echo calcularTotal(50, 2) * 1.13;  // se puede usar en una expresión

La diferencia entre echo y return dentro de una función es importante:

• Con echo, la función imprime y no sirve para nada más.
• Con return, la función entrega un valor que puedes guardar, operar o mostrar.

Prefiere siempre return. Una función que solo imprime es mucho menos reutilizable.

return termina la función

En cuanto se ejecuta un return, la función se detiene:

<?php
function esMayorDeEdad($edad)
{
    if ($edad >= 18) {
        return true;
    }

    return false;
}

Esto permite la salida temprana que vimos en condicionales: compruebas lo que descarta y sales cuanto antes.

Tipado de parámetros y retorno

Aquí está una de las mejoras grandes de PHP moderno. Puedes declarar qué tipo espera y qué tipo devuelve una función:

<?php
function calcularTotal(float $precio, int $cantidad): float
{
    return $precio * $cantidad;
}

¿Para qué sirve? Para que los errores aparezcan al llamar la función, no tres pantallas después con un resultado raro:

<?php
calcularTotal("hola", 3);   // TypeError, y te dice exactamente dónde

Los tipos disponibles son int, float, string, bool, array, void (no devuelve nada) y los nombres de tus propias clases.

Para forzarlo del todo, añade esta línea al inicio del archivo:

<?php
declare(strict_types=1);

Sin ella, PHP intenta convertir "5" a 5. Con ella, exige el tipo exacto. Actívala siempre: es una de las mejores costumbres que puedes tomar.

Tipos que aceptan null

Si un parámetro puede no tener valor, se marca con ?:

<?php
function saludar(?string $nombre): string
{
    return "Hola, " . ($nombre ?? "invitado");
}

Argumentos con nombre

Desde PHP 8 puedes pasar argumentos indicando su nombre, en cualquier orden:

<?php
function crearUsuario(string $nombre, string $rol = "lector", bool $activo = true)
{
    // ...
}

crearUsuario(nombre: "Ana", activo: false);

Esto resuelve un problema clásico: cuando una función tiene varios parámetros opcionales y solo quieres cambiar el último. Y además hace la llamada mucho más legible: crearUsuario("Ana", "lector", false) no dice nada; con nombres, sí.

El ámbito de las variables

Lo adelantamos en la lección de variables y aquí cobra sentido.

Una función no ve las variables de fuera:

<?php
$mensaje = "Hola";

function mostrar()
{
    echo $mensaje;   // Error: no existe aquí dentro
}

Y las variables creadas dentro no existen fuera:

<?php
function calcular()
{
    $resultado = 100;
}

calcular();
echo $resultado;   // Error: no existe aquí

Esto no es un inconveniente, es una protección: cada función es una caja cerrada y no puede romper por accidente algo de otra parte del programa.

La forma correcta de comunicarlas es pasar datos por parámetro y recibir el resultado con return. Existe la palabra global para saltarse esto, pero evítala: hace que el código sea impredecible.

Paso por valor y por referencia

Por defecto, la función recibe una copia:

<?php
function duplicar($numero)
{
    $numero = $numero * 2;
}

$valor = 10;
duplicar($valor);
echo $valor;   // sigue siendo 10

Con & recibe la variable original:

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

$valor = 10;
duplicar($valor);
echo $valor;   // ahora 20

Úsalo con cuidado: una función que modifica lo que recibe es más difícil de seguir. En general es preferible devolver el nuevo valor.

Un ejemplo práctico

<?php
declare(strict_types=1);

const IVA = 0.13;

function calcularSubtotal(float $precio, int $cantidad): float
{
    return $precio * $cantidad;
}

function aplicarDescuento(float $monto, float $porcentaje = 0): float
{
    return $monto - ($monto * $porcentaje);
}

function calcularTotal(float $precio, int $cantidad, float $descuento = 0): float
{
    $subtotal = calcularSubtotal($precio, $cantidad);
    $conDescuento = aplicarDescuento($subtotal, $descuento);

    return round($conDescuento * (1 + IVA), 2);
}

echo calcularTotal(precio: 250, cantidad: 3, descuento: 0.10);

Fíjate en cómo cada función hace una sola cosa y se combinan entre ellas. Esa es la idea que hay detrás de todo esto.

Errores comunes

• Usar echo en vez de return. Limita muchísimo la reutilización.
• Funciones que hacen demasiado. Si el nombre necesita un «y» —validarYGuardarUsuario()—, probablemente son dos funciones.
• Depender de variables globales en lugar de parámetros.
• Poner parámetros obligatorios después de los opcionales. PHP no lo permite.

Para cerrar

Las funciones son el primer paso hacia el código organizado: una tarea, un nombre, un resultado. Si además usas tipado y strict_types, el propio lenguaje te avisa cuando algo no encaja.

En la siguiente lección veremos las funciones anónimas y las arrow functions.

Saludos y éxitos.