PEST ist ein moderner Testing-Framework für PHP, das vor allem durch seine lesbare Syntax, Expressivität und enge Integration mit PHPUnit besticht.

📌 PEST = "PHP Testing for Humans"
Es richtet sich an Entwickler, die saubere, lesbare und schnelle Tests schreiben wollen – ohne viel Boilerplate.

🚀 Warum PEST statt PHPUnit?

PEST basiert auf PHPUnit, aber es:

• bietet eine minimalistische, expressive Syntax

• entfernt unnötigen Overhead

• unterstützt funktionalen, verhaltensbasierten Teststil

• lässt sich optional mit einer klassischen PHPUnit-Struktur kombinieren

🔍 Beispiel – PHPUnit vs. PEST

PHPUnit:

class UserTest extends TestCase
{
    public function test_user_has_name()
    {
        $user = new User('John');
        $this->assertEquals('John', $user->name);
    }
}

PEST:

it('has a name', function () {
    $user = new User('John');
    expect($user->name)->toBe('John');
});

👉 Deutlich kürzer, besser lesbar – besonders bei vielen Tests.

🧩 Features von PEST

• ✅ Elegante Syntax (ähnlich wie Jest oder Mocha in JavaScript)

• 🧪 Unterstützt unit, feature, API, browser-based Tests

• 🧱 Datengetriebene Tests (with([...]))

• 🧬 Test-Hooks wie beforeEach() / afterEach()

• 🎨 Erweiterbar über Plugins & eigene Expectations

• 🔄 Kompatibel mit PHPUnit (du kannst PHPUnit-Tests weiter nutzen)

🛠️ Installation

In einem Laravel- oder Composer-Projekt:

composer require pestphp/pest --dev
php artisan pest:install  # (für Laravel-Projekte)

Dann kannst du direkt loslegen:

./vendor/bin/pest

🧠 Fazit

PEST ist ideal, wenn du:

• Tests schreiben willst, die Spaß machen

• sauberen, modernen Code bevorzugst

• bereits PHPUnit nutzt, aber Lust auf mehr Expressivität hast

💡 Viele moderne Laravel-Entwickler steigen auf PEST um, weil es sich perfekt in Laravel-Apps integriert und das Testen „menschlich“ macht – wie der Slogan schon sagt.

OPcache ist eine in PHP integrierte Bytecode-Caching-Erweiterung, die die Leistung von PHP-Anwendungen deutlich verbessert, indem sie den PHP-Code vorkompiliert und im Arbeitsspeicher (RAM) speichert.

⚙️ Wie funktioniert OPcache?

Normalerweise passiert bei jedem PHP-Aufruf:

1. PHP liest den Quellcode (*.php-Datei)

2. Der Code wird geparst und in Bytecode umgewandelt

3. Der Bytecode wird vom PHP-Interpreter ausgeführt

Mit OPcache passiert dieser Vorgang nur einmal. Danach wird der bereits kompilierte Bytecode aus dem Speicher genommen und direkt ausgeführt.

🚀 Vorteile von OPcache

php -i | grep opcache.enable

Oder im Code:

phpinfo();

📦 Typische Konfiguration (php.ini)

opcache.enable=1
opcache.memory_consumption=128
opcache.interned_strings_buffer=8
opcache.max_accelerated_files=10000
opcache.validate_timestamps=1
opcache.revalidate_freq=2

💡 In Produktionsumgebungen wird oft opcache.validate_timestamps=0 gesetzt – das bedeutet: PHP prüft nicht mehr bei jedem Request, ob sich Dateien geändert haben → noch mehr Performance, aber Änderungen erfordern dann z. B. einen Cache-Reset oder Neustart.

🧪 Wann bringt OPcache etwas?

OPcache bringt besonders viel bei:

• Laravel, Symfony, WordPress, Drupal, TYPO3

• vielen Requests pro Sekunde

• größeren Codebasen

🧼 Cache löschen (z. B. nach Code-Updates)

