To implement a PHP function with cache function, the key is to use closures to record input and output; the specific steps are as follows: 1. Define the memoize function and encapsulate the objective function and cache array with closures; 2. Use serialize to generate parameter unique keys; 3. Check whether the cache exists. If it does not exist, execute the function and store the result; 4. Return the cache value. Notes include handling non-serialization parameters, controlling memory usage and scope binding; optimization methods include using external cache systems such as Laravel's Cache Facade to achieve persistent storage.

It is not difficult to write a PHP function with cache function (that is, the commonly called memoization function). The key is to understand its core logic: record the input and output of the function, and return the result directly the next time you encounter the same input. Let’s take a look at how to implement it step by step.

What is Memoization?

Simply put, memoization is an optimization method used to avoid repeated calculations . For example, you have a time-consuming function, such as calculating a Fibonacci sequence or parsing a complex string. As long as the parameters are the same, the results will definitely be the same. At this time, you can use memoization to "remember" the previous results.

It is not a cache that caches the entire page or database query, but a small granular cache for a certain function call.

How to make a basic Memoization wrapper in PHP?

PHP does not have built-in memoization support, but you can wrap the objective function through closures or classes. Here we take the closure as an example:

 function memoize($func) {
    $cache = [];

    return function (...$args) use ($func, &$cache) {
        $key = serialize($args);

        if (!isset($cache[$key])) {
            $cache[$key] = $func(...$args);
        }

        return $cache[$key];
    };
}

Then you can use it like this:

 $fibonacci = function($n) use (&$fibonacci) {
    if ($n < 2) return $n;
    return $fibonacci($n - 1) $fibonacci($n - 2);
};

$memoizedFib = memoize($fibonacci);

echo $memoizedFib(10); // It&#39;s much faster

Note:

• Using serialize() to generate unique parameters is a common practice, but if the parameters contain objects, you have to deal with it yourself.
• If you are worried about key conflicts, you can also use md5(serialize($args)) to make a string key.
• Don't forget to pass in $func and reference $cache into the closure.

Possible problems and optimization suggestions

There may be several small pitfalls in actual use:

• Parameter type limitation : If there are types such as resources, objects, etc. in the parameters that cannot be serialized, an error will occur. The solution is to customize the key generation strategy, such as taking only certain fields or hashs.
• Memory usage issues : The cache is growing continuously may affect performance. You can add a maximum cache limit, and clear the earliest part after it exceeds it.
• Scope pollution : If you use recursive functions (like the Fibonacci above), be careful whether the scope binding of the closure is correct.

Common optimization methods include:

• Use weak reference arrays (such as WeakMap) to manage object parameter cache (PHP 8.0)
• Setting TTL (Expiration Time) mechanism
• Insert caches in external storage, such as APCu or Redis, suitable for multi-process sharing scenarios

Use more flexible ways in frameworks

If you are developing in a framework like Laravel or Symfony, you can directly use their cache systems to do something similar. For example, in Laravel, you can combine Cache Facade to do it:

 use Illuminate\Support\Facades\Cache;

function memoizedCall($key, $callback) {
    return Cache::remember($key, now()->addHour(), $callback);
}

// Use $result = memoizedCall("fib_10", function () {
    return fibonacci(10);
});

This not only implements memoization, but also automatically uses Redis or other drivers for persistent cache.

Basically that's it. Writing a simple memoization function is not too difficult, but to make it work stably in real projects, you have to pay attention to details such as parameter processing, cache cleaning, and cross-request sharing. But once you master it, it is a very practical performance optimization tool.

The above is the detailed content of How to write a memoization function (caching wrapper) in PHP?. For more information, please follow other related articles on the PHP Chinese website!