Wat zijn de fout-/exceptiontypes in PHP?

Question

Accepted Answer

PHP heeft twee parallelle systemen voor problemen: traditionele **fouten** (waarschuwingen, notices, fatale fouten) en **exceptions** (object-gebaseerd, opvangbaar met try/catch). Modern PHP vereinigt veel hiervan onder een `Throwable`-hiërarchie, en best practice begunstigt exceptions.

## Traditionele foutniveaus

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

Dit zijn PHP's klassieke, niveaugebaseerde fouten. Notices en waarschuwingen laten het script doorgaan (maar signaleren problemen); fatale fouten stoppen het.

## De Throwable-hiërarchie (modern, object-gebaseerd)

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

Modern PHP vertegenwoordigt ernstige problemen als **objecten** die `Throwable` implementeren, verdeeld in `Error` (engine-niveau, meestal bugs zoals `TypeError`) en `Exception` (applicatiefouten die je genereert en afhandelt).

## Opvangen met 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
}
```

Sinds PHP 7 zijn zelfs `Error`s (zoals `TypeError`) opvangbaar als `Throwable` — dus je kunt zowel fouten als exceptions opvangen.

## Exceptions gooien

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

## Foutafhandeling configureren

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

## Waarom het belangrijk is

Het begrijpen van PHP's fout- en exceptionsysteem is belangrijk voor het schrijven van robuuste applicaties en effectief debuggen.

Het kennen van de traditionele **fautniveaus** (notice/warning/fatal) helpt je PHP's berichten te interpreteren en de ernst van problemen te herkennen, terwijl het begrijpen van de moderne **`Throwable`-hiërarchie** (de verdeling tussen engine-niveau `Error`s — meestal programmeerfouten — en applicatie `Exception`s die je genereert en afhandelt) essentieel is voor moderne PHP-foutafhandeling.

De praktische vaardigheden — `try/catch/finally` gebruiken om exceptions af te handelen, specifieke typen opvangen, betekenisvolle exceptions gooien, en dat zelfs `Error`s opvangbaar zijn als `Throwable` (sinds PHP 7) — zijn alledaagse kennis voor het bouwen van betrouwbare code.

Belangrijk is dat het weten van de productiepraktijk van **fouten loggen in plaats van deze aan gebruikers te tonen** (omdat weergegeven fouten gevoelige informatie lekken — een beveiligingskwestie) essentieel is voor veilige implementatie.

Modern PHP begunstigt de exception-gebaseerde, object-georiënteerde benadering, dus het begrijpen van de fout-/exceptiontypes, hoe deze correct af te handelen, en veilige foutconfiguratie is basiskennis voor het schrijven van robuuste, debugbare, veilige PHP-applicaties.