Du kannst OPcache z. B. in einem Deployment-Tool mit folgendem Befehl leeren:

opcache_reset();

Oder über die Kommandozeile:

php -r "opcache_reset();"

🧠 Fazit

OPcache ist ein einfacher, aber extrem effektiver Performance-Booster für jede PHP-Anwendung. Er sollte in jeder produktiven Umgebung aktiviert sein – es ist kostenlos, nativ in PHP enthalten und reduziert Ladezeiten sowie Serverlast drastisch.

Laravel Octane ist eine offizielle Erweiterung für das Laravel-Framework, die die Performance deiner Anwendung dramatisch verbessert, indem sie Laravel auf Hochleistungsservern wie Swoole oder RoadRunner ausführt.

⚡ Was macht Laravel Octane besonders?

Statt bei jeder HTTP-Anfrage den Laravel-Framework-Code neu zu laden (wie bei PHP-FPM üblich), hält Octane deine Anwendung permanent im Speicher. Das spart Bootstrapping-Zeit und macht deine App viel schneller.

🔧 Wie funktioniert das technisch?

Laravel Octane nutzt Worker-basierte Server (z. B. Swoole oder RoadRunner), die:

1. Die Laravel-Anwendung einmalig booten,

2. Dann Anfragen wiederholt und schnell verarbeiten, ohne das Framework neu zu starten.

🚀 Vorteile von Laravel Octane

RoadRunner ist ein High-Performance Application Server für PHP, der von Spiral Scout entwickelt wurde. Er ersetzt den klassischen PHP-FPM (FastCGI Process Manager) und bietet durch eine dauerhafte Ausführung deiner PHP-Anwendung einen massiven Performance-Schub – besonders bei Frameworks wie Laravel oder Symfony.

🚀 Was macht RoadRunner besonders?

✅ Performance durch Worker

• PHP-Skripte werden nicht bei jeder Anfrage neu geladen, sondern laufen dauerhaft in sogenannten Worker-Prozessen (ähnlich wie bei Node.js oder Swoole).

• Dadurch sparst du dir das erneute Bootstrapping deiner App bei jedem Request – das ist wesentlich schneller als bei PHP-FPM.

✅ In Go geschrieben

• RoadRunner selbst ist in der Programmiersprache Go geschrieben – das bedeutet hohe Stabilität, einfache Cross-Plattform-Deployments und parallele Verarbeitung von Anfragen.

✅ Features

• HTTP-Server (inkl. HTTPS, Gzip, CORS, etc.)

• PSR-7 & PSR-15 Middleware-Kompatibilität

• Unterstützung für:

  • Queues (z. B. mit RabbitMQ, Redis, etc.)

  • gRPC

  • WebSockets

  • Static file serving

  • Metrics (Prometheus)

  • RPC zwischen PHP und Go

• Hot Reload für Änderungen im Code (mit Watch-Modul)

⚙️ Wie funktioniert RoadRunner technisch?

1. RoadRunner startet PHP-Worker-Prozesse.

2. Die Worker laden einmal den gesamten Framework-Bootstrap.

3. RoadRunner verteilt HTTP- oder gRPC-Anfragen an die Worker.

4. Die Antwort wird über Go zurückgegeben – schnell und parallel.

📦 Typischer Einsatz:

• Laravel + RoadRunner (statt Laravel + PHP-FPM)

• Anwendungen mit hoher Request-Frequenz

• APIs, Microservices, Echtzeit-Anwendungen (z. B. mit WebSockets)

• Serverless-ähnliche Dienste, wo Latenz kritisch ist

📉 Vergleich zu PHP-FPM

PDO steht für PHP Data Objects und ist eine Datenbank-Abstraktionsschicht in PHP. Es handelt sich um eine objektorientierte Schnittstelle, mit der du auf verschiedene Datenbanken zugreifen kannst – z. B. MySQL, PostgreSQL, SQLite – ohne den Datenbankspezifischen Code stark ändern zu müssen.

