Chapitre 16 : Gestion des erreurs

1. Introduction

La gestion des erreurs est une compétence essentielle en programmation. Elle permet de prévoir et de gérer les situations imprévues qui peuvent survenir lors de l'exécution d'un script PHP. Un bon débogage permet de trouver et corriger rapidement les bugs dans votre code.

Dans ce chapitre, nous allons apprendre à :

• Comprendre les différents types d'erreurs en PHP
• Utiliser les blocs try/catch pour gérer les exceptions
• Créer des exceptions personnalisées
• Utiliser les outils de débogage

2. Les types d'erreurs en PHP

PHP distingue plusieurs niveaux d'erreurs :

Parse Error (Erreur de syntaxe)

Erreur fatale qui empêche le script de s'exécuter. Elle survient quand la syntaxe PHP est incorrecte.

<?php
// Parse Error : point-virgule manquant
echo "Bonjour"
?>

Fatal Error

Erreur grave qui arrête l'exécution du script (ex : appel d'une fonction inexistante).

<?php
fonctionInexistante(); // Fatal error
?>

Warning (Avertissement)

Erreur non fatale, le script continue de s'exécuter.

<?php
include("fichier_inexistant.php"); // Warning
echo "Le script continue...";
?>

Notice

Message informatif, souvent pour signaler l'utilisation d'une variable non définie.

<?php
echo $variableNonDefinie; // Notice
?>

3. Configuration de l'affichage des erreurs

Vous pouvez contrôler l'affichage des erreurs avec error_reporting() et ini_set() :

<?php
// Afficher toutes les erreurs (utile en développement)
error_reporting(E_ALL);
ini_set('display_errors', 1);

// Masquer les erreurs (recommandé en production)
error_reporting(0);
ini_set('display_errors', 0);

// Afficher uniquement les erreurs graves
error_reporting(E_ERROR | E_WARNING);
?>

4. Gestion des exceptions avec try/catch

Les exceptions permettent de gérer les erreurs de manière structurée avec les blocs try, catch et finally.

Syntaxe de base

<?php
try {
    // Code susceptible de générer une erreur
    $resultat = 10 / 0;
} catch (Exception $e) {
    // Gestion de l'erreur
    echo "Erreur : " . $e->getMessage();
}
?>

Exemple complet avec finally

<?php
function diviser($a, $b) {
    if ($b == 0) {
        throw new Exception("Division par zéro impossible !");
    }
    return $a / $b;
}

try {
    echo diviser(10, 2) . "\n"; // Affiche 5
    echo diviser(10, 0) . "\n"; // Lance une exception
    echo "Cette ligne ne sera jamais exécutée";
} catch (Exception $e) {
    echo "Erreur capturée : " . $e->getMessage();
} finally {
    echo "\nBloc finally toujours exécuté";
}
?>

Résultat :

5
Erreur capturée : Division par zéro impossible !
Bloc finally toujours exécuté

5. Exceptions personnalisées

Vous pouvez créer vos propres classes d'exceptions pour mieux organiser la gestion des erreurs :

<?php
class MonException extends Exception {
    public function messagePersonnalise() {
        return "Erreur personnalisée : " . $this->getMessage();
    }
}

try {
    throw new MonException("Quelque chose s'est mal passé");
} catch (MonException $e) {
    echo $e->messagePersonnalise();
}
?>

Capturer plusieurs types d'exceptions

<?php
class ValidationException extends Exception {}
class DatabaseException extends Exception {}

try {
    // Code...
    throw new ValidationException("Données invalides");
} catch (ValidationException $e) {
    echo "Erreur de validation : " . $e->getMessage();
} catch (DatabaseException $e) {
    echo "Erreur de base de données : " . $e->getMessage();
} catch (Exception $e) {
    echo "Erreur générale : " . $e->getMessage();
}
?>

6. Outils de débogage

var_dump() et print_r()

Pour afficher le contenu détaillé d'une variable :

<?php
$tableau = ["nom" => "Dupont", "age" => 25];

var_dump($tableau);
// array(2) { ["nom"]=> string(6) "Dupont" ["age"]=> int(25) }

print_r($tableau);
// Array ( [nom] => Dupont [age] => 25 )
?>

error_log()

Pour enregistrer des messages dans un fichier de log :

<?php
error_log("Message de débogage", 3, "mon_log.txt");
?>

debug_backtrace()

Pour afficher la pile d'appels (call stack) :

<?php
function fonction1() {
    fonction2();
}

function fonction2() {
    print_r(debug_backtrace());
}

fonction1();
?>

7. Bonnes pratiques

• ✅ En développement : Activez l'affichage de toutes les erreurs
• ✅ En production : Désactivez l'affichage et loggez les erreurs dans des fichiers
• ✅ Utilisez try/catch pour les opérations critiques (BDD, fichiers, API)
• ✅ Créez des exceptions personnalisées pour mieux organiser votre code
• ✅ Utilisez finally pour le code qui doit toujours s'exécuter (fermeture de connexions, etc.)
• ❌ N'utilisez pas @ pour masquer les erreurs (mauvaise pratique)
• ❌ Ne laissez jamais les erreurs visibles en production

8. Exercice pratique

Créez une fonction qui lit un fichier et gère les erreurs possibles :

<?php
function lireFichier($nomFichier) {
    try {
        if (!file_exists($nomFichier)) {
            throw new Exception("Le fichier n'existe pas");
        }

        $contenu = file_get_contents($nomFichier);

        if ($contenu === false) {
            throw new Exception("Impossible de lire le fichier");
        }

        return $contenu;
    } catch (Exception $e) {
        error_log("Erreur : " . $e->getMessage());
        return null;
    }
}

// Utilisation
$contenu = lireFichier("mon_fichier.txt");
if ($contenu !== null) {
    echo $contenu;
} else {
    echo "Erreur lors de la lecture du fichier";
}
?>