Optimierung und Performance in PHP

Erste Schritte – Optimierung und Performance in PHP: Caching, Code‑Feinschliff

Eine Web‑App fühlt sich erst rund an, wenn sie auch unter Last flüssig läuft.
Die wichtigsten Stellschrauben: Caching (Ergebnisse zwischenspeichern)
und Code‑Optimierung (Bottlenecks eliminieren).
Im Folgenden erfährst du praxisnah, worauf du achten solltest.

1. OPcache – Bytecode‑Caching aktivieren

  • Ab PHP 5.5 integriert; speichert vorkompilierten Opcode im RAM.
  • Aktiviere in php.ini:
opcache.enable=1
opcache.memory_consumption=128    ; MB
opcache.max_accelerated_files=10000
opcache.validate_timestamps=1     ; dev=1, prod=0

Ergibt i. d. R. 30‑70 % weniger Exec‑Zeit für PHP Skripte.

2. HTTP‑Caching – Browser & Proxy Header

 <?php $expires = 60*60*24; // 1 Tag header("Cache-Control: public, max-age=$expires"); header("Expires: ".gmdate('D, d M Y H:i:s', time()+$expires).' GMT'); ?>

Für statische Assets zusätzlich Version‑Hash im Dateinamen (fingerprinting)
style.4a1f.css → Cache‑Busting bei Deploy.

3. Seiten‑Cache / Fragment‑Cache

3.1 Datei‑basiert (phpFK Cache‑Klasse)

$cached = \Core\Cache::get('home_html');
if ($cached) { echo $cached; exit; }

ob_start();            // Output‑Buffer
require 'views/home.php';
$html = ob_get_clean();

\Core\Cache::put('home_html', $html, 300); // 5 min
echo $html;

3.2 Redis / Memcached

$redis = new Redis();
$redis->connect('127.0.0.1');
$key = 'user:'.$id;

if (!$json = $redis->get($key)) {
    $json = json_encode(User::find($id));
    $redis->setex($key, 600, $json);
}
$user = json_decode($json);
  • Schneller als Festplatte, aber erfordert Dienst + PHP‑Ext.

4. Datenbank‑Optimierung

  • Indexes – WHERE‑ und JOIN‑Spalten indexieren.
  • LIMIT + OFFSET statt ganze Tabellen laden.
  • Verwende EXPLAIN SELECT … – prüfe mögliche Full Table Scan.
  • Nutze prepared statements, damit Query‑Plan gecached bleibt.

5. Autoload & Composer‑Feinschliff

composer install --optimize-autoloader --no-dev
composer dump-autoload -o          ; Klassenmap statt PSR‑4 Scans

6. Code‑Level Optimierung

  • Kritische Schleifen – unnötige Funktionsaufrufe herausziehen:
/* schlecht */
for ($i = 0; $i < count($arr); $i++) { … }

/* besser */
$len = count($arr);
for ($i = 0; $i < $len; $i++) { … }
  • Sammel‑SQL statt N+1 Queries:
-- schlecht : 100 SELECTs nacheinander
SELECT * FROM tasks WHERE id = ?;

-- gut
SELECT * FROM tasks WHERE id IN (1,2,3,…);

7. GZIP / Brotli – HTTP‑Kompression

Aktiviere in .htaccess (Apache):

<IfModule mod_deflate.c>
  AddOutputFilterByType DEFLATE text/html text/css application/javascript
</IfModule>

8. Assets minifizieren & zusammenfassen

  • Für kleine Projekte → Online‑Tools oder Esbuild: 
    npx esbuild app.js --minify
  • Reduziert Requests & Dateigröße.

9. Monitoring & Profiling

  • Laravel Telescope, Symfony Profiler oder xhprof.
  • Schnelles Timing –  
    microtime(true)

    um kritische Blöcke setzen.

10. Zusammenfassung (80/20‑Regel)

  1. OPcache einschalten – Gratis‑Turbo.
  2. HTTP‑/Browser‑Caching + GZIP für Assets.
  3. Datenbank: Indexe & Bulk‑Queries.
  4. Seiten‑/Fragment‑Cache per Redis oder Datei.
  5. Autoloader optimieren +  
    composer install --no-dev

    für Produktion.

Fazit

Performance entsteht aus vielen kleinen Stellschrauben:
Aktiviere zuerst systemweite Features (OPcache, GZIP),
eliminiere anschließend DB‑Nadelöhre, feile dann am Code.
Mit Caching auf mehreren Ebenen erzielst du das beste Verhältnis aus Geschwindigkeit,
Server‑Last und Entwicklungsaufwand.