Les exceptions en PHP : try, catch et throw

Historiquement, les erreurs PHP sont gérées via le système error reporting, c'est à dire l'affichage de messages d'erreur directement dans la page (avec différents niveaux de gravité : Notice, Warning, ou encore Fatal error, sauf Parse error qui est un cas à part).

Mais depuis PHP 5, les exceptions ont fait leur apparition. Ce système de gestion des erreurs est radicalement différent, c'est un mécanisme utilisé dans de nombreux langages comme Javascript, C#, Python ou Java. Le principe est très simple : on entoure le code qui peut potentiellement provoquer une erreur par un bloc try catch, et si une erreur se produit lors de l'exécution du code présent dans le bloc try, PHP va exécuter le code qui se trouve dans le catch, permettant ainsi de gérer l'erreur.

Concernant les fonctions PHP (le core), l'ancien mécanisme est encore bien présent, mais les nouvelles extensions orientée objet, introduite avec PHP 5, comme la classe PDO, utilisent les exceptions.

try catch

Pour commencer à travailler avec les exceptions, voici un exemple très simple, on va utiliser PDO et lui passer de mauvais paramètres pour qu'il lève une exception :

try{
	$pdo = new PDO("n'importe quoi !");
} catch(Exception $e){
	print_r($e);
}

Si tout se passe bien, PDO va lever cette exception, et on va passer dans le catch qui "attrape" l'exception. Dans cet exemple, le catch ne fait qu'afficher l'objet Exception, pour voir ce qu'il y a dedans :

PDOException Object
(
    [message:protected] => invalid data source name
    [string:private] => 
    [code:protected] => 0
    [file:protected] => C:\EasyPHP\www\php-exception-try-catch.php
    [line:protected] => 14
    [trace:private] => Array
        (
            [0] => Array
                (
                    [file] => C:\EasyPHP\www\php-exception-try-catch.php
                    [line] => 14
                    [function] => __construct
                    [class] => PDO
                    [type] => ->
                    [args] => Array
                        (
                            [0] => n'importe quoi !
                        )

                )

        )

    [errorInfo] => 
)

On peut voir qu'un objet Exception contient plein d'informations très utiles, comme le fichier et la ligne à laquelle s'est produite l'erreur, mais surtout un message d'erreur, parfois accompagné d'un code d'erreur.

Tous ces attributs sont en protected (voir en private), ça signifie qu'on ne peut pas les lire directement en faisant $e->message. Pour cela, il faut utiliser des fonctions qu'on appelle des assesseurs (car ce sont des fonctions qui permettent de lire, d'accéder à des attributs) :

• getMessage()
• getCode()
• getFile()
• getLine()
• getTrace()

Exemple :

try{
	$pdo = new PDO("n'importe quoi !");
} catch(Exception $e){
	echo $e->getMessage();
}

Plus d'infos sur la documentation de la classe Exception : class.exception.php.

Attention : une exception non catchée provoque l'arrêt du script par la survenue d'une Fatal error: Uncaught exception

Lever manuellement une exception avec throw

Tout comme on peut créer des erreurs avec la fonction trigger_error, on peut provoquer une exception, grâce à l'instruction throw :

function maFonction($param = null){
	if( !isset($param) ){
		throw new Exception("param est vide");
	}
}

try{
	maFonction();
} catch(Exception $e){
	print_r($e);
}

En fait on créé un objet Exception, comme n'importe quel objet : avec new, puis on la lance avec throw. On peut même utiliser throw dans un catch pour propager l'exception en dehors du bloc.

On peut aussi définir le code d'exception en second paramètre au constructeur d'exception : throw new Exception("param est vide", 3);.

Les différents types d'exceptions

Exception n'est pas le seul type d'exception, l'intérêt de ce mécanisme est qu'on peut utiliser différents types d'exception (on appelle ça les exceptions étendues), pour ensuite déclarer plusieurs blocs catch : un pour chaque type d'exception :

Exception
	ErrorException
	LogicException
		BadFunctionCallException
			BadMethodCallException
		DomainException
		InvalidArgumentException
		LengthException
		OutOfRangeException
	RuntimeException
		OutOfBoundsException
		OverflowException
		RangeException
		UnderflowException
		UnexpectedValueException

Voici un billet similaire qui vous permettera d'en savoir plus sur validation de la valeur d'une cellule excel.

Ce système est hiérarchique, c'est-à-dire que Exception est le type d'exception le plus générique, tous les types d'exception en découlent. Du coup, en mettant un catch(Exception $e), on attrape tous les types d'exceptions.

Voici un exemple avec plusieurs catch :

function maFonction($param = null){
	if( !isset($param) ){
		throw new Exception("param est vide");
	}
	
	if( $param === 0 ){
		throw new InvalidArgumentException("param ne peut être égal à 0");
	}
}

try{
	maFonction(0);
} catch(InvalidArgumentException $e){
	echo "catch 1\n";
	print_r($e);
} catch(Exception $e){
	echo "catch 2\n";
	print_r($e);
}

Créer ses propres exceptions

En héritant de la classe Exception, ou d'une classe elle-même héritant de la classe Exception, on peut créer ses propres types :

class MaFonctionException extends Exception{}

try{
	throw new MaFonctionException("Badaboum !");
} catch(MaFonctionException $e){
	echo $e->getMessage();
} catch(Exception $e){
	echo $e->getMessage();
}

Remplacer les erreurs natives PHP par des exceptions

Comme on l'a vu au début, il subsiste encore une grande partie du code PHP qui n'utilise pas les exceptions. Mais on peut facilement transformer les erreurs en exceptions en utilisant un error handler et la classe ErrorException :

function exception_error_handler($errno, $errstr, $errfile, $errline){
	throw new ErrorException($errstr, $errno, 0, $errfile, $errline);
}
set_error_handler('exception_error_handler');

Finally, avec PHP 5.5

PHP 5.5 a introduit le bloc finally, qui existe déjà dans d'autres langages, et qui sert à contenir du code qui est toujours exécuté, qu'on passe dans le try ou dans le catch :

try{
	throw new Exception("Big badaboum !");
} catch(Exception $e){
	print_r($e);
} finally {
	echo "Et finalement...";
}

Découvrez ce tutoriel photoshop : enseigne de casino à lire tout de suite !