PHP lernen - Tutorial

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

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-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: phpinfo( INFO_ALL ). Jede Anweisung endet mit einem Semikolon (;). Um die Skript-Umgebung zu schließen, kommt der schließende PHP-Tag zum Einsatz: ?>.

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

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, das den Beginn des PHP-Codes ankündigt. 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.

Wurde PHP korrekt installiert, sollten Sie nun folgende Webseite als Ergebnis der Skriptausführung angezeigt bekommen:

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.

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!. Mit dem Tag ?> beenden Sie das Skript. Achten Sie auf das Semikolon nach der Anweisung. Statt Hello World! kann ein beliebiger Text verwendet werden.

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:

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.

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 PHP-Nutzerinnen und -Nutzern 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 sieben 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.

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.

Hier zeigt sich die Stärke von PHP: Inhalte lassen sich als Variablen einbinden. Dieses Feature ist die Grundlage dynamischer Webentwicklung. Im Gegensatz zu statischen Webpages, die bereits als fertig auslieferbare HTML-Seiten vorliegen, werden dynamische Webpages erst im Augenblick des Seitenaufrufs erzeugt. Dabei lädt der PHP-Interpreter die einzelnen Elemente der angeforderten Webpage mithilfe von Variablen aus verschiedenen Datenbanken und setzt diese zu einer individuell auf die Anfrage abgestimmten HTML-Seite zusammen.

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.

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

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.

Fehlermeldungen und Maskierung

Kommt es zu syntaktischen Fehlern, liegt kein valider PHP-Code vor und 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.

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:

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

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öchte 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.

Unter 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 jedoch, dass auch PHP die Trennung von String und Variable einfordert, wenn wir mit Funktionsaufrufen oder komplexeren Variablen arbeiten. Es empfiehlt 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.

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

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:

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

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 das Hashtag (#) oder zwei aufeinander folgende 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!
?>

Der Texteditor Notepad++ hebt Kommentare grün 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.

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 $zahl1und*$zahl2* die Ganzzahlen 237 und 148 zu und definieren im Anschluss eine Variable $ergebnis. Diese soll die Summe der Variablen $zahl1und*$zahl2* speichern. Dazu bedienen wir uns des arithmetischen Operators +(Plus). Abschließend geben wir das Additionsergebnis mithilfe des Sprachkonstruktsecho als Text aus. Beachten Sie, dass Sie bei der Zuweisung von Zahlenwerten zu Variablen keine Anführungszeichen benötigen.

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
?>

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

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

Wie alle 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.

Um das Prä-Dekrement der Variable $zahlzu 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.

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 $_GETund$_POST**– vordefinierteSystem-Variablen, die in allen Gültigkeitsbereichen verfügbar sind. Als assoziative Arrays (Datenfelder) speichern*$_GETund$_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 $_GETund*$_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 $_GETund*$_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 inOnlineshopsundInternetforen 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 Style-Sheets – 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 vornameundnachnameaus einem HTTP-Query-String auszulesen und in die PHP-Variablen $variable1und*$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=Johnundnachname=Doe. Die Ausgabe der Werte erfolgt wie bisher mithilfe des Sprachkonstrukts echo.

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

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

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: methodundaction. 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.

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.

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 $zahl1und*$zahl2* und weisen diesen die Werte 10und20 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.

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

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

<?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 ifundelse ist beispielsweise die Passwortabfrage auf Basis eines HTML-Formulars. Wir simulieren diese erneut mithilfe unserer PHP-Dateien seite1.phpundseite2.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.

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 quertz123 ein und klicken auf den Absenden-Button.

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

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 ORund*||* enger binden als ANDundOR. Zudem binden ANDund*&&* enger als ORund*||*. 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 usernameundpasswort übergeben und speichert diese in den Variablen $usernameund*$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.

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.

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-Schliefe definieren wir: $zahl größer/gleich 10. Die Anweisung echo wird somit so lange wiederholt, bis die $zahl einen Wert größer 10 angenommen hat.

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-*Schliefe 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 <= 1 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 breakundcontinue 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.

Möchten wir lediglich die 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.

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. Wie das funktioniert, erfahren Sie in unserem MySQL-Tutorial.

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()undfile_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:

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.

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 Browser-Ansicht 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.

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 (new lines) automatisch in HTML-Zeilenumbrüche (breaks) 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.

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

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.

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.

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