Manejo de errores

PHP representa la mayoría de los problemas en tiempo de ejecución como excepciones — objetos que se pueden lanzar, capturar y gestionar con elegancia en lugar de bloquear todo el script.

try, catch y throw

<?php
function divide(float $a, float $b): float {
    if ($b === 0.0) {
        throw new InvalidArgumentException("Cannot divide by zero.");
    }
    return $a / $b;
}

try {
    echo divide(10, 0);
} catch (InvalidArgumentException $e) {
    echo "Error: " . $e->getMessage();
}

throw lanza una excepción, deteniendo inmediatamente la ejecución normal y buscando hacia afuera un bloque catch que coincida. getMessage() recupera el texto descriptivo pasado al construir la excepción. Si ningún bloque catch coincide, la excepción se propaga hacia arriba por completo y, si no se gestiona, bloquea el script con un error fatal.

Capturar varios tipos de excepción

<?php
try {
    processPayment();
} catch (InsufficientFundsException | PaymentGatewayException $e) {
    echo "Payment failed: " . $e->getMessage();
} catch (Exception $e) {
    echo "Unexpected error: " . $e->getMessage();
}

Un solo catch puede listar varios tipos de excepción separados por |, gestionándolos de forma idéntica. Varios bloques catch se comprueban en orden, así que enumera los tipos de excepción más específicos antes que los generales — un catch (Exception $e) que actúe como comodín colocado primero absorbería todo lo que hay debajo, ya que toda excepción integrada termina extendiendo Exception.

finally: siempre se ejecuta

<?php
function readFile(string $path): string {
    $handle = fopen($path, "r");
    try {
        return fread($handle, filesize($path));
    } finally {
        fclose($handle);
    }
}

El código dentro de finally se ejecuta ya sea que el bloque try tenga éxito, lance una excepción, o incluso haga un return anticipado — lo que lo convierte en el lugar confiable para la limpieza (cerrar un manejador de archivo, liberar un bloqueo) que debe ocurrir pase lo que pase.

Clases de excepción personalizadas

<?php
class InsufficientFundsException extends Exception {
    public function __construct(private float $shortfall) {
        parent::__construct("Insufficient funds: short by $" . number_format($shortfall, 2));
    }

    public function getShortfall(): float {
        return $this->shortfall;
    }
}

throw new InsufficientFundsException(25.50);

Extender la clase integrada Exception de PHP te permite añadir datos específicos del dominio ($shortfall aquí) y un mensaje personalizado, sin dejar de poder capturarse como una Exception normal desde cualquier código que no necesite los detalles. Este es el patrón estándar para representar "cosas que pueden salir mal" en la lógica de negocio de una aplicación real.

Errores frente a excepciones

<?php
try {
    strlen(); // ArgumentCountError — a subclass of Error, not Exception
} catch (\Throwable $e) {
    echo get_class($e) . ": " . $e->getMessage();
}

PHP distingue entre Exception (problemas recuperables que tu propio código lanza deliberadamente) y Error (problemas graves como llamar a una función no definida o un desajuste de tipos, que el propio PHP lanza). Ambos implementan la interfaz Throwable, así que catch (\Throwable $e) captura cualquiera de los dos — útil para un manejador de nivel superior que nunca debe dejar pasar nada sin capturar, aunque el código de aplicación cotidiano normalmente captura subclases específicas de Exception en su lugar.