Quais são os tipos de erro/exceção em PHP?

Question

Accepted Answer

O PHP tem dois sistemas paralelos para problemas: **erros** tradicionais (avisos, notificações, erros fatais) e **exceções** (baseadas em objetos, capturáveis com try/catch). O PHP moderno unifica grande parte disso sob uma hierarquia `Throwable`, e a boa prática favorece exceções.

## Níveis de erro tradicionais

```text
E_NOTICE   → minor issues (e.g. using an undefined variable) — script continues
E_WARNING  → non-fatal problems (e.g. include of a missing file) — continues
E_ERROR / Fatal → serious errors (e.g. calling an undefined function) — script HALTS
E_DEPRECATED → use of deprecated features
```

Estes são os erros clássicos baseados em nível do PHP. Notificações e avisos deixam o script continuar (mas sinalizam problemas); erros fatais o interrompem.

## A hierarquia Throwable (moderna, baseada em objetos)

```text
Throwable (interface)
  ├── Error      → internal PHP/engine errors (TypeError, DivisionByZeroError, ...)
  │                 — typically PROGRAMMING bugs
  └── Exception  → application-level exceptions (the ones you throw and catch)
        ├── RuntimeException, LogicException
        ├── InvalidArgumentException, etc.
        └── your custom exceptions
```

O PHP moderno representa problemas sérios como **objetos** que implementam `Throwable`, divididos em `Error` (nível de mecanismo, geralmente bugs como `TypeError`) e `Exception` (erros de aplicação que você lança e manipula).

## Capturando com try/catch

```php
try {
    $result = riskyOperation();
} catch (InvalidArgumentException $e) {     // catch a SPECIFIC type
    echo "Bad argument: " . $e->getMessage();
} catch (Throwable $e) {                     // catch anything (Error OR Exception)
    log($e);
} finally {
    cleanup();                                // always runs
}
```

Desde o PHP 7, até `Error`s (como `TypeError`) são capturáveis como `Throwable` — então você pode capturar tanto erros quanto exceções.

## Lançando exceções

```php
function divide(int $a, int $b): float {
    if ($b === 0) {
        throw new InvalidArgumentException("Cannot divide by zero");   // raise
    }
    return $a / $b;
}
```

## Configurando o tratamento de erros

```php
error_reporting(E_ALL);         // report ALL errors (development)
ini_set('display_errors', '0'); // production: DON'T show errors to users (log them instead)
set_error_handler(...);          // convert errors to exceptions, custom handling
```

## Por que isso importa

Entender o sistema de erro e exceção do PHP é importante para escrever aplicações robustas e depurar efetivamente.

Conhecer os **níveis de erro** tradicionais (notificação/aviso/fatal) ajuda você a interpretar as mensagens do PHP e reconhecer a severidade dos problemas, enquanto entender a hierarquia moderna **`Throwable`** (a divisão entre `Error`s de nível de mecanismo — geralmente bugs de programação — e `Exception`s de aplicação que você lança e captura) é fundamental para o tratamento moderno de erros em PHP.

As habilidades práticas — usar `try/catch/finally` para manipular exceções, capturar tipos específicos, lançar exceções significativas, e o fato de que `Error`s são capturáveis como `Throwable` (desde o PHP 7) — são conhecimentos do dia a dia para construir código confiável.

Importantemente, conhecer a prática de produção de **registrar erros em vez de exibi-los aos usuários** (pois erros exibidos vazam informações sensíveis — uma preocupação de segurança) é essencial para implantação segura.

O PHP moderno favorece a abordagem baseada em exceções e orientada a objetos, portanto, entender os tipos de erro/exceção, como manipulá-los adequadamente e a configuração segura de erros é conhecimento fundamental para escrever aplicações PHP robustas, depuráveis e seguras.