Try, Catch, Finally

Parte da seção Programação Orientada a Objetos do Journey de PHP da Coddy — lição 68 de 91.

Agora que você sabe como criar e lançar exceções, você precisa aprender como capturá-las. A estrutura try-catch-finally permite que você lide com exceções de forma elegante, em vez de deixar que elas interrompam sua aplicação.

Envolva o código que pode lançar uma exceção em um bloco try e, em seguida, trate a exceção em um bloco 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();
}

Saída:

Error: Cannot divide by zero

Você pode capturar diferentes tipos de exceção com múltiplos blocos catch. O PHP os verifica em ordem, portanto, coloque as exceções mais específicas primeiro:

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

O bloco finally executa independentemente de uma exceção ter sido lançada ou capturada. É perfeito para tarefas de limpeza, como fechar conexões:

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

Saída:

Attempting operation
Caught: Failed
Cleanup complete

O bloco finally é executado mesmo que você retorne de dentro dos blocos try ou catch, tornando-o confiável para operações de limpeza essenciais.

Desafio

Fácil

Vamos construir um sistema de processamento de arquivos que demonstra como o try-catch-finally funciona em conjunto para lidar com erros de forma graciosa, garantindo que a limpeza sempre ocorra.

Você organizará seu código em três arquivos:

FileException.php — Crie uma classe personalizada FileException que estende Exception. Isso representará erros relacionados a arquivos em seu sistema.
FileProcessor.php — Crie uma classe FileProcessor que simula operações de arquivo. Inclua o arquivo FileException. Sua classe deve ter:
- Uma propriedade booleana privada $isOpen inicializada como false
- Um método open(string $filename): void que define $isOpen como true e imprime "Opening: [filename]". Se o nome do arquivo for "invalid.txt", lance uma FileException com a mensagem "Cannot open file"
- Um método process(): void que imprime "Processing file...". Se $isOpen for false, lance uma RuntimeException com a mensagem "File not open"
- Um método close(): void que define $isOpen como false e imprime "File closed"
- Um método isOpen(): bool que retorna o estado atual
main.php — Inclua o arquivo FileProcessor. Você receberá uma entrada: um nome de arquivo.
Crie um FileProcessor e use uma estrutura try-catch-finally para:
- No bloco try: chame open() com o nome do arquivo e, em seguida, chame process()
- Capture FileException primeiro e imprima "File error: [message]"
- Capture RuntimeException e imprima "Runtime error: [message]"
- No bloco finally: verifique se o arquivo está aberto usando isOpen() e, se estiver, chame close(). Em seguida, imprima "Cleanup complete"

O bloco finally garante que a limpeza ocorra independentemente de as operações terem sucesso ou falha. Esse padrão é essencial para gerenciar recursos como arquivos, conexões de banco de dados ou sockets de rede, onde a limpeza deve ocorrer independentemente do que aconteça durante o processamento.

Folha de consulta

Use try-catch-finally para tratar exceções de forma elegante e garantir que o código de limpeza sempre seja executado:

<?php
try {
    // code that might throw an exception
} catch (ExceptionType $e) {
    // handle the exception
    echo $e->getMessage();
}

Capture múltiplos tipos de exceção com blocos catch separados. Coloque as exceções mais específicas primeiro:

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

O bloco finally é executado independentemente de uma exceção ter sido lançada ou capturada, tornando-o ideal para operações de limpeza:

<?php
try {
    // attempt operation
} catch (Exception $e) {
    // handle error
} finally {
    // cleanup code runs always
}

Experimente você mesmo

<?php
require_once 'FileProcessor.php';

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

// TODO: Criar uma instância de FileProcessor

// TODO: Usar a estrutura try-catch-finally:
// - No bloco try: chamar open() com o filename, depois chamar process()
// - Capturar FileException primeiro e imprimir "File error: [message]"
// - Capturar RuntimeException e imprimir "Runtime error: [message]"
// - No bloco finally: verificar se o arquivo está aberto usando isOpen(), se sim, chamar close()
//   Depois imprimir "Cleanup complete"

?>