1. PHP5 in 14 Tagen

2. Unser Online-Tipp
für noch mehr Wissen ...
... aktuelles Fachwissen rund
um die Uhr — zum Probelesen,
Downloaden oder auch auf Papier.
www.InformIT.de

3. PHP
PHP5
JÖRG KRAUSE
eBook
Die nicht autorisierte Weitergabe dieses eBooks
ist eine Verletzung des Urheberrechts!

4. 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 Software-Bezeichnungen, die in diesem Buch
erwähnt werden, sind gleichzeitig auch eingetragene Marken
oder sollten als solche betrachtet werden.
Umwelthinweis:
Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt.
10 9 8 7 6 5 4 3 2 1
06 05 04
ISBN 3-8272-6314-X
© 2004 by Markt+Technik Verlag,
ein Imprint der Pearson Education Deutschland GmbH,
Martin-Kollar-Straße 10–12, D–81829 München/Germany
Alle Rechte vorbehalten
Lektorat: Boris Karnikowski, bkarnikowski@pearson.de
Herstellung: Philipp Burkart, pburkart@pearson.de
Korrektur: Haide Fiebeler-Krause, Berlin
Satz: reemers publishing services gmbh, Krefeld, (www.reemers.de)
Coverkonzept: independent Medien-Design, München
Coverlayout: Sabine Krohberger
Druck und Verarbeitung: Bercker, Kevelaer
Printed in Germany

5. Inhaltsverzeichnis
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Für wen das Buch und die Reihe gedacht sind . . . . . . . . . 15
Unsere Zielgruppe als Leser . . . . . . . . . . . . . . . . . . . . . . . . 16
PHP und ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Ein paar Worte zum Autor . . . . . . . . . . . . . . . . . . . . . . . . . 17
In diesem Buch verwendete Konventionen . . . . . . . . . . . . 18
Woche 1 – Wochenvorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Tag 1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.1 Die Geschichte von PHP . . . . . . . . . . . . . . . . . . . . . . . . . . 22
PHP/FI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
PHP3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
PHP4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
PHP5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.2 PHP auf einen Blick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Ein wenig Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Mit PHP spielen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Ein paar wichtige Techniken . . . . . . . . . . . . . . . . . . . . . . . 27
1.3 Einen Webserver bauen . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Vorbemerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
WAMP vorbereiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.4 Apache installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Installationsstart. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Erste Schritte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Apache testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Weitere Einstellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Apache automatisch starten . . . . . . . . . . . . . . . . . . . . . . . . 36
1.5 PHP5 installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.6 PHP5 konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Die Datei php.ini . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Wichtige Konfigurationsschritte . . . . . . . . . . . . . . . . . . . . . 38
5

6. Inhaltsverzeichnis
1.7 PHP5 testen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Konfiguration des Webservers für PHP5 . . . . . . . . . . . . . . 40
PHP-Skripte ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Wenn es nicht funktioniert. . . . . . . . . . . . . . . . . . . . . . . . . 42
1.8 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Tag 2 Erste Schritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.1 Einfache HTML-Seiten . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
HTML-Refresh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Tabellen und Bilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Formulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.2 PHP einbetten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Wie PHP den Code erkennt . . . . . . . . . . . . . . . . . . . . . . . . 53
2.3 Ausgaben erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Die Ausgabe mit echo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Variablen ausgeben. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Ausgabe von großen Textmengen . . . . . . . . . . . . . . . . . . . 57
Vielfältige Formatierungen mit print und Verwandten. . . 58
2.4 Professionelles Programmieren . . . . . . . . . . . . . . . . . . . . . 62
Nicht nur für die Nachwelt: Kommentare. . . . . . . . . . . . . 62
Benennungsregeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
2.5 Webserver und Browser. . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Prinzip des Seitenabrufs . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
HTTP auf einen Blick . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
2.6 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Tag 3 Daten verarbeiten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.1 Variablen und Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.2 Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Konstanten definieren und nutzen. . . . . . . . . . . . . . . . . . . 76
3.3 Rechnen und Vergleichen mit Ausdrücken . . . . . . . . . . . . 78
Ausdrücke und Operatoren. . . . . . . . . . . . . . . . . . . . . . . . . 78
3.4 Allgemeine Aussagen zu Zeichenketten . . . . . . . . . . . . . . . 83
Datentyp und Größe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Umgang mit Sonderzeichen. . . . . . . . . . . . . . . . . . . . . . . . 84
Zeichenketten erkennen und bestimmen . . . . . . . . . . . . . 85
Zeichenkettenoperationen . . . . . . . . . . . . . . . . . . . . . . . . . 86
6

7. Inhaltsverzeichnis
3.5 Die Zeichenkettenfunktionen . . . . . . . . . . . . . . . . . . . . . . 86
Suchen und Ersetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Ermitteln von Eigenschaften einer Zeichenkette . . . . . . . 90
Teilzeichenketten und Behandlung einzelner Zeichen . . 90
HTML-abhängige Funktionen . . . . . . . . . . . . . . . . . . . . . . 92
3.6 Reguläre Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Einführung in die Welt der regulären Ausdrücke . . . . . . . 95
Anwendungsbeispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Typische Suchmuster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
3.7 Datums- und Zeitfunktionen . . . . . . . . . . . . . . . . . . . . . . . 110
Der Timestamp und die Serverzeit . . . . . . . . . . . . . . . . . . 110
Rechnen mit Datums- und Zeitwerten . . . . . . . . . . . . . . . 110
Tricks mit JavaScript: Lokale Zeit ermitteln . . . . . . . . . . . 117
3.8 Formatieren und Ausgeben. . . . . . . . . . . . . . . . . . . . . . . . . 119
Zahlen formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Umwandeln, Anpassen und Ausgeben . . . . . . . . . . . . . . . . 120
3.9 Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Zeichenketten-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . 125
Funktionen für reguläre Ausdrücke . . . . . . . . . . . . . . . . . . 129
Referenz Ausgabe- und Datumsfunktionen . . . . . . . . . . . . 129
3.10 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
Tag 4 Programmieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
4.1 Verzweigungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Einfache Verzweigungen mit if . . . . . . . . . . . . . . . . . . . . . 132
Alternative Zweige mit else. . . . . . . . . . . . . . . . . . . . . . . . . 136
Mehrfachverzweigungen mit switch . . . . . . . . . . . . . . . . . 137
4.2 Schleifen erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Gemeinsamkeiten aller Schleifenanweisungen . . . . . . . . . 141
Die Zählschleife for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Die Universalschleifen do/while und while . . . . . . . . . . . . 148
4.3 Benutzerdefinierte Funktionen. . . . . . . . . . . . . . . . . . . . . . 150
Funktionen definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Parameter der Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . 153
Referenzen auf Funktionen und Parameter. . . . . . . . . . . . 159
Statische Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Globale Variablen und Konstanten . . . . . . . . . . . . . . . . . . 162
Rekursive Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Variable Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
7

8. Inhaltsverzeichnis
4.4 Modularisierung von Skripten . . . . . . . . . . . . . . . . . . . . . . 168
Module einbinden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Informationen über Module ermitteln. . . . . . . . . . . . . . . . 172
4.5 Fehlerbehandlung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Konventionelle Fehlerbehandlung . . . . . . . . . . . . . . . . . . 174
Fehlerbehandlung mit PHP5 . . . . . . . . . . . . . . . . . . . . . . . 178
4.6 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
Tag 5 Daten mit Arrays verarbeiten. . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
5.1 Datenfelder im Einsatz: Arrays . . . . . . . . . . . . . . . . . . . . . . 182
5.2 Arrays erstellen und befüllen . . . . . . . . . . . . . . . . . . . . . . . 182
Ein einfaches Array erstellen . . . . . . . . . . . . . . . . . . . . . . . 183
Die Anzahl der Elemente ermitteln . . . . . . . . . . . . . . . . . . 184
Den Index manipulieren . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Schlüssel statt Indizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Arraywerte schneller zuweisen . . . . . . . . . . . . . . . . . . . . . . 186
5.3 Arrays manipulieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
Werte entfernen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
Der Arrayzeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
Arrayfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
Arraydaten manipulieren . . . . . . . . . . . . . . . . . . . . . . . . . . 193
5.4 Arrays ausgeben. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Arrays zählbar ausgeben: for . . . . . . . . . . . . . . . . . . . . . . . . 193
Beliebige Arrays mit foreach durchlaufen . . . . . . . . . . . . . 194
Einfache Arrays mit while, each, list ausgeben . . . . . . . . . 195
Array mit array_walk durchlaufen . . . . . . . . . . . . . . . . . . . 196
Fehlersuche mit print_r . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
5.5 Referenz der Arrayfunktionen . . . . . . . . . . . . . . . . . . . . . . 198
5.6 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
Tag 6 Objektorientierte Programmierung . . . . . . . . . . . . . . . . . . . . . . 203
6.1 Warum objektorientiert programmieren?. . . . . . . . . . . . . . 205
6.2 Syntax der Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
Eine Klasse definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
Ein Objekt erzeugen und benutzen . . . . . . . . . . . . . . . . . . 208
Eine Klasse erweitern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Zugriffskontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
8

