Anfang

PHP ist eine Programmiersprache, die am Server ausgeführt wird. Dort wird sie "geparsed", das heißt, der Code wird umgewandelt, so dass für den Nutzer nur mehr ganz normaler HTML-Code sichtbar ist. Das hat den großen Vorteil, dass eigentlich niemand deinen Code klauen kann - weil er ihn einfach nie zu Gesicht bekommt.

Der Nachteil ist leider, dass du nicht wie beim HTML-Dokumenten mal eben nachschauen kannst, wie etwas geht - weil du es eben nicht siehst.

Jedoch unterstützt nicht jeder Webserver standardmäßig PHP. Daher musst du entweder vorher mit dem Provider, den du für deine eigene Homepage hast abklären, ob es möglich ist, oder du probierst es einfach einmal aus (* test.php). Eine Alternative ist es, PHP auf deinem Computer zu Hause zu testen. Du kannst jedoch nicht so einfach eine PHP Datei aufrufen und bekommst alles richtig angezeigt, sondern du musst dir davor einen virtuellen Webserver installieren.

*
Um zu testen, ob auf deinem Server PHP zur Verfügung steht, lege eine Text-Datei mit dem Namen test.php an (z. B. mit dem Windows Editor oder einem anderen Texteditor - bitte nicht Word oder ähnliches verwenden) und schreibe in diese Datei:
<?php
phpinfo();
?>
Diese Datei lädst du dann auf deinen Server hoch und rufst sie über die Adresszeile deines Browsers auf. Du solltest dann eine ziemlich lange Auflistung angezeigt bekommen. Falls nicht, brauchst du noch nicht verzweifeln. Du kannst als Dateinamen auch noch test.php3 oder test.php4 ausprobieren (es ist möglich, dass dein Provider nur diese Endungen unterstützt). Geht es dann noch immer nicht, hast du mit sehr großer Wahrscheinlichkeit keine PHP-Unterstützung.


Da der virtuelle Webserver, mit dem ich zu Beginn gearbeitet habe, mittlerweile nicht mehr funktioniert, möchte ich dir XAMPP ans Herz legen. Mit XAMPP kannst du dir einen eigenen Server in Versionen für verschiedene Betriebssysteme downloaden. Da auf Apachefriends.org sehr gute Anleitungen sowohl für die Installation, als auch für Konfiguration und Verwendung zur Verfügung gestellt werden, gehe ich hier nicht weiter darauf ein. Wenn du den Webserver installiert hast, geht es hier weiter.

Bist du soweit? Wenn dein Webserver funktioniert kannst du Dateien, die im "Pfad zu Xampp"\xampp\htdocs-Ordner liegen in deinem Browser über http://localhost/dateiname aufrufen. Vorsicht ! - Es funktioniert nicht, wenn du die Dateien im Explorer (oder im Arbeitsplatz) mit einem Doppelklick startest - dabei wird der Server nicht angesprochen. Das erfolgt nur wenn du localhost verwendest).

Damit hätten wir das Schwierigste erst mal geschafft, du wirst sehen, so schwer ist das alles gar nicht.

Ein paar Bemerkungen noch vorweg:

Jetzt schauen wir mal, wie man ganz normalen Text anzeigen lassen kann :-))


Text ausgeben

Lernt man eine neue Programmiersprache, soll als erstes die Ausgabe des Textes "Hello World" gelernt werden. Es kommt dabei nicht so sehr auf den Text an (von mir aus kannst du auch "Hallo Uhu" verwenden), als viel mehr darauf, dass eine Anzeige von Text zu den absolut elementaren Dingen zählt.

Wir legen daher eine Datei mit dem Namen hallo.php an und schreiben in diese Datei nur
<?php
echo "Hello World";
?>
Die Farben brauchst du natürlich nicht. Das nennt sich Syntax-Highlighting und dient dazu, den Code einfacher lesbar zu machen. Das ganze wird abgespeichert und anschließend über den Browser aufgerufen (... localhost/weitere Pfadangaben/hallo.php) oder auf deinen Webspace hochgeladen und von dort aufgerufen.

Im Browser steht jetzt einfach Hello World - vollkommen unformatiert (aber ohne dieses <?php-Zeug) - was wir ja auch wollten.

So, was heißt denn das, was wir da geschrieben haben überhaupt?
<?php
Die spitze Klammer und das Fragezeichen werden immer dann verwendet, wenn man PHP verwenden möchte. Eine ähnliche Vorgangsweise ist ja auch aus HTML bekannt. Dabei werden die Befehle mit <Befehl> eingeleitet und mit </Befehl> beendet. In PHP verwenden wir <?php und ?> als Anfangs- und Endezeichen. Alles, was zwischen diesen Zeichen steht, wird als PHP-Code interpretiert.

In der nächsten Zeile steht jetzt
echo "Hello World";
Das beinhaltet zunächst die Anweisung, dass ein Text ausgegeben werden soll. Alternativ zum Befehl echo kann man auch den Befehl print verwenden. Bei mir wirst du allerdings immer echo finden, einfach weil es mir sympathischer ist.

In Anführungszeichen folgt dann der Text, der ausgegeben werden soll. Dieser Text wird beim Parsen (dem Umwandeln von PHP-Code in HTML und dem Ausführen von Befehlen) in die HTML-Datei geschrieben. In unserer Datei steht jetzt also lediglich Hello World (du kannst gerne über Quelltext anzeigen nachschauen :-))

Das abschließende Semikolon (;) ist bei jeder PHP-Anweisung notwendig. Es gibt sozusagen bekannt, wo die Anweisung zu Ende ist.

Mit dem beendenden
?>
wird der PHP-Block abgeschlossen.

Innerhalb der Anführungszeichen kannst du auch ohne Probleme HTML-Code verwenden und damit deinen Text formatieren. Das einzige, worauf du achten musst, sind Sonderzeichen.

Damit meine ich nicht die aus HTML bekannte Maskierung für Umlaute (wie &auml;) sondern Sonderzeichen für PHP.

Du hast ja oben gesehen, dass wir den Text in Anführungszeichen gesetzt haben. Das birgt das Problem, dass ein Anführungszeichen als Ende der Zeichenkette (des Textes) angesehen wird und es dadurch zu Problemen kommen kann. Wenn wir z. B. den Code
<?php
echo "Hello "World"";
?>
verwenden wollen, erscheint beim Aufrufen der Datei eine Fehlermeldung (parse error).

Um also Anführungszeichen zu verwenden, müssen wir sogenannte Maskierungszeichen einsetzten. Ein solches Maskierungszeichen ist der Backslash (\).

Der richtige Code sieht daher so aus
<?php
echo "Hello \"World\"";
?>
Jetzt wird als Text Hello "World" ausgegeben.

Beachte bitte, dass nur die Anführungszeichen, die angezeigt werden sollen, einen Backslash vorangestellt bekommen. Das einleitende und das abschließende Anführungszeichen stehen ohne ein Maskierungszeichen da.

Was passiert jetzt aber, wenn wir einen Backslash verwenden wollen? Der muss natürlich auch ein Maskierungszeichen erhalten. Also würde der Befehl zum Anzeigen von c:\windows so aussehen:
<?php
echo "c:\\windows";
?>
Ein doppelter Backslash, damit einer angezeigt wird.

Auch für Zeilenumbrüche gibt es eine Art Maskierung - \n (nicht zu verwechseln mit dem <br> bzw. <br /> für einen sichtbaren Zeilenumbruch).

Wie gesagt ist es auch problemlos möglich, HTML-Code zur Formatierung zu verwenden. Also z. B.
<?php
echo "<h2>Hallo du!</h2>";
?>
Nur muss auch hierbei darauf geachtet werden, dass Anführungszeichen einen Backslash vorangestellt bekommen.

Es ist übrigens auch kein Problem in einer Datei teilweise PHP und teilweise HTML zu verwenden:
<html>
<head>
<title>Meine Seite mit PHP</title>
</head>
<body>
<h2>Willkommen</h2>
<br />
<?php
echo "Sch&ouml;n, dass du da bist!";
?>
</body>
</html>
Den Text mit PHP ausgeben zu lassen hat in diesem Beispiel natürlich keinen Sinn. Es soll nur aufzeigen, was möglich ist. So kann man auch mehrere PHP-Bereiche in einer Datei definieren.

Das war schon der erste Punkt. Ist doch gar nicht so schwer bisher, oder?

Dann lass uns mal schauen, was Variablen sind ...


Variablen

Dann lass uns mal schauen, was Variablen sind ...

Vielleicht kennst du Variablen aus dem Mathematikunterricht. Das sind diese komischen Buchstaben, die keinen Sinn zu ergeben scheinen, aber doch so wichtig sind. In PHP werden Variablen verwendet, um Inhalte (z. B. Text oder Zahlen) darin zu speichern.

Du kannst deinen Variablen beliebige Namen geben, solltest jedoch Groß- und Kleinschreibung beachten.

Damit PHP jetzt aber auch erkennt, dass es sich bei einem Wort um den Namen einer Variable handelt wird davor ein Dollarzeichen ($) gesetzt.

Das sieht dann in etwa so aus:
<?php
$uhrzeit = "09:19 Uhr";
?>
Damit definierst du eine Variable namens uhrzeit und weist ihr den Inhalt 09:19 Uhr zu. Die Zuweisung erfolgt durch das = und dem Inhalt der Variable, der in Anführungszeichen gesetzt wird.

Beachte dabei aber bitte, dass in PHP ein Variablenname mit einem Buchstaben oder einem Unterstrich (_) beginnen muss. "2uhrzeit" wäre daher nicht möglich - _2uhrzeit jedoch schon.

Und auch hier ist wieder zum Schluss das Semikolon, um die Zeile abzuschließen.

Jetzt stellt sich natürlich die Frage, was man mit diesem Text und der Variable anfangen soll.

Nun, zum einen ist es damit ganz einfach möglich, den Text mehrmals zu verwenden, ohne ihn jedes Mal neu schreiben zu müssen. Das ist vor allem bei langen Inhalten sehr interessant.

Wenn wir jetzt also den Text Anton fuhr um 09:19 Uhr nach Wien, wo er um 09:19 Uhr ankam. schreiben wollen, verwenden wir dazu folgenden Code (in einer Zeile):
<?php
echo "Anton fuhr um ",$uhrzeit," nach Wien, wo er um ",$uhrzeit," ankam.";
?>
Das schaut jetzt auf den ersten Blick sehr kompliziert aus und ich muss auch zugeben, dass in dem Fall auch die Schreibeweise mit
<?php
echo "Anton fuhr um $uhrzeit nach Wien, wo er um $uhrzeit ankam.";
?>
möglich wäre. Da wir aber später vielleicht auch einmal 09:19 Uhr, ausgeben wollen (oder anderes, bei dem gleich nach dem Inhalt der Variable schon wieder Text kommt), ist es sinnvoll, auch die erste Fassung zu kennen.

Hierbei steht der Text, der keinen Variablennamen hat, in Anführungszeichen. Also z. B. der Teil Anton fuhr um . Danach wird das Anführungszeichen geschlossen und durch einen Beistrich getrennt wird die Variable dazugeschrieben. Nochmals eine Trennung mit Beistrich und schon kann der nächste Text in Anführungszeichen hinzugefügt werden.

Wichtig ist hierbei, dass die Leerzeichen zwischen dem Inhalt der Variable und dem Text (in dem Fall z. B. zwischen um und 09:19) innerhalb der Anführungszeichen stehen müssen, sonst werden sie nicht beachtet.

