PHP lernen: Tutorial für Einsteigerinnen und Einsteiger

PHP ist eine der gängigsten Programmiersprachen für die serverseitige Programmierung. Im Laufe der Zeit hat sich PHP zu einem unverzichtbaren Bestandteil vieler moderner Websites und Internettechnologien entwickelt. Doch PHP zu lernen kann für Neueinsteigerinnen und Neueinsteiger eine große Herausforderung sein. In diesem PHP-Tutorial zeigen wir Ihnen die Grundlagen der beliebten Programmiersprache sowie ihre wichtigsten Operatoren, Schleifen und Funktionen.

PHP-Tutorial: Was Sie mitbringen sollen

Unser Tutorial richtet sich in erster Linie an Neuanfängerinnen und Neuanfänger. Bei manchen Beispielen ist es jedoch hilfreich, über ein Grundwissen der modernen Webentwicklung sowie HTML zu verfügen. Um die aufgeführten Beispiele an Ihrem eigenen Rechner nachzuvollziehen, müssen Sie folgende vorbereiten:

• Webserver inklusive PHP-Interpreter
• PHP installieren
• Webbrowser
• Texteditor

XAMPP

Als Server empfehlen wir für den Einstieg die lokale Testumgebung XAMPP, die von Apache Friends für die Betriebssysteme Windows, Linux und macOS kostenlos zur Verfügung gestellt wird. XAMPP ist ein reiner Testserver. Webentwicklerinnen und Webentwicklern bietet das Software-Bundle die Möglichkeit, in kürzester Zeit eine komplette Testumgebung für Skripte, HTML-Seiten und Stylesheets aufzusetzen. Ein sicherer Betrieb als Webserver im Internet ist jedoch nicht gewährleistet. Eine ausführliche Installationsanleitung finden Sie in unserem XAMPP-Tutorial.

PHP Built-in Server

PHP bringt seit Version 5.4 einen integrierten Entwicklungsserver mit, der sich besonders für einfache Tests und Lernzwecke eignet. Dieser sogenannte Built-in Server erfordert keine zusätzliche Server-Software wie Apache oder NGINX. Voraussetzung ist lediglich eine installierte PHP-Version auf Ihrem System. Anschließend können Sie den Server direkt über die Kommandozeile im Projektverzeichnis starten:

php -S localhost:8000

PHP stellt die Dateien im aktuellen Ordner anschließend unter der Adresse http://localhost:8000 im Webbrowser bereit. Der Built-in Server eignet sich vor allem für erste PHP-Experimente, kleine Testskripte oder das schnelle Nachvollziehen von Codebeispielen.

Docker und Docker-Compose

Eine etwas anspruchsvollere Alternative ist der Einsatz von Docker. Docker ermöglicht es, Entwicklungsumgebungen in sogenannten Containern zu kapseln. Dadurch lassen sich Webserver, PHP und Datenbanken exakt so konfigurieren, wie sie später auch in der Produktionsumgebung laufen. Für PHP-Projekte wird häufig Docker-Compose verwendet, um mehrere Dienste gemeinsam zu starten. Die gesamte Konfiguration wird in einer Datei („docker-compose.yml)“ festgehalten und kann mit einem einzigen Befehl gestartet werden.

PHP-Grundlagen: Die Syntax der Skriptsprache

Haben Sie Ihren lokalen Webserver (z. B. mithilfe von XAMPP) eingerichtet, sollten Sie testen, ob PHP korrekt installiert wurde und bereit ist, Skripte auszuführen. Ein Skript ist ein Programm, das nicht vorab in Binärcode kompiliert wird. Stattdessen werden sie von einem Interpreter ausgeführt. Öffnen Sie Ihren bevorzugten Texteditor und übernehmen Sie folgendes PHP-Skript:

<?php
phpinfo();
?>

PHP-Skripte sind immer nach demselben Schema aufgebaut. Der öffnende PHP-Tag <?php signalisiert, dass eine Skript-Umgebung gestartet wird. Darauf folgt der eigentliche PHP-Code in Form von Anweisungen. Im Beispiel handelt es sich um den Aufruf der Funktion phpinfo(). Die meisten PHP-Funktionen verlangen einen oder mehrere Parameter, die zwischen den runden Klammern stehen; bei phpinfo() sind diese optional. Jede Anweisung endet mit einem Semikolon (;). Um die Skript-Umgebung zu schließen, kommt der schließende PHP-Tag zum Einsatz: ?>. Dieser ist bei reinen PHP-Dateien optional.

Speichern Sie die Textdatei unter dem Namen „test“ im Format .php (PHP-Skript) ab und starten Sie Ihren Webserver. Sofern Sie die Testumgebung XAMPP nutzen, legen Sie „test.php“ im XAMPP-Verzeichnis unter „htdocs“ ab (C:\xampp\htdocs).

Close

Die Beispieldatei lässt sich nun über folgende URL im Webbrowser aufrufen: http://localhost/test.php. Verwenden Sie einen anderen Webserver oder eine individuelle Konfiguration der XAMPP-Software, wählen Sie die URL dem jeweiligen Dateipfad entsprechend.

Mit dem Eintippen der URL http://localhost/test.php weisen Sie Ihren Webbrowser an, die Datei „test.php“ vom Webserver anzufordern. Der Apache HTTP Server oder die von Ihnen bevorzugte Webserver-Software ruft die Datei im entsprechenden Verzeichnis ab. Die Endung .php kündigt an, dass die Datei PHP-Code enthält. Nun schaltet sich der in den Webserver eingebundene PHP-Interpreter ein. Dieser parst das Dokument und stößt auf das öffnende PHP-Tag <?php. Der Interpreter ist in der Lage, den PHP-Code auszuführen und eine HTML-Ausgabe zu erzeugen, die vom Webserver an den Webbrowser ausgeliefert wird.

„Hello World!“ – so geben Sie Text per echo aus

Wurde PHP fehlerfrei installiert, wird es Zeit, das erste eigene Skript zu schreiben. Dazu bietet sich die Anweisung PHP echo an. Anders als phpinfo() stellt echo keine Funktion dar. Vielmehr handelt es sich um ein Sprachkonstrukt, das es ermöglicht, einen nachfolgenden String als Text auszugeben.

Erstellen Sie für Ihr erstes eigenes Skript eine neue PHP-Datei und notieren Sie in dieser folgenden Code:

<?php
echo 'Hello World!';

Das öffnende Tag <?php startet eine Skript-Umgebung. Es folgt das Sprachkonstrukt echo sowie der in einfache Anführungszeichen gefasste String „Hello World!“. Achten Sie auf das Semikolon nach der Anweisung. Statt „Hello World!“ kann ein beliebiger Text verwendet werden. Da es sich um eine reine PHP-Datei handelt, haben wir auf den schließenden PHP-Tag verzichtet.

Speichern Sie das Skript unter „hello.php“ im Ordner „htdocs“ auf ihrem Webserver ab und rufen Sie die Datei über die URL ‘http://localhost/hello.php’ im Webbrowser auf. Wurde der Code richtig übertragen, sollte das Browserfenster nun die von Ihnen verwendete Zeichenfolge zeigen:

Close

Jeder Text, den Sie mit echo ausgeben, kann bei Bedarf mit HTML-Tags ausgezeichnet werden. Diese werden vom Webbrowser anschließend der HTML-Spezifikation entsprechend interpretiert. Versuchen Sie es selbst, z. B. mit folgendem Skript:

<?php
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';

Im Webbrowser aufgerufen wird das Ergebnis der Skriptausführung folgendermaßen dargestellt:

Close

Die in <h1>-Tags gefasste Zeichenfolge „Hello World!“ wird vom Webbrowser als Überschrift erster Ordnung interpretiert. Es folgen ein automatischer Zeilenumbruch und der Textabsatz <p>.