9. Inhaltsverzeichnis
6.3 Schnittstellen zur Außenwelt . . . . . . . . . . . . . . . . . . . . . . . 220
Schnittstellen (Interfaces) . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Informationen über Klassen und Objekte . . . . . . . . . . . . . 223
Eigene Fehlerklassen erstellen . . . . . . . . . . . . . . . . . . . . . . 224
Spezielle Zugriffsmethoden für Klassen. . . . . . . . . . . . . . . 227
6.4 Analyse und Kontrolle von Objekten . . . . . . . . . . . . . . . . . 232
__METHOD__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Zeichenkettenform: __toString() . . . . . . . . . . . . . . . . . . . . 234
Abstammung von Klassen und Objekten . . . . . . . . . . . . . . 235
6.5 Referenz der OOP-Funktionen . . . . . . . . . . . . . . . . . . . . . 239
OOP-Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
OOP-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
6.6 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Tag 7 Das Dateisystem entdecken. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
7.1 Dateizugriff organisieren. . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Einsatzfälle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
7.2 Praktischer Dateizugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Prinzipien des Dateizugriffs . . . . . . . . . . . . . . . . . . . . . . . . 246
Wichtige Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Nachrichtenquelle für eine News-Seite . . . . . . . . . . . . . . . 250
Beliebige Code-Dateien ausgeben . . . . . . . . . . . . . . . . . . . 254
Protokolldatei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
7.3 Verzeichniszugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
Inhalt eines Verzeichnisses anzeigen . . . . . . . . . . . . . . . . . 257
Das Verzeichnisobjekt dir und verwandte Funktionen . . . 260
Rekursive Dateiliste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
Verzeichniszugriff mit Iteratoren . . . . . . . . . . . . . . . . . . . . 265
7.4 Funktions-Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Datei-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Prozess-Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
7.5 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
9

10. Inhaltsverzeichnis
Woche 2 – Wochenvorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Tag 8 Formular- und Seitenmanagement . . . . . . . . . . . . . . . . . . . . . . . 277
8.1 Grundlagen in HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Viel HTML – wenig PHP. . . . . . . . . . . . . . . . . . . . . . . . . . 278
8.2 Auswerten der Daten aus Formularen . . . . . . . . . . . . . . . . 280
Grundlegende Schritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Auswertung von Formularen . . . . . . . . . . . . . . . . . . . . . . . 283
Textfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Optionsfelder und Kontrollkästchen . . . . . . . . . . . . . . . . . 287
Dropdown-Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
8.3 Professionelle Formulare und »Sticky Forms« . . . . . . . . . . 301
Ausfüllhinweise und Feldvorgaben . . . . . . . . . . . . . . . . . . 302
Ausfüllhilfen mit JavaScript . . . . . . . . . . . . . . . . . . . . . . . . 303
Fehlerangaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Sticky Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
Mehrseitige Formulare mit versteckten Feldern . . . . . . . . 325
8.4 Dateien hochladen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
Prinzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
Konfigurationsmöglichkeiten . . . . . . . . . . . . . . . . . . . . . . . 340
8.5 Von der Seite zum Projekt . . . . . . . . . . . . . . . . . . . . . . . . . 341
Die HTTP-Methode GET . . . . . . . . . . . . . . . . . . . . . . . . . 341
Daten per URL übermitteln . . . . . . . . . . . . . . . . . . . . . . . . 344
Sicherheitsprobleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
8.6 Cookies und Sessions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
Cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
Session-Verwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
8.7 Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
Wichtige Systemarrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
Server- und Umgebungsvariablen . . . . . . . . . . . . . . . . . . . 365
Session-Verwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
8.8 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Tag 9 Professionelle Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . 373
9.1 Mehrsprachige Webseiten . . . . . . . . . . . . . . . . . . . . . . . . . 374
Browserdaten erkennen . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Lokalisierung und Formatierung von Zeichen . . . . . . . . . 376
10

11. Inhaltsverzeichnis
9.2 Dynamisch Bilder erzeugen . . . . . . . . . . . . . . . . . . . . . . . . 379
Prinzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
Einführung in die Grafikbibliothek GD2 . . . . . . . . . . . . . 381
Anwendungsbeispiel »Dynamischer Werbebanner« . . . . . 386
9.3 Code röntgen: Die Reflection-API . . . . . . . . . . . . . . . . . . . 395
Die Reflection-API als Objektmodell . . . . . . . . . . . . . . . . . 395
Die Reflection-Klassen im Detail . . . . . . . . . . . . . . . . . . . . 397
9.4 Funktions-Referenz GD2 . . . . . . . . . . . . . . . . . . . . . . . . . . 407
9.5 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
Tag 10 Kommunikation per HTTP, FTP und E-Mail. . . . . . . . . . . . . . 415
10.1 Konzepte in PHP5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
Prinzip der Streams und Wrapper . . . . . . . . . . . . . . . . . . . 416
Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
10.2 Streams und Wrapper anwenden . . . . . . . . . . . . . . . . . . . . 419
Daten von einer fremden Website beschaffen . . . . . . . . . . 419
Daten komprimiert speichern. . . . . . . . . . . . . . . . . . . . . . . 420
10.3 Filter verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
10.4 Die Stream-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
Eigene Wrapper und Filter. . . . . . . . . . . . . . . . . . . . . . . . . 425
Anwendung spezifischer Stream-Funktionen . . . . . . . . . . 425
10.5 E-Mail versenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
Praktische Umsetzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
10.6 Funktions-Referenz Stream-Funktionen . . . . . . . . . . . . . . 440
10.7 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
Tag 11 Datenbankprogrammierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
11.1 Prinzip der Datenbankprogrammierung . . . . . . . . . . . . . . 444
11.2 Die universelle Abfragesprache SQL . . . . . . . . . . . . . . . . . 444
Was ist SQL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
Tabellen und Abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
Tabellen anlegen und füllen . . . . . . . . . . . . . . . . . . . . . . . 448
Aktualisieren und Löschen von Daten . . . . . . . . . . . . . . . . 452
Fortgeschrittene Abfragen mit SELECT . . . . . . . . . . . . . . 453
Verknüpfungen zwischen Tabellen . . . . . . . . . . . . . . . . . . 457
Fortgeschrittene SQL-Techniken. . . . . . . . . . . . . . . . . . . . 459
11

12. Inhaltsverzeichnis
11.3 Der MySQL-Dialekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
Grobe Abweichungen vom SQL92-Standard . . . . . . . . . . 461
Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
11.4 Erste Schritte mit MySQL und MySQLi . . . . . . . . . . . . . . 477
MySQLi vorbereiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
Verbindung testen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
Mit der Datenbank arbeiten . . . . . . . . . . . . . . . . . . . . . . . . 479
11.5 Referenz MySQLi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
11.6 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Tag 12 Die integrierte Datenbank SQLite . . . . . . . . . . . . . . . . . . . . . . . 497
12.1 Hintergrund. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
12.2 Vor- und Nachteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
Wann SQLite vorteilhaft ist . . . . . . . . . . . . . . . . . . . . . . . . 499
Wann SQLite nachteilig ist . . . . . . . . . . . . . . . . . . . . . . . . 499
12.3 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
Eine einfache Beispielanwendung . . . . . . . . . . . . . . . . . . . 500
Eine Benutzerverwaltung mit SQLite . . . . . . . . . . . . . . . . 501
Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
12.4 Referenz SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
12.5 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
Tag 13 Datenbanklösungen mit MySQL . . . . . . . . . . . . . . . . . . . . . . . . 509
13.1 Bibliotheks-Verwaltung mit MySQL. . . . . . . . . . . . . . . . . . 510
Schrittfolge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Weitere Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
13.2 Vorbereitung der Datenbank. . . . . . . . . . . . . . . . . . . . . . . . 512
Datenbank anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
Tabellen anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
13.3 Die Seiten des Projekts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
Vorbereitungen – das Template-System. . . . . . . . . . . . . . . 516
Funktionsweise des Template-Systems. . . . . . . . . . . . . . . . 517
Der Code der Seiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
Die Geschäftslogik des Ausleihvorgangs . . . . . . . . . . . . . . 537
13.4 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
13.5 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
12

13. Inhaltsverzeichnis
Tag 14 XML und Webservices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
14.1 Vorbemerkungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
XPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562
Ein konkretes XML-Format: RSS. . . . . . . . . . . . . . . . . . . . 568
14.2 Einführung in die libxml2 . . . . . . . . . . . . . . . . . . . . . . . . . 575
Neu in PHP5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
Die neuen DOM-Funktionen . . . . . . . . . . . . . . . . . . . . . . 576
14.3 SimpleXML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
Unterschiede zur DOM-Schnittstelle . . . . . . . . . . . . . . . . 581
Ein Schritt weiter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
XML-Namensräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
14.4 SOAP-Webservices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
Der Amazon-Webservice: ein Überblick . . . . . . . . . . . . . . 597
Webservices konsumieren . . . . . . . . . . . . . . . . . . . . . . . . . 607
14.5 Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
Referenz SimpleXML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
Referenz DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
14.6 Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
Anhang A Antworten auf die Kontrollfragen . . . . . . . . . . . . . . . . . . . . . . . . 627
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
13

15. Vorwort
Sie möchten PHP lernen? Kein Problem, nehmen Sie sich ein Buch, ein paar
Tage Zeit und schon können Sie PHP?! Leider ist das nicht ganz so, denn PHP ist
keine isolierte Sprache auf der einsamen Insel der glücklichen Programmierer,
sondern in ein komplexes System aus Standards, anderen Sprachen und Protokol-
len eingebunden. Um PHP erfolgreich einsetzen zu können, müssen Sie sehr viel
mehr beherrschen und wissen, als der reine Sprachkern erfordert.
Der erste Tag soll deshalb dazu dienen, die Begriffe und Abhängigkeiten zu sortie-
ren, Sie mit den wichtigsten Techniken vertraut zu machen und so die Grund-
lagen für schnelle Lernfortschritte zu legen.
Sie erfahren hier,
í an welche Zielgruppe sich dieses Buch wendet,
í wie dieses Buch aufgebaut ist und wie Sie es benutzen sollten, um maximalen
Nutzen daraus zu ziehen,
í wie sich PHP entwickelt hat und warum manches so ist, wie es sich heute dar-
stellt,
í wie das PHP in die Welt der Webserver und deren Protokolle und Techniken
eingebunden ist,
í wo Sie im Internet mehr Quellen finden und wie Sie Hilfe bei praktischen
Problemen erhalten.
Für wen das Buch und die Reihe gedacht sind
Das vorliegende Buch ist Teil der sehr erfolgreichen »14-Tage«-Reihe. Warum
14 Tage? An wen wurde dabei als Zielgruppe gedacht?
15

