X'inhu l-error/exception types f'PHP?

Question

Accepted Answer

PHP għandu żewġ sistemi paralleli għal problemi: **errors** tradizzjonali (warnings, notices, fatal errors) u **exceptions** (ibbażati fuq oġġetti, catċabbli bi try/catch). PHP modern jagħmel unit ta' ħafna minn dan taħt ġerarkija `Throwable`, u l-prattika tajba favur exceptions.

## Livelli ta' error tradizzjonali

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

Dawk huma l-errors klassici ta' PHP, ibbażati fuq livelli. Notices u warnings jippermettu l-iskrittu jkompli (iżda jissinjalizzaw problemi); fatal errors iwaqqfu.

## Il-ġerarkija Throwable (modern, ibbażata fuq oġġetti)

```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 modern jirrappreżenta problemi serjużi bħala **oġġetti** li jimplimentaw `Throwable`, maqsuma f' `Error` (livell tal-engine, ġeneralment bugs bħal `TypeError`) u `Exception` (errors tal-applikazzjoni li tintefa' u tittratta).

## Catċar bi 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
}
```

Minn PHP 7 'il quddiem, anki `Error`s (bħal `TypeError`) huma catċabbli bħala `Throwable` — allura tista' tcatċa tanto errors kif exceptions.

## Jintefa' exceptions

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

## Konfigurazzjoni ta' error handling

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

## Għaliex hu importanti

Fhim tas-sistema ta' error u exception ta' PHP hu importanti għat-tiktib ta' applikazzjonijiet robusti u debug effettiv.
/n Taf il-**livelli ta' error tradizzjonali** (notice/warning/fatal) tgħin biex tinterpreta l-messaġġi ta' PHP u tirkinnixxi s-serita ta' problemi, filwaqt li l-fhim tal-**ġerarkija `Throwable` moderna** (id-diviżjoni bejn `Error`s tal-livell tal-engine — ġeneralment bugs tal-programmar — u `Exception`s tal-applikazzjoni li tintefa' u tittratta) hu essenzjali għal modern PHP error handling.

Il-ħiliet prattiċi — użu ta' `try/catch/finally` biex tittratta exceptions, catċar ta' tipi speċifiċi, tintefa' ta' exceptions sigrifikanti, u li anki `Error`s huma catċabbli bħala `Throwable` (minn PHP 7) — huma għarfien ta' kuljum għat-twaħħil ta' kodiċi affidabbli.

Importantment, il-għarfien tal-prattika tal-produzzjoni ta' **logging ta' errors aktar ma' min jiddiżplayja lill-users** (peress li errors murija jniżżlu informazzjoni sensittiva — konsiderazzjoni ta' sigurtà) hu essenzjali għad-deployment safe.

PHP modern favur l-approċċ ibbażat fuq exceptions u orjentatu lejn oġġetti, allura l-fhim ta' tipi ta' error/exception, kif tittratawhom sew, u konfigurazzjoni secure ta' errors hu għarfien fundamentali għat-tiktib ta' applikazzjonijiet robusti, debuggabbli, u secure ta' PHP.