Wir könnten jetzt unseren gesamten Text durch Variablen ausgeben lassen. Entweder wir schreiben alles in eine Variable oder wir legen Satzteile an. In dem Fall machen wir es mit Satzteilen - zwecks Übung :-)
<?php
$anton = "Anton fuhr um ";
$uhrzeit = "09:19 Uhr";
$wien = " nach Wien, wo er um ";
$ankommen = "ankam.";
?>
Wenn du genau hinsiehst, erkennst du, dass ich teilweise die Leerzeichen gleich in den Variablen abgespeichert habe - jedoch nicht überall. Dadurch kannst du jetzt am PHP-Code sehr gut den Unterschied erkennen.
<?php
echo "$anton$uhrzeit$wien$uhrzeit $ankommen";
?>
Jetzt werden die einzelnen Teile des Satzes (also die Variablen) einfach aneinander gereiht. Da beim "ankam" das Leerzeichen davor fehlt, binde ich es durch das Leerzeichen nachträglich ein.

Eine kleine Besonderheit haben diese Variablen jetzt noch: man kann sie erweitern.

Wir verwenden jetzt die Variable $text und verlängern (erweitern) diese.
<?php
$text = "Heute ist";
$text .= " Mittwoch!";
?>
Siehst du den Punkt vor dem zweiten Ist-Gleich? Durch den Punkt wird die Variable $text so erweitert, dass Heute ist Mittwoch! darin enthalten ist.

Wenn du keinen Punkt verwenden würdest, würde die Variable zunächst den Text Heute ist enthalten und dann durch Mittwoch! überschrieben werden, da durch das reine Ist-Gleich ein neuer Wert zugewiesen wird.

Du kannst den Punkt auch verwenden, um Variablen miteinander zu verbinden.
<?php
$kompletter_Satz = $anton.$uhrzeit.$wien.$uhrzeit.$ankommen;
?>
Wenn wir diese Variable jetzt ausgeben, fehlt natürlich wieder unser Leerzeichen, das wir ebenfalls einbinden können. Das sieht dann so aus:
<?php
$kompletter_Satz = $anton.$uhrzeit.$wien.$uhrzeit." ".$ankommen;
?>
Der normale Text wird ebenfalls mit Punkten verbunden, muss jedoch in Anführungszeichen gesetzt werde.

Ich weiß, das klingt jetzt einmal ziemlich kompliziert, aber sobald du ein paar Mal Variablen verwendet hast, wirst du dich daran gewöhnen :-))


Variablen übergeben

Übergabe per Formular

So, wie wir bisher mit Variablen gearbeitet haben, müssen diese von Anfang an festgelegt sein. Es kann jetzt aber auch der Fall sein, dass wir die Variablen erst später festlegen wollen bzw. diese durch eine Benutzereingabe füllen wollen.

Ein Beispiel dazu kannst du dir hier (Popup) anschauen.

Bei diesem Script wird durch ein Formular der Inhalt des Feldes übergeben und auf der darauf folgenden Seite ausgegeben.

Ganz wichtig ist es hierbei, dass die Formularfelder einen eindeutigen Namen bekommen, da dieser Name als Variablenname verwendet wird.

Die erste Seite, die beim Beispiel angezeigt wird sieht so aus (nur das Formular ohne CSS-Anweisungen):
<form action="form2.php" method="post">
<input type="text" size="17" name="Inhalt">
<input type="submit" value="OK">
</form>
Die erste Zeile ruft ein Formular auf, bei dem durch das action festgelegt wird, welche Datei nach dem Absenden aufgerufen werden soll. Du kennst das vielleicht mit cgi-Programmen. Dort steht dann action="sendmail.cgi" oder Ähnliches. Ebenfalls wird hier festgelegt, dass als method post verwendet werden soll.


post contra get

Als Übertragungsmethoden hast du prinzipiell post und get zur Verfügung. Bei PHP werden wir fast immer post verwenden. Der Unterschied besteht darin, dass durch get eine URL aufgerufen wird, an die sämtliche Formulardaten angehängt werden. Nun ist aber die maximale Länge von URLs beschränkt und wenn zuviel Inhalt mitgeschickt werden soll, funktioniert es daher nicht mehr.

So würde in unserem Fall diese URL so aussehen (falls "Claudia" in das Feld eingetragen wurde):

http://www.schattenbaum.net/php/form2.php?Inhalt=Claudia

Überträgt man die Daten jedoch mittels post können beliebig lange Inhalte mit übertragen werden, da diese nicht in eine URL umgewandelt werden, sondern durch Steuerungsanweisungen des Browsers übermittelt werden.

Das Umstellen auf get kann jedoch dann sinnvoll sein, wenn man überprüfen möchte ob und welche Daten übertragen werden.


Durch die folgende Zeile wird ein Text-Input-Feld mit einer Größe von 17 definiert und diesem Feld wird der Name Inhalt zugewiesen. Danach kommt nur Leerzeichen (hervorgerufen durch die Zeilenschaltung) und ein Submitbutton - die Value-Angabe beim Submitbutton ist gleichzeitig seine Beschriftung.

Wenn du das mit den Formularen gerade nicht vestehst, empfehle ich dir, dich mit Formularen in HTML zu beschäftigen.

Aber was steht jetzt in der form2.php, die ja durch unser Formular aufgerufen wird?
Und jetzt kann ich deinen Namen (oder das, was du in das Feld geschrieben hast) anzeigen lassen:
<br /><br />
<?php
echo $_POST["Inhalt"];
?>
<br /><br />
Wie das funktioniert erf&auml;hrst du, wenn du das Fenster wieder schlie&szlig;t.
Du erinnerst dich daran, dass unser Input-Feld den Namen Inhalt hatte? Genau dieses Feld (bzw. der Inhalt des Feldes) wird jetzt ausgegeben. Das "Inhalt" wird zum Namen der Variable und ist dadurch für uns ansprechbar. Eine Sicherheitseinstellung in PHP sorgt zusätzlich dafür, dass wir uns sicher sein können, dass die Variable via post übergeben würde. Dafür reicht es aber nicht, einfach nur den Variablennamen zu schreiben, sondern wir müssen $_POST["Variablenname"]; verwenden. Es ist grundsätzlich sinnvoll, wenn man zusätzlich überprüft, ob der Inhalt der Variable tatsächlich etwas ist, das wir haben wollen (also in unserem Fall ein Name/Text und nicht etwa Code). Das würde jedoch jetzt zu weit gehen, daher arbeiten wir an dieser Stelle ohne weitere Überprüfung. Bezüglich Sicherheitsrisiken bei der Übergabe von Variablen, wirf bitte einen Blick auf die sehr gute Seite von Daniel Fett Wenn man diese Variable öfter in einer Seite verwendet oder einfach der besseren Übersicht wegen kann es auch sinnvoll sein, die Variablen vor dem Einsatz wieder in einen "kurzen Variablennamen" umzuschreiben. Das sieht dann so aus:
$Inhalt = $_POST["Inhalt"];
Wurde die Variable per get übergeben, verwendet man anstatt _POST _GET. Ansonsten funktioniert es genauso.

Verwendest du jedoch bei Feldname (in form1.php) und Variablenname (in form2.php) eine unterschiedliche Schreibweise (z. B. große bzw. kleine Anfangsbuchstaben) so bekommst du einfach nichts angezeigt.

Jedes Feld in deinem Formular ist über den Namen, den du ihm gegeben hast ansprechbar. Du musst allerdings auch hier beachten, dass du keine Zahlen an den Anfang stellen darfst. Der Name "01Absender" ist daher nicht möglich. Du solltest daher darauf achten, dass du keinen Feldnamen doppelt verwendest.

Übergabe per URL

Da du aber nicht immer ein Formularfeld verwenden kannst, wenn du Daten übergeben willst, kannst du dies auch mittels einer Url machen.

Dabei gibst du zunächst ganz normal den Namen der Datei an ...
test.php
... und verbindest dann durch ein Fragezeichen den Namen der 1. Variable ...
test.php?Vorname
... auch hier erfolgt die Zuweisung des Inhaltes durch ein Ist-Gleich ...
test.php?Vorname=Claudia
... Weitere Variablen kannst du mit einem kaufmännischen Und (&) anhängen (dabei brauchst du kein weiteres Fragezeichen) ...
test.php?Vorname=Claudia&Nachname
... und auch dieser Variable wird ein Inhalt zugeordnet ...
test.php?Vorname=Claudia&Nachname=Unkelbach
In der Datei test.php kannst du jetzt durch $_GET["Vorname"] und $_GET["Nachname"] auf die Inhalte (Claudia bzw. Unkelbach) der Variablen zugreifen.

Das sieht dann z. B. so aus (hier sieht man auch die Übergabe von get-Variablen):
<?php
echo "Vorname: ", $_GET["Vorname"];
echo "<br />";
echo "Nachname: ", $_GET["Nachname"];
?>
Na? Noch immer alles klar? Fein, dann können wir ja gleich weitermachen.


Mathematische Operatoren

Bisher haben wir für die Variablen immer nur Text genommen. Es ist aber genauso möglich, Zahlen dafür zu verwenden und gerade diese, werden sehr häufig dafür verwendet.

Weist man eine Zahl als Inhalt zu, darf man keine Anführungszeichen setzen (sonst wird die Zahl wie Text behandelt und man kann beispielsweise nicht mehr damit rechnen.
<?php
$zahl1 = 10;
$zahl2 = 5;
?>
Wir weisen hiermit zwei Variablen aus, geben der ersten den Namen zahl1 und den Inhalt 10 und der zweiten den Namen zahl2 mit dem Inhalt 5. Du siehst, es werden keine Anführungszeichen gesetzt - das Semikolon am Ende darf jedoch nicht fehlen.

Und jetzt schauen wir einmal, was man damit alles berechnen kann ...
<?php
$addition = $zahl1 + $zahl2;
$subtraktion = $zahl1 - $zahl2;
$multiplikation = $zahl1 * $zahl2;
$division = $zahl1 / $zahl2;
?>
Hierbei wurden den Variablen die Namen der Rechnart gegeben und anschließend eine passende Rechnung mit den vorher definierten Variablen durchgeführt. Die Rechenoperatoren sind dabei die bekannten +, -, * und /.

Im nächsten Schritt lassen wir jetzt diese Ergebnisse anzeigen:
Ergebnis der Addition: <?php echo $addition; ?>
<br />
Ergebnis der Subtraktion: <?php echo $subtraktion; ?>
<br />
Ergebnis der Multiplikation: <?php echo $multiplikation; ?>
<br />
Ergebnis der Division: <?php echo $division; ?>
In diesem Fall verwende ich jetzt eine andere Schreibeweise als sonst - es wird wirklich nur der Inhalt der Variablen durch eine PHP-Anweisung ausgegeben - der Rest steht in reinem HTML da. Du siehst also, es sind viele verschiedene Schreibweisen möglich und letztendlich musst du die finden, die dir am sympathischsten ist. Die Ausgabe sieht aber auf jeden Fall so aus:

Ergebnis der Addition: 15
Ergebnis der Subtraktion: 5
Ergebnis der Multiplikation: 50
Ergebnis der Division: 2

Wenn wir unsere Rechnung noch mit dazu anschreiben wollen, können wir es natürlich auch so machen:
<?php echo $zahl1; ?> + <?php echo $zahl2; ?> = <?php echo $addition; ?>
<br />
<?php echo $zahl1," - ",$zahl2," = ",$subtraktion; ?>
Du siehst schon, ich habe jetzt zwei verschiedene Schreibweisen verwendet. Die Ausgabe ist die gleiche und sieht so aus:

10 + 5 = 15
10 - 5 = 5

Eine Kurzform zu den bisher angeführten mathematischen Operatoren wird in PHP sehr häufig verwendet - nämlich immer dann, wenn eine Variable hochgezählt (bzw. heruntergezählt) werden soll.

Das ginge zum einen durch folgende Befehle:
<?php
$count1 = 0;
$count2 = 10;
$count1 = $count1 + 1;
$count2 = $count2 - 1;
?>
Dadurch erhält die Variable count1 zunächst den Wert 0 und wird danach auf 1 geändert, während die Variable count2 bei 10 startet und auf 9 geändert wird.

Weitaus kürzer geht es aber mit folgendem Code:
<?php
$count1 = 0;
$count2 = 10;
$count1++;
$count2--;
?>
Durch den Befehl $count1++ wird die Variable count1 um 1 erhöht und die Variable count2 durch $count2-- um eins verringert, so dass aus 0 wiederum der Wert 1 wurde und aus 10 der Wert 9. Es folgen ganz einfach 2 + bzw. - direkt nach dem Variablennamen.

Das schaut auf den ersten Blick vermutlich verwirrend aus, du wirst dich aber sicherlich innerhalb kürzester Zeit daran gewöhnen. Und falls nicht, kannst du noch immer statt $count1++ und $count2-- die Langform verwenden:
<?php
$count1 = $count1 + 1;
$count2 = $count2 - 1;
?>
Aber ich denke, du siehst schon, dass die Variante mit $count1++ und $count2-- um einiges schneller geschrieben werden kann und eigentlich viel einfacher ist :-)

