PHP performance optimalisatie: 10 bewezen technieken

Een trage PHP-applicatie kost je bezoekers, conversies en Google-rankings. Gelukkig is PHP performance optimalisatie geen black magic: met de juiste technieken haal je binnen een middag grote snelheidswinst binnen.

In deze handleiding loop je door tien bewezen optimalisatietechnieken, van OPcache tot database tuning en profiling. Je bouwt voort op kennis uit eerdere artikelen in onze PHP Development serie, dus zorg dat je de basis van PHP en databases met PDO al onder de knie hebt.

Waarom performance optimalisatie belangrijk is

Elke 100ms extra laadtijd kan je conversie met enkele procenten laten dalen. Voor zoekmachines zoals Google is page speed bovendien een rankingfactor via de Core Web Vitals.

Voor PHP betekent dit: snellere responstijden, lager serververbruik en blije gebruikers. En het beste nieuws? Veel optimalisaties kosten nauwelijks tijd.

1. Zet OPcache aan

OPcache is verreweg de grootste quick win. Zonder OPcache parst en compileert PHP bij élke request je scripts opnieuw naar bytecode. Met OPcache gebeurt dat één keer, waarna de bytecode in het geheugen blijft.

Check je php.ini:

opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=20000
opcache.validate_timestamps=1
opcache.revalidate_freq=2

In productie kun je validate_timestamps=0 zetten voor nog meer snelheid, maar vergeet dan niet OPcache handmatig te legen bij een deploy.

2. Gebruik de nieuwste PHP-versie

Elke nieuwe PHP-versie brengt performancewinst. PHP 8.3 is afhankelijk van je workload 20-40% sneller dan PHP 7.4, puur door interne optimalisaties en de JIT-compiler.

Upgraden is gratis snelheid. Controleer wel je dependencies en draai je testsuite voor je live gaat.

Activeer ook JIT als je CPU-intensieve taken draait:

opcache.jit_buffer_size=100M
opcache.jit=tracing

3. Schakel autoloading slim in

Composer's autoloader laadt classes pas wanneer ze nodig zijn. In productie moet je altijd de geoptimaliseerde autoloader gebruiken:

composer install --no-dev --optimize-autoloader --classmap-authoritative

Dit genereert een statische classmap en voorkomt tragere filesystem-lookups. Meer over dependency management lees je in Composer en dependency management in PHP uitgelegd.

4. Cache zware berekeningen

Niet elke operatie hoeft bij elke request opnieuw. Database queries, API-calls en zware berekeningen kun je cachen in Redis of Memcached.

function getPopularProducts(Redis $redis, PDO $db): array
{
    $cacheKey = 'popular_products_v1';
    $cached = $redis->get($cacheKey);

    if ($cached !== false) {
        return json_decode($cached, true);
    }

    $stmt = $db->query(
        'SELECT id, name FROM products
         ORDER BY sales DESC LIMIT 10'
    );
    $products = $stmt->fetchAll(PDO::FETCH_ASSOC);

    $redis->setex($cacheKey, 300, json_encode($products));
    return $products;
}

Bedenk vooraf een cache-invalidatiestrategie. Verouderde cache veroorzaakt subtiele bugs die lastig te debuggen zijn.

5. Optimaliseer je database queries

Je applicatie is zo snel als je traagste query. Zet de slow query log aan in MySQL en analyseer queries die langer dan 1 seconde duren.

Een paar vuistregels:

• Gebruik indexes op kolommen waarop je filtert of joint
• Vermijd SELECT *, haal alleen de kolommen op die je echt nodig hebt
• Fix N+1 queries met joins of eager loading
• Gebruik EXPLAIN om het queryplan te begrijpen

Een klassiek N+1 probleem:

// Fout: 1 + N queries
$users = $db->query('SELECT * FROM users')->fetchAll();
foreach ($users as $user) {
    $orders = $db->query(
        "SELECT * FROM orders WHERE user_id = {$user['id']}"
    )->fetchAll();
}

// Goed: 1 query met JOIN
$stmt = $db->query(
    'SELECT u.id, u.name, o.total
     FROM users u
     LEFT JOIN orders o ON o.user_id = u.id'
);

6. Profile je code voor je optimaliseert

Optimaliseer nooit op gevoel. Gebruik een profiler om te zien waar de echte bottleneck zit.

Populaire tools:

• Xdebug, gratis, lokaal, met cachegrind-output
• Blackfire, commercieel, uitstekende UI
• Tideways, productie-gerichte APM voor PHP

