Hva er feil-/ekseptionstyper i PHP?

Question

Accepted Answer

PHP har to parallelle systemer for problemer: tradisjonelle **feil** (advarsler, varslinger, fatale feil) og **eksepsjoner** (objekt-baserte, fangsbare med try/catch). Moderne PHP forener mye av dette under et `Throwable`-hierarki, og god praksis favoriserer eksepsjoner.

## Tradisjonelle feilnivå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
```

Disse er PHPs klassiske, nivå-baserte feil. Varslinger og advarsler lar skriptet fortsette (men signaliserer problemer); fatale feil stopper det.

## Throwable-hierarkiet (moderne, objekt-basert)

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

Moderne PHP representerer alvorlige problemer som **objekter** som implementerer `Throwable`, delt inn i `Error` (motor-nivå, vanligvis bugs som `TypeError`) og `Exception` (applikasjonsfeil du kaster og håndterer).

## Fangst 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
}
```

Siden PHP 7 er selv `Error`er (som `TypeError`) fangsbare som `Throwable` — så du kan fange både feil og eksepsjoner.

## Kasting av eksepsjoner

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

## Konfigurering av feilhåndtering

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

## Hvorfor det betyr noe

Å forstå PHPs feil- og ekseptionssystem er viktig for å skrive robuste applikasjoner og debugge effektivt.

Å kjenne de tradisjonelle **feilnivåene** (varsel/advarsel/fatal) hjelper deg tolke PHPs meldinger og gjenkjenne alvorlighetsgraden av problemer, mens forståelse av det moderne **`Throwable`-hierarkiet** (delingen mellom motor-nivå `Error`er — vanligvis programmeringsfeil — og applikasjons `Exception`er du kaster og håndterer) er nøkkelen til moderne PHP-feilhåndtering.

De praktiske ferdighetene — å bruke `try/catch/finally` til å håndtere eksepsjoner, fange spesifikke typer, kaste meningsfulle eksepsjoner, og at selv `Error`er er fangsbare som `Throwable` (siden PHP 7) — er hverdagskunnskap for å bygge pålitelig kode.

Viktig er det at kjennskap til produksjonspraksisen med **å logge feil i stedet for å vise dem til brukere** (siden viste feil lekkje sensitiv informasjon — en sikkerhetsbetenkeligent) er essensielt for sikker distribusjon.

Moderne PHP favoriserer den eksepsjons-baserte, objekt-orienterte tilnærmingen, så forståelse av feil-/ekseptionstyper, hvordan å håndtere dem korrekt, og sikker feilkonfigurering er grunnleggende kunnskaper for å skrive robuste, debugbare, sikre PHP-applikasjoner.