Katere so vrste napak/izjem v PHP?

Question

Accepted Answer

PHP ima dva vzporedna sistema za težave: tradicionalne **napake** (opozorila, obvestila, usodne napake) in **izjeme** (na objektih temelječe, ujemljive s try/catch). Sodobni PHP veliko tega enotno predstavlja pod hierarhijo `Throwable`, dobra praksa pa daje prednost izjemam.

## Tradicionalne ravni napak

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

To so klasične, na ravneh temelječe napake PHP. Obvestila in opozorila omogočajo, da se skript nadaljuje (vendar signalizirajo težave); usodne napake ga zaustavijo.

## Hierarhija Throwable (sodobna, na objektih temelječa)

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

Sodobni PHP resne težave predstavlja kot **objekte**, ki implementirajo `Throwable`, razdeljene na `Error` (na motorju temelječe, običajno napake kot `TypeError`) in `Exception` (aplikacijske napake, ki jih sprožite in obravnavate).

## Ujemanje z 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
}
```

Od PHP 7 naprej so tudi `Error`i (kot `TypeError`) ujemljivi kot `Throwable` — zato lahko ujamete tako napake kot izjeme.

## Metanje izjem

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

## Nastavljanje obravnavanja napak

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

## Zakaj je to pomembno

Razumevanje sistema napak in izjem v PHP je pomembno za pisanje robustnih aplikacij in učinkovito odpravljanje napak.

Znanje tradicionalnih **ravni napak** (obvestilo/opozorilo/usodna) vam pomaga interpretirati PHP-jeve sporočila in prepoznati resnost težav, medtem ko razumevanje sodobne **hierarhije `Throwable`** (delitev med napakama na motorju `Error` — običajno programske napake — in aplikacijskimi `Exception`i, ki jih sprožite in ujamete) je ključno za sodobno obravnavanje napak v PHP.

Praktične spretnosti — uporaba `try/catch/finally` za obravnavanje izjem, ujemanje določenih vrst, metanje smiselnih izjem in dejstvo, da so `Error`i ujemljivi kot `Throwable` (od PHP 7 naprej) — so vsakodnevno znanje za izgradnjo zanesljivega koda.

Pomembno je tudi vedeti, da je proizvodno prakso **beleženja napak namesto njihovega prikaza uporabnikom** (ker prikazane napake razkrivajo občutljive podatke — varnostna težava) bistveno za varno razporeditev.

Sodobni PHP daje prednost izjemam temelječemu na objektih pristopu, zato je razumevanje vrst napak/izjem, kako jih pravilno obravnavati in varno nastavljanje napak temeljno znanje za pisanje robustnih, razhroščljivih, varnih PHP aplikacij.