Dann schauen wir uns mal als nächstes die Vergleichsoperatoren an.


Vergleichsoperatoren

Auch wenn wir bisher nur den echo-Befehl verwenden und es daher ziemlich sinnlos erscheint, zu überprüfen, ob eine Variable einen bestimmten Inhalt hat, oder ob die Inhalte zweier Variablen gleich sind, sind Vergleichsoperatoren ein sehr wichtiger Bereich in PHP, der häufig Verwendung findet.

Es gibt insgesamt sechs verschiedene Operatoren, mit denen sich Inhalte bzw. Zustände von Variablen oder Werten überprüfen lassen.

Der erste ist das Ist-Gleich.

Da ein einfaches Ist-Gleich in PHP einer Variablen einen Wert zuweist, wird für diesen Zweck ein doppeltes verwendet.
$variable1 == $variable2
10 == 10
"PHP" == "PHP"
$variable == 10
"PHP" == $variable
Es lassen sich also sowohl Variablen, als auch Werte vergleichen - oder aber auch beides gemischt.

Das Ergebnis eines solchen Vergleichs ist immer entweder true oder false.

Enthält im oberen Beispiel die variable1 also z. B. den Wert 10 und die variable2 den Wert PHP ist das Ergebnis false. Die Zeile 10 == 10 hat das Ergebnis true (auch wenn dieser Vergleich nicht gerade sinnvoll ist :-))

Das Gegenteil zu Ist-Gleich bietet der Operator Ungleich. Dieser schreibt sich !=
10 != 5
"PHP" != "CGI"
10 != 10
Auch hier ist das Ergebnis entweder wahr oder falsch (true oder false).

Die beiden ersten Zeilen des Beispiels liefern den Wert true zurück, da 10 ungleich 5 ist, bzw. PHP ungleich CGI. In der letzten Zeile wird überprüft, ob 10 ungleich 10 ist - die Antwort darauf ist jedoch false - denn 10 ist gleich 10.

Klingt jetzt verwirrend - ist aber nicht so schlimm.

Die nächsten Operatoren sind kleiner und größer als.

< steht für "kleiner als" und > für "größer als".
10 < 15
15 > 10
15 < 15
In dem Fall liefern die ersten beiden Beispiele das Ergebnis true und das letzte Beispiel false.

Es ist übrigens nicht sinnvoll, Texte mit kleiner und größer als zu vergleichen.

Die letzen beiden Vergleichoperatoren sind ganz ähnlich. Sie überprüfen jedoch nicht nur ob etwas kleiner (bzw. größer) als etwas ist, sondern zugleich, ob es gleich groß ist. Die Befehle dazu lauten <= für "kleiner gleich" und >= für "größer gleich".
10 <= 15
15 <= 15
15 >= 10
15 >= 15
In diesem Beispiel sind alle Werte true.

Keine Panik, falls das jetzt alles verwirrend ist - sobald wir ein bißchen weiter sind, wirst du den Sinn dieser Vergleichsmöglichkeiten sehen und dann kannst du auch an Hand von Beispielen ausprobieren, wie sie funktionieren.

Daher würde ich vorschlagen, wir schauen uns als nächstes gleich einmal die if-Abfragen an.


If-Anweisungen

Bisher hat PHP für uns noch keinen Vorteil gegenüber reinem HTML. Klar, wir können Variablen bestimmen - aber welchen Sinn haben diese, wenn wir dennoch nur den Text ausgeben können? Und auch unsere Rechenoperationen sind zwar recht nett, aber dafür muss man nicht wirklich PHP bemühen.

Mit einer if-Anweisung ist es jedoch möglich, eine gewisse Bedingung zu prüfen und nur dann, wenn diese Bedingung zutrifft, etwas Bestimmtes zu machen.

Das Grundgerüst einer solchen if-Anweisung sieht so aus:
<?php
if(Bedingung)
{
  Anweisung
}
?>
Die Bedingung, die überprüft werden soll, wird in ein Klammer nach dem einleitenden if gesetzt. Danach folgt in geschwungenen Klammern die Anweisung, die ausgeführt werden soll, wenn die Bedingung wahr ist.

Okay, das klingt bisher ziemlich theoretisch, also schauen wir mal, wie so eine Bedingung und eine Anweisung aussehen kann ...
<?php
if($user == "Claudia")
{
  echo "Bist du Cloud?";
}
?>
Hierbei wurde (z. B. durch eine Formulareingabe) ein Username übergeben, der in der Variable user gespeichert ist. Die if-Anweisung testet jetzt, ob der Username Claudia ist (beachte, dass hier das doppelte Ist-Gleich eingesetzt wird und nicht das einfache!). Ist das der Fall wird die Frage Bist du Cloud? ausgegeben.

Doch was passiert jetzt, wenn die Bedingung nicht wahr ist - also der Username nicht Claudia ist?

So, wie unsere if-Anweisung derzeit aussieht, passiert in dem Fall einfach nichts. Es gibt jedoch eine Erweiterung zu if - nämlich das else.

Das Grundgerüst dafür ist folgendes:
<?php
if(Bedingung)
{
  Anweisung
}
else
{
  Anweisung
}
?>
Jetzt wird zunächst die Bedingung der if-Anweisung getestet - ist diese wahr (true), wird die 1. Anweisung ausgeführt. Ist die Bedingung jedoch falsch (false) wird das ausgeführt, was als Anweisung im else-Teil festegelegt wurde - mit der 1. Anweisung passiert einfach nichts.

Auf unser Beispiel von vorher angewandt könnte das dann so aussehen:
<?php
if($user == "Claudia")
{
  echo "Bist du Cloud?";
}
else
{
  echo "Also Cloud bist du sicher nicht!";
}
?>
Auch hier wird getest, ob der Username, der in der Variable user gespeichert ist "Claudia" lautet - ist das der Fall, erfolgt die Frage "Bist du Cloud?". Ist der Username (also der Inhalt der Variable user) nicht Claudia, sondern irgendetwas anderes (bzw. gar kein Wert), so wird "Also Cloud bist du sicher nicht!" ausgegeben.

Bis hierher verständlich? Dann zeige ich dir jetzt noch, wie man mehrere if-Anweisungen verbinden kann:
<?php
if($user == "Claudia")
{
  echo "Bist du Cloud?";
}
elseif($user == "Andreas")
{
  echo "Bist du Unki?";
}
else
{
  echo "Also du bist sicher weder Cloud noch Unki!";
}
?>
In diesem Beispiel wird als erstes überprüft, ob der Username "Claudia" ist - ist das der Fall wird, wie gehabt, der 1. Text ausgegeben. Ist das nicht der Fall, wird die elseif Bedingung überprüft und getestet, ob der Username Andreas ist. Falls das der Fall ist, wird der 2. Text ausgegeben - ist das auch nicht der Fall, kommt der letzte Text, der in der else Anweisung steht.

Du kannst natürlich auch einfach eine ganz normale if-Anweisung in den else-Teil schreiben:
<?php
if($user == "Claudia")
{
  echo "Bist du Cloud?";
}
else
{
  if($user == "Andreas")
  {
    echo "Bist du Unki?";
  }
  else
  {
    echo "Also du bist sicher weder Cloud noch Unki!";
  }
}
?>
Das Prinzip hierzu ist das gleiche - zunächst wird die if-Bedingung überprüft. Ist diese falsch, wird in die else-Bedingung gesprungen. In dieser befindet sich erneut eine if-Anweisung, die geprüft wird und für den Fall, dass diese falsch ist gibt es eine weitere else-Anweisung.

Diese Variante ist jedoch umständlicher und fehleranfälliger und du musst ganz besonders darauf achten, dass du alle geschwungenen Klammern auch wieder schließt (musst du immer - jedoch treten hier leichter Fehler auf, da die geschwungenen Klammern verschachtelt werden).

if-Anweisungen sind ein sehr flexibles und vielseitiges Werkzeug, das wir sicher noch öfter verwenden werden.

Zuvor schauen wir uns aber noch an, wie man ganz einfach viele derartige if-Abfragen ausführen kann.


Switch

Wenn wir so wie in unserem vorigen Beispiel je nach User (also Inhalt der Variable) einen anderen Text ausgeben wollen, wird es umständlicher, umso mehr verschiedene Fälle wir abdecken wollen. Wir bräuchten ja für jeden Fall eine eigene if- bzw. elseif-Anweisung. Um das zu vereinfachten gibt es die Funktion switch.

Das sieht erstmal so aus:
<?php
switch($user)
{
  case ("Claudia"):
  echo "Bist du Cloud?";
  break;
}
?>
In der Klammer hinter dem switch steht die Variable, die wir überprüfen wollen - in unserem Fall also der angegebene Username ($user). Innerhalb der geschweiten Klammern geben wir jetzt den Fall (case) an, den wir behandeln wollen. Dafür schreiben wir case ("gewünschter Inhalt"):. Achte bitte darauf, dass am Ende ein Doppelpunkt kommt.

Das, was wir bei case angeben, wird überprüft ob es mit der oben angegebenen Variable entspricht. Wenn wir also schreiben case ("Claudia"): wird genauso wie bei einer if-Abfrage überprüft, ob $user == "Claudia" zutrifft.

Danach können wir angeben, was im Falle einer Übereinstimmung (also wenn der Username tatsächlich Claudia ist) tun wollen. Bei uns ist das die Ausgabe des Textes "Bist du Cloud?" mit Hilfe des echo-Befehls. Der wiederum muss mit dem üblichen Semikolon abgeschlossen werden.

Ganz wichtig hierbei ist es, dass wir danach noch break; verwenden. Damit wird die switch-Funktion an dieser Stelle abgebrochen und nichts weiter getan.

Das alleine ist jetzt eher langweilig und wir könnten es genauso gut mit einer if-Anweisung hinbekommen. Interessant wird switch jetzt aber, wenn wir mehrere Fälle überprüfen wollen. Wir erweitern das ganze also noch um die schon bekannte Überprüfung, ob der Username vielleicht nicht Claudia, sondern Andreas lautet:
<?php
switch($user)
{
  case ("Claudia"):
  echo "Bist du Cloud?";
  break;
 
  case ("Andreas"):
  echo "Bist du Unki?";
  break;
}
?>
Wie du sehen kannst, geben wir den zweiten Fall, den wir überprüfen wollen einfach darunter an, genauso wie den ersten. Sollte die Variable $user also nicht "Claudia" beinhalten, gibt die Funktion auch nicht "Bist du Cloud?" aus, sondern testet auf den nächsten festgelegten Fall, bei uns also "Andreas". Falls dieses Mal der richtige Wert in der Variable ist, führt sie den dazu gehörenden Befehl - bei uns also wiederum die Ausgabe eines Textes mittels echo - aus und endet dann. Das entspricht in unserem vorigen Beispiel mit der if-Anweisung dem elseif-Teil.