Hauptmerkmale von PDO:

✅ Einheitliche API:
Egal ob MySQL, SQLite oder PostgreSQL – du benutzt denselben Code-Stil.

✅ Prepared Statements:
Sicherer Schutz vor SQL-Injektionen durch gebundene Parameter:

$stmt = $pdo->prepare("SELECT * FROM users WHERE id = :id");
$stmt->execute(['id' => $userId]);

✅ Transaktionen:
PDO unterstützt Transaktionen (wichtig z. B. bei Bankbuchungen).

✅ Fehlerbehandlung per Exception:

$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

✅ Flexibler Datenbankwechsel:
Möchtest du von MySQL auf PostgreSQL wechseln? Meist nur der DSN-String und Treiber müssen geändert werden.

$dsn = 'mysql:host=localhost;dbname=testdb;charset=utf8mb4';
$user = 'root';
$pass = '';

try {
    $pdo = new PDO($dsn, $user, $pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "Verbindung erfolgreich!";
} catch (PDOException $e) {
    echo "Verbindung fehlgeschlagen: " . $e->getMessage();
}

Fazit:

PDO ist der empfohlene Weg, um in modernen PHP-Anwendungen mit Datenbanken zu arbeiten – besonders wegen der Sicherheit und Flexibilität.

Doctrine DBAL (Database Abstraction Layer) ist eine PHP-Bibliothek, die eine Abstraktionsschicht für den Datenbankzugriff bietet. Sie ist ein Teil von Doctrine, einem weit verbreiteten ORM-Projekt (Object-Relational Mapping), aber kann unabhängig vom ORM verwendet werden.

Ziel und Nutzen von Doctrine DBAL:

Doctrine DBAL bietet eine einheitliche API, um mit verschiedenen Datenbanken (wie MySQL, PostgreSQL, SQLite usw.) zu kommunizieren, ohne direkt SQL für die jeweilige Datenbank schreiben zu müssen.

Hauptfunktionen von Doctrine DBAL:

• Verbindungsverwaltung:

• • Verbindungsaufbau zu Datenbanken über Konfigurationsarrays.

  • Unterstützung für Verbindungs-Pooling, Transaktionen usw.

• SQL-Query-Builder:

• • Dynamisches Erstellen von SQL-Abfragen über eine objektorientierte API:

$qb = $conn->createQueryBuilder();
$qb->select('u.id', 'u.name')
   ->from('users', 'u')
   ->where('u.age > :age')
   ->setParameter('age', 18);
$stmt = $qb->executeQuery();

• Datenbankunabhängigkeit:

  • Die gleichen Funktionen und Abfragen funktionieren mit verschiedenen DBMS, z. B. MySQL, PostgreSQL, SQLite.

• Schema-Management:

  • Werkzeuge zum Erstellen, Ändern und Vergleichen von Datenbankschemata.

  • Nützlich für Migrationen.

• Datentyp-Konvertierung:

  • Konvertiert Daten zwischen PHP und dem nativen Datenbankformat.

use Doctrine\DBAL\DriverManager;

$conn = DriverManager::getConnection([
    'dbname' => 'test',
    'user' => 'root',
    'password' => '',
    'host' => 'localhost',
    'driver' => 'pdo_mysql',
]);

$result = $conn->fetchAllAssociative('SELECT * FROM users');

Wann DBAL statt ORM?

Du verwendest DBAL ohne ORM, wenn:

• Du mehr Kontrolle über SQL willst.

• Dein Projekt keine komplexe Objekt-Mapping-Logik braucht.

• Du bereits vorhandene SQL-Strukturen nutzen musst.

Fazit:

Doctrine DBAL ist ein mächtiges Werkzeug für sauberen, portablen und sicheren Datenbankzugriff in PHP, ohne sich auf ein vollständiges ORM einlassen zu müssen. Es liegt genau zwischen direktem PDO-Zugriff und einem vollwertigen ORM wie Doctrine ORM.

Die PHP-Bibliothek Whoops ist ein leistungsstarkes und benutzerfreundliches Fehlermanagement-Tool für PHP-Anwendungen. Sie sorgt dafür, dass Fehler in einer ansprechenden und übersichtlichen Weise dargestellt werden, was die Fehlersuche und -behebung erleichtert.

Hauptfunktionen von Whoops

✅ Schöne, interaktive Fehlerseiten
✅ Detaillierte Stack-Traces mit Code-Vorschau
✅ Einfache Integration in bestehende PHP-Projekte
✅ Unterstützung für verschiedene Frameworks (Laravel, Symfony, Slim, etc.)
✅ Anpassbar durch eigene Handler und Logger

Installation

Whoops kann mit Composer installiert werden:

composer require filp/whoops

Grundlegende Nutzung

Hier ist ein einfaches Beispiel, wie du Whoops in deinem PHP-Projekt aktivieren kannst:

require 'vendor/autoload.php';

use Whoops\Run;
use Whoops\Handler\PrettyPageHandler;

$whoops = new Run();
$whoops->pushHandler(new PrettyPageHandler());
$whoops->register();

// Erzeugt einen Fehler (z. B. eine nicht definierte Variable aufrufen)
echo $undefinedVariable;

Falls ein Fehler auftritt, zeigt Whoops eine übersichtliche Debug-Seite an.

Anpassung und Erweiterung

Du kannst Whoops auch erweitern, z. B. indem du eine eigene Fehlerbehandlung hinzufügst:

use Whoops\Handler\CallbackHandler;

$whoops->pushHandler(new CallbackHandler(function ($exception, $inspector, $run) {
    error_log($exception->getMessage());
}));

Diese Variante loggt Fehler in eine Datei, anstatt sie direkt anzuzeigen.

Einsatzgebiete

Whoops wird oft in Entwicklungsumgebungen verwendet, um schnell auf Fehler zu reagieren. In Produktionsumgebungen sollte es jedoch deaktiviert oder durch eine benutzerdefinierte Fehlerseite ersetzt werden.

Twig ist ein leistungsfähiges und flexibles Templating-System für PHP, das häufig in Symfony, aber auch in anderen PHP-Projekten verwendet wird. Es ermöglicht eine klare Trennung von Logik und Präsentation und bietet viele nützliche Features für die Frontend-Entwicklung.

Wichtige Merkmale von Twig

1. Einfache Syntax mit Platzhaltern ({{ }})

Twig verwendet doppelte geschweifte Klammern für die Ausgabe von Variablen:

<p>Hallo, {{ name }}!</p>

→ Wenn name = "Max" ist, wird ausgegeben:
"Hallo, Max!"

2. Steuerstrukturen ({% %})

Twig unterstützt if-else, Schleifen und andere Kontrollstrukturen:

If-Else

{% if user.isAdmin %}
    <p>Willkommen, Admin!</p>
{% else %}
    <p>Willkommen, Nutzer!</p>
{% endif %}

Schleifen (for)

<ul>
{% for user in users %}
    <li>{{ user.name }}</li>
{% endfor %}
</ul>

3. Template-Vererbung

Twig unterstützt das Konzept von "Base-Layouts", ähnlich wie Blade in Laravel.

Eltern-Template (base.html.twig)

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}Meine Seite{% endblock %}</title>
</head>
<body>
    <header>{% block header %}Standard-Header{% endblock %}</header>
    <main>{% block content %}{% endblock %}</main>
