Module PHP.10 – Gestion des erreurs

Objectif

Maîtriser la gestion des erreurs en PHP : comprendre les types d'erreurs, utiliser les exceptions avec try/catch, et créer des exceptions personnalisées.

Théorie

Erreurs PHP

Types d'erreurs :

Erreurs fatales (Fatal errors)
- Arrêtent l'exécution
- Exemple : fonction inexistante appelée
Erreurs critiques (Critical errors)
- Problèmes graves
- Exemple : mémoire insuffisante
Avertissements (Warnings)
- N'arrêtent pas l'exécution
- Exemple : fichier introuvable
Notices
- Informations mineures
- Exemple : variable non définie utilisée

Niveaux d'erreurs :

error_reporting(E_ALL);              // Toutes les erreurs
error_reporting(E_ERROR);            // Seulement erreurs fatales
error_reporting(E_WARNING);         // Seulement avertissements
error_reporting(E_ALL & ~E_NOTICE);  // Tout sauf notices

Affichage des erreurs :

ini_set('display_errors', 1);        // Afficher (développement)
ini_set('display_errors', 0);        // Cacher (production)
error_reporting(E_ALL);              // Rapporter toutes

Exceptions

Les exceptions permettent de gérer les erreurs de manière élégante.

Structure try/catch :

try {
    // Code qui peut générer une exception
    $resultat = diviser(10, 0);
} catch (Exception $e) {
    // Gestion de l'erreur
    echo "Erreur : " . $e->getMessage();
}

Lancer une exception :

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

Propriétés de l'exception :

catch (Exception $e) {
    $e->getMessage();    // Message d'erreur
    $e->getCode();       // Code d'erreur
    $e->getFile();       // Fichier où l'erreur s'est produite
    $e->getLine();       // Ligne de l'erreur
    $e->getTrace();      // Pile d'appels
    $e->getTraceAsString(); // Pile en string
}

Plusieurs catch

On peut gérer différents types d'exceptions.

try {
    // Code
} catch (DivisionByZeroError $e) {
    echo "Division par zéro";
} catch (TypeError $e) {
    echo "Type incorrect";
} catch (Exception $e) {
    echo "Autre erreur : " . $e->getMessage();
}

finally

Le bloc finally s'exécute toujours, même en cas d'exception.

try {
    $fichier = fopen("data.txt", "r");
    // Traitement
} catch (Exception $e) {
    echo "Erreur : " . $e->getMessage();
} finally {
    if (isset($fichier)) {
        fclose($fichier);  // Toujours fermer
    }
}

Exceptions personnalisées

Créer ses propres types d'exceptions.

Création :

class ValidationException extends Exception {
    private $champ;
    
    public function __construct($message, $champ = "") {
        parent::__construct($message);
        $this->champ = $champ;
    }
    
    public function getChamp() {
        return $this->champ;
    }
}

Utilisation :

function validerEmail($email) {
    if (empty($email)) {
        throw new ValidationException("Email requis", "email");
    }
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        throw new ValidationException("Email invalide", "email");
    }
    return true;
}

try {
    validerEmail("");
} catch (ValidationException $e) {
    echo "Erreur de validation : " . $e->getMessage();
    echo "Champ : " . $e->getChamp();
}

Exceptions natives PHP

Exceptions courantes :

Exception : Classe de base
Error : Erreurs fatales (PHP 7+)
TypeError : Erreur de type
ArgumentCountError : Mauvais nombre d'arguments
DivisionByZeroError : Division par zéro
ParseError : Erreur de syntaxe

Hiérarchie :

Throwable
├── Error
│   ├── TypeError
│   ├── ParseError
│   └── ...
└── Exception
    ├── RuntimeException
    ├── InvalidArgumentException
    └── ...

Gestion des erreurs de fichiers

try {
    $fichier = fopen("inexistant.txt", "r");
    if (!$fichier) {
        throw new Exception("Impossible d'ouvrir le fichier");
    }
    // Lecture
    fclose($fichier);
} catch (Exception $e) {
    echo "Erreur fichier : " . $e->getMessage();
}

Avec file_get_contents :

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

Gestion des erreurs de base de données