16. Vorwort
Unsere Zielgruppe als Leser
Das Buch wendet sich an Leser, die bisher mit anderen Skriptsprachen oder auch
nur mit HTML gearbeitet haben oder sich in der Ausbildung befinden. Elemen-
tare Grundlagen der Programmierung sind hilfreich, vieles lässt sich aber auch gut
aus dem Zusammenhang erschließen.
Dieses Buch ist so ausgelegt, dass Sie jedes Kapitel an einem Tag durcharbeiten
können. Nach nur 14 Tagen haben Sie dann alle wichtigen Funktionen kennen
gelernt und können selbst PHP-Programme schreiben. Der Weg zum professionel-
len Programmierer ist freilich weit.
Die ersten Erfolge und die steile Lernkurve sollten Sie ermutigen, sich fortan zügig
in spezifische Probleme einzuarbeiten und dort die Feinheiten der jeweiligen
Funktion zu verstehen. Dieses Buch kann und will nicht jedes Detail behandeln.
Eine umfassende Darstellung würde gut den zehnfachen Umfang erfordern. Um
in einer überschaubaren Zeit zu greifbaren Ergebnissen zu gelangen, müssen Sie
sich auf die entscheidenden 20% konzentrieren, mit denen Sie 80% aller Alltags-
aufgaben meistern können.
Um einen intensiven Lerneffekt zu erzielen, finden Sie am Ende jedes Tages
einige Fragen. Beantworten Sie diese und schlagen Sie bei Schwierigkeiten noch-
mals nach. Lassen Sie den Tag immer Revue passieren und wiederholen sie selbst-
ständig Abschnitte, die Ihnen besonders kompliziert erschienen. Die 14 Tage sind
kein Zwang, sondern helfen vor allem bei der zielgerichteten Erarbeitung der Auf-
gabenstellung.
PHP und ...
PHP als Skriptsprache zur Webserverprogrammierung steht nicht isoliert da. Tat-
sächlich können Sie PHP niemals erfolgreich einsetzen, wenn Sie sich nicht mit
den Technologien auseinander setzen, die rund um den Webserver benutzt wer-
den.
An erster Stelle steht natürlich HTML. Ohne HTML-Kenntnisse werden Sie kein
einziges brauchbares PHP-Programm erstellen. Damit eng verbunden ist Java-
Script, das HTML an einigen Stellen etwas unter die Arme greift. Ohne JavaScript
kommen Sie aus, bleiben aber immer in der Amateur-Liga.
Gleiches gilt für Datenbanken und die Datenbankabfragesprache SQL. Es gibt
viele kleine und gute Programme, die auf eine Datenbankanbindung verzichten.
16

17. Für wen das Buch und die Reihe gedacht sind
Praktisch jedes größere Projekt baut jedoch darauf auf, und es sind signifikante
Vorteile, die den Einsatz von Datenbanksystemen in so breiter Front vorangetrie-
ben haben. SQL spielt deshalb in diesem Buch eine bedeutende Rolle. In engem
Zusammenhang damit steht XML – eingesetzt zum Datenaustausch und zur
Schaffung von universellen Datenschnittstellen. Auch dieses Thema nimmt brei-
ten Raum ein und zwingt so auch den Leser zur aktiven Auseinandersetzung
damit.
Zwischen Browser und Webserver pendeln die Daten nicht im luftleeren Raum.
Das Web basiert auf Protokollen, die den Verkehr regeln – allen voran HTTP. Da
Sie als PHP-Entwickler die Kontrolle über den Webserver haben, nehmen Sie die
Rolle des Verkehrspolizisten ein. Und an dieser Stelle müssen Sie zwangsläufig
HTTP kennen. Damit eng verbunden sind die anderen im Internet verwendeten
Protokolle wie POP3 und SMTP für E-Mail oder FTP für Dateiübertragungen.
Ein paar Worte zum Autor
Jörg Krause, Jahrgang 1964, wohnt mit Familie in Berlin. Er
arbeitet als freier Autor, Systemprogrammierer und Consul-
tant. Seine Arbeitsschwerpunkte sind die
í Programmierung von Internetapplikationen und Daten-
banken mit PHP, ASP, C#, XML/XSL, HTML, MS SQL-
Server, MySQL,
í Programmierung von Windows-Applikationen mit .NET-
Technologie,
í Consulting für Start-Ups und »Old Economy«,
í Seminare über Webserverprogrammierung (HTML, ASP, PHP) ,
í und journalistische Arbeiten.
Sie finden außerdem regelmäßig Artikel von ihm in Fachzeitschriften wie iX, dot-
net- oder PHP-Magazin und können seine Vorträge auf Fachkonferenzen erleben.
Des Weiteren veröffentlichte er mehr als 30 Fachbücher zu Themen wie Windows
2000, Windows XP, Microsoft Active Server Pages, ASP.NET, C#, VB.NET, PHP
sowie Electronic Commerce und Online Marketing.
17

18. Vorwort
Interessierten Lesern steht der Autor für professionelle Softwareentwicklung und
Programmierung zur Verfügung. Dies betrifft sowohl Web- als auch Windows-
Applikationen. Professionelles Know-how finden Sie über Beratung, Coaching,
Training, Schulung und Consulting.
In diesem Buch verwendete Konventionen
Dieses Buch enthält spezielle Icons, mit denen wichtige Konzepte und Informationen her-
ausgestrichen werden sollen.
Ein Hinweis enthält interessante Informationen zum behandelten Thema.
Ein Tipp gibt Ihnen Ratschläge oder zeigt Ihnen einfachere Wege zur Lösung
eines Problems auf.
Ein Achtungszeichen weist Sie auf mögliche Probleme hin und hilft Ihnen,
schwierigen Situationen aus dem Wege zu gehen.
In Listings zeigt Ihnen dieses Zeichen, dass die laufende Zeile nur aus satztechni-
schen Gründen umbrochen wurde. Sie müssen hier also keinen Return setzen.
18

19. W
T ag 1 Einführung 21 O
T ag 2 Erste Schritte 45
C
Tag 3 Daten verarbeiten 73
H
T ag 4 Programmieren 131
E
T ag 5 Daten mit Arrays verarbeiten 181
Tag 6 Objektorientierte Programmierung 203
T ag 7 Das Dateisystem entdecken 243
W
T ag 8 Formular- und Seitenmanagement 277 O
Tag 9 Professionelle Programmierung 373 C
Tag 10 Kommunikation per HTTP, FTP und E-Mail 415 H
Tag 11 Datenbankprogrammierung 443 E
Tag 12 Die integrierte Datenbank SQLite 497
Tag 13 Datenbanklösungen mit MySQL 509
Tag 14 XML und Webservices 549

21. Einführung
1

22. Einführung
1.1 Die Geschichte von PHP
Dieser Abschnitt zeigt einen kurzen Abriss der Geschichte von PHP, die zwar erst
kurz aber dafür umso beeindruckender ist.
PHP/FI
1995 entwickelte der damals erst 17-jährige Däne Rasmus Lerdorf unter dem
Namen PHP/FI einen Satz von Perl-Skripten zur Erfassung der Zugriffe auf seine
Website. Diese so genannten »Personal Home Page (Tools)/Forms Interpreter«
setzte er später noch einmal in der Sprache C um. Das führte zu mehr Leistung
und höherer Geschwindigkeit, als dies mit den damaligen Perl-Werkzeugen mög-
lich war. PHP/FI kannte Variablen, konnte Formularinhalte interpretieren und
besaß eine Perl-ähnliche Syntax, die allerdings noch relativ inkonsistent war.
Lerdorf entschied sich, den Quellcode von PHP/FI im Sinne der Debian Free
Software Guidelines freizugeben. Damit war der Weg für die einfache Entwick-
lung dynamischer Websites frei.
Im November 1997 wurde PHP/FI 2.0 offiziell freigegeben; nach eigenen Anga-
ben kam die Software auf ca. 50.000 Sites zum Einsatz. Obwohl bereits mehrere
Entwickler am Quellcode mitarbeiteten, leistete nach wie vor Lerdorf den Löwen-
anteil der Arbeit. PHP/FI 2.0 wurde kurz darauf durch die erste Alphaversion von
PHP3 abgelöst.
PHP3
Im gleichen Jahr starteten Andi Gutmans und Zeev Suraski eine Kooperation mit
Rasmus Lerdorf. Auf der Basis von PHP/FI 2.0 aufbauend kündigten sie PHP 3.0
als offiziellen Nachfolger an, denn die bestehende Leistungsfähigkeit von PHP/FI
2.0 hatte sich vor allem im Bereich von eCommerce-Applikationen als nicht
ausreichend erwiesen. Die neue Sprache sollte unter einem neuen Namen veröf-
fentlicht werden; vor allem deswegen, um die im alten Namen implizierte einge-
schränkte Nutzung aufzugeben. Man einigte sich auf PHP, das – ganz im Stile des
GNU-Projektes – ein rekursives Akronym für »PHP Hypertext Preprocessor« dar-
stellt. PHP Version 3.0 wurde im Juni 1998 nach einer neunmonatigen öffentli-
chen Testphase offiziell freigegeben.
22

