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

Question

IT Interview Practice · 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.

Tradiciniai error lygiai

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

Gaudymas su try/catch

Iškėlimas exceptions

Error handling konfigūracija

Kodėl tai svarbu

Susiję klausimai