Exemple PHP Try Catch : didacticiel de gestion des exceptions et des erreurs

Qu'est-ce qu'une exception ?

Une erreur est un résultat inattendu du programme qui ne peut pas être géré par le programme lui-même.

Les erreurs sont résolues en corrigeant le programme. Un exemple d’erreur serait une boucle infinie qui ne cesse jamais de s’exécuter.

Une exception est un résultat inattendu du programme qui peut être géré par le programme lui-même.

Des exemples d'exception incluent la tentative d'ouverture d'un fichier qui n'existe pas.

Cette exception peut être gérée soit en créant le fichier, soit en présentant à l'utilisateur la possibilité de rechercher le fichier.

Pourquoi gérer les exceptions ?

• Évitez les résultats inattendus sur nos pages qui peuvent être très ennuyeux ou irritants pour nos utilisateurs finaux
• Améliorer la sécurité de nos applications en n'exposant pas les informations que des utilisateurs malveillants pourraient utiliser pour attaquer nos applications
• Les exceptions Php sont utilisées pour modifier le flux normal d'un programme si une erreur prévisible se produit.

Gestion des erreurs PHP

Lorsqu'une erreur survient, en fonction de vos paramètres de configuration, PHP affiche le message d'erreur dans le navigateur Web avec des informations relatives à l'erreur survenue.

PHP propose plusieurs façons de gérer les erreurs.

Nous allons examiner trois (3) méthodes couramment utilisées ;

1. Déclarations de décès– la fonction die combine les fonctions d’écho et de sortie en une seule. C'est très utile lorsque nous voulons afficher un message et arrêter l'exécution du script lorsqu'une erreur se produit.
2. Gestionnaires d'erreurs personnalisés – ce sont des fonctions définies par l’utilisateur qui sont appelées chaque fois qu’une erreur se produit.
3. Rapport d'erreur PHP – le message d'erreur en fonction de vos paramètres de rapport d'erreurs PHP. Cette méthode est très utile dans un environnement de développement lorsque vous n'avez aucune idée de la cause de l'erreur. Les informations affichées peuvent vous aider à déboguer votre application.

Exemples de gestion des erreurs

Examinons maintenant quelques exemples simples de routines de gestion des erreurs.

Supposons que nous ayons développé une application qui utilise des fichiers texte pour stocker des données. Nous souhaiterons peut-être vérifier l’existence du fichier avant d’essayer d’en lire les données.

Le code ci-dessous implémente l'exemple ci-dessus.

<?php
$denominator = 0;
echo 2 / $denominator;
?>

En supposant que vous ayez enregistré le fichier simple_error.php dans le dossier phptuts, ouvrez l'URL http://localhost/phptuts/simple_error.php

Vous obtiendrez les résultats suivants

Comme vous pouvez le voir à partir des résultats ci-dessus, cela donne à notre application un aspect non professionnel et peut être ennuyeux pour l'utilisateur.

Nous allons modifier le code ci-dessus et écrire un gestionnaire d'erreurs pour l'application

<?php
$denominator = 0;
if ($denominator != 0) {
    echo 2 / $denominator;
} else {
    echo "cannot divide by zero (0)";
}
?>

En supposant que vous ayez enregistré le code ci-dessus sous error_handling.php, ouvrez l'URL http://localhost/phptuts/error_handling.php

À noter: c'est une bonne pratique de sécurité d'afficher un message comme celui présenté ci-dessus au lieu d'afficher le message du type « Fichier introuvable ».

Regardons un autre exemple qui utilise un gestionnaire d'erreurs personnalisé.

Le gestionnaire d'erreurs personnalisé sera défini comme fonction de gestion des erreurs PHP par défaut et affichera essentiellement un numéro d'erreur et un message.

Le code ci-dessous illustre l'implémentation de l'exemple ci-dessus

<?php
function my_error_handler($error_no, $error_msg)
{
    echo "Opps, something went wrong:";
    echo "Error number: [$error_no]";
    echo "Error Description: [$error_msg]";
}
set_error_handler("my_error_handler");
echo (5 / 0);
?>

Ouvrez l'URL http://localhost/phptuts/custom_error_handler.php vous obtiendrez les résultats suivants

.

• Ils nous permettent de personnaliser les messages d'erreur.
• Le gestionnaire d'erreurs personnalisé peut également inclure la journalisation des erreurs dans un fichier/une base de données, l'envoi d'un e-mail au développeur, etc.

Examinons maintenant le troisième type de gestion des erreurs. Nous utiliserons la fonction error_reporting intégrée à PHP. Il a la syntaxe de base suivante

<?php
error_reporting($reporting_level);
?>

ICI,

• « error_reporting » est la fonction de rapport d'erreurs PHP
• « $reporting_level » est facultatif et peut être utilisé pour définir le niveau de reporting. Si aucun niveau de rapport n'a été spécifié, PHP utilisera le niveau de rapport d'erreurs par défaut tel que spécifié dans le fichier php.ini.

Différence entre les erreurs et les exceptions