23. Die Geschichte von PHP
PHP3 überzeugte vor allem durch seine Erweiterungsmöglichkeiten, die solide
Infrastruktur, die Möglichkeit einer objektorientierten Syntax sowie die Unterstüt-
zung der gängigsten Datenbanken. Dutzende von Entwicklern sahen diese Stärken
und beteiligten sich mit neuen Modulen an PHP3. Möglicherweise war gerade die
Zusammenarbeit von vielen Entwicklern einer der Gründe für den gewaltigen
Erfolg von PHP. Ende 1998 wurde PHP von einigen Zehntausend Benutzern ver-
wendet. Die Installationen von PHP deckten dabei schätzungsweise 10% aller
Websites im Netz ab.
PHP4
Bereits kurz nach dem offiziellen Release von PHP3 begannen Gutmans und
Suraski, den Kern von PHP umzuschreiben. Die Leistung komplexer Applika-
tionen sollte gesteigert werden und der Basiscode sollte modularer werden. Mitte
1999 wurde die neue PHP-Engine unter dem Namen »Zend« (gebildet aus Teilen
der Vornamen Zeev und Andi) erstmalig eingeführt, der auch Namensgeber der
Firma der beiden ist: Zend Ltd. (www.zend.com). Ein Jahr später konnte PHP4.0
offiziell freigegeben werden. Basierend auf der »Zend«-Engine glänzte diese Ver-
sion neben ihrer stark verbesserten Leistung vor allem durch ihre Unterstützung
verschiedenster Webserver, HTTP-Sessions, Ausgabepufferung und vielen neuen
Sprachkonstrukten.
PHP 4 wird weltweit von unzähligen Entwicklern erfolgreich eingesetzt. Mit meh-
reren Millionen Installationen (schätzungsweise 20% aller Websites) ist PHP
damit eine der erfolgreichsten Entwicklungen im dynamischen Internet.
PHP5
Die Arbeit an der Spezifikation und der Verbesserung der »Zend«-Engine als Basis
für die neuen Leistungsmerkmale von PHP5 ist der nächste Schritt. Obwohl
PHP 4 bereits optimal an die Aufgabe »Webserverprogrammierung« angepasst ist
und vielen Entwicklern ein verlässliches Werkzeug in die Hand gibt, blieben Kri-
tikpunkte bestehen. Vor allem die Profilager, wo mit C++ und Java programmiert
wird, bemängelten die eingeschränkten Fähigkeiten der Sprache im Bereich
Objektorientierung (OOP). Eine weitere wichtige Funktion war die Möglichkeit,
einen Applikationsserver aufzubauen. Skriptprogramme laufen normalerweise nur
auf Initiative des Benutzers ab, der über seinen Browser ein Programm startet.
Applikationsserver können selbstständig Programme agieren lassen. Diese Forde-
rung wurde mit PHP5 nicht erfüllt.
23

24. Einführung
Die OOP-Fähigkeiten sind mit der Version 5 deutlich verbessert worden. Sie wer-
den sich damit an gleich zwei Tagen intensiv beschäftigen können. Von einem
Applikationsserver ist allerdings nach wie vor weit und breit nichts zu sehen. Dies
wird »Skripter« freuen, denen die Einfachheit des Systems am Herzen liegt, und
das Profilager zu Recht an Java, C# und C++ festhalten lassen.
PHP5 ist ein gutes, professionelles und leistungsfähiges Tool geworden, mit dem
sich kleine und mittlere Projekte schnell und effizient erstellen lassen. Diesen
Markt sollte man vor Augen haben und verstehen, dass PHP5 keine ernst zu neh-
mende Konkurrenz für Java und ASP.NET ist, auch wenn diese Tatsache einige
Vertreter der PHP-Community partout nicht verstehen wollen.
1.2 PHP auf einen Blick
Wenn Sie neugierig sind und darauf brennen, schnell in PHP einzusteigen, sollten
Sie sich nicht zurückhalten lassen. Es ist durchaus hilfreich, schon mal ein paar
Skripte laufen zu lassen, bevor die ganzen theoretischen Schritte durchgegangen
werden.
Dieser Abschnitt setzt voraus, dass Sie bereits Zugriff auf einen PHP-Server haben.
Falls Sie die lokale Installation, die am zweiten Tag behandelt wird, noch nicht
vorziehen möchten und auch keinen Provider haben, der Skripte ausführt, gehen
Sie auf den Webserver des Autors: www.php5.comzept.de.
Dort können Sie die hier gezeigten Skripte eingeben und ausführen. Aus Sicher-
heitsgründen werden aber andere als die hier gezeigten Funktionen nicht akzep-
tiert.
Ein wenig Vorbereitung
Um Skriptdateien ausführen zu können, brauchen Sie einen Webserver. Wenn
Sie sich damit auskennen, nutzen Sie den Ihnen bekannten Webserver und legen
Sie ein virtuelles Verzeichnis mit dem Namen »MuT« an, in das Sie dann alle
Skripte speichern. Rufen Sie die fertigen Skripte nun wie folgt auf:
http://localhost/MuT/scriptname
24

25. PHP auf einen Blick
Statt scriptname steht der Name des Skripts, beispielsweise listing1.php. Die
Dateierweiterung benötigt der Webserver, um die Datei an den PHP-Interpreter
weiterzureichen. Genauer wird dies am zweiten Tag erläutert.
Wenn Sie die Codes des Programms sehen oder der Browser das Skript zum Her-
unterladen anbietet, ist die gewählte Dateierweiterung .php unbekannt oder PHP
ist nicht oder falsch installiert. Zur Lösung dürfen Sie schon mal zum zweiten Tag
blättern und schmulen.
Mit PHP spielen
PHP wird in HTML eingebettet. Das heißt, Sie erstellen primär eine einfache
HTML-Seite und bringen darin PHP unter. Der erste Schritt besteht deshalb in
der Beschaffung einer geeigneten HTML-Datei:
Listing 1.1: Basis aller Versuche: Eine einfache HTML-Datei (html1.php)
html
head
titleListing 1/title
/head
body
h1Unser erster Test/h1
/body
/html
Speichern Sie diesen Text unter html1.php im Übungsverzeichnis des Webservers.
Führen Sie ihn dann aus, indem Sie im Browser folgende Zeile eingeben:
http://localhost/MuT/html1.php
Wenn es nicht funktioniert, probieren Sie statt localhost die lokale IP-Adresse
127.0.0.1. Wenn der Webservers nicht lokal (auf der Entwicklungsmaschine) läuft,
müssen Sie den Namen oder die IP-Adresse anstellte von localhost angeben. Am
zweiten Tag werden ein paar Tipps vorgestellt, wie man ein Entwicklungssystem
geschickt aufbaut.
Nun geht es aber wirklich los! Das erste Skript diente nur als Test für die Funktion
des Webservers und von PHP. Es enthielt freilich noch keinen PHP-Code. Eine
kleine Erweiterung soll nun auch PHP ins Spiel bringen:
25

26. Einführung
Listing 1.2: PHP erzeugt Text
html
head
titleListing 2/title
/head
body
h1Unser erster Test/h1
?php
$text = Hallo PHP5;
print($text);
?
/body
/html
Hier sind Sie nun gleich mit mehreren Techniken konfrontiert worden, die ele-
mentar für die PHP-Programmierung sind. Auch wenn es nur vier neue Zeilen
sind, passiert hier jedoch Erstaunliches. Typisch für die Programmierung ist es,
dass fast jedes Zeichen eine Bedeutung hat. Programmierer arbeiten sehr effizient,
deshalb wird viel abgekürzt und viel mit Symbolen gearbeitet. Zeilenweise
betrachtet sieht dies nun folgendermaßen aus:
í ?php
Hier geht es los: Diese Zeichenfolge leitet einen Programmteil ein, der von
PHP verarbeitet werden soll. Auf der nächsten Zeile steht nun Programmcode.
í $text = Hallo PHP5;
Hier passieren mehrere Dinge. Zum einen wird eine Variable erzeugt. Sie hat
den Namen »text« und speichert die Zeichenfolge »Hallo PHP5«. Das $-Zei-
chen sagt PHP, dass es sich um eine Variable handelt, es ist aber nicht Teil des
Namens. Der Name ist willkürlich gewählt und adressiert eine Speicherstelle,
wo PHP die Daten ablegt.
Das Semikolon am Ende ist auch ganz wichtig und teilt PHP mit, dass dieser
Befehl nun zu Ende ist. Der Zeilenwechsel selbst ist PHP ziemlich egal (meis-
tens jedenfalls), das Programm liest sich aber so besser.
í print($text);
Hier ist auch wieder richtig viel los: »print« ist eine Funktion, die PHP bereit
stellt und die Daten ausgibt; in diesem Fall die Variable $text und damit deren
Inhalt. Ausgeben heißt bei PHP »an dieser Stelle ins HTML einfügen«. Denn
die eigentliche Ausgabe zum Browser – das Senden der Daten – erledigt der
Webserver.
26

