Comment gérez-vous correctement les exceptions ?

Question

Accepted Answer

PHP gère les erreurs avec des **exceptions** capturées via `try/catch/finally`. Une gestion appropriée des exceptions signifie capturer des types spécifiques, créer des exceptions personnalisées significatives, nettoyer les ressources et ne jamais exposer les détails internes aux utilisateurs. ## La structure de base ```php getMessage()); } catch (DatabaseException $e) { handleDbError($e); } catch (Throwable $e) { // catch-all (Error OR Exception) — last logError($e); throw $e; // re-throw what you can't handle } finally { cleanup(); // ALWAYS runs (success or failure) } ``` Capturez des types d'exception **spécifiques** (les plus spécifiques en premier), utilisez `Throwable` comme capture finale (couvre à la fois `Error` et `Exception`), et utilisez `finally` pour le nettoyage qui doit toujours s'exécuter. ## Lancer et exceptions personnalisées ```php // throwing if ($amount < 0) { throw new InvalidArgumentException("Amount must be positive, got $amount"); } // a custom exception for your domain class InsufficientFundsException extends Exception { public function __construct(private float $shortfall) { parent::__construct("Short by $shortfall"); } public function getShortfall(): float { return $this->shortfall; } } throw new InsufficientFundsException(50.0); ``` Les classes d'exception personnalisées rendent la gestion des erreurs expressive et permettent aux appelants de capturer des erreurs de domaine spécifiques. ## Chaînage d'exceptions (préserver la cause) ```php try { $db->query(...); } catch (PDOException $e) { // wrap with context, preserving the original as the "previous" exception throw new RepositoryException("Failed to load user", 0, $e); } ``` Le troisième argument du constructeur chaîne l'exception originale (`$e->getPrevious()`), préservant la cause complète pour le débogage. ## Bonnes pratiques ```text ✓ Catch SPECIFIC exceptions, not a blanket Throwable (unless intentionally last) ✓ Don't swallow exceptions silently (empty catch) — log or re-throw ✓ Use finally / proper cleanup for resources (files, connections) ✓ Create meaningful custom exceptions for domain errors ✓ SECURITY: log details internally; show users a generic message (don't leak stack traces / internal info — display_errors off in production) ``` ## Pourquoi c'est important Une gestion appropriée des exceptions est essentielle pour construire des applications PHP robustes, fiables et sécurisées. Comprendre la structure `try/catch/finally`, capturer les types d'exception **spécifiques** (pour un traitement ciblé) avec `Throwable` comme capture finale (couvrant à la fois `Error` et `Exception` en PHP moderne), et utiliser `finally` pour le nettoyage garanti est une connaissance fondamentale au quotidien. Au-delà des mécaniques, les bonnes pratiques comptent : créer des **exceptions personnalisées significatives** pour les erreurs de domaine rend le code expressif et permet aux appelants de gérer les défaillances spécifiques ; le **chaînage d'exceptions** préserve la cause racine pour le débogage ; et de manière cruciale, **ne pas avaler les exceptions silencieusement** (enregistrer ou relancer plutôt) prévient les défaillances cachées. Un point particulièrement important est la **sécurité** : les exceptions et erreurs doivent être **enregistrées en interne mais jamais exposées aux utilisateurs** (les traces de pile et les détails internes divulguent des informations sensibles et aident les attaquants — d'où `display_errors` désactivé en production). Savoir comment gérer correctement les exceptions — captures spécifiques, exceptions personnalisées, nettoyage, chaînage et enregistrement sécurisé plutôt que exposition — distingue le PHP robuste et professionnel du code fragile qui s'arrête maladroitement ou fuit des informations, ce qui en fait une connaissance importante pour construire des applications fiables et sécurisées.