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. Das musst du entweder vorher mit deinem Provider abklären, oder du probierst es einfach einmal aus (* test.php). Und vor allem: auf deinem Computer zu Hause kannst du 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 (zB 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. In dem Fall kann ich dir 
NoDeeps als Hoster empfehlen. Falls es mit einer der alternativen Endungen geht, musst du bei der Serverkonfiguration noch einen weiteren Punkt beachten (* php3 bzw. php4).
Viele schwören hier auf die Verwendung von Apache (der auch auf den meisten Servern installiert ist). Da ich jedoch den ersten Kontakt mit OmniHTTPd (heißt mittlerweile OmniSecure) hatte und mit dem sehr zufrieden bin, werde ich diesen Webserver erklären.
Zu finden ist OmniSecure unter der Adresse http://www.omnicron.ca. Die Datei ist knapp 2 MB groß und das Programm ist für den nicht kommerziellen Einsatz kostenlos erhältlich. Es handelt sich jedoch um eine laufzeitbeschränkte Version. Aber keine Sorge, die Laufzeiten sind ziemlich lang und sobald sie abgelaufen ist, steht eine neue Version zur Verfügung. Das hat zugleich den Vorteil, dass man immer mit einer neuen Version arbeitet :-)
Es ist übrigens auch kein Problem, den Webserver auf einem älteren Computer laufen zu lassen, da die Systemanforderungen nicht so extrem sind. Laut der Firma Omnicron reicht ein Pentium mit 64 MB RAM aus und das kann ich auch bestätigen, da er auf meinem Pentium 233 mit 64 MB RAM wirklich problemlos läuft.
Nach dem Download steht eine Datei zur Verfügung, die nur ausgeführt werden muss und schon wird der virtuelle Webserver installiert. Standardmäßig schlägt das Installationsprogramm den Pfad c:\httpd vor. In dieses Verzeichnis müssen dann alle Webdokumente, die über den Server aufgerufen werden sollen, abgespeichert werden (Unterverzeichnisse sind natürlich auch möglich).
Nach der Installation bzw. dem Start des Webservers existiert ein weiteres TrayIcon in Windows - so ein kleiner gelber Blitz. Klickt man mit der rechten Maustaste darauf, kommt man zu den Einstellungen (Properties) des Webservers.
Falls beim Starten des Webservers eine Fehlermeldung kommt, dass auf das Access Log nicht zugegriffen werden kann, hilft es unter Webserver Global Settings auf die Registerkarte Logging zu gehen und dort die Haken bei Use zu entfernen. Alternativ kann man auch die Logdateien händisch anlegen (einfach eine neue Textdatei anlegen an dem vorgeschlagenen Platz anlegen und ihr den Namen AccessLog.txt bzw. ErrorLog.txt geben). Die Logdateien sind aber zum Testen nicht unbedingt erforderlich.
Da ich meine Daten alle auf dem Laufwerk D liegen hatte, habe ich hier ein paar kleine Änderungen vorgenommen, um diese Daten nicht verschieben zu müssen. Dazu gibt es bei den Einstellungen den Button Default Virtual Settings. Mit der Registerkarte Server lassen sich die notwendigen Änderungen vornehmen. In das Feld Server Root musst du den Pfad zu deinen Dateien eintragen. Bei mir ist das d:\httpd\homepage.
Eine weitere Änderung, die ich nachträglich vorgenommen habe, war, beim Default Index einen weiteren Wert hinzuzufügen. Standardmäßig steht dort index.html. Da ich jetzt aber auch index.php verwende (und es auch Menschen gibt, die index.htm verwenden), steht dort jetzt der Eintrag index.html, index.php (da kann man dann natürlich auch noch index.htm dazuschreiben). So wird zunächst in einem Verzeichnis nach der index.html gesucht und danach nach der index.php (je nach dem, in welcher Reihenfolge du die Dateien geschrieben hast).
Wenn du zweimal mit OK bestätigst, verlässt du die Serverkonfiguration wieder.
*
Brauchst du auf deinem Server die Endungen php3 oder php4 um PHP auszuführen, solltest du auf deinem virtuellen Server noch eine weitere Einstellung vornehmen.
Über Web Server Global Settings (beim Aufrufen der Properties) kommst du zur Registerkarte External. Hier kannst du einstellen, dass die Dateien mit der Endung php3 (bzw. php4) als PHP-Dateien erkannt werden sollen. Nur dann kannst du sie lokal ausführen.
Markiere dazu den Eintrag .php c:\httpd\php\php.exe und schreibe ins Feld Virtual .php3 (bzw. .php4) hinein. Anschließend klickst du auf Add. Wenn du möchtest kannst du das auch noch mit php4 machen.
So ... und jetzt kannst du eine Datei, die d:\httpd\homepage\schattenbaum\php\index.php als Adresse hat in deinem Browser über localhost/schattenbaum/php 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 (oder die IP Adresse (127.0.0.1) verwendest).
Naa? Bist du noch da? Ich hoffe :-) Und keine Sorge - das war für den Anfang mal das Schwierigste.
Ein paar Bemerkungen noch vorweg:
- Gib deinen PHP-Dateien immer die Endung php (oder php3 oder php4).
- Lade deine PHP-Dateien immer im ASCII-Modus auf den Server (bei Online-Betrieb).
- Wenn du in eine Datei schreiben willst, vergib Schreibrechte (chmod 766 oder 777 -> in WS_FTP rechte Maustaste, chmod (UNIX) und für 766 Owner - Read, Write, Execute; Group - Read, Write; Other - Read, Write. Für 777 Owner - Read, Write, Execute; Group - Read, Write, Execute; Other - Read, Write, Execute)
- Verwendest du Kommazahlen, musst du anstatt des Dezimalkommas einen Dezimalpunkt verwenden (also 1.20 anstatt 1,20)
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";
?>
Das ganze wird abgespeichert und anschließend über den Browser aufgerufen (... localhost/weitere Pfadangaben/hallo.php).
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 ä) 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> 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ö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 = "16:30 Uhr";
?>
Damit definierst du eine Variable namens uhrzeit und weist ihr den Inhalt 16:30 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 16:30 Uhr nach Wien, wo er um 16:30 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 16:30 Uhr, ausgeben wollen (oder anderes, bei dem gleich nach dem Inhalt der Variable schon wieder Text kommt), sollten wir uns gleich an die erste Fassung gewöhnen.
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 16:30) 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 :-)
<?
$anton = "Anton fuhr um ";
$uhrzeit = "16:30 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.
<?
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 .= " Samstag!";
?>
Siehst du den Punkt vor dem zweiten Ist-Gleich? Durch den Punkt wird die Variable $text so erweitert, dass Heute ist Samstag! darin enthalten ist.
Wenn du keinen Punkt verwenden würdest, würde die Variable zunächst den Text Heute ist enthalten und dann durch Samstag! überschrieben werden, da durch das reine Ist-Gleich ein neuer Wert zugewiesen wird.
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
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 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">
<br><br>
<center>
<input type="submit" value="OK">
</center>
</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 ü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 noch ein Zeilenabstand und ein zentrierter Submitbutton.
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ährst du, wenn du das
Fenster wieder schließ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. Da Sicherheit aber immer wichtiger wird, gibt es eine Sicherheitseinstellung bei PHP, die auf immer mehr Servern aktiv ist. Dabei muss man von anderen Seiten übergebene Variablen extra übernehmen und zwar durch $_POST["Variablenname"];. 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 (zB 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.
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 damit 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=Schaffarik
In der Datei test.php kannst du jetzt durch $_GET["Vorname"] und $_GET["Nachname"] auf die Inhalte (Claudia bzw. Schaffarik) der Variablen zugreifen.
Das sieht dann zB so aus (hier sieht man auch die Übergabe von get-Variablen):
<?php
echo "Vorname: ", $_GET["Vorname"];
echo "<br>";
echo "Nachname: ", $_GET["Nachname"];
?>
Eventuell funktionieren auf deinem Server auch die Kurzformen $_post["Variablenname"]; und $_get["Variablenname"];. Die Anwendung erfolgt genauso, wie bei den langen Formen.
Na? Noch immer alles klar? Fein, dann können wir ja jetzt 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 Schreibeweisen möglich und letztendlich musst du die finden, die dir am sympathischsten ist.
Wenn wir unsere Rechnung richtig schön 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; ?>
Die Ausgabe davon sieht dann 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;
?>
Zunächst werden den beiden Variablen wieder die Werte zugewiesen und anschließend gebe ich diese Variablen einfach aus, um zu zeigen, welchen Wert sie enthalten:
<?php
echo $count1;
echo "<br>";
echo $count2;
?>
Das sieht jetzt so aus:
0
10
Und jetzt werden die Variablen erhöht (bzw. verringert) ...
<?php
$count1++;
$count2--;
?>
Und danach neu ausgegeben:
<?php
echo $count1;
echo "<br>";
echo $count2;
?>
Jetzt steht hier:
1
9
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 der Wert 1 wurde und aus 10 der Wert 9.
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 denken, du siehst schon, dass die Variante mit $count1++ und $count2-- um einiges schneller geschrieben werden kann :-)
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, die häufig Verwendung finden.
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 zB 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 Bedinung und eine Anweisung aussehen kann ...
<?php
if($user == "Claudia")
{
echo "Bist du Cloud?";
}
?>
Hierbei wurde (zB 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 Bedinung 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 Cloud, 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-Bedinung 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.
Bei dieser Variante musst du jedoch 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.
Aber zunächst schauen wir einmal, was passiert, wenn wir zwei Bedingungen zugleich überprüfen wollen.
Logische Operatoren
Manchmal reicht es nicht aus, wenn man nur eine einzige Bedingung überprüft - wenn ich zB 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 egal.
BTW ... das ist 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.
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 zB durch ein Formular übergeben, noch nicht abspeichern, was jedoch oft wünschenswert ist.
Zu diesem Zweck gibt es die Arbeit mit Dateien.
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 zB. 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 keinen 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);
?>
Ein Dank an Lord Xeen, der mich auf einen Fehler aufmerksam machte.
Aber durch die Arbeit mit Dateien sind auch viele weitere Anwendungen realisierbar. Man braucht sie für Log-Dateien und sie sind sogar in Postkartenskripten vorhanden ...
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 (zB bei Postkarten) ist es vollkommen egal, welchen Modus du wählst, sofern er schreiben unterstützt. 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 auf das Programmieren aus, bei dem man darauf achten muss, sondern auch dann, wen zB 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(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 die \" durch einfache Anführungszeichen bevor wir den Text ausgeben..
<?php
$text = "PHP setzt viele \"Sonderzeichen\" ein,
da gewisse Zeichen in PHP
eine spezielle Bedeutung haben.";
$text = ereg_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..
Damit ist zwar ein Wunsch von uns erfüllt, aber die \" stören noch immer und außerdem werden unsere Zeilenumbrüche nicht angezeigt.
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,
da gewisse Zeichen in PHP
eine spezielle Bedeutung haben.";
$text = ereg_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 der sogenannten UNIX-Timestamp ermittelt wird. Diese beinhaltet die Anzahl der Sekunden seit dem 1.1.1970 um 00:00 Uhr. Dadurch entsteht zB ein solcher Wert: 1219977172
Dieser Wert ist jedoch, wie ich zugeben muss, in seiner momentanen Form nicht brauchbar. Stell dir vor, du willst auf deiner HP 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 die UNIX-Timestamp.
<?php
$timestamp = time();
?>
Mit diesem kurzen Befehl time() wird die aktuelle UNIX-Timestamp ermittelt und - zur weiteren Verarbeitung - in der Variable timestamp gespeichert.
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.
Um ein Datum inkl. Uhrzeit im Stil von 29.08.2008 - 04:32 Uhr auszugeben gibt es zB 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 keine UNIX-Timestamp an, wird automatisch das aktuelle Datum (und die aktuelle Uhrzeit) ermittelt :-)
Wenn du ein Datum hast und dieses in die UNIX-Timestamp umwandeln willst, gibt es auch dafür einen Befehl:
<?php
$timestamp = mktime(16,59,0,8,7,2001);
?>
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 7.8.2001 um 16:59:00 Uhr.
Erinnerst du dich, dass ich vorher gesagt habe, Monatsnamen und Wochentage werde in PHP nur in Englisch angezeigt? Nun, es gibt auch eine Möglichkeit, die deutschen Namen (oder jede beliebige andere Sprache) zu verwenden. Dazu 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 Variable 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 zB 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 zB 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 Wert 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, nich 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 zB 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 die aufgefallen, dass wir hier im Gegensatz zu den if-Anweisungen keine geschwungenen Klammern verwendet haben. Das funktioniert in diesem Fall, weil wir nur einen 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 (zB wenn man überprüfen möchte, ob gerade ein bestimmter Wert ausgegeben werden soll.
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, können wir Arrays verwenden.
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 mittels $tage[Nummer des Tages].
Und die Nummer des Tages wird mit der Datumsfunktion ermittelt:
<?php
$tag = date("w");
?>
Ich lege hier keine Timestamp fest, da ich das heutige Datum verwenden möchte. Und jetzt erfolgt die Ausgabe über ...
<?php
echo $tage[$tag];
?>
Das ergibt Freitag.
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=>"Feber",
3=>"Mä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 ...
<?php
$monat = date("n");
?>
... und anschließend wird das Monat ausgegeben ...
<?php
echo $monate[$monat];
?>
Das Ergebnis hierzu ist August.
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 zB 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.
Mittels eines Formulars wird die Variable zahl an die darauffolgende Datei (form4.php) übergeben. In der 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++;?).
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 einen Formmailer oder sogar einen Newsletterservice realisieren.
! Achtung !
Die Mailfunktion funktioniert nicht am virtuellen Webserver, da dieser über keinen eigenen Mailserver verfügt. Du kannst den Mailversand nur auf deinem Webspace testen.
Die Funktion ist so aufgebaut:
<?php
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 zB so aussehen:
<?php
$empfaenger = "email@domain.de";
$betreff = "PHP ist toll";
$text = "Hallo Claudia!
$sender 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öchtest, benutze bitte die Adresse $sendermail.";
mail($empfaenger, $betreff, $text,
"From: $sender <$sendermail>");
?>
Das 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.
Die Variablen sender und sendermail werden dabei durch das Formular festgelegt - alle anderen werden selbst angeführt.
Durch weitere Parameter ist es mit dieser Funktion auch möglich HTML-Mails zu versenden.
<?php
$extra = "From: $sender <$sendermail>\n";
$extra .= "Content-Type: text/html\n
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. Dieser muss genau so übernommen werden und macht aus einer Mail eine HTML-Mail.
Der Text der Nachricht muss in dem Fall mittels HTML formatiert werden!
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 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 Tabellenlayouts 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. Ich verwende dafür normalerweise immer die Endung .inc, weil ich das angenehm finde, es ist aber wirklich jede Endung möglich. Mein Menü speichere ich also zB als menue.inc ab - www.schattenbaum.net/php/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 menue.inc zu bleiben:
<?php
include("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. Ein Beispiel dafür ist meine eigene Linkliste beim Schattenbaum. Diese baut sich, dank einer Zufallsfunktion jedes Mal anders auf. 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 (1 oder 5 oder 15 ...) 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.
Verwendet man diese Funktion mehrmals innerhalb einer Seite ist es sinnvoll, eine sogenannten Startwert festzulegen. Dieser beinhaltet meistens die Uhrzeit (allerdings nicht als Timestamp, sondern als Microtime (UNIX-Zeit in Mikrosekunden), da dadurch der größtmögliche (und immer unterschiedlicher) Zufallswert erzielt wird).
Das sieht dann so aus:
<?php
srand(microtime()*1000000);
$zufall = rand(1,100);
?>
Mit srand wird der Startwert festgelegt und dieser bekommt den Wert der Mikrotime (microtime()) mal eine Million (hat ebenfalls den Grund, dass dadurch die Zufallswerte verbessert werden). Anschließend wird wiederum eine Zufallszahl zwischen 1 und 100 ermittelt.
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 zählen diese meiner Meinung nach nicht zu den wichtigsten Dingen, die man braucht, um mit PHP etwas zu programmieren.
Solltest du eine bestimmte Funktion suchen, wirf bitte einen Blick auf www.php.net. Dort findest du alle Funktionen, die dir in PHP zur Verfügung stehen (es gibt auch eine Suchfunktion und du kannst sogar die Sprache auf Deutsch umstellen, wenn dir die Erklärungen auf Englisch zu schwierig erscheinen).
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