PHP lernen: Tutorial für Einsteigerinnen und Einsteiger

Inhaltsverzeichnis

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.

Webhosting

Das beste Webhosting zum Spitzenpreis

3x schneller und 60 % günstiger
Maximale Verfügbarkeit mit > 99.99 %
Nur bei IONOS: Bis zu 500 GB Speicherplatz inklusive

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

bash

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

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).

Damit Sie die Datei test.php via XAMPP ausführen können, müssen Sie diese im htdocs-Ordner platzieren.

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.

Hinweis

Bei der Funktion phpinfo() handelt es sich um die Kurzschreibweise des Standardwerts phpinfo(INFO_ALL). Dieser gibt detaillierte Informationen zur PHP-Konfiguration Ihres Webservers aus. Ist keine PHP-Version auffindbar, zeigt der Webbrowser eine Fehlermeldung oder liefert den PHP-Code, ohne diesen zu interpretieren, an den Browser aus.

„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.

Definition

Sprachkonstrukte sind Anweisungen, die in PHP dazu genutzt werden, den Programmablauf zu steuern. Zu den Sprachkonstrukten zählen neben echo Anweisungen wie if, for, do, include, return, exit oder die. Daher sind in diesem Fall anders als bei Funktionen keine Klammern nötig.

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

<?php
echo 'Hello World!';

php

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.

Tipp

Der schließende PHP-Tag ?> muss bei reinen PHP-Dateien nicht verwendet werden. So lassen sich versehentliche Leerzeilen oder unsichtbare Zeichen am Dateiende vermeiden, die zu Fehlermeldungen wie „Headers already sent“ führen können.

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:

Im Browser sehen Sie nun die Ausgabe „Hello World.“

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>';

php

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

Die Ausgabe kann im PHP-Skript mit HTML-Tags formatiert werden.

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:

Variablen-Typ	Beschreibung
String	Ein String ist eine Zeichenkette. Dabei kann es sich um ein Wort, einen Satz, einen Text oder den gesamten HTML-Code einer Webseite handeln.
Integer	Ein Integer ist eine Ganzzahl ohne Nachkommastellen. Diese kann positiv oder negativ sein.
Float	Ein Float ist eine Fließkommazahl, sprich ein Zahlenwert mit Nachkommastellen. Das Komma wird bei Programmiersprachen als Punkt (`.`) notiert. PHP unterstützt bis zu 14 Stellen hinter dem Komma
Boolean	Boolesche Variablen sind das Ergebnis einer logischen Operation und kennen nur zwei Werte: `TRUE` (wahr) und `FALSE` (falsch). Dieser Variablentyp kommt etwa zum Einsatz, wenn Sie mit Bedingungen arbeiten.
Array	Ein Array ist eine Variable, die mehrere Elemente beinhalten kann. Es handelt sich somit um eine Gruppierung mehrerer gleichartig strukturierter Daten, die zu einem Array zusammengefasst wurden.
Object	Der Variablen-Typ `object` ermöglicht es Programmierern, eigene Datentypen zu definieren. Anwendung findet er bei der objektorientierten Programmierung. In unserem PHP-Tutorial für Anfängerinnen und Anfänger klammern wir `object`-Variablen aus.
NULL	Der Wert `NULL` repräsentiert eine Variable ohne Wert. Für Variablen des Typs `NULL` ist dies der einzig mögliche Wert.
Resource	Eine Resource ist eine spezielle Variable, die eine Referenz auf externe Ressourcen enthält, z. B. eine geöffnete Datei, eine Datenbankverbindung oder einen Socket. Ressourcen werden von PHP selbst verwaltet. In unserem PHP-Tutorial für Anfängerinnen und Anfänger klammern wir `resource`-Variablen aus.

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";

php

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>";

php

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.

Variablen fungieren als eine Art Platzhalter und ermöglichen dynamische Texterstellung.

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>";

php

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

Wird eine gleichnamige Variable mehrfach definiert, überschreibt die jeweils letzte Definition die vorherige.

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

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

php

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>';

php

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

Wenn ein String in einfachen Anführungszeichen steht und dort eine Variablennennung auftaucht, wird diese nicht interpretiert.

Hinweis

