How to optimize the execution efficiency of PHP main function

In PHP projects, the efficiency of the main function or the main execution process directly affects the overall performance. When encountering slow running problems, in addition to hardware upgrades, optimizing the code itself is more critical. This article will introduce several practical methods to improve PHP execution efficiency to help you speed up the operation of main functions.

1. Use cache to reduce duplicate calculations

For time-consuming calculations or data requests, repeated execution can be avoided through caching. Common caching methods include file cache, memory cache (such as Redis, Memcached), etc.

Sample code:

 <?php
$cacheFile = '/tmp/cache.txt';

// Check if the cache exists and has not expired
if (file_exists($cacheFile) && (time() - filemtime($cacheFile)) < 3600) {
    $result = file_get_contents($cacheFile);
} else {
    // Simulation time-consuming operation
    $result = file_get_contents('https://gitbox.net/api/data');
    file_put_contents($cacheFile, $result);
}

echo $result;
?>

Reduce network requests or complex operations through cache, significantly improving program response speed.

2. Reduce unnecessary function calls

Frequent calls to functions in PHP will cause some overhead. Try to avoid calling complex functions in loops or calculating the results in advance.

 <?php
$data = range(1, 10000);

// Not recommended：Calling a function in a loop
foreach ($data as $item) {
    echo strlen("Value: $item") . "\n";
}

// optimization：Calculate length in advance
$prefix = "Value: ";
$prefixLen = strlen($prefix);
foreach ($data as $item) {
    echo $prefixLen + strlen((string)$item) . "\n";
}
?>

Reducing the number of function calls can reduce CPU load.

3. Save memory using the Generator

If you want to process a large amount of data, the generator can delay data generation and avoid loading large amounts of memory at once.

 <?php
function getLargeDataset() {
    for ($i = 0; $i < 1000000; $i++) {
        yield $i;
    }
}

foreach (getLargeDataset() as $value) {
    // Processing data
    if ($value > 10) break; // Example Exit early
}
?>

The generator does the same task with less memory.

4. Use PHP built-in functions instead of handwriting logic

PHP built-in functions are usually optimized for the underlying level and are executed much faster than PHP handwritten code. For example, use array_map , array_filter , array_reduce , etc. instead of loops.

 <?php
$numbers = [1, 2, 3, 4, 5];

// Handwriting loop
$squares = [];
foreach ($numbers as $n) {
    $squares[] = $n * $n;
}

// optimization版
$squares = array_map(fn($n) => $n * $n, $numbers);
?>

With built-in functions, the code is more concise and more efficient.

5. Use OPCache rationally to improve script loading speed

OPCache is PHP's official bytecode cache extension, which can avoid recompiling scripts every time they are executed, greatly improving execution efficiency.

Open method (php.ini):

 opcache.enable=1
opcache.memory_consumption=128
opcache.interned_strings_buffer=8
opcache.max_accelerated_files=10000

Execute php -i | grep opcache on the command line to confirm whether OPCache is enabled.

6. Avoid duplicate loading of files

Use require_once or include_once instead of require or include to avoid the same file being loaded multiple times and reduce I/O overhead.

 <?php
require_once 'config.php';
require_once 'functions.php';

// Continue executing the code
?>