Performance Optimization ⚡

<?php
// Rule #1 of performance: MEASURE before you change anything.
// microtime(true) gives the current time in seconds as a float.
// Subtract two readings to get how long a block took.

$start = microtime(true);                 // stopwatch START

$total = 0;
for ($i = 1; $i <= 1_000_000; $i++) {     // do some real work
    $total += $i;
}

$elapsedMs = (microtime(true) - $start) * 1000;   // seconds -> milliseconds

echo "Result: " . number_format($total) . "\n";
printf("Took: %.2f ms\n", $elapsedMs);            // %.2f = 2 decimal places

// memory_get_peak_usage(true) = the most RAM this script ever held.
$peakMb = memory_get_peak_usage(true) / 1048576;  // bytes -> MB (1024*1024)
printf("Peak memory: %.2f MB\n", $peakMb);
?>

Result: 500,000,500,000
Took: 14.30 ms
Peak memory: 2.00 MB

<?php
// ❌ BEFORE: count($items) runs on EVERY pass of the loop, and the
// "Item " text is rebuilt from scratch each time. Tiny here, but this
// exact pattern melts servers when the loop body does real work.

$items = range(1, 5);

$start = microtime(true);
for ($i = 0; $i < count($items); $i++) {        // count() called every loop!
    echo "Item " . ($i + 1) . " of " . count($items) . "\n"; // again!
}
printf("Time: %.4f ms\n", (microtime(true) - $start) * 1000);
?>

Item 1 of 5
Item 2 of 5
Item 3 of 5
Item 4 of 5
Item 5 of 5
Time: 0.0480 ms

<?php
// ✅ AFTER: hoist the invariant out of the loop. count() runs ONCE.
// Anything whose answer can't change inside the loop belongs ABOVE it.

$items = range(1, 5);

$start = microtime(true);
$n = count($items);                 // compute once, reuse $n
for ($i = 0; $i < $n; $i++) {       // condition is now a cheap variable read
    echo "Item " . ($i + 1) . " of " . $n . "\n";
}
printf("Time: %.4f ms\n", (microtime(true) - $start) * 1000);
?>

Item 1 of 5
Item 2 of 5
Item 3 of 5
Item 4 of 5
Item 5 of 5
Time: 0.0210 ms

<?php
// ❌ BEFORE: the N+1 query problem.
// 1 query to fetch users, then 1 MORE query PER user to fetch their orders.
// 100 users => 1 + 100 = 101 round-trips to the database. Pages crawl.

$users = $db->query("SELECT id, name FROM users");      // query #1

foreach ($users as $user) {
    // ⚠️ a NEW query every single loop -> this is the N+1
    $orders = $db->query(
        "SELECT * FROM orders WHERE user_id = " . $user["id"]
    );
    echo $user["name"] . ": " . count($orders) . " orders\n";
}

// Total queries for 100 users: 101  (1 + N)

<?php
// ✅ AFTER: eager-load everything in ONE extra query, then group in PHP.
// 100 users => just 2 queries total, no matter how many users there are.

$users = $db->query("SELECT id, name FROM users");      // query #1

$ids = array_column($users, "id");                      // [1, 2, 3, ...]
$in  = implode(",", array_map("intval", $ids));         // "1,2,3,..." (safe ints)

// query #2: every matching order in a single round-trip
$rows = $db->query("SELECT user_id, id FROM orders WHERE user_id IN ($in)");

// Bucket the orders by user_id so lookups are instant (no more queries).
$byUser = [];
foreach ($rows as $row) {
    $byUser[$row["user_id"]][] = $row;
}

foreach ($users as $user) {
    $count = count($byUser[$user["id"]] ?? []);         // array lookup, not a query
    echo $user["name"] . ": " . $count . " orders\n";
}

// Total queries: 2  (1 + 1) — and an INDEX on orders.user_id makes #2 instant.

<?php
// Caching = compute the slow thing ONCE, reuse the answer.
// APCu (in-process, per-server) is the simplest cache; Redis works the
// same way but is shared across servers. The pattern is identical:
//   1) try the cache  2) on a miss, compute + store  3) return.

function expensiveReport(): array {
    usleep(200000);                       // pretend this takes 200 ms (a real DB report)
    return ["sales" => 4200, "orders" => 87];
}