Sie fragen sich nun vielleicht, was passiert, wenn Sie die Anführungszeichen ganz weglassen? In diesem Fall weist PHP sie auf einen syntaktischen Fehler hin.

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);

php

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!;

php

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.

Fehler werden jederzeit im XAMPP-Log angezeigt.

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!\' ';

php

Der Backslash dient in PHP als Maskierungszeichen.

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

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

php

Nicht jedoch diese Schreibweise:

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

php

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>";

php

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.

Mit zwei Variablen können Sie theoretisch genau verfahren wie mit einer einzigen.

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>';

php

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

String1		Variable1		String2		Variable2		String3
‘<h1>Hello World!</h1><p>This dynamic web page was created by’	.	`$author1`	.	’ and ’	.	`$author2`	.	‘<\p>’

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.

Es ist gute Programmierpraxis, mehrere Elemente bei der Ausgabe mit dem Verkettungsoperator zu konkatenieren.

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;

php

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.

Der Verkettungsoperator wird auch eingesetzt, um Variablen direkt zu konkatenieren.

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>

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>

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.

Sie können PHP-Funktionen in Ihren HTML-Code einbetten.

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!

php

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>';

php

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

Wie Sie sehen können, werden Kommentare nicht ausgegeben.

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;

php

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.

Sie können mit numerischen Variablen genau wie mit Zahlen rechnen.

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.

Arithmetischer Operator	Operation	Ergebnis
`$zahl1 + $zahl2`	Addition	Summe von `$zahl1` und `$zahl2`
`$zahl1 - $zahl2`	Subtraktion	Differenz von `$zahl1` und `$zahl2`
`$zahl1 * $zahl2`	Multiplikation	Produkt von `$zahl1` und `$zahl2`
`$zahl1 / $zahl2`	Division	Quotient von `$zahl1` und `$zahl2`
`$zahl1 ** $zahl2`	Potenz	`$zahl2`-te Potenz von `$zahl1`

<?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 />";

php

Die Ausgabe sieht wie folgt aus:

Sie können die gängigen Rechenoperationen in PHP auch mit numerischen Variablen durchführen.

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;

php

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;

php

Die Berechnungen funktionieren ebenfalls mit Fließkommazahlen.

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.

Operation	Operator	Ergebnis
Prä-Inkrement	`++$zahl`	Der Operator `++` inkrementiert den Wert der Variable `$zahl`. Dabei wird der Wert um 1 erhöht. Das Ergebnis wird als neuer Wert von `$zahl` zurückgegeben.
Prä-Dekrement	`--$zahl`	Der Operator `--` dekrementiert den Wert der Variable `$zahl`. Dabei wird der Wert um 1 vermindert. Das Ergebnis wird als neuer Wert von `$zahl` zurückgegeben.
Post-Inkrement	`$zahl++`	Der aktuelle Wert von `$zahl` wird zunächst zurückgegeben und anschließend um den Wert 1 erhöht.
Post-Dekrement	`$zahl--`	Der aktuelle Wert von `$zahl` wird zunächst zurückgegeben und anschließend um den Wert 1 vermindert.

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;

php

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

Die Prä-Inkrementierung erhöht den Wert der Variable, bevor sie ausgegeben wird, um eins.

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;

php

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>';

php

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.

Bei der Prä-Inkrementierung wird der Wert der Variable vor der Ausgabe erhöht; bei der Post-Inkrementierung danach.

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;
}

php

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;
}

php

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.

Bild: ION_DE_DG-TVC_MyWebsite_960x320.Jpg

Bild: ION_DE_DG-TVC_MyWebsite_1200x1200.png

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 . "!";

php

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.

Mit $_GET können Sie Werte für Ihre Variablen aus der URL lesen.

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.

Hinweis

Umgehen lassen sich diese Einschränkungen mit der HTTP-Methode POST. Die damit übergebenen Daten finden Sie in der Superglobal $_POST.

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>

html

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 . ".";

php

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.

Sie können im HTML-Formular nun Werte eingeben, die zu Ihrem anderen Skript übertragen werden.

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.

Die Daten wurden nun zum anderen Skript übertragen.

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;
}

php

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;
}

php

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.

