PHP Academy · Lección

Try, Catch y Finally

Gestione las excepciones en tiempo de ejecución correctamente con bloques try/catch/finally.

Try, Catch y Finally es una lección gratuita de PHP Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de PHP Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de PHP Academy incluye 4 lecciones en total.

Excepciones frente a errores

PHP tiene dos formas de indicar problemas:

Errores — avisos, advertencias y errores fatales tradicionales de PHP (se trataron en la lección anterior)
Excepciones — objetos que se lanzan cuando ocurre algo excepcional; se capturan con try/catch

Las excepciones son el enfoque moderno y recomendado para gestionar errores recuperables.

Lanzar una excepción

Utilice throw para indicar que algo salió mal:

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

echo divide(10, 2);   // 5
// divide(10, 0);     // throws exception

Bloque try / catch

Coloque el código que podría lanzar una excepción dentro de try y gestione las excepciones en catch:

<?php
try {
    $result = divide(10, 0);
    echo $result;
} catch (InvalidArgumentException $e) {
    echo 'Error: ' . $e->getMessage();
    echo ' in ' . $e->getFile() . ':' . $e->getLine();
}

Múltiples bloques catch

Capture los distintos tipos de excepción en bloques catch separados:

<?php
try {
    $pdo = new PDO($dsn, $user, $pass);
    $result = performQuery($pdo);
} catch (PDOException $e) {
    error_log('DB error: ' . $e->getMessage());
    echo 'Database unavailable';
} catch (RuntimeException $e) {
    echo 'Runtime error: ' . $e->getMessage();
} catch (\Throwable $e) {
    echo 'Unexpected error: ' . $e->getMessage();
}

Bloque finally

finally se ejecuta independientemente de si se lanzó una excepción; es perfecto para las tareas de limpieza:

<?php
$connection = null;
try {
    $connection = openDatabaseConnection();
    $data = fetchData($connection);
} catch (DatabaseException $e) {
    error_log($e->getMessage());
    echo 'DB error';
} finally {
    // Always runs — even if exception was thrown
    if ($connection) {
        closeConnection($connection);
    }
}

Jerarquía de excepciones

Jerarquía de clases de excepciones de PHP:

Throwable (interfaz)
├─ Error — errores del motor de PHP (TypeError, ParseError…)
└─ Exception — excepciones de la aplicación
├─ RuntimeException
├─ InvalidArgumentException
├─ LogicException
└─ PDOException

Capturar Throwable

Capture tanto las excepciones como los errores de PHP con Throwable:

<?php
try {
    $result = someFunction();
} catch (\Exception $e) {
    echo 'Exception: ' . $e->getMessage();
} catch (\Error $e) {
    echo 'PHP Error: ' . $e->getMessage();
}

// Or catch both at once:
try {
    // ...
} catch (\Throwable $e) {
    echo get_class($e) . ': ' . $e->getMessage();
}

Captura de unión (PHP 8)

PHP 8 permite capturar varios tipos de excepción en un solo bloque catch:

<?php
try {
    processRequest();
} catch (InvalidArgumentException | RuntimeException $e) {
    echo 'Handled: ' . $e->getMessage();
}

// Compare PHP 7 approach:
// catch (InvalidArgumentException $e) { ... }
// catch (RuntimeException $e) { ... }

Volver a lanzar excepciones

Capture, registre y vuelva a lanzar una excepción para propagarla por la pila de llamadas:

<?php
function processOrder(int $id): void {
    try {
        $order = loadOrder($id);
        $order->process();
    } catch (PaymentException $e) {
        error_log('Payment failed for order ' . $id . ': ' . $e->getMessage());
        throw $e;  // re-throw after logging
    }
}

Encadenamiento de excepciones

Pase la excepción original como excepción «anterior» para conservar el contexto:

<?php
try {
    $data = fetchFromAPI();
} catch (NetworkException $e) {
    throw new ServiceUnavailableException(
        'Cannot reach upstream service',
        0,
        $e  // $previous — preserves original cause
    );
}

// Retrieve original:
// $e->getPrevious()

set_exception_handler

Registre un controlador global para las excepciones no capturadas:

<?php
set_exception_handler(function(\Throwable $e): void {
    error_log(sprintf(
        '[UNCAUGHT] %s: %s in %s:%d',
        get_class($e),
        $e->getMessage(),
        $e->getFile(),
        $e->getLine()
    ));
    http_response_code(500);
    echo 'An unexpected error occurred. Please try again.';
    exit(1);
});

Comprobación rápida

¿Qué bloque de try/catch/finally se ejecuta siempre, independientemente de si se lanza una excepción?

Repaso: try/catch/finally

Resumen de la gestión de excepciones:

Lance excepciones con throw new ExceptionClass()
Capture con catch (Type $e)
Utilice varios bloques catch para distintos tipos
finally siempre se ejecuta; úselo para las tareas de limpieza
Captura de unión en PHP 8: catch (A | B $e)
Vuelva a lanzar la excepción para conservar el contexto de la pila de llamadas

Preguntas frecuentes

¿La lección «Try, Catch y Finally» es gratis?

Sí — el texto completo de «Try, Catch y Finally» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de PHP Academy, actualiza a CoddyKit PRO. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Try, Catch y Finally»?

Gestione las excepciones en tiempo de ejecución correctamente con bloques try/catch/finally. Practicas PHP Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar PHP Academy?

No se requiere experiencia previa. PHP Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Try, Catch y Finally»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de PHP Academy?

Sí. Cada lección de PHP Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a PHP Academy