Was passiert jetzt aber, wenn wir zwei Fälle angegeben haben und keiner zutrifft?

Dafür gibt es die Angabe default:
<?php
switch($user)
{
  case ("Claudia"):
  echo "Bist du Cloud?";
  break;
 
  case ("Andreas"):
  echo "Bist du Unki?";
  break;
 
  default:
  echo "Also du bist sicher weder Cloud noch Unki!";
  break;
}
?>
Wenn die Variable $user irgendetwas beinhaltet, dass wir nicht definitiv mittels case festgelegt haben, macht die Funktion das, was unter default: steht. Bei uns gibt sie dann also den Text "Also bist du sicher weder Cloud noch Unki!" aus. Auch hier setze bitte am Ende ein break;.

Bei unserem Beispiel sieht das jetzt eher nutzlos aus. Die zwei Fälle ließen sich auch problemlos über die if- bzw. elseif-Anweisung überprüfen. Ganz anders aber, wenn wir viel mehr Möglichkeiten abdecken wollen. Für jeden Fall eine elseif-Anweisung zu schreiben ist sehr umständlich, mittels switch bzw. case geht das wesentlich schneller. Außerdem bietet die Funktion eine sehr schöne Lösung für den Fall, dass bei mehreren unterschiedlichen Inhalten der Variable das gleiche getan werden soll.

Was ich damit meine? Stell dir einfach vor, Andreas würde nicht immer "Andreas" als Name angeben, sondern auch mal "Andi" oder "Andy". Indem wir unsere "cases" erweitern, können wir das ganz einfach mit überprüfen:
<?php
switch($user)
{
  case ("Claudia"):
  echo "Bist du Cloud?";
  break;
 
  case ("Andreas"):
  case ("Andi"):
  case ("Andy"):
  echo "Bist du Unki?";
  break;
 
  default:
  echo "Also du bist sicher weder Cloud noch Unki!";
  break;
}
?>
Jetzt folgt nach dem ersten case ("Andreas"): also nicht die Anweisung, was in dem Fall getan werden soll, sondern ein weiterer möglicher Fall, der überprüft werden soll und für den das gleiche getan werden soll, wie wenn "Andreas" richtig gewesen wäre. All diese möglichen Fälle stehen untereinander, nach dem letzten kommt dann das, was getan werden soll, wieder beendet durch ein break;. Wenn jetzt also die Variable $user "Andreas", "Andi" oder "Andy" beinhaltet wird immer der Text "Bist du Unki?" ausgegeben.

Man kann natürlich nicht nur den echo-Befehl verwenden. Auch die Zuweisung von Variablen wäre möglich. Wenn du mehrere Sachen machen möchtest, schreibst du sie einfach untereinander und macht am Ende break; Also z. B..:
<?php
switch($user)
{
  case ("Claudia"):
  case ("Claudi"):
  echo "Bist du Cloud?";
  echo "<br />";
  echo "Sch&ouml;n, dich zu sehen.";
  $freude = "gro&szlig;";
  break;
 
  default:
  echo "Schade, wieder keine Cloud!";
  break;
}
?>
Damit würde also nicht nur "Bist du Cloud?" ausgegeben werden, sondern auch noch "Schön, dich zu sehen." (getrennt durch einen Zeilenumbruch, deswegen das <br>). Zusätzlich wird eine Variable $freude festgelegt, die mit dem Wert "groß" gefüllt wird. Diese könnten wir z. B. später weiter verwenden.

Man kann sogar if-Anweisungen ausführen:
<?php
switch($user)
{
  case ("Claudia"):
  case ("Claudi"):
  echo "Bist du Cloud?";
  echo "<br />";
  if($user == "Claudi")
  {
    echo " Du sollst deinen Namen doch nicht abk&uuml;rzen!";
  }
  break;
 
  default:
  echo "Schade, wieder keine Cloud!";
  break;
}
?>
Jetzt wird, wenn der Username "Claudia" oder "Claudi" ist "Bist du Cloud?" ausgegeben. Danach wird noch extra überprüft, ob der Username "Claudi" war und nur in diesem Fall kommt noch die zusätzlich Ermahnung "Du sollst deinen Namen doch nicht abkürzen!".

Die Möglichkeiten, die switch bietet sind also sehr vielfältig und auch sehr praktisch. Leider funktioniert es aber nur, wenn man überprüfen möchte, ob die Variable einen exakten Wert (oder einen exakten anderen) beinhaltet. Man kann weder mit größer oder kleiner arbeiten, noch überprüfen, ob zwei Variablen zugleich einen bestimmten Wert haben. Dafür brauchen wir wieder if-Anweisungen und wie das funktioniert erkäre ich als nächstes.


Logische Operatoren

Manchmal reicht es nicht aus, wenn man nur eine einzige Bedingung überprüft - wenn ich z. B. eine Passwortabfrage machen möchte, dann will ich wissen, ob Benutzername und Kennwort richtig sind. Eine Möglichkeit dafür wäre es, if-Anweisung so zu verschachteln, dass das richtige gemacht wird.

Das ist zwar zugegebenermaßen eine sehr schöne Übung für if-Anweisungen, aber nicht gerade dann geeignet, wenn man übersichtlichen und rasch zu programmierenden Code haben möchte.

Aus diesem Grund gibt es die logischen Operatoren. Mit diesen lassen sich Vergleiche miteinander verknüpfen.

Um bei dem Beispiel mit dem Passwort zu bleiben:
<?php
if($username == "Claudia" and $passwort == "PHP")
{
  echo "Zugriff erlaubt!";
}
?>
Hier werden die Variablen username und passwort gemeinsam überprüft und nur wenn beide Bedingungen als Ergebnis true erhalten, wird die Anweisung ausgeführt. Die Verbindung der beiden Bedingungen erfolgt über and. Das gleiche Ergebnis erzielt man mit &&. Welche Schreibweise man letztendlich verwendet ist in den meisten Fällen (und gerade für den Anfang) egal. Falls es dich näher interessiert, gibt es auf php.net weitere Infos zur Rangfolge von Operatoren.

Übrigens... das ist natürlich nicht mein Passwort ;-)))

Manchmal will man aber gar nicht, dass beide Bedingungen wahr sind, sondern ist schon mit einer zufrieden. In diesem Fall kann man einen Vergleich mittels oder durchführen.
<?php
if($username == "Claudia" or $passwort == "PHP")
{
  echo "Zugriff erlaubt!";
}
?>
Jetzt ist die Bedingung der if-Anweisung auch dann erfüllt, wenn nur einer der beiden Werte wahr ist. Das würde bedeuten, dass man eine Zugriffsberechtigung hat, wenn man entweder den Usernamen, oder das Passwort, oder aber beides richtig eingibt.

Die Alternative zu dem or, mit dem die beiden Bedingungen verbunden sind wäre || (AltGr + <).

Verwendet man jedoch die dritte Variante von logischen Operatoren, darf nur eine Bedingung wahr sein.

Diese Variante nennt sich exklusives oder und wird wie folgt geschrieben:
<?php
if($username == "Claudia" xor $passwort == "PHP")
{
  echo "Zugriff erlaubt!";
}
?>
Jetzt wird nur dann die Anweisung ausgeführt, wenn die Eingabe entweder Claudia (für den Usernamen) oder PHP (für das Passwort) war. Hat man beide Dinge angeben (bzw. sind beide richtig) erfolgt kein Zugriff.

Dieses "entweder oder" wird durch xor geschrieben.

Und damit haben wir die logischen Operatoren auch schon wieder fertig. Wenn wir sie verwenden, werden sie dir schnell in Fleisch und Blut übergehen.


Dateien

Bisher sind wir in der Lage, mit Variablen zu arbeiten, und diese sogar überprüfen zu lassen und erst danach eine bestimmte Bedingung auszuführen. Jedoch können wir die Daten, die wir z. B. durch ein Formular übergeben, noch nicht abspeichern, was jedoch oft wünschenswert ist. Wenn man sich näher mit PHP beschäftigt, wird man selten Dateien verwenden, sondern die Daten eher in einer Datenbank abspeichern, aber für den Einstieg sind auch Dateien eine ausreichende Lösung.

Zunächst ist zu beachten, dass das Arbeiten mit Dateien immer in drei Schritten abläuft. Eine Datei wird geöffnet, danach wir der Inhalt in die Datei geschrieben oder aus der Datei gelesen (oder auch beides) und zum Schluss wird sie wieder geschlossen.

Für das Öffnen von Dateien gilt folgender Befehl:
<?php
$datei = fopen(Dateiname, Modus);
?>
Der Befehl fopen öffnet die Datei, die mittels Dateiname festgelegt wird. Durch das Öffnen wird ein so genannter Dateizeiger innerhalb der Datei gesetzt. Dieser macht nicht mehr als zu sagen, wo der Startpunkt für das Lesen bzw. Schreiben in der Datei ist. Dieser Dateizeiger steht entweder am Anfang oder am Ende der Datei und wird in der festgelegten Variable (in dem Fall datei) gespeichert.

Folgende Modi stehen zur Verfügung:
  Modus    Funktion               Dateizeiger    Anlegen?
  ==========================================================
  r        Lesen                  Anfang         Nein
  r+       Lesen und Schreiben    Anfang         Nein
  w        Schreiben              Anfang         Ja
  w+       Lesen und Schreiben    Anfang         Ja
  a        Schreiben              Ende           Ja
  a+       Lesen und Schreiben    Ende           Ja
Bei Verwendung von r oder r+ muss die Datei, aus der gelesen, bzw. in die geschrieben werden soll bereits vorhanden sein - bei allen anderen Fällen wird die Datei neu angelegt (sofern sie noch nicht existiert).

Wenn du w+ verwendest, musst du beachten, dass der Inhalt der Datei ohne Nachfrage überschrieben wird, da der Dateizeiger auf den Anfang gesetzt wird.

Für das Anlegen einer Log-Datei ist daher beispielsweise der Modus a zu empfehlen - bei einer Log-Datei muss nicht gelesen werden, sondern nur geschrieben und das immer am Ende der Datei. Sieht man also in der oberen Tabelle nach ergibt sich daraus Modus a.

Wir machen jetzt als Beispiel einen ganz simplen textbasierten Counter, ohne Reloadsperre.
<?php
$datei = fopen("counter.txt","r+");
?>
Die Datei, in die der Counterstand geschrieben werden soll nennt sich counter.txt und wir verwenden den Modus r+. In dem Fall müssen wir die counter.txt anlegen, bevor wir sie benutzen können.

