Funciones en PHP

¿Por qué usar funciones?

Imaginá que necesitás calcular el precio con descuento en tres lugares distintos de tu programa. Sin funciones, copiás el mismo código tres veces:

// Sin función — repetición de código
$precio1 = 100;
$final1  = $precio1 - ($precio1 * 0.15);  // en la página de producto

$precio2 = 250;
$final2  = $precio2 - ($precio2 * 0.15);  // en el carrito

$precio3 = 80;
$final3  = $precio3 - ($precio3 * 0.15);  // en la factura

Si el descuento cambia de 15% a 20%, tenés que modificarlo en tres lugares. Con una función, lo definís una vez y lo cambiás en un solo lugar:

function aplicarDescuento($precio, $porcentaje) {
    return $precio - ($precio * $porcentaje / 100);
}

$final1 = aplicarDescuento(100, 15);
$final2 = aplicarDescuento(250, 15);
$final3 = aplicarDescuento(80,  15);

Probá el Ejemplo 1: Funciones básicas

Parámetros y argumentos

Los parámetros son las variables que define la función en su declaración. Los argumentos son los valores que le pasás al llamarla.

// $nombre y $saludo son parámetros
function saludar($nombre, $saludo) {
    echo "$saludo, $nombre!<br>";
}

// "Ana" y "Hola" son argumentos
saludar("Ana", "Hola");
saludar("Carlos", "Buenos días");

Valores por defecto

Podés darle un valor por defecto a un parámetro. Si al llamar la función no pasás ese argumento, se usa el valor por defecto:

function saludar($nombre, $saludo = "Hola") {
    echo "$saludo, $nombre!<br>";
}

saludar("Ana");               // Hola, Ana!  ← usa el default
saludar("Carlos", "Buenas"); // Buenas, Carlos!  ← sobreescribe el default

Probá el Ejemplo 2: Parámetros y defaults

return — devolver un valor

Una función puede devolver un resultado con return. Ese valor puede guardarse en una variable, usarse en una expresión o pasarse a otra función.

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

$resultado = sumar(3, 5);      // guarda el valor
echo $resultado;               // 8

echo sumar(10, 20);            // 30 — usamos el retorno directo
echo sumar(3, 5) * 2;         // 16 — en una expresión

return vs echo dentro de la función

// ❌ Función que imprime — no es reutilizable
function calcularIVA_mal($precio) {
    echo $precio * 1.21;   // imprime directo, no se puede usar en otra operación
}

// ✅ Función que retorna — flexible y reutilizable
function calcularIVA($precio) {
    return $precio * 1.21;
}

$conIVA = calcularIVA(100);          // 121
$total  = calcularIVA(100) + 50;     // 171 — podemos seguir operando
echo number_format($conIVA, 2);

Probá el Ejemplo 3: return

Scope — alcance de las variables

En PHP, las variables definidas fuera de una función no son accesibles dentro de ella, y viceversa. Cada función tiene su propio scope (alcance).

$mensaje = "Hola desde afuera";

function mostrar() {
    // $mensaje no existe acá — PHP no lo ve
    echo $mensaje;   // Warning: Undefined variable
}

mostrar();

La forma correcta es pasar la variable como parámetro:

$mensaje = "Hola desde afuera";

function mostrar($texto) {
    echo $texto;   // ✓ recibe el valor como argumento
}

mostrar($mensaje);  // Hola desde afuera

Funciones con arrays

Las funciones pueden recibir y devolver arrays, lo que las hace muy poderosas para procesar colecciones de datos:

function calcularTotal($items) {
    $total = 0;
    foreach ($items as $item) {
        $total += $item["precio"] * $item["cantidad"];
    }
    return $total;
}

function filtrarPorPrecio($productos, $max) {
    $resultado = [];
    foreach ($productos as $p) {
        if ($p["precio"] <= $max) {
            $resultado[] = $p;
        }
    }
    return $resultado;
}

$carrito = [
    ["nombre" => "Laptop",  "precio" => 1200, "cantidad" => 1],
    ["nombre" => "Mouse",   "precio" => 25,   "cantidad" => 2],
    ["nombre" => "Teclado", "precio" => 75,   "cantidad" => 1],
];

echo "Total: $" . number_format(calcularTotal($carrito), 2) . "<br>";

$baratos = filtrarPorPrecio($carrito, 100);
foreach ($baratos as $p) {
    echo $p["nombre"] . "<br>";
}

Ejemplo Completo

Sistema de facturación con funciones bien separadas:

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

function aplicarDescuento($monto, $porcentaje) {
    return $monto * (1 - $porcentaje / 100);
}

function calcularIVA($monto, $tasa = 21) {
    return $monto * $tasa / 100;
}

function mostrarLinea($nombre, $cantidad, $precio) {
    $subtotal = calcularSubtotal($precio, $cantidad);
    echo $nombre . " x$cantidad @ $" . number_format($precio, 2);
    echo " = $" . number_format($subtotal, 2) . "<br>";
    return $subtotal;
}

// Uso
echo "<strong>FACTURA</strong><br><br>";

$subtotal  = 0;
$subtotal += mostrarLinea("Laptop",  1, 1200);
$subtotal += mostrarLinea("Mouse",   2, 25);
$subtotal += mostrarLinea("Teclado", 1, 75);

$conDescuento = aplicarDescuento($subtotal, 10);
$iva          = calcularIVA($conDescuento);
$total        = $conDescuento + $iva;

echo "<br>Subtotal     : $" . number_format($subtotal, 2) . "<br>";
echo "Descuento 10%: -$" . number_format($subtotal - $conDescuento, 2) . "<br>";
echo "IVA 21%      : $" . number_format($iva, 2) . "<br>";
echo "<strong>TOTAL        : $" . number_format($total, 2) . "</strong>";
?>

Probá el Ejemplo 4: Sistema de facturación

Buenas Prácticas

• Una función, una responsabilidad — cada función debería hacer una sola cosa; si el nombre necesita "y", probablemente conviene dividirla
• Nombres descriptivos — calcularDescuento() es claro; f() no dice nada
• Preferí return sobre echo — las funciones que devuelven valores son reutilizables en cualquier contexto
• Pasá los datos como parámetros — evitá variables globales; hacen el código impredecible
• Valores por defecto para parámetros opcionales — hacen las funciones más flexibles sin complicar su uso