array ( 0 => 'index.php', 1 => 'PHP Manual', ), 'head' => array ( 0 => 'UTF-8', 1 => 'fr', ), 'this' => array ( 0 => 'language.exceptions.php', 1 => 'Les exceptions', 2 => 'Les exceptions', ), 'up' => array ( 0 => 'langref.php', 1 => 'Référence du langage', ), 'prev' => array ( 0 => 'language.errors.php7.php', 1 => 'Les Erreurs en PHP 7', ), 'next' => array ( 0 => 'language.exceptions.extending.php', 1 => 'Étendre les Exceptions', ), 'alternatives' => array ( ), 'source' => array ( 'lang' => 'fr', 'path' => 'language/exceptions.xml', ), 'history' => array ( ), 'extra_header_links' => array ( 'rel' => 'alternate', 'href' => '/manual/en/feeds/language.exceptions.atom', 'type' => 'application/atom+xml', ), ); $setup["toc"] = $TOC; $setup["toc_deprecated"] = $TOC_DEPRECATED; $setup["parents"] = $PARENTS; manual_setup($setup); contributors($setup); ?>

Les exceptions

Sommaire

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 bloc 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 instanceof Throwable. Tenter de lancer un objet qui ne l'est pas 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.

catch

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 bloc catch peut spécifier plusieurs exceptions à l'aide du caractè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é.

finally

Un bloc finally peut aussi être spécifié après ou à la place 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.

Une autre interaction notable est entre une exception lancée dans un bloc try, et une exception lancée dans un bloc finally. Si une exception est lancée dans les deux blocs, alors, l'exception lancée dans le bloc finally sera celle qui sera propagée, et l'exception lancée dans le bloc try sera utilisée comme exception précédente.

Gestionnaire d'exceptions global

Si une exception est autorisée à remonter jusqu'à la portée globale, elle peut être attrapée par un gestionnaire d'exceptions global s'il a été défini. La fonction set_exception_handler() peut définir une fonction qui sera appelée à la place d'un bloc catch si aucun autre bloc n'est invoqué. L'effet est essentiellement identique à entourer le programme entier dans un bloc try-catch avec cette fonction en tant que catch.

Notes

Note:

Les fonctions internes de PHP utilisent principalement l' Error reporting, seules les extensions orientées objet modernes utilisent les exceptions. Quoi qu'il en soit, des erreurs peuvent facilement être traduites en exceptions avec ErrorException. Cependant, cette technique ne fonctionne que pour les erreurs non fatales.

Exemple #1 Convertir l'error reporting en exceptions

<?php
function exceptions_error_handler($severity, $message, $filename, $lineno) {
throw new ErrorException($message, 0, $severity, $filename, $lineno);
}

set_error_handler('exceptions_error_handler');
?>

Astuce

La bibliothèque standard PHP (SPL) fournit un bon nombre d'exceptions additionnelles.

Exemples

Exemple #2 Lancer une exception

<?php
function inverse($x) {
if (!$x) {
throw new Exception('Division par zéro.');
}
return 1/$x;
}

try {
echo inverse(5) . "\n";
echo inverse(0) . "\n";
} catch (Exception $e) {
echo 'Exception reçue : ', $e->getMessage(), "\n";
}

// On continue l'exécution
echo "Bonjour le monde !\n";
?>

L'exemple ci-dessus va afficher :

0.2
Exception reçue : Division par zéro.
Bonjour le monde !

Exemple #3 Gestion de l'exception avec un bloc finally

<?php
function inverse($x) {
if (!$x) {
throw new Exception('Division par zéro.');
}
return 1/$x;
}

try {
echo inverse(5) . "\n";
} catch (Exception $e) {
echo 'Exception reçue : ', $e->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";
?>

L'exemple ci-dessus va afficher :

0.2
Première fin.
Exception reçue : Division par zéro.
Seconde fin.
Bonjour le monde !

Exemple #4 Interaction entre le bloc finally et return

<?php

function test() {
try {
throw new Exception('foo');
} catch (Exception $e) {
return 'catch';
} finally {
return 'finally';
}
}

echo test();
?>

L'exemple ci-dessus va afficher :

finally

Exemple #5 Héritage d'une exception

<?php

class MyException extends Exception { }

class Test {
public function testing() {
try {
try {
throw new MyException('foo!');
} catch (MyException $e) {
// on la relance
throw $e;
}
} catch (Exception $e) {
var_dump($e->getMessage());
}
}
}

$foo = new Test;
$foo->testing();

?>

L'exemple ci-dessus va afficher :

string(4) "foo!"

Exemple #6 Gestion des exceptions de capture multiple

<?php

class MyException extends Exception { }

class MyOtherException extends Exception { }

class Test {
public function testing() {
try {
throw new MyException();
} catch (MyException | MyOtherException $e) {
var_dump(get_class($e));
}
}
}

$foo = new Test;
$foo->testing();

?>

L'exemple ci-dessus va afficher :

string(11) "MyException"

Exemple #7 Omettre la variable attrapée

Seulement permis dans PHP 8.0.0 et ultérieur.

<?php

class SpecificException extends Exception {}

function test() {
throw new SpecificException('Oopsie');
}

try {
test();
} catch (SpecificException) {
print "Une SpecificException a été levée, mais les détails ne nous intéressent pas.";
}
?>

L'exemple ci-dessus va afficher :

Une SpecificException a été levée, mais les détails ne nous intéressent pas.

Exemple #8 Throw en tant qu'expression

Seulement permis dans PHP 8.0.0 et ultérieur.

<?php

function test() {
do_something_risky() or throw new Exception("Cela n'a pas fonctionné");
}

function do_something_risky() {
return false; // Simuler un échec
}

try {
test();
} catch (Exception $e) {
print $e->getMessage();
}
?>

L'exemple ci-dessus va afficher :

Cela n'a pas fonctionné

Exemple #9 Exception dans try et dans finally

<?php

try {
try {
throw new Exception(message: 'Third', previous: new Exception('Fourth'));
} finally {
throw new Exception(message: 'First', previous: new Exception('Second'));
}
} catch (Exception $e) {
var_dump(
$e->getMessage(),
$e->getPrevious()->getMessage(),
$e->getPrevious()->getPrevious()->getMessage(),
$e->getPrevious()->getPrevious()->getPrevious()->getMessage(),
);
}

L'exemple ci-dessus va afficher :

string(5) "First"
string(6) "Second"
string(5) "Third"
string(6) "Fourth"