Funciones en PHP: parámetros, return, alcance, tipado y callbacks

Hasta ahora vimos variables, condicionales, bucles y arrays. A medida que un programa crece, aparece un problema muy común: la misma lógica empieza a repetirse en varios lugares.

Las funciones permiten agrupar instrucciones bajo un nombre, reutilizarlas y dividir un programa en partes más pequeñas y comprensibles.

¿Qué es una función?

Una función es un bloque de código que realiza una tarea concreta y que puede ejecutarse cuando sea necesario.

En vez de repetir varias veces:

$precio = 1000;
$iva = $precio * 0.21;
$total = $precio + $iva;

podemos encapsular esa lógica dentro de una función y reutilizarla.

Funciones incorporadas y funciones propias

PHP incluye muchas funciones listas para usar, como:

count()
strlen()
var_dump()
array_filter()
date()

Estas funciones ya vienen con PHP.

Pero también podemos crear nuestras propias funciones con la palabra clave function.

Crear una función

function saludar() {
    echo 'Hola desde una función';
}

Esto define la función, pero todavía no la ejecuta.

Llamar una función

saludar();

Cuando PHP encuentra esa llamada, ejecuta el código que está dentro de la función.

¿Por qué usar funciones?

Las funciones ayudan a:

• evitar código repetido;
• dividir problemas grandes en partes pequeñas;
• mejorar la lectura del código;
• facilitar pruebas y mantenimiento;
• reutilizar lógica.

Parámetros

Una función puede recibir valores desde afuera mediante parámetros.

function saludar($nombre) {
    echo 'Hola ' . $nombre;
}

saludar('Ana');

En este caso $nombre es el parámetro de la función.

Parámetros y argumentos

Aunque suelen confundirse, no son exactamente lo mismo:

• parámetro: variable declarada en la función;
• argumento: valor que enviamos al llamar la función.

Ejemplo:

function saludar($nombre) {
    // $nombre es parámetro
}

saludar('Ana'); // 'Ana' es argumento

Más de un parámetro

function sumar($a, $b) {
    return $a + $b;
}

La función recibe dos valores y los utiliza dentro de su lógica.

return

return devuelve un valor al lugar desde donde se llamó la función.

function sumar($a, $b) {
    return $a + $b;
}

$resultado = sumar(10, 5);

echo $resultado;

Resultado:

15

Diferencia entre echo y return

Esta diferencia es fundamental.

echo muestra contenido:

function saludar($nombre) {
    echo 'Hola ' . $nombre;
}

return devuelve un valor para poder seguir utilizándolo:

function obtenerSaludo($nombre) {
    return 'Hola ' . $nombre;
}

$mensaje = obtenerSaludo('Ana');

En general, una función es más reutilizable cuando devuelve datos en lugar de imprimirlos directamente.

return termina la función

Cuando PHP ejecuta return, la función finaliza.

function ejemplo() {
    return 10;

    echo 'Esto nunca se ejecuta';
}

Parámetros con valores por defecto

Podemos hacer que un parámetro sea opcional.

function saludar($nombre = 'Invitado') {
    return 'Hola ' . $nombre;
}

echo saludar();
echo saludar('Ana');

Si no enviamos un argumento, se utiliza 'Invitado'.

Los parámetros obligatorios deben ir primero

Es recomendable escribir primero los parámetros obligatorios y luego los opcionales.

function crearUsuario($nombre, $activo = true) {
    // ...
}

Ejemplo: calcular IVA

function calcularIva($importe, $porcentaje = 21) {
    return $importe * $porcentaje / 100;
}

$iva = calcularIva(10000);

echo $iva;

La lógica del cálculo queda centralizada en un único lugar.

Ejemplo: calcular total con IVA

function calcularTotalConIva($importe, $porcentaje = 21) {
    $iva = $importe * $porcentaje / 100;

    return $importe + $iva;
}

