PHP => Undantagshantering och felrapportering

Ställer in felrapportering och var de ska visas

Om det inte redan är gjort i php.ini kan felrapportering ställas in dynamiskt och bör ställas in så att de flesta fel kan visas:

Syntax

int error_reporting ([ int $level ] )

exempel

// 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);

fel loggas som standard med php, normalt i en error.log-fil på samma nivå än det körande skriptet.

i utvecklingsmiljö kan man också visa dem på skärmen:

ini_set('display_errors', 1);

i produktionen bör man dock

ini_set('display_errors', 0);

och visa ett vänligt problemmeddelande genom användning av en undantags- eller felhanterare.

Undantag och felhantering

försök fånga

try..catch block kan användas för att kontrollera flödet i ett program där undantag kan kastas. De kan fångas och hanteras graciöst snarare än att låta PHP stoppa när man stöter på:

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);
}

Exemplet ovan skulle catch undantaget som kastas i try och logga meddelandet ("Mitt testundantag!") Till en textfil.

Fånga olika undantagstyper

Du kan implementera flera catch för olika typer av undantag som ska hanteras på olika sätt, till exempel:

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());
}

I exemplet ovan kommer den första catch att användas eftersom den matchar först i utföringsordningen. Om du bytte ordning på catch , skulle Exception verkställa först.

Likaså om du skulle kasta en UnexpectedValueException stället du skulle se den andra hanterare för en standard Exception som används.

till sist

Om du behöver göra något efter antingen ett try eller en catch är klar, kan du använda ett finally uttalande:

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

Exemplet ovan skulle producera följande:

Hoppsan! Hej värld - jag är klar nu - hemtid!

Throwable

I PHP 7 ser vi introduktionen av det Throwable gränssnittet, vilket Error såväl som Exception implementerar. Detta lägger till en serviceavtalsnivå mellan undantag i PHP 7 och låter dig implementera gränssnittet för dina egna anpassade undantag:

$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);

Innan PHP 7 kan du helt enkelt ange ett Exception eftersom alla undantagsklasser från PHP 5 förlänger det.

Logga dödliga fel

I PHP är ett dödligt fel ett slags fel som inte kan fångas, det vill säga efter att ett dödligt fel har uppstått ett program inte återupptas. Men för att logga in det här felet eller på något sätt hantera kraschen kan du använda register_shutdown_function att registrera avstängningshanteraren.

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');

Referens:

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

PHP
Undantagshantering och felrapportering

Sök…