Une classe d'exception écrite par l'utilisateur peut être définie en étendant la classe Exception interne. Les membres et les propriétés suivants montrent ce qui est accessible dans la classe enfant qui est dérivée de la classe Exception interne. ]]> Si une classe étend la classe Exception interne et redéfinit le constructeur, il est vivement recommandé qu'elle appelle aussi parent::__construct() pour s'assurer que toutes les données disponibles ont été proprement assignées. La méthode __toString() peut être réécrite pour fournir un affichage personnalisé lorsque l'objet est présenté comme une chaîne. Les exceptions ne peuvent pas être clonées. Si vous tentez de cloner une exception, une erreur fatale (E_ERROR) sera émise. code}]: {$this->message}\n"; } public function customFunction() { echo "Une fonction personnalisée pour ce type d'exception\n"; } } /** * Création d'une classe pour tester l'exception */ class TestException { public $var; const THROW_NONE = 0; const THROW_CUSTOM = 1; const THROW_DEFAULT = 2; function __construct($avalue = self::THROW_NONE) { switch ($avalue) { case self::THROW_CUSTOM: // lance une exception personnalisée throw new MyException('1 est un paramètre invalide', 5); break; case self::THROW_DEFAULT: // lance l'exception par défaut. throw new Exception('2 n\'est pas autorisé en tant que paramètre', 6); break; default: // Aucune exception, l'objet sera créé. $this->var = $avalue; break; } } } // Exemple 1 try { $o = new TestException(TestException::THROW_CUSTOM); } catch (MyException $e) { // Devrait être attrapée echo "Capture mon exception\n", $e; $e->customFunction(); } catch (Exception $e) { // Sauté echo "Capture l'exception par défaut\n", $e; } // Continue l'exécution var_dump($o); // Null echo "\n\n"; //Exemple 2 try { $o = new TestException(TestException::THROW_DEFAULT); } catch (MyException $e) { // Ne correspond pas à ce type echo "Capture mon exception\n", $e; $e->customFunction(); } catch (Exception $e) { // Devrait être attrapée echo "Capture l'exception par défaut\n", $e; } // Continue l'exécution var_dump($o); // Null echo "\n\n"; // Exemple 3 try { $o = new TestException(TestException::THROW_CUSTOM); } catch (Exception $e) { // Devrait être attrapée echo "Capture l'exception par défaut\n", $e; } // Continue l'exécution var_dump($o); // Null echo "\n\n"; // Exemple 4 try { $o = new TestException(); } catch (Exception $e) { // sauté, aucune exception echo "Capture l'exception par défaut\n", $e; } // Continue l'exécution var_dump($o); // TestException echo "\n\n"; ?> ]]> PHP a une gestion des exceptions similaire à ce qu'offrent les autres langages de programmation. Une exception peut être lancée ("&throw;") et attrapée ("&catch;") dans PHP. Le code devra être entouré d'un bloc &try; pour faciliter la saisie d'une exception potentielle. Chaque &try; doit avoir au moins un bloc &catch; ou &finally; correspondant. Si une exception est lancée et que la portée courante de la fonction n'a pas de block &catch;, l'exception "remontera" la pile d'appel de la fonction appelante jusqu'à trouver un bloc &catch; correspondant. Tous les blocs &finally; rencontrés seront exécutés. Si la pile d'appel est déroulée jusqu'à la portée globale sans rencontrer de bloc &catch; correspondant, le programme sera terminé avec une erreur fatale sauf si un gestionnaire global d'exception a été défini. L'objet lancé doit être une instance de la classe Exception ou d'une sous-classe de la classe Exception. Tenter de lancer un objet qui ne correspond pas à cela résultera en une erreur fatale émise par PHP. À partir de PHP 8.0.0, le mot clé &throw; est une expression et peut être utilisé dans n'importe quel contexte d'expressions. Dans les versions antérieures c'était une déclaration qui devait être sur sa propre ligne. Un bloc &catch; définit comment réagir à une exception qui a été lancée. Un bloc &catch; définit un ou plusieurs types d'exceptions ou erreurs qu'il peut gérer, et optionnellement une variable dans laquelle assigner l'exception. (Cette variable était requise dans les versions antérieures à PHP 8.0.0) Le premier bloc &catch; qu'une exception ou erreur lancée rencontre et qui correspond au type de l'objet lancé gérera l'objet. Plusieurs blocs &catch; peuvent être utilisés pour attraper différentes classes d'exceptions. L'exécution normale (lorsqu'aucune exception n'est lancée dans le bloc &try;) continue après le dernier bloc &catch; défini dans la séquence. Les exceptions peuvent être lancées (&throw;) ou relancées dans un bloc &catch;. Sinon, l'exécution continuera après le bloc &catch; qui a été déclenché. Lorsqu'une exception est lancée, le code suivant le traitement ne sera pas exécuté et PHP tentera de trouver le premier bloc &catch; correspondant. Si une exception n'est pas attrapée, une erreur fatale issue de PHP sera envoyée avec un message "Uncaught Exception ..." indiquant que l'exception n'a pu être attrapée à moins qu'un gestionnaire d'exceptions ne soit défini avec la fonction set_exception_handler. À partir de PHP 7.1, un block &catch; peut spécifier plusieurs exceptions à l'aide du caratère pipe (|). Ceci est utile lorsque différentes exceptions de hiérarchies de classes différentes sont traitées de la même manière. À partir de PHP 8.0.0, le nom de variable pour l'exception attrapée est optionnel. Si non spécifié, le bloc &catch; sera toujours exécuté mais n'aura pas accès à l'objet lancé. Un bloc &finally; peut aussi être spécifié après des blocs &catch;. Le code à l'intérieur du bloc &finally; sera toujours exécuté après les blocs &try; et &catch;, indépendamment du fait qu'une exception a été lancée, avant de continuer l'exécution normale. Une interaction notable est entre un bloc &finally; et une déclaration &return;. Si une déclaration &return; est rencontrée à l'intérieur des blocs &try; ou &catch;, le bloc &finally; sera quand même exécuté. De plus, la déclaration &return; est évaluée quand elle est rencontrée, mais le résultat sera retourné après que le bloc &finally; soit exécuté. Additionnellement, si le bloc &finally; contient aussi une déclaration &return; la valeur du bloc &finally; est retournée. Si une exception est autorisée à remonter jusqu'à la portée globale, elle peut être attrapée par un gestionnaire d'exceptions global si il a été défini. La fonction set_exception_handler peut définir une fonction qui sera appelée à la place d'un block &catch; si aucun autre block n'est invoqué. L'effet est essentiellement identique à entourer le programme entier dans un block &try;-&catch; avec cette fonction en tant que &catch;. &reftitle.notes; Les fonctions internes de PHP utilisent principalement l' Error reporting, seules les extensions orientées objet utilisent les exceptions. Quoiqu'il en soit, des erreurs peuvent facilement être traduites en exceptions avec ErrorException. Cependant, cette technique ne fonctionne que pour les erreurs non fatales. ]]> La bibliothèque standard PHP (SPL) fournit un bon nombre d'exceptions additionnelles. &reftitle.examples; getMessage(), "\n"; } // Continue execution echo "Bonjour le monde !\n"; ?> ]]> &example.outputs; getMessage(), "\n"; } finally { echo "Première fin.\n"; } try { echo inverse(0) . "\n"; } catch (Exception $e) { echo 'Exception reçue : ', $e->getMessage(), "\n"; } finally { echo "Seconde fin.\n"; } // On continue l'exécution echo "Bonjour le monde !\n"; ?> ]]> &example.outputs; ]]> &example.outputs; getMessage()); } } } $foo = new Test; $foo->testing(); ?> ]]> &example.outputs; testing(); ?> ]]> &example.outputs; Seulement permis dans PHP 8.0.0 et ultérieur. ]]> Seulement permis dans PHP 8.0.0 et ultérieur. getMessage(); } ?> ]]>