PHP => Behandeling van uitzonderingen en foutrapportage

Foutrapportage instellen en waar deze worden weergegeven

Als dit nog niet is gebeurd in php.ini, kan foutrapportage dynamisch worden ingesteld en moet het zo worden ingesteld dat de meeste fouten kunnen worden weergegeven:

Syntaxis

int error_reporting ([ int $level ] )

Voorbeelden

// should always be used prior to 5.4
error_reporting(E_ALL);

// -1 will show every possible error, even when new levels and constants are added 
// in future PHP versions. E_ALL does the same up to 5.4.
error_reporting(-1);

// without notices
error_reporting(E_ALL & ~E_NOTICE);

// only warnings and notices.
// for the sake of example, one shouldn't report only those
error_reporting(E_WARNING | E_NOTICE);

fouten worden standaard vastgelegd door php, normaal gesproken in een error.log-bestand op hetzelfde niveau als het lopende script.

in de ontwikkelomgeving kan men ze ook op het scherm tonen:

ini_set('display_errors', 1);

in productie moet men dat echter wel doen

ini_set('display_errors', 0);

en een vriendelijk probleembericht weergeven door het gebruik van een Exception- of Error-handler.

Uitzondering en foutafhandeling

proberen te vangen

try..catch blocks kunnen worden gebruikt om de stroom van een programma te besturen waar uitzonderingen kunnen worden gegenereerd. Ze kunnen worden gepakt en gracieus worden behandeld in plaats van PHP te laten stoppen wanneer men wordt aangetroffen:

try {
    // Do a bunch of things...
    throw new Exception('My test exception!');
} catch (Exception $ex) {
    // Your logic failed. What do you want to do about that? Log it:
    file_put_contents('my_error_log.txt', $ex->getMessage(), FILE_APPEND);
}

Het bovenstaande voorbeeld zou catch van de uitzondering gegooid in de try blok en meldt dat de boodschap ( "mijn test uitzondering!") Naar een tekstbestand.

Verschillende soorten uitzonderingen vangen

U kunt meerdere catch implementeren voor verschillende soorten uitzonderingen die op verschillende manieren moeten worden afgehandeld, bijvoorbeeld:

try {
    throw new InvalidArgumentException('Argument #1 must be an integer!');
} catch (InvalidArgumentException $ex) {
    var_dump('Invalid argument exception caught: ' . $ex->getMessage());
} catch (Exception $ex) {
    var_dump('Standard exception caught: ' . $ex->getMessage());
}

In het bovenstaande voorbeeld wordt de eerste catch gebruikt, omdat deze eerst overeenkomt in de volgorde van uitvoering. Als u de volgorde van de catch omwisselde, zou de Exception eerst worden uitgevoerd.

Op dezelfde manier, als je om een gooi UnexpectedValueException in plaats daarvan zou je zien de tweede handler voor een standaard Exception wordt gebruikt.

Tenslotte

Als je iets gedaan moeten worden na ofwel een try of een catch is afgewerkt lopen, kunt u gebruik maken van een finally statement:

try {
    throw new Exception('Hello world');
} catch (Exception $e) {
    echo 'Uh oh! ' . $e->getMessage();
} finally {
    echo " - I'm finished now - home time!";
}

Het bovenstaande voorbeeld zou het volgende opleveren:

Oh Oh! Hallo wereld - Ik ben nu klaar - tijd voor thuis!

Throwable

In PHP 7 zien we de introductie van de Throwable interface, die zowel Error als Exception implementeert. Dit voegt een servicecontractniveau toe tussen uitzonderingen in PHP 7 en stelt u in staat om de interface te implementeren voor uw eigen aangepaste uitzonderingen:

$handler = function(\Throwable $ex) {
    $msg = "[ {$ex->getCode()} ] {$ex->getTraceAsString()}";
    mail('[email protected]', $ex->getMessage(), $msg);
    echo myNiceErrorMessageFunction();
};
set_exception_handler($handler);
set_error_handler($handler);

Voorafgaand aan PHP 7 kunt u eenvoudig Exception typen omdat vanaf PHP 5 alle uitzonderingsklassen deze uitbreiden.

Fatale fouten vastleggen

In PHP is een fatale fout een soort fout die niet kan worden gevangen, dat wil zeggen dat na een fatale fout een programma niet wordt hervat. Om deze fout te registreren of op een of andere manier de crash te verwerken, kunt u de functie register_shutdown_function om de afsluithandler te registreren.

function fatalErrorHandler() {
    // Let's get last error that was fatal.
    $error = error_get_last();
   
    // This is error-only handler for example purposes; no error means that
    // there were no error and shutdown was proper. Also ensure it will handle 
    // only fatal errors.
    if (null === $error || E_ERROR != $error['type']) {
        return;
    }

    // Log last error to a log file.
    // let's naively assume that logs are in the folder inside the app folder.
    $logFile = fopen("./app/logs/error.log", "a+");

    // Get useful info out of error.
    $type    = $error["type"];
    $file    = $error["file"];
    $line    = $error["line"];
    $message = $error["message"]

    fprintf(
        $logFile,
        "[%s] %s: %s in %s:%d\n",
        date("Y-m-d H:i:s"),
        $type,        
        $message,
        $file, 
        $line);

    fclose($logFile);       
}


register_shutdown_function('fatalErrorHandler');

Referentie:

Modified text is an extract of the original Stack Overflow Documentation

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

PHP
Behandeling van uitzonderingen en foutrapportage

Zoeken…