Een snelle manier om zelf tijd te meten:

$start = hrtime(true);
heavyFunction();
$elapsedMs = (hrtime(true) - $start) / 1_000_000;
error_log("heavyFunction: {$elapsedMs}ms");

7. Gebruik efficiënte datastructuren

PHP-arrays zijn flexibel maar niet altijd optimaal. Voor grote datasets kunnen alternatieven sneller en zuiniger zijn:

• SplFixedArray voor arrays met een vaste grootte
• Generator voor grote datasets die je stream-gewijs verwerkt
• WeakMap voor caches met zwakke references

Generators zijn vooral handig bij grote bestanden:

function readLines(string $file): Generator
{
    $handle = fopen($file, 'r');
    try {
        while (($line = fgets($handle)) !== false) {
            yield trim($line);
        }
    } finally {
        fclose($handle);
    }
}

foreach (readLines('huge.csv') as $line) {
    processLine($line);
}

Dit leest regel voor regel zonder het hele bestand in het geheugen te laden. Meer over arrays en loops in PHP vind je in ons eerdere artikel.

8. Offload zware taken naar een queue

Laat HTTP-requests geen dingen doen die niet direct nodig zijn. E-mails versturen, PDFs genereren of webhooks afvuren kun je beter in de achtergrond doen.

Gebruik een queue zoals Redis, RabbitMQ of Laravel's queue systeem. Je response is dan direct klaar en de gebruiker wacht niet onnodig.

$queue->push(new SendWelcomeEmailJob($user->id));
return new JsonResponse(['ok' => true]);

9. Optimaliseer sessions en cookies

Standaard slaat PHP sessions op in bestanden. Bij hoog verkeer wordt dat een bottleneck door filesystem-locks.

Zet je sessions in Redis of een ander memory-gebaseerd backend. In combinatie met sessions en authentication in PHP geeft dit flink betere schaalbaarheid.

session.save_handler=redis
session.save_path="tcp://127.0.0.1:6379"

Zet daarnaast session_write_close() aan zodra je niets meer naar de sessie hoeft te schrijven. Dit voorkomt dat andere requests van dezelfde gebruiker moeten wachten.

10. Gebruik HTTP-caching slim

Niet elke request hoeft PHP te bereiken. Met de juiste headers laat je de browser en tussenliggende proxies het werk doen:

header('Cache-Control: public, max-age=3600');
header('ETag: "' . md5($content) . '"');

Voor API's die data teruggeven kun je met Last-Modified en If-Modified-Since headers een lichte 304-response terugsturen in plaats van de volledige payload.

Meer over API's lees je in API bouwen in PHP.

Samengevat: jouw performance checklist

Begin altijd met meten voor je optimaliseert. Pak dan de grootste winst eerst:

1. OPcache aan en PHP upgraden naar 8.3+
2. Database queries en indexes nakijken
3. Caching toevoegen op zware operaties
4. N+1 problemen fixen
5. Zware taken naar een queue verplaatsen

Performance optimalisatie is geen eenmalige klus. Monitor continu, profile bij rare spikes, en itereer. Je gebruikers, en je serverrekening, zullen je dankbaar zijn.

Veelgestelde vragen

Wat is de belangrijkste PHP performance optimalisatie?

OPcache inschakelen is de snelste winst. Het compileert PHP-scripts naar bytecode en slaat die op in het geheugen, wat de uitvoertijd tot wel 3x kan verlagen zonder codewijzigingen.

Hoe meet ik PHP performance?

Gebruik profilers zoals Xdebug, Blackfire of Tideways om te zien welke functies en queries traag zijn. Combineer dit met tools als New Relic voor monitoring in productie.

Welke PHP-versie is het snelst?

PHP 8.3 en hoger zijn aanzienlijk sneller dan PHP 7 door de JIT-compiler en diverse optimalisaties. Een upgrade kan 20-40% snelheidswinst opleveren zonder codewijzigingen.

Is caching altijd een goed idee?

Caching versnelt je applicatie flink, maar vereist een doordachte invalidatiestrategie. Verouderde cache kan tot bugs en datainconsistentie leiden, dus plan cache-keys en TTL zorgvuldig.

Hoe voorkom ik N+1 query problemen?

Gebruik eager loading of JOINs om gerelateerde data in één query op te halen in plaats van in een loop. Frameworks zoals Laravel bieden hiervoor handige tools zoals with().