</body>
</html>

Kind-Template (page.html.twig)

{% extends 'base.html.twig' %}

{% block title %}Startseite{% endblock %}

{% block content %}
    <p>Willkommen auf meiner Seite!</p>
{% endblock %}

→ Die Blöcke überschreiben die Standardinhalte des Basis-Templates.

4. Inkludieren von Templates

Man kann wiederverwendbare Teile wie Header oder Footer einbinden:

{% include 'partials/navbar.html.twig' %}

5. Filter & Funktionen

Twig enthält viele Filter, um Inhalte zu formatieren:

6. Sicherheit & Escaping

Twig escapet HTML automatisch, um XSS-Angriffe zu verhindern:

{{ "<script>alert('XSS');</script>" }}

→ Gibt nur <script>alert('XSS');</script> aus.

Möchtest du HTML ungefiltert ausgeben, nutze |raw:

{{ "<strong>Fett</strong>"|raw }}

7. Erweiterbarkeit

• Twig unterstützt eigene Filter & Funktionen.
• Man kann PHP-Objekte und Arrays direkt in Twig verwenden.

PSR-12 ist ein Standard der PHP-Fig (PHP Framework Interoperability Group), der Coding-Style-Guidelines für PHP definiert. Es baut auf PSR-1 (Basic Coding Standard) und PSR-2 (Coding Style Guide) auf und erweitert diese, um modernere Anforderungen und Best Practices zu berücksichtigen.