• Les exceptions sont levées et destinées à être détectées alors que les erreurs sont généralement irrécupérables.
• Les exceptions sont gérées de manière orientée objet. Cela signifie lorsqu'une exception est levée ; un objet d'exception est créé et contient les détails de l'exception.

Le tableau ci-dessous montre les méthodes des objets d'exception

<?php
echo $e->getMessage();
?>

<?php
echo $e->getCode();
?>

<?php
echo $e->getFile();
?>

<?php
echo $e->getLine();
?>

<?php
print_r( $e->getTrace());
?>

<?php
echo $e->getPrevious();
?>

<?php
echo $e->getTraceAsString();
?>

<?php
echo $e->__toString();
?>

<?php
throw new Exception("This is an exception example");
?>

ICI,

• "throw" est le mot-clé utilisé pour lever l'exception
• « new Exception (...) » crée un objet d'exception et transmet la chaîne « Ceci est un exemple d'exception » comme paramètre de message.

Le code ci-dessus génère le message suivant.

Nous allons maintenant examiner un exemple qui implémente les exceptions throw et catch.

Nous modifierons l'exemple ci-dessus et inclurons l'essai, le lancer et l'attraper.

Il a la syntaxe de base suivante.

<?php
try {
    //code goes here that could potentially throw an exception
}
catch (Exception $e) {
    //exception handling code goes here
}
?>

ICI,

• « try{…} » est le bloc de code à exécuter qui pourrait potentiellement déclencher une exception
• « catch(Exception $e){…} » est le bloc de code qui intercepte l'exception levée et attribue l'objet d'exception à la variable $e.

Le code ci-dessous montre l'exemple d'exception de base avec l'exception try, throw et catch implémentée.

Le programme lève délibérément une exception qu'il intercepte ensuite.

<?php
try {
    $var_msg = "This is an exception example";
    throw new Exception($var_msg);
}
catch (Exception $e) {
    echo "Message: " . $e->getMessage();
    echo "";
    echo "getCode(): " . $e->getCode();
    echo "";
    echo "__toString(): " . $e->__toString();
}
?>

Ouvrez l'URL http://localhost/phptuts/exception_handling.php Vous obtiendrez les résultats suivants.

Il est également possible de créer plusieurs exceptions pour une instruction try php en fonction du type d'exception levée.

Voir l'article sur MySQL, Accès aux données PHP… pour des exemples d'implémentation de plusieurs exceptions

Exceptions multiples

Les exceptions multiples utilisent plusieurs blocs try catch pour gérer les exceptions levées. Plusieurs exceptions sont utiles lorsque :

• Vous souhaitez afficher un message personnalisé en fonction de l'exception levée
• Vous souhaitez effectuer une opération unique en fonction de l'exception levée

L'organigramme ci-dessous illustre le fonctionnement de plusieurs exceptions

Regardons un exemple qui utilise plusieurs exceptions.

Nous allons modifier le code qui divise un nombre par le dénominateur passé.

Nous nous attendons à ce que deux types d'exceptions se produisent ;

• Division par zéro
• Division par un nombre négatif

Par souci de simplicité, nous afficherons uniquement le type d'exception dans nos blocs catch.

La classe Exception intégrée à PHP est utilisée pour lancer des exceptions.

Nous allons créer deux classes qui étendent la classe d'exception et les utiliser pour lancer des exceptions.

Le code ci-dessous montre l'implémentation.

<?php
class DivideByZeroException extends Exception {};
class DivideByNegativeException extends Exception {};
function process($denominator)
{
	try
	{
		if ($denominator == 0)
		{
			throw new DivideByZeroException();
		}
		else if ($denominator < 0)
		{
			throw new DivideByNegativeException();
		}
		else
		{
			echo 25 / $denominator;
		}
	}
	catch (DivideByZeroException $ex)
	{
		echo "DIVIDE BY ZERO EXCEPTION!";
	}
	catch (DivideByNegativeException $ex)
	{
		echo "DIVIDE BY NEGATIVE NUMBER EXCEPTION!";
	}
	catch (Exception $x)
	{
	echo "UNKNOWN EXCEPTION!";
	}
}
process(0);
?>

Tester le code

Nous supposerons que vous avez enregistré multiple_exceptions.php dans le dossier phptuts.

Accédez à l'URL http://localhost/phptuts/multiple_exceptions.php

Revenez au fichier PHP et transmettez -1 comme paramètre comme indiqué dans le diagramme suivant.

Accédez à l'URL http://localhost/phptuts/multiple_exceptions.php.

Quels résultats obtenez-vous ? Passez 3 comme paramètre.

Quels résultats obtenez-vous ?

Résumé

• Les erreurs sont des résultats inattendus produits par le code PHP
• La gestion des erreurs améliore les performances de l'application
• PHP a des fonctions intégrées qui peuvent être utilisées pour personnaliser la façon dont PHP signale les erreurs
• Les exceptions sont comme des erreurs, mais elles peuvent être interceptées à l'aide du bloc catch lorsqu'elles sont lancées.
• L'affichage de messages d'erreur contenant des informations sur l'erreur est considéré comme une mauvaise pratique de sécurité.