Vergleichsoperator	Beschreibung	Bedingung
`==`	ist gleich	Die Bedingung ist erfüllt, wenn `$a` und `$b` den gleichen Wert aufweisen.
`===`	ist identisch	Die Bedingung ist erfüllt, wenn `$a` und `$b` den gleichen Wert aufweisen und demselben Datentyp angehören. Veranschaulichen lässt sich dies an einem Beispiel, bei dem eine Integer (1) mit einem String (“1”) verglichen wird: `1 == "1"` wird zu `TRUE` und `1 === "1"` wird zu `FALSE`. Verwenden Sie für Bedingungen, die die Gleichheit zweier Variablen voraussetzen, am besten immer den Vergleichsoperator `===` (ist identisch).
`!=`	ist ungleich	Die Bedingung ist erfüllt, wenn `$a` und `$b` ungleiche Werte aufweisen.
`!==`	nicht identisch	Die Bedingung ist erfüllt, wenn `$a` und `$b` ungleiche Werte aufweisen oder unterschiedlichen Datentypen angehören.
`<`	ist kleiner als	Die Bedingung ist erfüllt, wenn der Wert von `$a` kleiner ist als der Wert von `$b`.
`>`	ist größer als	Die Bedingung ist erfüllt, wenn der Wert von `$a` größer ist als der Wert von `$b`.
`<=`	ist kleiner oder gleich	Die Bedingung ist erfüllt, wenn der Wert von `$a` kleiner ist als der Wert von `$b` oder `$a` und `$b` den gleichen Wert aufweisen.
`>=`	ist größer oder gleich	Die Bedingung ist erfüllt, wenn der Wert von `$a` größer ist als der Wert von `$b` oder `$a` und `$b` den gleichen Wert aufweisen.

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";
}

php

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.

Der Code nach der if-Anweisung wird ausgeführt, wenn die spezifizierte Bedingung zutrifft.

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;
}

php

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";
}

php

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.

Wenn die if-Bedingung nicht zutrifft, wird der Code hinter dem else-Statement ausgeführt.

Hinweis

Soll die Ausführung eines Codefragments an die Gleichheit zweier Werte gebunden werden, kommt in PHP ein doppeltes Gleichheitszeichen (==) zum Einsatz. Das einfache Gleichheitszeichen (=) verwenden Sie ausschließlich bei der Zuweisung von Werten zu Variablen.

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.";
}

php

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>

html

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";
}

php

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.

Im Webformular können Sie nun ein Passwort eingeben.

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.

Wenn Sie das richtige Passwort eingegeben haben, greift die if-Bedingung aus dem Skript und eine Erfolgsmeldung wird angezeigt.

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.

Enge Bindung	Schwache Bindung	Beschreibung
`&&`	`AND`	Beide Bedingungen, die mit dem Operator verbunden sind, müssen `TRUE` sein.
`		`

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>

html

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";
}

php

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“.

Nur, wenn beide Bedingungen, die mit AND verknüpft sind, zu TRUE auswerten, ist die Anmeldung erfolgreich.

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",
};

php

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.

Da die Variable $status auf den Wert 404 gesetzt ist, greift der zweite Fall der match-Bedingung und wir erhalten die Meldung „Nicht gefunden“.

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
}

php

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 />";
}

php

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.

Sobald der Wert 10 erreicht ist, bricht die Schleife ab.

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)

php

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

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

php

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

php

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 /> ";
}

php

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 /> ";
}

php

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.

Mit break können Sie aus einer Schleife herausspringen, sobald eine bestimmte if-Bedingung erfüllt ist.

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 /> ";
}

php

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

Mit continue können Sie einen Schleifendurchlauf überspringen, wenn eine bestimmte Bedingung eintritt.

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:

In unserer Textdatei sind vier Beispiel-Blindtextzeilen.

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;

php

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.

Mit der Funktion file_get_contents() können Sie den Inhalt einer Datei lessn und dann in PHP verarbeiten.

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);

php

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

Mit der PHP-Funktion nl2br() können Sie Zeilenumbrüche erzeugen.

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];

php

Die Funktion file() eiget sich zum Auslesen einzelner Zeilen aus einer Datei.

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!";

