This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
... aktuelles Fachwissen rund um die Uhr – zum Probelesen, Downloaden oder auch auf Papier.
www.InformIT.de
PHP & MySQL Dynamik für Ihre Webseiten! GIESBERT DAMASCHKE
Ü leicht
Ü
klar
eBook Die nicht autorisierte Weitergabe dieses eBooks ist eine Verletzung des Urheberrechts!
Ü
sofort
Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.
Die Informationen in diesem Produkt werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für Verbesserungsvorschläge und Hinweise auf Fehler sind Verlag und Herausgeber dankbar. Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Die gewerbliche Nutzung der in diesem Produkt gezeigten Modelle und Arbeiten ist nicht zulässig. Fast alle Hardware- und Softwarebezeichnungen, die in diesem Buch erwähnt werden, sind gleichzeitig auch eingetragene Warenzeichen oder sollten als solche betrachtet werden. Umwelthinweis: Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt.
Dynamische Webseiten mit PHP ................... 14 Datenbankbasiertes Webpublishing ...............15 Xampp!.......................................................... 16 Xampp installieren .........................................18 Der erste PHP-Test .........................................21 HTML und PHP .............................................23 Kommentare in PHP ......................................25 Textausgaben mit »echo«...............................26 Variablen & Konstanten ................................. 28 Der Einsatz von Variablen..............................31 Rechnen und Verknüpfen in PHP................... 34 Abkürzungen und Zuweisungen ....................38 Kleine Typenlehre .......................................... 39 Menschen, nicht Maschinen: Rasmus Lerdorf ..............................................41
2
Entscheidungen, Schleifen und Funktionen
42
Logische Vergleiche und Verknüpfungen .......44 Wenn ... dann ... andernfalls!.........................46 Auf Inhalt überprüfen .....................................49 Alternative Abfragen ......................................50 Datumsangaben in PHP .................................51 Programmschleifen ........................................55 Das kleine Einmaleins ....................................59 Funktionen.....................................................61 Variablentypen überprüfen ............................64 Menschen, nicht Maschinen: Brian Behlendorf ............................................65
5
3
Ein Besucherzähler und anderes
66
Drei Projekte für die Homepage.....................68 Grundlegende Dateioperationen mit PHP ......68 Den Besucherzähler als Grafik ausgeben .......72 Wiederholungen ausfiltern mit Cookies .........75 Ein Kennwortschutz für Webseiten................. 77 Eingaben überprüfen ......................................79 Externe Dateien einbinden .............................80 Ein Kontaktformular auf der Webseite ............83 Die Auswertung .............................................85 Die Ausgabe .................................................. 88 Menschen, nicht Maschinen: David Axmark, Allan Larsson und Michael »Monty« Widenius ...........................91
4
Daten strukturieren mit Arrays Ein Umfrageformular mit PHP ........................94 Array: Ein Name, viele Werte.........................95 Ein universales Formular ................................98 Die Auswahl als Drop-Down-Menü ...............99 Das Formular als Tabelle..............................101 Die Ergebnisdatei anlegen und testweise auslesen ........................................102 Assoziative Arrays: Namen statt Nummern...105 Die Umfrage auswerten ...............................107 Das Ergebnis ausgeben ................................110 Datumsangaben mit Arrays ..........................112 Ein intelligentes Menüsystem .......................114 Menschen, nicht Maschinen: Bruce Perens ..119
6
92
Inhaltsverzeichnis
5
Datenbanken mit MySQL und PHPMyAdmin
120
Warum eigentlich eine Datenbank? .............122 PHPMyAdmin ..............................................123 Kopfüber in die Datenwelt ...........................128 Mit PHP auf MySQL-Daten zugreifen...........133 Datensätze ändern .......................................137 Tabellenstruktur ändern ...............................141 Tabellen sichern, löschen und importieren ..145 Menschen, nicht Maschinen: Eric S. Raymond...........................................149
6
Eine Logdatei mit MySQL und PHP
150
Kurzer Rückblick und neue Aussichten ........152 Woher des Wegs, Webwanderer? ................153 Datentypen in MySQL .................................155 Datentypen für Zeichenketten ......................155 Numerische Datentypen ..............................157 Datums- und Zeittypen ................................159 Die Tabelle der Logdatei ..............................161 Daten via PHP in eine Tabelle schreiben .....162 Die Logdaten in die Logdatei schreiben .......164 Die Logdatei vollständig ausgeben ...............167 Die Einträge einer Tabelle zählen.................171 Die Logdatei bereichsweise ausgeben ..........175 TIMESTAMP-Einträge einfügen.....................177 TIMESTAMP-Einträge formatiert auslesen .....180 Das komplette Script ....................................182 Menschen, nicht Maschinen: Richard M. Stallman ....................................183
7
7
Eine Mottomaschine für die Homepage 184 Öfter mal was Neues: Die Mottomaschine ...186 Die Motto-Tabelle........................................186 Das Eingabeformular....................................187 Die Auswertung ...........................................189 Berechneter Zufall .......................................191 Ein Abstecher zu den Lottozahlen ................193 Die Motto-Auswahl und -Ausgabe ...............194 Das Bearbeitungsmodul ...............................196 Ausgewählte Mottos anzeigen......................200 Das ausgewählte Motto bearbeiten und speichern ..............................................201 Der Maschinenraum ....................................204 Einträge aus einer MySQL-Tabelle löschen ..208 Eine neue Funktion für die Mottomaschine ..208 Jede Menge Formulare .................................209 Das Auswertungsscript anpassen..................211 Die Ausgaberoutine anpassen ......................213 Zufallszugriffe mit MySQL ...........................216 Die Bildermaschine: Dateiverzeichnisse mit PHP lesen ..............................................218 Menschen, nicht Maschinen: Linus Torvalds..............................................221
8
Fauler Zauber und andere Fallgruben Fehler gibt es immer wieder ... .....................224 Fauler Zauber mit »Magic Quotes« ..............224 Magic Quotes ausgetrickst ...........................227 Sichere Variablenübernahme .......................228 Die fehlerbereinigte Mottomaschine ............231 Die Sollbruchstellen die() und exit() .............233 Datei- und Datenbankfehler abfangen..........234 Fehlermeldungen bei fehlgeschlagenem Lese- oder Schreibzugriff..............................238 Fehlermeldungen protokollieren ..................241 Die Protokolldatei auslesen und löschen......244 Typische Fehler............................................246 Menschen, nicht Maschinen: Kai Oswald Seidler und Kay Vogelgesang ....249
8
222
Inhaltsverzeichnis
9
Ein Gästebuch
250
Konzept eines Gästebuches .........................252 Eine Tabelle in Handarbeit...........................252 Das Grundgerüst ..........................................256 Die Vorschauroutine ....................................259 Inhalte und Formate .....................................262 Einen Beitrag speichern................................264 Gästebuch ausgeben ....................................266 Der Gästebuch-Prototyp ..............................268 Fehleingaben abfangen ................................269 Umbrüche einfügen .....................................272 Das Gästebuch komplett ..............................274 Menschen, nicht Maschinen: Larry Ewing ....277
10
Ein Weblog
278
Was ist ein »Weblog«? .................................280 Die Zielvorgabe ...........................................280 Das Grundgerüst ..........................................282 Die Tabellen ................................................286 Das Admin-Interface ....................................287 Noch einmal: Datums- und Zeitfunktionen ..291 Menüeinträge auslesen und anzeigen...........293 Das Blog anzeigen .......................................294 Zwischenstand .............................................298 Einen Kennwortschutz einfügen ...................298 Die Formatierung der Eingabe......................302 Schönheitsreparatur beim Menü...................303 Menschen, nicht Maschinen: Sie, ich, wir alle ...........................................304
Internetlexikon
305
Stichwortverzeichnis
311
9
Liebe Leserin, lieber Leser, warum interessiert man sich für PHP und MySQL und greift zu einem Buch zu diesem Thema? Aus Neugier, allgemeinem technischen Interesse oder weil man Programmiersprachen und Datenbanken als solche so ungemein spannend findet? Mag sein. Doch vor allem wohl deshalb, weil einem die immer gleichen Webseiten aus reinem HTML nicht mehr genügen. Weil man sich die Arbeit erleichtern will. Weil man es leid ist, unzählige Dokumente zu öffnen, zu bearbeiten und zu speichern, nur weil sich ein Eintrag geändert hat. Weil man seine Homepage flexibler und leistungsfähiger gestalten möchte. Weil man endlich die Vorteile dynamischer Websites nutzen möchte. Wenn Sie das wollen, dann sind Sie bei diesem Buch genau richtig. Es wird Sie Schritt für Schritt mit ausführlichen Erklärungen von den ersten zögerlichen Anfängen in PHP und MySQL bis zur Erstellung eines Weblogs begleiten und Sie mit den erstaunlichen Möglichkeiten dieses dynamischen Duos vertraut machen. Wenn Sie bislang nur mit HTML gearbeitet haben, dann halten Sie sich gut fest – mit PHP und MySQL revolutionieren Sie Ihre Homepage und stoßen in bislang völlig ungeahnte Bereiche vor. Dieses Buch setzt auf die motivierende Kraft des schnellen Erfolgserlebnisses, auf den Praxiskick, der einem dabei hilft, den Spaßfaktor einer nur scheinbar so trockenen Sache wie dem Programmieren zu entdecken. Die Funktionen von PHP und MySQL werden Ihnen nicht um ihrer selbst willen erklärt, sondern immer mit Blick auf ihren möglichen und nützlichen Einsatz in der Praxis. An zahlreichen praxisnahen Beispielen lernen Sie, wie Sie schon mit wenigen Code-Zeilen in PHP die erstaunlichsten Dinge realisieren können. Schließlich müssen Sie kein Informatikstudium absolviert haben, um PHP und MySQL gewinnbringend einzusetzen. Alles, was Sie tun müssen, ist: anfangen. Wenn Sie Anregungen, Kritik oder Fragen zu diesem Buch haben, mailen Sie diese bitte an [email protected]. P.S.: Die in diesem Buch vorgestellten Beispiele und Scripts finden Sie unter der Adresse http://www.damaschke.de/scripts/ zum Download.
11
Kapitel 1
Erste Schritte in PHP
Mit der serverbasierten Scriptsprache PHP und einer MySQLDatenbank sind dynamische Webseiten kein Problem. In diesem Kapitel bekommen Sie einen ersten Einblick in die erstaunlichen Möglichkeiten, die Ihnen mit PHP & MySQL offen stehen.
Ihr Erfolgsbarometer
Das lernen Sie neu: Dynamische Webseiten mit PHP
14
Xampp!
16
Xampp installieren
18
HTML und PHP
23
Textausgaben mit »echo«
26
Variablen & Konstanten
28
Rechnen und Verknüpfen in PHP
34
Kleine Typenlehre
39
13
Dynamische Webseiten mit PHP PHP ist eine serverbasierte Scriptsprache, die aus statischen HTML-Dateien dynamische, interaktive und flexible Webseiten macht. Mit PHP ist es möglich, Webseiten in Abhängigkeit von individuellen Vorgaben des Benutzers zu erzeugen. Man kann Formular-Eingaben verarbeiten, in einer MySQLDatenbank speichern, zu einem späteren Zeitpunkt wieder auslesen und erneut anzeigen. Script- vs. Programmiersprache
Bei einer Programmiersprache wird der Programmcode durch einen so genannten Compiler in Maschinencode umgesetzt und als direkt ausführbare Programmdatei gespeichert. Die Anweisungen eines Scripts werden dagegen bei jedem Aufruf erneut sequentiell abgearbeitet. Scripts sind normalerweise rechenintensiver und langsamer als Programme, was bei heutigen Computern nicht mehr so stark ins Gewicht fällt.
Eine traditionelle Webseite liegt als HTML-Code auf der Festplatte des Webservers vor. Fordert ein Besucher diese Seite an, so schickt der Webserver eine exakte Kopie der Datei an den Webbrowser des Besuchers, der die gesendeten Daten analysiert und schließlich die Webseite anzeigt. Bei PHP ist das prinzipiell anders. Hier ist eine Webseite kein statisches HTML-Dokument, sondern diese Seite wird erst in dem Moment erzeugt, in dem ein Besucher sie anfordert. Auf dem Server steht gewissermaßen nur die Rohfassung oder Konstruktionsanweisung der angeforderten Seite parat. Diese Rohfassung besteht aus mehr oder weniger viel normalem HTML-Code, in den PHP-Anweisungen eingebettet sind. Diese Anweisungen können sehr einfacher Natur sein – zum Beispiel: »Füge am Kopf jeder angezeigten Seite das aktuelle Datum ein« –, aber auch beliebig komplex werden. Der Besucher einer Webseite merkt davon jedoch nichts. Er fordert unter einer bestimmten Webadresse ein bestimmtes Dokument von einem Webserver an. Der Webserver führt die PHP-Anweisungen in diesem Dokument aus und setzt das gewünschte HTML-Dokument zusammen, das dem Besucher schließlich übermittelt wird. Der Besucher bekommt die PHP-Anweisungen also nicht zu Gesicht, sondern nur das fertige Ergebnis und wird sich allenfalls wundern, warum eine Webseite, die er immer mit der gleichen Adresse aufruft, immer wieder anders aussieht. Selbst ein Blick in den Quelltext der
14
Datenbankbasiertes Webpublishing
Webseite verrät – anders als bei clientbasierten Scriptsprachen wie etwa Javascript, die erst im Browser ausgeführt werden – nichts über ihre Entstehung. Lediglich die Dateiendung, etwa »index.php« statt »index.html«, zeigt, dass es sich hier um eine dynamisch erzeugte Webseite und nicht um eine statische HTML-Datei handelt.
Datenbankbasiertes Webpublishing Durch den Einsatz von PHP wird also eine HTML-Seite flexibel, doch erst in Kombination mit einer MySQL-Datenbank entfaltet sich das volle Potenzial dynamischer Websites in Form eines datenbankbasierten Webpublishings. MySQL
SQL ist die Abkürzung für Standard Query Language. Ein SQL-Server ist ein Datenbankserver, der mittels SQL-Kommandos gesteuert wird. MySQL ist eine sehr leistungsfähige Open-Source-Variante von SQL.
Das klingt jetzt vielleicht etwas rätselhaft, daher dazu rasch ein einfaches Beispiel. Sie möchten, dass beim Aufruf der Startseite »index.php« Ihrer Website ein wechselndes Motto zur Begrüßung angezeigt wird. Beim klassischen HTML-Design würden Sie dieses Motto direkt in den HTML-Code der Startseite integrieren. Möchten Sie das Motto ändern, müssen Sie die Datei index.php im Editor öffnen, das Motto austauschen und die geänderte Datei schließlich wieder auf den Webserver laden. Beim Einsatz von PHP und MySQL gehen Sie dagegen grundlegend anders vor. Die verschiedenen Mottos, die beim Aufruf von index.php angezeigt werden sollen, liegen als Einträge in einer MySQL-Tabelle vor, die zum Beispiel »meine_mottos« heißt. Der Code von index.php enthält dagegen keine direkt anzuzeigenden Texte mehr, sondern nur noch einige HTML-Codes zur Formatierung der Seite und verschiedene PHP-Anweisungen. Wird die Seite aufgerufen, so wird das nächste Motto aus »meine_mottos« ausgelesen, in die Seite eingefügt und die so erzeugte HTML-Datei an den Browser geschickt. Möchten Sie ein Motto hinzufügen, löschen oder korrigieren, so verändern Sie die Daten in der MySQL-Tabelle – die Datei index.php bleibt davon völlig unberührt. Idealerweise enthält die Datei nur die Formatierungen der angezeigten Seite, während die Inhalte aus einer Datenbank ausgelesen werden, die wiederum von Ihnen jederzeit problemlos verändert werden kann.
15
Denkt man dieses Beispiel etwas weiter, gelangt man schnell zu Content Management Systemen, bei denen der Webautor sich nicht mehr mit der Formatierung und HTML-Umsetzung seiner Texte herumschlägt, sondern diese Texte über ein Formular in eine Datenbank eingibt und die webtaugliche Aufbereitung PHP und MySQL überlässt.
Xampp! PHP-Code schreiben ist nicht schwer, ihn auszuführen dagegen sehr: Wie bei HTML benötigen Sie zum Schreiben von PHP-Code keine besonderen Werkzeuge, sondern nur einen einfachen Texteditor, zur Not reicht selbst Notepad, das zum Lieferumfang von Windows gehört. Doch anders als bei HTML können Sie Ihre PHP-Scripte nicht dadurch testen, dass Sie sie lokal in einem Browser öffnen. Schließlich muss PHP-Code von einem PHP-tauglichen Webserver abgerufen werden, damit er ausgeführt wird.
Mit Xampp für Windows können Sie auf Ihrem Windows-Computer einen vollwertigen Webserver mit PHP, MySQL und mehr installieren.
16
Xampp!
Inzwischen gehören PHP und MySQL glücklicherweise zum Standardangebot bei praktisch allen Webhostern, so dass Sie keine Schwierigkeit haben werden, hier einen passenden Anbieter zu finden. Problematisch aber bleibt, dass Sie zum Testen Ihrer Scripts jedes PHPDokument zuerst in ein Testverzeichnis auf dem Webserver hochladen und anschließend mit Ihrem Browser abrufen müssen. Dazu müssen Sie nicht nur permanent online sein (was, falls Sie keine Flatrate oder Standleitung haben, ziemlich ins Geld geht), das kostet auch Zeit und Nerven. Das muss doch einfacher gehen. Die benötigte Serversoftware stammt aus der Open-Source-Szene und kann kostenlos aus dem Internet geladen werden. Nun müssen Sie also nur noch einen lokalen Apache-Webserver mit allen benötigten Modulen installieren und konfigurieren, einen MySQL-Server aufsetzen, und schon – das ist Ihnen zu kompliziert? Ach, wissen Sie was? Mir auch. Apache-Webserver
Wer bei dem Namen des wohl wichtigsten Webservers im Internet an Karl May, Winnetou und edle Indianer denkt, liegt gar nicht mal so falsch. Der Name des Webservers, so sein Entwickler Brian Behlendorf in einem Interview aus dem Jahr 2000, verdankt sich dem Wunsch, ein fantastisches, abenteuerliches Bild zu beschwören. Erst nach der Namensfindung fiel ihm auf, dass »Apache« auch ein hübsches Wortspiel ist: »a patchy Server«, ein geflickter, gepatchter Server. Schließlich bestehe Serversoftware aus einm Haufen Software-Flicken und -Modulen und wird ständig weiterentwickelt und gepatcht.
Glücklicherweise müssen wir uns auch nicht in die ganz und gar nicht trivialen Untiefen der Webserverinstallation und -konfiguration einarbeiten, um mit PHP und MySQL spannende Dinge anstellen zu können. Denn da gibt es lobenswerterweise die Apachefriends, die uns sehr viel Arbeit abgenommen haben und eine lokale Serverinstallation auf Mausklick bereit halten. Kostenlos, versteht sich. Die Lösung des Problems lautet Xampp für Windows. Dabei ist »ampp« die Abkürzung für Apache, MySQL, PHP und Perl, das X steht als Platzhalter für verschiedene Betriebssysteme. Xampp für Windows wird mitunter auch als Wampp bezeichnet. Aber das klingt nicht so hübsch, also lassen wir das. Xampp für Windows läuft unter allen Windows-Installationen ab Version Windows 98 und bietet ein fix und fertig konfiguriertes und sofort einsatzbe-
17
reites Programmpaket, in dem sich alles findet, was Sie zum Betrieb eines Webservers benötigen. Neben den Bestandteilen, die bereits im Namen genannt werden, sind dies zum Beispiel auch FTP-Server, Mailserver und verschiedene Hilfsprogramme wie das unverzichtbare Tool PHPMyAdmin, das im Rahmen dieses Buches noch eine große Rolle spielen wird.
Xampp installieren Die jeweils aktuelle Version von Xampp für Windows finden Sie unter www.apachefriends.org. Alle Scripts in diesem Buch wurden mit der zum Zeitpunkt der Manuskripterstellung aktuellen Version 1.4.5 von Xampp getestet. Die Installation und Inbetriebnahme von Xampp wird auf den Webseiten der Apachefriends ausführlich beschrieben und im Folgenden exemplarisch vorgestellt.
Wenn Sie die EXE-Datei der Installationsdatei laden, beschränkt sich die Xampp-Installation auf wenige Mausklicks.
1 Laden Sie die gewünschte Installationsdatei von Xampp für Windows von den
Webseiten der ApacheFriends und entpacken Sie diese Datei im Hauptverzeichnis Ihrer Festplatte, d. h. normalerweise auf Laufwerk C:\. Am einfachsten geht dies, indem Sie die EXE-Version der Installationsdatei laden und starten. Anschließend finden Sie das Verzeichnis »xampp« im Hauptverzeichnis, also etwa C:\xampp\.
2
Wechseln Sie nun in das neu angelegte Xampp-Verzeichnis auf Laufwerk C:\ und starten Sie die Datei »xampp_start.exe«. Es öffnet sich ein DOS-Fenster, das Sie über den Start von Apache und MySQL informiert. Dieses Fenster dürfen Sie nicht schließen, aber Sie können es natürlich minimieren.
18
Xampp installieren
Ein Klick und schon läuft auf Ihrem lokalen Windows-Computer ein Web- und ein MySQL-Server.
3 Rufen Sie nun in Ihrem Webbrowser die Adresse http://localhost/ auf. Wenn
alles geklappt hat – und es gibt eigentlich keinen Grund, warum es das nicht getan haben sollte –, sehen Sie nun die Xampp-Begrüßungsseite.
Na, wer sagt's denn: Xampp stellt Ihnen alles zur Verfügung, was Sie zur PHP- und MySQL-Entwicklung benötigen.
19
4
Um die Arbeit mit Xampp zu beenden und alle laufenden Server wieder zu stoppen, rufen Sie im Xampp-Verzeichnis einfach die Datei »xampp_stop.exe« auf.
Und tschüss – so einfach, wie Sie die verschiedenen Server starten, so einfach beenden Sie sie auch wieder.
WICHTIGE DURCHSAGE!
Sobald Xampp gestartet ist, läuft auf Ihrem Computer unter anderem ein vollwertiger Webserver und ein Datenbankserver. Sollten Sie zu diesem Zeitpunkt online sein, sind diese Server – und damit Ihr Computer – via Internet zu erreichen und angreifbar. Die Absicherung der verschiedenen Serverdienste auf Ihrem Computer ist zwar möglich, aber nicht ganz trivial und ihre Beschreibung würde den Rahmen dieses Buches sprengen. Am einfachsten und sichersten ist es, wenn Sie während der Zeit, in der Sie Xampp laufen lassen, einfach offline bleiben.
20
Der erste PHP-Test
Sobald Sie via Xampp den Apache-Webserver gestartet haben, ist Ihr Computer im Internet erreichbar. Falls Sie während der Arbeit mit Xampp online sind, sollten Sie den Zugriff von außen auf Ihren Computer möglichst unterbinden. Allerdings ist nicht jede Personal Firewall (hier: Sygate) in der Lage, bei Zugriffen auf den Server zwischen denen, die von der lokalen Maschine erfolgen (und also harmlos sind) und denen, die von außen kommen (und die ein potentielles Sicherheitsrisiko darstellen) zu unterscheiden.
Der erste PHP-Test Sobald Sie Xampp installiert und probeweise gestartet haben, müssen Sie nur noch das Webverzeichnis für Ihre Tests vorbereiten und schon steht Ihrer PHP- und MySQL-Entwicklung nichts mehr im Weg.
1
Im Xampp-Verzeichnis finden Sie einen Ordner namens »htdocs«. Auf dieses Verzeichnis greift der Apache-Webserver standardmäßig als Webverzeichnis zu. Heißt Ihr Xampp-Verzeichnis »C:\xampp« und rufen Sie im Browser die Adresse http://localhost/index.php auf, dann schickt Apache die Datei C:\xampp\htdocs\ index.php an den Browser. Nach der Installation von Xampp finden sich im Webverzeichnis zahlreiche Beispiele, Demos und Dokumente.
2
Benennen Sie das Verzeichnis »htdocs« um, etwa in »htdocs_xampp«, und legen Sie ein neues Verzeichnis »htdocs« an. Dieses neue, leere Verzeichnis entspricht einem neuen und leeWren Verzeichnis bei einem Webhoster.
Sichern Sie das originale Xampp-Webverzeichnis, indem Sie es einfach umbenennen und legen Sie ein neues htdocs-Verzeichnis für Ihre Tests an.
21
Wenn Sie jetzt Xampp starten und Ihren lokalen Webserver mit http://localhost/ aufrufen, erhalten Sie eine Fehlermeldung. Kein Wunder, das Webverzeichnis ist ja leer und das Verzeichnis, auf das Apache in der XamppKonfiguration standardmäßig zugreifen will, existiert nicht mehr. Aber das ändern wir jetzt und setzen dabei sofort eine Prise PHP ein.
3
Öffnen Sie Ihren Editor, notieren Sie in einem neuen, leeren Textdokument das folgende Kommando =phpinfo()?>
4
und speichern Sie die Datei im neu angelegten »htdocs«-Verzeichnis auf Ihrer Festplatte unter dem Namen »index.php«.
Kleine Ursache, große Wirkung: Die unscheinbare Code-Zeile führt zu einer kompletten Konfigurations-Anzeige der installierten PHP-Version.
5 Starten Sie Xampp und rufen Sie in Ihrem Browser die Adresse http://localhost/
index.php auf. Sie sehen nun nicht den kurzen Textschnipsel, den Sie gespeichert haben, sondern eine umfangreiche Tabelle mit Informationen über die laufende PHPInstallation. Wenn Sie einen Blick in den Quelltext der Seite werfen, sehen Sie, dass der unscheinbare Einzeiler offensichtlich eine vollständige HTML-Seite erzeugt hat.
22
HTML und PHP
Was ist da passiert? Nun, ganz einfach: Wir haben vom Webserver eine Datei mit der Endung ».php« angefordert. Anhand dieser Endung erkennt der Server, dass es sich hier nicht um eine normale HTML-Datei handelt, die er unbesehen durchreichen kann, sondern dass sich in der Datei ein Script befindet, das er ausführen muss, bevor die Datei versandfertig ist. Der Webserver öffnet die Datei und stößt sofort auf eine spitze Klammer, gefolgt von einem Fragezeichen: . Diese Zeichenkombination signalisiert den Beginn von PHP-Code. Das sich anschließende Gleichheitszeichen = ist eine (allerdings nur hier, direkt am Anfang eines PHP-Blocks, gültige) Abkürzung für die Anweisung echo, die dem Server signalisiert, dass er den folgenden Text in die HTML-Datei einfügen soll. Der folgende Text besteht jedoch aus einer neuen Anweisung bzw. Funktion und lautet phpinfo(). Als Ergebnis liefert diese Funktion eine vollständige HTML-Datei mit verschiedenen Systeminformationen. Diesen Code fügt der Webserver nun an die Stelle der echo-Anweisung bzw. des Gleichheitszeichens in die Datei ein. Anschließend stößt der Server auf ?>, womit ihm das Ende der PHP-Anweisung signalisiert wird. Alles, was jetzt folgt, ist wieder normaler HTML-Code. Da aber nichts mehr folgt, wird die Datei abgeschlossen und an den Browser geschickt, der die Datei index.php angefordert hat. Der Browser bekommt eine aus seiner Perspektive völlig normale HTML-Seite und stellt sie wie gewohnt dar.
HTML und PHP Das kleine Beispiel zeigt zwar recht eindrucksvoll, wie aus einer unscheinbaren PHP-Anweisung eine ausgewachsene Webseite wird, ist aber, zugegeben, auch ein wenig untypisch. Zum einen kommt es in der Praxis so gut wie nie vor, dass Sie bei Ihren Scripts auf eigenes HTML völlig verzichten, zum anderen werden Sie eigentlich immer mehr als nur eine Zeile PHP ausführen wollen. Eines allerdings zeigt das Beispiel sehr schön: PHP-Code kann nicht nur an jeder beliebigen Stelle in einem HTML-Dokument eingefügt werden, er benötigt noch nicht einmal HTML. Man muss nur darauf achten, dass der PHP-Code korrektes HTML erzeugt, das in einem Webbrowser dargestellt werden kann. Der PHP-Code selbst besteht aus beliebig vielen Anweisungen, die durch ein Semikolon voneinander getrennt werden (das Semikolon darf fehlen, wenn es sich um die letzte Anweisung eines Scripts handelt). Damit der Interpreter den Code eindeutig von der HTML-Umgebung, in die er einge-
23
bettet ist, trennen kann, wird er normalerweise durch ein eingeleitet und mit ?> abgeschlossen. Die Einleitung können Sie auch als arbeiten können. Ein typisches Grundgerüst einer HTML-Datei mit PHP-Code sieht also beispielsweise so aus: Hier steht irgendwas in HTML echo "Eine PHP-Anweisung"; echo "noch eine PHP-Anweisung"; echo "und eine dritte"; ?> Hier ist nochmal HTML
Der Vollständigkeit halber sei angemerkt, dass PHP-Scripte innerhalb einer HTML-Datei nicht nur einmal und an einer Stelle, sondern beliebig oft an beliebigen Stellen eingefügt werden können. Die verschiedenen Scripte werden dabei als zusammengehörig aufgefasst. So können Sie in dem einen Script auf Informationen und Daten zugreifen, die Sie in einem anderen Script innerhalb der Datei benutzen. Frei platzierbar
Im Gegensatz zu anderen Scriptsprachen wie etwa Javascript können PHP-Anweisungen an beliebigen Stellen auftauchen – auch außerhalb des HTML-Bereichs. So ist es zum Beispiel möglich, die HEADERDaten einer HTML-Datei über ein PHP-Script zu gestalten, bevor die Datei angezeigt wird.
Wir werden in späteren Beispielen verschiedene praktische Anwendungen kennen lernen. Der typische Einsatz dieser Eigenheit besteht etwa darin, dass Sie in einem Script bestimmte Berechnungen durchführen, die Ergebnisse dieser Berechnungen ausgeben und anschließend weitere Berechnungen erstellen. Die Ergebnisausgabe erfolgt in solchen Fällen typischerweise der Einfachheit halber in HTML, anschließend wechselt man wieder zum Script.
24
Kommentare in PHP
= "Irgendwas in PHP, und gleich ..."; ?> Ausgabe und Formatierung der Ergebnisse in HTML = "... geht es weiter mit PHP"; ?>
Kommentare in PHP Wenn Sie ein PHP-Script schreiben, dann wissen Sie natürlich, was die einzelnen Anweisungen bewirken sollen. Das wissen Sie vermutlich auch noch am nächsten Tag. Oder in der nächsten Woche. Aber wissen Sie das auch noch im nächsten Monat oder gar im nächsten Jahr? Aus diesem Grund sollten Sie sich angewöhnen, Ihren Code zu kommentieren. Das mag zur Zeit noch reichlich übertrieben anmuten, schließlich sind die einzelnen Beispiele bislang praktisch selbst erklärend, doch Sie wissen ja – früh übt sich ...
1
Wenn Sie nur kurze Kommentare und Hinweise einfügen, dann setzen Sie einen doppelten Schrägstrich // vor den Kommentar, PHP ignoriert (fast) alles, was nach dieser Markierung kommt bis zum Zeilenende. Das könnte etwa so aussehen: // Es folgen einige einfache echo-Beispiele echo "Dies ist eine Zeile aus PHP. "; echo "Dies ist noch eine PHP-Zeile. "; // Das war's schon ?>
Wie gesagt: Der Interpreter ignoriert die Kommentarzeichen und – fast – alles, was ihnen folgt. Einzige Ausnahme: das abschließende PHP-Tag ?>, das immer, ganz gleich, wo es auftaucht, das Ende des aktuellen PHP-Blocks bezeichnet.
2
Mehrzeilige Erläuterungen werden mit einem /* eingeleitet und mit einem */ beendet. Der Server wird den gesamten Kommentarblock bei der Abarbeitung des Scripts ignorieren: /* Dies ist ein Beispiel für einen mehrzeiligen Kommentar in PHP. Alles, was zwischen der Anfangs- und Ende-Markierung steht, wird vom Server ignoriert. Dieses Script bewirkt also: gar nichts. */ ?>
25
Textausgaben mit »echo« Wie oben schon erwähnt, geben Sie mit echo beliebigen Text aus, den der Webserver genau an der Stelle im HTML-Dokument platziert, an der die echo-Anweisung steht. Die generelle Syntax der echo-Anweisung lautet dabei echo "text";, wobei der Text in Anführungszeichen an Stelle der echo-Anweisung in das HTML-Dokument eingetragen wird. Geben Sie also innerhalb des body-Abschnitts einer HTML-Datei den PHP-Code-Schnipsel echo "Test"; ?> ein, so führt das zum gleichen Ergebnis, als würden Sie direkt Test notieren. Nun werden Sie vielleicht denken, dass das ein etwas umständlicher Weg ist, um Text in einem Browser auszugeben – das kann man mit HTML schließlich auch einfacher haben. Damit haben Sie natürlich Recht – und auch wieder nicht, wie ein einfaches Beispiel zeigt. Wenn Sie auf einer Webseite Text ausgeben, müssen Sie die Sonderzeichen kodieren, also Buchstaben wie ä, ö oder ü durch die so genannten HTMLEntities ä, ö und ü ersetzen. Bei einer Textausgabe mit echo können Sie diese Umsetzung der Sonderzeichen in die korrekten Entities einfach PHP überlassen, dafür steht die Funktion htmlentities() zur Verfügung.
1
Wir kümmern uns später darum, was genau eigentlich Funktionen sind und wie man mit ihnen umgeht, in diesem Kapitel geht es nur darum, ein paar Ergebnisse zu sehen. Geben Sie diesen (oder vergleichbaren) Code im -Teil Ihrer PHP-Testdatei ein: echo echo echo echo echo
Wenn Sie diese Datei im Browser aufrufen, werden die Texte »München«, »Fröhliche Grüße« und »Jürgen« untereinander dargestellt, was noch nicht weiter bemerkenswert ist. Werfen Sie jedoch einen Blick in den Quelltext, werden Sie feststellen, dass die Umlaute korrekt kodiert wurden, ohne dass Sie sich darum kümmern mussten.
3
Sollen mehrere Texte mit echo ausgegeben werden, kann man sie einfach mit einem Komma getrennt nacheinander notieren. So lassen sich etwa die fünf Anweisungen zu einer einzigen zusammenziehen:
So weit, so gut. Problematisch wird es jedoch, wenn Sie ein Anführungszeichen ausgeben möchten – denn das ist für echo ja das Signal für den Anfang bzw. das Ende eines auszugebenden Textes. Wenn Sie etwa die Anweisung echo "Dies ist ein "Zitat"-Test"; ?>
ausführen lassen möchten, wird PHP bei der Interpretation dieser Anweisung ins Stolpern geraten.
1
Zuerst wird der Teil echo "Dies ist ein " als abgeschlossene Anweisung zur Textausgabe interpretiert. Das sich anschließende Zitat"-Test" ist für PHP der Beginn einer neuen Anweisung – die in diesem Fall aber für das System völlig unverständlich ist, weshalb die Analyse des Scripts an dieser Stelle abgebrochen und eine Fehlermeldung ausgegeben wird.
2 Um Anführungszeichen (und auch alle anderen kritischen Zeichen) mit einer
echo-Anweisung ausgeben zu können, muss PHP signalisiert werden, dass dieses Zeichen in diesem besondern Fall nicht das Ende des auszugebenden Textes markiert, sondern im Gegenteil noch dazugehört.
3
Hierzu dient der Backslash, also der Schrägstrich von links oben nach rechts unten: \. Das direkt nach dem Backslash folgende Zeichen wird von PHP als einfacher Text und nicht als Steuerzeichen oder Kommando betrachtet. Der Vollständigkeit halber sei noch die eine Ausnahme erwähnt, bei der es genau anders herum ist. Bei der Zeichenkombination \n wird aus dem Buchstaben »n« ein Zeilenumbruch im Quelltext (was wir aber getrost ignorieren können).
Fluchthelfer
Da man mit dem Backslash gewissermaßen den strengen Regeln von PHP für einen kurzen Moment entkommt, nennt man das Zeichen auch »Escape-«, also »Flucht-Zeichen«, mit dem man die Sonderzeichen auf gut Denglisch »escapet« oder »maskiert«. Da durch den Backslash ein Steuerzeichen zu einem normalen Schriftzeichen wird, findet man gelegentlich auch die Formulierung, die Steuerzeichen würden »entwertet«.
27
4
Um das obige Beispiel also auszugeben und eine Fehlermeldung zu vermeiden, muss man die Anweisung als echo "Dies ist ein \"Zitat\"-Test"; ?>
5 formulieren. Wenn Sie nun noch htmlentities() einsetzen – echo htmlentities("Dies ist ein \"Zitat\"-Test"); ?>
6
– werden die Anführungszeichen auch noch korrekt in " aufgelöst und alles ist in schönster HTML-Ordnung.
Dank Escape-Zeichen und htmlentities() wird der auszugebende Text in korrekten HTML-Code umgesetzt.
Variablen & Konstanten Nun gut, werden Sie jetzt vielleicht einwenden, das ist ja alles ganz nett, aber immer noch nicht sonderlich aufregend. Und überhaupt – wo bleibt eigentlich die versprochene Dynamik? Gemach, gemach, wir stehen ja noch ganz am Anfang. Bislang haben wir es nur mit festen Inhalten zu tun gehabt. Zwar hat PHP mehr oder weniger stark in die Anzeige eingegriffen, aber wirklich flexibler oder gar dynamischer als normales HTML ist das noch nicht. Doch durch den Einsatz von Variablen wird alles anders.
28
Variablen & Konstanten
Variablen sind symbolische Bezeichner für Speicherbereiche, die vom Programmierer mit beliebigen Werten gefüllt werden und die im Programmablauf ihren Wert verändern können. Um die konkrete Verwaltung des Arbeitsspeichers kümmert sich der Computer, wir deklarieren nur einen symbolischen Bezeichner als Variable und weisen der Variable einen Wert zu. Wie eine Variable benannt wird, bleibt dem Programmierer überlassen, man muss nur daran denken, dem Namen ein führendes Dollarzeichen zu geben, an dem PHP erkennt, dass es sich hier um eine Variable handelt. Bei der Namenswahl setzt Ihnen PHP kaum Grenzen, Sie können Buchstaben, Ziffern und den Unterstrich _ benutzen. Nicht erlaubt sind Anführungsund andere Steuerzeichen, Leerzeichen und Ziffern am Anfang des Variablennamens. Tabu sind natürlich auch die Wörter und Begriffe, mit denen PHP selbst arbeitet. Zwar könnten Sie eine Variable namens $echo benutzen, aber das ist keine gute Idee, führt dergleichen doch sehr schnell zu Tippfehlern, missverständlichem Code und ähnlich unerfreulichen Dingen. Außerdem unterscheidet PHP zwischen Groß- und Kleinschreibung.
•
Gültige Variablennamen sind zum Beispiel $ergebnis, $Ergebnis und $erGEBnis. Das ist für unser Ohr zwar drei Mal der gleiche Name, für PHP sind es aber drei völlig verschiedene Werte (Tippfehler bei Variablen sind eine der häufigsten Fehlerquellen in PHP-Scripts).
•
Ungültige Variablennamen sind dagegen $12_Uhr_Mittags (Ziffer am Anfang des Namens), $High Noon (Leerzeichen im Namen) oder $HighNoon (das Minus-Zeichen ist als Sonderzeichen in einem Variablennamen nicht erlaubt). Namensgebung
Auch wenn Umlaute in Variablennamen erlaubt sind, sollten Sie darauf ebenso verzichten wie auf andere Sonderzeichen. Stellen Sie sich vor, Sie müssten Ihren PHP-Code eines Tages mit einer amerikanischen Tastatur korrigieren, auf der es die deutschen Sonderzeichen nicht gibt. Schon deshalb ist es eine gute Idee, wann immer möglich beim kleinsten gemeinsamen Nenner aller Computersysteme, dem Standard-ASCII-Code, zu bleiben. Um Verwirrungen und Fehlerquellen in umfangreicheren Scripten zu vermeiden, sollten Sie sich auf Buchstaben und Ziffern beschränken und versuchen, im Laufe der Zeit ein festes Schema zur Benennung von Variablen zu entwickeln.
29
Bevor Sie mit einer Variablen arbeiten können, müssen Sie diese im Programm bekannt machen, bzw. Sie müssen sie »deklarieren«. Das ist in manchen Programmiersprachen eine recht aufwändige Sache, in PHP ist das glücklicherweise sehr einfach. Sie deklarieren eine Variable dadurch, dass Sie ihr einen Wert zuweisen. Das geschieht durch eine simple Gleichung: $Name = Wert: $Sinn_des_Lebens = 42; $Benutzer_Name = "Käpt'n Blaubär"; $Die_Zahl_Pi = 3.14159265; ?>
Jede Wertzuweisung ist eine abgeschlossene, gültige PHP-Anweisung und muss folglich von den anderen durch ein Semikolon getrennt werden. Wie Sie sehen, kann eine Variable unterschiedliche Inhalte haben: Die Variable $Sinn_des_Lebens ist eine ganze Zahl; $Benutzer_Name ist normaler Text, oder, wie das im Programmierjargon heißt, eine Zeichenkette bzw. ein »String« und bei $Die_Zahl_Pi handelt es sich um eine Fließkommazahl. Hinweis
Bei Fließkommazahlen wird ein Punkt an Stelle eines Kommas gesetzt, also 3.14 statt 3,14.
Die Wertzuweisung an eine Variable kann an beliebiger Stelle in Ihrem PHP-Script erfolgen. Dort, wo Sie eine Variable benötigen, führen Sie diese einfach durch eine Wertzuweisung ein, um den Rest kümmert sich PHP. Neben den Variablen gibt es in PHP natürlich auch noch Konstanten, die in der Praxis allerdings nur eine eher untergeordnete Rolle spielen. Wenn man sie benötigt, ist es gut, dass sie zur Verfügung stehen – aber man benötigt sie sehr selten. Konstanten sind, wie die Variablen, symbolische Namen für Speicherzellen, in denen Sie beliebige Werte ablegen können. Doch anders als bei Variablen können Sie diesen Wert nach der Initialisierung der Konstante im Programmablauf nicht mehr verändern. Konstanten werden auch nicht über eine einfache Wertzuweisung definiert, sondern über die Funktion define(Name, Wert). Für Name tragen Sie den Namen der zu definierenden Konstanten ein, für Wert den Wert, den Sie ihr geben möchten: define(PI, 3.14159265);
30
Der Einsatz von Variablen
Anders als Variablen besitzen Konstanten kein führendes Dollarzeichen. Damit man sie besser vom übrigen Code unterscheiden kann, hat es sich eingebürgert, sie durchgehend groß zu schreiben, also BENUTZER statt Benutzer oder benutzer. Da Konstanten kein eindeutiges Erkennungszeichen besitzen, kann man sie auch, anders als Variablen, nicht so ohne weiteres mit anderem Text mischen und über echo ausgeben. Die Variable $name kann zum Beispiel mit echo "Der Name lautet: $name"; ?>
ausgegeben werden, bei der Konstanten BENUTZER funktioniert das nicht, da PHP sie bei echo "Der Name lautet: BENUTZER"; ?>
nicht als Konstante erkennt, sondern als auszugebenden Text interpretiert. Hier muss man zum Beispiel zu zwei echo-Anweisungen greifen: define(BENUTZER,"Donald Duck"); echo "Der Name lautet:" ; echo BENUTZER; echo " "; ?>
Wenn Sie, so wie in diesem Beispiel, mit echo-Anweisungen mehrere Zeichenketten oder Werte nacheinander ausgeben, dann können Sie daraus auch eine echo-Anweisung machen, der Sie die auszugebenden Werte mit einem Komma getrennt übergeben: echo "Der Benutzername lautet: ",BENUTZER," "; ?>
Der Einsatz von Variablen Variablen dienen dazu, einen Wert, der sich im Laufe des Programms verändert – etwa durch eine Berechnung oder Benutzereingabe – zu verwalten. Hierzu ein kleines Beispiel, das gleich zeigt, in welche Bereiche Sie mit PHP vorstoßen und etwas ausführt, was mit HTML nicht geht.
31
Wie Sie vielleicht wissen, kann man (unabhängig von der eingesetzten Scriptsprache) auf zwei Arten mit dem Browser Werte an den Webserver übermitteln, mit get und mit post. Um post kümmern wir uns später im Zusammenhang mit der Auswertung von Formularen, bei get wird eine Wertzuweisung einfach mit einem Fragezeichen an die Adresse einer Webseite als URL-Parameter gehängt. So wird etwa mit
http://localhost/index.php?t=test zum Beispiel die Datei index.php aufgerufen und dabei der Variablen t der Wert test zugewiesen. Damit der Webserver mit dieser Zuweisung überhaupt etwas anfangen kann, muss »index.php« ein Script enthalten, das die übergebene Variable verarbeitet. Und genau das machen wir jetzt. Wir basteln eine Webseite namens »test.php«, deren Titelzeile und Text in Abhängigkeit eines mit get übergebenen Wertes verändert wird.
1 PHP speichert alle mit get übergebenen Werte in einem so genannten »Array«
namens $_GET[] (in einem Array werden mehrere Werte unter einem Variablennamen gespeichert – aber auch hier gilt: um die Details kümmern wir uns später). Um auf einen bestimmten übergebenen Wert zuzugreifen, setzt man seinen Namen (in einfachen Anführungszeichen) in die eckigen Klammern und weist einer Variablen in PHP diesen Wert zu. Die erste Zeile von »test.php« lautet also: $titel = $_GET['t']; ?>
2
Hiermit deklarieren wir die Variable $titel, indem wir ihr den mit get übergebenen Wert für t zuweisen. Als Nächstes folgt der übliche HTML-Code, mit , und . Nur dass wir statt eines fest vorgegebenen Titels die übergebene Variable einsetzen: =$titel?>
3
Sie erinnern sich – die echo-Anweisung darf direkt nach Beginn eines PHP-Scripts durch ein Gleichheitszeichen abgekürzt werden. Der eingefügte PHP-Schnipsel wird beim Abruf der Seite also durch genau den Wert ersetzt werden, der mit get übergeben wurde.
32
Der Einsatz von Variablen
4
Nun folgt der -Teil des HTML-Codes, in dem wir erneut auf die Variable zugreifen und sie mit echo ausgeben:
Guten Tag,
der Titel dieser Webseite lautet =$titel?>
5
Wie Sie sehen, können Sie HTML und PHP lustig durcheinander mischen, Sie müssen nur darauf achten, dass das PHP-Script sinnvollen HTML-Code erzeugt. In diesem Fall wird der übergebene Wert noch einmal zur Kontrolle kursiv ausgegeben.
6
Und da das ganze eine korrekte HTML-Datei ergeben soll, setzen wir nun noch den üblichen Abschluss einer HTML-Datei:
An diesem Beispiel sehen Sie nicht nur den Einsatz von Variablen, sondern können auch erkennen, dass PHP-Code an beliebigen Stellen und beliebig oft in den HTML-Code eingefügt werden kann.
Wenn Sie die Datei »test.php« nun speichern, können Sie über den getParameter bestimmen, was in der Titelzeile der Webseite stehen soll, indem Sie den gewünschten Namen mit ?t= an den Dateinamen anhängen:
http://localhost/test.php?t=Firlefanz http://localhost/test.php?t=Irgendwas http://localhost/test.php?t=Ein Test Falls Sie bei der Eingabe Leerzeichen benutzen, werden diese vom Browser automatisch als %20 kodiert, bevor der Wert an den Webserver übergeben wird, aus Ein Test wird also Ein%20Test. Diese Kodierung wird lediglich für die Verarbeitung der Leerzeichen benötigt und erscheint in der Adresse-
33
zeile des Browser, aber natürlich nicht in der Titelzeile oder im Text der Webseite.
Der Beginn einer wundervollen Freundschaft: PHP verarbeitet einen übergebenen Wert und macht den ersten Schritt zu einer dynamischen Webseite. In diesem Beispiel kann der Benutzer durch die Änderung des übergebenen Parameters Titel und Text der Webseite ändern.
Rechnen und Verknüpfen in PHP Bislang haben wir uns mit Variablen beschäftigt, die als Wert einen String enthielten, also eine Zeichenkette bzw. Text. Das klassische Einsatzgebiet von Variablen sind aber Zahlenwerte und Ziffern. Es ist kein Problem, mit PHP beliebige Rechenoperationen durchzuführen. Dazu müssen Sie den Variablen lediglich die gewünschten Werte zuweisen und mit den üblichen arithmetischen Operatoren verknüpfen. Die vier Grundrechenarten werden wie gewohnt notiert, Variablen können mit festen Zahlen kombiniert werden und auch die üblichen Klammerregeln gelten bei Berechnungen mit PHP. Damit auch die Rechenanweisungen nicht gar zu trocken daher kommen, setzen wir sie in einem kleinen dynamischen Beispiel ein. Diesmal werden via get zwei Werte übergeben, die von PHP auf verschiedene Weise verrechnet werden. Die Berechnung samt Ergebnis wird als HTML-Seite im Browser angezeigt. Um mit get mehr als einen Wert zu übergeben, müssen Sie die Zuweisungen lediglich mit einem Ampersand, dem so genannten »kaufmännischen Und« & verketten, etwa so: test.php?a=5&b=7.
34
Rechnen und Verknüpfen in PHP
Bei diesem Scriptbeispiel werden zwei Werte eingelesen, auf verschiedene Weise miteinander verrechnet und die Ergebnisse anschließend ausgegeben.
1
Das PHP-Script zur Berechnung und Ausgabe der beiden Zahlen wird im body der Datei notiert. Das Script zerfällt dabei in drei Teile. Zuerst werden die beiden Rechenwerte über $_GET[] zwei Variablen zugewiesen. Das sieht zum Beispiel so aus: $a = $_GET['a']; $b = $_GET['b']; ?>
2
Anschließend führt PHP die Berechnungen durch und speichert die Ergebnisse in vier weiteren Variablen. Dieser Teil kann dann so aussehen (natürlich können Sie auch andere Berechnungen durchführen und andere Variablennamen wählen): $addition = $a + $b + 27; $subtraktion = $a - $b - 3; $multiplikation = $a * ($b - 19); $division = $a / ($b + 61); ?>
35
3
Schließlich müssen die Ergebnisse noch mit echo ausgegeben werden. Hier ist eine Eigenheit bemerkenswert: Innerhalb einer Zeichenkette in Anführungszeichen werden zwar die Variablen erkannt und durch ihre aktuellen Werte ersetzt, ein echo "$a" gibt also den aktuellen Wert der Variablen $a aus, nicht den Text »$a«. Das gilt jedoch nicht für die Rechenanweisungen, die zu einfachem, auszugebenden Text werden. Mit echo "3 + 2" führen Sie also keine Berechnung durch, sondern geben den Text »3 + 2« aus. echo echo echo echo ?>
Am Ende jeder Zeile fügen wir noch ein -Tag für den Zeilenumbruch ein, ansonsten würden die vier Zeilen ohne Leerzeichen aneinander gehängt werden.
Hier werden mit get die beiden Werte a=5 und b=10 an das Script in test.php übergeben, das sie auf verschiedene Weisen verrechnet und das Ergebnis ausgibt.
Bei sehr vielen Berechnungen in PHP werden Sie ein und denselben Variablennamen sowohl auf der linken als auch der rechten Seite des Zuweisungsoperators = finden, wie zum Beispiel hier: $variable = $variable + 4; ?>
Diese Notierung sieht auf den ersten Blick vielleicht seltsam aus, erklärt sich aber ganz einfach. PHP führt nämlich zuerst die Rechenoperationen auf der rechten Seite aus, addiert den Wert 4 zum aktuellen Wert von $variable. Dieses Ergebnis wird danach $variable als neuer Wert zugewiesen.
36
Rechnen und Verknüpfen in PHP
Im folgenden Beispiel wird $variable mit dem Wert 5 initialisiert. In der nächsten Codezeile wird zum aktuellen Wert von $variable 4 addiert und das Ergebnis $variable zugewiesen. Damit wird der ursprüngliche Wert von $variable überschrieben und $variable hat nun den Wert 9: $variable = 5; $variable = $variable + 4; ?>
Die mit weitem Abstand wohl häufigste arithmetische Operation, die in PHP vorkommt, ist die kontinuierliche Erhöhung bzw. Verminderung einer Variablen um den Wert 1. Normalerweise würde man dies als $counter = $counter + 1; ?>
oder als $counter = $counter - 1; ?>
notieren. Doch da speziell diese Operationen sehr häufig benötigt werden, gibt es dafür auch eine Abkürzung. Mit $counter++ wird der Wert der Variablen $counter um eins erhöht, mit $counter-- entsprechend um eins vermindert. In beiden Fällen handelt es sich um abgeschlossene Anweisungen, die mit einem Semikolon von anderen Anweisungen in einem PHP-Script getrennt werden müssen: $a = 10; $a++; $b = 5; $b--; ?>
Hier wird der Variablen $a der Wert 10 zugewiesen und anschließend um eins erhöht, $a hat also nun den Wert 11. Ähnliches passiert mit der Variablen $b, die mit dem Wert 5 initialisiert wird und danach um eins vermindert wird, also den Wert 4 besitzt. Wie Sie hier sehen, können Sie mehrere Anweisungen in einer Zeile notieren. Sie müssen nur darauf achten, alle Anweisungen mit einem Semikolon ; voneinander zu trennen. Neben den vier Grundrechenarten Addition, Subtraktion, Multiplikation und Division kennt PHP noch den so genannten »Modulo«-Operator, mit dem der ganzzahlige Rest einer Division ermittelt wird. Das kennen Sie vielleicht
37
noch aus der Grundschule, bevor die Kommarechnung dran kam: »10 geteilt durch 3 ist 3, Rest 1«, »12 geteilt durch 5 ist 2, Rest 2«. Mit der Einführung von »modulo« lässt sich das auch als »10 modulo 3 = 1« bzw. als »12 modulo 5 = 2« formulieren. Das Zeichen für Modulo ist in PHP das Prozentzeichen %, die genannten Beispiele könnte man dann folgendermaßen in PHP notieren: $a = 10 % 3; // $a hat den Wert 1 $b = 12 % 5; // $b hat den Wert 2 ?>
Benötigt werden Modulo-Operationen zum Beispiel dann, wenn man wissen möchte, ob eine Zahl durch eine andere Zahl restlos teilbar ist. Wenn zum Beispiel $a % 2 den Wert 0 ergibt, dann ist $a restlos durch 2 teilbar, also eine gerade Zahl. Außer den arithmetischen Operatoren +, –, *, /, % und dem Zuweisungsoperator = kennt PHP schließlich noch den so genannten Verkettungsoperator, mit dem Sie beliebige Zeichenketten verknüpfen können. Dieser Operator besteht in einem einfachen Punkt und hängt den rechten Operanden an den linken an. Nach der Ausführung dieses Codefragments: $teil_1 = "Guten "; $teil_2 = "Abend"; $gruss = $teil_1.$teil_2; echo $gruss; ?>
hat die Variable $gruss demnach den Wert Guten Abend.
Abkürzungen und Zuweisungen Programmierer sind faule Menschen und tippen ungern auch nur ein Zeichen zu viel ein. Das klingt Ihnen jetzt zu negativ? Dann formulieren wir das einfach um: Programmierer sind vorsichtige Menschen, die wissen, dass jeder Tippfehler ein Script ruinieren kann und die daher möglichst wenig Zeichen eintippen. So oder so – es kann nicht überraschen, dass es für verschiedene häufig vorkommende Operationen Abkürzungen gibt, die Ihnen Tipparbeit ersparen und gleichzeitig die Tippfehlergefahr verringern. Einige davon haben Sie schon kennen gelernt.
38
Kleine Typenlehre
So kann die echo-Anweisung direkt zu Beginn eines Scripts mit einem Gleichheitszeichen abgekürzt werden, die folgenden zwei Anweisungen führen zum gleichen Ergebnis: echo "Dies ist ein Test"; ?> = "Dies ist ein Test"; ?>
Ebenfalls bekannt sind die Erhöhung oder Verminderung einer Variablen um den Wert eins mit einem nachgestellten doppelten Plus- bzw. Minus-Zeichen: $a++; // $a wird um eins erhöht $b--; // $b wird um eins vermindert ?>
Darüber hinaus können Sie immer dann, wenn Sie auf beiden Seiten des Gleichheitszeichens dieselbe Variable notieren – etwa in $a = $a + 27 oder $string = $string.$text –, die Notation durch spezielle Zuweisungsoperatoren abkürzen: Operator
Beispiel
Erläuterung
+=
$a += 27
Identisch mit: $a = $a + 27
–=
$a –= 3
Identisch mit: $a = $a – 3
*=
$a *= 19
Identisch mit: $a = $a * 19
/=
$a /= 61
Identisch mit: $a = $a / 61
%=
$a %= 42
Identisch mit: $a = $a % 42
.=
$a .= $b
Identisch mit: $a = $a.$b
Kleine Typenlehre Eine Variable kann unterschiedliche Inhalte haben: ganze Zahlen, Fließkommazahlen und Texte. Je nach ihrem Inhalt ist sie von einem bestimmten »Typ«. Die unterschiedlichen Typen werden mit englischen Begriffen benannt.
•
Eine ganze Zahl heißt auf Englisch »integer«; wenn $a = 1961, dann ist $a also vom Typ integer.
•
Besitzt eine Variable einen gebrochenen bzw. Fließkommawert wie beispielsweise $euro_kurs = 1.95583, dann ist diese Variable vom Typ double.
39
•
Enthält die Variable eine Zeichenkette (englisch: »string«) wie etwa in $text = "Hallo Welt!", dann ist diese Variable vom Typ string.
•
Außerdem kann eine Variable das Ergebnis eines logischen Vergleiches repräsentieren und die Werte »wahr« oder »falsch« annehmen, bzw. true oder false. In diesem Fall ist der Datentyp boolean (benannt nach dem englischen Logiker George Boole).
Jeder Datentyp stellt andere Anforderungen an den Arbeitsspeicher, was bei vielen Programmiersprachen dazu führt, dass Sie zum Beispiel einer einmal als Integer angelegten Variablen im Programmablauf keinen Fließkommawert zuweisen können und einer einmal als Fließkommazahl deklarierten Variablen keinen Text. PHP nimmt es da nicht so genau und macht es Ihnen damit einfacher und schwieriger zugleich. Der Datentyp einer Variablen wird dem Wert angepasst, der der Variablen zugewiesen wird. So kann im Laufe eines Scripts eine Variable zuerst als string eingeführt und später als integer oder double weiterverarbeitet und am Schluss als boolean benutzt werden. Es ist zwar angenehm, dass Sie sich als PHP-Programmierer nicht sonderlich um die Datentypen kümmern müssen, doch es gibt auch einen Haken: PHP führt auch unsinnige Anweisungen ohne Fehlermeldung aus und addiert zum Beispiel klaglos eine Fließkommazahl und einen Text: $text = "Hallo Welt"; $zahl = 42.42; $summe = $text + $zahl; echo $summe; ?>
Diese Zeilen werden anstandslos verarbeitet. Da sich ein Text nicht zu einer Zahl addieren lässt, versucht PHP zuerst, den Text als Zahl zu interpretieren, was mit Hallo Welt aber nicht gelingt. Daher wird aus der String-Variablen $text mit dem Wert Hallo Welt intern eine Variable vom Typ double mit dem Wert 0 und zur Double-Variablen $zahl addiert. Als Ergebnis wird dann 42.42 ausgegeben werden. Etwas anders sieht die Sache aus, wenn eine string-Variable eindeutig als Zahl zu interpretieren ist. In diesem Fall gelingt die interne Umwandlung und das Rechenergebnis ist korrekt. Genau das passiert übrigens bei unserem weiter oben gezeigten Script, dem Werte als URL-Parameter übergeben werden. Jede mit get übergebene Variable ist für PHP vom Typ string. Doch solange ihr Wert aber auch eindeutig als Zahl gelesen werden kann, kann PHP damit auch richtig rechnen.
40
Menschen, nicht Maschinen
Diese automatische Konvertierung und Anpassung der Datentypen müssen Sie immer im Hinterkopf behalten und bei Ihren Variablen-Operationen berücksichtigen. Sollte eine Berechnung in einem Script einfach mal nicht das tun, was sie tun soll und Sie den Fehler nicht finden, dann kontrollieren Sie die Datentypen Ihrer Variablen – vielleicht hat sich ja irgendwo ein kleiner Fehler mit großen Folgen eingeschlichen.
Menschen, nicht Maschinen: Rasmus Lerdorf
In diesem Buch geht es um eine Programmiersprache und um Computer, also um Maschinendinge. Doch Maschinen sind nur Mittel zum Zweck, am Anfang und am Ende steht immer der Mensch. Ohne die Kreativitiät und das Engagement von Menschen gäbe es weder PHP noch Computer, ohne den Wunsch, mit anderen Menschen zu kommunzieren, gäbe es kein Internet und keine Webseiten. Da es in diesem Buch mitunter reichlich trocken und technisch zugehen wird, soll wenigstens am Abschluss jedes Kapitels kurz auf die Menschen hingewiesen werden, denen wir PHP, MySQL & Co. verdanken. Die Reihenfolge der Nennung ist dabei mehr oder weniger ein Zufallsprodukt und drückt keine Wertung aus. Den Anfang macht Rasmus Lerdorf. Lerdorf wurde 22. November 1968 in Qeqertarsuaq, Grönland, geboren. Mit 17 sammelte er seine ersten Unix-Erfahrungen und hat seither zahlreiche Beiträge zur Open Source Software geleistet. Sein wohl folgenreichstes und wichtigstes Projekt begann er 1994/1995: Lerdorf ist der Erfinder von PHP und bis heute einer der wichtigsten Köpfe im PHP-Team. Das Kürzel stand ursprünglich für »Personal Homepage Tools«, eine Name, der spätestens ab der Version 3 (die maßgeblich von Zeev Suraski and Andi Gutmans entwickelt wurde) nicht mehr passend schien. Im April 1998 stimmte man in der PHP-Community über die Bedeutung des Akronyms ab. Das Rennen machte »PHP: Hypertext Preprocessor«. Die Homepage von Rasmus Lerdorf finden Sie unter der Adresse http://lerdorf.com/.
41
Kapitel 2
Entscheidungen, Schleifen und Funktionen
In diesem Kapitel lernen Sie, wie Sie in PHP Entscheidungen fällen, Befehlsfolgen mehrfach abarbeiten und eigene Anweisungen erzeugen können. Damit sind wir bereits bestens gerüstet, um Formulareingaben zu verwalten.
Ihr Erfolgsbarometer
Das können Sie schon: Sie haben Ihren lokalen Computer mit Xampp in einen Webserver mit PHP verwandelt und Ihre ersten Erfahrungen mit der Sprache gemacht.
16
Das lernen Sie neu: Logische Vergleiche und Verknüpfungen
44
Wenn ... dann ... andernfalls!
46
Datumsangaben in PHP
51
Programmschleifen
55
Funktionen
61
Variablentypen überprüfen
64
43
Logische Vergleiche und Verknüpfungen Bevor wir uns mit den verschiedenen Möglichkeiten beschäftigen, in PHP Entscheidungen zu fällen, müssen wir einen kleinen Abstecher in die Logik machen. Denn die Basis aller Entscheidungen in einem Programm oder Script ist der Vergleich zweier Werte. Dieser Vergleich wird durch so genannte Vergleichsoperatoren ausgedrückt. Wenn Sie zwei Zahlen oder Variablen miteinander vergleichen, dann kann dieser Vergleich zu einem von drei möglichen Ergebnissen führen. Entweder ist der eine Wert kleiner als der andere, oder er ist größer oder beide Werte sind gleich. Um diese Verhältnisse zwischen zwei Werten zu beschreiben, gibt es drei verschiedene Operatoren, mit denen die Werte zu einem Ausdruck verbunden werden.
• • •
$a < $b: Der Wert der Variablen $a ist kleiner als der Wert der Variablen $b. $a > $b: Der Wert der Variablen $a ist größer als der Wert der Variablen $b. $a == $b: Der Wert der Variablen $a ist gleich dem Wert der Variablen $b (da das Gleichheitszeichen in PHP bereits als Zuweisungsoperator
benutzt wird, wird die Gleichheit zweier Werte durch ein doppeltes Gleichheitszeichen dargestellt). Man kann diese drei Grundformen auch kombinieren und erhält so folgende Ausdrücke:
•
$x <= $y: Der Wert der Variablen $x ist kleiner oder gleich dem Wert der Variablen $y.
•
$x >= $y: Der Wert der Variablen $x ist größer oder gleich dem Wert der Variablen $y.
Schließlich besteht noch die Möglichkeit, die Ungleichheit zweier Werte zu formulieren:
44
•
$x != $y: Der Wert der Variablen $x ist ungleich dem Wert der Variablen $y.
•
In Abhängigkeit vom Wert der auf diese Art verknüpften Variablen ist ein so formulierter Ausdruck entweder wahr oder falsch.
•
In PHP lassen sich diese Ausdrücke auswerten und je nach Ergebnis (true oder false) der weitere Verlauf über Wenn-dann-Strukturen des Scripts steuern: Wenn ein bestimmter Ausdruck true ist, dann mache dieses, andernfalls tue jenes.
Logische Vergleiche und Verknüpfungen
Für $a = 1 und $b = 2 gilt: Ausdruck
Wert
Erläuterung
$a < $b
true
Der Ausdruck ist wahr, weil 1 kleiner als 2 ist.
$a > $b
false
Der Ausdruck ist falsch, weil 1 nicht größer als 2 ist.
$a == $b
false
Der Ausdruck ist falsch, weil 1 nicht gleich 2 ist.
$a != $b
true
Der Ausdruck ist wahr, weil 1 ungleich 2 ist.
$a <= $b
true
Der Ausdruck ist wahr, weil 1 kleiner oder gleich 2 ist.
$a >= $b
false
Der Ausdruck ist falsch, weil 1 weder kleiner noch größer als 2 ist.
Die einfachen Vergleiche erlauben auch nur einfache Abfragen. Mitunter möchte man aber etwas komplexere Bedingungen formulieren und die Ausführung eines Programmcodes von mehr als nur einem Ausdruck abhängig machen, etwa: »Wenn die Variable $a kleiner als $b ist und die Variable $c kleiner als $d, dann ...«. In diesem Fall müssen Sie die unterschiedlichen Ausdrücke mit einem logischen and (»und«) bzw. einem logischen or (»oder«) verknüpfen. Der so gebildete neue Ausdruck erzeugt in Abhängigkeit von den Wahrheitswerten der verknüpften Ausdrücke einen neuen Wahrheitswert.
1
Eine and-Verknüpfung ist dann (und nur dann) wahr, wenn alle verknüpften Ausdrücke wahr sind. Eine and-Verknüpfung lässt sich mit dem doppelten Ampersand && abkürzen: ($a < $b) and ($c > $d) ($a < $b) && ($c > $d) ?>
2
Eine or-Verknüpfung ist dann wahr, wenn mindestens einer der verknüpften Ausdrücke wahr ist. Eine or-Verknüpfung lässt sich mit dem doppelten Pipesymbol || abkürzen: ($a < $b) or ($c > $d) ($a < $b) || ($c > $d) ?>
45
3 Eine xor-Verknüpfung ist eine Verschärfung der or-Verknüpfung. Sie ist dann
(und nur dann) wahr, wenn entweder der eine oder der andere verknüpfte Ausdruck wahr ist. Wenn beide wahr sind, ist eine xor-Verknüpfung falsch, wenn beide verknüpften Aussagen falsch sind, natürlich auch. Für xor gibt es keine Abkürzung:
($a < $b) xor ($c > $d) ?>
4
Schließlich können Sie jeden Wahrheitswert durch ein vorangestelltes ! negieren. Ein negierter Ausdruck ist dann wahr, wenn der Ausdruck falsch ist und umgekehrt: !($a < $b) ?>
Wenn ... dann ... andernfalls! Mit der Möglichkeit, Verhältnisse zwischen zwei (oder mehr) Variablen bzw. Aussagen zu beschreiben, sind wir in PHP in der Lage, Entscheidungen zu treffen. Die klassische »Wenn-dann«-Verknüpfung wird in PHP mit einer if-Anweisung realisiert. Der umgangssprachliche Satz »Wenn eine bestimmte Bedingung zutrifft, dann tue dieses«, ließe sich in PHP abstrakt so formulieren: if (Bedingung) Anweisung;
Wenn Sie mehr als nur eine Anweisung ausführen wollen, dann müssen Sie die folgenden Anweisungen wie gewohnt mit einem Semikolon voneinander trennen und mit einer Mengenklammer zusammenfassen: if (Bedingung) { Anweisung 1; Anweisung 2; Anweisung 3; }
Die in der Mengenklammer zusammengefassten Anweisungen werden dann – und nur dann! – ausgeführt, wenn die Bedingung den Wert true besitzt, ansonsten ignoriert PHP den gesamten Block.
46
Wenn ... dann ... andernfalls!
Die Mengenklammer
Mit der Mengenklammer werden bei bestimmten Konstruktionen mehrere Anweisungen zusammengefasst. Die verschiedenen Anweisungen innerhalb der Mengenklammer werden wie gewohnt durch ein Semikolon getrennt. Nach der Mengenklammer steht jedoch kein Semikolon, auch wenn noch andere Anweisungen folgen sollten.
Jetzt sind wir in der Lage, ein kleines Script zu schreiben, das entscheiden kann, ob zwei übergebene Werte gleich sind, oder ob der erste kleiner bzw. größer als der zweite Wert ist. Dazu werden zuerst zwei mit get übergebene Werte in Variablen abgelegt. Anschließend überprüfen drei aufeinanderfolgende if-Abfragen die möglichen Beziehungen der beiden Werte und geben, falls sie zutreffen, einen kurzen Text aus. $a $b if if if ?>
= $_GET['a']; = $_GET['b']; ($a < $b) echo "A ist kleiner als B"; ($a > $b) echo "A ist größer als B"; ($a == $b) echo "A ist gleich B";
Speichern Sie das kleine Script im -Teil von z. B. »test.php« und rufen Sie es mit zwei Werten auf, etwa als
http://localhost/test.php?a=5&b=1 Das funktioniert schon ganz gut, hat aber noch einen Schönheitsfehler. Bei jedem Aufruf werden alle if-Abfragen abgearbeitet, auch dann, wenn dies gar nicht nötig ist. Wenn etwa die erste Abfrage zutrifft und die echo-Anweisung ausgeführt wird, können die übrigen beiden if-Abfragen übersprungen werden, weil sie garantiert nicht mehr zutreffen können. Für diesen Fall gibt es die else- Anweisung. Das englische Wort bedeutet so viel wie »sonst, anders, anderenfalls«. In Kombination mit if sind damit Konstruktionen der Art »Wenn die Bedingung zutrifft, tue jenes, andernfalls unternehme dieses« formulierbar. Trifft die Bedingung in der if-Abfrage zu, wird die damit verbundene Anweisung ausgeführt und der else-Teil ignoriert. Im umgekehrten Fall – die Bedingung ist falsch – wird der if-Teil ignoriert und die mit else verbundene Anweisung ausgeführt.
47
Die Konstruktion hat folgende Grundstruktur: if (Bedingung) Anweisung; else Anweisung;
Auch bei else können Sie mehrere, mit einem Semikolon getrennte Anweisungen mit einer Mengenklammer zusammenfassen (nach der, wie bei if, dann kein Semikolon mehr folgt): if (Bedingung) { Anweisung 1; Anweisung 2; } else { Anweisung 1; Anweisung 2; }
Mit der elseif-Anweisung lässt sich diese Abfrage noch weiter ausbauen. Hiermit lassen sich mehrere Bedingungen nacheinander überprüfen. Am Schluss steht schließlich die else-Anweisung, die ausgeführt wird, wenn keine der Bedingungen erfüllt wurde: if (Bedingung 1) Anweisung; elseif (Bedingung 2) Anweisung; else Anweisung;
Dabei können Sie auch mehrere elsif-Anweisungen aufeinander folgen und so verschiedene Bedingungen überprüfen lassen: if (Bedingung 1) Anweisung; elseif (Bedingung 2) Anweisung; elseif (Bedingung 3) Anweisung; elseif (Bedingung 4) Anweisung; elseif (Bedingung 5) Anweisung; else Anweisung;
Natürlich gibt es auch bei der if-elseif-else-Struktur die Möglichkeit, mit Mengenklammern mehrere Anweisungen zu bündeln. Hier gelten die gleichen Regeln wie bei if oder else: if (Bedingung 1) { Anweisung 1; Anweisung 2; } elseif (Bedingung 2) { Anweisung 1; Anweisung 2; } else { Anweisung 1; Anweisung 2; }
48
Auf Inhalt überprüfen
Damit können wir unser kleines Beispiel schon etwas eleganter formulieren und die überflüssigen if-Abfragen durch elseif und else ersetzen. Trifft die if-Abfrage zu, wird der entsprechende Text ausgegeben und das Script beendet. Andernfalls wird die elseif-Abfrage bearbeitet und erst, wenn diese ebenfalls nicht zutrifft, gelangt das Script zur else-Anweisung: $a = $_GET['a']; $b = $_GET['b']; if ($a < $b) echo "A ist kleiner als B"; elseif ($a > $b) echo "A ist größer als B"; else echo "A ist gleich B"; ?>
Auf Inhalt überprüfen Nun führt das Script zwar keine überflüssigen Abfragen mehr durch, aber einen Haken hat die Sache doch noch. Es erkennt nicht, wenn keine Werte für $a und $b übergeben wurden und führt anschließend eher unsinnige Vergleiche aus. Das mag in diesem Beispiel noch ein akzeptabler Fehler ohne große Konsequenzen sein, aber wenn wir bei einer Formularauswertung nicht überprüfen können, ob das Formular korrekt ausgefüllt wurde, kann das fatale Folgen haben. Hier hilft die Funktion isset(), der man in Klammern die Variable übergibt, die überprüft werden soll. Existiert die Variable, dann liefert isset() den Wert true zurück, andernfalls false. So lässt sich diese Funktion sehr schön in eine if-Abfrage integrieren: if (isset($a)) echo "A hat den Wert $a"; else echo "A ist nicht definiert"; ?>
Häufig wird isset() in Verbindung mit der Negation ! benutzt, um eine Konstruktion der Art »Wenn die Variable $a nicht existiert, dann ...« zu bilden, was in PHP so aussieht: if (!isset($a)) echo "Geben Sie einen Wert für A ein!"; else echo "A hat den Wert $a"; ?>
Unser Beispielscript kann nun so umgebaut werden, dass es nur ausgeführt wird, wenn für $a und $b Werte übergeben wurden, andernfalls wird ein kurzer Hinweis ausgegeben.
49
Die if-Abfragen des bisherigen Scripts rutschen dabei komplett in den Anweisungsteil einer weiteren if-Abfrage und werden dann (und nur dann) ausgeführt, wenn sowohl $a also auch $b einen Wert besitzen, die Funktion isset($a) und isset($b) den Wert true liefern: $a = $_GET['a']; $b = $_GET['b']; if (isset($a) && isset($b)) { if ($a < $b) echo "A ist kleiner als B"; elseif ($a > $b) echo "A ist größer als B"; else echo "A ist gleich B"; } else echo "Geben Sie Werte für A und B ein !"; ?>
Durch den Einsatz von isset() lässt sich überprüfen, ob eine Variable einen Wert besitzt und eine Weiterverarbeitung überhaupt sinnvoll ist.
Neben isset(), mit der man die Existenz einer Variablen überprüft, gibt es in PHP noch die Funktion empty(), die ähnlich arbeitet, aber mitunter seltsame Nebeneffekte produziert. Mit dieser Funktion wird überprüft, ob eine Variable einen Inhalt besitzt oder nicht. Fatalerweise wird allerdings der Wert 0 als »leer« gewertet, und zwar sowohl als numerischer Wert ($a=0), als auch als Zeichenkette ($a="0"). Der Einsatz dieser Funktion will also gut überlegt sein.
Alternative Abfragen Solange Sie nur zwei Werte vergleichen, werden Sie mit if, elseif und else keine Probleme bekommen. Sobald es aber darum geht, mehr als nur zwei oder drei Möglichkeiten zu beachten, tendieren if-Abfragen dazu, eher unübersichtlich zu werden. Hier greift man zur switch-Anweisung, mit der sich gewissermaßen beliebig viele if-Abfragen zusammenfassen lassen. Die switch-Anweisung wertet einen Ausdruck aus und vergleicht anschließend beliebig viele Varianten mit dem Ergebnis. Sollte eine Variante (case)
50
Datumsangaben in PHP
zutreffen, wird der dazugehörige Programmcode ausgeführt und die Anweisung über das Kommando break verlassen. Ein frei definierbarer default-Block enthält überdies Anweisungen, die ausgeführt werden, wenn keine der Vorgaben zutrifft. Die Struktur der switchAnweisung hat folgenden Aufbau: switch (Ausdruck) { case Ergebnis1: Anweisung1; break; case Ergebnis2: Anweisung2; break; // beliebig viele weitere case-Einträge default: Anweisung_default; }
Das Ergebnis des Ausdrucks wird mit den case-Vorgaben verglichen und im Falle einer Übereinstimmung der dazugehörige Code ausgeführt. Über das break-Kommando wird die switch-Anweisung verlassen und das Programm mit dem Code nach der abschließenden geschweiften Klammer fortgesetzt. Falls keine der gemachten Vorgaben mit dem Ergebnis des Ausdrucks überein stimmt, wird der default-Code ausgeführt (falls ein solcher Code vorhanden ist, diese Anweisung ist nicht zwingend erforderlich). Da dieser Code immer zuletzt steht, entfällt das break-Kommando. Achten Sie darauf, dass die case- und default-Zeilen mit einem Doppelpunkt, nicht mit einem Semikolon beendet werden! Wenn Sie das break-Kommando vergessen, dann erhalten Sie zwar keine Fehlermeldung, aber unter Umständen ein unerwünschtes Ergebnis. Sobald eine case-Anweisung zutrifft, werden sämtliche folgenden Anweisungen ausgeführt, auch die anderen case-Anweisungen. Obendrein wird die defaultAnweisung am Ende auf jeden Fall ausgeführt, was wohl kaum im Sinne des Erfinders ist.
Datumsangaben in PHP Ein einfaches, praxisnahes Einsatzgebiet für switch liefert die Datumsabfrage. Auch dafür bietet PHP – Sie ahnen es – eine eigene Funktion. Streng genommen gibt es sogar mehrere Funktionen, die sich mit Daten und Zeiten beschäftigen, wir beschränken uns hier aber nur auf die griffigste: date().
51
Der Einsatz der date()-Funktion ist recht einfach: Sie übergeben der Funktion einen oder mehrere bestimmte Parameter und die Funktion gibt Ihnen dafür das gewünschte Datum oder die gewünschte Uhrzeit zurück. Kompliziert wird die Sache nur dadurch, dass es für date() erstaunlich viele Parameter gibt, was für ein gewisses Durcheinander sorgt. Die folgende Tabelle stellt die wichtigsten date()-Parameter zusammen. Parameter für Datumsangaben mit date(): d
Tag im Monat als Zahl mit führender Null
j
Tag im Monat als Zahl ohne führende Null
w
Wochentag als Zahl von 0 – 6
m
aktueller Monat als Zahl mit führender Null (01-12)
n
aktueller Monat als Zahl ohne führende Null (1-12)
D
Wochentag, englischer Begriff, abgekürzt mit 3 Buchstaben
l
Wochentag, englischer Begriff, ausgeschrieben (Achtung: »l« ist ein kleines »L«, kein großes »i«)
F
Monat, englischer Begriff, ausgeschrieben
M
Monat, englischer Begriff, abgekürzt mit 3 Buchstaben
y
Das Jahr als zweistellige Zahl
Y
Das Jahr als vierstellige Zahl
Parameter für Zeitangaben mit date(): s
Sekunden, Zahl mit führender Null
i
Minuten, Zahl mit führender Null
H
Stunden im 24-Stunden-Format mit führender Null
G
Stunden im 24-Stunden-Format ohne führende Null
Die Parameter können bei date() auch als Bestandteile einer auszugebenden Zeichenkette benutzt werden, in der die übergebenen Parameter durch die entsprechenden Angaben ersetzt und alle anderen Zeichen unverändert ausgegeben werden. So lassen sich Datumsabfragen als kompakter Code formulieren.
52
Datumsangaben in PHP
1
Benötigt man etwa das aktuelle Datum in Form von »17. 6. 2002«, dann geht das ein wenig umständlich so: $tag = date(j); $monat = date(n); $jahr = date(Y); echo "Heute ist der $tag. $monat. $jahr"; ?>
2
Diese vier Anweisungen lassen sich jedoch zu einer einzigen einschmelzen, indem man date() die benötigten Parameter zusammen mit den Punkten und Leerzeichen nach Tag und Monat als Zeichenkette übergibt (date("j. n. Y")) und diesen Ausdruck einfach mit einem Komma an den auszugebenden Text hängt: = "Heute ist der ", date("j. n. Y"); ?>
3 Auf die gleiche Weise können wir das aktuelle Datum und die Uhrzeit mit
date() ermitteln. Die Ausgabe soll nach dem Muster Heute ist WOCHENTAG,
der DATUM. Es ist jetzt UHRZEIT Uhr erfolgen. $wochentag = date(l); $datum = date("d. F Y"); $uhrzeit = date("H:i"); echo "Heute ist $wochentag, der $datum. "; echo "Es ist jetzt $uhrzeit Uhr."; ?>
4
Allerdings ist das Ergebnis nicht so ganz das, was wir uns vielleicht vorgestellt haben – schließlich wird die Ausgabe in einem Mischmasch aus Deutsch und Englisch erfolgen.
Die date()-Funktion liefert das aktuelle Datum und Uhrzeit – allerdings auf Englisch.
53
5
Hier können wir nun durch eine switch-Abfrage die englischen Tages- und Monatsbezeichnungen durch die deutschen Begriffe austauschen. $wochentag = date(l); switch($wochentag) { case "Monday": $wochentag = "Montag"; break; case "Tuesday": $wochentag = "Dienstag"; break; // und so weiter bis Sunday } ?>
Wie Sie sehen, können Sie die verschiedenen case-Einträge auch in einer Zeile notieren.
6
Bei der Ermittlung des Monatsnamens geht man ähnlich vor. Die acht Anweisungen – nein, nicht zwölf, die Monatsnamen »April«, »August«, »September« und »November« werden im Englischen wie im Deutschen geschrieben, hier muss das Script also nichts ersetzen – werden nach dem gleichen Muster notiert: $monat = date(F); switch($monat) { case "January": $monat = "Januar"; break; case "February": $monat = "Februar"; break; // und so weiter bis December } ?>
7
Wenn in $wochentag und $monat nun die deutschen Bezeichnungen vorliegen, ist der Rest des Scripts rasch angepasst. Die Datumsangabe mit date("d. F Y") müssen wir nur noch durch $datum = date(d).".$monat ".date(Y); ?> ersetzen, die echo-Anweisungen bleiben unverändert.
54
Programmschleifen
Mit einer einfachen switch-Anweisung lassen sich die englischen Begriffe der date()Funktion durch die entsprechenden deutschen Bezeichnungen austauschen.
Das Datum auf der Homepage
Mit dem vorgestellten Script können Sie Besucher Ihrer Homepage mit dem aktuellen Datum und der Uhrzeit begrüßen. Setzen Sie dafür das Script (ohne die echo-Anweisungen versteht sich) an den Anfang des Codes Ihrer Webseite. Innerhalb des HTML-Teils können Sie dann jederzeit mit =$datum?> und =$uhrzeit?> Datum und Uhrzeit einfügen und die Ausgabe mit den üblichen HTML-Möglichkeiten formatieren.
Programmschleifen Bislang werden die Anweisungen in den Beispielscripten genau einmal durchlaufen. Doch ein Computer ist endlos geduldig und entfaltet seine wahre Stärke erst dann, wenn er einen bestimmten Anweisungsblock so lange wiederholt, wie Sie das wollen. Diese so genannten Schleifen sind das Kernstück eines jeden Programms und machen es flexibler und leistungsfähiger. Die einfachste Form einer Schleife in PHP ist die while-Konstruktion. »While« ist das englische Wort für »während, solange« und genauso funktioniert die Schleife auch. Solange eine bestimmte Abbruchbedingung nicht eintritt, solange werden die Anweisungen innerhalb der Schleife durchlaufen. Die Abbruchbedingung wird dabei als logischer Ausdruck notiert. In der allgemeinen Form sieht das so aus: while (Ausdruck) { // Beliebige Anweisungen }
55
Solange der Ausdruck den Wert true besitzt, werden die Anweisungen in den geschweiften Klammern ausgeführt. Mindestens eine dieser Anweisungen muss also den Wert des Ausdrucks so verändern, dass er irgendwann false ergibt, ansonsten wird die Abbruchbedingung nie erfüllt und die Schleife nie verlassen. Hinweis
Fehlende oder fehlerhaft formulierte Abbruchbedingungen sind eine der häufigsten Ursachen für einen Programmabsturz.
Das klingt jetzt vielleicht etwas abstrakt und trocken, also probieren wir das rasch an einem einfachen Beispiel aus.
1
Einem Script werden mit get zwei Zahlen übergeben, die als Anfangs- und Endwert gespeichert werden. Das Script zählt dann in Einserschritten von der einen bis zur anderen Zahl und zeigt das Ergebnis am Bildschirm an: $anfang = $_GET['a']; $ende = $_GET['e']; while ($anfang <= $ende) { echo $anfang," "; $anfang++; } ?>
2
Da die Variable $anfang innerhalb der while-Schleife verändert wird, verändert sich auch der Wahrheitswert der Abbruchbedingung. Sobald der Wert von $anfang größer als $ende ist, wird die Schleife verlassen.
Streng genommen müssten wir noch einige Sicherheitsabfragen für den Fall einfügen, dass keine Werte übergeben werden oder dass der Endwert kleiner als der Anfangswert ist. Aber wirklich nötig sind sie in diesem Fall nicht, denn die Schleife wird dann (und nur dann) durchlaufen, solange $anfang kleiner oder gleich $ende ist. In den anderen Fällen passiert gar nichts. While ist ein Beispiel für eine so genannte »abweisende Schleife«, bei der
noch vor dem ersten Durchlauf die Abbruchbedingung überprüft wird. Das Gegenstück ist eine »annehmende Schleife«, bei der erst nach den Anweisungen überprüft wird, ob die Abbruchbedingung eingetreten ist. Eine solche Schleife wird also mindestens einmal, eine abweisende Schleife unter Umständen gar nicht durchlaufen.
56
Programmschleifen
Eine annehmende Schleife in PHP wird mit do/while konstruiert: do { // Beliebige Anweisungen } while (Ausdruck);
Neben der while- kennt PHP noch die for-Schleife, die in vielen Fällen das gleiche Ergebnis liefert, aber einen etwas kompakteren und übersichtlicheren Code ermöglicht. Bei einer while-Konstruktion müssen Sie dafür sorgen, dass die Abbruchbedingung der Schleife erreicht wird, indem etwa innerhalb der Schleife ein Zähler mitgeführt oder durch kontinuierliche Akkumulation ein Grenzwert erreicht wird. Bei einer for-Konstruktion wird die Ausführungsbedingung und die kontinuierliche Erhöhung eines Zählers dagegen außerhalb und vor dem Start der eigentlichen Schleife definiert. Die allgemeine Syntax einer for-Schleife sieht so aus: for (Initialisierung; Bedingung; Veränderung) { // Beliebige Anweisungen }
Einzeilig
Besteht die Schleife nur aus einer Anweisung, kann man die for-Konstruktion in einer Zeile schreiben und auf die Mengenklammern verzichten.
Kernstück der for-Schleife sind die drei durch ein Semikolon getrennten Anweisungen in Klammern. Zuerst wird üblicherweise eine Variable als Zähler initialisiert, danach wird die Bedingung angegeben, die erfüllt sein muss, damit die Schleife durchlaufen wird, und schließlich wird der Zähler erhöht (oder verringert). Um die Zahlen von 1 bis 10 auszugeben, benötigt man zum Beispiel diese Schleife: for ($x = 1; $x <= 10; $x++) echo $x; ?>
Das kleine while-Beispiel ließe sich also in einer for-Schleife folgendermaßen notieren: $anfang = $_GET['a']; $ende = $_GET['e']; for ($wert = $anfang; $wert <= $ende; $wert++) echo $wert." "; ?>
57
Ein typischer Einsatz für die for-Schleife ist das Abzählen von Werten. Will man etwa die ASCII-Codes von 32 bis 255 ausgeben, so benötigt man dafür gerade mal eine Zeile PHP-Code. HTML- und numerische Entities
In HTML können Zeichen durch so genannte Entities dargestellt werden. Eine Entity wird mit einem Ampersand & eingeleitet und einem Semikolon ; beendet. Das auszugebende Zeichen wird entweder mit seinem ISO-Namen angegeben (z. B. »auml« für »a-Umlaut«, also »ä«) oder mit seinem numerischen Zeichencode (»ä« hat den Code 228, notiert als #228). Ein »ä« lässt sich so in HTML entweder als »ä« oder als »ä« darstellen.
Man lässt in einer Schleife eine Variable von 32 bis 255 hochzählen und setzt diese Variable in einer echo-Anweisung als Wert für die numerische Entity ein: ASCII-Codes 32 bis 255
Dies sind die ASCII-Codes von 32 bis 255:
for ($x = 32; $x <= 255; $x++) echo "$x; "; ?>
Eine einzige Zeile in PHP genügt, um sich die darstellbaren ASCII-Codes ausgeben zu lassen.
58
Das kleine Einmaleins
Das kleine Einmaleins Ihre wahre Stärke erreichen Schleifen dann, wenn man sie verschachtelt, d. h. innerhalb einer Schleife eine weitere Schleife ausführt. Verschachtelte Schleifen sind nicht immer auf Anhieb verständlich und tendieren dazu, sehr komplex zu werden und zu eher unerwarteten Ergebnissen zu führen. Gehen wir also das Verfahren an einem Beispiel etwas ausführlicher durch. Aufgabe ist es, das kleine Einmaleins zeilenweise über eine PHP-Anweisung auszugeben.
1
Wir benötigen zwei Schleifen, eine für die Reihen, die von eins bis zehn zählt und eine für die Spalten, die ebenfalls von eins bis zehn zählt und die eigentliche Multiplikation enthält. Das Grundgerüst könnte so aussehen: for ($r = 1; $r <= 10; $r++) { for ($s = 1; $s <= 10; $s++) echo ($r * $s); echo " "; } ?>
2
Die erste Schleife benutzt die Variable $r (für »Reihe«) als Zähler von 1 bis 10. Die erste Anweisung ist eine weitere Schleife, die die Variable $s (für »Spalte«) von 1 bis 10 zählt und das Ergebnis der Multiplikation von Reihen- und Spaltenzähler ausgibt. Abschließend sorgt ein -Tag dafür, dass eine neue Zeile begonnen wird.
3
Was passiert nun genau in dieser Schleife? Gehen wir sie im Kopf einmal kurz durch. Zu Beginn wird der Variablen $r der Wert 1 zugewiesen. Danach beginnt die zweite Schleife, in der die Variable $s die Werte 1 bis 10 durchläuft, während $r immer noch den Wert 1 besitzt. Innerhalb der zweiten Schleife werden $r und $s miteinander multipliziert und das Ergebnis ausgegeben. Insgesamt bekommt man also dieses Ergebnis:
1 2 3 4 5 6 7 8 9 10
4
Damit ist die innere Schleife beendet, die äußere wird fortgeführt. Es wird ein Zeilenumbruch erzwungen, danach wird der Wert für $r um eins erhöht. Da die Abbruchbedingung der äußeren Schleife noch nicht erreicht ist, beginnt nun alles von vorn, diesmal mit dem Wert 2 für die Variable $r, die Anzeige sieht nun so aus:
1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20
59
5
Wieder wird die innere Schleife beendet und die äußere fortgeführt. Dies wird so lange wiederholt, bis die Variable $r den Wert 11 erreicht hat und die äußere Schleife verlassen wird.
6
Damit die Ausgabe etwas ansprechender und übersichtlicher gerät, setzen wir den gesamten Code in ein
-Tag. Die äußere Schleife gibt die Reihen aus, muss also die innere Schleife mit einem
-Element umgeben. Dort werden nun die einzelnen Werte pro Reihe ausgegeben, die jeweils von einem
umrahmt werden müssen. Zusammen ergibt sich dieser HTML-Code mit PHP-Anteil:
for ($r = 1; $r <= 10; $r++) { echo "
"; for ($s = 1; $s <= 10; $s++) { echo "
"; echo ($r * $s); echo "
"; } echo "
"; } ?>
7 Die innere Schleife könnte mit einem Komma zu einer einzigen Anweisung
zusammengefasst und so in einer Zeile notiert werden. Allerdings wird's dann ein wenig unübersichtlich:
for ($s = 1; $s <= 10; $s++) echo "
",($r * $s),"
"; ?>
Für den Anfang empfiehlt es sich, auf solche Verkürzungen zu verzichten und jeden Schritt in einer einzelnen Zeile zu schreiben. Damit ist der PHP-Teil der Aufgabe erledigt, nun kann man sich daran machen, die Ausgabe durch Optimierung des Codes noch ein wenig gefälliger zu gestalten, etwa durch Stylesheets den Zellen Hintergrundfarben zu geben und die Zelleninhalte rechtsbündig auszurichten. Natürlich können Sie mit dieser Schleife nicht nur das kleine Einmaleins, sondern praktisch jede gewünschte Multiplikationstabelle erzeugen. Dafür müssen Sie lediglich die Schleifenwerte entsprechend anpassen. Dabei können Sie nicht nur die Start- und Endwerte der Schleife verändern, sondern auch die Schrittweite und etwa nur jeden zweiten Wert berechnen lassen:
60
Funktionen
for ($s = 1; $s <= 10; $s = $s + 2) ?>
Selbstverständlich können Sie für die Schrittweite $s = $s + 2 auch die verkürzte Darstellung benutzen: for ($s = 1; $s <= 10; $s += 2) ?>
Durch Anpassung der Schleifenwerte können Sie beliebige Multiplikationstabellen erzeugen. Dabei ist PHP für die Inhalte der Tabelle zuständig, während ihre Gestaltung wie gewohnt in HTML erfolgt.
Funktionen Eine Funktion bezeichnet in PHP gewissermaßen ein Programm innerhalb des Programms zur Lösung häufig wiederkehrender Aufgaben oder Anforderungen. PHP besitzt bereits von Haus aus mehr als 1.000 Funktionen zur
61
Erledigung der unterschiedlichsten Aufgaben, ein paar davon wie isset(), htmlentities() oder date() haben wir bereits kennen gelernt. Außerdem können Sie beliebige Funktionen definieren, die auf Ihre individuellen Programmerfordernisse zugeschnitten sind. Eine Funktion wird durch ihren Namen und normalerweise mit einem Parameter in Klammern aufgerufen, der innerhalb der Funktion verarbeitet wird. Das Ergebnis wird anschließend von der Funktion an das aufrufende Script zurückgegeben. Dort wird es einer Variablen zugewiesen und kann so im Script weiter verarbeitet werden. Das klingt jetzt vielleicht etwas umständlich, aber die Beschreibung ist länger als der PHP-Code. So liefert die Funktion sqrt() die Wurzel eines übergebenen Wertes zurück, sqrt(4) ergibt also den Wert 2. Damit mit diesem Ergebnis aber weiter gearbeitet werden kann, muss man es einer Variablen zuweisen, als Text ausgeben oder als Bestandteil einer weiteren Berechnung benutzen: $a = $_GET['a']; echo "Die Wurzel aus $a ist: ",sqrt($a); ?>
Funktionen können natürlich auch mehr als einen Parameter besitzen, die man mit Komma getrennt an die Funktion übergibt. So ersetzt etwa die Funktion str_replace() in einer Zeichenkette (einem so genannten »String«) beliebige Zeichen durch andere Zeichen. Dabei werden der Funktion folgende Parameter übergeben: das (oder die) Zeichen, die ersetzt, das (oder die) Zeichen, die eingefügt und schließlich der String, in dem die Zeichen ausgetauscht werden sollen. Mit str_replace("e", "x", "Internet")werden folglich alle Buchstaben »e« im Wort »Internet« durch ein »x« ersetzt. Zugegeben, das ist jetzt kein sehr sinnvolles Beispiel, aber diese Funktion wird uns später noch oft und in sinnvolleren Kontexten begegnen. Möchten Sie zur Lösung einer bestimmten Aufgabe eine Funktion selbst definieren, so können Sie dies über die Anweisung function tun. Sie definieren die Funktion, indem Sie ihr einen Namen geben, die benötigten Parameter nennen und, natürlich, die Anweisungen definieren, die innerhalb der Funktion ausgeführt werden sollen. Diese Anweisungen stehen immer in Mengenklammern. So ist es problemlos möglich, den arithmetischen Befehlsvorrat von PHP durch eine Quadrat-Funktion zu ergänzen (PHP besitzt zwar eine Funktion,
62
Funktionen
um die Quadratwurzel eines Wertes zu ermitteln, aber keine, um eine Zahl zu quadrieren). Die Funktion soll »square()« heißen, mit einem Wert aufgerufen werden und dessen Quadrat zurückgeben: function square($zahl) { return $zahl * $zahl; } ?>
Mit der Anweisung return gibt man einen Wert von der Funktion an das aufrufende Script zurück. Ein einfaches Beispiel soll den Einsatz selbstgemachter Funktionen verdeutlichen. Gültigkeit von Variablen
Variablen, die innerhalb einer Funktion benutzt werden, sind auch nur innerhalb der Funktion gültig. Eine Variable $zahl, die im Script benutzt wird, und eine Variable $zahl innerhalb einer Funktion sind für PHP zwei grundsätzlich verschiedene Werte.
Die Funktions-Definition wird üblicherweise an den Kopf des Dokuments gesetzt, im Script selbst kann die Funktion dann so benutzt werden wie jede andere Funktion auch. Das Beispielscript macht nun nichts anderes, als via get einen Wert entgegenzunehmen, ihn mit der Funktion square() zu quadrieren und die Berechnung auszugeben. Dabei wird die numerische Entity × benutzt, mit der sich ein Multiplikationszeichen darstellen lässt (was deutlich besser lesbar ist als der Einsatz von x oder *): function square($zahl) { return $zahl * $zahl; } ?> Quadratfunktion $a = $_GET['a']; echo "$a × $a = ",square($a); ?>
63
Wenn Sie eine Fließkommazahl übergeben möchten, müssen Sie statt des gewohnten Kommas einen Punkt notieren, also »12.1« statt »12,1«. Andernfalls wird der übergebene Wert als Zeichenkette, nicht als Zahl erkannt.
Variablentypen überprüfen Die selbstgeschriebene Funktion square() arbeitet wie erwartet, aber es gibt noch einen Schönheitsfehler: Wenn die mit get übergebene Variable $a kein numerischer Wert, sondern ein Text ist – etwa bei einem Aufruf mit
http://localhost/funktion.php?a=test dann wird das Quadrat von »test« gebildet. Das Script verarbeitet diese Eingabe zwar klaglos und wird als Ergebnis den Text »test × test = 0« ausgeben, aber sonderlich sinnvoll ist das nicht. Wir sollten also vor dem Funktionsaufruf überprüfen, ob ein numerischer Wert vorliegt.
1
Hier hilft uns die Funktion is_numeric(), die den Wert true zurückgibt, wenn die zu überprüfende Variable ein numerischer Wert ist, und false ergibt, wenn dies nicht der Fall ist. Damit können wir die Funktion als Bedingung in einer if-Konstruktion einsetzen, deren Anweisung ausgeführt wird, wenn die Variable numerisch ist, andernfalls – else – wird ein kurzer Hinweis angezeigt: $a = $_GET['a']; if (is_numeric($a)) echo "$a × $a = ",square($a); else echo "Bitte einen numerischen Wert eintragen!"; ?>
2
Wenn wir schon dabei sind, mögliche Eingabefehler abzufangen, dann können wir auch gleich mit isset($a)überprüfen, ob überhaupt ein Wert übergeben wurde. Wenn ja, dann wird die numerische Prüfung durchgeführt, wenn nicht, wird zur Eingabe eines Wertes aufgefordert. Das könnte dann so aussehen: $a = $_GET['a']; if (isset($a)) {
64
Menschen, nicht Maschinen
if (is_numeric($a)) echo "$a × $a = ",square($a); else echo "$a ist kein numerische Wert."; } else echo "Bitte einen numerischen Wert für a angeben."; ?> Die wichtigsten Variablen-Funktionen Funktion
Erläuterung
empty($a)
true, falls $a leer ist. Vorsicht, »0« gilt als »leer«!
isset($a)
true, falls $a existiert, wobei $a auch leer sein kann.
is_numeric($a)
true, falls $a ein numerischer Wert ist.
is_int($a)
true, falls $a ganzzahlig ist.
is_bool($a)
true, falls $a ein logischer Wert (boolean) ist.
is_float($a)
true, falls $a eine Fließkommazahl ist.
gettype($a)
Ermittelt den Typ der Variablen $a. Mögliche Rückgabewerte sind u. a.: boolean, integer, double und string.
settype($a,Typ)
Setzt den Typ der Variablen $a. Mit $a="1 Dutzend" ist $a vom Typ string. Nach settype($a,"integer") wird $a zu einer Integer-Variable mit dem Wert 1. Mögliche Werte für Typ sind u. a.: boolean, integer, double und string.
Menschen, nicht Maschinen: Brian Behlendorf
Brian Behlendorf aus dem sonnigen Südkalifornien schuf mit »Apache« den einflussreichsten und wichtigsten Webserver im Internet. Behlendorf studierte Anfang der neunziger Jahre an der Universität von Berkeley, Kalifornien, und gründete bereits 1993 – zwei Jahre vor dem großen Internetboom – zusammen mit Jonathan Nelson eine Webdesign-Firma. 1994 entwickelte er »Hotwired«, die Website für das Kult-Magazin »Wired«. Bei der Arbeit an Hotwired stellte man fest, dass die bisherigen Webserver nicht leistungsfähig genug waren und begann mit der Arbeit an einem eigenen Server, der auf den Namen Apache getauft und zu dessen professionellen Entwicklung im Februar 1995 die Apache Group gegründet wurde. Brian Behlendorfs private Homepage finden Sie hier: http://brian.behlendorf.com/
65
Kapitel 3
Ein Besucherzähler und anderes
In diesem Kapitel werden wir die bisher vorgestellten Verfahren im Praxiseinsatz testen, wobei Sie zusätzlich erfahren, wie Sie Formulare auswerten, Cookies einsetzen oder mit PHP Dateioperationen durchführen.
Ihr Erfolgsbarometer
Das können Sie schon: Sie haben Ihren lokalen Computer mit Xampp in einen Webserver mit PHP verwandelt und Ihre ersten Erfahrungen mit der Sprache gemacht.
16
Sie können in Ihren Programmen logische Entscheidungen treffen, Schleifen einsetzen und Funktionen definieren.
42
Das lernen Sie neu: Grundlegende Dateioperationen mit PHP
68
Den Besucherzähler als Grafik ausgeben
72
Wiederholungen ausfiltern mit Cookies
75
Ein Kennwortschutz für Webseiten
77
Externe Dateien einbinden
80
Ein Kontaktformular auf der Webseite
83
67
Drei Projekte für die Homepage Jetzt, wo wir den grundlegenden Einsatz von und den Umgang mit PHP kennen gelernt haben, wird es Zeit, PHP nicht nur in mehr oder weniger abstrakten Beispielen zu erproben, sondern im handfesten Praxiseinsatz an drei konkreten Projekten, die Ihnen etwas über die Besucher Ihrer Webseiten verraten.
•
Ein Besucherzähler: Wir schreiben ein kleines Script, das mitzählt, wie häufig eine Webseite aufgerufen wurde.
•
Passwortschutz: Ein einfaches Script sorgt dafür, dass erst nach Eingabe des richtigen Kennwortes eine Webseite dargestellt wird und Unbefugten der Zugriff verweigert wird.
•
Kontaktformular: Bieten Sie den Besuchern Ihrer Website die Möglichkeit, Ihnen über ein Formular eine Nachricht zu schicken.
Die wichtigsten Grundlagen zur Realisation dieser Projekte haben wir bereits kennen gelernt. Was wir allerdings noch nicht wissen, aber wissen müssen: Wie kann man mit PHP Daten in einer Datei speichern und bei Bedarf wieder auslesen?
Grundlegende Dateioperationen mit PHP Die Idee für den Besucherzähler ist denkbar einfach. In einer externen Datei »counter.txt« wird die Zahl der Besucherzugriffe gespeichert. Bei jedem Aufruf der Webseite lädt ein Script diese Zahl aus »counter.txt« und zeigt sie an. Anschließend wird sie um eins erhöht und wieder gespeichert. Bevor PHP auf eine Datei zugreifen kann, muss es die Datei öffnen. Dabei wird unterschieden, ob es sich dabei um einen Lese- oder Schreibzugriff handelt. Anschließend muss die geöffnete Datei wieder geschlossen werden. Die Arbeitsschritte, die unser Script erledigen muss, sehen also folgendermaßen aus:
1
Überprüfen, ob die Datei »counter.txt« existiert. Wenn nicht, dann muss diese Datei erzeugt und mit dem Wert 0 (oder einem anderen Startwert) initialisiert werden.
2
Die Datei »counter.txt« wird für den Lesezugriff geöffnet und der Wert ausgelesen. Der Wert wird der Variablen $counter zur späteren Verarbeitung übergeben. Anschließend wird die Datei geschlossen.
3
Der Wert wird um eins erhöht und die Datei »counter.txt« für den Schreibzugriff geöffnet. Die alte Zahl wird mit der neuen Zahl überschrieben, die Datei gespeichert und schließlich geschlossen.
68
Grundlegende Dateioperationen mit PHP
4 In der Variablen $counter und in der Datei »counter.txt« befindet sich nun der aktuelle Zählerstand.
Zum Öffnen einer Datei stellt PHP die Funktion fopen() zur Verfügung. Die Funktion erwartet zwei Parameter: Den Namen der zu öffnenden Datei und den Modus, in dem die Datei geöffnet werden soll. Dabei unterscheidet PHP drei unterschiedliche Zustände: Daten lesen (Parameter "r"), Daten schreiben (Parameter "w") und neue Daten anhängen (Parameter "a"). Die Funktion fopen()gibt nach dem Aufruf als Wert den so genannten Dateizeiger oder file-pointer zurück. Diesen Wert müssen wir beim Aufruf einer Variablen zuweisen, etwa $dz für Dateizeiger oder $fp für file-pointer. Alle anderen Dateioperationen benötigen anschließend diese Variable.
1
Widmen wir uns nun dem ersten Schritt, den unser Script abarbeiten muss. Um zu überprüfen, ob eine Datei existiert, gibt es die Funktion file_exists(), der man den Namen der zu prüfenden Datei übergibt.
2 Wenn die Datei bereits vorhanden ist, gibt die Funktion den Wert true zurück,
andernfalls den Wert false. Wir können diese Funktion also in einer if-Abfrage einsetzen und für den Fall, dass »counter.txt« nicht existiert, innerhalb der ifAbfrage die Datei anlegen und initialisieren: if (!file_exists("counter.txt")) { // Datei existiert nicht, neu anlegen und // initialisieren }
3
Für den Fall, dass »counter.txt« nicht existiert, muss sie neu angelegt werden. Dafür öffnen wir die Datei mit Schreibzugriff. PHP bemerkt, dass die Datei nicht existiert, in die geschrieben werden soll, und legt sie automatisch an: $dz = fopen("counter.txt","w");
Vorsicht!
Öffnen Sie eine existierende Datei mit dem Parameter "w", wird der Inhalt der Datei gelöscht und durch den neuen Inhalt ersetzt!
4
Um einen Wert in eine zum Schreiben geöffnete Datei zu schreiben, wird die Funktion fwrite() eingesetzt, der man den Dateizeiger und die zu schreibenden Daten übergibt. Um also in die neu angelegte Datei den Wert 0 zu schreiben, benötigen wir folgende Anweisung: fwrite($dz, "0");
69
5
Schließlich muss die immer noch geöffnete, neu angelegte Datei wieder geschlossen werden, wofür die Funktion fclose() benutzt wird, der man den Dateizeiger der zu schließenden Datei übergibt.
6
Setzen wir die einzelnen Schritte zusammen und benutzen, damit das Script etwas flexibler wird, für den Dateinamen eine Variable, so erhalten wir den folgenden Programmcode: $datei_name = "counter.txt"; if (!file_exists($datei_name)) { $dz = fopen($datei_name,"w"); fwrite($dz,"0"); fclose($dz); } ?>
Dieser Einstieg sorgt dafür, dass die Datei $datei_name auf jeden Fall existiert und wir beim Lesezugriff keine Fehlermeldung erhalten.
7
Um die Datei für den Lesezugriff zu öffnen, benutzten wir fopen() mit dem Parameter "r". Nach dem Öffnen können Sie über verschiedene Funktionen den Inhalt der Datei auslesen. Für uns genügt vorerst die Funktion fread(), mit der Sie eine bestimmte Zeichenanzahl aus einer geöffneten Datei auslesen. Dazu übergibt man der Funktion den aktuellen Dateizeiger und die Anzahl der zu lesenden Zeichen.
8
Da wir wohl kaum in die Verlegenheit geraten werden, einen Zähler mit mehr als zehn Stellen auszulesen, können wir uns darauf beschränken, die ersten zehn Zeichen zu lesen und diesen Wert der Variablen $counter zuzuweisen. Zum Abschluss schließen wir die Datei wieder mit fclose(): $dz = fopen($datei_name,"r"); $counter = fread($dz,10); fclose($dz); ?>
9
Nun enthält die Variable $counter den letzten, aktuellen Stand des Besucherzählers. Um den aktuellen Aufruf mit zu zählen, wird sie mit $counter++; um eins erhöht und mit fwrite() in »counter.txt« gespeichert. Dazu öffnen wir die Datei erneut für den Schreibzugriff, speichern den neuen Wert und schließen die Datei.
70
Grundlegende Dateioperationen mit PHP
10 Setzen wir alle Teile des Scripts zusammen, so erhalten wir diesen ScriptBlock, den wir an den Anfang der HTML-Datei setzen, deren Aufrufe gezählt werden sollen:
11 Den Wert der Variablen $counter können wir nun an beliebiger Stelle im HTML-Code der Webseite über =$counter;?> einfügen. Etwa so:
Guten Tag,
diese Seite wurde jetzt zum =$counter;?>. Mal aufgerufen.
Mit einer Hand voll PHP-Code lässt sich schnell und unkompliziert ermitteln, wie oft eine Datei aufgerufen wurde.
71
Den Besucherzähler als Grafik ausgeben Der Besucherzähler funktioniert zwar tadellos, ist jedoch noch ein wenig langweilig. Wir können ihn aber problemlos aufpeppen, indem wir den Zählerstand nicht als einfachen Text, sondern als Grafik ausgeben. Dafür wird der Inhalt der Variablen $counter als Zeichenkette interpretiert und die Ziffern von links nach rechts der Reihe nach ausgelesen. Für jede Ziffer wird eine entsprechende Zahlengrafik eingefügt, die wir als Dateien »0.gif« bis »9.gif« im gleichen Verzeichnis wie das Script ablegen. Derartige Grafiken finden Sie im Internet auf unzähligen Seiten zum freien Download, Sie können sich Ihre Zahlengrafiken natürlich auch selbst anlegen. Alles, was wir für dieses Vorhaben benötigen, ist eine Funktion, mit der man eine String-Variable Zeichen für Zeichen untersuchen kann. Eine solche Funktion steht mit substr() zur Verfügung, die dazu dient, beliebige Teilstücke aus einer Zeichenkette zu lesen. Sie arbeitet mit drei Parametern: der Zeichenkette, der Startposition des Teilstücks und schließlich der Länge des Teilstücks. Wird der letzte Parameter nicht angegeben, so gibt substr() den Rest der Zeichenkette ab der Startposition zurück. Zu beachten ist hier nur, dass substr() – wie praktisch alle Funktionen in PHP – mit dem Zählen bei 0 beginnt. Mit $dummy = substr("Zeichenkette",1,3); ?>
bekommt die Variable $dummy also drei Zeichen ab dem zweiten Zeichen von »Zeichenkette« zugewiesen. Nach dieser Anweisung besitzt die Variable den Wert »eic«, mit $dummy = substr("Zeichenkette",7); ?>
wird $dummy der Wert »kette« zugewiesen.
1 Um den Inhalt von $counter zu analysieren, benötigen wir eine Schleife, in der die Variable $pos von 0 bis zum Ende der Zeichenkette gezählt wird und mit der wir über substr($counter, $pos, 1) jeweils ein Zeichen auslesen.
2 Die Länge von $counter ermitteln wir mit der Funktion strlen(). Der Funktion wird einfach der String übergeben, als Ergebnis erhält man die Anzahl der Zeichen in diesem String.
72
Den Besucherzähler als Grafik ausgeben
3 Mit dem folgenden Testscript ermittelt strlen() die Länge der Zeichenkette
$counter, die zur Kontrolle mit echo ausgegeben wird. Danach folgt eine forSchleife, in der mittels substr() jeweils ein Zeichen ausgelesen und mit Zeilenumbruch ( ) ausgegeben wird:
Nach diesem Test können wir uns an die Umsetzung der ursprünglichen Idee machen. Dabei wird eine switch-Anweisung benutzt, die in Abhängigkeit von der aktuellen Ziffer über das -Element die benötigte Grafik einbindet. Achten Sie darauf, dass die für die Pfadangabe zur Grafik benötigten Anführungszeichen innerhalb der echo-Anweisung mit dem Backslash \ maskiert werden müssen: $anzahl = strlen($counter); for ($pos = 0; $pos < $anzahl; $pos++) { $ziffer = substr($counter, $pos, 1); switch ($ziffer) { case "0" : echo ""; case "1" : echo ""; case "2" : echo ""; case "3" : echo ""; case "4" : echo ""; case "5" : echo ""; case "6" : echo ""; case "7" : echo ""; case "8" : echo ""; case "9" : echo ""; } } ?>
Dieses Script löst zwar unsere Aufgabe, tut dies aber auf eine etwas plumpe Weise. So lässt sich die zehnzeilige switch-Anweisung stark vereinfachen, wenn wir uns klar machen, dass der aktuelle Wert von $ziffer auch als Teil des Dateinamens der benötigten Zifferngrafik interpretiert werden kann.
73
5 Wenn etwa der Wert von $ziffer »4« beträgt, dann wird die Grafik »4.gif« eingebunden, die wir in diesem Fall aber auch als echo "$ziffer.gif" notieren können. Damit lässt sich die Ziffernausgabe von zehn auf eine Zeile reduzieren:
Doch das Script hat immer noch einen kleinen Haken – der Zählerwert liegt nun nicht mehr als griffige Variable vor, sondern als mehrzeiliges Script, was den Einsatz in einem HTML-Code etwas umständlich macht.
7
Statt den Zähler also innerhalb der Schleife sofort auszugeben, setzen wir in der Schleife eine neue Zeichenkette $counter_grafik zusammen, die aus den benötigten -Elementen besteht und die dann an beliebiger Stelle im HTML-Code über =$counter_grafik;?> ausgegeben werden kann.
8 Dazu muss $counter_grafik vor Beginn der Schleife initialisiert werden. Inner-
halb der Schleife wird dann mit dem Verkettungsoperator . die jeweilige Anweisung angehängt. Und wenn wir schon beim Vereinfachen der Anweisungen sind, setzen wir auch gleich den in Kapitel 1 erläuterten Zuweisungsoperator .= ein: $anzahl = strlen($counter); $counter_grafik = ""; for ($pos = 0; $pos < $anzahl; $pos++) { $ziffer = substr($counter, $pos, 1); $counter_grafik .= ""; } ?>
9
Diesen Teil können wir nun ebenfalls an den Anfang der HTML-Datei schieben, etwa im Anschluss an die Dateizugriffe, und innerhalb des eigentlichen HTMLCodes mit einem =$counter_grafik?> den Zähler als Grafik ausgeben:
Diese Seite wurde nun =$counter_grafik;?> mal abgerufen
74
Wiederholungen ausfiltern mit Cookies
Mit einer Hand voll Zeilen mehr können Sie den Abrufzähler auch als Grafik darstellen.
Wiederholungen ausfiltern mit Cookies Es ist schon erstaunlich, welche Ergebnisse man mit ein paar PHP-Zeilen erzielen kann. Eines haben wir bei der bisherigen Arbeit allerdings kurzerhand unterschlagen: unser Besucherzähler – ist überhaupt kein Besucherzähler. Vielmehr handelt es sich um einen so genannten »Hitcounter«, also um einen Zähler, der angibt, wie oft eine Seite abgerufen wurde. Nun kann es aber sein, dass ein Besucher eine Seite mehrfach abruft, was den Zähler natürlich nach oben treibt, ohne dass es tatsächlich einen neuen Besucher gibt. Um das zu unterbinden, setzen wir einen so genannten temporären Cookie ein. Ein Cookie ist ein kleiner Datenschnipsel, den ein Webserver an den Browser schickt, um dort eine Markierung zu hinterlassen, an der der Server den Browser wieder erkennt. So ist es zum Beispiel möglich, wiederholte Zugriffe von der gleichen Person auszufiltern. Ein normaler Cookie wird vom Browser gespeichert, ein temporärer Cookie existiert dagegen nur so lange, wie das Browserfenster geöffnet ist und wird nicht gespeichert. Die Überlegung, um aus unserem Hitcounter einen echten Besucherzähler zu machen, ist folgende: Bei jedem Aufruf der Webseite wird, wie bisher auch, der aktuelle Zählerstand ausgelesen. Anschließend wird überprüft, ob ein Cookie vorhanden ist. Falls dies nicht der Fall ist, wird ein Cookie gesetzt, der Counter um eins erhöht und gespeichert. Doch falls ein Cookie vorliegt, handelt es sich um einen wiederholten Besuch. Der Counter muss nicht erhöht und auch nicht wieder gespeichert werden.
75
1
Ein Cookie ist im Prinzip eine Variable, der Sie mit der Funktion setcookie() einen Namen und einen Wert zuweisen. Um den Cookie »besucher« mit dem Wert »ja« zu setzen, benötigen Sie demnach folgende Anweisung: setcookie("besucher", "ja"); ?>
2 PHP speichert alle Cookies in der Systemvariablen $_COOKIE. Ähnlich wie bei
$_GET handelt es sich dabei um ein so genanntes Array (zur Erinnerung: ein Array
bietet die Möglichkeit, verschiedene Variablen unter einem Namen zu speichern, wir werden uns später auführlich mit Arrays beschäftigen). Um auf einen Cookie zuzugreifen, lesen wir seinen Wert aus diesem Array aus, in dem wir den Namen des Cookies in einfachen Anführungszeichen und eckigen Klammern einsetzen: $besucher = $_COOKIE['besucher']
3 Um zu überprüfen, ob eine Variable existiert, benutzen wir wieder die Funktion
isset(), die ein false zurückgibt, wenn die Variable nicht gesetzt ist. Andernfalls, also wenn der Cookie $besucher existiert, liefert die Funktion isset($besucher) den Wert true.
4
Wenn wir das Funktionsergebnis negieren und in einer if-Abfrage einsetzen, können wir für den Fall, dass der Cookie $besucher nicht existiert (!isset($besucher)), den Zähler erhöhen.
5
Der komplette PHP- und HTML-Code des Besucherzählers sieht im Ganzen jetzt so aus: $datei_name = "counter.txt"; // Existiert bereits ein Counter? if (!file_exists($datei_name)) { $dz = fopen($datei_name, "w"); fwrite($dz,"0"); fclose($dz); } // Counter auslesen $dz = fopen($datei_name,"r"); $counter = fread($dz, 10); fclose($dz); // Der Cookie wird abgefragt $besucher = $_COOKIE['besucher']; if (!isset($besucher)) { setcookie ("besucher","ja"); $counter++; $dz = fopen($datei_name, "w");
Diese Seite wurde nun =$counter_grafik;?> mal abgerufen
Ein Kennwortschutz für Webseiten Jede Webseite, die Sie auf Ihren Webserver laden, kann in der Regel von jedem Websurfer im Internet eingesehen werden, das ist schließlich Sinn und Zweck einer Website. Doch nicht immer möchte man, dass jedermann auf alles zugreifen kann. Manche Informationen sind vertraulich oder nur für einen bestimmten Nutzerkreis bestimmt. In diesem Fall muss man dafür sorgen, dass die Daten nicht von unbefugten Zeitgenossen gelesen werden können. Die Lösung des Problems ist ein Kennwortschutz. Die Idee: Bevor die Informationen angezeigt werden, muss sich der Besucher mit Benutzernamen und Kennwort legitimieren. Ein PHP-Script überprüft die Eingaben und gibt erst dann den Weg frei, wenn die Daten korrekt sind. Damit der Besucher die Möglichkeit hat, Name und Kennwort einzugeben, benötigen wir ein einfaches Formular mit zwei Eingabefeldern.
1
Standardmäßig werden bei einem Formular die Daten mit get an den Server übertragen, also im Klartext in der Adresszeile des Browser angezeigt. Das ist für ein Kennwort natürlich nicht zu empfehlen. Setzen wir stattdessen post ein, werden die Daten unsichtbar übermittelt. Deklarieren wir außerdem noch das Eingabefeld für das Kennwort als type="password", hat ein neugieriger Zeitgenosse keine Chance mehr, einen zufälligen Blick auf das Kennwort zu werfen.
77
2 Ein schmuckloses Formular zur Abfrage von Name und Kennwort sieht also so aus:
3
Natürlich können Sie dieses Formular mit den üblichen HTML-Codes noch deutlich ansprechender gestalten, aber für unsere Zwecke soll das genügen.
4
Wenn Sie in dieses Formular Daten eintragen und mit einem Klick auf »OK« abschicken, passiert gar nichts. Zwar übermittelt das Formular die eingegebenen Daten an den Scriptteil der Formulardatei zur Auswertung zurück, aber da es noch kein Script zur Auswertung gibt, gibt es auch keine Reaktion. Aber das kann man ja ändern.
5 Bei älteren Browsern wie etwa Netscape 4.7 müssen Sie im $user = $_POST['user']; $pass = $_POST['pass']; if (isset($user)) echo "Name = $user "; if (isset($pass)) echo "Kennwort = $pass "; ?>
Das Auswertungsscript des Formulars macht noch nicht mehr, als die eingegebenen Daten zur Kontrolle auszugeben; aber für den Anfang ist das ja schon mal nicht schlecht.
Eingaben überprüfen Der erfolgreiche Testdurchlauf zeigt uns, dass die Datenübertragung vom Formular zum Script funktioniert, wir können uns nun daran machen, die eingegebenen Daten zu überprüfen. Die richtigen Werte für $user und $pass können wir einfach im Script deklarieren. Da der PHP-Code auf dem Server ausgeführt und nicht an den Webbrowser übermittelt wird, bekommt der Besucher diese Deklaration auch dann nicht zu Gesicht, wenn er sich den Quelltext der Seite anzeigen lässt. Über eine if-Abfrage vergleicht man die eingegebenen mit den korrekten Daten. Nur wenn sowohl die Eingabe für den Benutzernamen als auch das Kennwort korrekt sind, die logische Verknüpfung mit AND bzw. in der Kurzform mit && also den Wert true ergibt, werden die Anweisungen in der ifAbfrage ausgeführt.
79
In der Grundform zum Testen könnte das zum Beispiel so aussehen: $user = $_POST['user']; $pass = $_POST['pass']; $user_ok = "Nilpferd"; $pass_ok = "hippo"; if ($user == $user_ok && $pass == $pass_ok) echo "Korrekte Eingabe."; else echo "Falsche Eingabe!"; ?>
Nun sollten die Zugangsdaten zu einer Webseite regelmäßig geändert werden. In diesem Fall müssten wir die Variablen $user_ok und $pass_ok im Script ändern, was auf Dauer aber ein wenig umständlich ist. Angenehmer wäre es doch, wenn wir die Zugangsdaten in einer externen Datei, deklarieren und die Formularseite einfach in Ruhe lassen könnten. Obendrein gilt es ein potentielles Sicherheitsrisiko zu bedenken: Es ist denkbar, dass auf dem Webserver der PHP-Interpreter ausfällt und der Server das Script nicht interpretiert, sondern als Klartext direkt an den Browser schickt. Zugegeben, das kommt praktisch nicht vor, aber es ist möglich. In diesem Fall könnte der Besucher die korrekten Eingaben einfach im Script nachlesen, was nun nicht gerade Sinn und Zweck eines Kennwortschutzes ist. Auch hier empfiehlt es sich folglich, die korrekten Daten außerhalb des Formulars und der Auswertungsroutine zu definieren.
Externe Dateien einbinden Externe Dateien lassen sich mit PHP über die Anweisung include() einbinden. Dabei wird der Inhalt der angegebenen Datei vollständig an die Stelle des include()-Kommandos gesetzt. Vor der Ausführung der Anweisung wird der aktuelle PHP-Code vorübergehend beendet, der Inhalt der angegebenen Datei geladen und anschließend PHP wieder aktiviert und das Script an der Stelle fortgeführt, an der es mit include() unterbrochen wurde. Das bedeutet in der Praxis: Möchten Sie im eingefügten Teil PHP-Kommandos benutzen, dann müssen Sie diese wie gewohnt mit einleiten und ?> beenden. Andernfalls wird der Dateiinhalt als normales HTML betrachtet. Wenn wir so in einer externen Daten namens »zugang.php« die Zugangsdaten definieren – $user_ok = "Nilpferd"; $pass_ok = "hippo"; ?>
80
Externe Dateien einbinden
– können wir diese in unserem Script über include("zugang.php") einbinden und sind damit in der Lage, in Zukunft Username und Passwort zu ändern, ohne das komplette Formular oder das Auswertungsscript bearbeiten zu müssen. Doch das Sicherheitsproblem bleibt bestehen: Wer den Namen der Datei mit der Variablendefinition kennt, kann die Datei unabhängig vom Formular oder Script direkt aufrufen und sich im Browser anzeigen lassen. Und wenn dann noch die PHP-Auswertung schief gehen sollte, war die ganze Kennwortmühe für die Katz. So unwahrscheinlich dieses Szenario auch ist – es ist nicht unmöglich, dass jemand einfach durch einen blöden Zufall über die eigentlich geheimen Daten stolpert. Include() und Pfadangaben
Die Funktion include() sucht standardmäßig im aktuellen Verzeichnis nach der einzubindenden Datei. Will man Dateien aus anderen Verzeichnissen einbinden, muss man eine relative Pfadnotierung benutzen. Mit include ("../inc/#_variablen.inc") greift man also auf die Datei #_variablen.inc zu, die, ausgehend vom übergeordneten Verzeichnis, im Verzeichnis »inc« zu finden ist.