Je nach Bedarf lässt sich echo sowohl mit einfachen (') als auch mit doppelten Anführungszeichen (") einsetzen. Möchten Sie lediglich Text ausgeben, macht es keinen Unterschied, für welche Anführungszeichen Sie sich entscheiden. Dies ändert sich jedoch, sobald PHP-Variablen ins Spiel kommen.

Variablen

Das Sprachkonstrukt echo hält mehr bereit als die reine Textausgabe. Diese lässt sich schließlich auch ohne PHP auf Basis von HTML hervorragend umsetzen. Der eigentliche Mehrwert von echo beruht darauf, dass die Anweisung es ermöglicht, Texte mithilfe von Variablen dynamisch zu erzeugen.

Variablen begegnen Ihnen z. B. in folgender Form: $beispiel.

Jede Variable besteht aus einem Dollarzeichen ($) gefolgt vom Variablen-Namen. Variablen kommen in PHP-Skripten zum Einsatz, um externe Daten in Webseiten einzubinden. Dabei kann es sich um Werte verschiedener Art handeln – von einfachen Zahlen und Zeichenketten bis hin zu ganzen Texten oder HTML-Dokumentstrukturen.

PHP unterscheidet acht Variablen-Typen:

Die zentrale Verwaltung von Inhalten erfolgt in der Regel mithilfe von Datenbanksystemen. Werte für Variablen lassen sich jedoch auch direkt im Skript definieren. Diese Art der Zuordnung erfolgt nach folgendem Schema:

$beispiel = "Wert";

Auf das charakteristische Dollarzeichen folgt der Variablen-Name (in diesem Fall beispiel). Dieser wird durch das Gleichheitszeichen (=) mit einem in doppelte Anführungszeichen gefassten Wert verknüpft. Werte für Variablen des Typs Integer und Float werden ohne Anführungszeichen notiert (z. B. $beispiel = 24; bzw. $beispiel = 2.7;)

PHP bietet Ihnen die Freiheit, Variablen nach eigenem Ermessen zu benennen. Es gelten jedoch folgende Einschränkungen:

• Jede Variable beginnt mit einem Dollarzeichen.
• Ein Variablen-Name ist eine beliebige Zeichenfolge aus Buchstaben, Ziffern und Unterstrichen (z. B. $beispiel\_1).
• Ein gültiger Variablen-Name beginnt immer mit einem Buchstaben oder einem Unterstrich ($beispiel1 oder $\_beispiel), nie mit einer Ziffer (falsch: $1beispiel).
• PHP ist case-sensitive. Die Skriptsprache unterscheidet zwischen Groß- und Kleinschreibung ($beispiel ≠ $Beispiel).
• Der Variablen-Name darf keine Leerzeichen oder Zeilenumbrüche enthalten (falsch: $beispiel 1)
• Von PHP für andere Zwecke reservierte Zeichenfolgen können nicht als benutzerdefinierte Variablen eingesetzt werden (z. B. $this)

Wir schauen uns das an einem Beispiel an:

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";

Auf das öffnende PHP-Tag folgt die Definition der Variable: Für $author soll der Wert „John Doe“ verwendet werden. Bei der Skriptausführung wird die Variable $author somit bei jeder Nennung innerhalb der Skript-Umgebung durch den Wert „John Doe“ ersetzt. Wie das im Webbrowser aussieht, zeigt die nachstehende Grafik.

Close

Liegt nun ein Irrtum vor und die Webpage stammt gar nicht von John Doe, sondern von seinem deutschen Kollegen Max Mustermann, braucht lediglich die Variable mit dem Namen $author angepasst zu werden, um den Fehler zu beheben. Effizient ist dies vor allem dann, wenn eine Variable innerhalb eines Skripts mehrfach vorkommt. Eine Korrektur müsste in diesem Fall lediglich an einer einzigen Stelle vorgenommen werden. Nämlich da, wo der Wert der Variable definiert wird.

Die Vorteile dieses Designkonzepts liegen auf der Hand: Werden Elemente der Website (z. B. im Footer-Bereich) überarbeitet, müssen die Anpassungen nicht auf jeder einzelnen Unterseite des Webprojekts manuell vorgenommen werden. Stattdessen genügt es, den entsprechenden Eintrag in der Datenbank zu aktualisieren. So wird die Überarbeitung automatisch für alle Webpages übernommen, die die entsprechenden Daten als Variablen einbinden.

Wird eine Variable innerhalb eines Skripts mehrfach definiert, überschreibt die neue Definition die vorhergehende. Ein nachfolgendes echo gibt immer den aktuellen Wert einer Variable aus.

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
$author = "Max Mustermann";
echo " <p>Supported by $author.</p>";

Im Codebeispiel wird für die Variable $author erst der Wert „John Doe“ vergeben und anschließend durch den Wert „Max Mustermann“ ersetzt.

Close

Nun zum Thema Anführungszeichen. Anders als Strings brauchen einzelne Variablen nicht in Anführungszeichen gesetzt werden:

<?php
$author = "John Doe";
echo $author;

Es sei denn, die Variable soll innerhalb eines Strings verwendet werden. In diesem Fall arbeiten Sie mit doppelten Anführungszeichen (“). Diese signalisieren dem PHP-Interpreter, dass er den String nach Variablen absuchen soll, die ggf. durch die mit ihnen verknüpften Werte zu ersetzen sind. Zeichenfolgen, die in einfache Anführungszeichen (’) gefasst sind, werden als reine Textinformation interpretiert und wiedergegeben – selbst dann, wenn es sich um Variablen handelt.

<?php
$author = "John Doe";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>';

Die Variable wird in diesem Fall also nicht interpretiert, sondern einfach als Text wiedergegeben.

Close

Strikte Typisierung mit declare(strict_types=1)

Standardmäßig versucht PHP, unterschiedliche Datentypen automatisch ineinander umzuwandeln. Dieses Verhalten wird häufig als Typ-Jonglieren bezeichnet und kann dazu führen, dass fehlerhafte Werte unbemerkt weiterverarbeitet werden. Mit der Direktive declare(strict_types=1); lässt sich dieses Verhalten gezielt deaktivieren. PHP prüft dann bei Funktionsaufrufen strikt, ob übergebene Argumente und Rückgabewerte den deklarierten Variablentypen entsprechen. Die Direktive muss am Anfang einer PHP-Datei stehen und wirkt nur auf diese Datei:

<?php
declare(strict_types=1);
function addiere(int $a, int $b): int
{
return $a + $b;
}
echo addiere(2, 3); 
echo addiere("2", 3);

Im Beispiel akzeptiert eine PHP-Funktion namens addiere() ausschließlich Integer-Werte. Während der Aufruf mit 2 und 3 problemlos funktioniert, führt der zweite Aufruf zu einem Fehler, da der String "2" nicht automatisch in eine Ganzzahl umgewandelt wird. Durch die strikte Typisierung werden solche Probleme frühzeitig erkannt, was die Wartbarkeit und Zuverlässigkeit von PHP-Code deutlich verbessert.

Fehlermeldungen und Maskierung

Kommt es zu syntaktischen Fehlern, liegt kein valider PHP-Code vor und die geladene Seite im Browser ist leer oder der PHP-Interpreter gibt eine Fehlermeldung aus. Zu erwarten ist eine solche beispielsweise, wenn man die Anweisung echo mit einem String ohne Anführungszeichen einsetzt:

<?php
echo Hello World!;

Fehlermeldungen beinhalten in den meisten Fällen Angaben dazu, wo ein Fehler aufgetreten ist, und liefern so wichtigen Input zu dessen Beseitigung. Sie können die Meldungen in jedem Fall im XAMPP-Log unter „C:\xampp\logs\php_error_log“ einsehen.

Close

Im aktuellen Beispiel wird ein Fehler in Zeile 2 unseres Programmcodes vermutet – genau da, wo wir zu Demonstrationszwecken die Anführungszeichen weggelassen haben.

Zu syntaktischen Fehlern kommt es auch, wenn Sie Zeichen als Text ausgeben möchten, die in PHP mit einer bestimmten Aufgabe verbunden sind. Ein Beispiel wäre das Anführungszeichen (’). Zeichen wie diese lassen sich in PHP nur dann als Text ausgeben, wenn Sie dem Interpreter verständlich machen, dass das Zeichen seiner eigentlichen Aufgabe entbunden wurde. Im Fall von einfachen Anführungszeichen stehen Ihnen dazu zwei Möglichkeiten zu Verfügung: Sie können einen String mit einfachen Anführungszeichen in doppelte Anführungszeichen fassen oder die Anführungszeichen durch einen vorangestellten Backslash maskieren (auch „escapen“ genannt):

<?php
echo '\'Hello World!\' ';

Close

Ebenfalls möglich wäre die Kombination einfacher und doppelter Anführungszeichen:

<?php
echo " 'Hello World!' ";

Nicht jedoch diese Schreibweise:

<?php
echo ' 'Hello World!' ';

Die Leerzeichen zwischen den Anführungszeichen wurden in den Beispielen zwecks Lesbarkeit eingefügt.

Verkettungsoperatoren

Möchten Sie mehrere Variablen innerhalb eines PHP-Skripts gleichzeitig ausgeben, könnten Sie dies so umsetzen, wie bisher gelernt:

<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author1 and $author2.</p>";

Sie schreiben beide Variablen einfach zusammen mit dem restlichen Text, der ausgegeben werden soll, in den in doppelte Anführungszeichen gefassten String. PHP erkennt die Variablen anhand des Dollarzeichens ($) automatisch und setzt die entsprechenden Werte ein.

Close

Unter Programmiererinnen und Programmierern gilt ein solches Vorgehen jedoch als unsaubere Arbeit. Es gilt das Dogma, dass Variablen nicht Teil des Strings sein sollten. Ein Grund dafür ist, dass zahlreiche Programmiersprachen eine solche Trennung vorschreiben. Wichtiger ist, dass auch PHP die Trennung von String und Variable empfiehlt, wenn wir mit Funktionsaufrufen oder komplexeren Variablen arbeiten. Es lohnt sich daher, diese Trennung auch bei der reinen Textausgabe konsequent umzusetzen, selbst wenn es in diesem Fall nicht zwangsläufig nötig wäre.

Arbeiten wir mit Variablen, haben wir es somit immer mit mehreren Elementen zu tun, die bei der Ausgabe miteinander verkettet werden müssen. In PHP kommt dazu der Verkettungsoperator (.) zum Einsatz.

„Sauber“ programmiert müsste der Code für das oben angeführte Beispiel somit folgendermaßen aussehen:

<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.</p>';

Wir haben es somit mit drei Strings und zwei Variablen zu tun, die zu einer Zeichenfolge verkettet werden.

Zu beachten ist, dass ein Verkettungsoperator Strings oder Variablen ohne Leerzeichen zusammenfügt. Wird ein Leerzeichen gewünscht, muss dieses wie im Beispiel im String innerhalb der Anführungszeichen notiert werden.

Close

Programmiererinnen und Programmierer nutzen den Verkettungsoperator nicht nur, um Strings und Variablen für die Textausgabe zu verknüpfen, sondern auch, um Variablen zu verlängern. Wie das funktioniert, zeigt das folgende Beispiel:

<?php
$beispiel = 'Hallo ';
$beispiel .= 'Welt';
echo $beispiel;

Um den Wert einer Variable zu verlängern, definieren Sie diese erneut, setzen dabei aber den Verkettungsoperator vor das Gleichheitszeichen. Es handelt sich dabei um die allgemein übliche Kurzschreibweise für $beispiel = $beispiel . 'Welt'.

PHP fügt den neuen Wert an den zuvor definierten an. Wünschen Sie ein Leerzeichen zwischen beiden Werten, notieren Sie dieses wie im Beispiel am Ende des ersten Strings.

Close

PHP in HTML einbinden

Der PHP-Interpreter interessiert sich prinzipiell nur für Code, der sich zwischen einem öffnenden und einem schließenden PHP-Tag befindet (wobei letzteres bei reinem PHP optional ist):

<?php [Dieser Bereich wird vom PHP-Interpreter geparst] ?>

Alle anderen Abschnitte des Dokuments werden vom Interpreter ignoriert und so, wie sie sind, an den Webserver weitergegeben. PHP-Code lässt sich somit beliebig in HTML-Dokumente integrieren – um z. B. ein Template für ein Content-Management-System zu erstellen. Dabei ist darauf zu achten, dass HTML-Dokumente, die PHP-Code enthalten, als PHP-Dateien gespeichert werden. Ansonsten wird das Dokument nicht vom PHP-Interpreter vorverarbeitet, sondern direkt an den Webbrowser ausgeliefert – was zur Folge hätte, dass der Programmcode als Text auf der Website erscheint.

Den PHP-Interpreter können Sie sich somit als den faulen Kollegen des Webservers vorstellen, der nur dann arbeitet, wenn er explizit dazu aufgefordert wird – z. B. durch ein öffnendes PHP-Tag.

Möchten Sie HTML und PHP kombinieren, schreiben Sie Ihre HTML-Seite wie gewohnt gemäß der klassischen Dokumentstruktur und speichern diese unter der Dateiendung .php ab:

<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
</body>
</html>

Ergänzen Sie Ihr HTML-Dokument nun um ein PHP-Skript. Achten Sie darauf, dass sich der gesamte Programmcode innerhalb der PHP-Tags befindet.

<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
<p>Your current time and date is:
<?php
echo date("d.m.Y H:i:s");
?>.</p>
</body>
</html>

Im Beispiel haben wir das Sprachkonstrukt echo mit der PHP-Funktion date() kombiniert, um das aktuelle Datum inklusive Uhrzeit serverseitig als Text ausgeben zu lassen. Der Parameter der Funktion gibt das gewünschte Format in Form eines Strings an:

"d.m.Y H:i:s" (Tag.Monat.Jahr Stunde:Minute:Sekunde)

Wird eine solche Datei von einem Webbrowser angefordert, führt der PHP-Interpreter zunächst das Skript aus und schreibt die aktuelle Uhrzeit als Text in das HTML-Dokument. Dieses wird im Anschluss vom Webserver ausgeliefert und im Browser als Webpage dargestellt.

Close

Die PHP-Kommentarfunktion

Wie HTML-Code lässt sich auch PHP beliebig auskommentieren. Kommentare im Quellcode werden vom PHP-Interpreter ignoriert, sofern diese der Syntax entsprechend ausgezeichnet wurden. PHP stellt dazu drei verschiedene Alternativen bereit.

Möchten Sie eine gesamte Zeile als Kommentar auszeichnen und somit von der Interpretation ausschließen, nutzen Sie den Hashtag (#) oder zwei aufeinanderfolgende Slashs. Im folgenden Codebeispiel kommen beide Möglichkeiten zum Einsatz:

<?php
## This is a single line comment
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
// This is also a single-line comment!

Texteditoren oder IDEs mit Syntaxhervorhebung heben Kommentare farblich hervor. Die in der Skript-Umgebung als Kommentar ausgezeichneten Textstellen kommen im Webbrowser – im Gegensatz zu HTML-Kommentaren – gar nicht erst an, da diese bereits bei der Skriptausführung durch den PHP-Interpreter ignoriert werden.

Darüber hinaus haben Sie die Möglichkeit, Kommentare einzufügen, die sich über mehrere Zeilen erstrecken. Markieren Sie dazu den Anfang eines Kommentarabschnitts mit einem Slash gefolgt von einem Asterisk und das Ende mit einem Asterisk gefolgt von einem Slash.

<?php
/*
This is a multiple-lines comment block
that spans over multiple
lines
*/
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';

Auch derart ausgezeichnete Kommentare werden nicht geparst und erscheinen somit nicht auf der Webseite.

Close

Programmiererinnen und Programmierer nutzen Kommentare, um den Quellcode ihrer Skripte zu strukturieren, Hinweise für eine spätere Bearbeitung zu hinterlassen oder der Erstellung interne Angaben wie den Autor oder das Datum hinzuzufügen. Kommentare sind optional und sollten sparsam verwendet werden, um eine gute Lesbarkeit des Quellcodes zu gewährleisten.

Rechnen mit Variablen

Im Rahmen unseres PHP-Tutorials sind Sie bereits mit Variablen in Berührung gekommen. Dabei wurden diesen in erster Linie String-Werte (sprich: Zeichenfolgen) zugewiesen. Nun werden wir uns mit Variablen beschäftigen, die Ganzzahlen (Integers) oder Gleitkommazahlen (Floats) repräsentieren.

Speichern Variablen Zahlenwerte, bietet PHP die Möglichkeit, mit diesen Berechnungen durchzuführen. Wir beginnen mit einer einfachen Addition zweier Ganzzahlen:

<?php
$zahl1 = 237;
$zahl2 = 148;
$ergebnis = $zahl1 + $zahl2;
echo "Ergebnis: " . $ergebnis;

Zunächst weisen wir den Variablen $zahl1 und $zahl2 die Ganzzahlen 237 und 148 zu und definieren im Anschluss eine Variable $ergebnis. Diese soll die Summe der beiden Variablen speichern. Dazu bedienen wir uns des **arithmetischen Operators + (Plus). Abschließend geben wir das Additionsergebnis mithilfe des Sprachkonstrukts echo als Text aus. Beachten Sie, dass Sie bei der Zuweisung von Zahlenwerten zu Variablen keine Anführungszeichen benötigen.

Close

Folgendes Codebeispiel zeigt eine Auswahl mathematischer Berechnungen, die sich mit PHP serverseitig durchführen lassen. Die verwendeten PHP-Operatoren entsprechen größtenteils den standardisierten Rechenzeichen der Mathematik.

<?php
$zahl1 = 10;
$zahl2 = 5;
$addition = $zahl1 + $zahl2; //Addition
$subtraktion = $zahl1 - $zahl2; //Subtraktion
$multiplikation = $zahl1 * $zahl2; //Multiplikation
$division = $zahl1 / $zahl2; //Division
$potenz = $zahl1 ** $zahl2; //Potenzrechnung
echo "Ergebnis der Addition: " . $addition ."<br />";
echo "Ergebnis der Subtraktion: " . $subtraktion . "<br />";
echo "Ergebnis der Multiplikation: " . $multiplikation . "<br />";
echo "Ergebnis der Division: " . $division . "<br />";
echo "5-te Potenz von 10 (10^5): " . $potenz . "<br />";
echo "Wurzel von 81: " . sqrt(81) . "<br />";

Die Ausgabe sieht wie folgt aus:

Close

Für komplexe Berechnungen lassen sich die verschiedenen arithmetischen Operationen in einem Skript kombinieren:

<?php
$zahl1 = 10;
$zahl2 = 5;
$ergebnis = 2 *$zahl1 + 5* $zahl2 - 3 * sqrt(81);
echo "Ergebnis: " . $ergebnis;

Der PHP-Interpreter ermittelt die Werte der Variablen und berechnet:

2 *10 + 5* 5 - 3 * √81 = 20 + 25 – 27 = 18

Die Funktion sqrt() berechnet die Quadratwurzel des eingeklammerten Parameters. Es gilt die klassische Operator-Rangfolge der Mathematik: Punkt- vor Strichrechnung. Die Anweisung echo gibt das Ergebnis als String für den Webbrowser aus.

Eingeklammerte Terme werden auch in PHP zuerst ausgewertet. Wir arbeiten diesmal mit Fließkommazahlen:

<?php
$zahl1 = 2.5;
$zahl2 = 3.7;
$ergebnis = 2 *($zahl1 + 5)* ($zahl2 - 3) * sqrt(81);
echo "Ergebnis: " . $ergebnis;

Close

Wie die meisten gängigen Programmiersprachen unterstützt auch PHP Operatoren, um Zahlenwerte um den Wert 1 zu erhöhen oder zu vermindern. Man unterscheidet zwischen dem Prä-Inkrementoperator, dem Prä-Dekrementoperator, dem Post-Inkrementoperator und Post-Dekrementoperator.

Wir demonstrieren die Rechenoperationen mit Inkrement- bzw. Dekrementoperatoren am Beispiel der Prä-Inkrementierung. Folgendes Skript erhöht den Wert der Variable $zahl um 1, speichert den neuen Wert in der Variable $ergebnis und gibt deren Wert anschließend als String aus:

<?php
$zahl = 0;
$ergebnis = ++$zahl;
echo "Ergebnis: " . $ergebnis;

Erhöht man den Wert 0 um 1, erhält man das Ergebnis 1.

Close

Um das Prä-Dekrement der Variable $zahl zu berechnen, bedienen wir uns derselben Skripts, tauschen jedoch den Prä-Inkrementoperator (++) gegen den Prä-Dekrementoperator (--):

<?php
$zahl = 0;
$ergebnis = --$zahl;
echo "Ergebnis: " . $ergebnis;

Wir dekrementieren somit den Wert 0 der Variable $zahl und erhalten das Ergebnis -1.

Eine Erhöhung vor und nach der Ausgabe (Prä- vs. Post-…) eines Wertes lässt sich an folgendem Skript verdeutlichen:

<?php
$x = 0;
echo '<p>Ergebnis: ' . ++$x;
echo '<br>x hat den Wert ' . $x;
echo '<p>Ergebnis: ' . $x++;
echo '<br>x hat den Wert ' . $x, '</p>';

In beiden Fällen erhalten wir dasselbe Ergebnis. Bei der Prä-Inkrementierung wird der Wert x vor der Ausgabe in Zeile 3 erhöht und bei der Post-Inkrementierung nach der Ausgabe in Zeile 5.

Close

Skalare Typen und Union Types

PHP ermöglicht es, Variablen, Funktionsparameter und Rückgabewerte mit sogenannten skalaren Typen zu versehen. Zu diesen zählen unter anderem int, float, string und bool. Durch die explizite Typangabe wird festgelegt, welche Art von Werten eine Funktion erwartet und zurückliefert. Dies erhöht die Lesbarkeit des Codes und hilft dabei, typische Fehler frühzeitig zu erkennen.

function hi(string $name): string {
return "Hallo " . $name;
}

In diesem Beispiel erwartet die selbstgeschriebene Funktion hi() einen String als Parameter und gibt ebenfalls einen String zurück. Wird ein anderer Datentyp übergeben, meldet PHP einen Fehler. In manchen Situationen soll eine Funktion jedoch mehr als einen Datentyp akzeptieren. Dafür stellt PHP sogenannte Union Types zur Verfügung. Diese erlauben es, mehrere mögliche Typen zu definieren, getrennt durch das Pipe-Zeichen |:

function formatId(int|string $id): string {
return "ID: " . $id;
}

Die Funktion formatId() akzeptiert hier sowohl Ganzzahlen als auch Zeichenketten als Parameter. Andere Datentypen sind nicht erlaubt. Union Types ermöglichen damit flexible, aber dennoch kontrollierte Funktionssignaturen.

Die Superglobals $_GET und $_POST

Sie kennen jetzt die PHP-Grundlagen, wissen mit Variablen umzugehen, können diese verketten und Berechnungen anstellen. Nun zeigen wir Ihnen, warum Variablen ein zentrales Konzept beim Programmieren von Skripten sind.

Eine wichtige Funktion von Skriptsprachen ist die Möglichkeit, Benutzereingaben auszuwerten und die Werte in ein anderes Skript zu übertragen. PHP stützt sich bei der Datenübergabe auf die Superglobals $_GET und $\_POST – vordefinierte System-Variablen, die in allen Gültigkeitsbereichen verfügbar sind. Als assoziative Arrays (Datenfelder) speichern $_GET und $_POST einen Satz von Variablen in Form von Strings in einer Variable.

PHP-Arrays können Sie sich wie einen Schrank mit mehreren Schubladen vorstellen. Jede dieser Schubladen bietet Ihnen die Möglichkeit, Daten abzulegen. Damit Sie später noch wissen, was in welcher Schublade steckt, beschriften Sie diese mit einem Variablen-Namen. Je nach Art des Arrays kann es sich dabei um einen Index oder einen Key (Schlüssel) handeln. Während Sie bei indizierten Arrays für jede Schublade einen Index in Form einer Zahl vergeben, beschriften Sie die Schubladen eines assoziativen Arrays mit einem Key in Form eines Strings (Zeichenfolge).

Die Superglobals $_GET und $_POST beinhalten eine Reihe von Variablen in Form von Schlüsseln, die es ermöglichen, an die mit diesen Schlüsseln verbundenen Werte zu gelangen. Wir kommen darauf zurück, wenn wir uns die Superglobals $_GET und $_POST im Detail anschauen.

Datenübergabe via $_GET

Die Superglobal $_GET stellt ein Array von Variablen dar, die einem PHP-Skript mithilfe einer URL übergeben werden.

Falls Sie sich hin und wieder auf Weblogs oder in Onlineshops und Internetforen aufhalten, werden Ihnen möglicherweise die eigenartigen URLs aufgefallen sein, die man dort antrifft. Üblich ist ein Aufbau nach folgendem Schema:

http://hostname/ordner/dateiname.php?variablenname=variablenwert

Auf ein Weblog übertragen könnte dieses Schema so aussehen:

http://www.beispiel-blog.de/index.php?id=1

Eine solche URL lässt sich ganz einfach aufschlüsseln: Auf einem Webserver mit der Domain „beispiel-blog.de“ findet sich eine Datei namens „index.php“, die der Erstellung einer dynamischen Webseite dient. Diese enthält in der Regel HTML- und PHP-Code sowie Verweise auf ausgelagerte Template-Files und externe Stylesheets – kurz alles, was benötigt wird, um eine Webseite darzustellen.

Dass es sich wahrscheinlich um eine dynamische Webseite handelt, signalisiert der Zusatz nach dem Fragezeichen (?): id=1. Dieser wird als HTTP-Query-String bezeichnet und beinhaltet eine Variable (id) und einen Wert (1), die mit einem Gleichheitszeichen (=) verbunden sind. URL-Parameter dieser Art werden beispielsweise eingesetzt, um eine dynamische Webpage zu erzeugen, Inhalte aus einer Datenbank zu laden oder ein passendes Template aufzurufen.

Dynamische Webseiten ermöglichen eine Trennung von Inhalt und Präsentation. Die „index.php“ beinhaltet zwar alle Informationen über die Struktur der Website, muss jedoch noch mit Inhalten befüllt werden. Diese sind in der Regel in einer Datenbank hinterlegt und lassen sich über die Parameter im HTTP-Query-String abrufen. In unserem Beispiel übergibt die URL der „index.php“ den Parameter: id=1. Dieser legt fest, welche Inhalte aus der Datenbank ausgelesen und in die „index.php“ geladen werden sollen. Bei einem Weblog handelt es sich meist um die ID eines bestimmten Artikels. In einem Forum ließe sich so ein bestimmter Eintrag abrufen und in einem Onlineshop ein bestimmtes Produkt.

Beinhaltet eine URL mehr als einen Parameter, werden diese mit einem Et-Zeichen (&) verbunden.

www.beispiel-blog.de/index.php?page=article&id=1

Um den Einsatz von $_GET an einem Codebeispiel zu veranschaulichen, kommen wir auch ohne Datenbank aus. In folgendem Skript verwenden wir die Superglobal $_GET, um die Werte der Variablen vorname und nachname aus einem HTTP-Query-String auszulesen und in die PHP-Variablen $variable1 und $variable2 zu schreiben:

<?php
$variable1 = $_GET['vorname'];
$variable2 = $_GET['nachname'];
echo "Hello " . $variable1 . " " . $variable2 . "!";

Der Aufruf der des Skripts erfolgt durch folgende URL:

localhost/hello.php?vorname=John&nachname=Doe

Wir übergeben somit die Parameter vorname=John und nachname=Doe. Die Ausgabe der Werte erfolgt wie bisher mithilfe des Sprachkonstrukts echo.

Close

Eine Datenübergabe via $_GET führt zwangsläufig dazu, dass die übertragenen Daten in der Adresszeile sichtbar sind. Es lässt sich somit jederzeit nachvollziehen, welche Parameter übergeben werden. Dies hat den Vorteil, dass Variablen in Hyperlinks gespeichert werden können. Zudem haben Internetnutzerinnen und -nutzer die Möglichkeit, URLs inklusive HTTP-Query-String als Lesezeichen im Browser abzulegen.

Dass GET-Parameter in Klartext in der URL aufgeführt werden, disqualifiziert diese Methode jedoch für die Übergabe sensibler Daten, wie sie beispielsweise bei Onlineformularen anfallen. Darüber hinaus ist der Umfang der Daten, die Mittels $_GET übergeben werden können, durch die Maximallänge von URLs begrenzt.

Datenübergabe via $_POST

Die HTTP-Methoden GET und POST unterscheiden sich in der Art der Datenübergabe: Während die zu übertragenden Daten bei der GET-Methode als URL-Parameter übergeben werden, erfolgt die Datenübergabe via $_POST im Body einer HTTP-Anfrage. Dies ermöglicht es, auch große Datenmengen von einem Skript an ein anderes zu übergeben.

Ein zentrales Anwendungsfeld der HTTP-POST-Methode ist die Übertragung von HTML-Formulardaten. Wir demonstrieren das am Beispiel einer Newsletter-Anmeldung. Erstellen Sie dazu eine neue PHP-Datei mit dem Namen „seite1.php“ und übernehmen Sie folgenden Codeblock:

<form method="post" action="seite2.php" >
Bitte senden Sie den Newsletter an: <br />
Ihr Vorname: <input type="text" name="vorname" /><br />
Ihr Nachname: <input type="text" name="nachname" /><br />
Ihre E-Mail-Adresse: <input type="text" name="email" /><br />
<input type="submit" value="Formular absenden" />
</form>

Zur Erstellung von Formularen kommt das HTML-Element <form> zum Einsatz. Dieses enthält im Start-Tag zwei Attribute: method und action. Mit dem method-Attribut definieren Sie die Übertragungsmethode, in diesem Fall HTTP-POST. Im action-Attribut wird die URL eines Skripts hinterlegt, das sämtliche Daten empfängt, die über nachfolgende Eingabefelder erfasst werden. Das Beispiel zeigt ein HTML-Formular mit drei Eingabeelementen (input type="text") und einem Absende-Button (input type="submit"). Als Empfänger der Daten ist die Datei „seite2.php“ definiert.

Um die Datenübergabe mittels $_POST zu veranschaulichen, nutzen wir für die Auswertung der Formulardaten ein einfaches Skript, das die übermittelten Werte als PHP-Variablen speichert und in Textform ausgibt. Erstellen Sie dazu eine Datei „seite2.php“ und fügen Sie folgenden Programmcode ein:

<?php
$vorname = $_POST["vorname"];
$nachname = $_POST["nachname"];
$email = $_POST["email"];
echo "Hallo " . $vorname . " " . $nachname . ", <br />
Sie haben sich mit folgender E-Mail-Adresse registriert: " . $email . ".";

Speichern Sie die beiden PHP-Dateien im „htdocs“-Ordner Ihres Testservers und rufen Sie „seite1.php“ über folgende URL im Webbrowser auf: http://localhost/seite1.php. Ihr Browser zeigt Ihnen nun die interaktive Weboberfläche Ihres HTML-Formulars.

Close

Geben Sie beliebige Anmeldedaten ein und drücken Sie den Absende-Button, um Variablen von einem Skript zum anderen zu übertragen. Sobald Sie die Eingabe auf „seite1.php“ bestätigt haben, werden Sie umgehend auf „seite2.php“ weitergeleitet. Das Browserfenster zeigt das Ergebnis der Skriptausführung auf Basis der übermittelten Daten.

Close

Nutzereingaben, die über die Inputfelder von „seite1.php“ erfasst werden, werden von „seite2.php“ über folgendes Schema abgerufen:

$_POST["Name des Inputfeldes"]

So ruft die Zeile $vorname = $_POST["vorname"] die Eingabe im Inputfeld vorname ab und speichert diese in der Variable $vorname. Die Variable $vorname wiederum lässt sich mittels echo als String ausgeben.

Das if-Konstrukt und die PHP-Vergleichsoperatoren

Bisher haben wir Variablen definiert, diese von einem Skript zum nächsten übertragen und als String ausgegeben. Im nächsten Schritt werden Sie lernen, die Ausführung von Codefragmenten an bestimmte Bedingungen zu knüpfen.

Das Sprachkonstrukt if gibt Ihnen die Möglichkeit, Skripte so zu schreiben, dass Anweisungen erst dann zum Tragen kommen, wenn eine durch Sie definierte Bedingung erfüllt ist – beispielsweise die Eingabe eines korrekten Passworts.

Bedingungen werden in PHP nach folgendem Grundgerüst definiert:

<?php
if(expression)
{
statement;
}

Dieses liest sich folgendermaßen: Nur dann, wenn die Bedingung in der expression erfüllt ist, wird das statement ausgeführt. Erfüllt ist eine Bedingung immer dann, wenn das if-Konstrukt das Ergebnis TRUE (wahr) zurückgibt. Andernfalls gilt diese als FALSE (falsch). In diesem Fall wird die Anweisung übersprungen.

In der Regel prüft das if-Konstrukt, ob der Wert einer Variablen dem entspricht, was in der Bedingung definiert wurde. Realisiert wird diese Kontrollstruktur normalerweise auf Basis von Vergleichsoperatoren.

Vergleichsoperatoren

Vergleichsoperatoren kommen bei der Formulierung von Bedingungen zum Einsatz, um zwei Argumente in eine logische Beziehung setzen, die als wahr (TRUE) oder falsch (FALSE) evaluiert werden kann. Kommen Vergleichsoperatoren in PHP-Kontrollstrukturen zum Einsatz, werden diese auf zwei Variablen in der expression eines if-Konstrukts angewendet:

if ($a == $b)
{
statement;
}

Versprachlicht lautet die Kontrollstruktur: Wenn Variable $a ist gleich Variable $b gilt, dann werden die im statement definierten Anweisungen ausgeführt.

Die PHP-Vergleichsoperatoren sind an die Programmiersprache C angelehnt und unterscheiden sich in ihrer Schreibweise zum Teil erheblich von den klassischen Symbolen der Mathematik. Eine Übersicht finden Sie in nachstehender Tabelle.

Folgendes Skript soll diese Kontrollstruktur verdeutlichen. Verglichen werden zwei Integers. Als Vergleichsoperator kommt < (ist kleiner) zum Einsatz:

<?php
$zahl1 = 10;
$zahl2 = 20;
if($zahl1 < $zahl2) {
echo "Die Bedingung ist erfüllt";
}

Wir definieren die Variablen $zahl1 und $zahl2 und weisen diesen die Werte 10 und 20 zu. Im Anschluss stellen wir eine Bedingung auf: Wenn $zahl1 kleiner ist als $zahl2, soll der in der echo-Anweisung aufgeführte String ausgegeben werden.

Das Ergebnis der Skriptausführung enthält die Antwort: 10 ist kleiner als 20. Das if-Konstrukt gibt das Ergebnis TRUE zurück. Die Bedingung ist erfüllt.

Close

Möchten Sie Anweisungen definieren, die ausgeführt werden, sobald eine Bedingung nicht erfüllt wurde, ergänzen Sie die if-Kontrollstruktur um das Sprachkonstrukt else zu einem If-Else-Statement in PHP:

<?php
if(Bedingung a)
{
Anweisung b;
}
else
{
Anweisung c;
}

Auch dieses Skript prüft, ob die Bedingung a das Ergebnis TRUE oder FALSE zurückgibt. Ist die Bedingung a erfüllt, wird Anweisung b ausgeführt. Ist die Bedingung a nicht erfüllt (FALSE), wird Anweisung b übersprungen und stattdessen Anweisung c ausgeführt.

Wir erweitern unser Skript um das else-Konstrukt und tauschen den Vergleichsoperator < (ist kleiner) gegen == (ist gleich):

<?php
$zahl1 = 10;
$zahl2 = 20;
if($zahl1 == $zahl2)
{
echo "Die Bedingung ist erfüllt";
}
else
{
echo "Die Bedingung ist nicht erfüllt";
}

Diesmal gibt das if-Konstrukt das Ergebnis FALSE zurück. Der Wert der Variable $zahl1 ist nicht gleich dem Wert der Variable $zahl2. Die Bedingung ist nicht erfüllt. Es wird somit nicht die unter if aufgeführte Anweisung ausgeführt, sondern die unter else definierte.

Close

Die Negation von Bedingungen erfolgt durch ein vorangestelltes Ausrufezeichen (!).

<?php
$zahl1 = 10;
$zahl2 = 20;
if ($zahl1 == $zahl2)
{
echo "Die Zahlen sind gleich.";
}
if (!($zahl1 == $zahl2))
{
echo "Die Zahlen sind nicht gleich.";
}

Das Beispiel zeigt die Bedingung $zahl1 == $zahl2 und deren Verneinung. !($zahl1 == $zahl2) entspricht ($zahl1 != $zahl2).

Eine praktische Anwendung von if und else ist beispielsweise die Passwortabfrage auf Basis eines HTML-Formulars. Wir simulieren diese erneut mithilfe unserer PHP-Dateien „seite1.php“ und „seite2.php“.

Öffnen Sie „seite1.php“ und fügen Sie folgenden Formularcode ein:

<form action="seite2.php" method="post">
Bitte geben Sie Ihr Passwort ein: <input type="password" name="passwort" />
<input type="submit" value="Absenden" />
</form>

Der Aufbau entspricht dem bereits erstellten Formular. Diesmal genügt uns jedoch ein Eingabefeld: die Passwortabfrage. Wie zuvor werden Benutzereingaben an das Skript „seite2.php“ übermittelt.

Dieses passen wir mit folgendem Code so an, dass die Passworteingabe mit einem hinterlegten Passwort abgeglichen wird:

<?php
$passwort = $_POST["passwort"];
if($passwort=="qwertz123")
{
echo "Das Passwort war korrekt";
}
else
{
echo "Das Passwort war falsch";
}

Der Code liest sich wie folgt: Zunächst weisen wir der Variable $passwort in Zeile 2 einen Wert zu, den wir über die HTTP-POST-Methode abrufen. Im Anschluss definieren wir folgende Kontrollstruktur: Das if-Kontrukt in Zeile 3 soll prüfen, ob der Wert der Variable $passwort mit dem String qwertz123 übereinstimmt. Ist dies der Fall, wird der String „Das Passwort war korrekt“ ausgegeben. Gibt if das Ergebnis FALSE zurück, kommt else in Zeile 7 zum Einsatz und es wird der String „Das Passwort war falsch“ ausgegeben.

Nun rufen wir das Skript „seite1.php“ über die URL http://localhost/seite1.php auf.

Close

Der Browser präsentiert uns die Webansicht unseres HTML-Formulars zur Passwortabfrage. Wir kommen der Aufforderung nach, geben das in Skript „seite2.php“ definierte Passwort „qwertz123“ ein und klicken auf den Absenden-Button.

Close

Der Webbrowser leitet uns automatisch auf „seite2.php“ um. Im Hintergrund gleicht die if-Kontrollstruktur unsere Eingabe mit dem hinterlegten Passwort ab und kommt zu dem Ergebnis „qwertz123 == qwertz123 ist TRUE“ und gibt den String „Das Passwort war korrekt“ aus. Testen Sie selbst, was passiert, wenn Sie ein abweichendes Passwort in das Eingabefeld tippen.

Logische Operatoren

Bedingungen, die Sie mithilfe von Vergleichsoperatoren in der Expression des if-Konstrukts definieren, lassen sich bei Bedarf mit weiteren Bedingungen in derselben Expression verknüpfen. PHP stützt sich dabei auf die logischen Operatoren AND und OR.

Um Bedingungen zu verknüpfen, stehen Ihnen in PHP logische Operatoren mit enger und mit schwacher Bindung zur Verfügung. Nutzen Sie lediglich eine der beiden Schreibweisen, werden Sie in der Praxis keinen Unterschied bemerken. Kombinieren Sie beide Schreibweisen, werden Sie feststellen, dass && und || enger binden als AND und OR. Vergleichbar ist dies mit der Operator-Rangfolge, wie sie von mathematischen Operatoren bekannt ist (z. B. Punkt vor Strich: * bindet enger als +).

Ein praxisnahes Beispiel bietet wiederum die Passwortabfrage. In der Regel umfassen Anmeldedaten ein geheimes Passwort sowie einen Benutzernamen. Nur wenn beide Eingaben mit den im System hinterlegten Daten übereinstimmen, ist der Log-in erfolgreich.

Wir öffnen erneut unser Formular zur Passwortabfrage in „Seite1.php“ und ergänzen ein Eingabefeld für den Benutzernamen:

<form action="seite2.php" method="post">
Benutzername: <input type="text" name="username" /><br />
Passwort: <input type="password" name="passwort" /><br />
<input type="submit" value="Absenden" />
</form>

Im nächsten Schritt müssen wir auch die Kontrollstruktur des if-Konstrukts anpassen. Wir nutzen dazu den logischen Operator AND, um die Bedingung für die Passwortabfrage mit einer Bedingung für die Abfrage des Benutzernamens zu verknüpfen.

<?php
$username = $_POST["username"];
$passwort = $_POST["passwort"];
if($username=="John Doe" AND $passwort=="qwertz123")
{
echo "Willkommen im internen Bereich " . $username . "!";
}
else
{
echo "Zugriff fehlgeschlagen";
}

Unser Skript „seite2.php“ bekommt nun die Werte für username und passwort übergeben und speichert diese in den Variablen $username und $passwort. Die Expression des if-Konstrukts enthält nun zwei Bedingungen, die mit dem logischen Operator AND verbunden sind. Nur wenn beide Bedingungen erfüllt sind (username=="John Doe" und $passwort=="qwertz123"), gibt if das Ergebnis TRUE zurück.

Da wir durch das Eingabefeld username den Benutzernamen erhalten, können wir diesen direkt für die Textausgabe via echo verwenden: Auf „Willkommen im internen Bereich“ folgt der Wert der Variable $username. Ist eine der beiden Bedingungen nicht erfüllt, erhalten wir die Textausgabe: „Zugriff fehlgeschlagen“.

Close

Logische Operatoren lassen sich beliebig kombinieren. Dabei gilt: AND hat eine höhere Operator-Rangfolge als OR. Wie bei mathematischen Gleichungen können Sie auch bei PHP Klammern nutzen, um die Rangfolge zu beeinflussen.

Bedingungen mit match

Bisher haben wir Entscheidungen in PHP mit if- und else-Anweisungen umgesetzt. Wenn jedoch ein einzelner Wert geprüft wird und je nach Wert unterschiedliche Ergebnisse entstehen sollen, kann der Code mit if schnell unübersichtlich werden. Genau für solche Fälle gibt es die Anweisung match.

<?php
$status = 404;
echo match ($status) {
200 => "OK",
404 => "Nicht gefunden",
default => "Unbekannter Status",
};

In diesem Beispiel wird der Wert der Variable $status geprüft. Entspricht er dem Wert 200, liefert match den Text „OK“ zurück. Ist der Wert 404, wird „Nicht gefunden“ gesetzt. Trifft keiner der genannten Werte zu, greift der default-Fall und es wird „Unbekannt“ verwendet.

Close

Der wichtigste Unterschied zu if-else besteht darin, dass match direkt einen Wert zurückgibt, der einer Variablen zugewiesen werden kann. Dadurch entfällt mehrfaches Schreiben von Zuweisungen innerhalb einzelner Bedingungen, und der Code bleibt kürzer, übersichtlicher und leichter verständlich.

Schleifen (while, for)

Manchmal ist es notwendig, dass ein Skript einen bestimmten Codeabschnitt mehrmals durchläuft, bevor der restliche Programmcode ausgeführt wird. Programmiersprachen nutzen dafür das Konzept der Schleife – auch PHP-Loops genannt. Dabei unterscheidet man drei Typen von Schleifen:

• while-Schleifen
• do-while-Schleifen
• for-Schleifen

while-Schleifen

Bei der while-Schleife handelt es sich um den simpelsten Schleifentyp, der Ihnen in PHP zur Verfügung steht. Der Grundaufbau entspricht folgendem Schema:

while (Bedingung)
{
Schleifenschritt und andere Anweisungen
}

Die while-Schleife weist PHP an, untergeordnete Anweisungen so lange auszuführen, wie die while-Bedingung erfüllt ist. Dazu prüft der PHP-Interpreter die Bedingung zu Beginn eines jeden Schleifendurchgangs. Gestoppt wird die Ausführung des untergeordneten Codes erst dann, wenn die while-Bedingung nicht mehr erfüllt ist.

Veranschaulichen lässt sich dieses Prinzip an einem einfachen Zählskript:

<?php
$zahl = 1;
while ($zahl <= 10) {
echo $zahl++ . "<br />";
}

Im Abschnitt „Rechnen mit Variablen“ wurde das Prinzip des Inkrementierens eingeführt. In folgendem Skript greifen wir darauf zurück, nutzen diesmal jedoch einen Post-Inkrement-Operator, um den Wert der Integer-Variable $zahl pro Schleifendurchgang erst nach der Textausgabe via echo um 1 zu erhöhen. Als Bedingung für die while-Schleife definieren wir: $zahl kleiner/gleich 10. Die Anweisung echo wird somit so lange wiederholt, bis die $zahl einen Wert größer 10 angenommen hat.

Close

Das Ergebnis der Skriptausführung ist ein String, der für jeden Schleifendurchgang den Wert der Variable $zahl ausgibt, bevor dieser inkrementiert wird. Das Skript zählt somit von 1 bis 10 und beendet die Codeausführung, sobald die while-Bedingung nicht mehr erfüllt ist.

do-while-Schleifen

Der Aufbau der do-while-Schleife gleicht dem der while-Schleife. Der Unterschied ist nur, dass die Bedingung nicht am Anfang jedes Schleifendurchgangs, sondern erst am Ende geprüft wird. Das Grundschema einer do-while-Schleife entspricht folgendem Beispiel:

do {
Schleifenschritt und andere Anweisungen
}
while (Bedingung)

Als do-while-Schleife programmiert, würde das vorhergehende Skript folgendermaßen aussehen:

<?php
$zahl = 1;
do {
echo $zahl++ . "<br />";
}
while ($zahl <= 10);

Das Ergebnis bleibt in diesem Fall das Gleiche. Das Besondere an der do-while-Schleife ist, dass diese mindestens einmal durchlaufen wird, selbst wenn die Bedingung in keinem Schleifendurchgang erfüllt wird.

for-Schleifen

Grundsätzlich hat die for-Schleife in einem PHP-Skript dieselbe Funktionalität wie die while-Schleife. Anders als bei dieser werden Startwert, Bedingung und Anweisung jedoch innerhalb einer Zeile notiert und nicht über drei oder mehr Zeilen verteilt. Der Grundaufbau der for-Schleife entspricht folgendem Schema:

for (Startwert; Bedingung; Schleifenschritt)
Anweisungen

Das bereits bekannte Beispiel ließe sich somit als for-Schleife in kompakter Form notieren:

<?php
for($zahl = 1; $zahl <= 10; $zahl++) {
echo $zahl . "<br /> ";
}

Zunächst wird für die Variable $zahl der Wert „1“ definiert. Dann prüft PHP, ob die Bedingung $zahl <= 10 erfüllt ist. Trifft dies zu, wird die Schleife fortgesetzt und die Anweisungen unterhalb der Schleife werden ausgeführt (hier die Anweisung echo). Erst danach wird der Schleifenschritt ausgeführt; in diesem Fall spielt es keine Rolle, ob Sie Prä- oder Post-Inkrementierung wählen, weil diese Anweisung auf jeden Fall vor der Ausgabe ausgeführt wird. Ist der Schleifenschritt abgeschlossen, beginnt der nächste Schleifendurchgang.

Startwert, Bedingung und Schleifenschritt sind optionale Elemente einer for-Schleife. Theoretisch sind selbst leere Schleifen möglich. Diese wären jedoch redundant.

Grundsätzlich ist es Ihnen überlassen, ob Sie Ihre PHP-Skripte mit einer for- oder einer while-Schleife schreiben. Es gibt jedoch ein Argument, das dafür spricht, for-Schleifen zu bevorzugen: Kommen for-Schleifen zum Einsatz, haben Sie die Rahmendaten der Schleife besser im Blick. Dies beugt der Gefahr vor, aus Versehen eine Forever-Schleife zu schreiben, die so lange läuft, bis der Speicher des Interpreters voll ist. Dies passiert Ihnen in Bezug auf das vorhergehende Beispiel dann, wenn Sie vergessen, den Wert der Variable $zahl zu erhöhen.

Soll die Schleife unabhängig von der Bedingung jedoch mindestens einmal durchlaufen werden, ist die do-while-Schleife die Schleife der Wahl.

break und continue

Der Ablauf einer while-, do-while- oder for-Schleife lässt sich durch die Anweisungen break und continue beeinflussen. Nutzen Sie break, um den Ablauf einer Schleife an einer beliebigen Stelle zu unterbrechen, und continue, um einen Schleifendurchgang zu überspringen. Beide Anweisungen werden mittels if an eine Bedingung gebunden. Folgendes Beispiel zeigt unser Zählskript mit einem break:

<?php
for ($zahl = 1; $zahl <= 10; $zahl++) {
if ($zahl == 5) {
echo "Bei 5 brechen wir das Skript ab!";
break;
}
echo $zahl . "<br /> ";
}

In der for-Schleife haben wir definiert, dass der Wert der Variable $zahl ausgehend von einem Startwert 1 in jeder Schleifenrunde um den Wert 1 erhöht werden soll, bis die Variable den Wert 10 erreicht hat. Diese Schleife stoppen wir nun vorzeitig mit der Anweisung break, sobald $zahl den Wert 5 erreicht hat. Das Sprachkonstrukt echo gibt somit lediglich die Zahlen 1 bis 4 aus.

Close

Möchten wir lediglich die Ausgabe der fünften Runde überspringen, nicht jedoch den gesamten Schleifenablauf stoppen, ersetzen wir die Anweisung break durch continue:

<?php
for ($zahl=1; $zahl <= 10; $zahl++) {
if ($zahl == 5) {
echo "Die 5 lassen wir aus!<br />";
continue;
}
echo $zahl . "<br /> ";
}

Statt der Ziffer 5 gibt uns PHP den unter if definierten Textstring „Die 5 lassen wir aus!“ aus.

Close

Dateioperationen

Dynamischen Webinhalten liegt eine Trennung von Inhalt und Präsentation zugrunde. Skriptsprachen wie PHP stellen daher verschiedene Funktionalitäten zur Verfügung, die es ermöglichen, Inhalte aus externen Datenquellen in zentrale Template-Files zu laden. In der Praxis handelt es sich bei diesen Datenquellen meist um Datenbanken, die mithilfe von Managementsystemen wie MySQL verwaltet werden. Darüber hinaus besteht die Möglichkeit, Daten aus Dateien einzubinden. Im Folgenden zeigen wir Ihnen, wie Sie Dateien als String in einem PHP-Skript einlesen und Textausgaben Ihres Skripts in Dateien speichern.

Dateien einlesen

Um den Inhalt einer Datei einzulesen, stellt PHP diverse Funktionen bereit, von denen sich für unsere Zwecke insbesondere file() und file_get_contents() anbieten. Während die Funktion file_get_contents() den gesamten Inhalt einer Datei in einen String liest, speichert die Funktion file() den Inhalt als Array. Jedes Element des Arrays entspricht einer Zeile der Datei. Mittels file() ist es somit einfacher möglich, jede Zeile einzeln auszugeben.

Wir demonstrieren die PHP-Dateioperationen an der Textdatei „beispiel.txt“, die wir im Ordner „htdocs“ unseres Testservers ablegen. Inhalt der Datei sind vier Zeilen Blindtext:

Close

Zunächst lesen wir die gesamte Datei als String ein. Dazu müssen wir der Funktion file_get_contents() den Namen der entsprechenden Datei als Parameter zuweisen. Dies geschieht nach folgendem Schema:

file_get_contents('beispiel.txt')

Nun haben wir die Möglichkeit, mit dem eingelesenen String zu arbeiten. Wir können diesen beispielsweise einer Variablen zuweisen und als Text im Webbrowser ausgeben:

<?php
$beispiel = file_get_contents('beispiel.txt');
echo $beispiel;

In der Browseransicht sehen wir, dass der Textstring ohne Absätze ausgeben wird. Die Zeilenumbrüche der Originaldatei werden nicht sichtbar. Dies hängt damit zusammen, dass der Webbrowser die Textausgabe des Skripts als HTML-Code interpretiert. Umbrüche, die in Texteditoren definiert wurden, gehen dabei verloren.

Close

Möchten Sie an der ursprünglichen Struktur festhalten, haben Sie verschiedene Möglichkeiten. Sie können die HTML-Codierung für den Zeilenumbruch (<br>) in der Ausgangsdatei manuell mittels Suchen und Ersetzen ergänzen, ein <pre> um den Datei-Inhalt setzen, dem Bereich die CSS-Eigenschaft white-space: pre-wrap zuweisen oder Sie nutzen die Funktion nl2br(), um PHP zu signalisieren, dass Zeilenumbrüche automatisch in HTML-Zeilenumbrüche umgewandelt werden sollen. Die Funktion verwenden Sie nach folgendem Schema:

<?php
$beispiel = file_get_contents('beispiel.txt');
echo nl2br($beispiel);

Wird das Sprachkonstrukt echo in Kombination mit nl2br() verwendet, fügt PHP vor jeder neuen Zeile einen HTML-Zeilenumbruch ein.

Close

Möchten Sie die Zeilen einer Datei einzeln ausgeben, bietet sich die Funktion file() an. Diese liest eine Datei ein, nummeriert alle Zeilen beginnend mit 0 durch und speichert deren Inhalte als Elemente eines Arrays. Übertragen auf unser Beispiel ergibt sich somit folgende Zuordnung:

[0] = Lorem ipsum dolor sit amet, consectetuer adipiscing elit

[1] = Aenean commodo ligula eget dolor. Aenean massa.

[2] = Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.

[3] = Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.

Um die jeweiligen Inhalte mittels echo auszugeben, müssen Sie lediglich die gewünschte Zeilennummer angeben. So liefert uns das folgende Skript beispielsweise lediglich die erste Zeile der Datei „beispiel.txt“ als Ausgabe für den Browser:

<?php
$beispiel = file("beispiel.txt");
echo $beispiel [0];

Close

Dateien schreiben

Mit PHP lassen sich nicht nur Dateien auslesen. Die Skriptsprache gibt Ihnen auch die Möglichkeit, Dateien zu erstellen und diese mit Inhalten zu beschreiben.

Wir nutzen dazu die PHP-Funktion file\_put_contents(). Diese erwartet zwei Parameter: Den Namen der Datei, die erstellt oder aktualisiert werden soll, sowie die Daten in Form eines Strings oder Arrays. Folgendes Skript erstellt die Datei test.txt und schreibt den String Das ist ein Test! in die erste Zeile. Der Zusatz \r\n führt zu einem Zeilenumbruch in der Zieldatei.

<?php
file_put_contents("test.txt", "Das ist ein Test! \r\n");
echo "test.txt wurde erstellt!";

Da uns file_put_contents keine Ausgabe für den Browser liefert, ergänzen wir eine echo-Anweisung, die uns ausgibt, welche Aktion durchgeführt wird.

Close

Findet sich im Zielordner bereits eine gleichnamige Datei, wird diese überschrieben. Dies verhindern Sie, indem Sie den Parameter FILE_APPEND setzen:

<?php
file_put_contents("test.txt","Der Test war erfolgreich! \r\n", FILE_APPEND);
echo "test.txt wurde aktualisiert!";

Nutzen Sie file_put_contents() mit dem Parameter FILE_APPEND, werden neue Inhalte an bereits bestehende angehängt.

Close

Was PHP in die Zieldatei schreibt, muss nicht zwangsläufig im Skript definiert werden. Alternativ haben Sie die Möglichkeit, Inhalte von einer Datei in eine andere zu übertragen. Folgendes Skript liest den Inhalt von beispiel.txt aus und fügt diesen in die Datei test.txt ein:

<?php
$beispiel = file_get_contents("beispiel.txt");
file_put_contents("test.txt", $beispiel, FILE_APPEND);
echo "test.txt wurde aktualisiert!";

Objektorientierte Programmierung

Die objektorientierte Programmierung (OOP) ist eine Methode, um Programme in kleine, überschaubare Bausteine, die sogenannten Objekte, zu unterteilen. Jedes Objekt gehört zu einer Klasse, die beschreibt, welche Eigenschaften und Methoden es besitzt. Eigenschaften sind dabei Variablen, die Merkmale des Objekts speichern, während Methoden Funktionen sind, die das Objekt ausführen kann. OOP hilft, den Code besser zu strukturieren, wiederverwendbar zu machen und leichter zu warten, insbesondere bei größeren Projekten.

Klassen

Eine Klasse ist die Vorlage für ein Objekt. Man kann sich eine Klasse wie einen Bauplan vorstellen, zum Beispiel für ein Auto, während ein Objekt das konkrete Auto ist, das nach diesem Bauplan erstellt wurde. Sie definiert, welche Daten ein Objekt enthält und welche Funktionen es ausführen kann. Im folgenden Beispiel sehen wir die Klasse Auto:

class Auto {
public string $marke;
public string $modell;
public function fahren() {
echo "Das Auto fährt!";
}
}
$meinAuto = new Auto();
$meinAuto->marke = "VW";
$meinAuto->modell = "Golf";
$meinAuto->fahren();

In diesem Beispiel wird die Klasse Auto definiert, die zwei Eigenschaften, $marke und $modell, sowie eine Methode fahren() besitzt. Danach wird ein Objekt dieser Klasse erstellt, indem $meinAuto die Klasse „Auto“ zugewiesen wird. Mit -> greifen wir auf die Eigenschaften des Objekts zu und setzen $marke auf VW und $modell auf Golf. Anschließend rufen wir die Methode fahren()auf, die den Text „Das Auto fährt!“ ausgibt. Das Schlüsselwort $this würde innerhalb der Methode auf das aktuelle Objekt verweisen.

Close

Constructor Property Promotion

Seit PHP 8.0 kann man Eigenschaften direkt im Konstruktor, also der Methode, die beim Erstellen eines Objektes einer Klasse automatisch aufgerufen wird, definieren und initialisieren. Dadurch entfällt die Notwendigkeit, sie vorher in der Klasse separat zu deklarieren, was den Code kürzer und übersichtlicher macht.

class Produkt {
public function __construct(
public string $name,
public float $preis
) {}
}
$produkt = new Produkt("Tasse", 12.99);
echo $produkt->name;
echo $produkt->preis;

In diesem Beispiel werden die Eigenschaften name und preis direkt im Konstruktor deklariert. Beim Erstellen des Objekts Produkt werden die Werte „Tasse“ und „12.99“ übergeben. Mit $produkt->name und $produkt->preis greifen wir auf die Werte zu, die automatisch gesetzt wurden. Constructor Property Promotion spart also Schreibarbeit und macht den Code einfacher zu lesen.

Interfaces

Ein Interface legt fest, welche Methoden eine Klasse haben muss, ohne deren konkrete Umsetzung vorzugeben. Klassen, die das Interface implementieren, müssen diese Methoden definieren, sodass unterschiedliche Klassen einheitlich behandelt werden können.

interface Fahrbar {
public function fahren();
}
class Auto implements Fahrbar {
public function fahren() {
echo "Das Auto fährt!";
}
}
$meinAuto = new Auto();
$meinAuto->fahren();

Hier definiert das Interface Fahrbar, dass jede implementierende Klasse eine Methode fahren() haben muss. Die Klasse Auto implementiert dieses Interface und definiert die Methode entsprechend. Anschließend wird ein Objekt der Klasse erstellt und die Methode aufgerufen, wodurch der Text „Das Auto fährt!“ ausgegeben wird.

Close

Intersection Types

Intersection Types ermöglichen es, dass ein Objekt mehrere Interfaces gleichzeitig erfüllen können muss. Das ist besonders praktisch, wenn eine Funktion sicherstellen soll, dass ein Objekt bestimmte Fähigkeiten besitzt.

interface JsonSerializable {}
interface Loggable {}
function speichere(JsonSerializable&Loggable $objekt) {
echo "Objekt kann JSON speichern und protokollieren";
}

In diesem Beispiel müssen Objekte, die an die Funktion speichere() übergeben werden, sowohl das Interface JsonSerializable als auch Loggable implementieren. Die Kombination der beiden Interfaces wird durch das & dargestellt. Dadurch ist garantiert, dass die Funktion nur Objekte verwendet, die beide Eigenschaften besitzen.

Readonly Properties

Readonly Properties können nur einmal beim Erstellen eines Objekts gesetzt werden und danach nicht mehr verändert werden. Das ist besonders nützlich, um sensible Daten vor unbeabsichtigten Änderungen zu schützen.

class Benutzer {
public function __construct(
public readonly string $name
) {}
}
$benutzer = new Benutzer("Max");
echo $benutzer->name;

In diesem Beispiel wird die Eigenschaft name direkt im Konstruktor gesetzt und als readonly markiert. Das bedeutet, dass der Wert „Max“ nach der Erstellung des Objekts nicht mehr verändert werden kann. Versuche, den Wert später zu ändern, führen zu einem Fehler. Readonly Properties eignen sich gut für Daten, die unveränderlich bleiben sollen, wie Benutzer-IDs oder Konfigurationswerte.

Property Hooks

Property Hooks erlauben es seit PHP-Version 8.4, Logik direkt beim Setzen oder Auslesen einer Eigenschaft auszuführen. Das ist praktisch, wenn Werte automatisch verarbeitet werden sollen.

class User {
public string $email {
set => strtolower($value);
get => strtoupper($this->email);
}
}
$user = new User();
$user->email = "Test@Example.com";
echo $user->email;

In diesem Beispiel wird beim Zuweisen eines Werts an die Eigenschaft email automatisch alles in Kleinbuchstaben umgewandelt, während beim Auslesen automatisch alles in Großbuchstaben dargestellt wird. Dadurch kann man Daten konsistent verarbeiten, ohne zusätzliche Methoden schreiben zu müssen.

Asymmetrische Sichtbarkeit

Mit asymmetrischer Sichtbarkeit, die ebenfalls erst mit PHP-Version 8.4 eingeführt wurde, kann man festlegen, dass eine Eigenschaft öffentlich gelesen, aber nur intern innerhalb der Klasse geschrieben werden darf. Das schützt wichtige Daten vor unkontrollierten Änderungen.

class Konto {
public private(set) float $guthaben = 0.0;
public function einzahlen(float $betrag) {
$this->guthaben += $betrag;
}
}
$konto = new Konto();
$konto->einzahlen(50);
echo $konto->guthaben;

In diesem Beispiel kann das Guthaben des Kontos öffentlich ausgelesen werden, aber nur innerhalb der Klasse verändert werden. Die Methode einzahlen() erlaubt eine kontrollierte Erhöhung des Guthabens. Versuche, direkt auf $guthaben zu schreiben, führen zu einem Fehler. Auf diese Weise können wichtige Daten geschützt werden, während der Zugriff für erlaubte Operationen weiterhin möglich bleibt.

Sauberen PHP-Code schreiben

Mit zunehmender Größe eines Projektes steigt auch die Bedeutung von gut strukturiertem und sauber geschriebenem Code. Sauberer PHP-Code ist leichter zu lesen, einfacher zu warten und weniger fehleranfällig. PHP-Anwendungen folgen deshalb bestimmten Konventionen und nutzen Werkzeuge, die Ordnung, Übersicht und Sicherheit fördern.

Composer und PSR-4 (automatisches Laden von Klassen)

Composer ist ein zentrales Werkzeug in der PHP-Entwicklung. Es dient dazu, externe Bibliotheken zu verwalten und PHP-Klassen automatisch zu laden. Ohne Composer müssten Klassen mit require oder include manuell eingebunden werden, was bei größeren Projekten schnell unübersichtlich wird. Composer nutzt in der Regel den Autoload-Standard PSR-4. Dieser Standard legt fest, wie Klassen anhand ihres Namens und ihres Speicherorts gefunden werden. Der Name einer Klasse entspricht dabei der Ordnerstruktur, in der sie gespeichert ist.

Ein einfaches Beispiel verdeutlicht dieses Prinzip. Befindet sich eine Klasse User im Namespace App\Model, liegt die entsprechende Datei in einem Ordner „src/Model“:

<?php
namespace App\Model;
class User {
public function getName() {
return "Max Mustermann";
}
}

Dank PSR-4 kann diese Klasse an jeder Stelle im Projekt verwendet werden, ohne die Datei manuell einzubinden. PHP lädt sie automatisch, sobald sie benötigt wird. Das macht den Code übersichtlicher und reduziert Fehlerquellen.

Namespaces für klare Trennung von Code

Namespaces helfen dabei, Klassen logisch zu gruppieren und Namenskonflikte zu vermeiden. In kleinen Skripten ist es problemlos möglich, Klassen einfach User oder Database zu nennen. In größeren Anwendungen kann es jedoch vorkommen, dass mehrere Klassen denselben Namen tragen, aber unterschiedliche Aufgaben erfüllen. Durch Namespaces lassen sich diese Klassen eindeutig voneinander trennen. So kann es beispielsweise eine Klasse User für die Datenbank und eine weitere Klasse User für die Darstellung im Frontend geben, ohne dass es zu Konflikten kommt.

Folgendes Beispiel zeigt die Verwendung eines Namespaces:

<?php
namespace App\Service;
class Mailer {
public function send() {
echo "E-Mail wurde versendet.";
}
}

Beim Einsatz der Klasse wird der vollständige Name inklusive Namespace verwendet oder per use eingebunden. Dadurch bleibt der Code eindeutig und gut strukturiert.

Projektstruktur: .env-Dateien und .gitignore

Eine klare Projektstruktur ist ein wichtiger Bestandteil sauberen PHP-Codes. PHP-Projekte trennen den eigentlichen Programmcode von öffentlich erreichbaren Dateien und Konfigurationsdaten. Häufig liegt der PHP-Code in einem eigenen Ordner, während der Webserver nur auf ein öffentliches Verzeichnis zugreifen darf.

Konfigurationswerte wie Datenbank-Zugangsdaten oder API-Schlüssel werden meist nicht direkt im Code gespeichert. Stattdessen nutzt man sogenannte .env-Dateien, in denen solche Werte zentral abgelegt werden. Das erhöht die Sicherheit und erleichtert den Wechsel zwischen Entwicklungs- und Produktivumgebung.

Ein einfaches Beispiel für eine .env-Datei könnte so aussehen:

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=secret

Diese Datei wird bewusst nicht in der Versionsverwaltung gespeichert. Dafür sorgt die .gitignore-Datei, die festlegt, welche Dateien oder Ordner von Git ignoriert werden sollen. In der .gitignore wird die .env-Datei explizit ausgeschlossen, damit sensible Daten nicht versehentlich veröffentlicht werden.

Fehlerbehandlung und Logging

Der Umgang mit Fehlern unterscheidet sich zwischen Entwicklungs- und Produktivumgebung. Während der Entwicklung ist es sinnvoll, PHP-Fehlermeldungen direkt anzuzeigen. Dadurch lassen sich Probleme schnell erkennen und beheben.

In produktiven Anwendungen sollten Fehlermeldungen hingegen nicht sichtbar sein, da sie interne Informationen preisgeben könnten. Stattdessen werden Fehler in Logdateien geschrieben, die nur für Entwicklerinnen und Entwickler zugänglich sind.

In einer Entwicklungsumgebung kann die Fehlerausgabe beispielsweise so aktiviert werden:

<?php
ini_set('display_errors', 1);
error_reporting(E_ALL);

In einer produktiven Umgebung wird die Anzeige von Fehlern deaktiviert und das Logging aktiviert. PHP schreibt auftretende Fehler dann in eine Logdatei, ohne diese den Besucherinnen und Besuchern der Webseite anzuzeigen. So bleibt die Anwendung stabil und sicher, während Fehler dennoch nachvollziehbar dokumentiert werden.

Datenbank-Basics mit PHP: Ein einfaches PDO-Beispiel

Um Daten mit PHP zu speichern oder auszulesen, benötigt man eine Datenbank. In diesem Beispiel verwenden wir MySQL, das standardmäßig in XAMPP enthalten ist. PHP kann über PDO, also PHP Data Objects, sicher mit der Datenbank kommunizieren. PDO stellt sicher, dass Befehle korrekt ausgeführt werden und dass Benutzereingaben keine Sicherheitslücken verursachen.

Datenbank und Tabelle erstellen

Zuerst erstellen wir in phpMyAdmin eine neue Datenbank mit dem Namen testdb. Innerhalb dieser Datenbank legen wir eine Tabelle namens users an. Diese Tabelle enthält drei Spalten: id für die eindeutige Identifikation jedes Benutzers, username für den Benutzernamen und email für die E-Mail-Adresse. In SQL sieht das so aus:

CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) NOT NULL,
email VARCHAR(100) NOT NULL
);