Ziel von PSR-12

PSR-12 zielt darauf ab, einen einheitlichen und lesbaren Code-Stil für PHP-Projekte zu schaffen. Dies erleichtert die Zusammenarbeit zwischen Entwicklern und sorgt für Konsistenz in der Codebasis.

Wichtige Richtlinien von PSR-12

1. Einrückung

• 4 Leerzeichen werden für die Einrückung verwendet (keine Tabs).

2. Zeilenlänge

• Die maximale Zeilenlänge sollte 120 Zeichen nicht überschreiten.
• Code darf für bessere Lesbarkeit auf mehrere Zeilen umgebrochen werden.

3. Namespace und Use-Anweisungen

• Nach der namespace-Deklaration muss eine Leerzeile stehen.
• use-Anweisungen werden nach der namespace-Deklaration gruppiert.
• Importierte Klassen, Funktionen und Konstanten sollten alphabetisch sortiert werden und keine Leerzeilen enthalten.

namespace App\Controller;

use App\Service\MyService;
use Psr\Log\LoggerInterface;

4. Klassen

• Der Öffnungsblock { einer Klasse oder Methode steht in der nächsten Zeile.
• Sichtbarkeiten (public, protected, private) sind bei allen Methoden und Eigenschaften zwingend erforderlich.

class MyClass
{
    private string $property;

    public function myMethod(): void
    {
        // code
    }
}

5. Methoden und Funktionen

• Jeder Parameter einer Methode/Funktion muss auf einer neuen Zeile stehen, wenn sie umgebrochen wird.
• Rückgabetypen sollten explizit angegeben werden.

public function myFunction(
    int $param1,
    string $param2
): string {
    return 'example';
}

6. Control Structures (if, while, for, etc.)

• Der Öffnungsblock { muss in derselben Zeile wie die Kontrollstruktur stehen.
• Zwischen der Kontrollstruktur und der Bedingung steht ein Leerzeichen.

if ($condition) {
    // code
} elseif ($otherCondition) {
    // code
} else {
    // code
}

7. Arrays

• Arrays sollten im kurzen Syntax-Stil ([]) geschrieben werden.
• Bei mehrzeiligen Arrays sollte jedes Element in einer neuen Zeile stehen.

$array = [
    'first' => 'value1',
    'second' => 'value2',
];

8. Typdeklarationen

• Typen für Parameter, Rückgabewerte und Eigenschaften sind zwingend erforderlich (sofern möglich).
• Nullbare Typen werden mit ? vor dem Typ deklariert.

public function getValue(?int $id): ?string
{
    return $id !== null ? (string) $id : null;
}

9. Dateien

• PHP-Dateien müssen mit einem <?php-Tag beginnen und dürfen kein schließendes ?>-Tag enthalten.
• Zwischen der Deklaration von Codeelementen (z. B. Klassen oder Funktionen) sollten Leerzeilen eingefügt werden.

Unterschiede zu PSR-2

PSR-12 erweitert PSR-2 um:

• Unterstützung moderner PHP-Features (z. B. nullable types, declare(strict_types=1), traits, type hinting).
• Mehr Klarheit bei der Zeilenlänge, bei umgebrochenen Methodenparametern und bei Arrays.
• Explizitere Regeln zur Typdeklaration.

Vorteile von PSR-12

• Vereinfachung von Code-Reviews.
• Bessere Lesbarkeit und Wartbarkeit von Code.
• Erhöhte Interoperabilität zwischen verschiedenen PHP-Projekten.
• Einheitlichkeit bei der Verwendung moderner PHP-Features.

Zusammenfassung

PSR-12 ist der Standard für modernen und konsistenten PHP-Code. Es bringt Klarheit und Struktur in PHP-Projekte, besonders bei Teams, die gemeinsam an einer Codebasis arbeiten. Mit Tools wie PHP_CodeSniffer oder PHP-CS-Fixer kannst du PSR-12 problemlos einhalten.

PSR-11 ist eine PHP-Standard-Empfehlung (PHP Standard Recommendation), die sich mit der Container-Interface-Definition beschäftigt. Sie beschreibt ein einheitliches Interface für Dependency Injection Container, das in PHP-Projekten verwendet werden kann. Dependency Injection Container sind Werkzeuge, die Klassen und ihre Abhängigkeiten verwalten und auflösen.

Ziel von PSR-11

PSR-11 wurde eingeführt, um sicherzustellen, dass verschiedene Frameworks, Bibliotheken und Tools interoperabel mit Dependency Injection Containern arbeiten können. Durch die Einhaltung dieses Standards wird es möglich, verschiedene Container in einem Projekt zu verwenden, ohne den Code ändern zu müssen.

Kernkomponenten des PSR-11

PSR-11 definiert zwei Interfaces:

1. ContainerInterface

   • Das zentrale Interface, das Methoden bereitstellt, um Abhängigkeiten aus dem Container zu holen.

namespace Psr\Container;

interface ContainerInterface {
    public function get(string $id);
    public function has(string $id): bool;
}

• • get(string $id): Gibt die Instanz (oder den Service) zurück, die im Container unter einer bestimmten ID registriert ist.
  • has(string $id): Prüft, ob der Container eine Instanz mit der angegebenen ID enthält.

• 2. NotFoundExceptionInterface

  • Wird ausgelöst, wenn ein Service nicht im Container gefunden wird.

namespace Psr\Container;

interface NotFoundExceptionInterface extends ContainerExceptionInterface {
}

3. ContainerExceptionInterface

• • Wird für generelle Fehler im Container verwendet.

Vorteile von PSR-11

• Interoperabilität: Verschiedene Frameworks und Bibliotheken können denselben Container nutzen.
• Standardisierung: Einheitliche API für Containerzugriffe.
• Erweiterbarkeit: Entwickler können eigene Container erstellen, die den PSR-11-Spezifikationen entsprechen.

Typischer Anwendungsfall

PSR-11 wird häufig in Frameworks wie Symfony, Laravel, oder Zend Framework (jetzt Laminas) verwendet, die Dependency Injection Container bereitstellen. Auch Tools wie PHP-DI oder Pimple unterstützen PSR-11.

Beispiel

Ein einfaches Beispiel für den Einsatz von PSR-11:

use Psr\Container\ContainerInterface;

class MyService {
    public function __construct(private string $message) {}
    public function greet(): string {
        return $this->message;
    }
}

$container = new SomePSR11CompliantContainer();
$container->set('greeting_service', function() {
    return new MyService('Hello, PSR-11!');
});

if ($container->has('greeting_service')) {
    $service = $container->get('greeting_service');
    echo $service->greet(); // Ausgabe: Hello, PSR-11!
}

Fazit

PSR-11 ist eine wichtige Schnittstelle für modernes PHP-Entwickeln, da sie Abhängigkeiten und deren Auflösung standardisiert. Dies führt zu flexibleren und besser wartbaren Anwendungen.