Aber was jetzt? Jetzt ist zwar eine Datei geöffnet, aber wir können noch nichts mit den Werten, die darin enthalten sind, anfangen. Da wir einen Counter haben wollen, soll zunächst der derzeitige Wert ausgegeben werden. Zu diesem Zweck lesen wir den Dateiinhalt aus.
<?php
$counterstand = fgets($datei, 10);
?>
Mit fgets wird der Inhalt der Datei gelesen. Davor muss die Datei geöffnet worden sein und ein Dateizeiger muss gesetzt sein (das haben wir beides mit dem fopen Befehl durchgeführt und in die Variable datei gespeichert. Der Wert 10 gibt an, wieviele Zeichen gelesen werden sollen.

Das Lesen von Dateien erfolgt zeilenweise, das heißt es wird immer maximal bis zu einem Absatzzeichen gelesen - oder bis zum Dateiende. Jedoch kann auch festgelegt werden, dass z. B.. nur die ersten 10 Zeichen einer Datei gelesen werden sollen, so wie wir das jetzt gemacht haben (ich gehe davon aus, dass ein Counter nicht mehr als 10 Stellen haben wird).

Der Counterstand wird jetzt in die Variable counterstand gespeichert und soll anschließend erhöht werden.

Jedoch haben wir jetzt ein Problem. Da wir die Datei ja erst angelegt haben und noch kein Wert darin enthalten ist, ist die Variable counterstand leer. Wir wissen aber, dass sie nicht leer sein sollte, sondern den Wert 0 beinhalten sollte. Um das zu erreichen können wir jetzt die Variable "von Hand" auf 0 setzen.
<?php
if($counterstand == "")
{
  $counterstand = 0;
}
?>
Mit $counterstand = 0 setze ich den Wert der Variable auf 0. Damit das aber nicht immer geschieht, sondern nur dann, wenn in der Datei kein Wert steht, überprüfe ich davor, ob die Variable counterstand leer ist. Dieses leer wird durch zwei Anführungszeichen ausgedrückt (dazwischen darf sich kein Leerzeichen befinden).

Erst dann, wenn die Variable tatsächlich leer ist, wird der Wert auf 0 gesetzt.

Was kommt jetzt bei einem Counter? Da ein Zugriff erfolgte, muss der Counterstand um 1 erhöht werden und dieser neue Wert muss dann in die Datei geschrieben werden.
<?php
$counterstand++;
?>
Du erinnerst dich an diesen Befehl? Er ist die Kurzform zu $counterstand = $counterstand + 1 und erhöht den Wert um 1.

Und jetzt kann die Variable über echo $counterstand ausgegeben ...
<?php
echo $counterstand;
?>
... und der neue Wert in die Datei geschrieben werden.

Dafür müssen wir aber zuerst den Dateizeiger an den Anfang das Dokumentes zurück (sonst wird statt 2 plötzlich 12 geschrieben, weil sich der Dateizeiger am Ende befindet) setzen.

Dafür gibt es den Befehl rewind.
<?php
rewind($datei);
?>
Und anschließend den neuen Wert in die Datei schreiben.
<?php
fwrite($datei, $counterstand);
?>
Mit dem Befehl fwrite wird nun der neue Counterstand in die Datei geschrieben. Dabei wird zunächst angeben, wohin (in unserem Fall beschreibt die Variable datei in welcher Datei und an welche Stelle (Dateizeiger)) geschrieben werden soll. Nach dem Komma wird festgelegt, was geschrieben werden soll - bei uns ist das der neue Counterstand.

Da wir den Dateizeiger mit rewind an den Anfang gesetzt haben wird automatisch der alte Wert überschrieben.

Jetzt müssen wir nur mehr die Datei schließen und schon ist der Counter fertig.
<?php
fclose($datei);
?>
Der Befehl fclose gibt an, dass eine Datei geschlossen werden soll und in Klammer setzt man die Datei mit Zeiger - also die Variable, die am Anfang verwendet wurde um diesen Wert darin zu speichern.

Unser gesamter Counter sieht also so aus:
<?php
$datei = fopen("counter.txt","r+");
$counterstand = fgets($datei, 10);
if($counterstand == "")
{
  $counterstand = 0;
}
$counterstand++;
echo $counterstand;
rewind($datei);
fwrite($datei, $counterstand);
fclose($datei);
?>
Beachte bitte, dass wir in diesem Bespiel zwar sowohl gelesen als auch geschrieben haben, das aber nicht immer notwendig ist.

Um eine Datei immer weiter zu führen (wie eben bei einer Log-Datei), verwende am besten a (a+ ist nicht notwendig, da du die Daten ja nicht auslesen musst), da a am Dateiende zu schreiben beginnt.

Wenn du immer eine neue Datei anlegen möchtest kannst du w, w+, a oder a+ verwenden - je nachdem, ob du auch lesen möchtest. Du musst nur darauf achten, dass du immer einen neuen Dateinamen hast (am einfachsten geht das mit der aktuellen Uhrzeit/Datum).

Vergiss nicht, dass PHP einen Backslash vor Anführungszeichen setzt und Zeilenumbrüche durch \n ersetzt. Das wirkt sich vor allem dann aus, wenn du die Daten aus einer Textarea in eine Datei schreiben lässt. Was du dagegen tun kannst, erfährst du auf der nächsten Seite.


Suchen/Ersetzen

Wie bereits erwähnt werden in PHP Anführungszeichen durch Backslash Anführungszeichen geschrieben und auch ein Zeilenumbruch wird durch ein solches Sonderzeichen "maskiert". Das wirkt sich jedoch nicht nur darauf aus, das wir beim Füllen einer Variable darauf achten müssen, sondern auch dann, wen z. B. Text aus einer Textarea (oder auch aus einer Datei oder Datenbank) übernommen wird.
PHP setzt viele "Sonderzeichen" ein,
da gewisse Zeichen in PHP
eine spezielle Bedeutung haben.
Wird dieser Text in PHP auf irgendeine Art übergeben, schaut er eigentlich so aus (keine Zeilenumbrüche bei \n - die wurden nur wegen der Übersichtlichkeit hinzugefügt):
PHP setzt viele \"Sonderzeichen\" ein,
\n
da gewisse Zeichen in PHP
\n
eine spezielle Bedeutung haben.
Zum einen wollen wir aber nicht diese komischen \n in unserem Text haben, dann hätten wir gerne statt der \n richtige Zeilenumbrüche, die auch in HTML sichtbar sind (also <br>) und zum Schluß wollen wir auch noch statt "spezielle" "besondere" schreiben.

Fangen wir mal beim letzten Punkt an. Es gibt in PHP verschiedene Möglichkeiten, Text zu ersetzen. Meine bevorzugte Variante ist ereg_replace. ereg_replace ist ab PHP 5.3.0 als veraltet eingestuft und wird mit PHP 6 entfernt werden. Es sollte daher nicht mehr verwendet werden. Die Alternativen dazu sind str_replace, und preg_replace. Letzteres erfordert allerdings die Verwendung von regulären Ausdrücken, was es etwas umständlicher macht.
str_replace(Suche,Ersetze,betroffene Variable)
Machen wir mal ein Beispiel dazu und speichern den oben angeführten Text in eine Variable namens text und ersetzen dann das Wort "spezielle" durch "besondere" bevor wir den Text ausgeben.
<?php
$text = "PHP setzt viele \"Sonderzeichen\" ein,\nda gewisse Zeichen in PHP\neine spezielle Bedeutung haben.";
$text = str_replace("spezielle","besondere",$text);
?>
Wir überschreiben die Variable text mit dem neuen Text, der dadurch entsteht, dass PHP innerhalb der Variable text (als letztes in der Klammer festgelegt) nach "spezielle" sucht und dieses durch "besondere" ersetzt. Der Such- und Ersetztext muss in Anführungszeichen geschrieben werden. Würden wir jetzt mit echo den Text ausgeben würde dort stehen PHP setzt viele "Sonderzeichen" ein, da gewisse Zeichen in PHP eine besondere Bedeutung haben.

Die Funktion preg_replace funktioniert ganz ähnlich, nur dass sie reguläre Ausdrücke verwendet. Da das hier den Rahmen sprengen würde, nur kurz die Information, dass es dafür diese Funktion gibt, in den meisten Fällen aber str_replace ausreichen ist. Weitere Informationen über reguläre Ausdrücke findest du im hervorragenden Tutorial zu regulären Ausdrücken von Daniel Fett.

Würden wir jetzt mit echo den Text ausgeben würde dort stehen PHP setzt viele "Sonderzeichen" ein, da gewisse Zeichen in PHP eine besondere Bedeutung haben.

Wenn wir den Text jetzt aber nicht direkt in eine Variable geschrieben hätten, sondern z. B. von einem Formular übergeben bekommen hätten, würde da statt PHP setzt viele "Sonderzeichen" ein... plötzlich PHP setzt viele \"Sonderzeichen\" ein... stehen. Und außerdem wollen wir eigentlich auch die Zeilenumbrüche in unserem ausgegebenen Text haben, die ja jetzt einfach verschluckt werden, weil sie keine HTML-Anweisungen sind.

Für beide Probleme gibt es in PHP eine fertige Funktion.

Um die Zeilenumbrüche hinein zu bekommen verwenden wir die Funktion nl2br. Dabei wird wiederum die Variable text überschrieben. Die Funktion lautet nl2br und in Klammer wird die Variable angegeben, bei der die \n durch <br> ersetzt werden sollen.
<?php
$text = nl2br($text);
?>
Jetzt sieht unser Text so aus:

PHP setzt viele \"Sonderzeichen\" ein,
da gewisse Zeichen in PHP
eine besondere Bedeutung haben.


Es ist wichtig, dass nl2br vor dem nächsten Befehl verwendet wird - sonst funktioniert er nämlich nicht mehr, da wir im nächsten Schritt alle Backslashes entfernen.

Und auch hierfür gibt es bereits eine fertige Funktion. Diese nennt sich stripslashes und funktioniert genauso wie nl2br. Die alte Variable wird durch den neuen Text überschrieben, der dadurch entsteht, dass die Funktion stripslashes auf die Variable text (in Klammer angeführt) angewendet wird.
<?php
$text = stripslashes($text);
?>
Und jetzt schaut unser Text endlich so aus, wie wir ihn haben wollten:

PHP setzt viele "Sonderzeichen" ein,
da gewisse Zeichen in PHP
eine besondere Bedeutung haben.


Der gesamte Code sieht nun so aus:
<?php
$text = "PHP setzt viele \"Sonderzeichen\" ein,\nda gewisse Zeichen in PHP\neine spezielle Bedeutung haben.";
$text = preg_replace("/spezielle/","besondere",$text);
$text = nl2br($text);
$text = stripslashes($text);
echo $text;
?>
Und jetzt schauen wir uns endlich an, was Datum und Uhrzeit können ...


Datum & Uhrzeit

PHP verfügt auch über eine Datums- und Uhrzeitfunktion, die nicht nur zur Anzeige von Daten benutzt werden kann.

Das verwirrende daran ist jedoch, dass die Zeit zunächst mittels des sogenannten UNIX-Timestamp ermittelt wird. Dieser beinhaltet die Anzahl der Sekunden seit dem 1.1.1970 um 01:00 Uhr. Dadurch entsteht z. B. ein solcher Wert: 1511342356

Dieser Wert ist jedoch, wie ich zugeben muss, in seiner momentanen Form nicht brauchbar. Stell dir vor, du willst auf deiner Internetseite sagen, "Heute ist der 7. August" und du bekommst nur so ein merkwürdiges Zahlenspiel heraus.

Aus diesem Grund verfügt PHP über weitere Funktionen, die Uhrzeiten formatieren lassen. Die Grundlage dazu ist aber immer der UNIX-Timestamp. Bevor wir allerdings etwas mit den Datumsfunktionen von PHP machen, legen wir erstmal die gewünschte Zeitzone fest. Das funktioniert über date_default_timezone_set.
<?php
date_default_timezone_set("Europe/Berlin");
$timestamp = time();
?>
Die erste Codezeile legt die Zeitzone fest. In der zweiten Codezeile verwenden wir den kurzen Befehl time() und ermitteln damit den aktuellen UNIX-Timestamp und speichern ihn - zur weiteren Verarbeitung - in der Variable timestamp.

Um die Zeit jetzt angenehm zu formatieren gibt es die Funktion date (format, timestamp).

Für die Formatierung stehen hierbei sehr viel Möglichkeiten zur Verfügung (ich biete hier nur einen Auszug an, die vollständige Liste findet sich unter www.php.net):
  Format Beschreibung                          Beispiel
  ========================================================
  d      Tag des Monats, zweistellig           03, 28
  j      Tag des Monats                        7, 13
  m      Nummer des Monats, zweistellig        01, 11
  n      Nummer des Monats                     2, 10
  y      Jahr zweistellig                      99, 00
  Y      Jahr vierstellig                      1999, 2001
  H      Stunde im 24-Stunden-Format, zweist.  08, 16
  G      Stunde im 24-Stunden-Format           7, 18
  i      Minuten, zweistellig                  08, 45
  s      Sekunden, zweistellig                 06, 56

  w      Wochentag in Zahlenwert               2, 6
PHP hat zwar auch Formate zur Anzeige von Monatsnamen und Wochentagsnamen, jedoch sind diese auf Englisch und erfordern ein wenig "Spielerei".

Um ein Datum inkl. Uhrzeit im Stil von 22.11.2017 - 09:19 Uhr auszugeben gibt es z. B. folgende Schreibweise:
<?php
$datum = date("d.m.Y",$timestamp);
$uhrzeit = date("H:i",$timestamp);
echo $datum," - ",$uhrzeit," Uhr";
?>
Ich habe hierbei Datum und Uhrzeit in zwei verschieden Variablen gespeichert, da ich sie eventuell auch einzeln verwenden möchte. Es wäre aber auch die Anweisung "d.m.Y - H:i" möglich.

Keine Panik - ich kann diese ganze Tabelle auch nicht auswendig, sondern schaue im Bedarfsfall immer mal wieder nach :-)

