Hoe werkt fout- en uitzonderingafhandeling in PHP…

Fouten- en uitzonderingafhandeling in PHP stelt je in staat om de uitvoering van het programma te controleren bij het optreden van onjuiste situaties, kritische crashes te voorkomen en zinvolle informatie aan de gebruiker te bieden.

Fouten

Fouten zijn problemen die op het niveau van de PHP-interpreter optreden. Ze kunnen syntactisch, logisch of gerelateerd aan toegang tot niet-bestaande bronnen zijn. Fouten niveaus worden bepaald door constanten (E_ERROR, E_WARNING, E_NOTICE, etc.) en kunnen worden aangepast met error_reporting en display_errors.

Voor foutafhandeling worden aangepaste functies-handlers gebruikt, geregistreerd via set_error_handler(). Deze functie onderschept fouten (behalve E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING), waardoor ze kunnen worden geregistreerd, een bericht worden weergegeven, het script worden gestopt of voortgezet.

<?php
// Aangepaste foutafhandelingsfunctie
function myErrorHandler($errno, $errstr, $errfile, $errline) {
    // Log de fout
    error_log("Fout [$errno]: $errstr in bestand $errfile op regel $errline");

    // Toon bericht aan gebruiker (afhankelijk van omgeving)
    if (ini_get('display_errors')) {
        echo "Er is een fout opgetreden: [$errno] $errstr<br>";
        echo "In bestand: $errfile op regel: $errline<br>";
    }

    // Stop het script bij kritieke fouten
    if ($errno == E_USER_ERROR) {
        die("Kritieke fout. Script gestopt.");
    }

    // Ga door met standaard PHP-afhandeling, indien de functie false retourneert
    // return false;
}

// Registreer de handlerfunctie
set_error_handler("myErrorHandler");

// Voorbeeldfout
// echo $undeclaredVar; // Roep E_NOTICE op

Uitzonderingen

Uitzonderingen zijn objecten die worden geworpen bij het optreden van uitzonderlijke situaties. Ze maken het mogelijk om de code te structureren en de stroom van uitvoering flexibeler te beheren dan traditionele foutafhandeling.

Uitzonderingen worden afgehandeld met behulp van de constructie try...catch...finally:

try: blok code waarin een uitzondering kan optreden.
catch: blok code dat wordt uitgevoerd als in try of een andere catch een uitzondering van het opgegeven type is geworpen. Meerdere catch-blokken kunnen worden gebruikt voor verschillende typen uitzonderingen.
finally: (beschikbaar vanaf PHP 5.5) blok code dat altijd wordt uitgevoerd, ongeacht of een uitzondering is geworpen en opgevangen.

<?php
function divide($a, $b) {
    if ($b === 0) {
        // Werp een ingebouwde Exception
        throw new Exception("Delen door nul is niet mogelijk.");
    }
    return $a / $b;
}

try {
    // Probeer code uit te voeren die een uitzondering kan werpen
    echo divide(10, 2) . "<br>";
    echo divide(5, 0) . "<br>"; // hier wordt een uitzondering gegenereerd
    echo "Deze code wordt niet uitgevoerd als de vorige uitzondering werpt.";
} catch (Exception $e) {
    // Vang de uitzondering op
    echo "Opgevangen uitzondering: " . $e->getMessage() . "<br>";
    // Je kunt ook bestand, regel en stack trace krijgen
    // echo "In bestand: " . $e->getFile() . " op regel: " . $e->getLine() . "<br>";
    // echo "Stack trace:<pre>" . $e->getTraceAsString() . "</pre>";
} finally {
    // Dit blok wordt altijd uitgevoerd
    echo "Operatie voltooid.<br>";
}

Uitzonderingsklassen

PHP biedt de basisklasse Exception, waaruit andere ingebouwde uitzonderingsklassen erven (bijvoorbeeld InvalidArgumentException, RuntimeException). Je kunt eigen uitzonderingsklassen maken door van Exception of zijn afgeleiden te erven, voor een meer precieze representatie van fouttypes.

<?php
class MyCustomException extends Exception {
    // Eigen eigenschappen en methoden kunnen worden toegevoegd
}

function processData($data) {
    if (empty($data)) {
        // Werp een aangepaste uitzondering
        throw new MyCustomException("Gegevens voor verwerking ontbreken.");
    }
    // ... gegevens verwerken
}

try {
    processData([]);
} catch (MyCustomException $e) {
    echo "Opgevangen aangepaste uitzondering: " . $e->getMessage() . "<br>";
} catch (Exception $e) {
    // Afhandeling van andere uitzonderingen
    echo "Opgevangen andere uitzondering: " . $e->getMessage() . "<br>";
}

Algemene principes

Vang geen fouten af die je niet kunt verwerken. Als je niet weet hoe je op een bepaalde fout moet reageren, laat deze dan hogerop afhandelen.
Uitzonderingen zijn beter geschikt voor verwachte, maar uitzonderlijke situaties (bijvoorbeeld invoerfouten, onmogelijkheid om verbinding te maken met de database). Fouten wijzen vaak op problemen in de code of omgeving.
Log fouten en uitzonderingen. Dit is cruciaal voor debugging en monitoring.
Ontwikkel geen gevoelige informatie aan de gebruiker in foutmeldingen.
Gebruik set_exception_handler() om onopgevangen uitzonderingen af te handelen. Dit voorkomt fatale fouten en zorgt voor een graceful degradation.

<?php
// Handler voor onopgevangen uitzonderingen
function myExceptionHandler($exception) {
    error_log("Onopgevangen uitzondering: " . $exception->getMessage());
    // Redirect naar foutpagina, algemene boodschap tonen, etc.
    echo "Er is een onverwachte fout op de server opgetreden. Probeer het later opnieuw.";
}

set_exception_handler('myExceptionHandler');

// Deze code werpt een uitzondering die door myExceptionHandler wordt afgehandeld
// throw new Exception("Dit is een onopgevangen uitzondering.");

Zo is het correct gebruik van fout- en uitzonderingafhandeling een fundamenteel onderdeel van het maken van betrouwbare en onderhoudbare PHP-toepassingen.

Hoe werkt fout- en uitzonderingafhandeling in PHP?