Datenbankoperationen in PHP

Jetzt erstellen wir eine Datei „crud.php“ im XAMPP-Ordner „htdocs“. Wir stellen in diesem Beispiel eine Verbindung zur Datenbank her zeigen zunächst die grundlegenden Operationen CREATE, READ, UPDATE und DELETE (CRUD):

<?php
// Verbindung zur Datenbank herstellen
$host = '127.0.0.1';
$db = 'testdb';
$user = 'root';
$pass = '';
$charset = 'utf8mb4';
$dsn = "mysql:host=$host;dbname=$db;charset=$charset";
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, // Fehler sichtbar machen
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, // Daten als Array
];
try {
$pdo = new PDO($dsn, $user, $pass, $options);
} catch (PDOException $e) {
echo "Verbindung fehlgeschlagen: " . $e->getMessage();
exit;
}
// CREATE: neuen User einfügen
$stmt = $pdo->prepare("INSERT INTO users (username, email) VALUES (:username, :email)");
$stmt->execute([
'username' => 'Max Mustermann',
'email' => 'max@example.com'
]);
// READ: alle User auslesen
$stmt = $pdo->query("SELECT * FROM users");
$users = $stmt->fetchAll();
// Ausgabe der Benutzerliste
echo "<h2>Benutzerliste</h2>";
foreach ($users as $user) {
echo "ID: " . $user['id'] . " – Name: " . htmlspecialchars($user['username']) . " – E-Mail: " . htmlspecialchars($user['email']) . "<br>";
}
// UPDATE: E-Mail eines Users ändern
$stmt = $pdo->prepare("UPDATE users SET email = :email WHERE username = :username");
$stmt->execute([
'email' => 'max.mustermann@example.com',
'username' => 'Max Mustermann'
]);
echo "<p>Die E-Mail-Adresse von Max Mustermann wurde aktualisiert.</p>";
// DELETE: User löschen
$stmt = $pdo->prepare("DELETE FROM users WHERE username = :username");
$stmt->execute([
    'username' => 'Max Mustermann'
]);
?>

