Hvad er fejl-/undtagelsestyperne i PHP?

Question

IT Interview Practice · Accepted Answer

PHP har to parallelle systemer til at håndtere problemer: traditionelle **fejl** (advarsler, notitser, fatale fejl) og **undtagelser** (objekt-baserede, kan fanges med try/catch). Moderne PHP samler meget af dette under et `Throwable` hierarki, og god praksis favoriserer undtagelser.

## Traditionelle fejlniveauer

```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, niveaubaserede fejl. Notitser og advarsler lader scriptet fortsætte (men signalerer problemer); fatale fejl stopper det.

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

```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 repræsenterer alvorlige problemer som **objekter**, der implementerer `Throwable`, opdelt i `Error` (motor-niveau, normalt fejl som `TypeError`) og `Exception` (applikationsfejl, som du rejser og håndterer).

## Fangning 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 kan selv `Error`er (som `TypeError`) fanges som `Throwable` — så du kan fange både fejl og undtagelser.

## Rejsning af undtagelser

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

## Konfigurering af fejlhå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 betyder noget

At forstå PHPs fejl- og undtagelsessystem er vigtig for at skrive robuste applikationer og fejlfinde effektivt.

Kendet til de traditionelle **fejlniveauer** (notits/advarsel/fatal) hjælper dig med at tolke PHPs meddelelser og genkende alvorligheden af problemer, mens forståelse af det moderne **`Throwable` hierarki** (opdeling mellem motor-niveau `Error`er — normalt programmeringsfejl — og applikations `Exception`er, som du rejser og håndterer) er nøglen til moderne PHP-fejlhåndtering.

De praktiske færdigheder — brug af `try/catch/finally` til at håndtere undtagelser, fangning af specifikke typer, rejsning af meningsfulde undtagelser, og at selv `Error`er kan fanges som `Throwable` (siden PHP 7) — er dagligdags viden for at bygge pålidelig kode.

Vigtigvis er kendskab til produktionspraksis for at **logge fejl i stedet for at vise dem til brugere** (da viste fejl lækker følsomme oplysninger — et sikkerhedsproblem) væsentligt for sikker installation.

Moderne PHP favoriserer den undtagelse-baserede, objekt-orienterede tilgang, så forståelse af fejl-/undtagelsestyperne, hvordan man håndterer dem korrekt, og sikker fejlkonfiguration er grundlæggende viden for at skrive robuste, fejlfindebare, sikre PHP-applikationer.

Traditionelle fejlniveauer

Throwable-hierarkiet (moderne, objekt-baseret)

Fangning med try/catch

Rejsning af undtagelser

Konfigurering af fejlhåndtering

Hvorfor det betyder noget

Relaterede spørgsmål