Wie behandelst du Exceptions ordnungsgemäß?

Question

Accepted Answer

PHP behandelt Fehler mit **Exceptions**, die über `try/catch/finally` abgefangen werden. Ordnungsgemäße Exception-Behandlung bedeutet das Abfangen spezifischer Typen, das Erstellen aussagekräftiger Custom Exceptions, das Bereinigen von Ressourcen und das Nichtvollstellen interner Details an Benutzer. ## Die grundlegende Struktur ```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) } ``` Fange **spezifische** Exception-Typen ab (die spezifischsten zuerst), verwende `Throwable` als finalen Catch-All (deckt sowohl `Error` als auch `Exception` ab), und nutze `finally` für Cleanup-Code, der immer ausgeführt werden muss. ## Exceptions werfen und Custom Exceptions ```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); ``` Custom Exception-Klassen machen die Fehlerbehandlung aussagekräftig und ermöglichen es den Aufrufern, spezifische Domain-Fehler abzufangen. ## Exception Chaining (die Ursache bewahren) ```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); } ``` Das dritte Konstruktor-Argument verkündet die ursprüngliche Exception (`$e->getPrevious()`), wodurch die vollständige Ursache für das Debugging erhalten bleibt. ## Best Practices ```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) ``` ## Warum es wichtig ist Ordnungsgemäße Exception-Behandlung ist unverzichtbar für den Aufbau robuster, zuverlässiger und sicherer PHP-Anwendungen. Das Verständnis der `try/catch/finally`-Struktur, das Abfangen **spezifischer** Exception-Typen (für gezielte Behandlung) mit `Throwable` als finalem Catch-All (Abdeckung von `Error` und `Exception` im modernen PHP) und die Verwendung von `finally` für garantierte Bereinigung ist fundamentales alltägliches Wissen. Über die Mechanik hinaus sind Best Practices wichtig: das Erstellen **aussagekräftiger Custom Exceptions** für Domain-Fehler macht Code aussagekräftig und ermöglicht es den Aufrufern, spezifische Fehler zu behandeln; **Exception Chaining** bewahrt die Grundursache zum Debuggen; und entscheidend ist **nicht stillschweigend Exceptions zu schlucken** (stattdessen protokollieren oder erneut werfen), um versteckte Fehler zu vermeiden. Ein besonders wichtiger Punkt ist **Sicherheit**: Exceptions und Fehler sollten **intern protokolliert, aber niemals Benutzern ausgesetzt werden** (Stack Traces und interne Details geben sensible Informationen preis und helfen Angreifern — daher `display_errors` off in der Produktion). Zu wissen, wie man Exceptions ordnungsgemäß behandelt — spezifische Catches, Custom Exceptions, Bereinigung, Chaining und sichere Protokollierung statt Ausstellung — unterscheidet robustes, professionelles PHP von fragiler Code, der ungraceful abstürzt oder Informationen preisgibt, was es zu wichtigem Wissen für den Aufbau zuverlässiger, sicherer Anwendungen macht.