Gibst du übrigens bei der Funktion date keinen UNIX-Timestamp an, wird automatisch das aktuelle Datum (und die aktuelle Uhrzeit) ermittelt. Das sieht dann z. B. so aus:
<?php
$datum = date("d.m.Y");
$uhrzeit = date("H:i");
echo $datum," - ",$uhrzeit," Uhr";
?>
Wenn du ein Datum hast und dieses in den UNIX-Timestamp umwandeln willst, gibt es auch dafür einen Befehl:
<?php
$timestamp = mktime(9,19,0,11,22,2017);
?>
Durch mktime wird diese Funktion aufgerufen und das Ergebnis wird in der Variable timestamp gespeichert. Die Werte in Klammer ergeben sich von links nach rechts durch Stunde, Minute, Sekunde, Monat, Tag, Jahr. Der Wert oben entspricht also dem 22.11.2017 um 9:19:00 Uhr.

Ich habe oben erwähnt, dass der Timestamp sich auf den 1.1.1970 bezieht. Er ist aber natürlich auch in der Lage, Daten anzuzeigen, die davor liegen. Dafür wird einfach ein negativer Timestamp verwendet, der dann die Sekunden vor dem 1.1.1970 anzeigt.

Erinnerst du dich, dass ich vorher gesagt habe, Monatsnamen und Wochentage werde in PHP nur in Englisch angezeigt? Nun, es gibt auch zwei Möglichkeiten, die deutschen Namen (oder jede beliebige andere Sprache) zu verwenden. Für die eine gibt es zwei spezielle Funktionen in PHP. Für die andere brauchen wir Arrays. Und genau darum geht es auf der nächste Seite.


Array (+foreach)

Was ist eigentlich ein Array? Nun, ich würde ein Array als eine Variable, in der viele weitere Variablen gespeichert werden können beschreiben. Eine jede dieser "Variablen" ist durch eine eindeutige Nummer oder einen Begriff ansprechbar.

Ein Array bekommt, wie jede "normale" Variable einen Namen zugeordnet, jedoch erfolgt die Zuweisung der Inhalte nicht über ein einfaches Ist-Gleich, sondern über die Funktion array.
<?php
$blumen = array("Rose", "Tulpe", "Nelke", "Sonnenblume");
?>
In diesem Fall existiert ein Array namens blumen in das verschiedene Blumennamen geschrieben wurden. Diese Blumennamen haben jetzt automatisch Nummern zugewiesen bekommen, wobei die Nummerierung bei 0 beginnt (Rose hat also den Wert 0, Tulpe den Wert 1 usw.).

Der Zugriff erfolgt jetzt über den Arraynamen plus der Nummer des Eintrages in eckigen Klammern.
<?php
echo $blumen[3];
?>
In diesem Fall wird der Begriff Sonnenblume ausgegeben.

In manchen Fällen ist die vorgegebene Nummerierung jedoch nicht verwendbar und so kann man auch selbst einen eindeutigen Namen (oder eine Nummer) für jeden Eintrag festlegen. Dabei schreibt man zunächst den Namen für den Wert und durch einen Pfeil (=>) getrennt den Wert.
<?php
$blumen = array("rot"=>"Rose", "rosa"=>"Tulpe", "weiss"=>"Nelke", "gelb"=>"Sonnenblume");
?>
Jetzt haben alle Blumennamen eine Farbe zugeordnet bekommen, über die sie angesprochen werden können.
<?php
echo $blumen["rosa"];
?>
Gibt somit Tulpe aus.

Verwendet man Worte, so muss man diese unter Anführungszeichen setzen - weist man jedoch Zahlen zu, ist das nicht notwendig.

Es gibt bei Arrays eine Funktion, um zu überprüfen, wieviele Werte sich in dem Array befinden. Das kann z. B. dann genutzt werden, wenn man in das Array nur eine bestimmte Anzahl von Werten schreiben möchte. Der Befehl dazu lautet count.
<?php
$anzahl = count($blumen);
?>
Der Rückgabewert würde in unserem Fall 4 ergeben, da sich vier Werte im Array befinden.

Eine weitere wichtige Funktion ist die Überprüfung, ob sich ein bestimmter Wert bereits im Array befindet (ich habe z. B. einen Zufallsgenerator für Lottozahlen programmiert und dabei alle Zahlen in ein Array geschrieben und davor immer abgefragt, ob die Zahl nicht schon existiert, damit kein Wert doppelt vorkommt).

Die Funktion dazu lautet in_array und beinhaltet, welcher Wert gesucht wird und worin (in welchem Array) gesucht werden soll. Am sinnvollsten ist der Einsatz im Zusammenhang mit einer if-Abfrage.
<?php
if(in_array("Tulpe", $blumen))
{
  echo "Tulpe ist im Array enthalten.";
}
?>
Hier wird überprüft, ob sich der Wert Tulpe im Array blumen befindet. Ist dies der Fall wird der Text ausgegeben - ansonsten passiert nichts.

Eine weitere Funktion, die ich beim oben erwähnten Lottozufallsgenerator verwendet habe war array_push. Hierbei wird das Array um einen Wert erweitert - er wird in das Array dazugeschrieben. Die Zuweisung erfolgt so:
<?php
array_push($blumen,"Efeu","Kornblume");
?>
Zunächst wird festgelegt, welches Array erweitert werden soll und danach werden (durch Komma getrennt) die gewünschten Werte angegeben.

Beachte, dass hierbei kein Name für einen Wert zugewiesen werden kann. Wenn du diese Funktion in Verbindung mit einem Array, in dem du Namen zugewiesen hast, benutzt, wird das Array nicht erweitert.

Was bei Arrays noch von Interesse ist, ist die Sortierung der darin enthaltenen Werte. Diese kann auf unterschiedliche Arten erfolgen.

Möchte man die Feldnamen sortieren, verwendet man die Funktionen ksort oder krsort, wobei ksort eine aufsteigende Reihenfolge (a,b,c,d) liefert und krsort eine absteigende (d,c,b,a).
<?php
ksort($blumen);
?>
Ergibt die Reihenfolge gelb (Sonnenblume), rosa (Tulpe), rot (Rose), weiss (Nelke). Die Werte werden jedoch nach wie vor auf die gleiche Art und Weise angesprochen ($arrayname[Feldname]).

Möchte man die Werte sortieren, gibt es die Funktionen asort und arsort. Auch hier sortiert asort aufsteigend und arsort absteigend.
<?php
asort($blumen);
?>
Hier ergibt sich die Reihenfolge Nelke, Rose, Sonnenblume, Tulpe. Auch im Fall eines Arrays, dem keine Feldnamen zugewiesen wurden, bleiben jedoch die Nummern der einzelnen Werte gleich (Nelke hat nach wie vor den Eintrag Nummer 2).

Wenn da jetzt aber alles gleich bleibt - wozu benötigt man überhaupt eine Sortierung?

Nun, es gibt auch eine Möglichkeit, nicht einen bestimmten Wert eines Arrays anzusprechen, sondern das gesamte Array auf einmal ausgeben zu lassen. Dazu dient die Funktion foreach.

Mit foreach wird jeder Wert des Arrays vorrübergehend einer Variable zugeordnet und dann z. B. gelistet. Der Name der Variable wird durch den Befehl as angegeben.
<?php
foreach($blumen as $meine_blume)
  echo $meine_blume,"<br />";
?>
Die Liste würde dann so aussehen:

Rose
Tulpe
Nelke
Sonnenblume


Wende ich jetzt meine Sortierung an, ändert sich die Reihenfolge bei der Ausgabe ...
<?php
asort($blumen);
foreach($blumen as $meine_blume)
  echo $meine_blume,"<br />";
?>
... ergibt folgendes ...

Nelke
Rose
Sonnenblume
Tulpe

Vielleicht ist dir aufgefallen, dass wir hier im Gegensatz zu den if-Anweisungen keine geschwungenen Klammern verwendet haben. Das funktioniert in diesem Fall, weil wir nur eine einzige Anweisung (die echo-Anweisung) ausführen lassen. Möchten wir beispielsweise den Zeilenumbruch in eine extra echo-Anweisung schreiben müssen wir geschwungene Klammern verwenden um die Anweisung festzulegen.
<?php
foreach($blumen as $meine_blume)
{
  echo $meine_blume;
  echo "<br />";
}
?>
Diese Anweisung liefert genau das gleiche Ergebnis wie oben, jedoch ist die Schreibweise etwas anders.

