Cilat janë llojet e gabimeve/përjashtimeve në PHP?

Question

Accepted Answer

PHP ka dy sisteme paralele për problemet: **gabimet** tradicionale (paralajmërime, noticat, gabimet fatale) dhe **përjashtimet** (të bazuara në objekte, të kapshme me try/catch). PHP-ja moderne unifikoi shumë nga kjo nën hierarkinë `Throwable`, dhe praktika e mirë preferon përjashtimet.

## Nivelet tradicionale të gabimeve

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

Këto janë gabimet klasike të PHP-së, të bazuara në nivele. Noticat dhe paralajmërimet e lejojnë skriptin të vazhdojë (por sinjalizojnë probleme); gabimet fatale e ndalojnë atë.

## Hierarkia e Throwable (moderne, e bazuar në objekte)

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

PHP-ja moderne përfaqëson problemet serioze si **objekte** që zbatojnë `Throwable`, të ndarë në `Error` (në nivel motori, zakonisht defekte si `TypeError`) dhe `Exception` (gabimet e aplikacionit që ngreni dhe trajtoni).

## Kapja me 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
}
```

Nga PHP 7 e tutje, edhe `Error`-at (si `TypeError`) janë të kapshëm si `Throwable` — kështu që mund të kapni si gabimet ashtu edhe përjashtimet.

## Ngritja e përjashtimeve

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

## Konfigurimi i trajtimit të gabimeve

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

## Pse ka rëndësi

Kuptimi i sistemit të gabimeve dhe përjashtimeve të PHP-së është i rëndësishëm për shkrimin e aplikacioneve të forta dhe për diagnostikimin efektiv.

Dija e **niveleve tradicionale të gabimeve** (noticat/paralajmërimet/fatal) ju ndihmon të interpretoni mesazhet e PHP-së dhe të njohni rëndësimin e problemeve, ndërsa kuptimi i hierarkisë moderne **`Throwable`** (ndarja midis `Error`-ave në nivel motori — zakonisht defekte programimi — dhe `Exception`-ave të aplikacionit që ngreni dhe trajtoni) është kyç për trajtimin modern të gabimeve në PHP.

Zanatet praktike — përdorimi i `try/catch/finally` për të trajtuar përjashtimet, kapja e llojeve specifike, ngritja e përjashtimeve domethënëse, dhe fakti që `Error`-at janë të kapshëm si `Throwable` (nga PHP 7 e tutje) — janë njohuri të përditshme për ndërtimin e kodit të besueshëm.

Me rëndësi, njohja e praktikës në prodhim të **regjistrimit të gabimeve në vend të shfaqjes së tyre përdoruesve** (meqënëse gabimet e shfaqur rrjedhin informacione sensitive — një shqetësim sigurimi) është thelbësore për shpërndarjen e sigurt.

PHP-ja moderne preferon qasjen e bazuar në përjashtime, të orientuar në objekte, kështu që kuptimi i llojeve të gabimeve/përjashtimeve, si t'i trajtoni ato siç duhet, dhe konfigurimi i sigurt i gabimeve është njohuri themelore për shkrimin e aplikacioneve të forta, të diagnostikueshëm dhe të sigurt në PHP.