Performance Optimization

PHP Performance Optimization 🚀

The Racing Car Analogy

Imagine your PHP code is a racing car. It can be fast or slow depending on how well you tune it. Today, we’ll learn four magic tricks to make your car zoom like lightning:

1. OPcache - A super memory that remembers the road
2. Memory Management - Packing your car trunk smartly
3. Garbage Collection - Cleaning up trash from the back seat
4. Performance Tips - Secret racing techniques

🧠 OPcache: The Super Memory

What is OPcache?

Think of reading a recipe book. Every time you bake cookies, you:

1. Open the book
2. Read the recipe
3. Understand the steps
4. Then bake

That’s slow! What if you could remember the recipe forever after reading it once?

OPcache does exactly that for PHP!

PHP normally does this every time someone visits your website:

Read code → Parse it → Compile it → Run it

With OPcache:

First visit: Read → Parse → Compile → SAVE → Run
Next visits: Just run! (Super fast!)

How to Enable OPcache

In your php.ini file:

opcache.enable=1
opcache.memory_consumption=128
opcache.max_accelerated_files=10000
opcache.validate_timestamps=0

What these mean:

Real World Magic

Without OPcache:

“Hey server, read my code, understand it, then run it… for EVERY visitor!”

With OPcache:

“I already know this code by heart. Running now!”

Result: Your website can be 2-3 times faster!

📦 Memory Management: Smart Packing

What is Memory?

Memory is like a backpack your PHP script carries while running.

graph TD
    A["Start Script"] --> B["Pack Variables"]
    B --> C["Do Work"]
    C --> D["Unpack & Return"]
    D --> E["End Script"]

The Backpack Problem

Bad packing:

// Loading ENTIRE file into memory
$data = file_get_contents('huge_file.txt');
// Backpack is now SUPER heavy!

Smart packing:

// Read line by line
$handle = fopen('huge_file.txt', 'r');
while ($line = fgets($handle)) {
    // Process one line
    // Backpack stays light!
}
fclose($handle);

Memory Tricks

1. Unset when done:

$bigArray = [/* lots of data */];
// Use it...
unset($bigArray); // Empty the backpack!

2. Use generators for big lists:

// Bad: Creates ALL numbers at once
function getNumbers() {
    return range(1, 1000000);
}

// Good: Creates ONE at a time
function getNumbers() {
    for ($i = 1; $i <= 1000000; $i++) {
        yield $i; // Like a magic dispenser!
    }
}

3. Check memory usage:

echo memory_get_usage();      // Current
echo memory_get_peak_usage(); // Maximum

🗑️ Garbage Collection: The Cleanup Crew

What is Garbage?

When you stop using something, it becomes “garbage”:

$toy = "Ball";    // Ball is being used
$toy = "Car";     // Ball is now garbage!
                  // Nobody can reach it anymore

How PHP Cleans Up

PHP has a cleanup crew that removes garbage automatically!

graph TD
    A["Create Variable"] --> B["Use It"]
    B --> C{Still Needed?}
    C -->|Yes| B
    C -->|No| D["Mark as Garbage"]
    D --> E["Cleanup Crew Collects"]
    E --> F["Memory is Free!"]

The Tricky Circle Problem

Sometimes garbage forms a circle:

class Node {
    public $friend;
}

$a = new Node();
$b = new Node();
$a->friend = $b;  // A points to B
$b->friend = $a;  // B points to A

unset($a, $b);    // Both are garbage
                  // But they hold each other!

PHP’s cycle collector finds these circles and cleans them too!

Control the Cleanup

// Force cleanup NOW
gc_collect_cycles();

// Check garbage stats
$info = gc_status();
echo "Runs: " . $info['runs'];
echo "Collected: " . $info['collected'];

// Turn off (rare, for speed)
gc_disable();

// Turn back on
gc_enable();

⚡ PHP Performance Tips: Racing Secrets

Tip 1: Use the Right Quotes

// Slow: PHP looks for variables
$msg = "Hello World";

// Faster: No variable check
$msg = 'Hello World';

// When you NEED variables:
$name = 'Alice';
$msg = "Hello $name";  // Use double

Tip 2: === is Faster Than ==

// Slow: Converts types to compare
if ($count == "5") { }

// Fast: Direct comparison
if ($count === 5) { }

Tip 3: Pre-calculate Loop Limits

// Slow: Counts every loop!
for ($i = 0; $i < count($arr); $i++) { }

// Fast: Count once
$len = count($arr);
for ($i = 0; $i < $len; $i++) { }

Tip 4: Use Built-in Functions

// Slow: Manual loop
$found = false;
foreach ($arr as $item) {
    if ($item === 'needle') {
        $found = true;
        break;
    }
}

// Fast: Built-in function
$found = in_array('needle', $arr, true);

Tip 5: Cache Database Results

// Slow: Query every time
function getUser($id) {
    return $db->query("SELECT...");
}

// Fast: Remember the answer
$cache = [];
function getUser($id) {
    global $cache;
    if (!isset($cache[$id])) {
        $cache[$id] = $db->query("SELECT...");
    }
    return $cache[$id];
}

Tip 6: Use Static for Reused Values

function getConfig() {
    static $config = null;
    if ($config === null) {
        $config = parse_ini_file('config.ini');
    }
    return $config;
}
// Reads file only ONCE, no matter how
// many times you call the function!

🎯 Quick Summary

🏁 Your Racing Car is Ready!

Now you know:

1. OPcache = Your car remembers every road
2. Memory = Pack light, travel far
3. Garbage Collection = Auto-clean passengers
4. Tips = Drive like a pro

Your PHP is no longer a slow bicycle. It’s a rocket ship! 🚀

Remember: Fast code = Happy users = Successful apps!