Zuerst wird mit PDO eine Verbindung zur Datenbank aufgebaut. Wir geben dazu Host, Datenbankname, Benutzername, Passwort und Zeichensatz an. PDO sorgt dafür, dass SQL-Befehle sicher ausgeführt werden und Fehler sichtbar werden.

Anschließend zeigen wir die vier grundlegenden Operationen:

• CREATE (Einfügen von Daten): Mit INSERT INTO fügen wir einen neuen User ein. Die Platzhalter :username und :email sorgen dafür, dass Benutzereingaben sicher verarbeitet werden.
• READ (Daten auslesen): Mit SELECT * FROM users holen wir alle vorhandenen Datensätze. Mit fetchAll() speichern wir die Ergebnisse in einem Array und geben sie in einer übersichtlichen Liste aus.
• UPDATE (Daten ändern): Mit UPDATE können wir die E-Mail-Adresse eines Users ändern. Wir verwenden wieder Platzhalter, um die Werte sicher einzusetzen.
• DELETE (Daten löschen): Mit DELETE FROM users WHERE username = :username entfernen wir einen bestimmten User aus der Datenbank. Der Platzhalter :username sorgt dafür, dass die Eingabe sicher verarbeitet wird, ohne dass ein Angreifer die Datenbank manipulieren kann. So können wir gezielt einzelne Datensätze löschen, ohne die ganze Tabelle zu beeinflussen.

