PHP Academy · Aula

Try, Catch e Finally

Trate exceções de tempo de execução de forma adequada com blocos try/catch/finally.

Try, Catch e Finally é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

Exceções e erros

O PHP tem duas formas de sinalizar problemas:

Erros — notificações, avisos e erros fatais tradicionais do PHP (discutidos na lição anterior)
Exceções — objetos lançados quando algo excepcional acontece; capturados com try/catch

As exceções são a abordagem moderna e preferida para tratar erros recuperáveis.

Lançando uma exceção

Use throw para sinalizar que algo deu errado:

<?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

Bloco try / catch

Coloque o código que pode lançar uma exceção em try e trate as exceções em catch:

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

Vários blocos catch

Capture diferentes tipos de exceção em blocos 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();
}

Bloco finally

finally é executado independentemente de uma exceção ter sido lançada — é ideal para a limpeza:

<?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);
    }
}

Hierarquia de exceções

Hierarquia de classes de exceção do PHP:

Throwable (interface)
├─ Error — erros do mecanismo do PHP (TypeError, ParseError…)
└─ Exception — exceções da aplicação
├─ RuntimeException
├─ InvalidArgumentException
├─ LogicException
└─ PDOException

Capturando Throwable

Capture tanto exceções quanto erros do PHP com 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ão (PHP 8)

O PHP 8 permite capturar vários tipos de exceção em um único bloco catch:

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

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

Relançando exceções

Capture, registre e lance novamente uma exceção para propagá-la pela pilha de chamadas:

<?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
    }
}

Encadeamento de exceções

Passe a exceção original como uma exceção anterior para preservar o 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 um manipulador global para exceções não 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);
});

Verificação rápida

Qual bloco de try/catch/finally tem a execução garantida, independentemente de uma exceção ser lançada?

Recapitulação: try/catch/finally

Resumo do tratamento de exceções:

Lance exceções com throw new ExceptionClass()
Capture-as com catch (Type $e)
Use vários blocos catch para tipos diferentes
finally sempre é executado — use-o para a limpeza
Captura de união no PHP 8: catch (A | B $e)
Relance a exceção para preservar o contexto da pilha de chamadas

Perguntas Frequentes

A aula “Try, Catch e Finally” é grátis?

Sim — o texto completo de “Try, Catch e Finally” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “Try, Catch e Finally”?

Trate exceções de tempo de execução de forma adequada com blocos try/catch/finally. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Try, Catch e Finally”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para PHP Academy