PHP - Gestion des erreurs

Salut à toi, aspirant(e)s développeur(euse)s PHP ! Aujourd'hui, nous allons plonger dans le monde passionnant de la gestion des erreurs en PHP. Ne t'inquiète pas si tu es nouveau dans la programmation ; je vais te guider à travers chaque concept étape par étape, comme j'ai fait pour des centaines d'étudiant(e)s au cours de mes années d'enseignement. Alors, prends une tasse de café (ou ton breuvage préféré) et c'est parti !

La fonction die()

Commençons par une fonction simple mais puissante : die(). Cette fonction est comme appuyer sur le bouton d'arrêt d'urgence de ton code. Lorsque PHP rencontre die(), il arrête immédiatement l'exécution et affiche un message.

Voici un exemple de base :

<?php
$file = fopen("important_file.txt", "r");
if (!$file) {
die("Oh non ! Le fichier n'a pas pu être ouvert.");
}
echo "Si vous voyez ceci, le fichier a été ouvert avec succès !";
?>

Dans ce code, nous essayons d'ouvrir un fichier. Si cela échoue, die() arrête tout et affiche notre message personnalisé. C'est comme dire à PHP : "Si tu ne peux pas le faire, arrête-toi et dis-moi !"

La fonction de gestion des erreurs

Passons maintenant à un niveau supérieur dans notre gestion des erreurs avec une fonction de gestion des erreurs personnalisée. C'est comme avoir ton propre assistant personnel pour s'occuper des erreurs.

Voici comment tu peux en créer une :

<?php
function myErrorHandler($errno, $errstr, $errfile, $errline) {
echo "<b>Oops ! Quelque chose s'est mal passé :</b><br>";
echo "Erreur : [$errno] $errstr<br>";
echo "Erreur à la ligne $errline dans $errfile<br>";
}

set_error_handler("myErrorHandler");

// Créons une erreur
echo($undefined_variable);
?>

Dans cet exemple, nous avons créé une fonction appelée myErrorHandler qui fournit des informations détaillées sur toute erreur qui se produit. Ensuite, nous disons à PHP d'utiliser cette fonction avec set_error_handler(). Lorsque nous essayons d'afficher une variable non définie, notre gestionnaire d'erreurs personnalisé prend le relais, fournissant un message convivial et informatif.

La classe ArithmeticError

PHP 7 a introduit plusieurs nouvelles classes d'erreurs, y compris ArithmeticError. Cette classe est lancée lorsqu'une erreur se produit lors d'opérations mathématiques.

Voyons comment elle fonctionne :

<?php
$number = 1;
try {
$result = $number << -1;
} catch (ArithmeticError $e) {
echo "Oops ! Une erreur mathématique s'est produite : " . $e->getMessage();
}
?>

Ici, nous essayons d'effectuer une opération de décalage de bits avec un nombre négatif, ce qui n'est pas autorisé. PHP attrape cela avec une ArithmeticError, et nous la gérons avec grâce.

DivisionByZeroError

Souviens-tu en cours de mathématiques quand ton professeur te disait que tu ne peux pas diviser par zéro ? Eh bien, PHP se souvient aussi ! DivisionByZeroError est lancé lorsque tu essaies de diviser par zéro.

<?php
function divide($numerator, $denominator) {
if ($denominator == 0) {
throw new DivisionByZeroError("Whoa là ! Tu ne peux pas diviser par zéro !");
}
return $numerator / $denominator;
}

try {
echo divide(10, 0);
} catch (DivisionByZeroError $e) {
echo "Erreur : " . $e->getMessage();
}
?>

Dans cet exemple, nous avons créé une fonction divide qui vérifie si le dénominateur est zéro. Si c'est le cas, elle lance une DivisionByZeroError avec un message personnalisé.

ArgumentCountError

As-tu déjà appelé quelqu'un et oublié ce que tu voulais dire ? Eh bien, ArgumentCountError est la manière de PHP de dire : "Hé, tu as oublié de me dire quelque chose d'important !"

<?php
function greet($name) {
return "Hello, $name!";
}

try {
echo greet();  // Oups, nous avons oublié de fournir un nom !
} catch (ArgumentCountError $e) {
echo "Erreur : " . $e->getMessage();
}
?>

Dans ce cas, nous appelons la fonction greet sans fournir de nom. PHP lance un ArgumentCountError, que nous attrapons et gérons.

TypeError

TypeError est lancé lorsque une valeur n'est pas du type attendu. C'est comme commander une pizza et recevoir un hamburger à la place !

<?php
function addNumbers(int $a, int $b) {
return $a + $b;
}

try {
echo addNumbers("5", "10");  // Nous passons des chaînes, pas des entiers !
} catch (TypeError $e) {
echo "Oops ! " . $e->getMessage();
}
?>

Ici, notre fonction addNumbers attend des entiers, mais nous passons des chaînes. PHP attrape cette incohérence de type et lance un TypeError.

Gestion des exceptions en PHP

Les exceptions en PHP sont comme des filets de sécurité dans un cirque. Elles attrapent les erreurs avant qu'elles ne deviennent de gros problèmes. Jetons un coup d'œil sur la manière de les utiliser :

<?php
function checkAge($age) {
if ($age < 0) {
throw new Exception("L'âge ne peut pas être négatif !");
}
if ($age < 18) {
throw new Exception("Désolé, tu dois avoir 18 ans ou plus.");
}
return "Bienvenue ! Tu es assez âgé.";
}

try {
echo checkAge(15);
} catch (Exception $e) {
echo "Erreur : " . $e->getMessage();
} finally {
echo "<br>Merci d'avoir utilisé notre vérificateur d'âge !";
}
?>

Dans cet exemple, nous vérifions si quelqu'un est assez âgé pour entrer. Nous utilisons try pour essayer le code, catch pour gérer toute exception, et finally pour exécuter du code indépendamment de la survenue ou non d'une exception.

Création d'un gestionnaire d'exceptions personnalisé

Enfin, créons notre propre gestionnaire d'exceptions personnalisé. C'est comme concevoir ton propre système de messages d'erreur !

<?php
class CustomException extends Exception {
public function errorMessage() {
$errorMsg = 'Erreur à la ligne '.$this->getLine().' dans '.$this->getFile()
.': <b>'.$this->getMessage().'</b> n\'est pas une adresse e-mail valide';
return $errorMsg;
}
}

$email = "[email protected]";

try {
if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE) {
throw new CustomException($email);
}
} catch (CustomException $e) {
echo $e->errorMessage();
}
?>

Ici, nous avons créé une classe CustomException qui fournit un message d'erreur détaillé pour les adresses e-mail invalides. Nous utilisons cette exception personnalisée pour gérer les erreurs lors de la validation d'une adresse e-mail.

Et voilà ! Nous avons couvert unelarge gamme de techniques de gestion des erreurs en PHP. Souviens-toi, une bonne gestion des erreurs est comme porter une ceinture de sécurité - elle peut sembler inutile jusqu'à ce que tu en aies besoin. Continue à pratiquer ces concepts, et bientôt tu seras un pro de la gestion des erreurs !

Méthode	Description
die()	Arrête l'exécution du script et affiche un message
set_error_handler()	Définit une fonction de gestion des erreurs personnalisée
try-catch	Utilisé pour la gestion des exceptions
throw	Utilisé pour lancer une exception
finally	Spécifie du code à exécuter indépendamment de la survenue d'une exception
classes d'erreurs personnalisées	Permettent de créer des types d'erreurs spécifiques

Bonne programmation, et souviens-toi - en programmation, les erreurs sont juste des opportunités d'apprendre et d'améliorer ton code !

Credits: Image by storyset