Kokie yra klaidos/išimčių tipai PHP?

Question

Accepted Answer

PHP turi dvi lygiagrečias sistemas problemoms spręsti: tradicinius **errors** (įspėjimai, pranešimai, kritinės klaidos) ir **exceptions** (objektu pagrįstos, gaunamos try/catch struktūroje). Šiuolaikinis PHP sujungia didelę dalį to pagal `Throwable` hierarchiją, ir gera praktika palaiko exceptions.

## Tradiciniai error lygiai

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

Tai PHP klasikinės, lygio pagrindu grindžiamos klaidos. Pranešimai ir įspėjimai leidžia skriptui tęstis (bet signalizuoja problemas); kritinės klaidos jį sustabdo.

## Throwable hierarchija (šiuolaikiškai, objektais grindžiama)

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

Šiuolaikinis PHP atvaizduoja rimtas problemas kaip **objektus** realizuojančius `Throwable`, padalytus į `Error` (variklio lygis, paprastai klaidos kaip `TypeError`) ir `Exception` (aplikacijos klaidos, kurias jūs keliате ir tvarkaте).

## Gaudymas su 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
}
```

Nuo PHP 7, net `Error`s (kaip `TypeError`) yra gaudomi kaip `Throwable` — todėl galite gaudyti tiek errors, tiek exceptions.

## Iškėlimas exceptions

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

## Error handling konfigūracija

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

## Kodėl tai svarbu

Supratimas apie PHP error ir exception sistemą yra svarbus norint rašyti patikimas aplikacijas ir efektyviai debuginti.

Žinojimas tradiciniu **error lygiais** (notice/warning/fatal) padeda jums interpretuoti PHP pranešimus ir atpažinti problemų sunkumą, o supratimas šiuolaikine **`Throwable` hierarchija** (padalijimas tarp variklio lygio `Error`s — paprastai programavimo klaidų — ir aplikacijos `Exception`s, kuriuos jūs keliате ir tvarkaте) yra raktas į šiuolaikinį PHP error handling.

Praktiniai įgūdžiai — `try/catch/finally` naudojimas exception valdymui, specifinių tipų gaudymui, prasmingų exceptions keliamui, ir tai, kad net `Error`s yra gaudomi kaip `Throwable` (nuo PHP 7) — yra kasdieniai žinios patikimam kodui kurti.

Svarbu, žinoti gamybos praktiką — **errors registravimo užuot jų rodymo vartotojams** (nes rodomi errors atskleidžia jautrią informaciją — saugos prielaida) — yra būtina saugiam diegimui.

Šiuolaikinis PHP palaiko exception pagrįstą, objektiškai orientuotą požiūrį, todėl error/exception tipų supratimas, kaip juos tinkamai tvarkyti, ir saugi error konfigūracija yra pagrindinės žinios rašant patikimas, debugintinas, saugias PHP aplikacijas.