$total = calcularTotalConIva(10000);

Alcance de variables

Una variable creada fuera de una función no está disponible automáticamente dentro de ella.

$nombre = 'Ana';

function mostrarNombre() {
    echo $nombre;
}

Ese código no funciona como muchos principiantes esperan, porque $nombre pertenece al ámbito exterior.

Variables locales

Las variables creadas dentro de una función existen solamente dentro de esa función.

function calcular() {
    $resultado = 10 + 5;

    return $resultado;
}

$resultado es una variable local.

La palabra global

PHP permite acceder a una variable externa mediante global.

$iva = 21;

function mostrarIva() {
    global $iva;

    echo $iva;
}

Aunque existe, conviene evitar depender de variables globales siempre que sea posible. Las funciones suelen ser más fáciles de entender y probar cuando reciben los datos mediante parámetros.

Una alternativa mejor a global

$iva = 21;

function calcularImpuesto($importe, $iva) {
    return $importe * $iva / 100;
}

$resultado = calcularImpuesto(10000, $iva);

La dependencia queda explícita.

Variables static dentro de funciones

Una variable local normalmente se crea de nuevo cada vez que llamamos a la función.

Con static podemos conservar su valor entre llamadas.

function contador() {
    static $numero = 0;

    $numero++;

    return $numero;
}

echo contador(); // 1
echo contador(); // 2
echo contador(); // 3

Tipado de parámetros

PHP permite indicar qué tipo esperamos recibir.

function sumar(int $a, int $b) {
    return $a + $b;
}

Esto expresa que ambos parámetros deben representar enteros.

Tipado de retorno

También podemos indicar qué tipo debe devolver la función.

function sumar(int $a, int $b): int {
    return $a + $b;
}

El : int indica el tipo de retorno.

Ejemplo con string

function nombreCompleto(string $nombre, string $apellido): string {
    return $nombre . ' ' . $apellido;
}

Ejemplo con bool

function esMayorDeEdad(int $edad): bool {
    return $edad >= 18;
}

Esta función no imprime un mensaje. Devuelve true o false, lo que permite reutilizarla dentro de otras condiciones.

Nullable types

En algunos casos queremos aceptar un tipo o null.

function mostrarTelefono(?string $telefono): string {
    return $telefono ?? 'Sin teléfono';
}

?string significa:

string o null

Union types

Desde PHP 8 podemos declarar más de un tipo posible utilizando |.

function mostrarId(int|string $id): string {
    return 'ID: ' . $id;
}

La función acepta un entero o un string.

Funciones que devuelven arrays

function crearUsuario(string $nombre, string $email): array {
    return [
        'nombre' => $nombre,
        'email' => $email,
        'activo' => true
    ];
}

Los arrays son un tipo de retorno muy habitual en PHP.

Paso por valor

Por defecto, los valores simples se pasan de forma que modificar el parámetro no altera necesariamente la variable original.

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

$valor = 10;
duplicar($valor);

echo $valor;

El valor exterior sigue siendo 10.

Paso por referencia con &

Podemos indicar que queremos trabajar directamente sobre la variable original utilizando &.

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

$valor = 10;
duplicar($valor);

echo $valor;

Ahora el resultado es:

20

El paso por referencia debe utilizarse con cuidado porque la función produce un efecto sobre una variable externa.

Funciones anónimas

Una función no siempre necesita tener un nombre.

$saludar = function ($nombre) {
    return 'Hola ' . $nombre;
};

echo $saludar('Ana');

Este tipo de función es muy utilizado en callbacks.

Callbacks

Un callback es una función que enviamos a otra función para que sea ejecutada.

Ya vimos un ejemplo con array_map():

$numeros = [1, 2, 3, 4];

$dobles = array_map(function ($numero) {
    return $numero * 2;
}, $numeros);

array_map() ejecuta nuestro callback para cada elemento.

Arrow functions