Sichere Benutzereingaben und Datenverarbeitung

Sobald PHP mit Benutzereingaben arbeitet, entsteht ein Sicherheitsrisiko. Besucherinnen und Besucher können Formularfelder manipulieren, unerwartete Daten senden oder gezielt versuchen, eine Anwendung zu missbrauchen. Deshalb stellt PHP verschiedene Funktionen bereit, mit denen Eingaben geprüft, verarbeitet und sicher gespeichert werden können.

Daten sicher in Datenbanken speichern: Prepared Statements

Eine der häufigsten Sicherheitslücken in PHP-Anwendungen entsteht bei der Arbeit mit Datenbanken. Werden Benutzereingaben direkt in SQL-Abfragen eingebaut, kann eine sogenannte SQL-Injection auftreten. Dabei schleusen Angreiferinnen und Angreifer eigenen SQL-Code ein.

Prepared Statements verhindern dieses Problem, indem SQL-Code und Benutzerdaten strikt voneinander getrennt werden. PHP stellt dafür die Datenbankschnittstelle PDO zur Verfügung.

<?php
$stmt = $pdo->prepare("SELECT * FROM users WHERE username = :username");
$stmt->execute([
'username' => $username
]);

Der Code bereitet eine Datenbankabfrage vor, mit der alle Nutzenden aus der Tabelle users gesucht werden, deren Benutzername einem bestimmten Wert entspricht. Statt den Benutzernamen direkt in den SQL-Befehl zu schreiben, wird der Platzhalter :username verwendet, der erst beim Ausführen der Abfrage mit einem konkreten Wert gefüllt wird. Dadurch trennt PHP den SQL-Code von den Benutzerdaten und verhindert, dass Eingaben den Befehl manipulieren können.