php

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.

Mit der Funktion file_put_contents() können Sie Dateien schreiben.

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!";

php

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

Wenn Sie den Parameter FILE_APPEND hinzufügen, dann werden die Inhalte, die Sie file_put_contents übergeben, an Ihre Datei angehangen.

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!";

php

MyWebsite Now Plus

Erstellen Sie Ihre Firmenwebsite

Verschiedene Designs inkl. Domain und E-Mail-Adresse
Über 17.000 lizenzfreie Fotos & SEO-Funktionen
Ergänzung der Website um digitales Booking-Tool

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();

php

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.

Nachdem Sie ein Objekt der Auto-Klasse definiert haben, liefert ein Funktionsaufruf von fahren() eine entsprechende Ausgabe.

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;

php

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();

php

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.

Ein Interface definiert, dass unsere Klasse eine Methode namens fahren() beinhalten muss.

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";
}

php

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;

php

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;

php

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;

php

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";
}
}

php

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.";
}
}

php

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

txt

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);

php

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
);

sql

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'
]);
?>

php

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
]);

php

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');

php

Wenn Sie htmlspecialchars() nutzen, wird HTML-Code als einfacher String interpretiert.

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);

php

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);

php

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

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

php

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));

php

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ß.";
}

php

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.

10 Jahre Digital Guide: Eine Erfolgsgeschichte

KI-Telefonassistent: Die Live-Demo

Verpassen Sie nie wieder einen Anruf.

KI-Wissen für Ihren Erfolg

Unser Newsletter bringt Ihnen die wichtigsten Insights rund um KI – verständlich, praxisnah und auf den Punkt.

CodeIgniter – das Leichtgewicht unter den PHP-Frameworks

CodeIgniter ist ein von EllisLab entwickeltes, quelloffenes PHP-Framework, das aktuell unter der Schirmherrschaft des British Columbia Institute of Technology steht. Die schlanke Software ist an das MVC-Architekturmuster angelehnt, wird für ihre gute Performance gelobt und…

PHP
Tutorials

REDPIXEL.PLShutterstock

Python-Logging: So machen Sie mit dem Python-Logging-Modul Skriptfehler ausfindig

Python-Logging ist ein Modul in der Python-Bibliothek. Da es in den Quellcode integriert ist, können Entwickler mit wenigen Befehlen Python-Logging-to-File vornehmen – also eine Log-Datei erstellen und Hinweise an diese Datei senden, die beim Ablauf einer Anwendung geloggt…

Lexikon
Python

REDPIXEL.PLShutterstock

PHP 8: Alle Informationen zur neuen Version

PHP ist eine der wichtigsten Sprachen im Internet. Viele Content-Management-Systeme, etwa WordPress, TYPO3 oder Joomla, basieren auf PHP. Mit dem Release von PHP 8 sind nun diverse neue Features eingeführt worden. Auch einige alte Funktionen wurden überarbeitet, sodass es zu…

REDPIXEL.PLShutterstock

PHP vs. Python – Die beiden Programmiersprachen im Vergleich

Im Duell PHP vs. Python hat wohl jeder Entwickler einen Favoriten. Beide Programmiersprachen haben eine große Fangemeinde und gehören zu den besten Optionen auf dem Markt. Hier erfahren Sie, welche Unterschiede und Gemeinsamkeiten die beiden haben, wo ihre Stärken und Schwächen…

PHP
Lexikon
Python

Howard MarshShutterstock

E-Mails versenden mit PHPMailer – so wird’s gemacht!

Die Mail-Erweiterung PHPMailer bietet sich vor allem für Kontaktformulare auf Websites und für den Versand automatisch generierter E-Mails an. Wir zeigen Ihnen, wie Sie PHPMailer installieren können und wie Sie Schritt für Schritt E-Mails mit PHPMailer versenden. Erfahren Sie…

PHP
Tutorials

REDPIXEL.PLShutterstock

PHP installieren: So richten Sie die Skriptsprache ein

Wenn Sie im Bereich der Webentwicklung aktiv sind, stehen Sie früher oder später vor der Aufgabe, PHP zu installieren. Damit Ihnen die Installation der verbreiteten Skriptsprache leicht von der Hand geht, haben wir eine Schritt-für-Schritt-Anleitung für Sie zusammengestellt.…

