Les exceptions sont utilisées pour changer le flux normal d'un script si une erreur se produit spécifié.
Qu'est-ce qu'une exception
Avec PHP 5 est venu une nouvelle façon orientée objet de traiter des erreurs.
La gestion des exceptions est utilisée pour modifier l'écoulement normal de l'exécution de code si une erreur spécifiée (exceptional) condition se produit. Cette condition est appelée une exception.
C'est ce qui se passe normalement lorsqu'une exception est déclenchée:
- L'état actuel du code est enregistré
- L'exécution de code passe à un prédéfini (custom) sur (custom) fonction de gestionnaire d'exception
- En fonction de la situation, le gestionnaire peut alors reprendre l'exécution de l'état de code enregistré, mettre fin à l'exécution du script ou continuer le script à partir d'un autre emplacement dans le code
Nous illustrons les différentes méthodes de gestion des erreurs:
- Utilisation de base des exceptions
- Création d'un gestionnaire d'exception personnalisée
- plusieurs exceptions
- Re-lancer une exception
- Définition d'un gestionnaire d'exceptions de niveau supérieur
Note: Les exceptions ne doivent être utilisés avec des conditions d'erreur, et ne doivent pas être utilisés pour passer à un autre endroit dans le code à un moment précis.
Utilisation de base des exceptions
Quand une exception est levée, le code suivant ne sera pas exécuté, et PHP va essayer de trouver la correspondance "catch" bloc.
Si une exception est pas pris, une erreur fatale sera émis avec une "Uncaught Exception" message.
Permet d'essayer de lancer une exception sans l'attraper:
<?php
//create function with an exception
function checkNum($number) {
if($number>1) {
throw new Exception("Value must be 1 or below");
}
return true;
}
//trigger exception
checkNum(2);
?>
Le code ci-dessus obtiendrez une erreur comme ceci:
Fatal error : Uncaught exception 'Exception'
with message 'Value must be 1 or below' in C:\webfolder\test.php:6
Stack trace: #0 C:\webfolder\test.php(12):
checkNum(28) #1 {main} thrown in C:\webfolder\test.php on line 6
Essayez, lancer et à attraper
Pour éviter l'erreur de l'exemple ci-dessus, nous devons créer le code approprié pour gérer une exception.
Code d'exception appropriée doit inclure:
- Essayez - Une fonction à l' aide d' une exception devrait être dans un "try" bloc. Si l'exception ne déclenche pas, le code continuera normalement. Toutefois , si l'exception déclenche, une exception est "thrown"
- Throw - Voici comment déclencher une exception. Chaque "throw" doit avoir au moins un "catch"
- Catch - Un "catch" bloc récupère une exception et crée un objet contenant les informations d'exception
Permet d'essayer de déclencher une exception avec le code valide:
<?php
//create function with an exception
function checkNum($number) {
if($number>1) {
throw new Exception("Value must be 1 or below");
}
return true;
}
//trigger exception in a "try" block
try {
checkNum(2);
//If the exception is thrown, this text will not be shown
echo 'If you see this, the number is 1 or below';
}
//catch exception
catch(Exception $e) {
echo 'Message: ' .$e->getMessage();
}
?>
Le code ci-dessus obtiendrez une erreur comme ceci:
Message: Value must be 1 or below
Exemple expliqué:
Le code ci-dessus jette une exception et l'attrape:
- Le checkNum() fonction est créée. Il vérifie si un nombre est supérieur à 1. Dans ce cas, une exception est levée
- Le checkNum() fonction est appelée dans un "try" bloc
- L'exception dans le checkNum() fonction est lancée
- Le "catch" bloc récupère l'exception et crée un objet ($e) contenant les informations d'exception
- Le message d'erreur de l'exception est fait l' écho en appelant $e-> getMessage() de l'objet d'exception
Cependant, une façon de contourner le "every throw must have a catch" règle est de définir un gestionnaire d'exception de haut niveau pour gérer les erreurs qui se glisseraient à travers.
Création d'une classe d'exception personnalisée
Pour créer un gestionnaire d'exception personnalisée, vous devez créer une classe spéciale avec des fonctions qui peuvent être appelées lorsqu'une exception se produit en PHP. La classe doit être une extension de la classe d'exception.
La classe d'exception personnalisée hérite des propriétés de la classe d'exception de PHP et vous pouvez ajouter des fonctions personnalisées à elle.
Permet de créer une classe d'exception:
<?php
class customException extends Exception {
public function errorMessage() {
//error message
$errorMsg = 'Error on line '.$this->getLine().' in '.$this->getFile()
.': <b>'.$this->getMessage().'</b> is not a valid E-Mail address';
return $errorMsg;
}
}
$email = "[email protected]";
try {
//check if
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();
}
?>
La nouvelle classe est une copie de l'ancienne classe d'exception avec un ajout de la errorMessage() fonction. Comme il est une copie de l'ancienne classe, et il hérite des propriétés et méthodes de l'ancienne classe, nous pouvons utiliser les méthodes de la classe d'exception comme getLine() et getFile() et getMessage() .
Exemple expliqué:
Le code ci-dessus jette une exception et il attrape avec une classe d'exception personnalisée:
- Le customException() classe est créée comme une extension de l'ancienne classe d'exception. De cette façon, il hérite de toutes les méthodes et propriétés de l'ancienne classe d'exception
- Le errorMessage() fonction est créée. Cette fonction renvoie un message d'erreur si une adresse e-mail est invalide
- La variable $ email est réglé sur une chaîne qui n'est pas une adresse e-mail valide
- Le "try" bloc est exécuté et une exception est levée depuis l'adresse e-mail est invalide
- La "catch" bloc intercepte l'exception et affiche le message d'erreur
Exceptions multiples
Il est possible pour un script d'utiliser plusieurs exceptions pour vérifier les conditions multiples.
Il est possible d'utiliser plusieurs blocs de if..else, un interrupteur, ou imbriquer plusieurs exceptions. Ces exceptions peuvent utiliser différentes classes d'exception et de retour des messages d'erreur différents:
<?php
class customException extends Exception
{
public function errorMessage()
{
//error message
$errorMsg = 'Error on line '.$this->getLine().' in '.$this->getFile()
.': <b>'.$this->getMessage().'</b> is not a valid E-Mail address';
return $errorMsg;
}
}
$email = "[email protected]";
try {
//check if
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 is an example e-mail");
}
}
catch (customException $e) {
echo $e->errorMessage();
}
catch(Exception $e) {
echo $e->getMessage();
}
?>
Exemple expliqué:
Le code ci-dessus teste deux conditions et lance une exception si l'une des conditions ne sont pas remplies:
- Le customException() classe est créée comme une extension de l'ancienne classe d'exception. De cette façon, il hérite de toutes les méthodes et propriétés de l'ancienne classe d'exception
- Le errorMessage() fonction est créée. Cette fonction renvoie un message d'erreur si une adresse e-mail est invalide
- La variable $ email est réglé sur une chaîne qui est une adresse e - mail valide, mais contient la chaîne "example"
- Le "try" bloc est exécuté et une exception n'est pas jeté sur la première condition
- La deuxième condition déclenche une exception puisque l'e-mail contient la chaîne "example"
- La "catch" bloc intercepte l'exception et affiche le message d'erreur correct
Si l'exception levée étaient des customException de classe et il n'y avait pas de prise de customException, seule la prise d'exception de base, l'exception serait là gérée.
Re-lancer des exceptions
Parfois, quand une exception est levée, vous pouvez le gérer différemment la manière standard. Il est possible de lancer une exception une seconde fois dans un "catch" bloc.
Un script doit masquer les erreurs du système des utilisateurs. Les erreurs système peuvent être importants pour le codeur, mais sont sans intérêt pour l'utilisateur. Pour faciliter les choses pour l'utilisateur, vous pouvez re-jeter l'exception avec un utilisateur message amical:
<?php
class customException extends Exception {
public function errorMessage() {
//error message
$errorMsg = $this->getMessage().' is not a valid E-Mail address.';
return $errorMsg;
}
}
$email = "[email protected]";
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();
}
?>
Exemple expliqué:
Le code ci - dessus teste si l'adresse e - mail contient la chaîne "example" en elle, si elle le fait, l'exception est relancées:
- Le customException() classe est créée comme une extension de l'ancienne classe d'exception. De cette façon, il hérite de toutes les méthodes et propriétés de l'ancienne classe d'exception
- Le errorMessage() fonction est créée. Cette fonction renvoie un message d'erreur si une adresse e-mail est invalide
- La variable $ email est réglé sur une chaîne qui est une adresse e - mail valide, mais contient la chaîne "example"
- Le "try" bloc contient un autre "try" bloc pour permettre de re-jeter l'exception
- L'exception est déclenchée depuis l'e-mail contient la chaîne "example"
- La "catch" bloc intercepte l'exception et re-jette un "customException"
- Le "customException" est pris et affiche un message d'erreur
Si l'exception n'est pas pris dans son courant "try" bloc, il recherchera un bloc catch sur "higher levels" des "higher levels" .
Définir un niveau supérieur Exception Handler
Le set_exception_handler() fonction définit une fonction définie par l' utilisateur pour traiter toutes les exceptions non traitées.
<?php
function myException($exception)
{
echo "<b>Exception:</b> " . $exception->getMessage();
}
set_exception_handler('myException');
throw new Exception('Uncaught Exception occurred');
?>
La sortie du code doit être quelque chose comme cela ci-dessus:
Exception: Uncaught Exception occurred
Dans le code ci - dessus il n'y avait pas "catch" bloc. Au lieu de cela, le gestionnaire d'exceptions de haut niveau déclenché. Cette fonction devrait être utilisée pour intercepter des exceptions non rattrapées.
Règles pour les exceptions
- Le code peut être entouré dans un bloc d'essai, pour aider à attraper des exceptions possibles
- Chaque bloc try ou "throw" doit avoir au moins un bloc catch correspondant
- Plusieurs blocs de capture peuvent être utilisés pour attraper différentes classes d'exceptions
- Des exceptions peuvent être jetés (or re-thrown) dans un bloc catch dans un bloc d'essai
Une règle simple: Si vous jetez quelque chose, vous devez l'attraper.