27. PHP auf einen Blick
í ?
Damit alles seine Ordnung hat, wird der PHP-Abschnitt korrekt beendet. Der
Rest ist nur HTML und wird unverändert vom Webserver ausgegeben.
Programmierung mit PHP ist nun eigentlich ganz einfach. Es kommt darauf an,
die richtigen Funktionen und Befehle in der richtigen Reihenfolge aufzuschrei-
ben. Damit es Spaß macht, bietet PHP über 2.000 solcher Funktionen in über
100 Bibliotheken und dazu noch reichlich Sprachbefehle und Operatoren. Inso-
fern ist PHP nun doch nicht so ganz einfach...
Ein paar wichtige Techniken
Das Beispiel zeigte freilich nur wenig. Etwas mehr Systematik bietet dieser
Abschnitt. Zuerst sollten Sie lernen, sich über Zeilenumbrüche weniger Gedan-
ken zu machen. Folgender Code ist dem bereits gezeigten völlig gleichwertig1:
?php $text = Hallo PHP5; ?
?php print($text); ?
In einem Skript können beliebig viele solcher PHP-Blöcke stehen, die von oben
nach unten abgearbeitet werden. Wie es gezeigt wurde ist es nicht immer clever,
immerhin braucht auch die Erkennung der Zeichen ?php und ? einige Zeit
(nichts, was Sie jemals spüren oder messen könnten, aber richtige Programmierer
macht es schon nervös, wenn der Server ständig ein paar Nanosekunden lang sinn-
lose Dinge tut).
Woran Sie sich hier gewöhnen müssen, sind die öffnenden und schließenden
Sequenzen und die abschließenden Semikola.
Manche Befehle wirken über einen bestimmten Bereich hinweg bzw. fassen
mehrere Zeilen zusammen. In solchen Fällen werden geschweifte Klammern ver-
wendet. Das sieht dann folgendermaßen aus:
?php
$a = 5;
$b = 5;
if ($a == $b)
{
$text = a und b sind gleich;
1 Um Papier zu sparen, wird der langweilige HTML-Teil hier nicht jedes Mal mitgedruckt
27

28. Einführung
print($text);
}
?
PHP wird deshalb der Gruppe der so genannten Klammersprachen zugeordnet, zu
der auch Java und alle C-Versionen zählen. Die Klammer ersetzt übrigens das
Semikolon, aber das haben Sie sicher bereits bemerkt. Eine wichtige Technik ist
das Einrücken. Das ist dem PHP-Interpreter natürlich wieder egal, es dient nur der
Verbesserung der Lesbarkeit. Tun Sie sich selbst und allen späteren Entwicklern
des Programms den Gefallen, wirklich konsequent einzurücken. Die meisten Edi-
toren unterstützen das in der einen oder anderen Weise.
Weil gerade die Rede von anderen Entwicklern war: Kommentare im Quelltext
sind ein gutes Mittel, sich als mitteilsam zu erweisen und die Lesbarkeit weiter zu
verbessern. Dazu setzen Sie wieder spezielle Zeichen ein:
?php
// $a und $b wurden bereits woanders definiert
if ($a == $b)
{
$text = a und b sind gleich;
print($text);
}
?
Die beiden Schrägstriche leiten einen Kommentar ein, der am nächsten Zeilen-
umbruch endet. Alternativ können mehrzeilige Kommentare mit /* Kommentar */
geschrieben werden. Da gibt es aber einige Fallen und deshalb wird diesem
Thema am dritten Tag ein eigener Abschnitt gewidmet.
Eine nähere Betrachtung ist die Funktion print wert. Funktionen haben Parame-
ter und deshalb immer runde Klammern am Ende. Wenn man mal keine Daten
übergeben will, bleiben die Klammern leer, aber sie fallen niemals weg. Ob man
Daten direkt (Fachsprache: als Literal) oder über eine Variable übergibt, spielt sel-
ten eine Rolle. Es gibt aber Fälle, wo dies wichtig ist. Auch dazu wird der dritte
Tag handfeste Informationen zu bieten haben. Damit die Sache in der Praxis nicht
langweilig wird (wer kommt schon mit 2.000 Funktionen aus?), können Sie auch
eigene Funktionen definieren.
Auch wenn es so ähnlich aussieht, if ist keine Funktion, sondern eine Sprachan-
weisung. Die Klammern fassen einen komplexeren Ausdruck zusammen. Sprach-
anweisungen sehen sehr unterschiedlich aus und bedürfen einer eingehenden
Betrachtung. Tag 6 widmet sich ganz diesem Thema, ebenso wie den selbst erstell-
ten Funktionen.
28

29. Einen Webserver bauen
1.3 Einen Webserver bauen
Bevor die Arbeit mit PHP5 beginnen kann, benötigen Sie eine Entwicklungsum-
gebung. Diese besteht aus einem Editor, in dem Quelltexte erfasst und bearbeitet
werden, einem Webserver, PHP5 ausführen kann, und einem Browser, der die
Skripte vom Webserver abruft. Für die Bearbeitung von Datenbanken wird noch
ein Datenbanksystem benötigt.
Vorbemerkungen
PHP5 ist fest in der Linux-Welt etabliert. Inzwischen existiert jedoch auch eine
sehr stabile Version für Windows, die den Einsatz auch auf Produktionssystemen
erlaubt. Für die Entwicklung zählten jedoch schon früher auch andere Kriterien,
wie beispielsweise ein guter Editor. Diese sind nach wie vor eher in der Windows-
Welt zu finden.
Nach Untersuchungen einiger kommerzieller Editor-Hersteller werden ca. 90%
aller Skripte auf Windows entwickelt. Das Hosting – also der eigentliche Produkti-
onsbetrieb der fertigen Applikation – findet dann mit ähnlicher Dominanz unter
Linux statt.
Der Aufbau eines Entwicklungssystems unter Linux ist deshalb in den meisten Fäl-
len kein Thema, Aufwand und Nutzen stehen in einem sehr ungünstigen Verhält-
nis zueinander. An dieser Stelle soll deshalb nur der Aufbau eines so genannten
WAMP-Systems demonstriert werden, wie es in den allermeisten Fällen zum Ein-
satz kommen dürfte.
WAMP vorbereiten
Alle nötigen Daten finden Sie auf der CD zum Buch. Wenn Sie die allerneuesten
Versionen möchten, müssen Sie diese entsprechend aus dem Internet herunterla-
den. Benötigt werden:
í PHP5 – Binärdistribution für Windows
í PHP5 PECL-Module
í Apache 2 – Binärdistribution für Windows
29

30. Einführung
Auf die Datenbank soll an dieser Stelle vorerst verzichten werden. In den entspre-
chenden Kapiteln wird entweder das integrierte SQLite benutzt, das keine weite-
ren Installationsschritte verlangt, oder MySQL, dem ein eigener Tag gewidmet ist.
Im Internet finden Sie die entsprechenden Dateien auf folgenden Webseiten:
í PHP5: www.php.net/downloads.php
Nutzen Sie hier die Option »PHP5.0.0 zip package« unter »Windows Bina-
ries«. Außerdem ist die »Collection of PECL modules for PHP5.0.0« interes-
sant, eine Sammlung weiterer Module, von denen einige gebraucht werden
könnten. PHP5 selbst ist ca. 7,5 MB groß, die Module brauchen etwa 930 KB.
í Apache: httpd.apache.org/download.cgi
Wählen Sie hier die Option »Win32 Binary (MSI Installer)«. Der Dateiname
hat in etwa die Form »apache_2.0.50-win32-x86-no_ssl.msi«. Es handelt sich
also um die Version 2.0.50 für Win32-Systeme, verpackt als Windows-Installer-
Paket (MSI). Die Größe beträgt ca. 6 MB. Wenn Sie auf dem Webserver
genau diese Version finden, können Sie sie auch von der CD nehmen.
Windows-Installer-Pakete sind mit Windows XP eingeführt worden und
laufen sofort auf Windows XP Pro, XP Home und Windows Server 2003.
Sie laufen auch auf einem aktualisierten Windows 98 und Me. Falls
MSI als Dateierweiterung nicht bekannt ist, müssen Sie sich über die
Microsoft-Download-Seite ein entsprechendes Update beschaffen.
Benötigt wird mindestens Microsoft Installer 1.2. Gehen Sie bei Bedarf
auf folgende Website: www.microsoft.com/downloads/release.asp?Release
ID=32831 (Win 9X) bzw. www.microsoft.com/downloads/release.asp?Re
leaseID=32832 (NT4, 2000).
Nach dem die Installationspakete vorliegen, beginnt die Installation. Installieren
Sie zuerst den Webserver, testen Sie ihn und fahren Sie dann mit PHP5 fort.
1.4 Apache installieren
Dank des Installers ist die Installation ganz einfach. Die Schritte werden nachfol-
gend gezeigt und anhand der Bemerkungen können Sie die nötigen Angaben
machen. Starten Sie nun den Installer und überspringen Sie den Startbildschirm
des Assistenten mit NEXT.
30

31. Apache installieren
Installationsstart
Nach dem Start der Installation müssen Sie die Lizenzbedingungen bestätigen
und eine Informationsseite mit allgemeinen Hinweisen über sich ergehen lassen.
Gehen Sie jeweils mit NEXT weiter, bis Sie zur Seite SERVER INFORMATION
gelangt sind.
Abbildung 1.1:
Auch bei GPL-
Projekten sind die
Lizenzbestimmun-
gen anzuerkennen
Erste Schritte
Die erste erforderliche Eingabe konfiguriert den Server. Webserver sind immer
Teil einer Domain, wenn Sie im Inter- oder Intranet laufen, beispielsweise
php.net. Sie haben immer einen bestimmten Namen, der meist »www« lautet. Der
Webserver der PHP Group heißt deshalb www.php.net. Es ist möglich, dass Sie
lokal über keine Domain verfügen, weil ihr Rechner direkt am Internet hängt, Sie
also keine eigenen Namensdienste betreiben. Die Angabe der richtigen Domain
ist jedoch notwendig, damit der Browser den Server später auch findet.
Für einen lokal betriebenen Webserver nimmt man meist den Namen localhost,
der an die interne Loopback-Adresse 127.0.0.1 gebunden ist. Diese Adresse stellt
sicher, dass Anfragen nicht über Router ans Internet oder andere Computer im
Netzwerk weitergeleitet werden. Meist ist die entsprechende Verknüpfung zwi-
31

32. Einführung
schen localhost und 127.0.0.1 schon vorhanden. Um dies zu prüfen, öffnen Sie die
Datei hosts (ohne Dateierweiterung) im Verzeichnis c:windowssystem32
driversetc. Ist die Datei leer, wird folgende Zeile eingefügt:
127.0.0.1 localhost
Achten Sie beim Speichern darauf, dass der Editor keine Dateierweiterung
anhängt. Auf dem folgenden Bildschirm im Installationsassistenten ist nun folgen-
des anzugeben:
í Domain: localhost
í Servername: localhost
í E-Mail des Administrators: Ihre E-Mail (wird nicht benutzt)
í Option FOR ALL USERS, ...
Die Option FOR ALL USERS, ... (für alle Benutzer) ist grundsätzlich richtig, wenn
Sie keine anderen Webserver wie die Internetinformationsdienste auf dem Com-
puter installiert haben. Apache benutzt standardmäßig Port 80 (dies ist der Port,
den der Browser benutzt, wenn man nichts angibt). Dieser Port sollte natürlich frei
sein. Haben Sie keinen anderen Webserver installiert, ist dieser Port frei.
Abbildung 1.2:
Einstellungen für
ein lokales System
32

