Try, Catch, Finally

Parte de la sección Programación Orientada a Objetos del Journey de PHP de Coddy — lección 68 de 91.

Ahora que sabes cómo crear y lanzar excepciones, necesitas aprender cómo capturarlas. La estructura try-catch-finally te permite manejar excepciones de manera elegante en lugar de dejar que bloqueen tu aplicación.

Envuelve el código que podría lanzar una excepción en un bloque try, luego maneja la excepción en un bloque catch:

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

$calc = new Calculator();

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

Salida:

Error: Cannot divide by zero

Puedes capturar diferentes tipos de excepciones con múltiples bloques catch. PHP las comprueba en orden, así que coloca primero las excepciones más específicas:

<?php
try {
    // código arriesgado
} catch (InvalidArgumentException $e) {
    echo "Bad input: " . $e->getMessage();
} catch (Exception $e) {
    echo "Something went wrong: " . $e->getMessage();
}

El bloque finally se ejecuta independientemente de si se lanzó o se capturó una excepción. Es perfecto para tareas de limpieza como cerrar conexiones:

<?php
try {
    echo "Attempting operation\n";
    throw new Exception("Failed");
} catch (Exception $e) {
    echo "Caught: " . $e->getMessage() . "\n";
} finally {
    echo "Cleanup complete";
}

Salida:

Attempting operation
Caught: Failed
Cleanup complete

El bloque finally se ejecuta incluso si realizas un return desde dentro de los bloques try o catch, lo que lo hace confiable para operaciones de limpieza esenciales.

Desafío

Fácil

Vamos a construir un sistema de procesamiento de archivos que demuestre cómo try-catch-finally trabajan juntos para manejar errores con elegancia mientras se asegura que la limpieza siempre ocurra.

Organizarás tu código en tres archivos:

FileException.php — Crea una clase personalizada FileException que extienda de Exception. Esto representará errores relacionados con archivos en tu sistema.
FileProcessor.php — Crea una clase FileProcessor que simule operaciones de archivos. Incluye el archivo FileException. Tu clase debe tener:
- Una propiedad booleana privada $isOpen inicializada en false
- Un método open(string $filename): void que establezca $isOpen en true e imprima "Opening: [filename]". Si el nombre del archivo es "invalid.txt", lanza una FileException con el mensaje "Cannot open file"
- Un método process(): void que imprima "Processing file...". Si $isOpen es false, lanza una RuntimeException con el mensaje "File not open"
- Un método close(): void que establezca $isOpen en false e imprima "File closed"
- Un método isOpen(): bool que devuelva el estado actual
main.php — Incluye el archivo FileProcessor. Recibirás una entrada: un nombre de archivo.
Crea un FileProcessor y utiliza una estructura try-catch-finally para:
- En el bloque try: llama a open() con el nombre del archivo, luego llama a process()
- Captura FileException primero e imprime "File error: [message]"
- Captura RuntimeException e imprime "Runtime error: [message]"
- En el bloque finally: verifica si el archivo está abierto usando isOpen(), y si es así, llama a close(). Luego imprime "Cleanup complete"

El bloque finally asegura que la limpieza ocurra ya sea que las operaciones tengan éxito o fallen. Este patrón es esencial para gestionar recursos como archivos, conexiones a bases de datos o sockets de red donde la limpieza debe ocurrir independientemente de lo que suceda durante el procesamiento.

Hoja de referencia

Usa try-catch-finally para manejar excepciones de manera elegante y asegurar que el código de limpieza siempre se ejecute:

<?php
try {
    // código que podría lanzar una excepción
} catch (ExceptionType $e) {
    // manejar la excepción
    echo $e->getMessage();
}

Captura múltiples tipos de excepciones con bloques catch separados. Coloca las excepciones más específicas primero:

<?php
try {
    // código arriesgado
} catch (InvalidArgumentException $e) {
    echo "Bad input: " . $e->getMessage();
} catch (Exception $e) {
    echo "Something went wrong: " . $e->getMessage();
}

El bloque finally se ejecuta independientemente de si se lanzó o capturó una excepción, lo que lo hace ideal para operaciones de limpieza:

<?php
try {
    // intentar operación
} catch (Exception $e) {
    // manejar error
} finally {
    // el código de limpieza siempre se ejecuta
}

Pruébalo tú mismo

<?php
require_once 'FileProcessor.php';

// Leer entrada
$filename = trim(fgets(STDIN));

// TODO: Crear una instancia de FileProcessor

// TODO: Usar la estructura try-catch-finally:
// - En el bloque try: llamar a open() con el nombre del archivo, luego llamar a process()
// - Capturar FileException primero e imprimir "File error: [message]"
// - Capturar RuntimeException e imprimir "Runtime error: [message]"
// - En el bloque finally: verificar si el archivo está abierto usando isOpen(), si es así llamar a close()
//   Luego imprimir "Cleanup complete"

?>