Care sunt tipurile de erori/excepții în PHP?

Question

Accepted Answer

PHP are două sisteme paralele pentru probleme: **erorile** tradiționale (avertismente, notificări, erori fatale) și **excepțiile** (bazate pe obiecte, capturabile cu try/catch). PHP modern unifică o mare parte din acestea sub o ierarhie `Throwable`, iar practica bună favorizează excepțiile.

## Niveluri tradiționale de erori

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

Acestea sunt erorile clasice ale PHP, bazate pe niveluri. Notificările și avertismentele permit continuarea scriptului (dar semnalizează probleme); erorile fatale îl opresc.

## Ierarhia Throwable (modernă, bazată pe obiecte)

```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 reprezintă problemele serioase ca **obiecte** care implementează `Throwable`, împărțite în `Error` (la nivel de motor, de obicei erori ca `TypeError`) și `Exception` (erori de aplicație pe care le ridici și gestionezi).

## Capturarea cu 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
}
```

De la PHP 7 încoace, chiar și `Error`-urile (cum ar fi `TypeError`) sunt capturabile ca `Throwable` — deci poți captura atât erori, cât și excepții.

## Ridicarea de excepții

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

## Configurarea gestionării erorilor

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

## De ce este important

Înțelegerea sistemului de erori și excepții al PHP este importantă pentru scrierea aplicațiilor robuste și pentru depanare eficientă.

Cunoașterea **nivelurilor tradiționale de erori** (notificare/avertisment/fatal) te ajută să interpretezi mesajele PHP și să recunoști severitatea problemelor, în timp ce înțelegerea ierarhiei moderne **`Throwable`** (împărțirea dintre `Error`-urile la nivel de motor — de obicei erori de programare — și `Exception`-urile de aplicație pe care le ridici și gestionezi) este cheia gestionării moderne a erorilor în PHP.

Abilitățile practice — utilizarea `try/catch/finally` pentru a gestiona excepțiile, capturarea unor tipuri specifice, ridicarea de excepții semnificative, și faptul că `Error`-urile sunt capturabile ca `Throwable` (de la PHP 7) — sunt cunoștințe zilnice pentru construirea codului fiabil.

Important, cunoașterea practicii de producție a **înregistrării erorilor în loc de afișarea lor utilizatorilor** (deoarece erorile afișate divulgă informații sensibile — o problemă de securitate) este esențială pentru implementarea sigură.

PHP modern favorizează abordarea bazată pe excepții, orientată pe obiecte, deci înțelegerea tipurilor de erori/excepții, modul de gestionare corespunzător și configurația sigură a erorilor este cunoștință fundamentală pentru scrierea aplicațiilor PHP robuste, ușor de depanat și securizate.