33. Apache installieren
Setzen Sie mit NEXT fort. Im nächsten Schritt werden Sie gefragt, ob sie die Stan-
dardinstallation oder eine benutzerdefinierte wünschen. Wählen Sie CUSTOM
(Benutzerdefiniert).
Abbildung 1.3:
Benutzerdefinierte
Installation –
verhindert unnö-
tige Module
Sie können nun auf der nächsten Seite einige Optionen abwählen, die für PHP5
nicht benötigt werden. Falls Sie sich intensiver mit Apache auseinandersetzen
möchten, belassen Sie die Dokumentation im Installationspaket. Allerdings sind
die Texte auch online verfügbar. Mit einer schnellen Internetverbindung können
Sie online schneller arbeiten (siehe Abbildung 1.4).
Im nächsten Schritt müssen Sie den Start der Installation nur noch bestätigen, den
Rest erledigt der Installer dann automatisch (siehe Abbildung 1.5).
Falls Fehler auftreten, werden diese in Konsolenfenstern angezeigt. Am Ende
erhalten Sie eine Erfolgsmeldung. Nun kann der Webserver getestet werden.
Ein erneuter Start des Installers erlaubt die Reparatur oder Vervollständi-
gung einer bestehenden Installation, die nicht komplett installiert wurde
oder aus anderen Gründen nicht läuft.
33

34. Einführung
Abbildung 1.4:
Was nicht benö-
tigt wird, fliegt
raus
Abbildung 1.5:
Während der
Installation
34

35. Apache installieren
Apache testen
Der erste Test ist sehr einfach. Öffnen Sie Ihren Browser und geben Sie folgende
Adresse ein:
http://localhost
Abbildung 1.6:
Der Webserver
funktioniert
Weitere Einstellungen
Der Apache Webserver wird über eine Konfigurationsdatei mit dem Namen
httpd.conf verwaltet. Diese ist über START | ALLE PROGRAMME | APACHE HTTP
SERVER 2.0.50 | CONFIGURE APACHE SERVER zu finden.
Prüfen Sie beispielsweise Ihre Einstellungen, die Sie während der Installation vor-
genommen haben, indem Sie nach einer Zeile suchen, die mit SERVERNAME
beginnt. Dort sollte folgendes stehen:
ServerName localhost:80
35

36. Einführung
Jetzt ist noch interessant zu wissen, wo die Dateien abgelegt werden, die der Web-
server anbietet. Jeder Webserver hat ein Stammverzeichnis, das benutzt wird,
wenn die blanke Adresse angegeben wird. Beim Apache-Webserver heißt dieses
Verzeichnis htdocs und liegt unter
C:ProgrammeApache GroupApache2htdocs
Apache automatisch starten
Es ist sinnvoll, wenn der Webserver nach dem Start des Betriebssystems sofort zur
Verfügung steht. Bei manueller Arbeitsweise können Sie Apache über entspre-
chende Aufrufe starten und stoppen. Über START | ALLE PROGRAMME | APACHE
HTTP SERVER 2.0.50 | CONTROL APACHE SERVER finden Sie die Optionen
START, STOP und RESTART.
Abbildung 1.7:
Dienst-Verwaltung für den
Apache Webserver
36

37. PHP5 installieren
Unter Win9X fügen Sie den Startaufruf in den Autostart-Ordner des Startmenüs
ein. Auf XP und 2000 wird Apache automatisch als Dienst installiert und startet
mit dem Betriebssystem. Se können dies kontrollieren, indem Sie den Dienst-
Manager öffnen. Gehen Sie (unter XP) dazu im STARTMENÜ auf ARBEITSPLATZ,
klicken Sie mit der rechten Maustaste und wählen Sie dann VERWALTEN. Alterna-
tiv finden Sie die Option auch in der Systemsteuerung unter VERWALTUNG |
COMPUTERVERWALTUNG. Es öffnet sich eine Managementkonsole. Dort suchen
Sie den Zweig DIENSTE UND ANWENDUNGEN und darin DIENSTE. In der Dienst-
liste ist der Eintrag APACHE2 zu finden. Öffnen Sie diesen mit einem Doppelklick
(siehe Abbildung 1.7).
Wenn Sie möchten, dass der Dienst immer automatisch startet, stellen Sie den
STARTTYP entsprechend ein.
Läuft alles, geht die Installation nun mit PHP5 weiter.
1.5 PHP5 installieren
PHP5 kommt als ZIP-Datei daher und muss nur ausgepackt werden. Dazu wählen
Sie ein passendes Verzeichnis, am besten im Zweig Ihres Apache-Webservers:
C:ProgrammeApache Groupphp5
Entpacken Sie alle Dateien dorthinein. Denken Sie daran, dass Winzip beim Ent-
packen evtl. den Namen der Datei in den Pfad einbaut. Unter dem Verzeichnis
php5 sollten sofort die entsprechenden Arbeitsdateien folgen, nicht der von Win-
zip erzeugte Ordner, der dem Namen der gepackten Datei entspricht.
Entpacken Sie nun noch die PECL-Datei. Sie können alle enthaltenen Module
nach folgendem Pfad kopieren:
C:ProgrammeApache Groupphp5ext
Hier liegen bereits die standardmäßig in PHP5 eingebundenen Module.
1.6 PHP5 konfigurieren
PHP5 wird – ähnlich wie der Apache Webserver – über eine Konfigurationsdatei
mit dem Namen php.ini konfiguriert. Nach der Installation gibt es diese noch
nicht. Stattdessen finden Sie zwei Musterdateien:
37

38. Einführung
í php.ini-dist
Dies ist die Datei mit allen Standardoptionen.
í php.ini-recommended
Eine Datei mit der empfohlenen Konfiguration.
Erstellen Sie nun eine Kopie von php.ini-dist und nennen diese php.ini. Lassen
Sie die Originaldatei auf jeden Fall unverändert, damit Sie die ursprüngliche Kon-
figuration im Fehlerfall wiederherstellen können.
Die Datei php.ini
Die Datei php.ini ist in mehrere Abschnitte unterteilt, die jeweils bestimmte Funk-
tionen konfigurieren. Die Abschnitte beginnen immer mit einem als Sektion aus-
geführten Block, der etwa folgendermaßen aussieht:
[Session]
Darin befinden sich mehrere Optionen, denen jeweils ein Wert zugewiesen wird.
Vielen Optionen wird lediglich ein »On« oder »Off« zugeordnet, um die betref-
fende Funktion ein- oder auszuschalten:
asp_tags = Off
Anderen werden bestimmte Werte zugeordnet:
output_buffering = 4096
Einige Optionen sind auch »ausgeblendet«, indem ein Kommentarzeichen (das ist
das Semikolon) davor gestellt ist:
;extension=php_curl.dll
Wenn man diese Option aktivieren möchte, entfernt man einfach das Semikolon.
Stört eine Option, setzt man ein Semikolon davor.
Wichtige Konfigurationsschritte
Eigentlich muss man bei PHP5 nicht viel konfigurieren. Einige Optionen sind
dennoch eine nähere Betrachtung wert, damit später alles funktioniert.
Zuerst sollten Sie PHP5 mitteilen, wo die Erweiterungen zu finden sind, die even-
tuell benutzt werden sollen. Die entsprechende Option heißt folgendermaßen:
38

39. PHP5 testen
extension_dir = ./
Tragen Sie hier den Pfad zum ext-Verzeichnis ein:
extension_dir = C:ProgrammeApache GroupPHP5ext
Nun können Sie die Erweiterungen selbst freigeben, die Sie benutzen möchten.
Dazu suchen Sie die Liste mit den extension-Optionen. Nehmen Sie, wenn der
Eintrag bereits vorhanden ist, das Semikolon weg. Um ein PECL-Modul zu
benutzten, fügen Sie den entsprechenden Eintrag hinzu. Für dieses Buch sind fol-
gende Einträge sinnvoll:
extension = php_gd2.dll
extension = php_mysqli.dll
extension = php_soap.dll
Sie werden früher oder später weitere benötigen; ergänzen Sie dann die Liste ent-
sprechend.
Eine sinnvolle Funktion ist das Hochladen von Dateien. Zur Konfiguration dienen
zwei Optionen:
upload_tmp_dir = C:Windowstemp
upload_max_filesize = 8M
Die erste teilt PHP mit, in welchem Pfad temporäre Dateien abzulegen sind. Stan-
dardmäßig ist diese Option nicht aktiviert. Beachten Sie, dass der Webserver in die-
sem Pfad Schreibrechte benötigt. Die zweite Option stellt die Größe der Dateien
auf maximal 8 MB ein, der Standardwert 2 MB ist meist zu klein.
Die Verwaltung von Benutzersitzungen spielt in PHP5 eine große Rolle. Damit
später alles funktioniert, ist auch hier eine entsprechende Änderung erforderlich:
session.save_path = C:Windowstemp
Die Option ist meist auskommentiert.
Dies sind freilich nur einige Optionen, die geändert werden können. An entspre-
chender Stelle wird im Buch immer wieder auf diese php.ini zugegriffen.
1.7 PHP5 testen
Um nun mit PHP5 arbeiten zu können, muss dem Webserver noch mitgeteilt wer-
den, wann und wie PHP-Skripte auszuführen sind. Standardmäßig ist ein Webser-
39

