Vilka är fel-/exceptiontyperna i PHP?

Question

Accepted Answer

PHP har två parallella system för problem: traditionella **errors** (warnings, notices, fatal errors) och **exceptions** (objektbaserade, fångbara med try/catch). Modern PHP förenar mycket av detta under en `Throwable`-hierarki, och god praxis gynnar exceptions.

## Traditionella felenivåer

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

Dessa är PHPs klassiska, nivåbaserade fel. Notices och warnings låter skriptet fortsätta (men signalerar problem); fatal errors stoppar det.

## Throwable-hierarkin (modern, objektbaserad)

```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 representerar allvarliga problem som **objekt** som implementerar `Throwable`, uppdelade i `Error` (motornivå, vanligtvis buggar som `TypeError`) och `Exception` (applikationsfel som du höjer och hanterar).

## Fångning med 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
}
```

Sedan PHP 7 är även `Error`s (som `TypeError`) fångbara som `Throwable` — så du kan fånga både fel och exceptions.

## Kastning av exceptions

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

## Konfigurering av felhantering

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

## Varför det är viktigt

Att förstå PHPs fel- och exceptionsystem är viktigt för att skriva robusta applikationer och felsöka effektivt.

Att känna till de traditionella **felenivåerna** (notice/warning/fatal) hjälper dig att tolka PHPs meddelanden och känna igen allvarlighetsgraden av problem, medan förståelse för den moderna **`Throwable`-hierarkin** (uppdelningen mellan motornivå `Error`s — vanligtvis programmeringsfel — och applikation `Exception`s du kastar och hanterar) är nyckeln till modern PHP-felhantering.

De praktiska färdigheterna — att använda `try/catch/finally` för att hantera exceptions, fånga specifika typer, kasta meningsfulla exceptions, och att även `Error`s är fångbara som `Throwable` (sedan PHP 7) — är vardagskunskap för att bygga tillförlitlig kod.

Viktigt är att veta produktionspraxisen med **loggning av fel snarare än visning för användare** (eftersom visade fel läcker känslig information — en säkerhetsfara) är väsentlig för säker distribution.

Modern PHP gynnar det exceptionbaserade, objektorienterade tillvägagångssättet, så att förstå fel-/exceptiontyperna, hur man hanterar dem korrekt, och säker felkonfiguration är grundläggande kunskap för att skriva robusta, felsökbara, säkra PHP-applikationer.