PHP
Tutorials

PHP lernen: Tutorial für Ein­stei­ge­rin­nen und Ein­stei­ger

PHP-Tutorial: Was Sie mit­brin­gen sollen

XAMPP

PHP Built-in Server

Docker und Docker-Compose

PHP-Grund­la­gen: Die Syntax der Skript­spra­che

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

Variablen

Strikte Ty­pi­sie­rung mit declare(strict_types=1)

Feh­ler­mel­dun­gen und Mas­kie­rung

Ver­ket­tungs­ope­ra­to­ren

PHP in HTML einbinden

Die PHP-Kom­men­tar­funk­ti­on

Rechnen mit Variablen

Skalare Typen und Union Types

Die Su­per­glo­bals $_GET und $_POST

Da­ten­über­ga­be via $_GET

Da­ten­über­ga­be via $_POST

Das if-Konstrukt und die PHP-Ver­gleichs­ope­ra­to­ren

Ver­gleichs­ope­ra­to­ren

Logische Ope­ra­to­ren

Be­din­gun­gen mit match

Schleifen (while, for)

while-Schleifen

do-while-Schleifen

for-Schleifen

break und continue

Da­tei­ope­ra­tio­nen

Dateien einlesen

Dateien schreiben

Ob­jekt­ori­en­tier­te Pro­gram­mie­rung

Klassen

Con­s­truc­tor Property Promotion

In­ter­faces

In­ter­sec­tion Types

Readonly Pro­per­ties

Property Hooks

Asym­me­tri­sche Sicht­bar­keit

Sauberen PHP-Code schreiben

Composer und PSR-4 (au­to­ma­ti­sches Laden von Klassen)

Name­spaces für klare Trennung von Code

Pro­jekt­struk­tur: .env-Dateien und .gitignore

Feh­ler­be­hand­lung und Logging

Datenbank-Basics mit PHP: Ein einfaches PDO-Beispiel

Datenbank und Tabelle erstellen

Da­ten­bank­ope­ra­tio­nen in PHP

Sichere Be­nut­zer­ein­ga­ben und Da­ten­ver­ar­bei­tung

Daten sicher in Da­ten­ban­ken speichern: Prepared State­ments

Ausgaben absichern: Output-Escaping

Be­nut­zer­ein­ga­ben filtern: filter_input()

Pass­wör­ter sicher speichern mit password_hash()

Schutz vor For­mu­lar­ma­ni­pu­la­ti­on: CSRF-Tokens

Datei-Uploads mit Va­li­die­rung

PHP lernen: Tutorial für Einsteigerinnen und Einsteiger

PHP-Tutorial: Was Sie mitbringen sollen

PHP-Grundlagen: Die Syntax der Skriptsprache

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

Strikte Typisierung mit declare(strict_types=1)

Fehlermeldungen und Maskierung

Verkettungsoperatoren

Die PHP-Kommentarfunktion

Die Superglobals `$_GET` und `$_POST`

Datenübergabe via `$_GET`

Datenübergabe via `$_POST`

Das `if`-Konstrukt und die PHP-Vergleichsoperatoren

Vergleichsoperatoren

Logische Operatoren

Bedingungen mit `match`

Schleifen (`while`, `for`)

`while`-Schleifen

`do-while`-Schleifen

`for`-Schleifen

`break` und `continue`

Dateioperationen

Objektorientierte Programmierung

Constructor Property Promotion

Interfaces

Intersection Types

Readonly Properties

Asymmetrische Sichtbarkeit

Composer und PSR-4 (automatisches Laden von Klassen)

Namespaces für klare Trennung von Code

Projektstruktur: .env-Dateien und .gitignore

Fehlerbehandlung und Logging

Datenbankoperationen in PHP

Sichere Benutzereingaben und Datenverarbeitung

Daten sicher in Datenbanken speichern: Prepared Statements

Benutzereingaben filtern: `filter_input()`

Passwörter sicher speichern mit `password_hash()`

Schutz vor Formularmanipulation: CSRF-Tokens

Datei-Uploads mit Validierung