Hi,
I’ve noticed a performance issue when getting a value of a repeater field or a gallery field (generally speaking: a field that returns a large array of data).
Example:
if (get_field('gallery')) {
foreach (get_field('gallery') as $image) {
// Do something;
}
}
The reason is simple: get_field('gallery') runs twice.
There’s a simple workaround:
$gallery = get_field('gallery');
if ($gallery) {
foreach ($gallery as $image) {
// Do something;
}
}
But I don’t like this solution because it requires a global variable. Global variables are considered as a bad practice and I try to avoid them in my templates.
here’s a simple test I run. A single call to get_field('gallery') field containing about 300 images.
$start = microtime(true);
get_field('gallery');
$end = microtime(true);
var_dump($end - $start);
Ther result was ~3.22s
I’ve increased the number of calls to get_field('gallery'):
$start = microtime(true);
get_field('gallery');
get_field('gallery');
$end = microtime(true);
var_dump($end - $start);
Ther result was ~6.44s
I also tried with more calls to get_field('gallery'). Each call to get_field('gallery') function multiplied the end result by ~2. So when there were 4 calls the result was 12.8s.
So I came up with an idea to cache the values returned by the get_field() function. The caching class is very simple. I’ve assumed that the result of get_field() function call is determined only by the arguments passed to the get_fiedl() function. So if the arguments are the same the result will be the same as well.
Here’s the implementation of the Cache() class. It’s a singleton, because I need only one instance of this class.
class Cache
{
private static $instance;
private $cachedFields = [];
private function __construct()
{
}
private function __clone()
{
}
public static function getInstance()
{
if (self::$instance === null) {
self::$instance = new Cache();
}
return self::$instance;
}
public function get($serializedArguments)
{
return $this->cachedFields[$serializedArguments];
}
public function exists($serializedArguments)
{
if (!array_key_exists($serializedArguments, $this->cachedFields)) {
return false;
}
return true;
}
public function add($serializedArguments, $fieldValue)
{
$this->cachedFields[$serializedArguments] = $fieldValue;
}
}
and here’s the implementation of the get_cached_field() function:
function get_cached_field($fieldName, $postId = false, $formatValue = true)
{
// Get an instance of Cache class.
$cache = Cache::getInstance();
// Get valid post ID using acf core function
$validPostId = acf_get_valid_post_id($postId);
// Serialize function arguments. I can't simply 'use serialize(func_get_args())' because of $postId which if not passed as an argument defaults to current $post->ID
$serializedArguments = serialize([$fieldName, $validPostId, $formatValue]);
// Check if the value is already cached and return the cached value if the condition is evaluates to <code>true</code>
if ($cache->exists($serializedArguments)) {
return $cache->get($serializedArguments);
}
// Otherwise use get_field() function to retrieve the vale
$fieldValue = get_field($fieldName, $validPostId, $formatValue);
// Save the value to cache
$cache->add($serializedArguments, $fieldValue);
// And return the value
return $fieldValue;
}
And the benchmark:
$start = microtime(true);
get_cached_field('gallery');
get_cached_field('gallery');
$end = microtime(true);
var_dump($end - $start);
Ther result was ~3.22s
I tried to add more calls to get_cached_field('gallery');. The result was pretty much the same. No matter how many calls there were. For example, when I increased the number of calls to 25 the result was 3.3s.
I think this kind of optimization could make into ACF core. I can’t see any side effects (correct me if I’m wrong). Of course, I don’t suggest adding a new function, I’d like it to be implemented in the get_field() function.
PS
I didn’t implement it for the get_sub_field() function yet, but it shouldn’t be complicated either.
