Milyen hibatípusok és kivételek vannak a PHP-ben?

Question

Accepted Answer

A PHP-nek két párhuzamos rendszere van a problémák kezelésére: a hagyományos **hibák** (figyelmeztetések, értesítések, végzetes hibák) és a **kivételek** (objektum alapú, try/catch-vel elkapható). A modern PHP sok mindent egységesít a `Throwable` hierarchia alatt, és az ajánlott gyakorlat a kivételek használatát favorizálja.

## Hagyományos hibaszintek

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

Ezek a PHP klasszikus, szintalapú hibái. Az értesítések és figyelmeztetések lehetővé teszik a szkript folytatódását (de problémákat jeleznek); a végzetes hibák leállítják azt.

## A Throwable hierarchia (modern, objektum alapú)

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

A modern PHP az objektumok használatával ábrázolja a komoly problémákat `Throwable` implementáció útján, amely `Error` (motor szintű, általában `TypeError` szintű hibák) és `Exception` (alkalmazási hibák, amelyeket te emelsz fel és kezelsz) között oszlik meg.

## Elkapás try/catch-szel

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

A PHP 7 óta az `Error`ek (például `TypeError`) is elkaphatók `Throwable`ként — így mind a hibákat, mind a kivételeket el tudod kapni.

## Kivételek felvetése

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

## Hibakezelés konfigurálása

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

## Miért számít ez

A PHP hibakezelési és kivételrendszerének megértése fontos a robusztus alkalmazások írásához és a hatékony hibakereséshez.

A hagyományos **hibaszinteken** (értesítés/figyelmeztetés/végzetes hiba) való jártasság segít a PHP üzeneteket értelmezni és felismerni a problémák súlyosságát, míg a modern **`Throwable` hierarchia** megértése — a motorszintű `Error`ek (általában programozási hibák) és az általad felvetett és kezelt alkalmazási `Exception`ek közötti megkülönböztetés — kulcsfontosságú a modern PHP hibakezeléshez.

A gyakorlati készségek — a `try/catch/finally` használata a kivételek kezelésére, konkrét típusok elkapása, értelmes kivételek felvetése, és hogy az `Error`ek is elkaphatók `Throwable`ként (PHP 7 óta) — napi használatú tudás a megbízható kód írásához.

Fontos, hogy ismerje az éles szerverrel kapcsolatos **hibák naplózásának** (nem pedig felhasználóknak való megjelenítésének) gyakorlatát (mivel a megjelenített hibák érzékeny információkat szivárogtatnak — biztonsági kockázat), amely elengedhetetlen a biztonságos telepítéshez.

A modern PHP az kivételalapú, objektumorientált megközelítést favorizálja, ezért a hibatípusok/kivételek megértése, a megfelelő kezelésük, valamint a biztonságos hibakonfigurálás alapvető tudás a robusztus, hibakereshető, biztonságos PHP-alkalmazások írásához.