PHP如何自动记录PCRE正则执行错误？含json_decode()场景

Great question! The core issue here is that functions like preg_match() and json_decode() don’t trigger standard PHP errors or uncaught exceptions when they fail—they just set an error code that you have to retrieve manually with preg_last_error() or json_last_error(). That’s why these failures don’t show up in your PHP error log by default.

Below are practical, no-custom-logging-code solutions to auto-log these silent errors, leveraging PHP’s native error/exception handling:

1. Use Built-in Exception Throwing (PHP 7.3+) #

This is the cleanest and most performant approach. PHP lets you convert these silent failures into standard exceptions, which are automatically logged by PHP’s default error handling (just like uncaught exceptions).

For PCRE Functions (e.g., preg_match()) #

Add the PREG_THROW_ON_ERROR flag when calling the function. This will throw a PregException instead of returning false and setting an error code:

// Instead of the default call:
// preg_match('/your-pattern/', $subject, $matches);

// Use this to trigger exceptions on failure:
preg_match('/your-pattern/', $subject, $matches, PREG_THROW_ON_ERROR);

If you don’t catch the exception, PHP will automatically write it to your error log.

For JSON Functions (e.g., json_decode()) #

Use the JSON_THROW_ON_ERROR flag (available since PHP 7.0) to throw a JsonException when parsing fails:

// Instead of the default call:
// $data = json_decode($json);

// Use this to trigger exceptions on failure:
$data = json_decode($json, false, 512, JSON_THROW_ON_ERROR);

Uncaught JsonExceptions are logged automatically by PHP’s native error system.

2. Wrap Native Functions to Trigger Standard PHP Warnings (All PHP Versions) #

If you’re stuck on an older PHP version, create wrapper functions that trigger a standard E_USER_WARNING when an error occurs. PHP automatically logs warnings (assuming your error_reporting settings include E_USER_WARNING, which is default).

// Wrapper for preg_match
function my_preg_match($pattern, $subject, &$matches = null, $flags = 0, $offset = 0) {
    $result = preg_match($pattern, $subject, $matches, $flags, $offset);
    
    if ($result === false) {
        $errorMsg = preg_last_error_msg();
        $errorCode = preg_last_error();
        // Trigger a warning that PHP will log automatically
        trigger_error("preg_match failed: $errorMsg (Code: $errorCode)", E_USER_WARNING);
    }
    
    return $result;
}

// Wrapper for json_decode
function my_json_decode($json, $assoc = false, $depth = 512, $flags = 0) {
    $result = json_decode($json, $assoc, $depth, $flags);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        $errorMsg = json_last_error_msg();
        $errorCode = json_last_error();
        trigger_error("json_decode failed: $errorMsg (Code: $errorCode)", E_USER_WARNING);
    }
    
    return $result;
}

Replace all calls to preg_match()/json_decode() with your wrappers—no custom logging code needed, PHP handles the rest via its native error logging.

3. Use Tick Functions to Auto-Check Errors (No Code Changes, But Performance Cost) #

If you can’t modify existing code, use PHP’s tick mechanism to automatically check for PCRE/JSON errors after every statement. This works without changing your function calls but adds overhead since it runs after every line of code.

// Enable ticks (runs the registered function after every statement)
declare(ticks=1);

function auto_check_silent_errors() {
    // Check and log PCRE errors
    $pregError = preg_last_error();
    if ($pregError !== PREG_NO_ERROR) {
        $errorMsg = preg_last_error_msg();
        error_log("PCRE Silent Error: $errorMsg (Code: $pregError)");
        // Reset error state to avoid re-logging the same error
        preg_match('/^.$/', '');
    }
    
    // Check and log JSON errors
    $jsonError = json_last_error();
    if ($jsonError !== JSON_ERROR_NONE) {
        $errorMsg = json_last_error_msg();
        error_log("JSON Silent Error: $errorMsg (Code: $jsonError)");
        // Reset error state
        json_decode('{}');
    }
}

// Register the tick function
register_tick_function('auto_check_silent_errors');

This will automatically log errors as they occur using PHP’s built-in error_log() function, which writes to your default PHP error log.

• For PHP 7.3+, use PREG_THROW_ON_ERROR and JSON_THROW_ON_ERROR—this is the cleanest, most efficient option.
• For older PHP versions, wrapper functions that trigger warnings balance ease of use and performance.
• Tick functions work without code changes but add overhead, so use them sparingly in production.

内容的提问来源于stack exchange，提问作者Leo Galleguillos