Ausgaben absichern: Output-Escaping

Nicht nur das Speichern von Daten, sondern auch deren Ausgabe kann gefährlich sein. Gibt man Benutzereingaben ungefiltert im Browser aus, kann sogenanntes Cross-Site-Scripting (XSS) auftreten. Dabei wird schädlicher Code im Browser anderer Nutzerinnen und Nutzer ausgeführt. Um das zu verhindern, werden Ausgaben maskiert. In PHP geschieht dies meist mit der Funktion htmlspecialchars() und der Text wird angezeigt, aber nicht als Code interpretiert.

<?php
echo htmlspecialchars("<h1>Hello World!</h1>", ENT_QUOTES, 'UTF-8');

Close

Benutzereingaben filtern: filter_input()

PHP bietet mit filter_input() eine Möglichkeit, Benutzereingaben bereits beim Einlesen zu prüfen und zu bereinigen. So lassen sich ungültige oder unerwünschte Werte frühzeitig erkennen.Ein einfaches Beispiel ist das Einlesen einer E-Mail-Adresse:

<?php
$email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);

Ist die Eingabe keine gültige E-Mail-Adresse, liefert die Funktion false zurück. Auf diese Weise kann der Code gezielt reagieren, bevor mit den Daten weitergearbeitet wird.

