Gestione eccezioni PHP
- Pagina precedente Errori PHP
- Pagina successiva Filtro PHP
L'eccezione (Exception) viene utilizzata per modificare il flusso normale dello script in presenza di errori specifici.
Cos'è un'eccezione?
PHP 5 fornisce un nuovo metodo di gestione degli errori orientato agli oggetti.
La gestione delle eccezioni viene utilizzata per modificare il flusso normale dello script in presenza di errori (eccezioni). Questo stato si chiama eccezione.
Quando viene sollevata un'eccezione, di solito accade:
- Lo stato del codice corrente viene salvato
- La esecuzione del codice viene passata a una funzione di gestore di eccezioni predefinita
- A seconda della situazione, il gestore potrebbe riprendere l'esecuzione del codice dallo stato di codice salvato, terminare l'esecuzione dello script o continuare l'esecuzione dello script da un'altra parte del codice
Mostriamo diversi metodi di gestione degli errori:
- Uso di base dell'eccezione
- Creazione di un gestore di eccezioni personalizzato
- Eccezioni multiple
- Rilanciare l'eccezione
- Impostazione del gestore di eccezioni di livello superiore
Uso di base dell'eccezione
Quando viene sollevata un'eccezione, il codice successivo non viene eseguito, PHP cerca di trovare un blocco di codice "catch" corrispondente.
Se l'eccezione non viene catturata e non viene utilizzato set_exception_handler() per gestirla, si verificherà un errore grave (errore fatale) e verrà visualizzato il messaggio di errore "Uncaught Exception" (eccezione non catturata).
Proviamo a sollevare un'eccezione senza catturarla:
<?php
//crea funzione con eccezione
function checkNum($number)
{
if($number>1)
{
throw new Exception("Il valore deve essere 1 o inferiore");
}
return true;
}
//solleva eccezione
checkNum(2);
?>
Il codice otterrà un errore simile a questo:
Errore fatale: eccezione non catturata 'Exception'
con messaggio 'Value must be 1 or below' in C:\webfolder\test.php:6
Trace della pila: #0 C:\webfolder\test.php(12):
checkNum(28) #1 {main} lanciato in C:\webfolder\test.php alla riga 6
Try, throw e catch
Per evitare gli errori del esempio sopra, dobbiamo creare il codice appropriato per gestire le eccezioni.
Il gestore corretto dovrebbe includere:
- Try - La funzione di eccezione deve essere situata all'interno del blocco di codice "try". Se non viene sollevata un'eccezione, il codice continuerà a eseguire normalmente. Tuttavia, se viene sollevata un'eccezione, verrà lanciata un'eccezione.
- Throw - Ecco come si definisce come lanciare un'eccezione. Ogni "throw" deve avere almeno un "catch"
- Catch - Il blocco di codice "catch" cattura l'eccezione e crea un oggetto che contiene le informazioni dell'eccezione
Lanciamo un'eccezione:
<?php
//Creare una funzione che può lanciare un'eccezione
function checkNum($number)
{
if($number>1)
{
throw new Exception("Il valore deve essere 1 o inferiore");
}
return true;
}
//Lanciare l'eccezione nel blocco di codice "try"
try
{
checkNum(2);
//Se viene lanciata l'eccezione, questo testo non verrà visualizzato
echo 'Se vedi questo, il numero è 1 o inferiore';
}
//Catturare l'eccezione
catch(Exception $e)
{
echo 'Messaggio: ' .$e->getMessage();
}
?>
Il codice sopra genererà un errore simile a questo:
Messaggio: Il valore deve essere 1 o inferiore
Example explanation:
Il codice sopra ha lanciato un'eccezione e l'ha catturata:
- Creare la funzione checkNum(). Controlla se il numero è maggiore di 1. Se lo è, lancia un'eccezione.
- Chiamare la funzione checkNum() all'interno del blocco di codice "try".
- L'eccezione nel funzionamento checkNum() viene lanciata
- Il blocco di codice "catch" riceve l'eccezione e crea un oggetto che contiene le informazioni dell'eccezione ($e).
- Utilizzando $e->getMessage() su questo oggetto exception, viene visualizzato il messaggio di errore dell'eccezione.
Per seguire il principio di "ogni throw deve avere un catch", è possibile impostare un gestore di eccezioni di livello superiore per gestire gli errori persi.
Creare una classe Exception personalizzata
Creare un gestore di eccezioni personalizzato è molto semplice. Creiamo semplicemente una classe speciale che può chiamare le sue funzioni quando si verifica un'eccezione in PHP. Questa classe deve essere un'estensione della classe exception.
Questa classe exception personalizzata eredita tutte le proprietà della classe exception di PHP, potete aggiungere funzioni personalizzate.
Iniziamo a creare la classe exception:
<?php
class customException extends Exception
{
public function errorMessage()
{
//error message
$errorMsg = 'Errore alla riga '.$this->getLine().' nel file '.$this->getFile()
: <b>'.$this->getMessage().'</b> non è un indirizzo e-mail valido
return $errorMsg;
}
}
$email = "someone@example...com";
try
{
//Verifica se
if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE)
{
//throw exception if email is not valid
throw new customException($email);
}
}
catch (customException $e)
{
//display custom message
echo $e->errorMessage();
}
?>
Questa nuova classe è una copia della vecchia classe di exception, più la funzione errorMessage(). Poiché è una copia della vecchia classe, eredita le proprietà e i metodi dalla vecchia classe, possiamo utilizzare i metodi della classe exception, come getLine(), getFile() e getMessage().
Example explanation:
Il codice sopra lancia un'eccezione e la cattura attraverso una classe di exception personalizzata:
- The customException() class is created as an extension of the old exception class. This way, it inherits all properties and methods of the old class.
- Crea la funzione errorMessage(). Se l'indirizzo e-mail non è valido, la funzione restituisce un messaggio di errore
- Imposta la variabile $email a una stringa di indirizzo e-mail non valida
- Esegui il blocco "try", poiché l'indirizzo e-mail non è legittimo, viene lanciata un'eccezione
- Il blocco "catch" cattura l'eccezione e visualizza il messaggio di errore
Eccezioni multiple
È possibile utilizzare più eccezioni per uno script, per verificare diverse situazioni.
È possibile utilizzare più blocchi if..else, o un blocco switch, o anidar più eccezioni. Queste eccezioni possono utilizzare diverse classi di exception e restituire messaggi di errore diversi:
<?php
class customException extends Exception
{
public function errorMessage()
{
//error message
$errorMsg = 'Errore alla riga '.$this->getLine().' nel file '.$this->getFile()
: <b>'.$this->getMessage().'</b> non è un indirizzo e-mail valido
return $errorMsg;
}
}
$email = "someone@example.com";
try
{
//Verifica se
if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE)
{
//throw exception if email is not valid
throw new customException($email);
}
//check for "example" in mail address
if(strpos($email, "example") !== FALSE)
{
throw new Exception("$email è un'e-mail di esempio");
}
}
catch (customException $e)
{
echo $e->errorMessage();
}
catch(Exception $e)
{
echo $e->getMessage();
}
?>
Example explanation:
Il codice sopra testato verifica due condizioni, se nessuna condizione è soddisfatta, viene lanciata un'eccezione:
- The customException() class is created as an extension of the old exception class. This way, it inherits all properties and methods of the old class.
- The errorMessage() function is created. If the e-mail address is not valid, the function returns an error message.
- Esegui il blocco "try", non viene lanciata un'eccezione sotto la prima condizione.
- Poiché l'e-mail contiene la stringa "example", la seconda condizione scatena l'eccezione.
- Il blocco "catch" cattura l'eccezione e visualizza il messaggio di errore appropriato
Se non viene catturata l'eccezione customException, ma solo l'eccezione base, gestisci l'eccezione lì.
Rilanciare l'eccezione
A volte, quando viene lanciata un'eccezione, potresti voler gestirla in modo diverso dallo standard. È possibile lanciare di nuovo l'eccezione in un blocco "catch".
The script should hide system errors from the user. While system errors may be important for programmers, users are not interested in them. To make it easier for users, you can re-throw exceptions with messages that are more user-friendly:
<?php
class customException extends Exception
{
public function errorMessage()
{
//error message
$errorMsg = $this->getMessage().' is not a valid E-Mail address.';
return $errorMsg;
}
}
$email = "someone@example.com";
try
{
try
{
//check for "example" in mail address
if(strpos($email, "example") !== FALSE)
{
//throw exception if email is not valid
throw new Exception($email);
}
}
catch(Exception $e)
{
//re-throw exception
throw new customException($email);
}
}
catch (customException $e)
{
//display custom message
echo $e->errorMessage();
}
?>
Example explanation:
The above code checks if the string "example" is present in the e-mail address. If it is, the exception is thrown again:
- The customException() class is created as an extension of the old exception class. This way, it inherits all properties and methods of the old class.
- The errorMessage() function is created. If the e-mail address is not valid, the function returns an error message.
- The $email variable is set to a valid e-mail address but contains the string "example".
- The "try" block contains another "try" block, which allows the exception to be thrown again.
- An exception was triggered because the e-mail contains the string "example".
- "catch" caught the exception and re-threw "customException".
- Caught "customException" and displayed an error message.
Se un'eccezione non viene catturata nel suo attuale blocco di codice try, verrà cercato un blocco di codice catch a livello superiore.
Impostazione del gestore di eccezioni di livello superiore (Top Level Exception Handler)
La funzione set_exception_handler() può impostare un funzione utente definita per gestire tutte le eccezioni non catturate.
<?php
function myException($exception)
{
echo "<b>Exception:</b> " , $exception->getMessage();
}
set_exception_handler('myException');
throw new Exception('Uncaught Exception occurred');
?>
L'output del codice sopra dovrebbe essere simile a questo:
Exception: Uncaught Exception occurred
Nel codice sopra non esiste un blocco di codice catch, ma viene attivato il programma di gestione delle eccezioni di livello superiore. Dovrebbe essere utilizzata questa funzione per catturare tutte le eccezioni non catturate.
Regole delle eccezioni
- Il codice che deve gestire le eccezioni deve essere inserito all'interno di un blocco di codice try, in modo da catturare eventuali eccezioni potenziali.
- Ogni blocco di codice try o throw deve avere almeno un blocco di codice catch corrispondente.
- Utilizzando più blocchi di codice catch, è possibile catturare diversi tipi di eccezioni.
- È possibile lanciare nuovamente (re-thrown) un'eccezione all'interno del blocco di codice catch all'interno del blocco di codice try.
In breve: se viene lanciata un'eccezione, deve essere catturata.
- Pagina precedente Errori PHP
- Pagina successiva Filtro PHP
