Hoe handle je uitzonderingen correct?

Question

Accepted Answer

PHP verwerkt fouten met **exceptions** die worden afgevangen via `try/catch/finally`. Correct afhandelen van uitzonderingen betekent het afvangen van specifieke types, het maken van betekenisvolle aangepaste exceptions, het opruimen van resources, en het nooit blootstellen van interne details aan gebruikers. ## De basisstructuur ```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) } ``` Vang **specifieke** exception types af (meest specifieke eerst), gebruik `Throwable` als laatste catch-all (dekt zowel `Error` als `Exception`), en gebruik `finally` voor opruiming die altijd moet worden uitgevoerd. ## Gooien en aangepaste 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); ``` Aangepaste exception-klassen maken foutafhandeling expressief en stellen callers in staat specifieke domeinfouten af te vangen. ## Exception chaining (behoud de oorzaak) ```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); } ``` Het derde constructor-argument koppelt de originele exception (`$e->getPrevious()`), waardoor de volledige oorzaak behouden blijft voor debugging. ## 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) ``` ## Waarom het belangrijk is Correcte afhandeling van uitzonderingen is essentieel voor het bouwen van robuuste, betrouwbare en veilige PHP-applicaties. Het begrijpen van de `try/catch/finally`-structuur, het afvangen van **specifieke** exception types (voor gerichte afhandeling) met `Throwable` als laatste catch-all (dekt zowel `Error` als `Exception` in moderne PHP), en het gebruik van `finally` voor gegarandeerde opruiming is fundamentele dagelijkse kennis. Buiten de mechanica zijn de best practices belangrijk: het maken van **betekenisvolle aangepaste exceptions** voor domeinfouten maakt code expressief en stelt callers in staat specifieke fouten af te handelen; **exception chaining** bewaart de root cause voor debugging; en cruciaal, **exceptions niet zwijgend inslikken** (in plaats daarvan loggen of opnieuw gooien) voorkomt verborgen fouten. Een bijzonder belangrijk punt is **beveiliging**: exceptions en fouten moeten **intern worden geregistreerd maar nooit aan gebruikers worden blootgesteld** (stack traces en interne details lekken gevoelige informatie en helpen aanvallers — vandaar `display_errors` uit in productie). Weten hoe je uitzonderingen correct afhandelt — specifieke catches, aangepaste exceptions, opruiming, chaining, en veilige logging in plaats van blootstelling — onderscheidt robuuste, professionele PHP van fragiele code die onbeheerst crasht of informatie lekt, waardoor het belangrijke kennis is voor het bouwen van betrouwbare, veilige applicaties.