40. Einführung
ver ein primitives Stück Software. Er erkennt Anfragen mit dem Protokoll HTTP
auf Port 80 (falls so konfiguriert) und führt diese aus. Das heißt, er erkennt mindes-
tens die HTTP-Kommandos GET (Anfordern einer Ressource, beispielsweise
einer Datei) und POST (Anfordern einer Ressource, der zugleich Formulardaten
übergeben werden). GET führt standardmäßig dazu, dass der Webserver auf der
Festplatte nach der entsprechenden Datei sucht und diese an den Browser sendet.
Damit PHP5 ins Spiel kommt, wird eine spezielle Dateierweiterung benutzt.
Theoretisch ist die Wahl freigestellt, eine »sinnvolle« Benennung ist jedoch unbe-
dingt erforderlich. Für PHP5 ist dies .php, falls keine andere Version auf demsel-
ben Server läuft. Haben Sie parallel noch PHP 4 laufen, ist .php5 eine gute
Ergänzung. Alle Skripte in diesem Buch tragen die Dateierweiterung .php und las-
sen sich nur dann unverändert einsetzen, wenn dies auch im Apache entsprechend
konfiguriert wird.
Konfiguration des Webservers für PHP5
Die Verknüpfung der Dateierweiterung findet wieder in der httpd.conf statt. Letzt-
lich wird nur definiert, dass Dateien mit der Endung .php nicht direkt ausgeliefert,
sondern zuvor an die ausführbare Instanz von PHP geschickt werden.
Der Apache-Webserver kann PHP5 in zwei Arten bedienen – als CGI (Common
Gateway Interface) und als Apache-Modul (mod_php). Es ist für ein Entwicklungs-
system dringend zu empfehlen, CGI zu benutzen. CGI ist eine sehr alte und ver-
gleichsweise langsame Schnittstelle. Auf einem Entwicklungssystem, wo immer
nur ein Browser läuft und damit kaum parallele Zugriffe stattfinden, gibt es jedoch
keinen Unterschied in der Zugriffsgeschwindigkeit. CGI bietet dafür einen durch-
aus ernst zu nehmenden Vorteil. Da bei jedem Aufruf die entsprechende Instanz
gestartet wird, die die Anfrage ausführt, werden auch eventuell vorhandene Ände-
rungen an der Konfiguration sofort erkannt. Da gerade in der ersten Zeit häufig
mit den Konfigurationen gespielt wird, wäre ein ständiges Stoppen und Starten des
Servers suboptimal. Denn läuft PHP als Modul, wird es nur einmal gestartet und
bleibt für jeden folgenden Aufruf aktiv. Änderungen an der PHP-Konfiguration
wirken sich damit nicht sofort aus, da diese nur beim Start gelesen wird.
Änderungen an der httpd.conf erfordern immer einen Neustart des Web-
servers – also des Apache2-Dienstes im Besonderen. Das Betriebssystem
selbst muss niemals neu gestartet werden.
40

41. PHP5 testen
Tragen Sie nun folgenden Text in die httpd.conf ein (beachten Sie, dass der Skript-
Alias hier nur php lautet, Installationen die PHP 4 und PHP5 parallel betreiben,
sollten hier einen anderen Namen benutzen):
ScriptAlias /php/ C:/Programme/Apache Group/php5/
AddType application/x-httpd-php .php
Action application/x-httpd-php /php/php-cgi.exe
Änderungen wirken sich erst aus, wenn der Apache-Dienst neu gestartet wird. Die
drei Zeilen verknüpfen die Dateierweiterung .php mit der ausführbaren Datei php-
cgi.exe, die Teil der PHP5-Installation ist. Passen Sie die Pfade an, wenn Sie bei
den vorhergehenden Schritten nicht exakt den Vorschlägen gefolgt sind.
PHP-Skripte ausführen
Nun ist es an der Zeit, einen ersten Test vorzunehmen. PHP5 stellt eine Funktion
bereit, die über die gesamte Konfiguration Auskunft gibt: phpinfo. Diese wird
benutzt, um das allerkleinste PHP-Skript zu schreiben:
Listing 1.3: info.php – Informationen über PHP5 ermitteln
?php
phpinfo();
?
Speichern Sie diesen Text unter dem Namen info.php unter htdocs ab. Rufen Sie
dann im Browser folgende Adresse auf:
http://localhost/info.php
Sie sollten dann in etwa folgende Seite sehen (siehe Abbildung 1.8).
Wenn Sie die Seite weiter nach unten scrollen, finden Sie Angaben zu den instal-
lierten Modulen, konfigurierten Umgebungs- und Servervariablen und andere
Daten über Ihr PHP5. Wenn Sie Änderungen an der Datei php.ini vornehmen,
beispielsweise Erweiterungen hinzufügen, erscheinen hier Angaben über jedes
einzelne Modul. Sie können so sehr schnell kontrollieren, ob die Einstellungen
den gewünschten Effekt haben. Stimmt alles, kann es jetzt mit der Programmie-
rung richtig losgehen.
41

42. Einführung
Abbildung 1.8:
PHP5 läuft auf
einem Apache-
Webserver
Wenn es nicht funktioniert
Auch wenn die Installation verhältnismäßig trivial ist, können Fehler passieren.
Jeder Computer ist anders konfiguriert und manchmal klappt es einfach nicht. Ein
paar typische Fehler zeigt die folgende Liste:
í Fehlermeldung der Art »Socket-Fehler« oder »Adresse 0.0.0.0:80 nicht verfüg-
bar« während der Installation des Webservers.
Sie haben einen weiteren Webserver (vermutlich IIS) laufen, der Port 80 ist so
bereits belegt. Weisen Sie dem IIS eine andere IP-Adresse, einen anderen Port
zu oder deaktivieren Sie ihn ganz. Starten Sie die Apache-Installation erneut
mit der Option REPAIR.
í Der Browser zeigt die Fehlermeldung 400 (Bad Request, Falsche Anforde-
rung).
Die Verknüpfung zwischen .php und PHP ist in der httpd.conf falsch einge-
richtet. Vermutlich stimmt ein Pfad nicht. Versuchen Sie auch nochmals, den
42

43. Kontrollfragen
Webserver neu zu starten: START | ALLE PROGRAMME | APACHE HTTP-SER-
VER 2.0.50 | CONTROL APACHE SERVER | RESTART.
Alternativ können Sie das Fehlerprotokoll untersuchen. Öffnen Sie START |
ALLE PROGRAMME | APACHE HTTP-SERVER 2.0.50 | REVIEW SERVER LOG
FILES | REVIEW ERROR LOG. Dort finden Sie hilfreiche Hinweise zu den Vor-
gängen im Webserver, beispielsweise folgendes:
[Mon Jul 19 16:03:41 2004] [error] [client 127.0.0.1] script not found
or unable to stat: C:/Programme/Apache Group/php5php-cgi.exe
Hier fehlt in der Konfiguration hinter php5 offensichtlich ein Pfadtrennzei-
chen.
í Statt der Info-Seite wird der Inhalt der Datei angezeigt.
Auch hier gelangte die Datei nicht bis zu PHP, Apache hat sie einfach als Res-
source behandelt und ausgeliefert. Vermutlich ist der Eintrag in der httpd.conf
nicht vorhanden oder nach dem Eintragen erfolgt kein Neustart.
1.8 Kontrollfragen
1. Wann wurde PHP das erste Mal unter diesem Namen bekannt?
2. Was bedeutet »PHP«?
3. Worauf ist der Name »Zend« zurückzuführen?
4. Anhand welcher Begrenzungszeichen werden PHP-Fragmente in HTML-Code
erkannt?
5. Welches Protokoll wird zur Übertragung von HTML-Seiten vom Server zum
Browser verwendet?
6. Welcher Webserver kann auf allen Betriebssystemen zur Entwicklung eingesetzt
werden?
7. Wofür steht der Begriff WAMP?
8. Welche Bedeutung hat die Adresse »http://localhost«?
9. Mit welcher Funktion kann PHP5 ausführlich getestet werden?
43

45. Erste Schritte
2

46. Erste Schritte
Die ersten Schritte mit PHP beginnen immer mit HTML. Denn es ist das Ziel
jeder PHP-Anwendung, HTML-Seiten zu erzeugen. Darauf aufbauend wird das
Einbetten von PHP in HTML behandelt und es werden elementare Programmier-
techniken vorgestellt, die in den folgenden Tagen angewendet werden. Als Ab-
schluss soll ein Blick auf die Arbeitsweise von HTTP das Zusammenspiel von
Webserver und Browser näher bringen.
2.1 Einfache HTML-Seiten
Ihre Entwicklungsumgebung sollte also in der Lage sein, HTML-Seiten über
einen URL-Aufruf auszuliefern. Das folgende Skript kann als Start benutzt werden:
Listing 2.1: Basis aller Seiten – eine HTML-Struktur
html
head
titleKein Titel/title
/head
body
PHP beginnt hier...
/body
/html
Diese Seite sollte in einem Verzeichnis des Webservers liegen, das mit dem Brow-
ser aufgerufen werden kann, beispielsweise http://localhost/php5Mut/html1.html.
Diese Adresse wird im Browser eingegeben, dann sollte sie erscheinen. Erst wenn
dies funktioniert, lohnt es, mit PHP5 weiterzumachen.
Viele Fehler bei der Entwicklung von PHP entstehen, weil schlechtes oder nicht
lauffähiges HTML erzeugt wird. Browser tolerieren zwar falsches HTML, reagie-
ren also nicht mit einer Fehlermeldung. Sie zeigen aber im Zweifelsfall gar nichts
oder völlig unsinniges an. Nicht immer ist ein falsches PHP-Skript daran schuld.
Wenn beispielsweise vergessen wurde, das title-Tag zu schließen, nimmt der
Browser den gesamten Text als Titel und die Seite selbst bleibt weiß. Solche Feh-
ler offenbart ein Blick in den Quelltext, beim Internet Explorer am einfachsten
über das Kontextmenü (rechte Maustaste) – QUELLTEXT ANZEIGEN.
46

47. Einfache HTML-Seiten
HTML-Refresh
Bevor Sie mit PHP anfangen, sollten Sie ihre HTML-Kenntnisse überprüfen. Die-
ser Abschnitt zeigt die wichtigsten Elemente einer HTML-Seite.
Grundstruktur
Jede HTML-Seite hat folgende Grundstruktur:
Listing 2.2: Grundaufbau einer HTML-Seite
html
head
titleTitel der Seite/title
/head
body
/body
/html
Alles, was auf der Seite ausgegeben werden soll, muss zwischen den body-Tags
stehen. Im Kopfbereich (head) stehen der Seitentitel, JavaScript-Codes und Ver-
weise auf Stildateien (CSS).
JavaScript einbinden
Um JavaScript zu nutzen, ist folgendes Tag vorgesehen:
script language=JavaScript
function MyFunction()
{
alert(Tu was);
}
/script
Stildateien (Stylesheets) einbinden
Stildateien werden über das Tag link eingebunden:
link href=stile/comzept.css type=text/css/
47

