¿Cuáles son los tipos de error/excepción en PHP?

Question

Accepted Answer

PHP tiene dos sistemas paralelos para problemas: **errores** tradicionales (advertencias, avisos, errores fatales) y **excepciones** (basadas en objetos, capturables con try/catch). PHP moderno unifica gran parte de esto bajo una jerarquía `Throwable`, y la buena práctica favorece las excepciones.

## Niveles de error tradicionales

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

Estos son los errores clásicos de PHP basados en niveles. Los avisos y advertencias permiten que el script continúe (pero señalan problemas); los errores fatales lo detienen.

## La jerarquía Throwable (moderna, basada en 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
```

PHP moderno representa problemas serios como **objetos** que implementan `Throwable`, divididos en `Error` (a nivel del motor, generalmente errores como `TypeError`) y `Exception` (errores de aplicación que lanzas y manejas).

## Captura con 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 PHP 7, incluso los `Error`s (como `TypeError`) son capturables como `Throwable` — así que puedes capturar tanto errores como excepciones.

## Lanzar excepciones

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

## Configurar manejo de errores

```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 qué es importante

Comprender el sistema de errores y excepciones de PHP es importante para escribir aplicaciones robustas y depurar de manera efectiva.

Conocer los **niveles de error** tradicionales (aviso/advertencia/fatal) te ayuda a interpretar los mensajes de PHP y reconocer la gravedad de los problemas, mientras que comprender la **jerarquía moderna de `Throwable`** (la división entre `Error`s a nivel del motor — generalmente errores de programación — y `Exception`s de aplicación que lanzas y capturas) es clave para el manejo moderno de errores en PHP.

Las habilidades prácticas — usar `try/catch/finally` para manejar excepciones, capturar tipos específicos, lanzar excepciones significativas, y que incluso los `Error`s sean capturables como `Throwable` (desde PHP 7) — son conocimiento cotidiano para construir código confiable.

Importantemente, saber la práctica en producción de **registrar errores en lugar de mostrarlos a los usuarios** (ya que mostrar errores filtra información sensible — una preocupación de seguridad) es esencial para un despliegue seguro.

PHP moderno favorece el enfoque basado en excepciones y orientado a objetos, así que comprender los tipos de error/excepción, cómo manejarlos correctamente, y la configuración segura de errores es conocimiento fundamental para escribir aplicaciones PHP robustas, depurables y seguras.