To time a PHP function effectively, use microtime() for basic timing by capturing the start and end time around the function call, then calculate the difference. 1. Use microtime(true) to get precise timestamps as floats. 2. Subtract the start time from the end time to determine execution duration. 3. Round the result to four decimal places for readability. For repeated use, wrap the logic in a reusable helper function that returns both the result and the execution time. For deeper performance insights, consider profiling tools like Xdebug, Blackfire.io, Tideways, or XHGui. If the function outputs directly, use output buffering with ob_start() and ob_get_clean() to capture and separate timing output from the function's output.

Timing how long a PHP function takes to execute is a common task when you're trying to optimize performance or debug slow-running code. The idea is simple: capture the time before and after the function runs, then subtract the two to get the duration.

Here’s how to do it effectively in different scenarios.

Use microtime() for basic timing

The most straightforward way to measure execution time in PHP is using the built-in microtime() function. It returns the current Unix timestamp with microseconds as a float, which gives you high precision.

$startTime = microtime(true);

// Call your function here
your_function();

$endTime = microtime(true);

$executionTime = $endTime - $startTime;
echo "Execution time: " . round($executionTime, 4) . " seconds";

• Set true as the argument to return a float instead of a string.
• Round the result to 4 decimal places for readability unless you need higher precision.
• This method works great for quick checks in scripts or during development.

Wrap it in a reusable function

If you find yourself timing multiple functions often, it helps to wrap the logic into a helper function. That keeps your code clean and avoids repetition.

function time_function(callable $callback) {
    $start = microtime(true);
    $result = $callback();
    $end = microtime(true);

    return [
        'result' => $result,
        'time' => round($end - $start, 4)
    ];
}

Usage example:

$response = time_function(function() {
    // Your heavy function or process
    return some_complicated_operation();
});

echo "Took {$response['time']} seconds.";

This pattern is especially useful if you want to log or compare performance across different parts of your app.

Consider using profiling tools for deeper insights

While microtime() gets the job done for one-off checks, real performance analysis usually requires more depth — like seeing which internal functions are taking the most time, memory usage, etc.

In that case, use a profiler like:

• Xdebug – enables stack traces and integrates with profiling tools.
• Blackfire.io – gives detailed performance reports including call graphs and bottlenecks.
• Tideways / XHGui – lightweight alternatives that offer visual insight into function calls and execution paths.

These tools can help identify not just total execution time, but also what's happening under the hood inside your function.

Don’t forget about output buffering and display

Sometimes you might want to show the timing result without disrupting the actual output of the function. In those cases, make sure to buffer the output:

ob_start(); // Start output buffer
$startTime = microtime(true);

your_function();

$endTime = microtime(true);
$output = ob_get_clean(); // Capture and clean the buffer

echo "Function executed in " . round($endTime - $startTime, 4) . " seconds.<br>";
echo $output; // Resume normal output

This is helpful when testing functions that generate HTML or other output directly.

That’s basically it. Whether you're doing a quick check or digging deep into performance issues, these methods should cover most use cases. Timing a PHP function doesn’t have to be complicated — but knowing the right approach makes all the difference.

The above is the detailed content of How to time the execution of a PHP function for performance?. For more information, please follow other related articles on the PHP Chinese website!