48. Erste Schritte
Das Attribut href verweist auf den relativen, variablen Pfad zu der Stildatei, wäh-
rend das Attribut type auf den Typ festgelegt ist.
Sollen die Stile direkt eingebettet werden, wird dagegen das Tag style verwen-
det:
style
*
{
color:black;
font-weight:normal;
text-decoration:none;
font-size:9pt;
font-family:Verdana;
}
/style
Das Sternchen legt die gewählte Formatierung als global fest.
Die wichtigsten Formatier- und Auszeichnungselemente
Die folgende Tabelle zeigt in einer Übersicht die wichtigsten Elemente, die in all-
täglichen Seiten (und in diesem Buch) verwendet werden:
Tag Wichtige Attribute Container? Beschreibung
b, strong ja Fett
i, em ja Kursiv
u ja Unterstrichen
strike ja Durchgestrichen
pre ja Wie im Text formatiert
sup ja Hoch gestellt
sub ja Tiefer gestellt
p wahlweise Absatz
Tabelle 2.1: Wichtige Formatier- und Auszeichnungselemente
48

49. Einfache HTML-Seiten
Tag Wichtige Attribute Container? Beschreibung
br clear=left|right nein Zeilenumbruch, das Attribut
clear bestimmt das Verhalten
angrenzender Blöcke
img src, width, height, nein Fügt ein Bild ein, src bestimmt
hspace, vspace den Pfad zum Bild
ul type ja Liste mit Zeichen als Aufzäh-
lungszeichen
ol type ja Liste mit Zahlen als Aufzäh-
lungszeichen
li ja Listelement für ul und ol
div ja Absatz, frei formatierbar
span ja Zeichenblock, frei formatierbar
Tabelle 2.1: Wichtige Formatier- und Auszeichnungselemente (Forts.)
Wenn keine Attribute benannt sind, können dennoch immer die Standardattribute
benutzt werden:
í style
Enthält eingebettete Stildefinitionen, beispielsweise color:red;
í class
Verweist auf eine Klasse, die in Stildefinitionen der Seite erstellt wurde.
í id
Verweist auf eine ID, die in Stildefinitionen der Seite erstellt wurde.
Tabellen und Bilder
Tabellen und Bilder sind auf fast jeder Seite zu finden. Tabellen dienen vor allem
der Formatierung. Die Grundstruktur einer Tabelle basiert auf folgenden Tags:
í table/table
Diese Tags umschließen die Tabelle.
49

50. Erste Schritte
í tr.../tr
Es folgen Tags für die Definition einer Reihe.
í tdInhalt/td
Innerhalb der Reihe stehen diese Tags für jede Zeile.
í thKopf/th
Kopfelemente werden mit einem eigenen Tag definiert. Der Inhalt erscheint
fett und zentriert, wenn dies nicht von Stilen überschrieben wird.
Eine einfache Tabelle mit drei mal drei Zellen sieht nun folgendermaßen aus:
Listing 2.3: Einfache Tabelle mit Überschrift
table border=1
tr
thName/ththAnschrift/ththTelefon/th
/tr
tr
td/tdtd/tdtd/td
/tr
tr
td/tdtd/tdtd/td
/tr
/table
Das Attribut border sorgt für einen einfachen Rand. Meist wird hier 0 eingesetzt,
damit die Tabelle nur das Raster für andere Elemente liefert, selbst aber unsichtbar
bleibt.
Abbildung 2.1:
Eine einfache Tabelle
Wichtige Tabellenattribute
Die folgenden Tabellen zeigen die wichtigsten Attribute für die Tags table und
td.
50

51. Einfache HTML-Seiten
Attribut Beispiel Bedeutung
border border=1 Rand in Pixel
cellspacing cellspacing=3 Abstand der Zellen voneinander
cellpadding cellpadding=4 Abstand des Inhalts zum Zellenrand
width width=100% Breite, entweder in Pixel oder % vom Browserfenster
oder der umschließenden Tabelle
height height=477 Höhe, entweder in Pixel oder % vom Browserfenster
oder der umschließenden Tabelle
Tabelle 2.2: Einige Attribute für table
Attribut Beispiel Bedeutung
bgcolor bgcolor=red Hintergrundfarbe der Zelle
width width=50 Breite der Zelle, kann nicht kleiner sein als der
Inhalt
height height=20 Höhe der Zelle, kann nicht kleiner sein als der
Inhalt
colspan colspan=3 Zelle dehnt sich über drei Spalten aus
rowspan rowspan=2 Zelle dehnt sich über zwei Zeilen aus
Tabelle 2.3: Einige Attribute für td
Vor allem der Umgang mit colspan und rowspan ist nicht ganz einfach. Dabei
muss beachtet werden, dass die Gesamtzahl der Zellen pro Reihe immer gleich ist,
damit sich eine konstante Anzahl von Spalten bildet. Andernfalls zerfällt die
Tabelle. Das folgende Bild zeigt, wie eine Verknüpfung von Zellen mit
colspan=2 bzw. rowspan=2 aussieht:
Abbildung 2.2:
Verknüpfte Zellen mit rowspan und colspan
51

52. Erste Schritte
Der Code für diese Tabelle sieht nun folgendermaßen aus:
Listing 2.4: Tabelle mit verknüpften Zellen
table border=1
tr
thName/ththAnschrift/ththTelefon/th
/tr
tr
td colSpan=2/td
td rowspan=2/td
/tr
tr
td/td
td/td
/tr
/table
In der zweiten und dritten Zeile sind nur zwei td-Elemente enthalten, weil sich
durch die Verknüpfungen die erforderliche Anzahl von drei Zellen ergibt. Das
heißt, die Angabe td steht für eine Zelle, während td colspan=2 für zwei
Zellen steht. In die folgende Zeile ragt die mit rowspan verknüpfte Zelle der zwei-
ten Zeile hinein, deshalb kann (und muss) die dritte Zelle hier entfallen.
Formulare
Formulare sind der dritte große Komplex in HTML. PHP bietet eine weitläufige
Unterstützung für die Verarbeitung von Formulardaten. Deshalb ist eine gute
Kenntnis der Formularelemente unerlässlich.
Ein Formular erstellen
Ein Formular entsteht, indem Formularelemente neben normalem HTML inner-
halb des Tags form gestellt wird.
Die Formularelemente
Die folgende Tabelle zeigt alle Formularelemente und die wichtigsten Attribute:
52

53. PHP einbetten
Element type-Attribut Attribute Nutzen, Anwendung
input text value, size, name Textfeld, einzeilig
button value, name Schaltfläche
submit value, name Absendeschaltfläche
reset value, name Rücksetzschaltfläche, leert das For-
mular
file name Dateihochladen
checkbox value, name, checked Kontrollkästchen
radio value, name, checked Optionsfeld
select - size, multiple Listbox, Klappfeld
textarea - Großes Textfeld, statischer Text
steht zwischen den Tags (Container)
Die Benutzung wird an anhand vieler Beispiele im Buch dokumentiert, sodass
eine ausführliche Darstellung an dieser Stelle nicht sinnvoll erscheint. Sollte
Ihnen das eine oder andere Tag gänzlich unbekannt erscheinen, konsultieren Sie
die entsprechende Fachliteratur zum Thema HTML.
2.2 PHP einbetten
Bislang wurde der Text in den HTML-Seiten statisch ausgegeben. Nach diesen
Grundlagen ist es nun an der Zeit, PHP5 zum Leben zu erwecken. Die folgenden
Beispiele zeigen, wie das mit PHP funktioniert. Die genaue Arbeitsweise wird im
Laufe des Tages noch genauer erläutert. Probieren Sie die Beispiele erst aus.
Wie PHP den Code erkennt
Wenn der Browser eine PHP-Seite beim Webserver anfordert, erkennt dieser an
der Dateierweiterung, dass PHP für die Verarbeitung zuständig ist. Der Webserver
übergibt dem PHP-Modul die Information, welche Seite verarbeitet werden soll.
53

54. Erste Schritte
Das Modul lädt diese Seite dann von der Festplatte und liest den Inhalt Zeile für
Zeile ein. In einem mehrstufigen Prozess entstehen daraus Zwischencodes, die
interpretiert werden. Auf die genauen Zusammenhänge wird noch genauer einge-
gangen. Bei diesem Vorgang sucht das PHP-Modul gezielt nach bestimmten PHP-
Codes. Der erste ist die Eröffnung eines Code-Blocks:
?php
Der zweite wichtige Code ist das Ende eine Code-Blocks:
?
Die Syntax lehnt an XML an und würde im XML-Dialekt als so genannte Prozess-
anweisung verstanden werden. Baut man Seiten mit XHTML (der XML-Darstel-
lung von HTML), so stört der eingebettet PHP-Code die Syntax der Seite nicht
und erlaubt weiterhin die Mischung von PHP und (X)HTML. Es gibt noch andere
Erkennungszeichen, die PHP zulässt. Das Gezeigte ist jedoch das einzige praxist-
augliche und wird deshalb exklusiv vorgestellt.
Wie viele solcher Blöcke in der Seite stehen, spielt kaum ein Rolle. Man kann
zwar theoretische Erwägungen darüber anstellen, ob die mehrfache Eröffnung von
Code-Blöcken auf der Seite Leistung kostet, in der Praxis ist das aber kaum rele-
vant, weil viele andere Teile der Verarbeitungsmaschine einen weitaus gewichtige-
ren Einfluss nehmen.
Jeder Text, der außerhalb der Blöcke steht, wird unverändert ausgegeben. Dies
betrifft normalerweise den HTML-Anteil. Da die Verarbeitung von oben nach
unten erfolgt, wird die Seite genau so gesendet, wie sie aufgebaut ist. Es ist nun
Sache der eingebetteten Codes, an den richtigen Stellen vernünftige Ausgaben zu
erzeugen.
Listing 2.5: PhpStart1.php: Eine einfache Ausgabe
html
head
titlePhpStart1/title
/head
body
?php
echo PHP beginnt hier...;
?
/body
/html
54