Funciones en PHP: return, parámetros, tipos y recursividad

Forjar una función

Hasta ahora has llamado funciones de PHP (strlen, count...) y de BIT-8. Ahora vas a declarar las tuyas:

function saludar($nombre) {
    return "¡Hola, $nombre!";
}

• function + nombre + paréntesis con los parámetros + bloque.
• return devuelve un valor y termina la función en ese momento.
• Se usa igual que cualquier otra: echo saludar("Vera");

Beneficios: escribes el código una vez (principio DRY: Don't Repeat Yourself), le das un nombre que explica qué hace, y si hay un bug lo arreglas en un solo sitio.

<?php
echo saludar("Vera"), "\n";

function saludar($nombre) {
    return "¡Hola, $nombre!";
}

function area($ancho, $alto) {
    return $ancho * $alto;
}
echo saludar("Forja"), "\n";
echo "Área: ", area(3, 4), "\n";

¡Hola, Vera!
¡Hola, Forja!
Área: 12

return

Algunas cosas importantes sobre return:

• Puedes tener varios return (por ejemplo, dentro de un if). El primero que se ejecuta termina la función.
• Si una función termina sin return, devuelve null.
• Devolver no es imprimir. Una función que hace echo escribe en pantalla, pero no te da ningún valor para seguir trabajando. Casi siempre es mejor que la función devuelva y que decida quien la llama si lo imprime.

<?php
function signo($n) {
    if ($n > 0) {
        return "positivo";
    }
    if ($n < 0) {
        return "negativo";
    }
    return "cero";
}
echo signo(-4), " ", signo(0), "\n";

function mal($a, $b) {
    $suma = $a + $b;
}
var_dump(mal(2, 3));

negativo cero
NULL

Valores por defecto y argumentos con nombre

Un parámetro puede tener un valor por defecto: si no lo pasas, se usa ese.

function precio($base, $descuento = 0) { ... }
precio(100);       // descuento = 0
precio(100, 20);   // descuento = 20

Los parámetros con valor por defecto van al final.

Argumentos con nombre (PHP 8): puedes indicar a qué parámetro va cada valor, en cualquier orden, y saltarte los que tienen valor por defecto:

precio(descuento: 50, base: 10);

Si llamas a una función con menos argumentos de los obligatorios, PHP lanza un ArgumentCountError.

<?php
function etiqueta($producto, $cantidad = 1, $unidad = "sacos") {
    return "$cantidad $unidad de $producto";
}
echo etiqueta("heno"), "\n";
echo etiqueta("heno", 5), "\n";
echo etiqueta("leche", 2, "litros"), "\n";
echo etiqueta(unidad: "cajas", producto: "fresas"), "\n";

1 sacos de heno
5 sacos de heno
2 litros de leche
1 cajas de fresas

Tipos en parámetros y retorno

Puedes declarar el tipo de cada parámetro y del valor devuelto:

function area(int $lado): int {
    return $lado * $lado;
}

Tipos habituales: int, float, string, bool, array, ?int (int o null), int|string (uno u otro), void (no devuelve nada), mixed (cualquiera).

¿Qué pasa si pasas "5" a un parámetro int? Depende del modo:

• Modo coercitivo (por defecto): PHP intenta convertirlo. "5" → 5. Pero "hola" no se puede: TypeError.
• Modo estricto: poniendo declare(strict_types=1); al principio del archivo, NO convierte nada: "5" a un int es un TypeError. (La única excepción: un int se acepta donde se pide un float.)

<?php
function area(int $lado): int {
    return $lado * $lado;
}
echo area(3), "\n";
echo area("4"), "\n";
echo area(2.0), "\n";
echo area("cuatro"), "\n";

9
16
4

La pila de llamadas

¿Qué pasa en la memoria cuando llamas a una función?

1. PHP crea un marco (frame) nuevo para esa llamada, con su propia tabla de símbolos, vacía.
2. Los parámetros son variables locales de ese marco, con una copia de los valores que pasaste.
3. La función se ejecuta usando su tabla.
4. Al hacer return, el marco se destruye: sus variables locales desaparecen.

Si una función llama a otra, los marcos se apilan unos sobre otros: es la pila de llamadas (call stack).

<?php
function duplica($n) {
    $n = $n * 2;
    return $n;
}
$x = 5;
$y = duplica($x);
echo "x sigue valiendo $x, y vale $y\n";

x sigue valiendo 5, y vale 10

Recursividad

Una función puede llamarse a sí misma. Se llama recursividad, y es muy útil cuando un problema se puede dividir en versiones más pequeñas de sí mismo:

function factorial(int $n): int {
    if ($n <= 1) {
        return 1;                    // caso base
    }
    return $n * factorial($n - 1);   // caso recursivo
}

Toda función recursiva necesita un caso base que no se llame a sí mismo. Si no, cada llamada apila un marco nuevo... hasta que la pila se desborda (stack overflow).

Usa el paso a paso para ver cómo se apilan las llamadas: factorial(4) espera a factorial(3), que espera a factorial(2)...

<?php
function factorial(int $n): int {
    if ($n <= 1) {
        return 1;
    }
    return $n * factorial($n - 1);
}
echo factorial(4), "\n";
echo factorial(10), "\n";

24
3628800

Funciones para BIT-8

Con funciones, tus programas de la granja se vuelven mucho más claros. Por ejemplo, una función ir_a($x, $y) que lleve a BIT-8 a cualquier casilla, o cosechar_fila().

Una vez forjadas, tu programa principal se lee casi como un cuento:

ir_a(0, 0);
cosechar_campo();
plantar_zanahorias();

<?php
function cosechar_fila(int $n): void {
    for ($i = 0; $i < $n; $i++) {
        if (puede_cosechar()) {
            cosechar();
        }
        mover(ESTE);
    }
}

function cosechar_campo(): void {
    $n = tam();
    for ($f = 0; $f < $n; $f++) {
        cosechar_fila($n);
        mover(NORTE);
    }
}

cosechar_campo();

Ejercicios de Funciones en PHP resueltos

Intenta resolverlos antes de mirar la solución. En el juego puedes ejecutarlos y comprobarlos automáticamente.

<?php
function area_campo(int $lado): int {
    return $lado * $lado;
}

<?php
function precio_final(float $precio, int $descuento = 0): float {
    return $precio * (100 - $descuento) / 100;
}

<?php
// Version con el camino mas corto (aprovecha que el campo es un donut)
function ir_a($x, $y) {
    $n = tam();
    $dx = ($x - pos_x() + $n) % $n;   // pasos hacia el ESTE
    $dy = ($y - pos_y() + $n) % $n;   // pasos hacia el NORTE
    for ($i = 0; $i < min($dx, $n - $dx); $i++) {
        mover($dx <= $n - $dx ? ESTE : OESTE);
    }
    for ($i = 0; $i < min($dy, $n - $dy); $i++) {
        mover($dy <= $n - $dy ? NORTE : SUR);
    }
}

ir_a(2, 1);
cosechar();
ir_a(0, 2);
cosechar();
ir_a(1, 0);
cosechar();

<?php
function mejora($nivel) {
    $nivel = $nivel + 10;
    $extra = 1;
    return $nivel * 2;
}
$nivel = 5;
$resultado = mejora($nivel);
echo $nivel, " ", $resultado, " ", $extra ?? "sin extra";

5 30 sin extra

<?php
function sumar_todo(array $numeros): int {
    $total = 0;
    foreach ($numeros as $n) {
        $total += $n;
    }
}
echo "La suma es ", sumar_todo([3, 4]);

<?php
function sumar_todo(array $numeros): int {
    $total = 0;
    foreach ($numeros as $n) {
        $total += $n;
    }
    return $total;
}
echo "La suma es ", sumar_todo([3, 4]);

<?php
function potencia(int $base, int $exp): int {
    if ($exp === 0) {
        return 1;
    }
    return $base * potencia($base, $exp - 1);
}