Was sind die Fehler-/Exception-Typen in PHP?

Question

IT Interview Practice · Accepted Answer

PHP hat zwei parallele Systeme für Probleme: traditionelle **Fehler** (Warnings, Notices, Fatal Errors) und **Exceptions** (objektorientiert, mit try/catch abfangbar). Modernes PHP vereint vieles davon unter einer `Throwable`-Hierarchie, und bewährte Praktiken bevorzugen Exceptions.

## Traditionelle Fehler-Level

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

Das sind PHPs klassische, level-basierte Fehler. Notices und Warnings lassen das Skript weiterlaufen (signalisieren aber Probleme); Fatal Errors stoppen es.

## Die Throwable-Hierarchie (modern, objektorientiert)

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

Modernes PHP stellt ernsthafte Probleme als **Objekte** dar, die `Throwable` implementieren, aufgeteilt in `Error` (Engine-Level, normalerweise Bugs wie `TypeError`) und `Exception` (Anwendungsfehler, die Sie werfen und behandeln).

## Abfangen mit 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
}
```

Seit PHP 7 können sogar `Error`s (wie `TypeError`) als `Throwable` abgefangen werden – Sie können also sowohl Fehler als auch Exceptions abfangen.

## Exceptions werfen

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

## Fehlerbehandlung konfigurieren

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

## Warum es wichtig ist

Das Verständnis von PHPs Fehler- und Exception-System ist wichtig für das Schreiben robuster Anwendungen und effektives Debugging.

Die Kenntnis der traditionellen **Fehler-Level** (Notice/Warning/Fatal) hilft Ihnen, PHPs Meldungen zu interpretieren und die Schwere von Problemen zu erkennen, während das Verständnis der modernen **`Throwable`-Hierarchie** (die Aufteilung in Engine-Level `Error`s – normalerweise Programmierfehler – und Anwendungs-`Exception`s, die Sie werfen und abfangen) der Schlüssel zur modernen PHP-Fehlerbehandlung ist.

Die praktischen Fähigkeiten – `try/catch/finally` zur Exception-Behandlung nutzen, spezifische Typen abfangen, aussagekräftige Exceptions werfen, und dass sogar `Error`s als `Throwable` abfangbar sind (seit PHP 7) – sind alltägliches Wissen zum Erstellen zuverlässigen Codes.

Wichtig ist auch die Produktivpraxis, **Fehler zu protokollieren, anstatt sie Benutzern anzuzeigen** (da angezeigte Fehler sensible Informationen offenlegen – ein Sicherheitsrisiko), ist für sichere Bereitstellung unerlässlich.

Modernes PHP bevorzugt den exception-basierten, objektorientierten Ansatz, daher ist das Verständnis der Fehler-/Exception-Typen, wie man sie richtig behandelt, und sichere Fehlerkonfiguration Grundlagenwissen für das Schreiben robuster, debuggbarer und sicherer PHP-Anwendungen.

Traditionelle Fehler-Level

Die Throwable-Hierarchie (modern, objektorientiert)

Abfangen mit try/catch

Exceptions werfen

Fehlerbehandlung konfigurieren

Warum es wichtig ist

Ähnliche Fragen