PHP permite escribir funciones anónimas simples de forma más compacta mediante fn.

$numeros = [1, 2, 3, 4];

$dobles = array_map(
    fn($numero) => $numero * 2,
    $numeros
);

Captura de variables en arrow functions

Las arrow functions pueden utilizar variables del ámbito exterior automáticamente.

$multiplicador = 3;

$resultado = array_map(
    fn($numero) => $numero * $multiplicador,
    [1, 2, 3]
);

Funciones anónimas y use

En una función anónima tradicional podemos importar variables externas mediante use.

$iva = 21;

$calcular = function ($importe) use ($iva) {
    return $importe * $iva / 100;
};

Ejemplo práctico: calcular descuento

function calcularDescuento(float $total, bool $premium): float {
    if ($premium && $total >= 100000) {
        return $total * 0.20;
    }

    if ($total >= 100000) {
        return $total * 0.10;
    }

    return 0;
}

La función recibe toda la información necesaria y devuelve únicamente el descuento calculado.

Ejemplo práctico: total de productos

function calcularTotal(array $productos): float {
    $total = 0;

    foreach ($productos as $producto) {
        $total += $producto['precio'] * $producto['cantidad'];
    }

    return $total;
}

Una función debería hacer una tarea clara

En general, una función es más fácil de mantener cuando tiene una responsabilidad bien definida.

Es mejor tener:

calcularSubtotal()
calcularIva()
calcularDescuento()

que una función gigantesca llamada:

procesarTodo()

Nombres descriptivos

El nombre debería explicar qué hace la función.

Buenos ejemplos:

calcularTotal()
esMayorDeEdad()
obtenerNombreCompleto()
filtrarProductosActivos()

Nombres poco claros:

hacer()
procesar()
x()

Errores comunes

• confundir echo con return;
• olvidar llamar la función después de crearla;
• depender demasiado de variables globales;
• crear funciones que hacen demasiadas cosas;
• no usar nombres descriptivos;
• usar paso por referencia sin necesidad;
• declarar tipos incompatibles con lo que realmente devuelve la función;
• duplicar lógica en vez de reutilizar una función existente.

Buenas prácticas

• dar a cada función una responsabilidad clara;
• preferir parámetros frente a variables globales;
• devolver datos con return cuando sea posible;
• usar tipos cuando ayuden a expresar la intención;
• mantener funciones relativamente pequeñas;
• elegir nombres que describan la acción.

Ejercicios

1. crear una función que salude a una persona;
2. crear una función que sume dos números;
3. calcular IVA utilizando un parámetro opcional;
4. crear una función que determine si una persona es mayor de edad;
5. crear una función que devuelva nombre y apellido unidos;
6. crear una función que reciba un array y devuelva su suma;
7. declarar tipos de parámetros y retorno;
8. crear una función que acepte string|null;
9. crear una función que acepte un id int|string;
10. probar paso por valor y paso por referencia;
11. duplicar un array de números usando array_map() y una función anónima;
12. reescribir el ejercicio anterior mediante una arrow function;
13. crear una función para calcular descuentos;
14. crear una función que calcule el total de un array de productos.

Qué aprendimos

• qué es una función;
• funciones incorporadas y propias;
• parámetros y argumentos;
• return;
• diferencia entre echo y return;
• valores por defecto;
• alcance de variables;
• global y static;
• tipado de parámetros y retorno;
• nullable y union types;
• paso por valor y por referencia;
• funciones anónimas;
• callbacks;
• arrow functions.

¿Qué sigue?

En la próxima guía comenzaremos a trabajar con formularios HTML y PHP: métodos GET y POST, las variables $_GET y $_POST, validación y procesamiento de datos enviados por el usuario.

¿Te sirvió esta guía? ☕

Si este contenido te ayudó y querés apoyar a Club Programador, podés colaborar mediante:

☕ Apoyar con Mercado Pago

🌎 Apoyar con PayPal