Mit diesem System lassen sich auch if-Abfragen innerhalb einer foreach-Schleife bewerkstelligen (z. B. wenn man überprüfen möchte, ob gerade ein bestimmter Wert ausgegeben werden soll.

Den erwähnten Lottozufallsgenerator findest du übrigens im Buch.

Und als nächstes verrate ich jetzt endlich den "Trick" mit dem richtig formatierten Datum.


Tage & Monate

Wie bereits bei Datum & Uhrzeit erwähnt, kann PHP auch den Wochentag bzw. den Monatsnamen anzeigen lassen. Jedoch sind das englische Wochentage bzw. Monate (also Monday, Tuesday usw.). Um diese Werte auf Deutsch (oder in jeder beliebigen anderen Sprache) anzeigen zu lassen, gibt es zwei Möglichkeiten. Die erste ist eine Lösung durch PHP selbst, die jedoch auf manchen Systemen zu merkwürdigen Ergebnissen führen kann und erstmal etwas seltsam aussieht, für die zweite Möglichkeit können wir Arrays verwenden.

Die Verwendung von setlocale und strftime

PHP verfügt über eine Funktion namens setlocale, damit kann festgelegt werden, welches Sprach-/Gebietsschema verwendet werden soll. Das lässt sich für verschiedene Fälle anwenden, wir kümmern uns jedoch jetzt nur um die Anpassung für Datum und Zeit. Der Befehl dafür ist ganz kurz:
<?php
setlocale(LC_TIME, "de_DE.utf8");
?>
Danach muss allerdings das Datum mit einer weiteren speziellen Funktion formatiert werden. Diese nennt sich strftime. Die Bezeichnungen für die einzelenen Formatierung sind ähnlich wie bei der Verwendung von date, werden jedoch alle mit einem führenden Prozentzeichen geschrieben. Eine vollständige Liste findest du wie immer auf php.net.

Wollen wir jetzt also den Wochentag auf deutsch ausgeben, sieht das so aus:
<?php
setlocale(LC_TIME, "de_DE.utf8");
echo "Heute ist ";
echo strftime("%A");
echo ".";
?>
Das ergibt dann: Heute ist Mittwoch.

Sofern diese Funktion bei dir Probleme macht oder du Namen verwenden möchtest, die nicht als lokale Namen gesetzt sind, gibt es auch die Möglichkeit mit einem Array zu arbeiten:

Die Verwendung eines Arrays

Die Grundlage zu diesem "Trick" bietet die Möglichkeit, die Nummer des Wochentags ausgeben zu lassen. Dabei beginnt die Nummerierung bei 0 für Sonntag und geht bis 6 für Samstag. Mit diesem Wissen kann man jetzt ein Array machen, in dem diesen Zahlen die richtigen Wochentage zugeordnet werden (da ein Array automatisch bei 0 anfängt, müssen die Werte nicht extra zugewiesen werden).
<?php
$tage = array("Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag");
?>
Um jetzt den richtigen Tag zu erwischen verwende ich bei der Ausgabe $tage[Nummer des Tages].

Und die Nummer des Tages wird mit der Datumsfunktion ermittelt (da wir date verwenden, müssen wir zunächst die Zeitzone festlegen):
<?php
date_default_timezone_set("Europe/Berlin");
$tag = date("w");
echo $tage[$tag];
?>
Ich lege hier keinen Timestamp fest, da ich das heutige Datum verwenden möchte. Im zweiten Schritt erfolgt direkt die Ausgabe über echo. Das ergibt Mittwoch.

Mit dem gleichen System können jetzt auch die Namen für die Monate festgelegt werden, jedoch darf nicht vergessen werden, dass die Monate nicht mit 0, sondern mit 1 beginnen.

Aus diesem Grund müssen diesem Array die Werte extra zugewiesen werden:
<?php
$monate = array(1=>"Januar",
                2=>"Februar",
                3=>"M&auml;rz",
                4=>"April",
                5=>"Mai",
                6=>"Juni",
                7=>"Juli",
                8=>"August",
                9=>"September",
                10=>"Oktober",
                11=>"November",
                12=>"Dezember");
?>
(das Array ist aus Übersichtlichkeitsgründen so geschrieben - selbstverständlich wäre es auch möglich, alle Werte in eine Reihe zu schreiben).

Jetzt wird wiederum das aktuelle Datum verwendet um den derzeitigen Monat abzufragen und anschließend der Monat ausgegeben.
<?php
$monat = date("n");
echo $monate[$monat];
?>
Das Ergebnis hierzu ist November.

Und das ist das ganze "Geheimnis" hinter einer deutschen Wochentags- bzw. Monatsangabe :-)

Und was schauen wir uns als nächstes an?


while-Schleife

In manchen Fällen ist es notwendig, eine Anweisung so lange auszuführen, bis ein bestimmtes Ergebnis eintritt. So möchte ich jetzt z. B. bis zu einer bestimmten Zahl zählen. Die Zahl soll allerdings nicht voher bestimmt werden, sondern soll vom Benutzer angegeben werden können. Wer sich das einmal ansehen möchte, klickt doch bitte mal hier (Popup).

In der ursprünglichen Datei befindet sich ein Formular, dass ein Feld zahl beinhaltet. Damit wird die Variable zahl an die darauffolgende Datei (form4.php) übergeben. In dieser Datei steht folgendes:
<?php
$zahl = $_POST["zahl"];
if($zahl > 25)
{
  $zahl = 25;
}
?>
Zunächst wird die über das Formular übermittelte Variable wieder in ihren "kurzen Namen" umgeschrieben. Dann wird überprüft, ob die Zahl wirklich kleiner als 25 ist (ich könnte auch weiter zählen lassen, aber das ist ja nicht notwendig und zum Schluss kommt jemand auf die Idee und zählt bis 1.000.000 oder so). Dazu lautet die Bedingung der if-Anweisung $zahl > 25 - also Wenn die Variable zahl größer als 25 ist, dann .... Anschließend erfolgt die Anweisung, die bewirkt, dass die Variable zahl auf 25 gesetzt wird, aber nur dann, wenn sie eben vorher größer als 25 war - ... setze die Variable zahl auf 25..

Der nächste Schritt ist jetzt die while-Schleife.

Bei while-Schleifen arbeitet man meistens mit einem "internen Counter", der zunächst initialisiert wird - in diesem Fall mit dem Wert 1.
<?php
$count = 1;
?>
Dabei wird einfach einer beliebigen Variable - in diesem Fall der Variable count - ein Wert zugewiesen. Das ist deswegen notwendig, weil die while-Schleife solange ausgeführt wird, wie eine bestimmte Bedingung zutrifft. Um so eine Bedingung zu schaffen, legen wir diese Variable count fest und zählen diese dann in der Schleife jeweils um 1 hoch (Du erinnerst dich an $count++;?). Wichtig ist, dass die Festlegung der Variable außerhalb der Schleife erfolgt, sie aber innerhalb der Schleife hochgezählt wird.

Das klingt zunächst verwirrend ... aber schauen wir uns doch einfach mal die Schleife an ...
<?php
while($count < $zahl)
{
  echo $count,", ";
  $count++;
}
?>
Gehen wir davon aus, dass unsere Variable zahl den Wert 5 erhalten hat. Sie kommt damit unbeschadet durch die if-Anweisung (diese greift ja nur, wenn der Wert größer als 25 ist). Jetzt kommt unsere while-Schleife.

Direkt nach dem einleitenden while wird innerhalb einer runden Klammer die Bedingung geschrieben (genauso, wie bei einer if-Anweisung). Solange diese Bedingung zutrifft, wird jetzt die Anweisung, die in geschwungenen Klammern geschrieben wird ausgeführt.

Bei uns lautet die Bedingung $count < $zahl. Die Variable count muss also kleiner als die Variable zahl sein. Momentan ist count auf 1 und zahl auf 5, das heißt, die Bedingung ist wahr - also erfüllt und die Schleifenanweisung wird durchlaufen.

In der steht jetzt echo $count,", ";. Es wird also der Inhalt der Variable count (momentan 1) ausgegeben und danach werden ein Komma und ein Leerzeichen gesetzt.

Die zweite Anweisung lautet nun so, dass die Variable count um 1 erhöht werden soll. Diese Anweisung ist absolut wichtig, da es sich sonst um eine Endlosschleife handelt und der Computer dabei abstürzt!!

Durch die Erhöhung um 1 hat die Variable count jetzt den Wert 2. Die Anweisung ist damit beendet und die while-Schleife wird erneut getestet.

Da 2 noch immer kleiner ist als der Inhalt der Variable zahl (5) wird die Schleife wieder durchlaufen. Jetzt wird die Zahl 2 ausgegeben und danach wird die Variable count auf 3 erhöht.

Das gleiche erfolgt jetzt solange, bis die Variable count auf 5 erhöht wurde. Wird jetzt die Schleifenbedingung überprüft, ist sie nicht mehr erfüllt, da 5 nicht kleiner als 5 ist. Daher wird jetzt nicht mehr die Schleife durchlaufen.

Unsere Zählung ist aber noch nicht beendet - bis jetzt steht nämlich nur 1, 2, 3, 4, hier - es soll aber bis 5 gezählt werden.

Aus dem Grund erfolgt jetzt der letzte Teil der PHP-Anweisung:
<?php
echo $zahl;
?>
Die Variable zahl wird ausgegeben. Da die Variable count den gleichen Wert hat, könnte alternativ auch sie ausgegeben werden.

Du wunderst dich, warum wir das so kompliziert machen und zum Schluss die Zahl extra ausgeben? Nun, das liegt an der Formatierung.

Durch die Anweisung in der while-Schleife schreiben wir ja nach jeder Zahl ein Komma Leerzeichen. Das ist aber bei der letzten Zahl nicht erwünscht. Daher lassen wir die while-Schleife nur solange ausführen, bis der Wert 4 angezeigt wird und schreiben an das Ende nur noch die höchste Zahl.

Es ist ganz wichtig, dass du bei while-Schleifen, die eine Bedingung im Stil von $count < Zahl beinhalten nicht vergisst, die Variable count (oder wie du sie eben nennen möchtest) durch $count++; hoch zu zählen!!

Wirklich oft verwenden werden wir diese Schleife bei mySQL.

Eine Alternative dazu ist übrigens die for-Schleife, die ganz ähnlich aufgebaut ist.


for-Schleife

Neben while-Schleifen gibt es in PHP auch noch for-Schleifen. Der Aufbau wirkt auf den ersten Blick komplizierter, jedoch erspart man sich den "internen Counter", da etwas dementsprechendes bereits in den Aufruf der for-Schleife kommt.

Dennoch kann man while-Schleifen nicht immer/automatisch durch for-Schleifen ersetzen, was einfach daran liegt, dass while-Schleifen ja auch andere Bedingungen behandeln als for-Schleifen.

Der Aufbau der for-Schleife ist ähnlich wie der des while, jedoch wird der Aufruf ein wenig erweitert: for(Startwert, Bedingung, Zähler).

Das heißt also, dass die Variable count, die wir bei der while-Schleife extra davor festgelegt haben, hier dem Startwert entspricht. Die Bedingung ist die selbe, wie bei while und der Zähler ist das, was wir bei while extra in die Schleife geschrieben haben, nämlich die Erhöhung der Variable.

Das Beispiel mit dem Durchzählen würde daher bei einer for-Schleife so aussehen:
<?php
for($count = 1; $count < $zahl; $count++)
{
  echo $count,", ";
}
?>
Zum Vergleich noch einmal die Variante mit der while-Schleife:
<?php
$count = 1;
while($count < $zahl)
{
  echo $count,", ";
  $count++;
}
?>
Wir verwenden also nichts anderes, nur die Anordnung verändert sich ein wenig. Das hat nebenbei auch gleich den Vorteil, dass man nicht vergessen kann, die Zählvariable zu erhöhen (Fehler in der Schleifenprogrammierung und daraus resultierende Endlosschleifen sind aber dennoch möglich - aufpassen muss man also auf jeden Fall!)

Als nächstes werfen wir noch einen Blick auf die Mailfunktion.


eMail-Versand

Eine sehr praktische Funktion, ist die Mailfunktion innerhalb PHP. Damit kann man ohne Probleme ein Kontaktformular oder sogar einen (kleinen!) Newsletterservice realisieren.

! Achtung !
Die Mailfunktion funktioniert nicht auf jedem virtuellen Webserver, da diese häufig über keinen eigenen Mailserver verfügen. Du kannst den Mailversand dann aber problemlos auf deinem Webspace testen.


Die Funktion ist so aufgebaut:
mail(Empfängeremail, Betreff, Nachricht, "From: Absender <Absenderemail>");
Es ist dabei sinnvoll, alle Werte in Variablen zu speichern. Geschieht dies nicht, sind eMail-Adressen ohne Anführungszeichen und Texte in Anführungszeichen zu schreiben.

Das kann dann z. B. so aussehen:
<?php
$empfaenger = "email@domain.de";
$absendername = "Kontaktformular";
$absendermail = "email@domain.de";
$betreff = "PHP ist toll";
$text = "Hallo Claudia!
        $user war gerade auf deinen PHP-Seiten und 
        wollte dir sagen, dass sie ihm/ihr sehr gut
        gefallen.
        Wenn du mit ihm/ihr Kontakt aufnehmen 
        m&ouml;chtest, benutze bitte die Adresse $usermail.";
mail($empfaenger, $betreff, $text, "From: $absendername <$absendermail>");
?>
Die Leerzeichen um die Einrückung bei der Variable $text zu erzeugen, sind hier nur aus Übersichtlichkeitsgründen vorhanden. Sie würden so im Text übernommen werden und müssen daher im richtigen Einsatz weggelassen werden.

Die Eingabe des Textes kann durch ein Formular erfolgen, in dem der User seinen Namen und seine eMail-Adresse einträgt und das dann automatisch diese Mail versendet. Sinnvoll ist es natürlich, als Empfänger die eigene eMail-Adresse anzugeben bzw. die desjenigen, der die Mail bekommen soll. Bezüglich Sicherheitsrisiken bei eMail-Versand über Formulare, wirf bitte einen Blick auf die sehr gute Seite von Daniel Fett.

