Errori PHP

Incontrare errori è una parte normale della scrittura di codice PHP. Prima riesci a leggere un errore e a capire a quale livello appartiene, perché PHP lo ha generato e come rispondervi, prima potrai distribuire codice funzionante. Questa pagina spiega i livelli di errore di PHP (le costanti E_*), la differenza tra errori ed eccezioni nel PHP moderno, e un flusso di lavoro pratico per segnalarli, registrarli e gestirli.

Livelli di errore PHP

Quando PHP rileva un problema, lo segnala a un livello specifico, identificato da una costante E_*. Il livello indica la gravità del problema e se lo script continua l'esecuzione. Queste costanti si combinano con error_reporting() e la direttiva error_reporting di php.ini per decidere quali livelli vengono mostrati o registrati.

Queste sono costanti bitmask, quindi si combinano con l'operatore OR bit a bit (|) e si escludono livelli con & e ~:

<?php
// Report everything except notices and deprecations
error_reporting(E_ALL & ~E_NOTICE & ~E_DEPRECATED);

Importante: A partire da PHP 8.0 molti ex warning e notice sono stati promossi a eccezioni Error lanciate (ad esempio, leggere una chiave di array non definita genera ora un avviso, mentre chiamare un metodo non definito lancia un Error). Sapere se un problema è un errore sollevato o un'eccezione lanciata determina come catturarlo — vedere di seguito.

Errori vs. Eccezioni

PHP ha due meccanismi correlati ma separati:

• Gli errori tradizionali vengono sollevati dal motore e instradati tramite error_reporting, display_errors e un gestore opzionale impostato con set_error_handler(). Non sono oggetti che puoi catch (a meno che il tuo gestore non li converta).
• Le eccezioni sono oggetti che si throw e si catch con blocchi try/catch. Da PHP 7, anche i problemi fatali del motore vengono lanciati come oggetti Error (come TypeError o DivisionByZeroError), e sia Exception che Error implementano l'interfaccia Throwable — quindi catch (\Throwable $e) cattura qualsiasi cosa intercettabile.

<?php
try {
    // intdiv() throws a DivisionByZeroError on division by zero
    echo intdiv(10, 0);
} catch (\Throwable $e) {
    echo get_class($e) . ": " . $e->getMessage();
}
// Output: DivisionByZeroError: Division by zero

Cause Comuni degli Errori PHP

La maggior parte degli errori risale a un insieme ristretto di cause:

• Errori di sintassi — un punto e virgola mancante o una parentesi non corrispondente (E_PARSE).
• Simboli non definiti — utilizzo di una variabile, costante, funzione o chiave di array che non esiste.
• Incompatibilità di tipo — passaggio del tipo sbagliato a un parametro tipizzato (lancia TypeError).
• Funzionalità deprecate — funzioni o sintassi destinate alla rimozione (E_DEPRECATED).
• Limiti di risorse — esaurimento del memory_limit o raggiungimento del max_execution_time.
• Errori esterni — un file mancante, o una connessione a database/API che rifiuta o va in timeout.
• Eccezioni non catturate — un throw senza un catch corrispondente, che diventa un errore fatale.

<?php
// Reading an undefined variable raises an E_WARNING and yields null
echo $undefined_variable ?? "fallback";
// Output: fallback

L'operatore null-coalescing (??) nell'esempio sopra è il modo idiomatico per leggere un valore che potrebbe essere non definito senza generare un avviso.

Configurazione della Segnalazione degli Errori

Controlla quali livelli emergono e dove vengono inviati. In sviluppo, mostra tutto; in produzione, nascondi gli errori agli utenti ma registrali.

<?php
// Development: show all errors on screen
error_reporting(E_ALL);
ini_set('display_errors', '1');

// Production: hide from users, write to the error log instead
// error_reporting(E_ALL);
// ini_set('display_errors', '0');
// ini_set('log_errors', '1');

Le impostazioni equivalenti di php.ini sono error_reporting, display_errors, log_errors ed error_log. Per il controllo programmatico vedi error_reporting() e per ispezionare l'errore più recente usa error_get_last().

Gestione degli Errori nel Codice

Ci sono tre strumenti complementari:

1. Cattura le eccezioni con try/catch in modo che un errore recuperabile non blocchi lo script:

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

try {
    echo safeDivide(10, 0);
} catch (InvalidArgumentException $e) {
    echo "Handled: " . $e->getMessage();
}
// Output: Handled: Cannot divide by zero

2. Installa un gestore di errori personalizzato con set_error_handler() per convertire gli errori tradizionali in eccezioni o per registrarli nel tuo formato:

<?php
set_error_handler(function (int $level, string $message, string $file, int $line) {
    // Turn a traditional warning/notice into an ErrorException so it can be caught
    throw new ErrorException($message, 0, $level, $file, $line);
});

try {
    // Reading a missing file raises an E_WARNING, now converted to an exception
    $contents = file_get_contents('/no/such/file.txt');
} catch (\Throwable $e) {
    echo "Caught: " . $e->getMessage();
}
// Output: Caught: file_get_contents(/no/such/file.txt): Failed to open stream: No such file or directory

3. Genera i tuoi errori con trigger_error() per segnalare problemi a livello applicativo attraverso la stessa pipeline degli errori del motore.

Best Practice

• Imposta display_errors a 0 in produzione — i stack trace esposti sono un rischio per la sicurezza. Usa invece log_errors e un error_log configurato.
• Sviluppa con error_reporting(E_ALL) in modo che notice e deprecation emergano presto.
• Preferisci catch (\Throwable $e) al livello superiore per catturare sia Exception che Error.
• Non silenziare mai i problemi con l'operatore @; correggi la causa o gestiscila esplicitamente.
• Centralizza la registrazione con error_log() in modo che ogni errore finisca in un unico posto.

Conclusione

Leggere un errore PHP inizia dal suo livello e dal fatto che si tratti di un errore sollevato o di un'eccezione lanciata. Con error_reporting() calibrato per ambiente, un gestore personalizzato che convoglia gli errori nel sistema delle eccezioni, e try/catch attorno al codice che può fallire, puoi diagnosticare i problemi rapidamente e mantenere la produzione resiliente. Continua con PHP Exceptions e error_reporting() per approfondire.

Practice