Passwörter sicher speichern mit password_hash()

Passwörter dürfen niemals im Klartext gespeichert werden. Selbst eine einfache Verschlüsselung ist nicht ausreichend. PHP stellt dafür die Funktion password_hash() bereit, die Passwörter sicher hasht.

<?php
$hash = password_hash($password, PASSWORD_DEFAULT);

Beim späteren Login wird das eingegebene Passwort mit password_verify() überprüft:

<?php
if (password_verify($password, $hash)) {
echo "Login erfolgreich";
}

Der eigentliche Passwortwert ist dabei nie wieder sichtbar. Selbst bei einem Datenbankleck bleiben die Passwörter geschützt.

Schutz vor Formularmanipulation: CSRF-Tokens

Bei Formularen besteht die Gefahr, dass sie ohne Wissen der Nutzerinnen und Nutzer abgeschickt werden. Um dies zu verhindern, werden sogenannte CSRF-Tokens eingesetzt. Dabei handelt es sich um zufällige Zeichenfolgen, die bei jedem Formularaufruf neu erzeugt werden.

<?php
$_SESSION['token'] = bin2hex(random_bytes(32));

Diese Zeile erzeugt einen zufälligen, schwer erratbaren Sicherheitscode und speichert ihn in der aktuellen Sitzung des Users. Die Funktion random_bytes(32) erstellt 32 zufällige Bytes, also Rohdaten, die nicht direkt lesbar sind. Mit bin2hex() werden diese Rohdaten in eine gut lesbare Zeichenfolge aus Buchstaben und Zahlen umgewandelt. Der erzeugte Wert wird in $_SESSION['token'] gespeichert und später verwendet, um zu prüfen, ob ein Formular wirklich von derselben Sitzung stammt.

Datei-Uploads mit Validierung

Auch Datei-Uploads sind besonders sensible und können Sicherheitsrisiken einbringen, da hier fremde Dateien auf den Server gelangen. Deshalb sollten Dateityp und Dateigröße immer geprüft werden.

Ein einfaches Beispiel für eine Dateigrößenprüfung könnte so aussehen:

<?php
if ($_FILES['upload']['size'] > 1000000) {
echo "Datei ist zu groß.";
}

Der Code prüft, wie groß die hochgeladene Datei ist, und vergleicht sie mit einem festgelegten Maximalwert von 1.000.000 Bytes. Ist die Datei größer als erlaubt, wird eine Fehlermeldung ausgegeben und der Upload kann abgelehnt werden. So wird verhindert, dass zu große Dateien auf den Server geladen werden. Zusätzlich sollte geprüft werden, ob es sich wirklich um den erwarteten Dateityp handelt, etwa ein Bild. Dateien sollten niemals ungeprüft ausführbar auf dem Server abgelegt werden.