Die Variablen user und usermail, die im Mailtext ausgegeben werden, werden dabei durch das Formular festgelegt - alle anderen werden selbst angeführt.

Achtung! Immer mehr Server verschicken aus Sicherheitsgründen Mails nur dann, wenn die Absenderadresse tatsächlich auf dem Server angelegt ist. Du kannst daher nicht einfach den im Formular angegebenen Absender als "From" angeben, sondern musst deine eigene Mailadresse dort eintragen, indem du eine extra Variable für die Absender-Mail-Adresse definierst. Alternativ kannst du natürlich auch die Empfänger-Mail-Adresse als Absenderadresse benutzen.

Durch weitere Parameter ist es mit dieser Funktion auch möglich HTML-Mails zu versenden.
<?php
$extra = "From: $absendername <$absendermail>\n";
$extra .= "Content-Type: text/html\n";
$extra .= "Content-Transfer-Encoding: 8bit\n";
mail($empfaenger, $betreff, $text, $extra);
?>
Hierbei werden die Variablen des Absenders in der Variable extra abgespeichert. Wichtig ist das \n am Ende der Variable (dadurch wird eine Zeilenumbruch erzeugt). Danach wird mit .= ein weiterer Wert an die Variable angehängt, der den Content-Type - bei uns also text/html - angibt. Dieser muss genau so übernommen werden. Anschließend benötigen wir noch Content-Transfer-Encoding. Auch diesen verwendest du bitte wie oben angegeben. Dadurch wird aus einer Mail eine HTML-Mail.

Der Text der Nachricht muss in dem Fall mittels HTML formatiert werden, reine Zeilenumbrüche funktionieren z. B. nicht!

Beachte aber bitte, dass Text-Mails zum einen beliebter sind als HTML-Mails und dass zum anderen die Programmierung einfacher ist, wenn du nur Text-Mails verwendest :-)

Als nächstes zeige ich dir die Vorteile von Includes.


Includes

Seit ich mit PHP programmiere gestalte ich neue Internetseiten eigentlich nur noch framelos, da sich der größte Vorteil von Frames mit PHP wunderbar ausgleichen lässt. Ich rede hierbei von den Menü-Frames, die ich immer deshalb gerne verwendet habe, weil man Änderungen an der Menüstruktur nur einmal machen musste und nicht jede Datei einzeln anpassen musste.

Durch die Verwendungen von PHP und Includes braucht man auch bei framelosen Layouts nur noch einmal ein Menü erstellen und kann es dann auf jeder Seite verwenden. Aber auch bei anderen mehrmals verwendeten Texten oder Codeteilen kann man Includes sehr sinnvoll einsetzen.

Zunächst braucht man dafür eine Datei, in der der Text/Code steht, der später eingebunden werden soll. Diese speichert man dann mit einem beliebiegen Namen (und einer beliebigen Endung) ab. Die Endung .inc bietet sich an, um sie im Verzeichnis leicht von normalen PHP-Dateien unterscheiden zu können, hat aber den Nebeneffekt, dass man dann die Datei direkt aufrufen und den Code lesen kann. Es kann also sinnvoll sein, auch für Includes die Endung .php zu verwende. Grundsätzlich ist aber jede Endung möglich. Ein Menü könntest du also z. B. als include_fuer_menue.inc abspeichern - www.schattenbaum.net/php/include_fuer_menue.inc aufzurufen kannst du dir aber sparen, da es hier in einer anderen Datei steht ;-)

Dort, wo du den Inhalt dieser Datei jetzt einbinden möchtest brauchst du noch eine PHP-Anweisung und zwar:
<?php
include("dateiname.endung");
?>
bzw. um bei der include_fuer_menue.inc zu bleiben:
<?php
include("include_fuer_menue.inc");
?>
Dann erscheint genau an der Stelle, an der du diesen Code verwendet hast der Inhalt der Datei.

Du kannst das übrigens auch ganz toll verwenden, wenn du Codeteile mehrfach brauchst, oder Variablen in mehreren Dateien mit den selben Werten brauchst. Aber probier es einfach selbst aus, dann wirst du bald merken, wie vielfältig Includes einsetzbar sind und was für eine Arbeitserleichterung sie darstellen.

Und jetzt schauen wir uns noch die Zufallsfunktion an.


Zufall

Mit Zufallszahlen lassen sich viele - teilweise witzige - Dinge realisieren. Zum Beispiel ist es möglich, Linklisten durch Zufall jedes Mal anders darzustellen, oder so wie auf dieser Seite meine "Zahl des Tages" bei jedem Seitenaufruf zu ändern. Das ist zwar keine "sinnvolle" Anwendung, kann aber eine Seite durchaus auflockern.

Die Funktion selbst ist einfach und rasch erklärt:
<?php
$zufall = rand(1,100);
?>
Mittels rand wird eine ganzzahlige (44 oder 36 oder 95 ...) Zufallszahl aus dem Zahlenpool von 1 bis 100 ausgewählt. Die Angaben in Klammer sind optional und geben die Unter- bzw. Obergrenze (also den Zahlenraum, innerhalb dem die Zufallszahl ausgewählt werden soll) an. Der ermittelte Wert wird anschließend in der Variable zufall gespeichert und kann jetzt weiterverwendet werden.

Sollte diese Funktion Probleme machen, kann man stattdessen auch mt_rand verwenden. Diese soll schneller sein.

Ganz prinzipiell ist allerdings zu sagen, dass die Zufallszahlen in PHP öfter problematisch sind - vorallem ein mehrfacher Aufruf über Schleifen führt häufig zum mehrfach gleichen Ergebnis.


Sessions

Sessions sind eines der mächtigsten Werkzeuge in PHP. Sie sind eigentlich unheimlich einfach aufgebaut und erfordern nur wenige Anweisungen, man kann aber viel mit ihnen erreichen. Sessions helfen dir dabei, Variablen für die gesamte Zeit, die ein User auf deiner Internetseite verbringt, zu speichern. Beim ersten Betreten einer Seite - z. B. index.php - wird die Session für diesen Benutzer gestartet. Du kannst dann Session-Variablen setzen, die auf jeder anderen Seite, auf der du die Session initialisierst und die der Benutzer besucht, ebenfalls zur Verfügung stehen. Wenn dein Besucher sein Browserfenster schließt oder nach Ablauf einer gewissen Zeitspanne in der keine Aktion mehr erfolgt (standardmäßig meistens 30 Minuten) wird die Session beendet und die Variablen werden gelöscht.

Was heißt das jetzt genau und was machen wir überhaupt damit?

Ein sehr klassisches Beispiel für den Einsatz von Sessions wären Seiten mit Login. Man meldet sich einmal mit seinem Benutzernamen und seinem Passwort an und hat dann Zugriff auf alle Seiten, ohne sich noch einmal anmelden zu müssen. Das muss man erst beim nächsten Besuch auf der Seite. Erreicht wird das, indem unsere Zugangsberechtigung in einer sogenannten Sessionvariable auf dem Server gespeichert wird. Wir bekommen zusätzlich eine Session-ID zugewiesen, die unsere Session eindeutig kennzeichnet. Diese Session-ID wird als Cookie auf unserem Computer abgespeichert. Es ist möglich, die Session-ID eines anderen zu übernehmen und dadurch Zugang zu erlangen, auch wenn man keine gültigen Logindaten hat. Einen vollständigen Schutz davor gibt es nicht.

Jetzt aber ans Programmieren.

Die Session startest/initialisiert du mit dem Befehl session_start(). Das musst du auf jeder Seite machen, auf der du Session-Variablen verwenden möchtest und am besten immer ganz am Anfang deiner Programmierung, da davor nichts ausgegeben werden darf. Erst danach kannst du Variablen speziell für deine Session setzen und abrufen. Eine Session-Variable sprichst du immer über $_SESSION["Variablenname"] an - sowohl beim Festlegen, als auch beim Abrufen oder Ändern.

Wir gehen im Beispiel davon aus, dass sich der Benutzer über ein Formular eingeloggt hat und wir bereits geprüft haben, ob er zugriffsberechtigt ist. Jetzt speichern wir diese Zugriffsberechtigung in einer Session. Zusätzlich legen wir eine Sessionvariable an, in der sein Benutzername (der in unserem Beispiel bereits über die Variable $username abrufbar ist) gespeichert wird, damit wir ihn jederzeit benutzen können.
<?php
session_start();
$_SESSION["berechtigter_User"] = 1;
$_SESSION["Username"] = $username;
?>
Auf jeder weiteren Seite, auf der wir die Session durch die Verwendung von session_start() aufrufen, können wir jetzt diese Variablen nutzen. Wir können also z. B. den User begrüßen, ohne erneut seinen Usernamen abfragen zu müssen.
<?php
session_start();
... z. B. weiterer Code ...
echo "Hallo ",$_SESSION["Username"],"!";
?>
Wenn der Username z. B. Franz war, steht dann da Hallo Franz!.

Genauso können wir natürlich auch auf die Sessionvariable berechtigter_User zugreifen und damit am Beginn jeder Seite überprüfen, ob der Benutzer überhaupt auf die Seite darf. Voraussetzung dafür ist wiederum, dass zuerst die Session gestartet wurde.
<?php
session_start();
if($_SESSION["berechtigter_User"] != 1)
{
  echo "Bitte logge dich zuerst ein!";
  ... Loginformular ...
}
else
{
  ... Inhalt der Seite ...
}
?>
Außerdem können wir jederzeit neue Sessionvariablen festlegen, nachdem die Session auf einer Seite einmalig gestartet wurde. Das funktioniert genauso wie oben. Diese Variablen lassen sich aber auch verändern:
<?php
session_start();
... z. B. weiterer Code ...
$_SESSION["bisheriger_Username"] = $_SESSION["Username"];
$_SESSION["Username"] = "Rumpelstilzchen";
?>
Wenn der User jetzt das nächste Mal auf eine Seite kommt, auf der wir ihn begrüßen, steht da nicht mehr Hallo Franz!, sondern Hallo Rumpelstilzchen!. Zugriff auf seinen richtigen Usernamen haben wir aber immer noch, da wir ihn davor in der Sessionvariable bisheriger_Username gespeichert haben.

Um eine Session zu beenden und den User in unserem Fall auszuloggen, müssen wir zuerst alle Daten der Session löschen und danach die Session löschen.
<?php
$_SESSION = array();
session_destroy();
?>
Die Zeile $_SESSION = array(); sorgt dabei dafür, dass alle Sessionvariablen geleert werden. Die zweite Zeile löscht dann erst die Session.

Probiere ruhig ein wenig herum, was Sessions so alles können, du wirst sehen, dass sie dir oft eine große Hilfe sein werden.


Und damit haben wir jetzt eigentlich alle Funktionen, Operatoren etc., die ich persönlich häufig verwende durch. Klar, es gibt noch Funktionen, die hin und wieder verwendet werden oder für spezielle Aufgaben einfach ideal sind, jedoch kannst du diese jederzeit auf php.net nachschlagen und dich dadurch selbst tiefer in das Thema PHP einarbeiten.

Solltest du also eine bestimmte Funktion suchen, wirf bitte einen Blick auf php.net. Dort findest du alle Funktionen, die dir in PHP zur Verfügung stehen (es gibt auch eine Suchfunktion und du kannst sogar meistens die Sprache auf Deutsch umstellen, wenn du die Erklärungen auf Englisch nicht verstehst).

Und wenn du jetzt noch immer mehr lernen möchtest, kann ich dich nur zu einer Runde mySQL einladen :-)
Das komplette Tutorial findet sich unter http://www.schattenbaum.net/php