Quali sono i tipi di errore/eccezione in PHP?

Question

Accepted Answer

PHP ha due sistemi paralleli per i problemi: gli **errori** tradizionali (avvisi, notifiche, errori fatali) e le **eccezioni** (basate su oggetti, catturabili con try/catch). PHP moderno unifica gran parte di questo sotto una gerarchia `Throwable`, e la buona pratica favorisce le eccezioni.

## Livelli di errore tradizionali

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

Questi sono gli errori classici di PHP, basati su livelli. Le notifiche e gli avvisi lasciano che lo script continui (ma segnalano problemi); gli errori fatali lo fermano.

## La gerarchia Throwable (moderna, basata su oggetti)

```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 moderno rappresenta i problemi gravi come **oggetti** che implementano `Throwable`, divisi in `Error` (a livello di motore, solitamente bug come `TypeError`) e `Exception` (errori applicativi che sollevi e gestisci).

## Cattura con 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
}
```

Da PHP 7, anche gli `Error` (come `TypeError`) sono catturabili come `Throwable` — quindi puoi catturare sia errori che eccezioni.

## Lanciare eccezioni

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

## Configurazione della gestione degli errori

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

## Perché è importante

Comprendere il sistema di errori e eccezioni di PHP è importante per scrivere applicazioni robuste e per fare debug in modo efficace.

Conoscere i **livelli di errore** tradizionali (notifica/avviso/fatale) ti aiuta a interpretare i messaggi di PHP e a riconoscere la gravità dei problemi, mentre comprendere la moderna **gerarchia `Throwable`** (la divisione tra `Error` a livello di motore — solitamente bug di programmazione — e `Exception` applicative che lanci e gestisci) è fondamentale per la gestione moderna degli errori in PHP.

Le competenze pratiche — usare `try/catch/finally` per gestire le eccezioni, catturare tipi specifici, lanciare eccezioni significative, e sapere che gli `Error` sono catturabili come `Throwable` (da PHP 7) — sono conoscenze quotidiane per costruire codice affidabile.

Importante, conoscere la pratica di produzione di **registrare gli errori anziché mostrarli agli utenti** (poiché gli errori mostrati perdono informazioni sensibili — una preoccupazione di sicurezza) è essenziale per un deployment sicuro.

PHP moderno favorisce l'approccio basato su eccezioni e orientato agli oggetti, quindi comprendere i tipi di errore/eccezione, come gestirli correttamente, e la configurazione sicura degli errori è una conoscenza fondamentale per scrivere applicazioni PHP robuste, debuggabili e sicure.