try {
    $pdo = new PDO("mysql:host=localhost;dbname=test", $user, $pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    
    $stmt = $pdo->query("SELECT * FROM users");
} catch (PDOException $e) {
    echo "Erreur BDD : " . $e->getMessage();
}

Bonnes pratiques

1. Toujours gérer les exceptions :

// ❌ Mauvais
$resultat = diviser(10, 0);  // Erreur fatale

// ✅ Bon
try {
    $resultat = diviser(10, 0);
} catch (Exception $e) {
    // Gestion appropriée
}

2. Messages d'erreur clairs :

throw new Exception("Division par zéro impossible");
// Pas : throw new Exception("Erreur");

3. Logging en production :

try {
    // Code
} catch (Exception $e) {
    error_log($e->getMessage());  // Log l'erreur
    // Afficher message générique à l'utilisateur
    echo "Une erreur s'est produite";
}

4. Ne pas exposer les détails :

// ❌ En production
catch (Exception $e) {
    echo $e->getMessage();  // Peut exposer des infos sensibles
}

// ✅ En production
catch (Exception $e) {
    error_log($e->getMessage());  // Log pour développeur
    echo "Erreur lors du traitement";  // Message générique
}

Exercice

Exceptions de base
- Créez une fonction qui lance une exception
- Capturez-la avec try/catch
- Affichez les informations de l'exception
Plusieurs catch
- Créez différentes exceptions
- Gérez-les avec plusieurs blocs catch
- Testez l'ordre des catch
Finally
- Utilisez finally pour nettoyer des ressources
- Vérifiez que finally s'exécute toujours
Exceptions personnalisées
- Créez une exception personnalisée
- Ajoutez des propriétés spécifiques
- Utilisez-la dans votre code
Gestion complète
- Créez un système avec plusieurs niveaux d'exceptions
- Gérez les erreurs de fichiers
- Implémentez le logging

Quiz

Que fait try/catch ?
- Empêche les erreurs
- Capture et gère les exceptions
- Compile le code
Quand s'exécute finally ?
- Seulement en cas d'erreur
- Toujours
- Seulement en cas de succès
Comment créer une exception personnalisée ?
- new Exception()
- Créer une classe qui étend Exception
- Utiliser error_log()
Quelle exception utiliser pour les erreurs de type ?
- Exception
- TypeError
- ParseError
Que faire avec les erreurs en production ?
- Les afficher à l'utilisateur
- Les logger et afficher un message générique
- Les ignorer

Mini défi

Mission : Créer un système de validation robuste

Créez un système complet de validation avec gestion d'erreurs :

Fonctionnalités :

Exceptions personnalisées
- ValidationException : Erreurs de validation
- FormatException : Format incorrect
- RequiredException : Champ requis manquant
Fonctions de validation
- validerEmail($email) : Valide un email
- validerAge($age) : Valide un âge (13-120)
- validerMotDePasse($mdp) : Valide un mot de passe (8+ caractères)
- validerTelephone($tel) : Valide un numéro de téléphone
Fonction de validation complète
- validerFormulaire($donnees) : Valide tous les champs
- Lance les exceptions appropriées
- Collecte toutes les erreurs
Gestion des erreurs
- Affiche les erreurs par champ
- Log les erreurs pour le développeur
- Message utilisateur clair

Exemple d'utilisation :

$donnees = [
    "email" => "email-invalide",
    "age" => 5,
    "mot_de_passe" => "123"
];

try {
    validerFormulaire($donnees);
} catch (ValidationException $e) {
    echo "Erreur : " . $e->getMessage();
    echo "Champ : " . $e->getChamp();
}

Critères :

✅ Exceptions personnalisées créées
✅ Toutes les validations implémentées
✅ Gestion d'erreurs complète
✅ Messages clairs pour l'utilisateur
✅ Logging pour le développeur
✅ Code robuste et sécurisé

Objectif : Maîtriser la gestion des erreurs et créer un système robuste avec exceptions personnalisées.

Validation : Vous pouvez passer au module suivant quand vous maîtrisez les exceptions et pouvez créer un système de gestion d'erreurs complet.

Objectif​

Théorie​

Erreurs PHP​

Exceptions​

Plusieurs catch​

finally​

Exceptions personnalisées​

Exceptions natives PHP​

Gestion des erreurs de fichiers​

Gestion des erreurs de base de données​

Bonnes pratiques​

Exercice​

Quiz​

Mini défi​