Python ist eine Programmiersprache, die für ihre einfache Lesbarkeit und Benutzerfreundlichkeit bekannt ist. Sie wurde von Guido van Rossum in den späten 1980er-Jahren entwickelt und 1991 erstmals veröffentlicht. Der Name „Python“ stammt nicht von der Schlange, sondern von der britischen Comedy-Serie „Monty Python’s Flying Circus“.
Python ist ideal für Einsteiger, aber auch für erfahrene Entwickler eine mächtige Sprache. Es wird oft als erste Programmiersprache empfohlen, weil man schnell erste Ergebnisse erzielen kann.
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.
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.
namespace-Deklaration muss eine Leerzeile stehen.use-Anweisungen werden nach der namespace-Deklaration gruppiert.namespace App\Controller;
use App\Service\MyService;
use Psr\Log\LoggerInterface;{ einer Klasse oder Methode steht in der nächsten Zeile.public, protected, private) sind bei allen Methoden und Eigenschaften zwingend erforderlich.class MyClass
{
private string $property;
public function myMethod(): void
{
// code
}
}public function myFunction(
int $param1,
string $param2
): string {
return 'example';
}{ muss in derselben Zeile wie die Kontrollstruktur stehen.if ($condition) {
// code
} elseif ($otherCondition) {
// code
} else {
// code
}[]) geschrieben werden.$array = [
'first' => 'value1',
'second' => 'value2',
];? vor dem Typ deklariert.public function getValue(?int $id): ?string
{
return $id !== null ? (string) $id : null;
}<?php-Tag beginnen und dürfen kein schließendes ?>-Tag enthalten.PSR-12 erweitert PSR-2 um:
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.
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.
PSR-11 definiert zwei Interfaces:
ContainerInterface
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
namespace Psr\Container;
interface NotFoundExceptionInterface extends ContainerExceptionInterface {
}3. ContainerExceptionInterface
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.
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!
}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.
PSR-7 ist eine PHP Standard Recommendation (PSR), die sich auf HTTP-Nachrichten in PHP bezieht. Sie wurde von der PHP-FIG (Framework Interoperability Group) entwickelt und definiert Schnittstellen für das Arbeiten mit HTTP-Nachrichten, wie sie von Webservern und -Clients verwendet werden.
Request und Response:
PSR-7 standardisiert, wie HTTP-Requests und -Responses in PHP dargestellt werden. Es stellt Schnittstellen für:
Unveränderlichkeit (Immutability):
Alle Objekte sind unveränderlich. Das bedeutet, dass Änderungen an einem HTTP-Objekt ein neues Objekt erzeugen, anstatt das bestehende zu modifizieren. Dies verbessert die Vorhersagbarkeit und erleichtert Debugging.
Streams:
PSR-7 verwendet Stream-Objekte, um HTTP-Nachrichtenkörper zu handhaben. Die StreamInterface definiert Methoden für die Arbeit mit Streams (z. B. read(), write(), seek()).
ServerRequest:
Die Schnittstelle ServerRequestInterface erweitert RequestInterface, um zusätzliche Daten wie Cookies, Server-Parameter und hochgeladene Dateien zu behandeln.
Kompatibilität mit Middleware:
PSR-7 ist der Grundstein für Middleware-Architekturen in PHP. Es erleichtert die Entwicklung von Middleware-Komponenten, die HTTP-Anfragen verarbeiten und Antworten manipulieren.
PSR-7 ist in modernen PHP-Frameworks und -Libraries weit verbreitet, darunter:
Das Ziel von PSR-7 ist es, die Interoperabilität zwischen verschiedenen PHP-Bibliotheken und -Frameworks zu verbessern, indem ein gemeinsamer Standard für HTTP-Nachrichten definiert wird.
PSR-6 ist ein Standard des PHP-FIG (PHP Framework Interoperability Group), der eine gemeinsame Schnittstelle für das Caching in PHP-Anwendungen definiert. Diese Spezifikation, die als „Caching Interface“ bekannt ist, zielt darauf ab, Interoperabilität zwischen verschiedenen Caching-Bibliotheken zu fördern, indem sie eine standardisierte API bereitstellt.
Wichtige Bestandteile von PSR-6 sind:
Cache Pool Interface (CacheItemPoolInterface): Stellt eine Sammlung von Cache-Elementen dar. Es ist verantwortlich für das Verwalten, Abrufen, Speichern und Löschen von Cache-Daten.
Cache Item Interface (CacheItemInterface): Repräsentiert einzelne Cache-Elemente innerhalb des Pools. Jedes Cache-Element enthält einen eindeutigen Schlüssel und einen gespeicherten Wert und kann so konfiguriert werden, dass es nach einer bestimmten Zeit abläuft.
Standardisierte Methoden: PSR-6 definiert Methoden wie getItem(), hasItem(), save() und deleteItem() im Cache-Pool sowie get(), set() und expiresAt() im Cache-Element-Interface, um Cache-Operationen zu standardisieren und Konsistenz sicherzustellen.
Durch die Definition dieser Schnittstellen ermöglicht PSR-6 Entwicklern das einfache Austauschen von Caching-Bibliotheken oder das Integrieren verschiedener Caching-Lösungen, ohne die Kernlogik der Anwendung ändern zu müssen.
PSR-4 ist eine PHP-Standard-Empfehlung für das Autoloading von Klassen basierend auf Namespaces und Dateipfaden. Dieser Standard wurde von der PHP-FIG (PHP Framework Interop Group) entwickelt und beschreibt, wie vollständig qualifizierte Klassennamen zu den entsprechenden Dateipfaden gemappt werden. Dadurch kann PHP Klassen automatisch finden und laden, ohne dass manuelle require- oder include-Anweisungen nötig sind.
Namespace-Zuordnung: PSR-4 verlangt, dass der Namespace und Klassenname mit der Verzeichnisstruktur und dem Dateinamen übereinstimmen. Jeder Namespace-Präfix wird mit einem Basisverzeichnis verknüpft, und innerhalb dieses Verzeichnisses entspricht die Verzeichnisstruktur dem Namespace.
Basisverzeichnis: Für jeden Namespace-Präfix wird ein Basisverzeichnis definiert, und die Klassen werden in Unterverzeichnissen des Basisverzeichnisses entsprechend ihrer Namespace-Struktur abgelegt. Zum Beispiel:
App\Controllers ist, sollte die Datei in einem Verzeichnis wie /path/to/project/src/Controllers liegen.Dateibenennung: Der Klassenname muss genau mit dem Dateinamen übereinstimmen und mit .php enden.
Kompatibilität mit Autoloadern: Die Implementierung von PSR-4 gewährleistet Kompatibilität mit modernen Autoloadern wie dem von Composer, wodurch PHP Klassen automatisch ohne manuelle Einbindung findet.
Angenommen, Sie haben die Klasse App\Controllers\UserController, so sollte die Verzeichnisstruktur wie folgt aussehen:
/path/to/project/src/Controllers/UserController.php
In der composer.json von Composer wird diese Zuordnung wie folgt angegeben:
{
"autoload": {
"psr-4": {
"App\\": "src/"
}
}
}Dies weist Composer an, die Klassen im App-Namespace aus dem src/-Verzeichnis zu laden. Wenn Sie composer dump-autoload ausführen, wird Composer das Autoloading gemäß dem PSR-4-Standard konfigurieren.
PSR-4 hat den älteren PSR-0-Standard abgelöst und ist nun der bevorzugte Autoloading-Standard für moderne PHP-Projekte.
Monolog ist eine weit verbreitete Logging-Bibliothek für PHP, die das PSR-3-Standardinterface für Logs implementiert und so kompatibel mit PSR-3-konformen Frameworks und Anwendungen ist. Monolog bietet eine einfache und flexible Möglichkeit, Logs in verschiedenen Zielsystemen zu speichern und zu verwalten. Entwickler können damit Fehler, Warnungen oder allgemeine Informationen in PHP-Anwendungen protokollieren und so das Debugging und die Wartung ihrer Anwendungen verbessern.
Logger Instanz: Monolog erstellt einen Logger über die Logger-Klasse. Die Logger-Instanz unterstützt verschiedene Log-Level (z. B. debug, info, warning, error), die in PHP-Programmen genutzt werden können, um verschiedene Schweregrade von Log-Nachrichten zu erfassen.
Handler: Ein Herzstück von Monolog ist das Konzept der Handler. Handler steuern, wohin und wie die Log-Einträge gespeichert werden. Monolog unterstützt zahlreiche Handler, darunter:
Formatter: Handler können mit Formatters kombiniert werden, um den Inhalt der Logs anzupassen. Monolog bietet verschiedene Formatierer, die z. B. die Logs im JSON-Format ausgeben können oder einfach nur die grundlegende Textausgabe formatieren.
Processor: Neben Handlern und Formattern erlaubt Monolog auch den Einsatz von Prozessoren, die zusätzliche Daten an die Log-Einträge anhängen, z. B. Kontextinformationen wie User-Daten oder die aktuelle IP-Adresse.
Hier ein einfaches Beispiel zur Initialisierung und Nutzung eines Monolog-Loggers:
use Monolog\Logger;
use Monolog\Handler\StreamHandler;
$logger = new Logger('name');
$logger->pushHandler(new StreamHandler(__DIR__.'/app.log', Logger::WARNING));
// Log-Meldung erstellen
$logger->warning('Dies ist eine Warnung');
$logger->error('Dies ist ein Fehler');Monolog ist eine der am häufigsten eingesetzten Logging-Bibliotheken in PHP, vor allem in Kombination mit Symfony, Laravel und anderen PHP-Frameworks.
PSR-3 ist eine Empfehlung der PHP-FIG (PHP Framework Interoperability Group), die ein standardisiertes Interface für Logging-Bibliotheken in PHP-Anwendungen festlegt. Das Ziel ist es, Entwicklern eine einheitliche und flexible Schnittstelle für das Logging bereitzustellen, die unabhängig von der verwendeten Bibliothek funktioniert. Dadurch können Log-Bibliotheken leicht ersetzt oder geändert werden, ohne dass bestehender Code angepasst werden muss.
Standardisiertes Logger-Interface: PSR-3 definiert das Interface Psr\Log\LoggerInterface mit verschiedenen Methoden für unterschiedliche Log-Level wie emergency(), alert(), critical(), error(), warning(), notice(), info() und debug().
Log-Level: Die acht vordefinierten Log-Level (z. B. emergency, alert, error) basieren auf dem weit verbreiteten Syslog-Protokoll RFC 5424, was die Kompatibilität mit vielen Logging-Systemen sicherstellt.
Nachrichteninterpolation: PSR-3 erlaubt es, Platzhalter in Log-Nachrichten (z. B. {platzhalter}) durch tatsächliche Werte zu ersetzen. Beispiel:$logger->error("Benutzer {username} nicht gefunden", ['username' => 'johndoe']);Dadurch werden Log-Nachrichten konsistent und lesbar formatiert, ohne dass aufwendige String-Manipulation nötig ist.
Flexible Implementierung: Jede Logging-Bibliothek, die LoggerInterface implementiert, kann in PSR-3-kompatiblem Code verwendet werden, wie etwa die weit verbreitete Bibliothek Monolog.
Dynamische Log-Level: Mit der log()-Methode kann man Nachrichten auch dynamisch auf jedem gewünschten Log-Level protokollieren, indem der Level als Parameter übergeben wird.
Hier ein Beispiel, wie ein PSR-3-konformer Logger verwendet wird:
use Psr\Log\LoggerInterface;
class UserService
{
private $logger;
public function __construct(LoggerInterface $logger)
{
$this->logger = $logger;
}
public function findUser($username)
{
$this->logger->info("Suche nach Benutzer {username}", ['username' => $username]);
// ...
}
}Mehr Informationen und Details finden sich auf der offiziellen PHP-FIG-Seite zur PSR-3-Spezifikation.
PSR-2 ist eine Richtlinie für den Programmierstil in PHP, die von der PHP-Fig (Framework Interop Group) als Empfehlung erstellt wurde. Die Abkürzung „PSR“ steht für „PHP Standards Recommendation“. PSR-2 wurde speziell entwickelt, um den Code lesbarer und einheitlicher zu machen, sodass verschiedene Entwicklerteams besser zusammenarbeiten können.
{ für Klassen und Methoden gehört in die nächste Zeile, die für Kontrollstrukturen wie if oder for in dieselbe Zeile.=, +, etc., wird ein Leerzeichen verwendet.Hier ist ein einfaches Beispiel, das die Richtlinien zeigt:
<?php
namespace Vendor\Package;
class ExampleClass
{
public function exampleMethod($arg1, $arg2 = null)
{
if ($arg1 === $arg2) {
throw new \Exception('Arguments cannot be equal');
}
return $arg1;
}
}PSR-2 wurde inzwischen von PSR-12 erweitert und ersetzt, das zusätzliche Regeln zur Verbesserung der Code-Konsistenz einführt.
PSR-1 ist eine PHP-Standards-Empfehlung (PHP Standards Recommendation), die von der PHP-FIG (Framework Interop Group) erstellt wurde. Sie definiert grundlegende Codierungsstandards für PHP, um die Interoperabilität zwischen verschiedenen PHP-Projekten und -Frameworks zu gewährleisten. Das Ziel von PSR-1, auch als "Basic Coding Standard" bezeichnet, ist es, eine konsistente Grundlage für PHP-Code zu schaffen, was die Lesbarkeit und Zusammenarbeit bei Projekten im PHP-Ökosystem erleichtert. Die Hauptpunkte von PSR-1 umfassen:
Dateiformatierung:
<?php oder <?= Tags verwenden.Namensräume und Klassennamen:
StudlyCaps-Stil (PascalCase) deklariert werden.Konstanten-, Eigenschaften- und Methodennamen:
CONST_VALUE).camelCase-Stil geschrieben werden.Autoloading:
include- oder require-Anweisungen zu vermeiden.PSR-1 gilt als grundlegender Standard und ergänzt PSR-2 und PSR-12, die detailliertere Codeformatierungsrichtlinien festlegen. Zusammen verbessern diese Standards die Lesbarkeit und Konsistenz von PHP-Projekten.
Spring