function getReport(): array {
    $key = "daily_report";

    // 1) Try the cache. apcu_fetch sets $hit = true on a hit.
    $cached = apcu_fetch($key, $hit);
    if ($hit) {
        return $cached;                   // FAST path — no work done
    }

    // 2) Cache miss: do the slow work, then store it for 300 seconds.
    $report = expensiveReport();
    apcu_store($key, $report, 300);       // TTL = time-to-live in seconds
    return $report;
}

$first  = getReport();   // miss -> ~200 ms (computes and stores)
$second = getReport();   // hit  -> ~0 ms   (served from memory)

echo "Sales: " . $first["sales"] . ", Orders: " . $first["orders"] . "\n";
echo "Second call served from cache (no recompute).\n";
?>

Sales: 4200, Orders: 87
Second call served from cache (no recompute).

<?php
// Streaming with a generator (yield) keeps memory FLAT no matter the size.
// An array of 1,000,000 ints needs ~30+ MB at once. A generator hands you
// one value at a time, so peak memory barely moves.

function readNumbers(int $count): Generator {
    for ($i = 1; $i <= $count; $i++) {
        yield $i;                    // produced lazily, one at a time
    }
}

$total = 0;
foreach (readNumbers(1_000_000) as $n) {   // never builds the full array
    $total += $n;
}

echo "Sum of 1..1,000,000 = " . number_format($total) . "\n";
printf("Peak memory: %.2f MB\n", memory_get_peak_usage(true) / 1048576);
echo "(A real array of 1M ints would use ~30+ MB; the generator stays tiny.)\n";
?>

Sum of 1..1,000,000 = 500,000,500,000
Peak memory: 2.00 MB
(A real array of 1M ints would use ~30+ MB; the generator stays tiny.)

<?php
// OPcache stores COMPILED bytecode in shared memory, so PHP skips the
// parse-and-compile step on every request (commonly 30-70% faster).
// opcache_get_status() lets you see how well it's working.

if (!function_exists("opcache_get_status")) {
    exit("OPcache is not enabled in this PHP build.\n");
}

$status = opcache_get_status(false);
if ($status === false || empty($status["opcache_enabled"])) {
    exit("OPcache is installed but disabled (set opcache.enable=1).\n");
}

$stat = $status["opcache_statistics"];
printf("Cached scripts: %d\n", $stat["num_cached_scripts"]);
printf("Hit rate:       %.2f%%\n", $stat["opcache_hit_rate"]); // higher = better
printf("Cache hits:     %s\n", number_format($stat["hits"]));
printf("Cache misses:   %s\n", number_format($stat["misses"]));

/*
  Recommended php.ini for PRODUCTION:

  opcache.enable=1
  opcache.memory_consumption=128       ; MB of shared memory for opcodes
  opcache.max_accelerated_files=10000  ; raise above your file count
  opcache.validate_timestamps=0        ; 0 in prod: never stat() files per request
                                       ; (clear the cache on each deploy instead)
  opcache.jit_buffer_size=64M          ; JIT cache (PHP 8+)
  opcache.jit=tracing                  ; enable the tracing JIT for CPU-heavy code
*/

<?php
// 🎯 YOUR TURN — time a block of code. Fill in each ___ , then run it.
// You only need TWO microtime(true) readings: one before, one after.

$start = ___;                          // 👉 take the START reading: microtime(true)

$sum = 0;
for ($i = 1; $i <= 500_000; $i++) {    // the work we're timing
    $sum += $i;
}

$elapsedMs = (___ - $start) * 1000;    // 👉 take the END reading, then subtract $start

echo "Sum: " . number_format($sum) . "\n";
printf("Took: %.2f ms\n", $elapsedMs);

// ✅ Expected output (numbers vary per machine):
//    Sum: 125,000,250,000
//    Took: 7.10 ms
?>

Sum: 125,000,250,000
Took: 7.10 ms

<?php
// 🎯 YOUR TURN — kill the N+1 by hoisting work out of the loop.
// count($prices) is being recomputed on every pass. Move it ABOVE the loop
// into $n, then use $n in the condition so it's only computed once.

$prices = [10, 20, 30, 40];

___                                    // 👉 add a line:  $n = count($prices);
for ($i = 0; $i < ___; $i++) {         // 👉 use your $n here instead of count(...)
    echo "Price #" . ($i + 1) . ": $" . $prices[$i] . "\n";
}

// ✅ Expected output:
//    Price #1: $10
//    Price #2: $20
//    Price #3: $30
//    Price #4: $40
?>

Price #1: $10
Price #2: $20
Price #3: $30
Price #4: $40