Caching Techniques ⚡

<?php
// CACHE-ASIDE: the app checks the cache first; only a MISS hits the database.
//   1. look in the cache  ->  HIT  = return the cached value (fast)
//                              MISS = run the slow query, then STORE it
// Here a plain array stands in for a real cache so you can run it anywhere.

$cache = [];                       // our pretend cache (key => value)
$dbCalls = 0;                      // count how often we hit the "database"

function getUser(array &$cache, int &$dbCalls, int $id): string {
    $key = "user:$id";             // a unique key per user

    if (isset($cache[$key])) {     // 1) check the cache
        echo "HIT  $key\n";        //    found it — no database needed
        return $cache[$key];
    }

    echo "MISS $key\n";            // 2) not cached: do the expensive work
    $dbCalls++;
    $name = "User #$id";           //    pretend this came from the database
    $cache[$key] = $name;          // 3) store it so next time is a HIT
    return $name;
}

getUser($cache, $dbCalls, 1);      // MISS — first time we see user 1
getUser($cache, $dbCalls, 1);      // HIT  — served from the cache
getUser($cache, $dbCalls, 2);      // MISS — new user
getUser($cache, $dbCalls, 1);      // HIT  — still cached

echo "Database calls: $dbCalls\n"; // only 2 queries for 4 requests

MISS user:1
HIT  user:1
MISS user:2
HIT  user:1
Database calls: 2

<?php
// FILE CACHE with a TTL (time-to-live). Each value is saved to a file that
// expires after N seconds, so stale data can't live forever.

function cacheGet(string $key, int $ttl, callable $compute): mixed {
    $file = sys_get_temp_dir() . "/cache_" . md5($key) . ".json";

    // Serve from file if it exists AND is younger than the TTL.
    if (file_exists($file) && (time() - filemtime($file)) < $ttl) {
        echo "HIT  $key\n";
        return json_decode(file_get_contents($file), true);
    }

    echo "MISS $key (computing)\n";
    $value = $compute();                       // run the expensive work
    file_put_contents($file, json_encode($value));  // write it to disk
    return $value;
}

// A "slow" task: pretend this query takes 200ms.
$slowQuery = fn() => ['total' => 42, 'at' => date('H:i:s')];

$a = cacheGet("report:daily", 60, $slowQuery);  // MISS — runs the query
$b = cacheGet("report:daily", 60, $slowQuery);  // HIT  — same file, no recompute

echo "Total: {$a['total']}\n";
echo "Same data reused: " . ($a === $b ? "yes" : "no") . "\n";

MISS report:daily (computing)
HIT  report:daily
Total: 42
Same data reused: yes

<?php
// APCu: a fast in-memory cache built into PHP (enable the apcu extension).
// Data lives in the server's RAM, so reads are microseconds — but it is
// per-server (each web server has its own) and is wiped on restart.

function fib(int $n): int {                 // a deliberately slow function
    return $n < 2 ? $n : fib($n - 1) + fib($n - 2);
}

$key = 'fib:30';

// apcu_fetch sets $found by reference: true on a HIT, false on a MISS.
$value = apcu_fetch($key, $found);

if ($found) {
    echo "HIT  $key = $value\n";
} else {
    echo "MISS $key (computing)\n";
    $value = fib(30);                       // the expensive calculation
    apcu_store($key, $value, 300);          // cache it for 300 seconds (TTL)
}

echo "Result: $value\n";

MISS fib:30 (computing)
Result: 832040

<?php
// REDIS / MEMCACHED: an in-memory store that runs as its OWN service, so it
// is SHARED by every web server (unlike APCu). Perfect once you scale past
// one machine. Install a client first:  composer require predis/predis

$redis = new Predis\Client('tcp://127.0.0.1:6379');

function getTopProducts(Predis\Client $redis): array {
    $key = 'products:top';

    $cached = $redis->get($key);            // returns null on a MISS
    if ($cached !== null) {
        echo "Redis HIT\n";
        return json_decode($cached, true);  // Redis stores strings -> decode
    }

    echo "Redis MISS — running slow query\n";
    $products = [['id' => 1, 'name' => 'Widget'], ['id' => 2, 'name' => 'Gadget']];

    // setex = SET with EXpiry: store as JSON with a 300-second TTL.
    $redis->setex($key, 300, json_encode($products));
    return $products;
}

getTopProducts($redis);                     // MISS — fills the cache
$top = getTopProducts($redis);              // HIT  — served from Redis

// INVALIDATION: when products change, delete the key so the next read recomputes.
$redis->del('products:top');
echo "First product: {$top[0]['name']}\n";

; In php.ini (production settings) — no application code required:

opcache.enable=1                 ; turn OPcache on
opcache.memory_consumption=128   ; 128 MB for compiled bytecode
opcache.max_accelerated_files=10000  ; cache up to 10k files
opcache.validate_timestamps=0    ; stop re-checking files for changes (prod)

; With validate_timestamps=0, PHP won't notice edited files —
; so reload PHP-FPM after every deploy:  systemctl reload php8.3-fpm

<?php
// 🎯 YOUR TURN — finish the cache-aside lookup, then run it.
// Fill each ___ using the 👉 hint. The pattern is always: check, miss, store.

$cache = [];

function getPrice(array &$cache, string $sku): int {
    $key = "price:$sku";

    if (isset($cache[$key])) {        // 1) check the cache
        echo "HIT  $key\n";
        return ___;                   // 👉 return the cached value: $cache[$key]
    }

    echo "MISS $key\n";              // 2) not cached — do the work
    $price = strlen($sku) * 10;       //    pretend this came from the database
    $cache[___] = $price;             // 👉 store it under the key: $key
    return $price;
}

getPrice($cache, "ABC");              // MISS
getPrice($cache, "ABC");              // HIT  — second call is cached

// ✅ Expected output:
//    MISS price:ABC
//    HIT  price:ABC
?>

MISS price:ABC
HIT  price:ABC

<?php
// 🎯 YOUR TURN — give the cache a TTL so old data expires.
// An entry is fresh only while  (now - storedAt) < ttl.

$cache = ['weather' => ['value' => 'sunny', 'storedAt' => time() - 90]];
$ttl = 60;                            // entries live for 60 seconds

$entry = $cache['weather'];
$age   = time() - $entry['storedAt']; // how old the entry is, in seconds

if ($age < ___) {                     // 👉 compare against the TTL: $ttl
    echo "FRESH: {$entry['value']}\n";
} else {
    echo "STALE: re-fetch needed (age {$age}s)\n";
}

// ✅ Expected output (the entry is 90s old, TTL is 60s):
//    STALE: re-fetch needed (age 90s)
?>

STALE: re-fetch needed (age 90s)