Php5 Und My SQL In 14 Tagen.pdf - Ausbildung-Elektrotechnik

PHP5 und MySQL in 14 Tagen

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

PHP5 HP5 und
und
MySQ ySQ ySQL ySQ

Bibliografische Information Der Deutschen Bibliothek
Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie;
detaillierte bibliografische Daten sind im Internet über 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

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
PHP 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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

Inhaltsverzeichnis
6
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

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

Inhaltsverzeichnis
8
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

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

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

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

Inhaltsverzeichnis
12
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

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

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 Protokollen
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 sortieren,
Sie mit den wichtigsten Techniken vertraut zu machen und so die Grundlagen
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 darstellt,
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. Elementare
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 professionellen
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 Alltagsaufgaben
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 nochmals
nach. Lassen Sie den Tag immer Revue passieren und wiederholen sie selbstständig
Abschnitte, die Ihnen besonders kompliziert erschienen. Die 14 Tage sind
kein Zwang, sondern helfen vor allem bei der zielgerichteten Erarbeitung der Aufgabenstellung.
PHP und ...
PHP als Skriptsprache zur Webserverprogrammierung steht nicht isoliert da. Tatsächlich
können Sie PHP niemals erfolgreich einsetzen, wenn Sie sich nicht mit
den Technologien auseinander setzen, die rund um den Webserver benutzt werden.
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.

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 vorangetrieben
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 breiten
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 Consultant.
Seine Arbeitsschwerpunkte sind die
Programmierung von Internetapplikationen und Datenbanken
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, dotnet-
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 herausgestrichen
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 satztechnischen
Gründen umbrochen wurde. Sie müssen hier also keinen Return setzen.

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

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öglich
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 Entwicklung
dynamischer Websites frei.
Im November 1997 wurde PHP/FI 2.0 offiziell freigegeben; nach eigenen Angaben
kam die Software auf ca. 50.000 Sites zum Einsatz. Obwohl bereits mehrere
Entwickler am Quellcode mitarbeiteten, leistete nach wie vor Lerdorf den Löwenanteil
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öffentlicht
werden; vor allem deswegen, um die im alten Namen implizierte eingeschränkte
Nutzung aufzugeben. Man einigte sich auf PHP, das – ganz im Stile des
GNU-Projektes – ein rekursives Akronym für »PHP Hypertext Preprocessor« darstellt.
PHP Version 3.0 wurde im Juni 1998 nach einer neunmonatigen öffentlichen
Testphase offiziell freigegeben.

Die Geschichte von PHP
PHP3 überzeugte vor allem durch seine Erweiterungsmöglichkeiten, die solide
Infrastruktur, die Möglichkeit einer objektorientierten Syntax sowie die Unterstützung
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 verwendet.
Die Installationen von PHP deckten dabei schätzungsweise 10% aller
Websites im Netz ab.
PHP 4
Bereits kurz nach dem offiziellen Release von PHP3 begannen Gutmans und
Suraski, den Kern von PHP umzuschreiben. Die Leistung komplexer Applikationen
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 Version
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 mehreren
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 Kritikpunkte
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 Forderung
wurde mit PHP5 nicht erfüllt.
23

24
Einführung
Die OOP-Fähigkeiten sind mit der Version 5 deutlich verbessert worden. Sie werden
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 nehmende
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 Sicherheitsgründen
werden aber andere als die hier gezeigten Funktionen nicht akzeptiert.
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/

PHP auf einen Blick
Statt 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 Herunterladen
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)
Listing 1
Unser erster Test
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
Listing 2
Unser erster Test
Hier sind Sie nun gleich mit mehreren Techniken konfrontiert worden, die elementar
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 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 aufzuschreiben.
Damit es Spaß macht, bietet PHP über 2.000 solcher Funktionen in über
100 Bibliotheken und dazu noch reichlich Sprachbefehle und Operatoren. Insofern
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 Gedanken
zu machen. Folgender Code ist dem bereits gezeigten völlig gleichwertig 1 :
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 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 sinnlose
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 verwendet.
Das sieht dann folgendermaßen aus:

}
?>
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 Editoren
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:
Die beiden Schrägstriche leiten einen Kommentar ein, der am nächsten Zeilenumbruch
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 Parameter
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 selten
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 Sprachanweisung.
Die Klammern fassen einen komplexeren Ausdruck zusammen. Sprachanweisungen
sehen sehr unterschiedlich aus und bedürfen einer eingehenden
Betrachtung. Tag 6 widmet sich ganz diesem Thema, ebenso wie den selbst erstellten
Funktionen.

1.3 Einen Webserver bauen
Einen Webserver bauen
Bevor die Arbeit mit PHP5 beginnen kann, benötigen Sie eine Entwicklungsumgebung.
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 Produktionsbetrieb
der fertigen Applikation – findet dann mit ähnlicher Dominanz unter
Linux statt.
Der Aufbau eines Entwicklungssystems unter Linux ist deshalb in den meisten Fällen
kein Thema, Aufwand und Nutzen stehen in einem sehr ungünstigen Verhältnis
zueinander. An dieser Stelle soll deshalb nur der Aufbau eines so genannten
WAMP-Systems demonstriert werden, wie es in den allermeisten Fällen zum Einsatz
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 herunterladen.
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 entsprechenden
Kapiteln wird entweder das integrierte SQLite benutzt, das keine weiteren
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 Binaries«.
Außerdem ist die »Collection of PECL modules for PHP5.0.0« interessant,
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 nachfolgend
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.

Installationsstart
Apache installieren
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.
Erste Schritte
Abbildung 1.1:
Auch bei GPL-
Projekten sind die
Lizenzbestimmungen
anzuerkennen
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:\windows\system32\
drivers\etc. 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 folgendes
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 Computer
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

Apache installieren
Setzen Sie mit NEXT fort. Im nächsten Schritt werden Sie gefragt, ob sie die Standardinstallation
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ändigung
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

Apache testen
Apache installieren
Der erste Test ist sehr einfach. Öffnen Sie Ihren Browser und geben Sie folgende
Adresse ein:
http://localhost
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 vorgenommen
haben, indem Sie nach einer Zeile suchen, die mit SERVERNAME
beginnt. Dort sollte folgendes stehen:
ServerName localhost:80
Abbildung 1.6:
Der Webserver
funktioniert
35

36
Einführung
Jetzt ist noch interessant zu wissen, wo die Dateien abgelegt werden, die der Webserver
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:\Programme\Apache Group\Apache2\htdocs
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 entsprechende
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

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. Alternativ
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 Dienstliste
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:\Programme\Apache Group\php5
Entpacken Sie alle Dateien dorthinein. Denken Sie daran, dass Winzip beim Entpacken
evtl. den Namen der Datei in den Pfad einbaut. Unter dem Verzeichnis
php5 sollten sofort die entsprechenden Arbeitsdateien folgen, nicht der von Winzip
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:\Programme\Apache Group\php5\ext
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 Konfiguration
im Fehlerfall wiederherstellen können.
Die Datei php.ini
Die Datei php.ini ist in mehrere Abschnitte unterteilt, die jeweils bestimmte Funktionen
konfigurieren. Die Abschnitte beginnen immer mit einem als Sektion ausgefü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 betreffende
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 eventuell
benutzt werden sollen. Die entsprechende Option heißt folgendermaßen:

extension_dir = "./"
Tragen Sie hier den Pfad zum ext-Verzeichnis ein:
extension_dir = "C:\Programme\Apache Group\PHP5\ext"
PHP5 testen
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 folgende
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 entsprechend.
Eine sinnvolle Funktion ist das Hochladen von Dateien. Zur Konfiguration dienen
zwei Optionen:
upload_tmp_dir = ?C:\Windows\temp?
upload_max_filesize = 8M
Die erste teilt PHP mit, in welchem Pfad temporäre Dateien abzulegen sind. Standardmäßig
ist diese Option nicht aktiviert. Beachten Sie, dass der Webserver in diesem
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:\Windows\temp"
Die Option ist meist auskommentiert.
Dies sind freilich nur einige Optionen, die geändert werden können. An entsprechender
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 werden,
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 mindestens
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 unbedingt
erforderlich. Für PHP5 ist dies .php, falls keine andere Version auf demselben
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 lassen
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. Letztlich
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 Entwicklungssystem
dringend zu empfehlen, CGI zu benutzen. CGI ist eine sehr alte und vergleichsweise
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 durchaus
ernst zu nehmenden Vorteil. Da bei jedem Aufruf die entsprechende Instanz
gestartet wird, die die Anfrage ausführt, werden auch eventuell vorhandene Änderungen
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 Webservers
– also des Apache2-Dienstes im Besonderen. Das Betriebssystem
selbst muss niemals neu gestartet werden.

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 phpcgi.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
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 installierten
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 Programmierung
richtig losgehen.
41

42
Einführung
Wenn es nicht funktioniert
Abbildung 1.8:
PHP5 läuft auf
einem Apache-
Webserver
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ügbar«
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 Anforderung).
Die Verknüpfung zwischen .php und PHP ist in der httpd.conf falsch eingerichtet.
Vermutlich stimmt ein Pfad nicht. Versuchen Sie auch nochmals, den

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 Vorgä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 Pfadtrennzeichen.
Statt der Info-Seite wird der Inhalt der Datei angezeigt.
Auch hier gelangte die Datei nicht bis zu PHP, Apache hat sie einfach als Ressource
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

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 Programmiertechniken
vorgestellt, die in den folgenden Tagen angewendet werden. Als Abschluss
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
Kein Titel
PHP beginnt hier...
Diese Seite sollte in einem Verzeichnis des Webservers liegen, das mit dem Browser
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, reagieren
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 -Tag zu schließen, nimmt der
Browser den gesamten Text als Titel und die Seite selbst bleibt weiß. Solche Fehler
offenbart ein Blick in den Quelltext, beim Internet Explorer am einfachsten
über das Kontextmenü (rechte Maustaste) – QUELLTEXT ANZEIGEN.

HTML-Refresh
Einfache HTML-Seiten
Bevor Sie mit PHP anfangen, sollten Sie ihre HTML-Kenntnisse überprüfen. Dieser
Abschnitt zeigt die wichtigsten Elemente einer HTML-Seite.
Grundstruktur
Jede HTML-Seite hat folgende Grundstruktur:
Listing 2.2: Grundaufbau einer HTML-Seite
Titel der Seite
Alles, was auf der Seite ausgegeben werden soll, muss zwischen den -Tags
stehen. Im Kopfbereich () stehen der Seitentitel, JavaScript-Codes und Verweise
auf Stildateien (CSS).
JavaScript einbinden
Um JavaScript zu nutzen, ist folgendes Tag vorgesehen:
function MyFunction()
{
alert("Tu was");
}
Stildateien (Stylesheets) einbinden
Stildateien werden über das Tag eingebunden:
47

48
Erste Schritte
Das Attribut href verweist auf den relativen, variablen Pfad zu der Stildatei, während
das Attribut type auf den Typ festgelegt ist.
Sollen die Stile direkt eingebettet werden, wird dagegen das Tag verwendet:
*
{
color:black;
font-weight:normal;
text-decoration:none;
font-size:9pt;
font-family:Verdana;
}
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 alltäglichen
Seiten (und in diesem Buch) verwendet werden:
Tag Wichtige Attribute Container? Beschreibung
, ja Fett
, ja Kursiv
ja Unterstrichen
ja Durchgestrichen
ja Wie im Text formatiert
ja Hoch gestellt
ja Tiefer gestellt
wahlweise Absatz
Tabelle 2.1: Wichtige Formatier- und Auszeichnungselemente

Tag Wichtige Attribute Container? Beschreibung
Einfache HTML-Seiten
clear="left|right" nein Zeilenumbruch, das Attribut
clear bestimmt das Verhalten
angrenzender Blöcke
src, width, height,
hspace, vspace
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:
Diese Tags umschließen die Tabelle.
nein Fügt ein Bild ein, src bestimmt
den Pfad zum Bild
type ja Liste mit Zeichen als Aufzählungszeichen
type ja Liste mit Zahlen als Aufzählungszeichen
ja Listelement für und
ja Absatz, frei formatierbar
ja Zeichenblock, frei formatierbar
Tabelle 2.1: Wichtige Formatier- und Auszeichnungselemente (Forts.)
49

50
Erste Schritte
...
Es folgen Tags für die Definition einer Reihe.
Inhalt
Innerhalb der Reihe stehen diese Tags für jede Zeile.
Kopf
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
NameAnschriftTelefon
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.
Wichtige Tabellenattribute
Abbildung 2.1:
Eine einfache Tabelle
Die folgenden Tabellen zeigen die wichtigsten Attribute für die Tags und
.

Attribut Beispiel Bedeutung
border border="1" Rand in Pixel
cellspacing cellspacing="3" Abstand der Zellen voneinander
Einfache HTML-Seiten
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
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
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
NameAnschriftTelefon
In der zweiten und dritten Zeile sind nur zwei -Elemente enthalten, weil sich
durch die Verknüpfungen die erforderliche Anzahl von drei Zellen ergibt. Das
heißt, die Angabe steht für eine Zelle, während für zwei
Zellen steht. In die folgende Zeile ragt die mit rowspan verknüpfte Zelle der zweiten
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 innerhalb
des Tags gestellt wird.
Die Formularelemente
Die folgende Tabelle zeigt alle Formularelemente und die wichtigsten Attribute:

Element type-Attribut Attribute Nutzen, Anwendung
input text value, size, name Textfeld, einzeilig
button value, name Schaltfläche
submit value, name Absendeschaltfläche
PHP einbetten
reset value, name Rücksetzschaltfläche, leert das Formular
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 eingegangen.
Bei diesem Vorgang sucht das PHP-Modul gezielt nach bestimmten PHP-
Codes. Der erste ist die Eröffnung eines Code-Blocks:
Die Syntax lehnt an XML an und würde im XML-Dialekt als so genannte Prozessanweisung
verstanden werden. Baut man Seiten mit XHTML (der XML-Darstellung
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 praxistaugliche
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 relevant,
weil viele andere Teile der Verarbeitungsmaschine einen weitaus gewichtigeren
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
PhpStart1

Ausgaben erzeugen
Innerhalb der Code-Blöcke folgt nun PHP-Anweisung auf PHP-Anweisung. Dies
kann sehr verschieden aussehen, weil PHP im Umgang mit Code sehr flexibel ist.
Zur besseren Lesbarkeit schreibt man in der Regel immer genau eine Anweisung
pro Zeile oder teilt sehr lange Konstrukte sogar auf. Mehrere Anweisungen auf
einer Zeile gehört zu den Dingen, die man als Profi unbedingt vermeidet.
2.3 Ausgaben erzeugen
Auch einfachste PHP-Skripte geben Daten aus. Die erzeugten Zeichen werden an
der Stelle in die HTML-Ausgabe eingebaut, wo der entsprechende Ausgabebefehl
steht. PHP kennt hierfür mehrere Techniken:
Die Ausgabeanweisung echo
Die Ausgabefunktion print und einige spezialisierte Versionen, wie printf
Die verkürzte, direkte Ausgabe allein stehender Variablen
Die Ausgabe mit echo
Die Anweisung echo gibt die übergebenen Argument direkt aus. Im Gegensatz zu
Funktionen wie print müssen hier keinen Klammern gesetzt werden. Solange es
nur ein einziges Argument gibt, darf dieses aber in runde Klammern gestellt werden.
Diese Schreibweise ist jedoch unüblich und sollte auch deshalb vermieden
werden, um die Natur als Sprachanweisung im Code herauszuheben.
Außerdem verkraftet echo beliebig viele Argumente, die durch Kommata getrennt
werden. Listing 2.6 zeigt die möglichen Varianten:
Listing 2.6: EchoVariants.php – Ausgaben mit der Anweisung echo
Freilich wird in der Praxis nicht nur eine einfache Zeichenfolge ausgegeben, sondern
auch das Ergebnis einer Berechnung oder der Inhalt einer Variable.
55

56
Erste Schritte
Variablen ausgeben
Variablen sind benannte Speicherstellen für Daten. Am vierten Tag wird dieses
Thema ausführlich behandelt. Einstweilen sei nur auf die grundlegende Syntax
hingewiesen: $text ist eine Variable mit dem Namen »text«. Für PHP ist sie
erkennbar durch das vorangestellte $-Zeichen.
Eine solche explizite Erkennungsmöglichkeit erlaubt es, Variablen auch mitten in
anderem Text zu erkennen. Das funktioniert tatsächlich, sodass Sie auch folgendes
schreiben können:
Listing 2.7: EchoVariable1.php: Variable in einer Zeichenfolge erkennen
Die Variable $version wird anhand des $-Zeichens erkannt. Damit das Ende korrekt
gefunden wird, muss entweder ein Leerzeichen folgen oder die ganze Konstruktion
in geschweifte Klammern gepackt werden:
Listing 2.8: EchoVariable2.php: Variable in einer Zeichenfolge schützen
Solche Ausgaben sind sehr häufig und typisch in PHP. Die Möglichkeit, Variablen
in Zeichenketten einzubetten, ist deshalb außerordentlich hilfreich. Sie spart jede
Menge Verkettungen und Aufreihungen von Parametern und macht Ihre Programme
lesbarer und einfacher.
Abbildung 2.3:
Ausgabe mit echo
Nun kann es manchmal vorkommen, dass dieses Verhalten nicht gewünscht ist.
Sie haben es sicher schon bemerkt: Zeichenfolgen werden in Anführungszeichen
gepackt. Statt der gezeigten doppelten sind in PHP auch einfache zulässig. Werden
diese verwendet, versucht PHP nicht mehr, Variablen zu erkennen und auszuwerten.
Das folgende Beispiel zeigt den Effekt:

Ausgaben erzeugen
Listing 2.9: EchoVariable3.php – So werden Variablen nicht ausgewertet
In der Bildschirmausgabe erscheint der Text unverändert:
Abbildung 2.4:
Variablen werden in einfachen
Anführungszeichen nicht erkannt
Ausgabe von großen Textmengen
Die Möglichkeit, PHP und HTML zu vermischen, ist ein schneller und einfacher
Weg dynamische Webseiten zu erstellen. Leider führt diese Vermischung zu sehr
schlecht lesbaren Programmen. Solange Sie mit Trivialskripten wie in diesem
Kapitel arbeiten, fällt das nicht auf. Später jedoch – wenn richtige Projekte an der
Tagesordnung sind – wird der Code schnell unleserlich. Damit schleichen sich
Fehler ein. Für andere Entwickler, die mit dem Code arbeiten sollen, wird es teilweise
unmöglich oder zumindest zeitraubend, sich einzuarbeiten.
Vor diesem Hintergrund entstand eine ansatzweise aus der Sprache Perl übernommene
Technik, längere Textblöcke auszugeben – »heredoc« genannt. Dabei werden
der Anfang und das Ende in einer speziellen Weise gekennzeichnet. PHP liest
einen solchen Block, der auch viele Zeilen umfassen kann, als eine geschlossene
Zeichenfolge. Die bereits gezeigte Erkennung von Variablen und die Kennzeichnung
derselben mit geschweiften Klammern steht auch hier zur Verfügung. Das
folgende Beispiel zeigt die Anwendung:
Listing 2.10: EchoHeredoc.php – Ausgabe von Textblöcken innerhalb von PHP-Code

58
Erste Schritte
echo "$text";
?>
Der Abschnitt, der ausgegeben werden soll, beginnt mit

Ausgaben erzeugen
aber im Gegensatz zu echo immer wie eine Funktion. Funktionen geben Daten
zurück, wenn sie in Ausdrücken verwendet werden. Auf diese Feinheiten wird in
den nächsten Tagen noch genau eingegangen. An dieser Stelle ist es nur wichtig
zu wissen, dass Sie mit print Daten ausgeben können. Der Aufruf gibt, wenn die
Ausgabe gelang, den Wahrheitswert TRUE (Wahr) zurück. Meist wird dies jedoch
nicht ausgewertet und deshalb erscheint print in einem sehr einfachen Kontext:
Listing 2.11: Print.php – Einfache Ausgabe von Daten mit print
Der Aufruf ist nur mit genau einem Argument erlaubt, eine Verkettung mit Kommata
wie bei echo funktioniert nicht. Der Einsatz von print ist dann vorzuziehen,
wenn der Kontext Rückgabewerte erwartet. An den entsprechenden Stellen im
Buch wird darauf hingewiesen, ansonsten wird durchgehend echo verwendet.
Formatierung von Ausgaben
PHP und HTML sind im Zusammenspiel sehr leistungsfähig. Ein typischer
Anwendungsfall besteht im dynamischen Erzeugen von HTML-Tags. Stellen Sie
sich vor, eine Navigation aufzubauen, bestehend aus mehreren Hyperlinks, die
etwa folgendermaßen aussehen:
Seite 1
Drei Elemente dieses Tags könnten variabel sein: Die Attribute href und target und
der Inhalt des Tags. Folgende Variante ist funktionsfähig, aber nicht gut lesbar:
Die Funktion printf ist hier ausgesprochen hilfreich, denn sie erlaubt die Erstellung
einer Formatieranweisung und die getrennte Übergabe von Parametern. Dies
59

60
Erste Schritte
erhält die Lesbarkeit des HTML-Tags (oder können Sie die erste echo-Anweisung
des Beispiels auf Anhieb lesen?)
Listing 2.12: Printf.php: So werden dynamische HTML-Konstrukte lesbar

Ausgaben erzeugen
F steht für ein Füllzeichen, entweder ein Leerzeichen oder eine »0« (Null).
Andere Zeichen müssen mit einem Apostroph eingeleitet werden. Es folgt – ebenfalls
optional – ein Minuszeichen, wenn die Füllzeichen linksbündig aufgefüllt
werden sollen. Ohne Angabe wird rechts aufgefüllt.
Werden Zahlen ausgegeben, kann mit der weiteren Angabe D noch bestimmt werden,
wie viele Dezimalstellen erzeugt werden. Nebenbei rundet printf im
Bedarfsfall mathematisch korrekt.
Formatcode Bedeutung und weitere Parameter
b Zahlen werden binär ausgegeben (als Folge von »0« und »1«) (b = binary)
c Eine Zahl als Parameter wird als Zeichencode interpretiert (c = character)
d Zahlen werden als Dezimalwert mit Vorzeichen ausgegeben (d = decimal)
u Zahlen werden als Dezimalwert ohne Vorzeichen ausgegeben (u = unsigned)
f Zahlen werden als Gleitkommawert ausgegeben (f = float)
o Zahlen werden als Oktalzahl (Basis 8) ausgegeben (o = octal)
s Zeichenfolgen (s = string)
x und X Zahlen werden hexadezimal ausgegeben, x erzeugt kleine Buchstaben, X
große (x = heXadecimal)
% Gibt das Prozentzeichen selbst aus
Tabelle 2.4: Formatierte Ausgabe
Mit diesen Angaben lassen sich schon recht ansprechende Ergebnisse erzeugen,
beispielsweise für die Generierung von HTML-konformen Farbangaben:
Listing 2.13: Printf2.php – Erzeugen HTML-konformer Farben aus Dezimalzahlen

62
Erste Schritte
$r, $g, $b);
?>
Da HTML die Angabe von RGB-Farbwerten mit Hexadezimalzahlen erwartet,
bietet sich die Option $X an, wie im letzten Beispiel gezeigt. Der erzeugte HTML-
Code sieht nun folgendermaßen aus:
Farbausgabe mit printf
CC, 66 und 99 sind die zu den Dezimalzahlen 204, 102 und 153 passenden Hex-
Werte.
2.4 Professionelles Programmieren
Nach den ersten Fertigkeiten, die das Skript überhaupt erstmal zur Ausgabe von
Daten bewegen, sollten Sie sich mit bestimmten Programmierstilen vertraut
machen. Diese Techniken und Methoden helfen, später den Überblick zu behalten
und besseren Code zu schreiben. Der Begriff »besser« bedeutet hier: schneller
lesbar, einfacher wartbar, zuverlässiger, stabiler, schneller.
Code auf möglichst kleinem Raum unterzubringen und der verbreitete
Stolz, ein Problem mit noch weniger Zeilen gelöst zu haben als irgendjemand
anderes, ist unprofessionell und dumm, die künstliche Verkomplizierung
von Code ist amateurhaftes Gehabe.
Nicht nur für die Nachwelt: Kommentare
Kommentare sind ebenso wichtig wie guter Code, oder andersherum, kein guter
Code ohne gute Kommentare. Dabei sollten Kommentare nie beschreiben, wie
der Code arbeitet, sondern was er tut. Denn gute Entwickler können sehr wohl
fremden Code lesen und nachvollziehen. Jeden Gedankengang des ursprünglichen
Programmierers nachzuvollziehen und den Zusammenhang zu anderen,
nicht offensichtlich erkennbaren Programmteilen herzustellen, ist ungleich aufwändiger.

Warum Sie Kommentare schreiben sollten
Professionelles Programmieren
Kommentare sollten Sie unbedingt auch dann schreiben, wenn Sie nur für sich
selbst entwickeln. Denn einige Wochen oder Monate später fällt es auch erfahrenen
Entwicklern schwer, sich noch an die eigenen Überlegungen zu erinnern.
Einfache Wartungsaufgaben, die Kunden verständlicherweise einfordern, geraten
so zu einer störenden Mammutaufgabe, die zudem unpassenderweise immer
parallel zu einem neuen, spannenden Projekt anfallen.
Nicht zuletzt sind Kommentare auch dann hilfreich, wenn man Code nur für den
Eigenbedarf entwickelt. Später, wenn Sie mehr Erfahrung haben, lesen Sie Ihren
Code anders und können ihn schneller und professioneller überarbeiten.
Mit Hilfe externer Werkzeuge können aus entsprechend aufgebauten Kommentaren
automatisch Quellcode-Dokumentationen erstellt werden. Dies ist hilfreich,
wenn Bibliotheken verkauft werden sollen oder andere Entwickler Teile des Projekts
übernehmen.
Kommentare in PHP5
PHP5 kennt alle Kommentarzeichen, die schon seit der ersten Version mit dabei
sind. Änderungen gab es hier nicht. Der Stil ist weitgehend aus der Programmiersprache
C übernommen worden. Man unterscheidet Kommentarzeichen, die nur
für eine Zeile gelten und wo die Kommentare am Zeilenende aufhören und solche
Kommentare, die mit einem speziellen Endzeichen beendet werden müssen.
Einfache Zeilenkommentare werden folgendermaßen geschrieben:
Die beiden Schrägstriche leiten den Kommentartext ein, alles weitere bis zum
nächsten Zeilenumbruch wird vom PHP-Parser ignoriert.
Alternativ ist auch ein Doppelkreuz als einleitendes Kommentarzeichen möglich,
die Anwendung ist jedoch bestenfalls die »zweite Wahl«:
63

64
Erste Schritte
Die Wirkung ist identisch mit der ersten Variante. Beide können auch mitten auf
der Zeile beginnen und gelten dann ab dort:
Der Parser führt den PHP-Code am Zeilenanfang aus und ignoriert den Rest der
Zeile. Die Schreibweise mit den Schrägstrichen entspricht der in C üblichen und
ist weiter verbreitet. Sie sollten aus stilistischen Gründen entweder generell nur
eine Version verwenden oder eine ganz klare Vereinbarung (mit sich selbst) treffen,
unter welchen Umständen welche Kommentarzeichen verwendet werden.
Neben den einzeiligen gibt es auch mehrzeilige Kommentare. Diese beginnen
immer mit den Zeichen /* und enden mit */. Sie werden oft eingesetzt, um an
den Anfang der Seite einen längeren Abschnitt mit Informationen über Programm
und Autor zu setzen. Ebenso dienen Sie häufig zum so genannten »Auskommentieren«.
Dabei werden zu Testzwecken ganze Programmteile als Kommentar markiert
und so versteckt. Indifferente Fehler lassen sich damit besser einkreisen. Aber
es gibt kleine Fallen beim Umgang mit Kommentaren. Betrachten Sie als (negatives)
Beispiel den folgenden Code:
Wenn Sie diesen Abschnitt komplett auskommentieren möchten, müssten Sie folgendes
schreiben:
Das funktioniert freilich nicht, weil der erste Kommentar am Ende der zweiten
Zeile aufhört und die zweite Zeile ($d usw.) ausgeführt wird. Deshalb sind zwei
verschiedene Kommentarzeichen sehr hilfreich, denn hätte man gleich den Zeilenkommentar
verwendet, hätten die Kommentarzeichen ihre Wirkung nicht verfehlt:

Benennungsregeln
Professionelles Programmieren
Neben den Kommentaren gibt es auch Regeln für die Benennung von Variablen,
Klassen, Methoden und Funktionen. Dies gilt nicht nur für die Schreibweise, sondern
auch die Art und Weise der Namensvergabe. Lesbare, sinnvolle und eindeutige
Namen sind nicht immer einfach zu finden, zeichnen jedoch guten und
professionellen Code aus.
Regeln aus der PEAR-Welt
Fest zu PHP gehört eine große Sammlung an Bibliotheken und Skripten, die immer
wiederkehrende Aufgaben erledigen: PEAR (PHP Extension and Application Repository).
Da PEAR-Code weitgehend in PHP geschrieben wird und viele Hundert
Entwickler dazu beisteuern, wurde dafür eine Vorgabe entworfen, welchen Stil der
Code haben muss, damit alle anderen damit problemlos arbeiten können. Diese
Vorgaben sind sehr sinnvoll und sollten – mangels anderer Richtlinien – für alle
mittleren und größeren PHP-Projekte gelten. Kleine Testskripte und andere »Einzeiler«
profitieren davon freilich nur bedingt, sodass man es hier etwas lockerer
sehen kann. In der PEAR-Welt heißen diese Vorgaben »Coding Standards«.
PHP Coding Standards
PHP ist eine so genannte Klammersprache, Blöcke zusammengehörigen Codes
werden dabei durch geschweifte Klammern markiert. Es liegt in der Natur der
Sache, dass diese Blöcke oft tief verschachtelt werden. Um zusammengehörende
Klammern halbwegs lesbar zu behalten, werden die innen liegenden Codes eingerückt.
Der Coding Standard schreibt eine Einrücktiefe von vier Zeichen und die
Verwendung von Leerzeichen vor. Editoren sollten so eingestellt werden, dass sie
bei Druck auf die (TAB)-Taste vier Leerzeichen erzeugen.
65

66
Erste Schritte
Auch die Zeilenlänge hat Einfluss auf die Lesbarkeit. Mehr als 85 Zeichen sind
schlecht darstellbar, wenn in modernen Entwicklungsumgebungen noch Werkzeugkästen
und Symbolleisten auf dem Bildschirm platziert werden müssen. PHP
ist sehr tolerant in Bezug auf Zeilenumbrüche, deshalb ist eine »Verteilung« von
Code auf mehrere Zeilen besser als endlose Codeschlangen.
Die Bedeutung der Blöcke mit geschweiften Klammern wurde bereits angesprochen.
Auch deren Schreibweise ist vorgegeben. Sie sollten überdies immer gesetzt
werden, auch wenn dies im konkreten Kontext nicht zwingend erforderlich ist. Ein
Beispiel zeigt dies:
Hier wird die Ausgabe von $a nur dann erfolgen, wenn die Bedingung erfüllt ist.
Möglicherweise wollen Sie zu Testzwecken auch die andere Variable $b ausgeben.
Im Eifer des Gefechts steht dann folgendes im Skript:
Das ist zwar nett eingerückt, nur interessiert das PHP kaum. Ohne Klammern
wirkt if nur auf eine einzige Anweisung. Deshalb würde der erste Versuch besser
folgendermaßen aussehen:
Die Klammern umschließen den Block eindeutig und eine Erweiterung ist unproblematisch.
Das Beispiel zeigt auch, dass die schließende Klammer eine Zeile für
sich allein einnimmt. Noch besser lesbar, aber weniger verbreitet, ist es, auch die
öffnende Klammer allein auf eine Zeile zu setzen. Dies betont die Verschachtelungsebene
noch intensiver:

Professionelles Programmieren
echo $a;
}
else
{
// Tu nichts!
}
?>
Falls ein Block endet und aus technischen Gründen keine Klammer möglich ist,
fügen Sie einfach eine Leerzeile hinzu. Dies ist beispielsweise beim switch-Befehl
möglich:
Jedes break wird hier von einer Leerzeile abgeschlossen.
Funktionsaufrufe – egal ob zu internen oder selbst definierten Funktionen – werden
immer folgendermaßen geschrieben:
$a = funktion($parameter, $parameter2);
Dabei gilt, dass vor und nach dem Gleichheitszeichen jeweils ein Leerzeichen
steht. Die runde Klammer nach dem Funktionsnamen folgt ohne Leerzeichen
und nach jedem Komma in der Parameterliste steht wiederum ein Leerzeichen.
Das schließende Semikolon folgt wieder ohne Pause.
Manchmal kommt es vor, dass sehr viele Zuweisungen dieser Art hintereinander
stehen. Dann kann man diese nach den Gleichheitszeichen ausrichten, um die
Lesbarkeit weiter zu verbessern:
67

68
Erste Schritte
$antonia_name = funktion($parameter, $parameter2);
$bert = funktion($parameter3);
Zu den Standards gehört übrigens auch, sich bei der Markierung von Code-Blöcken
auf zu beschränken und keine der anderen Varianten zu benutzen.
Zuletzt noch ein Tipp für den Kopf eines Skripts, der Informationen zum Programm,
Autor und der Lizenz enthalten sollte:
Die erste Zeile steuert die Anzeige im Unix-Editor VIM, was vermutlich nur eine
Minderheit wirklich tangiert.
Namenskonventionen
Ob Sie deutsch oder englisch schreiben, bleibt Ihnen überlassen. Hier sollte das
potenzielle Zielpublikum beachtet werden. Wer seine Skripte im Internet anbietet,
sollte keine deutschen Namen verwenden. Für den Eigenbedarf ist es völlig in
Ordnung und weit besser, als unpassende oder falsche englische Begriffe zu verwenden,
was eher peinlich ist.

Webserver und Browser
Variablen- und Funktionsnamen unterliegen keiner zufälligen Namensgebung.
Sie sollten bedenken, dass Variablen immer Werte enthalten, also Zustände darstellen.
Sie werden deshalb mit Nomen bezeichnet: $name, $laenge, $content usw.
Die Namenskonventionen sind strenger als die von PHP selbst geforderten
Eigenschaften der Namen, wie sie am nächsten Tag beschrieben
werden. Es sind also »freiwillige« Vereinbarungen, die helfen, für Menschen
lesbaren Code zu erzeugen.
Funktionen führen dagegen Code aus, sie »tun« also etwas. Folgerichtig nutzen
Sie Verben zur Benennung, gegebenenfalls um ein Objekt ergänzt: $save(),
$load() oder auch $ladeDaten(). Namensteile werden durch Großbuchstaben
getrennt, wobei der erste Buchstabe klein ist. Ist die Zuordnung zu einem Modul
(Package in der PEAR-Welt genannt) wichtig, wird der Modulname davor gestellt
und durch Unterstrich getrennt: HTML_getData().
Klassennamen beschreiben den Sinn der Klasse: Log, HTML_Error_Resolver. Sie
beginnen immer mit einem Großbuchstaben und trennen Wörter mit Unterstrichen.
In der Regel handelt es sich um Nomen bzw. um substantivierte Verben.
Klassenmitglieder unterscheiden sich nicht von den allgemeinen Regeln, Methoden
entsprechen Funktionen und Eigenschaften einfachen Variablen, da sie
innerhalb der Klasse dieselbe Aufgabe übernehmen. Es ist üblich, private Mitglieder
von Klassen mit einem führenden Unterstrich zu benennen: $_content. Die
Regel stammt aus den PHP 4-Zeiten und ist nicht zwingend bei PHP5, weil es
einen speziellen Modifizierer gibt: private. Wie Sie es verwenden, sollten Sie pro
Projekt selbst festlegen und diese Regel dann konsequent durchhalten.
Konstanten werden immer in Großbuchstaben geschrieben. Auch hier gilt: Sind
sie Teil eines Moduls, wird der Modulname davor gesetzt und durch Unterstrich
getrennt: DB_INFO, XML_ERROR, WIDTH, HEIGHT.
2.5 Webserver und Browser
Webserver und Browser sind die beiden Programme, die bei der Bereitstellung
und Nutzung von Webseiten eine herausragende Rolle einnehmen. Sie verständigen
sich mit Hilfe des Protokolls HTTP miteinander. Dieser Abschnitt führt kurz
in Grundlagen und Prinzipien ein – Handwerkszeug für künftige PHP-Entwickler.
69

70
Erste Schritte
Prinzip des Seitenabrufs
Zwischen Browser und Webserver läuft ein streng reglementiertes Protokoll:
HTTP. Die Abkürzung steht für Hypertext Transfer Protocol und sagt bereits, wozu
es dient: dem Übertragen von durch Hyperlinks verknüpften Seiten. Bevor jedoch
die erste Seite im Browser erscheint, passiert einiges auf dem Weg zum und natürlich
im Server.
Der ganze Ablauf startet mit der Eingabe der Adresse der Seite im Browser. Der
Browser nutzt nun Betriebssystemfunktionen, um eine Verbindung mit dem
Server herzustellen. Der erste Schritt besteht in der Auflösung der Adresse. Intern
wird auf Datenebene die Protokollkombination TCP/IP benutzt. Sender und
Empfänger einer Botschaft benötigen hier eine eindeutige IP-Adresse der Art
134.15.211.65. Weil sich derartige Adressen schlecht merken (und vermarkten) lassen,
wurde das Domain Name System (DNS) entwickelt. Es basiert auf dem
gleichnamigen DNS-Protokoll und verwendet DNS-Server, die Zuordnungen zwischen
Adressen und Domain-Namen speichern. Diese Server bilden im Internet
eine Hierarchie, wobei der Ausgangspunkt von etwas mehr als einem Dutzend
Root-Server gebildet wird. Diese Server lösen die Toplevel-Namen, wie »com«
oder »de« auf. Erhält der Browser also eine ihm unbekannte Domain, fragt er den
nächsten erreichbaren Name-Server nach der Adresse. Dies ist der Server, den der
Provider beim Aufbau der Verbindung ins Internet zugewiesen hat. Große Firmen
betreiben manchmal auch eigene Name-Server. Der Name-Server wird freilich
nicht alle Millionen Adressen und deren IP-Nummern kennen. Also fragt er einen
der Root-Server an, ob diesem eine verwaltende Instanz für das benötigte Toplevel
bekannt ist. Der Root-Server verweist auf einen der Landes-Server oder den Verwalter
der generischen Level. Endet die Adresse auf »de« ist nic.de zuständig,
betrieben durch das DENIC in Karlsruhe.
War die vollständige Adresse www.comzept.de, wird nun beim DENIC nach dem
Betreiber der Domain »comzept.de« gefragt. Diese Anfrage verweist auf einen weiteren
Name-Server, nämlich dem für comzept.de zuständigen. Dies ist entweder
ein Server in der betreffenden Firma oder bei deren Provider. Dieser Name-Server
(der vierte in der Kette), hat nun seinerseits nur eine kleine Liste der Server-Adressen
und deren Namen zu verwalten, im Beispiel also www und dazu die passenden
IP-Adresse. Diese Information wird über das DNS-Protokoll dem zuerst anfragenden
Name-Server übermittel und gelangt von dort zum Browser. Der Browser
besitzt seinerseits eine eindeutige Adresse, die vom Provider beim Verbindungsaufbau
vergeben wurde. In Netzen mit festen IP-Adressen läuft meist ein Dienst, der

Webserver und Browser
die Adressevergabe steuert oder die Angaben sind auf der Netzwerkkarte des Computers
fest hinterlegt.
Das allein reicht jedoch noch nicht, um Daten zu übertragen. Denn auf dem Server
und meist auch auf dem Client laufen unzählige Dienste, die mit der aktuellen
Anforderung nichts zu tun haben. Um bestimmte Dienste gezielt erreichen zu
können, werden so genannte Ports verwendet. Webserver haben im Allgemeinen
(Standard) den Port 80. Mail-Server (SMTP) haben den Port 25 und POP3-Server
erreicht man über Port 110. Der Browser hat auch einen Port, der jedoch nicht fest
zugeordnet ist sondern dynamisch aus dem Adresspool oberhalb 1.024 vergeben
wird, beispielsweise 4.768. IP-Adresse und Port bilden zusammen einen so genannten
Socket. Zwischen zwei solchen Sockets spielt sich dann die Kommunikation
ab. Während IP für die Adresszuordnung sorgt, wird der Datenstrom per TCP
gesteuert. Hier findet die Verpackung der Daten in Pakete und die Fehlerprüfung
statt.
Die Daten, die der Browser nun sendet, werden ihrerseits wieder in ein höheres
Protokoll verpackt: HTTP. Dies sind lesbare Codes, die bestimmte Aktionen am
Server steuern oder im Browser zur Darstellung der Seiten führen.
HTTP auf einen Blick
Was der Browser sendet, sieht bei der ersten Anforderung in etwa folgendermaßen
aus:
GET info.php
GET ist das Kommando, danach folgt die Ressource, die mit GET angefordert
werden soll. Der Webserver erkennt das Kommando und weiß nun, dass er die
Datei laden und ausgeben soll. Wurde die Dateierweiterung verknüpft, kann sich
noch ein Programm dazwischen schieben und die Datei verarbeiten, bevor sie
gesendet wird. Die Erweiterung .php übergibt die Daten an PHP und dort wird die
Datei geladen, nach den Skript-Tags durchsucht, der Code untersucht und ausgeführt
und eine fertige HTML-Seite erstellt. Diese wird wieder an den Webserver
zurückgegeben und der sendet sie dann in Beantwortung der Anforderung aus:
HTTP/1.1 200 OK
Content-Length: 46783
71

72
Erste Schritte
Die Antwort besteht aus einem Hinweis auf das Protokoll (1.0 oder 1.1), einem Statuscode
(200 steht für OK, 404 für nicht gefunden) und verschiedenen Kopfzeilen,
die Zusatzinformationen liefern. Diese Kopfzeilen umfassen mehr als im Beispiel
gezeigt, beispielsweise auch Angaben über den Server, Cookies usw. Im Beispiel
wurde lediglich die Länge der Seite übertragen. Nach einer Leerzeile beginnt
dann der Inhalt der Datei.
Wenn eine HTML-Seite nun drei Bilder enthält, dann wird für jedes Bild eine
eigene GET-Anforderung erstellt und gesendet. Der Webserver wird meist keine
Verknüpfung für Bilder haben und diese als Ressource direkt von der Festplatte
laden und senden. Binärdaten werden ebenso angehängt wie alle anderen
Informationen – freilich so codiert, dass nichts verloren geht. Damit nicht jedes
Mal wieder die gesamte Kette von Name-Servern abgefragt wird, speichern diese
das letzte Ergebnis einige Zeit, sodass der gesamte Ablauf stark beschleunig wird.
Neben GET kann der Browser auch POST verwenden und seinerseits Daten an
die Anforderung anhängen. Dies wird genutzt, um Daten aus Formularen zu übertragen.
Diese Informationen werden PHP ebenfalls bereitgestellt, sodass sie in
Skripten ausgewertet werden können.
2.6 Kontrollfragen
1. Wie geben Sie mehrzeilige Texte aus PHP-Code heraus am besten aus?
2. Welche Funktion eignet sich zur Ausgabe hexadezimaler Farbangaben?
3. Welche Kommentarform wird am besten verwendet, wenn hinter einer Codezeile
ein kurzer, auf die Zeile bezogener Kommentar stehen soll? Mögliche Varianten
sind: /* */, // oder #.

Daten verarbeiten
3

74
Daten verarbeiten
Elementarer Bestandteil eines jeden Programms ist die Möglichkeit, Daten zu
erfassen, zu speichern und damit vielfältige Operationen anzustellen. PHP bietet
dafür alle auch aus anderen Sprachen bekannten Syntaxformen und -varianten.
3.1 Variablen und Literale
Variablen nehmen unter einem weitgehend freiwählbaren Namen Daten auf. Sie
lassen sich jederzeit verändern und können in Ausdrücken als Ersatz für literale
Konstrukte eingesetzt werden. PHP erkennt Variablen an einem vorangestellten
$-Zeichen. Der Name muss bestimmten Regeln gehorchen, damit er gültig ist:
Namen dürfen nur Buchstaben, Zahlen und den Unterstrich enthalten.
Das erste Zeichen des Namens muss ein Buchstabe oder der Unterstrich sein.
Groß- und Kleinschreibung wird unterschieden.
Das impliziert, dass Leerzeichen nicht erlaubt und Umlaute tabu sind.
PHP und Datentypen
PHP und Datentypen sind ein besonderes Kapitel, leider kein besonders erfreuliches.
Es ist typisches Merkmal von einfachen Skriptsprachen, mit den Datentypen
sehr locker umzugehen. Das heißt, es wird dem Benutzer wenig Gelegenheit gegeben,
selbst festzulegen, ob der Inhalt einer Variable eine Zahl oder eine Zeichenfolge
oder etwas anderes ist. PHP stellt dies anhand bestimmter Kriterien selbst fest
und wechselt den Typ auch mal auf halber Strecke.
Das ist nicht immer von Vorteil, auch wenn Sie am Anfang weniger einrichten
und festlegen müssen als bei anderen Sprachen. Es führt jedoch zu Problemen,
wenn Ihre Anwendung so programmiert ist, dass ein bestimmter Typ erforderlich
ist und dies gleichzeitig nicht ständig absichert. Es kommt dann zu so genannten
Seiteneffekten, die schwer nachvollziehbare Fehlerquellen sind.
Nichtsdestotrotz kennt PHP natürlich den intern und automatisch festgelegten
Typ, den eine Variable haben kann. Neben Variablen ist auch die Art des Rückgabewerts
einer Funktion in dieser Weise festgelegt (auch diesen können Sie nicht
explizit erzwingen). Die automatische Ermittlung erfolgt im Rahmen des Zuweisungsprozesses:

$zahl = 23;
Variablen und Literale
Hier wird der Variablen $zahl der Wert 23 zugewiesen. PHP erkennt keine Anführungszeichen,
wie sie für Zeichenfolgen typisch sind und auch keinen Dezimalpunkt,
wie er bei Gleitkommazahlen auftritt. Also handelt es sich um eine Ganzzahl,
als Integer bezeichnet.
Ganzzahlen lassen sich auch oktal und hexadezimal darstellen. Oktale Zahlen
haben die Zahlenbasis 8 und die Ziffern 0 bis 7. Sie werden erkannt, wenn eine
führende Null davor geschrieben wird:
$zahl = 040;
Hexadezimalzahlen haben die Zahlenbasis 16 und verwenden als Ziffernzeichen
für die Zeichen 0 bis 9 und A bis F. Die Kennzeichnung erfolgt durch das Präfix
»0x«:
$zahl = 0xFF;
Zeichenkettenliterale werden folgendermaßen geschrieben:
$zeichen = "Zahl 23";
Diese Anweisung legt die Zeichenfolge »Zahl 23« in die Variable $zeichen. Hier
erkennt PHP den Datentyp an den Anführungszeichen. Ob Sie einfache oder doppelte
verwenden, ist für den Typ ohne Bedeutung. Folgendes können Sie deshalb
auch schreiben:
$zeichen = 'Zahl 23';
Gleitkommazahlen (Teil des Zahlenraums der reellen Zahlen) haben Kommastellen,
ein Merkmal ist also der Dezimalpunkt. Denken Sie daran, dass in Programmiersprachen
immer die englische Schreibweise verwendet wird:
$wert = 13.04;
Große Zahlen können durch eine Exponentialdarstellung abgebildet werden.
Dabei wird der Wert als Konstruktion der Art 3·104 dargestellt. In PHP wird diese
Form folgendermaßen geschrieben:
$wert = 3E4;
Das »E« entspricht also »zehn hoch«. An dieser Stelle sei auch erwähnt, dass die
Genauigkeit durch die Rechenbreite des Computers bedingt nicht unendlich ist
und auch nicht genau dem reellen Zahlenraum entspricht. Scheinbar verrechnet
sich PHP bei sehr vielen Stellen deshalb manchmal geringfügig.
75

Literale
76
Daten verarbeiten
Die rechte Seite der Zuweisungen, wie ?23?, 13.04 oder 3E4 werden als Literale
bezeichnet – es sind konstante Werte mit einem definierten Aufbau. PHP erkennt
bestimmte Literale und erzeugt daraus entsprechende Werte.
Hinweise zur Definition
In der Standardeinstellung von PHP5 wird erwartet, dass Variablen vor der ersten
Verwendung deklariert werden. Damit ist gemeint, dass mindestens einmal ein
Wert zugewiesen wurde und PHP damit den Datentyp feststellen konnte. Auch
wenn dies trivial klingt: Man kann PHP so einstellen, dass dieser Zwang zur Deklaration
nicht erforderlich ist und sich damit eine Fehlerquelle einfangen. Sie sollten
es deshalb immer bei der Regel belassen, jede Variable zu deklarieren. Haben
Sie nämlich versehentlich einen Tippfehler gemacht oder Groß- und Kleinschreibung
verwechselt, weist eine Fehlermeldung auf diesen Umstand hin. Ohne diese
würde Ihr Programm wegen der automatischen Typerkennung und -umwandlung
möglicherweise dennoch funktionieren – bis bestimmte Daten auftreten, bei
denen es aus dem Tritt kommt. Solche sporadisch auftretenden Fehler sind nur
sehr schwer zu finden.
3.2 Konstanten
Oft werden Variablen eingesetzt, um einen Wert zur Konfiguration einer Anwendung
zu bestimmen. Diese Werte ändern sich während der Abarbeitung des Programms
nicht. PHP bietet mit Konstanten eine bessere Form. Konstanten können,
nachdem sie einmal einen Wert erhalten haben, nicht mehr verändert werden.
Konstanten definieren und nutzen
Zuständig für die Erzeugung einer Konstanten ist die Funktion define. Benötigt
wird der Name der Konstanten als Zeichenfolge und der zuzuweisende Wert.
define('BREITE', 640);

Konstanten
In Ausdrücken werden Konstanten ebenso wie Variablen verwendet. Sie werden
jedoch ohne führendes $-Zeichen geschrieben und können deshalb nicht in Zeichenfolgen
mit doppelten Anführungszeichen erkannt werden.
Listing 3.1: define.php – Definition und Ausgabe einer Konstanten
Umgang mit Konstanten
Abbildung 3.1:
Ausgabe einer Konstanten
Da Konstanten nur einmalig definiert werden können, kann es zu Problemen
kommen, wenn Konfigurationen von Programmteilen mehrfach erfolgen. Das
kann notwendig sein, um Module unabhängig voneinander anzuwenden. Jedes
Modul soll beispielsweise in der Lage sein, sich seine benötigten Konstanten selbst
zu definieren, wenn keine übergeordnete Instanz dies bereits getan hat. Diese Art
zu programmieren ergibt größtmögliche Sicherheit – das Modul bleibt in jedem
Kontext stabil.
Zur Abfrage einer bereits erfolgten Definition stellt PHP eine weitere Funktion zur
Verfügung: defined. Der Rückgabewert kann Wahr (TRUE) oder Falsch (FALSE)
sein, je nachdem, ob die als Parameter angegebene Konstante bereits existierte.
Die Anwendung ist nur mit einer if-Anweisung sinnvoll, wie folgendes Beispiel
zeigt:
Wie schon bei der Definition der Konstanten wird auch hier der Name, nicht
jedoch die Konstante selbst angegeben. Das ist logisch, weil diese ja möglicherweise
noch gar nicht existiert.
77

78
Daten verarbeiten
3.3 Rechnen und Vergleichen mit Ausdrücken
Ganz nebenbei wurde der Begriff »Ausdruck« bereits erwähnt. Es handelt sich
dabei immer um ein Konstrukt, das genau einen definierten Wert zurückgibt. Folgende
Beispiele stellen gültige Ausdrücke in PHP dar:
17 + 4
"Heute ist " . "Mittwoch"
3E4 == 30000
Der erste Ausdruck gibt 21 zurück; PHP erkennt zwei Integer-Werte und führt eine
Addition aus. Der zweite ergibt die Zeichenfolge »Heute ist Mittwoch«. Der Punkt
ist ein Operator zur Verbindung von Zeichen. Der dritte Ausdruck vergleicht zwei
Zahlen, die beiden Gleichheitszeichen sind ein so genannter Boolescher Operator.
In diesem Fall sind die beiden Zahlen gleich und der Ausdruck gibt »Wahr«
(TRUE) zurück.
Ausdrücke und Operatoren
Ausdrücke entstehen durch die Verbindung von Variablen, Konstanten, Literalen
und Operatoren. Den Operatoren kommt also eine sehr große Bedeutung zu. Es
gibt sehr viele davon, die für die unterschiedlichsten Zwecke eingesetzt werden
können.
Ausdrücke
Als Ausdruck werden alle Kombinationen aus Literalen, Variablen, Konstanten
oder Funktionsaufrufen und Operatoren bezeichnet, die einen konkreten skalaren
Wert zurückgeben. Dabei ist es erst einmal nicht relevant, welchen Datentyp dieser
Wert hat. Typische Ausdrücke sind:
$a + 4
45 – 56 * 99
$zahl1--
$string = $buchstabe . " " . $ende
Die Benutzung erfolgt entweder beim Funktionsaufruf, als Zuweisung (Ziel ist
eine Variable) oder im Kontext anderer Ausdrücke.

Rechnen mit Operatoren
Zum Rechnen werden folgende Operatoren verwendet:
Zeichen Operandenzahl Anwendung Bedeutung
+ 2 23 + $zahl Addition
- 2 $wert – 17 Subtraktion
Rechnen und Vergleichen mit Ausdrücken
- 1 -345 Negatives Vorzeichen
* 2 12 * 11 Multiplikation
/ 2 100 / 10 Division
% 2 6 % 3 Rest einer Ganzzahl-Division (Modulus
genannt)
() 1 (Ausdruck) 13 * (4 + 7) Klammern zur Bildung von Teilausdrücken
++ 1 $ziffer++ Erhöhung um 1, Inkrement
-- 1 --$zahl Verringerung um 1, Dekrement
Tabelle 3.1: Arithmetische Operatoren
Der Modulus-Operator kommt sehr häufig zum Einsatz, auch wenn der Rest einer
Division im Alltagsleben kaum eine Rolle spielt. Viele Divisionen ergeben jedoch
gebrochene Zahlen und dies ist bei der Ausgabe nicht immer praktisch. So müssen
Sie vielleicht in einer Tabelle jede dritte Zeile einfärben. Aber wie erkennt man
jede dritte Zeile? Haben Sie einen Wert, der die Zeilen zählt, teilen Sie diesen einfach
durch Drei. Immer wenn der Rest der Ganzzahl-Division gleich 0 ist, wurde
eine dritte Zeile erreicht.
Interessant sind auch die Inkrement- und Dekrementoperatoren. Mit diesen wird
der Wert in einer Variablen um eins erhöht bzw. verringert. Innerhalb von Ausdrücken
angewendet stellt sich die Frage, ob die Veränderung vor oder nach der Entnahme
des Wertes erfolgen soll. Gesteuert wird das durch die Platzierung des
Operators. Das folgende Beispiel zeigt dies:
79

80
Daten verarbeiten
Listing 3.2: OperatorIncdec.php – Werte um eins erhöhen oder verringern
Die Ausgabe zeigt die Wirkung:
Abbildung 3.2:
Ausgabe von Listing 3.2
Bei der Berechnung der Summe wird 20 ausgegeben, weil die Erhöhung der Variable
$digit erst nach der Auswertung des Ausdrucks erfolgt. Bei der Ausgabe der
Variablen $number erfolgt die Veränderung dagegen vorher, deshalb erscheint 11
(statt 12).
Zeichenfolgen verketten
Es wurde bereits angedeutet, dass Zeichenfolgen mit einem eigenen Operator verkettet
werden, dem Punkt ».«. Hier gibt es keine weiteren Besonderheiten. Bei der
Anwendung ist jedoch zu beachten, dass PHP erforderlichenfalls eine Typumwandlung
vornimmt, wie das folgende Beispiel zeigt:
Listing 3.3: TypeStringpoint.php – PHP erkennt hier alle Variablen als Zeichenfolgen
Dieses Skript gibt nicht 20 aus, sondern »137«. Das liegt daran, dass der Punkt nur
Zeichenfolgen verbinden kann. Damit das funktioniert, wandelt PHP die beiden
Variablen entsprechend um; aus der Zahl 13 wird die Zeichenfolge »13« usw. Dies

Rechnen und Vergleichen mit Ausdrücken
geschieht hier übrigens nur für diesen Ausdruck, danach stehen die Variablen
unverändert als Zahlen zur Verfügung. Im Hinblick auf die Programmsicherheit
und Stabilität ist dieses Verhalten kritisch. Sie sollten hier besondere Sorgfalt walten
lassen.
Kombinationsoperatoren
Sie kennen bereits die Zuweisung mit dem Gleichheitszeichen. Alle dualen Operatoren,
also solche mit zwei Operanden (+, –, *, /, %), können mit der Zuweisung
kombiniert werden. Das spart lediglich Tipparbeit und hat keinen Effekt auf den
Programmfluss. Die folgende klassische Operation kann verkürzt werden:
$a = $a + 5;
Hiermit wird der Inhalt von $a um fünf erhöht. Kürzer geht es mit einem Kombinationsoperator:
$a += 5;
Freilich geht das nicht immer. Folgende Operation ist nicht direkt verkürzbar:
$a = 17 - $a;
Vergleiche und Boolesches
Zu den typischen Operationen gehören auch Vergleiche (größer, kleiner, gleich)
und Boolesche Operationen (logische Ausdrücke). Der Name Boolesch stammt
von George Boole, der die Grundlagen der logischen Algebra entwickelte, und
wird deshalb immer groß geschrieben. Ausdrücke, die sich logisch auswerten lassen,
geben immer einen Wahrheitswert zurück, also entweder »Wahr«, in PHP als
TRUE ausgedrückt oder »Falsch«, wofür in PHP die Konstante FALSE steht.
PHP erkennt zwar logische Ausdrücke und kann bei Vergleichen entsprechend
damit umgehen, nutzt aber intern Zahlen zur Darstellung. Das führt dazu, dass
andere Ausdrucksarten fast immer auch in einen Wahrheitswert gewandelt werden,
wenn dies vom Kontext her erforderlich ist. Das führt manchmal zu schweren
Programmfehlern. Achten Sie deshalb unbedingt auf eine saubere Konstruktion
der Ausdrücke.
81

82
Daten verarbeiten
Die Vergleichsoperatoren finden Sie in der folgenden Tabelle:
Operator Bedeutung
< Kleiner als
> Größer als
= Größer als oder Gleich
== Gleich, wobei der Datentyp beider Operanden vor dem Vergleich so
umgewandelt wird, dass er gleich ist.
=== Gleich, wobei der Datentyp nicht verändert wird und identisch sein muss,
damit der Ausdruck Wahr wird
!= Ungleich als Umkehroperation zu ==
!== Ungleich als Umkehroperation zu ===
(a1)?(a2):(a3) Trinärer Operator, der den Ausdruck a1 auswertet und, wenn dieser Wahr
zurückgibt, a2 ausführt, ansonsten a3. Alle drei Bestandteile sind erforderlich,
die Klammern sind optional.
Tabelle 3.2: Vergleichsoperatoren
Wenn man nun dergestalt Ausdrücke entwickelt, ist auch eine Kombination von
Teilausdrücken erforderlich, um komplexere Strukturen abzubilden. Dazu werden
die logischen Operatoren eingesetzt, meist in Verbindung mit Klammern, um
die Rangfolge zu bestimmen.
Operator Bedeutung
|| Oder. Wahr, wenn einer der beiden Operanden Wahr ist.
&& Und. Wahr, wenn beide Operanden Wahr sind.
! Nicht, nur ein Operand möglich. Wahr, wenn der Operand Falsch ist.
or Oder. Wahr, wenn einer der beiden Operanden Wahr ist.
Tabelle 3.3: Logische (Boolesche) Operatoren

Operator Bedeutung
and Und. Wahr, wenn beide Operanden Wahr sind.
Allgemeine Aussagen zu Zeichenketten
xor Exklusives Oder. Wahr, wenn einer der Operanden Wahr ist, jedoch
nicht beide (ausschließendes Oder).
Tabelle 3.3: Logische (Boolesche) Operatoren (Forts.)
Scheinbar sind die Operatoren || und or bzw. && und and identisch. Dem ist
jedoch nicht so, denn jeder Operator hat eine definierte Rangfolge. Das heißt,
wenn Sie Ihre Ausdrücke ohne Klammern bauen, muss der Interpreter beim Auflösen
eine bestimmte Reihenfolge einhalten. Diese ist nicht einfach von links nach
rechts, sondern berücksichtigt bestimmte typische Gegebenheiten.
Betrachten Sie den folgenden Ausdruck:
echo 4 + 5 * 6;
PHP berechnet hier – mathematisch korrekt – das Ergebnis 34. Denn wegen der
Regel »Punkt- vor Strichrechnung« wird zuerst der rechte Teilausdruck ausgewertet.
Soll dies umgangen werden, sind Klammern erforderlich. Nun ist eine so allgemeine
Rechenregel jedem geläufig. Bei anderen Operatoren muss der Designer
der Sprache eine Reihenfolge festlegen. Mehr Informationen zur Rangfolge (Assoziativität)
der Operatoren werden im Zusammenhang mit dem if-Befehl (Siehe
Abschnitt »Einfache Verzweigungen mit if«).
3.4 Allgemeine Aussagen zu Zeichenketten
Zeichenketten oder Zeichenfolgen sind ein elementarer Datentyp in PHP. Die
Ausgabe von Text nach HTML erfolgt immer als Zeichenkette. Aus diesem Grund
sind Operationen mit Zeichenketten elementar und Sie sollten sich mit den
Möglichkeiten von PHP ebenso auseinandersetzen wie mit den vielfältigen Einsatzfällen.
Datentyp und Größe
Als Datentyp unterscheidet PHP nicht zwischen Zeichenketten und einzelnen
Zeichen. Es gilt deshalb generell, dass ein einzelnes Zeichen wie eine Zeichen-
83

84
Daten verarbeiten
kette mit der Länge 1 behandelt werden kann. Der Datentyp selbst wird als
»string« bezeichnet. Zur Umwandlung aus anderen Typen wird entsprechend der
Operator (string) verwendet:
$string = (string) 11;
Zeichenketten können bis zu 2 Milliarden Zeichen enthalten (2 GByte), dies ist
jedoch ein eher theoretischer Wert, da das Laufzeitverhalten unter sehr großen
Datenmengen massiv leidet. Der Umfang typischer HTML-Seiten von einigen
Dutzend KByte kann jedoch problemlos verarbeitet werden.
Zeichenketten haben keine definierte (vorgegebene) Länge oder ein spezielles
Endzeichen, wie dies bei C der Fall ist. Für die Abfrage der aktuellen Länge gibt es
eine passende Funktion.
Umgang mit Sonderzeichen
Zeichenketten selbst stehen in ihrer literalen Form in Anführungszeichen. Wenn
Sie nun ein solches Zeichen selbst ausgeben möchten, muss es maskiert werden.
Die Maskierung erfolgt durch ein spezielles Maskierungszeichen, das in PHP wie
in fast allen anderen Sprachen der Backslash »\« ist. Dem Backslash kommt deshalb
eine besondere Bedeutung zu. Das folgende Beispiel zeigt, wie Anführungszeichen
für ein HTML-Tag erzeugt werden:
""
Das kann vermieden werden (weil es schlecht lesbar ist), indem das jeweils korrespondierende
Anführungszeichen genutzt wird:
''
Damit verliert man aber unter Umständen die Fähigkeit zur Variablenerkennung.
Eine andere Aufgabe des Backslash besteht darin, Sonderzeichen zu erzeugen, die
sich über die Tastatur nicht eingeben lassen, weil sie im Editor eine besondere
Aufgabe haben. Das betrifft vor allem Zeilenumbrüche und Tabulatoren. Weitere
Sonderzeichen, die PHP erkennt und nutzt, zeigt die folgende Tabelle:

Zeichen Bedeutung
Allgemeine Aussagen zu Zeichenketten
\n Zeilenvorschub, entspricht dem Code 0A (hexadezimal, in PHP 0x0A
geschrieben)
\r Wagenrücklauf, entspricht dem Code 0D (hexadezimal, in PHP 0x0D
geschrieben)
\t Tabulator, Code 9
\\ Der Backslash selbst
\$ Das $-Zeichen, wenn $ in dem gegebenen Zusammenhang eine besondere
Bedeutung hat
\« Das doppelte Anführungszeichen, wenn es in einem Literal aus doppelten
Anführungszeichen steht
\' Das einfache Anführungszeichen, wenn es in einem Literal aus einfachen
Anführungszeichen steht
\40 Ein Zeichen mit dem Code 040 im oktalen Zahlensystem (Basis 8, 040 = Leerzeichen)
\x20 Ein Zeichen mit dem Code 0x20 im hexadezimalen Zahlensystem (auch das
Leerzeichen)
Tabelle 3.4: Sonderzeichen in Zeichenketten
Beachten Sie, dass die Zeilenumbrüche unter Windows und Unix unterschiedlich
sind. Während Unix nur \n einsetzt, wird unter Windows
\n\r geschrieben. Dies ist zu beachten, wenn Datenausgaben betriebssystemunabhängig
erfolgen sollen.
Zeichenketten erkennen und bestimmen
Wenn Sie feststellen möchten, ob eine Variable tatsächlich eine Zeichenkette enthält,
nutzen Sie die Funktion is_string:
is_string($var);
Der Rückgabewert ist Wahr (TRUE) oder Falsch (FALSE). Alternativ kann auch gettype
benutzt werden, hier wird bei einer Zeichenkette »string« zurückgegeben.
85

86
Daten verarbeiten
Um die Typumwandlung festzulegen, wird entweder der Umwandlungsoperator
(string) oder die Funktion settype benutzt:
$string = settype($var, "string");
Zeichenkettenoperationen
Mit Zeichenketten kann man allerlei anstellen. Typische Operationen sind:
Vergleichen, Suchen und Ersetzen
Ermitteln der Zeichenzahl und anderer Eigenschaften
Auswahl einer Teilzeichenkette und ähnliche Operationen
Behandlung einzelner Zeichen
Ermitteln von bestimmten Zeichen mit besonderer Bedeutung
Umwandeln in einen anderen Datentyp und HTML-abhängige Funktionen
Sprach- oder landesabhängiges Formatieren für die Ausgabe
Zum Suchen und Ersetzen gibt es gleich zwei Möglichkeiten. Einmal kann mit
Hilfe eines einfachen Vergleichsmusters gearbeitet werden, das eine exakte Übereinstimmung
bedingt. Zum anderen gibt es universelle Suchmuster, so genannte
reguläre Ausdrücke. Letztere werden in Abschnitt 3.6 »Reguläre Ausdrücke« ab
Seite 95 behandelt.
3.5 Die Zeichenkettenfunktionen
Die praktische Anwendung der Zeichenkettenfunktionen in diesem Abschnitt
zeigt die Einsatzbandbreite. Es geht in PHP – dies werden Sie später noch deutlicher
sehen – mehr um das Auffinden der passenden Funktionen als um Probleme
bei der Anwendung. Leider sind die Benennungsregeln bestenfalls als konfus zu
bezeichnen. Sie zeigen eine der Mankos freier Software: Viele unkoordinierte Entwicklungsschritte
und mangelnde Dominanz einer Ordnungsinstanz führen zu
Chaos. So wird bei Zeichenketten oft zwischen Groß- und Kleinschreibung unterschieden.
Ältere PHP-Funktionen verwenden zur Kennzeichnung der Verhaltensweise
die Zeichen »case« (von »case insensitive«), neuere dagegen nur »i« (von
»insensitive«). Einige Funktionen haben den Präfix »str_«, andere nur »str«, bei

Die Zeichenkettenfunktionen
anderen gibt es gar keinen Hinweis im Namen darauf, dass sie zur Gruppe der Zeichenkettenfunktionen
gehören.
Suchen und Ersetzen
Beim Suchen und Ersetzen geht es darum, Daten, die beispielsweise aus einer
Datenbank oder einem Formular empfangen wurden, auf bestimmte Merkmale
hin zu untersuchen. PHP bietet hier gleich mehrere Funktionen an.
Suchen einer Zeichenfolge in einer anderen
Angenommen, Sie haben eine Folge von Zeichen, beispielsweise einen Text aus
einem Formular, und möchten ermitteln, ob sich darin ein bestimmtes Wort
befindet. Dann wird die Funktion strpos eingesetzt. Sie liefert die Position der
Fundstelle:
Listing 3.4: strpos.php – Ermitteln einer Zeichenfolge in einer anderen
Die Ausgabe zeigt, dass der Text »langer« an 13. Stelle gefunden wurde:
Abbildung 3.3:
13 bedeutet das 14. Zeichen, weil die Zählung mit 0 beginnt
Man nennt eine solche Zählweise »nullbasiert«, das heißt, das erste Zeichen hat
den Index 0. Ist der Text nicht enthalten, wird FALSE zurückgegeben. Das ist zwar
für PHP typisch aber dennoch gewöhnungsbedürftig: Viele eingebaute Funktionen
können den Datentyp bei der Rückgabe wechseln. Da generell keine Möglichkeit
besteht, Datentypen zu erzwingen, erscheint dies konsequent. Es
erleichtert nur nicht unbedingt die Programmierung. Denn Sie müssen in Ihrem
Programm vor der weiteren Verarbeitung des Ergebnisses an die Reaktionen auf
verschiedene Datentypen denken. strpos beispielsweise gibt eine ganze Zahl
zurück (integer), wenn die Zeichenfolge gefunden wurde, oder einen Booleschen
Wert (boolean), wenn die Suche erfolglos war. Durch die bereits beschriebene
87

88
Daten verarbeiten
automatische Typumwandlung fällt dies nicht weiter auf, dennoch ist das Verhalten
ein Quell sporadisch auftretender Programmfehler.
Tabelle 3.8 können Sie entnehmen, dass es noch zwei andere Varianten von
strpos gibt. strrpos sucht die Fundstelle vom Ende her (was gleichbedeutend mit
der letzten Fundstelle ist, wenn man von vorn sucht) während stripos bei der
Suche nicht auf Groß- und Kleinschreibung achtet. Probieren Sie diese selbst aus,
indem Sie die Funktion und die Testdaten in Listing 3.4 austauschen.
Ähnlichkeiten zwischen Zeichenfolgen feststellen
Gibt ein Benutzer Daten ein, ist ein exakter Vergleich nicht immer angebracht.
Auch ähnliche Angaben können brauchbar sein. PHP bietet auch hier einige
Funktionen, die einen Vergleich erlauben.
Vergleichsfunktionen ermitteln typischerweise drei Zustände und geben einen von
drei Werten zurück:
0 bedeutet, dass die beiden Zeichenfolgen identisch sind.
1 bedeutet, dass die erste Zeichenfolge größer als die zweite eingestuft wird.
-1 bedeutet, dass die erste Zeichenfolge kleiner als die zweite eingestuft wird.
Normalerweise erfolgt ein solcher Vergleich auf »binärer« Basis. Bei Zeichen wird
also die Reihenfolge der Zeichen im Zeichensatz herangezogen. So hat der Buchstabe
»A« den Code 65, während »a« den Wert 97 hat. Deshalb werden Großbuchstaben
als »kleiner« als Kleinbuchstaben eingestuft, was nicht immer den
Erwartungen entspricht. Ein zweites Merkmal derartiger Vergleiche ist die Vorgehensweise
bei mehreren Zeichen: Der Algorithmus prüft Zeichen für Zeichen, bis
er einen Unterschied findet. Der Vergleich der Zeichenfolge »11« mit »2« führt
bereits beim ersten Zeichen zu einem Unterschied. »1« wird mit »2« verglichen;
die »2« ist natürlich größer und deshalb produzieren derartige Funktionen als
Ergebnis: »2« ist größer als »11«. Auch dies dürfte nur selten den Erwartungen entsprechen.
Binäre Vergleiche sind im Alltag also weniger gefragt.
PHP bietet zwei Lösungen für das Problem an: Zum einen kann die Unterscheidung
von Groß- und Kleinschreibung verhindert werden. Die Funktionen strcasecmp,
strnatcasecmp und strncasecmp setzen »a« gleich »A«, der Teilname »case«
deutet darauf hin. Der Teilname »nat« verhindert dagegen die binäre Suche und
versucht eine so genannte natürliche Suche. Hierbei werden Zahlen extrahiert und
als Zahl, nicht als Zeichen behandelt, wobei 11 dann größer als 2 ist.

Listing 3.5: StrNatCmp.php – Vergleichen von Zeichenketten
Die Zeichenkettenfunktionen
Das Ergebnis zeigt, dass die Standardfunktion strcmp (binär, abhängig von Großund
Kleinschreibung) $text1 als größer einstuft, was an dem Vergleich der »2« zur
korrespondierenden »1« liegt. Mit strnatcmp sieht es anders aus. Hier wird der
Zahlenanteil extrahiert und – soweit der Rest übereinstimmt – als Zahl verglichen.
Deshalb ist $text1 nun kleiner als $text2.
Die Vergleichsfunktionen werden auch eingesetzt, um Sortiervorgänge auszuführen.
Sortieralgorithmen greifen auf die Ergebnisse eines einzelnen Vergleichs zwischen
zwei Werten zurück. Das Einsortieren in die Ergebnisliste erfolgt auf Basis
der Rückgabewerte 0, 1 oder -1. Diese Anwendung wird im Zusammenhang mit
Arrays am achten Tag noch gezeigt.
Ersetzen von Zeichen
Abbildung 3.4:
Natürlich oder nicht: Verschiedene Vergleichsergebnisse
Ebenso wichtig wie das Suchen von Mustern ist das Ersetzen der Fundstelle durch
anderen Text. PHP stellt zwei Funktionen zur Verfügung: str_replace berücksichtigt
beim Suchvorgang Groß- und Kleinschreibung, während str_ireplace
dies nicht tut.
Listing 3.6: StrReplace.php: Ersetzen eines Teils einer Zeichenkette
89

90
Daten verarbeiten
Hier werden gleich drei Parameter benötigt: Der erste gibt die zu suchenden Zeichen
an, der zweite bestimmt die Ersatzzeichen. Als Ersatz kann auch eine leere
Zeichenkette angegeben werden, womit die zu suchenden Zeichen entfernt werden.
Der dritte Parameter gibt den Text an, der durchsucht werden soll.
Komfortablere Such- und Ersetzungsmöglichkeiten bieten übrigens reguläre Ausdrücke,
die zum Standardrepertoire eines jeden Softwareentwicklers gehören
sollten. Informationen dazu werden in Abschnitt 3.6 »Reguläre Ausdrücke« ab
Seite 95 vermittelt.
Ermitteln von Eigenschaften einer Zeichenkette
Bei der Beurteilung des Inhalts einer Zeichenfolge kommt es natürlich auch auf
die allgemeinen Eigenschaften an. Besonders häufig wird die Länge benötigt, also
die Anzahl der Zeichen. Bei der Auswertung von Formulardaten können so
Pflichtfelder leicht überprüft werden – die Anzahl der Zeichen muss einfach größer
als 0 sein.
Listing 3.7: strlen.php – Anzahl der Zeichen einer Zeichenkette
Im Gegensatz zum nullbasierten Index wird hier die wirkliche Länge ermittelt.
Daran müssen Sie denken, wenn die Ergebnisse der Funktion strlen zusammen
mit der Auswahl von Teilzeichenketten oder der Positionsbestimmung (strpos)
benutzt werden.
Abbildung 3.5:
Anzahl der Zeichen in einer Zeichenkettenvariablen
Teilzeichenketten und Behandlung einzelner Zeichen
Bei der Behandlung einzelner Zeichen werden Sie mit zwei Dingen in Berührung
kommen. Zum einen wird gelegentlich mit dem Zeichencode gearbeitet, das
heißt, Sie haben den Code eines Zeichens aus dem verwendeten Zeichensatz und

Die Zeichenkettenfunktionen
benötigen dazu das Zeichen. Dazu gehört auch die entsprechende Rückumwandlung.
Zum anderen benötigen Sie noch eine Technik zum gezielten Zugriff auf
einzelne Zeichen.
Umgang mit Zeichencodes
Vor dem Zugriff auf Zeichencodes steht natürlich die Kenntnis derselben. PHP
kann mit seinen Zeichenkettenfunktionen nur den erweiterten ASCII-Zeichensatz
(Codes 0 bis 255) darstellen, dies entspricht ISO-8859-1.
Abbildung 3.6:
Die Zeichentabelle
des Zeichensatzes
ISO-8859-1
Entsprechend dieser Tabelle führt chr(65) zum Zeichen »A« und ord("_") zum
Code 128. Dies entspricht bei Zeichencodes oberhalb 127 nicht der oft verwendeten
Unicode-Kodierung, die »breitere« Zeichen verwendet (16 statt 8 Bit) und
auch asiatische Schriften verarbeiten kann. Kritisch ist das lediglich, wenn Sie versuchen,
dezimale HTML-Entitäten zu erstellen, beispielsweise &#8364;. Dieses
Zeichen entspricht der Entität &euro; und stellte das Eurozeichen dar. Leider
kann PHP mit dem Code 8364 nichts anfangen und umgekehrt kann nicht garantiert
werden, dass ein Browser bei &#128; auch wirklich 1 das €-Symbol anzeigt.
1 Solange das Betriebssystem den Zeichensatz ISO-8859-1 oder einen darauf aufbauenden verwendet, kann es
die Zeichen schon dekodieren und der Browser wird sie dann auch darstellen. Da der Zeichensatz aber in
jeder Sprache etwas variiert, ist das Ergebnis mehr oder weniger unvorhersehbar.
91

92
Daten verarbeiten
Zugriff auf einzelne Zeichen
Am Anfang wurde bereits gezeigt, dass jedes Zeichen in einer Zeichenfolge einen
Index hat, beginnend mit 0. Dieser Index kann auch zur gezielten Auswahl genau
eines Zeichens benutzt werden:
Listing 3.8: chars1.php – Auswahl eines einzelnen Zeichens
Die Schreibweise mit den geschweiften Klammern ($field{3}) ist etwas gewöhnungsbedürftig,
erweist sich aber als gut lesbar.
Wenn die Auswahl nicht nur ein Zeichen, sondern gleich mehrere betrifft, sind wieder
spezielle Funktionen gefragt. substr wählt einfach eine Anzahl Zeichen aus,
wobei die verschiedenen Parametervarianten dies sehr flexibel ermöglichen. Der
erste Parameter gibt die Zeichenfolge an, aus der ein Teil ausgewählt werden soll.
Der zweite die Startposition, ab der ausgewählt werden soll. Ist dieser Wert negativ,
beginnt die Zählung von hinten. Der dritte – optionale – Parameter gibt die Anzahl
der Zeichen an, von der Startposition beginnend immer nach rechts zählend.
Das folgende Beispiel nutzt diese Funktion und einige andere, um die Werte der
Parameter zu bestimmen.
Listing 3.9: Substr.php – Einen Teil einer Zeichenkette ermitteln
Die Nutzung mehrere Zeichenkettenfunktionen zusammen in einer Anweisung ist
sehr typisch für die PHP-Programmierung. Das Beispiel gibt das Wort »Muster« aus.
HTML-abhängige Funktionen
Der Sinn und Zweck nahezu jeden PHP-Programms ist die Erzeugung von
HTML. Entsprechend umfangreich ist auch hier das Angebot an Funktionen.

Die Zeichenkettenfunktionen
Häufiges Problem ist die korrekte Ausgabe von Text. Daten aus Datenbanken enthalten
meist nicht die für HTML nötigen Entitäten, also beispielsweise »&auml;«
statt »ä«. Das folgende Beispiel zeigt, wie eine solche Umwandlung durchgeführt
werden kann:
Listing 3.10: HtmlEntity.php: Sonderzeichen in HTML-Entitäten umwandeln

94
Daten verarbeiten
?>
Die Funktion kennt noch zwei weitere Parameter. Der dritte gibt ein alternatives
Zeichen für den Umbruch an, der vierte kann auf 1 gesetzt werden, um einen
Umbruch auch mitten im Wort zuzulassen.
Abbildung 3.7:
Umbruchsteuerung zur Formatierung der Ausgabe
Das Problem mit dem Standardzeilenumbruch \n in einer Datenquelle tritt häufiger
auf. Statt wäre die Verwendung des Umbruch-Tags oft besser. Auch
dies ist in PHP schnell gelöst: nl2br nimmt diese Umwandlung vor.
Listing 3.12: nl2br.php – Umwandlung von Zeilenumbrüchen in -Tags
Die folgende Abbildung zeigt den Unterschied. Die Breite des Rahmens wird
durch den Stil bestimmt (Attribut style des HTML-Tags ):
Abbildung 3.8:
Das linke Bild ist
ohne nl2br entstanden,
das
rechte mit.
Noch eine interessante Anwendung von Zeichenkettenfunktionen betrifft die Zerlegung
von Zeichenfolgen. Telefonnummern oder Bankleitzahlen sind beispielsweise
besser lesbar, wenn man sie mit Leerzeichen gruppiert. Die Funktion
chunk_split ist dafür bestens geeignet. Ähnlich wie wordwrap wird nach einer definierten
Anzahl von Zeichen ein Trennzeichen eingefügt. Auch hier ist dies standardmäßig
der Zeilenumbruch.

Listing 3.13: ChunkSplit.php – Formatierung einer Bankleitzahl
Reguläre Ausdrücke
Die Zeichenfolge wird hier von links beginnend in Abschnitte gleicher Länge
geteilt. Der letzte Abschnitt kann freilich kleiner sein, was in diesem Fall aber
gewollt ist. An jeden Abschnitt wird das Leerzeichen angehängt, das durch den
dritten Parameter bestimmt wird.
Das Beispiel gibt »100 700 24« aus.
3.6 Reguläre Ausdrücke
Reguläre Ausdrücke beschreiben Suchmuster. So einfach dies klingt, ist es indes
nicht. Denn die Suche nach Zeichen in einem Text kann komplexen Regeln
gehorchen. Nicht alle Arten von Suchen sind mit regulären Ausdrücken abbildbar.
Derartige Ausdrücke können im Prinzip nur statischen Text beschreiben, nicht
jedoch Berechnungen anstellen. Die Suche nach einer Zahl, einer bestimmten
Buchstabenfolge oder einer Zeichenart ist einfach. Eine Prüfsumme oder einen
Zahlenbereich kann man damit nicht erfassen.
Vor allem bei der Prüfung von Formularfeldern, die ein Benutzer ausgefüllt hat,
laufen reguläre Ausdrücke zur Höchstform auf. Typisch sind Suchmuster, die
E-Mail-Adressen, einen URL oder Zahlen erkennen.
Einführung in die Welt der regulären Ausdrücke
Die ersten Schritte mit regulären Ausdrücken sind nicht einfach. Hat man aber
erstmal eine gewisse Systematik erkannt, ist es nicht unmöglich, auch schwierige
Aufgaben zu lösen. Auch wenn reguläre Ausdrücke sehr »unleserlich« aussehen
können, eine einfache Variante ist oft ausreichend.
Das Grundprinzip
Betrachten Sie folgenden Satz:
95

96
Daten verarbeiten
Eine wichtige Programmiersprache ist PHP.
Sie möchten in diesem Satz – an beliebiger Stelle – nach der Zeichenfolge »PHP«
suchen. Der passende Ausdruck dazu lautet:
PHP
Freilich kann man das mit einer einfache Suche mittels Zeichenkettenfunktionen
auch. Angenommen, Sie wollen nach den Zeichen »PHP« oder »Perl« suchen.
Wenn Sie Zeichenkettenfunktionen verwenden, benötigen Sie dazu zwei Anfragen.
Ein regulärer Ausdruck kennt dafür einen Operator:
PHP|Perl
Die erste wichtige Aussage lautet also: Zum Suchen nach beliebigen konkreten
Zeichen oder Zeichenfolgen werden diese einfach aufgeschrieben. Die zweite
wichtige Aussage: Suchmuster lassen sich miteinander verknüpfen, um komplexere
Abfragen zu ermöglichen.
Muster durch Platzhalter und Zeichenklassen
Nun ist das Suchen nach fest vorgegebenen Mustern recht einfach. Spannender ist
es, die Zeichen durch Platzhalter zu ersetzen. Der wichtigste Platzhalter ersetzt ein
beliebiges Zeichen – der Punkt (.):
P.P
Dieses Muster findet PAP, PBP usw. und natürlich auch PHP.
Außer »alle« oder »ein bestimmtes« Zeichen kann man beliebige Platzhalter selbst
konstruieren. Dazu werden so genannte Zeichenklassen eingesetzt, gekennzeichnet
durch eckige Klammern. Diese Gebilde stehen für genau ein Zeichen, das den
Kriterien entsprechen muss:
[PH]HP
Dieses Muster steht für PHP oder HHP. Der Inhalt der Zeichenklasse kann negiert
werden, das heißt, alle Zeichen außer den angegebenen sind zulässig:
[^PH]HP
Das letzte Muster erkennt – neben vielen anderen – AHP, BHP usw. nicht jedoch
PHP und HHP.
Weil bestimmte Zeichenklassen sehr häufig benötigt werden, gibt es einige vordefinierte
Abkürzungen dafür. Die folgende Tabelle zeigt diese:

Zeichen Bedeutung
\t Tabulator, entspricht dem ASCII-Wert 0x9
\n Zeilenumbruch (Newline), entspricht dem ASCII-Wert 0xC
Wiederholungen definieren
Reguläre Ausdrücke
\r Wagenrücklauf (Carriage Return), entspricht dem ASCII-Wert 0xA
\xHH Ein beliebiges Zeichen, definiert durch seinen hexadezimalen Wert HH
\d Eine Ziffer
\D Keine Ziffer (alles außer Zifferzeichen)
\s Jedes unsichtbare Zeichen (Leerzeichen, Tabulator usw.)
\S Alles außer unsichtbare Zeichen
\w Jedes Wortzeichen (Zahl, Ziffer, Unterstrich)
\W Kein Wortzeichen
\b Jedes für Wortgrenzen verwendete Zeichen (Leerzeichen, Interpunktion)
\B Kein für Wortgrenzen verwendetes Zeichen
\A Erstes Zeichen der Sequenz (absolut, ohne Rücksicht auf andere Schalter)
\Z Letztes Zeichen der Sequenz oder Zeile (absolut, ohne Rücksicht auf andere
Schalter)
\z Letztes Zeichen der Sequenz (absolut, ohne Rücksicht auf andere Schalter)
Tabelle 3.5: Vordefinierte Zeichen und Zeichenklassen
Damit man mit Zeichen und Zeichenklassen flexibel umgehen kann, lässt sich ein
Wiederholungsoperator anhängen. Dieser Zeigt an, wie oft das Zeichen vorkommen
soll:
{n, m}
Dabei steht das n für die Mindestzahl und das m für die Maximalzahl. Beide Werte
sind optional; {4,} steht beispielsweise für mindestens vier bis unendlich viele Zeichen,
{,6} für keines bis höchstens sechs Zeichen. Für drei Kombinationen gibt es
eine verkürzte Schreibweise, die häufig zum Einsatz kommt:
97

98
Daten verarbeiten
*
Steht für keines oder beliebig viele Zeichen, entspricht also {0,}.
?
Steht für keines oder genau ein Zeichen, entspricht also {0,1}.
+
Steht für ein oder mehr Zeichen, entspricht also {1,}.
Die Kombination {1,1} muss nicht angegeben werden, dies ist der Standardfall.
Um die Zeichenposition innerhalb der zu durchsuchenden Zeichenkette festlegen
zu können, sind weitere Sonderzeichen erforderlich:
^
Muster muss am Beginn der Zeichenkette anfangen.
$
Muster muss am Ende der Zeichenkette aufhören.
Da nun bereits einige Zeichen mit Sonderfunktionen belegt sind, braucht man
noch ein Aufhebungszeichen, wozu der Backslash \ eingesetzt wird. Suchen Sie
also nach einem Punkt, schreiben Sie \. .
Gruppierungen
Nicht nur einzelne Zeichen, sondern auch Kombinationen lassen sich mit den
Wiederholungsoperatoren +, *, ? und {n,m} verwenden. Gruppen entstehen durch
runde Klammern:
(PHP)+
Neben der Funktion der Gruppierung dienen die Klammern auch dazu, Teilmuster
zurückzugeben. In PHP entsteht am Ende nicht nur die Aussage »Muster
gefunden«, sondern auch ein Array mit den Teilmustern, die durch Gruppen definiert
wurden.
Anwendungsbeispiele
Bevor Sie mit regulären Ausdrücken beginnen, sollten Sie sich ein kleines Skript
bauen, das Eingabe und Test vereinfacht. Das folgende Listing zeigt eine einfache
Version. Dabei lernen Sie auch gleich einige PHP-Funktionen kennen, die mit

Reguläre Ausdrücke
regulären Ausdrücken umgehen können. Sie beginnen immer mit dem Präfix
preg_ 2 :
Listing 3.14: RegexTest.php – Ein Testskript für reguläre Ausdrücke

100
Daten verarbeiten
{
foreach ($val as $subkey => $subval)
{
echo "&nbsp;&nbsp;&nbsp;Teilgruppe
$subkey => $subval";
}
} else {
echo "$val";
}
}
}
} else {
echo "Keine Übereinstimmung gefunden";
}
} else {
echo "Kein Muster angegeben.";
}
?>
Kern des Skripts ist die Funktion preg_match_all. Sie sucht alle Vorkommen des
angegebenen Musters, bleibt also nicht stehen, wenn eine erste Übereinstimmung
gefunden wurde. Für Testzwecke ist dies sehr hilfreich. Wird dagegen nur nach
einem (dem ersten) Vorkommen gesucht, reicht preg_match aus.
Neben dem einfachen Suchen kann man natürlich auch Suchen und Ersetzen,
das heißt, gefundene Teilmuster gezielt austauschen.
Suchen und Ersetzen
Zum Suchen und Ersetzen stehen die Funktionen preg_replace und
preg_replace_callback bereit. Jede Fundstelle kann hier durch eine Ersatzzeichenkette
ausgetauscht werden. preg_replace_callback erledigt das auch für komplexe
Aufgaben, denn hier wird für jede Fundstelle eine so genannte
Rückruffunktion aufgerufen, in der man zusätzliche Berechnungen anstellen
kann. Das bringt viel Dynamik in den Ersetzungsvorgang.
Das folgende Beispiel zeigt die Anwendung. Ein Text soll nach einem Muster, hier
der Zeichenfolge ~#~ durchsucht werden. Das Nummernzeichen # soll dabei
durch eine fortlaufende Ziffer ersetzt werden. Mit preg_replace_callback ist das
sehr einfach zu realisieren:

Reguläre Ausdrücke
Listing 3.15: RegexReplace.php – Ersetzen mit Hilfe einer Rückruffunktion
Der Funktionsaufruf preg_replace_callback enthält den Namen der Rückruffunktion
replaceNumbers, die für jede Fundstelle aufgerufen wird, im Beispiel also vier
Mal. In der Funktion zählt eine statische Variable (static) die Aufrufe mit und
gibt den aktuellen Wert, beginnend mit 1, zurück. Der Rückgabewert wird zum
Ersetzen der Zeichenfolge benutzt. Statische Variablen behalten ihren Wert und
führen die Zuweisung nur beim ersten Aufruf aus.
Für die Ausgabe werden außerdem noch die normalen Zeilenumbrüche, wie sie
bei der Heredoc-Notation entstehen, in HTML-typische -Tags konvertiert.
Abbildung 3.9:
Ausgabe des Skripts mit
dynamisch ersetzten Ziffern
Noch einfacher ist preg_replace, wo anstatt der Rückruffunktion nur eine konstante
Zeichenkette angegeben wird. Allerdings kann man auch hier etwas Dynamik
bekommen, indem auf Gruppen zugegriffen wird. Zulässig ist nämlich die
Angabe von Referenzen auf Gruppen des Ausdrucks. Wie bereits in der Einführung
beschrieben, werden Gruppen durch runde Klammern gebildet. Auf diese
kann mit einer speziellen Referenzsyntax zugegriffen werden.
Angenommen, Sie suchen nach einem bestimmten Datumsformat, beispielsweise
der Art 8/9/2004 (amerikanisches Format) in einem Text. Sie möchten nun an die-
101

102
Daten verarbeiten
sen Stellen die deutsche Version 9.8.2004 sehen. Dies ist mit preg_replace in
einem Schritt erledigt.
Listing 3.16: RegexReplace2.php: Ersetzen mit Zugriff auf Teilmuster
Das Muster untersucht den Text auf Datumsformate hin. \d steht für eine Ziffer,
die im Beispiel für den Monat (erstes Teilmuster) ein oder zwei Mal vorkommen
darf: \d{1,2}. Die Jahreszahl muss immer vierstellig sein. Wichtig an dem gezeigten
Muster sind die drei runden Klammerpaare, die dafür sorgen, dass die erkannten
Teile in separaten Variablen abgelegt werden. Die Schrägstriche werden damit
zwar zur Erkennung herangezogen, fallen aber aus den Teilmustern heraus. In der
Ersatzzeichenkette kann nun auf die Teilmuster mit der Syntax \\n zugegriffen
werden, wobei n einfach die Nummer der öffnenden Klammer ist. \\2 bezeichnet
also die zweite Klammer, mithin der Tag im amerikanischen Datumsformat. Die
Punkte in der Ersatzzeichenkette werden wie normale Zeichen behandelt.
Reguläre Ausdrücke können weit komplexer sein. Schauen Sie sich folgendes
Suchmuster an:
(?

Reguläre Ausdrücke
( Zweites Teilmuster (nicht unterdrückt)
[^,]* Suche alles (*) außer dem Komma (^ negiert hier)
)
( Drittes Teilmuster (nicht unterdrückt)
,\1 Komma mit folgendem Text, der dem ersten nicht
unterdrückten Teilmuster (zweite Klammer)
entspricht – dies ist das Duplikat
)+ Davon mindestens 1 oder beliebig viele
(? Viertes Teilmuster (unterdrückt, ?-Zeichen)
= Positiv (=) vorausschauen
,|$ Vollständigkeit untersuchen, es muss entweder ein
weiteres Komma oder (|) das Musterende ($) folgen
)
Alles klar? Die Beispiele zeigen, wie stark reguläre Ausdrücke in der Praxis sind.
Sie zeigen auch, dass reguläre Ausdrücke nicht trivial sind. Es kommt also weniger
auf die Anwendung der PHP-Funktionen an. Problematischer ist das Finden der
passenden Ausdrücke. Der folgende Abschnitt stellt deshalb einige häufig benutzte
Ausdrücke vor – zum Lernen und natürlich zum Anwenden.
Typische Suchmuster
In diesem Abschnitt werden einige häufig benötigte Suchmuster vorgestellt und
kurz erläutert. Einerseits können Sie so reguläre Ausdrücke schnell anwenden,
andererseits lernen, vergleichbare Muster selbst zu entwerfen. Die Muster werden
nicht im Kontext eines PHP-Skripts dargestellt, da es sich hier lediglich um den
immer wieder gleichen Aufruf von preg_match, preg_match_all oder preg_replace
handeln würde.
Wenn Sie im Internet auf die Suche nach regulären Ausdrücken gehen,
sollten Sie daran denken, dass es sehr viele Regex-Maschinen gibt, die
keineswegs zueinander vollkommen kompatibel sind. PHP verwendet
eine weitgehend (aber nicht 100-prozentig) Perl-kompatible Methode.
JavaScript, Unix-Shells, .NET, VBScript und andere Systeme weichen
davon teilweise ab. Das Grundprinzip ist zwar allen gleich, aber die Syntax
variiert ebenso wie die Standardeinstellungen (beispielsweise ist Perl
standardmäßig »gierig«, und man unterdrückt dies explizit, während
.NET »ungierig« ist und man die Option explizit einschalten muss). Sie
müssen deshalb fremde Muster immer erst sorgfältig testen und eine
103

104
Daten verarbeiten
scheinbare Fehlfunktion ist nicht immer dem Anbieter anzulasten, es sei
denn, das Muster wurde explizit für PHP geschrieben.
Vorbemerkungen
Alle folgenden Beispiele verwenden als Begrenzungszeichen die Tilde (~). Wenn
in Ihrem Suchmuster nach der Tilde gesucht werden soll, müssen Sie ein anderes
Begrenzungszeichen nutzen, das nicht im Muster selbst vorkommt.
Sie finden jeweils das Muster auf einen Blick und danach zeilenweise mit Erläuterungen.
Sie finden auf der Buch-CD das Programm RegexExamples.php, das die
Beispiele enthält und ein Formular anbietet, mit dem sich schnelle
Tests ausführen lassen. Für die Ausführung ist JavaScript erforderlich.
HTML-Tags suchen
Tags zu suchen ist eine sehr häufige Aufgabe. Immer wieder müssen Daten umund
aufbereitet werden. Das folgende einfache Beispiel zeigt das Prinzip:
HTML-Tag suchen
~]*>(.*?)~i
~
]* Öffnendes b-Tag, alles außer >-Zeichen
> Bis zum >-Zeichen
(.*?) Beliebige Zeichen
Bis zum schließenden Tag
~
i Groß- und Kleinschreibung ist egal
Beliebige Tags suchen
~]*>(.*?)~iu
~
]*> Ende des Tags, beliebige Zeichen
innerhalb des Tags

für Attribute
(.*?) Beliebige Zeichen innerhalb des Tags
Der Tagname muss sich im schließenden Tag
wiederholen (eine Referenz)
~iu Groß-/Klein egal, Gierigkeit aus
Umgang mit Leerzeichen
Reguläre Ausdrücke
Leerzeichen umfassen im Allgemeinen alle beim Druck nicht sichtbaren Zeichen,
also neben dem eigentlichen Leerschritt auch Tabulatoren und Zeilenumbrüche.
Reguläre Ausdrücke verwenden dazu das Ersatzzeichen \s.
Führende Leerzeichen
~^\s+~
~
^ Zeichen muss am Beginn erscheinen
\s+ Ein oder mehr Leerzeichen
~
Abschließende Leerzeichen
~\s+$~
~
\s+ Ein oder mehr Leerzeichen
$ Unmittelbar vor dem Ende des Textes
~
IP-Adressen
Ebenso wie mit HTML-Tags hat man in der Webprogrammierung häufiger mit IP-
Adressen zu tun. Drei Versionen sollen die möglichen Lösungsansätze zeigen:
IP-Adressen (Schwache Version mit Gruppierung)
Die Version erkennt zwar die Gruppen, prüft aber nicht den Sinn der Zahlen.
IP-Nummern sind Bytes, habe Dezimal also einen Wertebereich zwischen 0
und 255. Das folgende Muster erkennt jedoch auch 980.378.275.455 noch als
gültig an:
~\b(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\b~
~
105

106
Daten verarbeiten
\b Beliebige Wortgrenze
(\d{1,3}) Erste Gruppe: 1 bis 3 Ziffern
\. Gefolgt von einem Punkt
(\d{1,3})\. Zweite Gruppe mit Punkt
(\d{1,3})\. Dritte Gruppe mit Punkt
(\d{1,3}) Letzte Gruppe
\b~ gefolgt von einer Wortgrenze
IP-Adressen (schwache Version ohne Gruppierung)
Dieses Muster entspricht dem vorhergehenden, es verzichtet jedoch auf die
Gruppierung der Teiladressen. Es ist vorzuziehen, wenn eine Auswertung der
einzelnen Blöcke nicht erforderlich ist.
~\b(?:\d{1,3}\.){3}\d{1,3}\b~
IP-Adressen (starke Version, mit Gruppierung)
Diese Version versucht etwas mehr Logik in die Sache zu bringen und erkennt
nur korrekte Nummernkreise. Hier ist freilich fraglich, ob der Aufwand lohnt,
ein Zugriff auf die Teilmuster des letzten Beispiels mit PHP und eine simple
Prüfung (

Gleitkommazahlen (englisches Format, ganzer Ausdruck)
~^((?:[-]|[.]|[-.]|[0-9])[0-9]*)(?:(?:\.)([0-9]+))?$~
Reguläre Ausdrücke
~
^ Muss am Textanfang beginnen
( Teilmuster
(?: Keine Aufnahme als Teilmuster
[-] Minuszeichen
| Oder
[.] Punkt
| Oder
[-.] Kombination aus beidem
|Oder
[0-9] Ziffer
)
[0-9]* Gefolgt von 0 oder mehr Ziffern
) Bilden die erste Gruppe
(?: Unterdrückte Teilgruppe
(?:\.) Beginnt mit Punkt, der ebenso bei der
Ausgabe unterdrückt wird
([0-9]+) Eine oder mehrere Ziffern
)? Gruppe ein oder kein Mal
$ Der Vergleichstext muss nun enden
~
Gleitkommazahlen (englisches Format mit Exponenten, beispielsweise 23e4)
Die folgende Variante funktioniert ähnlich, bindet jedoch zusätzlich noch die
Buchstaben e oder E mit ein, um den Exponenten abzutrennen.
~[-+]?([0-9]*\.)?[0-9]+([eE][-+]?[0-9]+)?~
Ganzzahlen mit optional Vorzeichen (alle Vorkommen)
Dieses Muster ermittelt alle Vorkommen ganzer Zahlen in einem Text.
~[-+]?\b\d+\b~
~
[-+]? Optionales Vorzeichen
\b Wortgrenze
\d+ Ziffernfolge (eine oder mehrere Ziffern)
\b Wortgrenze
~
107

108
Daten verarbeiten
Hexzahlen im PHP-Format (z.B. 0xFF)
Das folgende Beispiel funktioniert ähnlich, setzt jedoch das für Hex-Literale
typische Präfix 0x davor. Die zweite Variante ist identisch, nutzt aber den
Schalter i statt einer expliziten Angabe der Buchstaben in Groß- und Kleinschreibung.
~\b0[xX][0-9a-fA-F]+\b~
~\b0[X][0-9A-F]+\b~i
Datumsformate prüfen
Die folgenden Beispiele zeigen, wie mit Datumsformaten umgegangen werden
kann. Die Ausdrücke sind recht einfach, sodass sie sich leicht anpassen oder erweitern
lassen.
Datumsformat mm/dd/yyyy (Jahr nur 19XX und 20XX)
~(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])
[- /.](19|20)\d\d~
~
(0[1-9]|1[012]) Monate 01-09 und 10, 11, 12
[- /.] Erlaubte Trennzeichen
(
0[1-9] Tage 01 bis 09
| oder
[12][0-9] 10 bis 29 (1 oder 2 und 0 bis 9)
| oder
3[01] 30 oder 31
Abbildung 3.11:
Das Muster findet
alle ganzen
Zahlen in einem
Text (Bild vom
Testprogramm)

Reguläre Ausdrücke
)
[- /.] Erlaubte Trennzeichen
(19|20)\d\d 19nn oder 20nn, nn = jede Ziffer
~
Datumsformat yyyy-mm-dd (Jahr nur 19XX und 20XX)
Analog zum vorherigen Beispiel, aber mit anderer Reihenfolge.
~(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12]
[09]|3[01])~
Wörter suchen oder auf Merkmale hin analysieren
Sucht die Schlüsselwörter print, printf, echo, print_r
Der Ausdruck ist recht einfach, die zulässigen Wörter sind lediglich durch |
(oder) verknüpft.
~\b(print|echo|print_r|printf)\b~
E-Mail-Adresse (einfache Version)
Bereits etwas anspruchsvoller, aber bei weitem noch nicht so perfekt wie möglich
ist diese Prüfung einer E-Mail-Adresse.
~^([_a-z0-9-]+(\.[_a-z0-9-]+)*)@([a-z0-9-]+(?:\.[a-z0-9-]+)*)$~i
~
^ Prüfung ab Textanfang
( Teilmuster für den Namen
[_a-z0-9-]+ Beginnt mit _, -, Buchstaben, Zahlen
(\. Gefolgt von einem Punkt
[_a-z0-9-]+ Und _, -, Buchstaben oder Zahlen
)* Diese Kombination ist optional
)
@ Das @-Zeichen
( Teilmuster für die Domain
[a-z0-9-]+ Zulässige Zeichen, ein oder mehr Mal
(?:\.[a-z0-9-]+) Toplevel, durch Punkt getrennt, das
?: am Anfang unterdrückt die Gruppe
*) Das Teilmuster kann sich wiederholen
$ Und der Textende ist auch Musterende
~i Groß-/Klein ist wieder egal
109

110
Daten verarbeiten
3.7 Datums- und Zeitfunktionen
PHP verfügt über vielfältige Datums- und Zeitfunktionen, die außerdem durch ein
Kalendermodul ergänzt werden. Datumsberechnungen werden damit vereinfacht
und helfen dabei, nutzerfreundliche Websites aufzubauen. In diesem Abschnitt
werden verschiedene erweiterte Techniken der Datenausgabe vorgestellt. Dazu
gehört der Umgang mit Datums- und Zeitfunktionen sowie deren Formatierung.
Aber auch die vielfältigen Möglichkeiten, Zahlen und Währungsangaben zu verarbeiten,
werden behandelt.
Der Timestamp und die Serverzeit
Basis aller Zeitberechnungen in PHP bildet der Unix-Timestamp (Zeitstempel).
Dies ist ein sekundengenauer Zähler, der den Zeitraum seit dem 1.1.1970 zählt.
Dargestellt wird er im 32-Bit-Zahlenraum (Integer), sodass er Datumswerte bis
2037 enthalten kann. Solange man sich innerhalb dieses Zeitraumes bewegt, sind
die internen Funktionen außerordentlich wirkungsvoll und einfach. Daten, die
davor oder danach berechnet werden sollen, bedürfen einer etwas eingehenderen
Betrachtung.
Wenn Sie mit Zeitwerten arbeiten, die die aktuelle Zeit reflektieren, müssen Sie
beachten, dass der Server möglicherweise nicht in Ihrer Zeitzone oder der der
künftigen Nutzer steht. Manche Provider stellen ihre Server auch nicht auf die
Zeitzone ein, in der die Maschine physisch steht, sondern auf UTC (Universal
Time Conversion, früher als GMT, Greenwich Mean Time bezeichnet). Für die
Abfrage der lokalen Zeit des Browser benötigen Sie JavaScript; PHP allein hilft
hier nicht wirklich weiter. Lesen Sie mehr dazu im Abschnitt »Tricks mit Java-
Script: Lokale Zeit ermitteln« ab Seite 117.
Rechnen mit Datums- und Zeitwerten
Um unter PHP mit Datums- und Zeitwerten rechnen zu können, müssen Sie
zuerst über einen Zeitstempel verfügen – entweder den aktuellen (Jetzt-Zeit) oder
den für einen bestimmten Zeitpunkt. Für beides gibt es entsprechende Funktionen.

Datums- und Zeitfunktionen
Die aktuelle Zeit wird mit time ermittelt. Eine bestimmte Zeit wird dagegen mit
mktime (mk = engl. make; machen, erzeugen) erzeugt. Das folgende Beispiel zeigt
dies und gibt die Zeitstempel im »Rohformat« aus.
Listing 3.17: time.php – Der aktuelle Zeitstempel
Berechnungen mit Zeitwerten sind auf Basis des Zeitstempels sehr einfach. Da es
sich um ein Maß in Sekunden handelt, muss zur Berechnung eines anderen
Datums lediglich die nötige Anzahl Sekunden abgezogen oder hinzugefügt werden.
Dabei helfen folgende Umrechnungen:
1 Minute = 60 Sekunden
1 Stunde = 3.600 Sekunden
1 Tag = 86.400 Sekunden
1 Woche = 604.800 Sekunden
Monate sind naturgemäß unterschiedlich lang. Um also die Länge eines Monats
zu ermitteln, muss bekannt sein, in welchem Jahr er liegt (auch wenn dies nur
beim Februar zu unterschiedlichen Ergebnissen führen kann).
Ausgabe formatierter Zeit- und Datumswerte
Nachdem das benötigte Datum nun ermittelt wurde, muss es meist formatiert werden.
Mit den typischen Zeitstempeln kann in der Regel kein Benutzer etwas anfangen.
Zur Speicherungen in Datenbanken sind sie dagegen gut geeignet. Vor allem
wenn die spätere Formatierung flexibel angewendet werden soll, ist das Vorhalten
der Datumswerte in Form von Zeitstempeln optimal.
Zur Formatierung bietet PHP gleich zwei Funktionen an: date und strftime.
Während date ausschließlich englisch »spricht«, kennt strftime auch eine Lokalisierung.
Die Dopplung der Funktionen ist historisch bedingt und erschwert leider
den Umgang mit PHP etwas, weil derartige Inkonsistenzen die Lernkurve nicht
eben ebnen. Es bleibt in der Praxis nichts weiter übrig, als mit beiden Funktionen
parallel zu arbeiten.
111

112
Daten verarbeiten
Die folgende Tabelle stellt die beiden Funktionen und deren Formatparameter
gegenüber.
date strftime Beschreibung
a %p Erzeugt den Schriftzug »am« oder »pm«
A %r Erzeugt den Schriftzug »AM« oder »PM«
B Zeigt die Swatch-Internetzeit an, eine Zeitform, die den Tag ohne
Zeitzonen in 1.000 Einheiten teilt
d %d Gibt den Tag im Monat an; zwei Ziffern mit führender Null zwischen
01 und 31 werden ausgegeben
%e Gibt den Tag im Monat mit führendem Leerzeichen bei einstelligen
Werten an
D %a Erzeugt den Tag der Woche mit drei Buchstaben, beispielsweise
»Fri«
F %B Ausgeschriebener Monatsname, beispielsweise »January«
h Stunde im 12-Stunden-Format zwischen 01 und 12 mit führender
Null
H Stunde im 24-Stunden-Format zwischen 00 und 23 mit führender
Null
g %I Stunde im 12-Stunden-Format ohne führende Null, also zwischen
1 und 12
G %H Stunde im 24-Stunden-Format ohne führende Null, also zwischen
00 und 23
i Minuten 00 bis 59 mit führender Null
%M Minuten 0 bis 59
I 1 in der Sommerzeit, sonst 0.
j Tag des Monats ohne führende Null: 1 bis 31 sind mögliche
Werte.
l %A Ausgeschriebener Tag der Woche: »Friday«
Tabelle 3.6: Formatzeichen der Datumsformatierfunktion date und strftime

date strftime Beschreibung
L Boolescher Wert für das Schaltjahr: 0 oder 1
Datums- und Zeitfunktionen
m %m Monat des Jahres von 01 bis 12, also mit führender Null
n Monat des Jahres ohne führende Null: 1 bis 12
M %b Monat als Abkürzung mit drei Buchstaben: »Jan«
O Zeitdifferenz zu UTC in Stunden als Differenzzeichenkette, beispielsweise
»+0400«
r Datum und Zeit im RFC 822-Format. Folgendes Format wird verwendet:
»Mon, 19 Mar 2004 12:05:00 +0100«. Die RFC 822 definiert
Datumsformate, wie sie in E-Mails verwendet werden.
s %S Sekunden 00 bis 59 mit führender Null
S Suffix der englischen Ordnungszahlen: »th«, »nd« usw.
t Tage des Monats: 28 bis 31. Verwechseln Sie dies nicht mit der
Nummer des Tages.
T Zeitzoneneinstellung des Computers, beispielsweise »EST« oder
»MDT«
U Sekunden der UNIX-Epoche (seit 1.1.1970). Entspricht der Ausgabe
der Funktion time.
w %w Tag der Woche, beginnend mit 0 (Sonntag) bis 6 (Samstag)
W ISO-8601 Wochennummer des Jahres (ab erste Woche mit einem
Montag drin)
Y %Y Jahr im vierstelligen Format »2001«
y %y Jahr im zweistelligen Format »01«
z %j Tag im Jahr: 0 bis 365
Z %Z Offset der Zeitzonen gegen UTC in Sekunden von -43 200 bis
43 200 (86 400 Sekunden entspricht 1 Tag).
%G Das Jahr wie %Y, aber nur bei vollen Wochen. Angefangene
Wochen zählen im vorhergehenden oder im folgenden Jahr
Tabelle 3.6: Formatzeichen der Datumsformatierfunktion date und strftime (Forts.)
113

114
Daten verarbeiten
date strftime Beschreibung
Beachten Sie, dass die Funktion date nur englische Namen für
Wochentage oder Monate erzeugen kann. Benutzen Sie in lokalisierten
Umgebungen besser immer strftime.
Das Prinzip der Formatzeichen ist relativ einfach. Man stellt sich dazu eine Zeichenkette
zusammen, die alle benötigten Formatzeichen enthält. Für strftime
sieht das dann beispielsweise folgendermaßen aus:
%d.%m.%Y
%g Wie %G, aber kurzes Jahresformat wie %y
%x Zeit nach lokalen Systemeinstellungen
%X Datum nach lokalen Systemeinstellungen
%c Zeit + Datum nach lokalen Systemeinstellungen
%D Entsprechung der Folge »%m/%d/%y«
%U Wochennummer, beginnt mit Sonntag
%V Kalenderwoche nach ISO 8601
%W Wochennummer, beginnt mit Montag
%R Komplette Zeit im 24-Stunden-Format
%C Jahrhundert (2003 gibt »20« zurück)
%t Tabulator
%n Zeilenvorschub
%% Prozentzeichen
Tabelle 3.6: Formatzeichen der Datumsformatierfunktion date und strftime (Forts.)
Nun ist der Funktion noch ein Datumswert zu übergeben. Aus diesem werden die
benötigten Datumsfragmente dann extrahiert. Bei strftime kommt noch hinzu,
dass die Lokalisierung vorher eingestellt werden kann, um die Namen von Monaten
oder Wochentagen für eine bestimmte Sprache zu erzeugen. Das folgende
Beispiel zeigt, wie das geht:

Listing 3.18: DateStrftime.php – Lokalisierte Datumsformatierung
(hier: Windows-Version)
Datums- und Zeitfunktionen
setlocale(LC_TIME, "ge");
echo strftime("%A, %d. %B %Y", time());
Die Funktionen date und strftime geben jeweils die formatierte Zeichenkette
zurück, sodass anschließend die Ausgabe mit echo oder print erfolgen kann. Die
Angabe der Lokalisierung mit setlocale ist dagegen etwas tückisch, denn die
benötigten Angaben werden dem Betriebssystem entnommen und hier gibt es
Unterschiede zwischen der Windows- und der Linux-Version. Mehr dazu finden
Sie im Abschnitt »Lokalisierung und Formatierung von Zeichen« ab Seite 376.
Jetzt muss man natürlich feststellen, auf welcher Plattform man gerade das Skript
laufen lässt. Ein Plattformwechsel ist durchaus typisch, weil die meisten Entwickler
ihre Skripte auf Windows entwickeln und beim Provider unter Linux im Produktionsbetrieb
laufen lassen. Dazu kann die Konstante PHP_OS eingesetzt werden:
Listing 3.19: DateStrftimeExt.php: Datumsausgaben betriebsystemunabhängig steuern
$sl = TRUE;
if (PHP_OS == "WINNT")
{
$sl = setlocale(LC_TIME, "German_Germany");
}
else
{
$sl = setlocale(LC_TIME, "de_DE");
}
if ($sl)
{
echo strftime("%A, %d. %B %Y", time());
}
else
{
echo "Lokalisierung konnte nicht gesetzt werden";
}
setlocale gibt entweder die aktuelle Einstellung zurück, wenn die neue
akzeptiert werden konnte, oder FALSE, wenn die Zuweisung misslang.
Auf dieser Rückgabe beruht die im letzten Skript gezeigte Ausgabesteuerung.
115

116
Daten verarbeiten
Die Konstante PHP_OS gibt auf Windows-Systemen »WINNT« zurück, unabhängig
davon, ob es sich um Windows NT, 2000 oder XP handelt. Auf Linux-Systemen
steht »Linux« drin, auf FreeBSD beispielsweise »FreeBSD«. Um auch ältere Windows-Systeme
zu erfassen, ist folgende Abfrage noch robuster:
if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN')
{
echo 'Dieser Server läuft unter Windows!';
}
else
{
echo 'Dieser Server läuft nicht unter Windows!';
}
Beachten Sie, dass die Abfrage des Betriebssystems nichts mit dem System
zu tun hat, das der Benutzer der Seite nutzt bzw. auf dem der Browser
läuft.
Abschließend noch ein Wort zu der stillschweigend genutzten Konstanten
LC_TIME. Damit wird setlocale mitgeteilt, dass die Einstellung nur für Zeit- und
Datumswerte erfolgen soll. PHP kennt auch andere Funktionen, deren Ausgaben
sich lokalisieren lassen. Diese verlangen andere Konstanten. Mit LC_ALL wird die
Lokalisierung global umgestellt. Im Abschnitt 9.1 »Mehrsprachige Webseiten« ab
Seite 374 finden Sie mehr Informationen dazu.
Datumsfragmente mit idate
Wenn man nur einen bestimmten Teil aus einem Zeitstempel benötigt, ist idate
eine interessante Funktion, die mit PHP5 neu eingeführt wurde. Die folgende
Tabelle zeigt, welche Formatanweisungen möglich sind:
Format Beschreibung
B Swatch Internet Time
d Tag des Monats
h Stunde (12:00 Format)
H Stunde (24:00 Format)
Tabelle 3.7: Formatanweisungen der Funktion idate

Format Beschreibung
i Minute
I 1, wenn Sommerzeit, sonst 0
L 1, wenn Schaltjahr, sonst 0
m Nummer des Monats
s Sekunden
t Tag im Monat
Datums- und Zeitfunktionen
U Sekunden seit Beginn der Unix-Epoche, entspricht der von time erzeugten
Ausgabe.
w Tag der Woche, wobei 0 der Sonntag ist.
W ISO-8601-Wochennummer. Die erste Woche beginnt am ersten Montag
im Jahr.
y Jahr (1 oder 2 Ziffern, 2005 wird als »5« zurückgegeben)
Y Jahr (4 Ziffern)
Z Tag im Jahr
Z Offset der Zeitzone in Sekunden
Tabelle 3.7: Formatanweisungen der Funktion idate (Forts.)
Die Funktion gibt immer einen Zahlenwert zurück, was zwangsläufig bedeutet,
dass immer nur eine der Formatanweisungen benutzt werden kann:
$jahr = idate('Y');
Der zweite, optionale Parameter bestimmt über einen Zeitstempel die zugrunde
liegende Zeitangabe. Beachten Sie bei den zweistelligen Jahreszahlen, dass auch
diese als Zahl zurückgegeben werden. Das Jahr 2004 wird also mit dem Parameter
»y« als Zahl 4, nicht als Zeichenkette »04« erscheinen.
Tricks mit JavaScript: Lokale Zeit ermitteln
Um die lokale Zeit eines Benutzers zu ermitteln, benötigen Sie JavaScript. Meist
ist es ausreichend, diese Information nur einmal, gleich beim ersten Seitenaufruf,
117

118
Daten verarbeiten
zu ermitteln. Es bietet sich an, dazu das Refresh-Tag von HTML einzusetzen, das
einen erneuten Aufruf der Seite erzwingt. Der Benutzer muss deshalb nicht eingreifen,
ein Formular senden oder einen Link klicken. Gleichzeitig können Sie
feststellen, ob JavaScript überhaupt aktiviert ist.
Das Ganze basiert auf einem einfachen Trick. Zuerst wird mit PHP festgestellt, ob
eine Zeitinformation bereits vorliegt. Das ist beim ersten Aufruf der Seite natürlich
nicht der Fall. Dann wird eine JavaScript-Sequenz erzeugt, die die lokale Zeit
abfragt. Es ist hilfreich, dazu ein Formular einzusetzen und das Formular dann per
JavaScript senden zu lassen.
Listing 3.20: datejavascript.php – Lokale Zeit des Browsers ermitteln

Formatieren und Ausgeben
Hier wird einmal abgefragt, ob ein Formular oder eine Seite gesendet wurde. Beim
ersten Aufruf der Seite über den Browser kann es sich nie um ein Formular handeln.
Die Variable $_SERVER['REQUEST_METHOD'] enthält diese Information. Der
Umgang mit derartigen Informationen wird später noch ausführlich behandelt.
Der linke Teil der Abfrage umfasst die Erkennung der gesendete Zeitinformation.
Verpackt wird diese in einem versteckten Feld im Formular mit dem Namen
»timeForm«. Der Rest ist reines JavaScript. Bei ersten Aufruf wird der Skriptblock
erzeugt und dann sofort ausgeführt. Dies führt zum Senden des Formulars, was
PHP wiederum wie beschrieben erkennt.
Ist JavaScript nicht vorhanden, verbleibt die Seite im ersten Zustand, entsprechend
ist die Variable $_POST['timeField'] niemals gesetzt. Darauf zielen die Abfragen
mit der Funktion isset ab, die testet, ob eine Variable initialisiert wurde.
3.8 Formatieren und Ausgeben
Neben Datumsangaben sind meist Zeichenketten und Zahlen zu formatieren. Vor
allem mehrsprachige Webseiten profitieren von den Möglichkeiten, die PHP bietet.
Zahlen formatieren
Eine wichtige Formatierfunktion ist number_format. Damit lassen sich Zahlen –
intern immer im englischen Format vorliegend – in das im deutschsprachigen
Sprachraum übliche Format umwandeln. Das folgende Skript zeigt die Anwendung:
Listing 3.21: NumberFormat.php: Zahlen für eine deutsche Website formatieren
$z1 = 100000;
$z2 = 2.67;
$z3 = $z1 / $z2;
echo "$z3 ";
echo number_format($z3, 2, ',', '.');
Die vier Parameter der Funktion number_format haben folgende Bedeutung:
1. Zahl, die formatiert werden soll.
2. Anzahl der Dezimalstellen, auf die gerundet werden soll.
119

120
Daten verarbeiten
3. Zeichen für das Dezimaltrennzeichen (deutsch: Komma, englisch: Punkt).
4. Zeichen für das Tausendertrennzeichen (optional, deutsch: Punkt, englisch:
Komma).
Abbildung 3.12:
Unformatierte (oben) und formatierte (unten) Zahl im Vergleich
Umwandeln, Anpassen und Ausgeben
Mehr Möglichkeiten der Formatierung bieten die rund um printf etablierten
Funktionen, die teilweise aus der C-Welt übernommen wurden:
printf
Die Funktion formatiert einen oder mehrere Werte und gibt das Resultat wie
print sofort aus.
sprintf
Die Funktion formatiert einen oder mehrere Werte und gibt das Resultat als
Zeichenkette zurück.
vprintf
Die Funktion formatiert einen oder mehrere Werte aus einem Array und gibt
das Resultat wie print sofort aus.
vsprintf
Die Funktion formatiert einen oder mehrere Werte aus einem Array und gibt
das Resultat als Zeichenkette zurück.
sscanf
Hiermit lässt sich eine Zeichenkette anhand vorhandener Funktionsmuster
durchsuchen und die Fundstellen werden in Variablen abgelegt.
fscanf
Funktioniert wie sscanf, als Eingabe wird aber eine Datei erwartet.
Der Trick bei der Nutzung besteht auch hier, ähnlich wie bei strftime, in der
Nutzung von Formatangaben. Die Eingabewerte werden dann so verändert, dass
sie den Formatangaben entsprechen. Alle hier vorgestellten Funktionen verwenden
denselben Satz an Formaten, der nachfolgend vorgestellt wird.

Die Formatstruktur
Formatieren und Ausgeben
Jede Formatanweisung wird einem Datenwert zugeordnet. Sie beginnt immer mit
dem Prozentzeichen als Sonderzeichen. Soll ein Prozentzeichen ausgegeben werden,
schreibt man %%. Nach dem Prozentzeichen folgen (optional) verschiedene
Formathinweise, die abhängig von der Datenart sind. Zwischen dem Prozentzeichen
und den Formatinstruktionen kann optional ein Verweis auf einen bestimmten
Datenwert stehen, bestehend aus der Argumentnummer und einem Backslash.
Alle Funktionen erlauben die Angabe mehrerer Datenwerte, entweder als Parameterkette
oder als Array. Der Verweis auf einen bestimmten Parameter erhöht die
Flexibilität.
Am Ende steht dann eine Instruktion, die die Art der Formatierung bestimmt:
b
Das Argument wird als ganze Zahl betrachtet und als Binär-Wert ausgegeben.
c
Das Argument wird als ganze Zahl betrachtet und das entsprechende ASCII-
Zeichen wird ausgegeben.
d
Das Argument wird als ganze Zahl betrachtet und ein Dezimalwert (mit Vorzeichen)
wird ausgegeben.
u
Das Argument wird als ganze Zahl betrachtet und ein Dezimalwert (ohne Vorzeichen)
wird ausgegeben.
f
Das Argument wird als float angesehen und eine Fließkomma-Zahl wird ausgegeben.
o
Das Argument wird als ganze Zahl betrachtet und als Oktalzahl ausgegeben.
s
Das Argument wird als Zeichenkette betrachtet und unverändert ausgegeben.
x
Das Argument wird als ganze Zahl betrachtet und als Hexadezimal-Wert ausgegeben
(mit Kleinbuchstaben für die Hex-Zeichen »a« bis »f«).
121

122
Daten verarbeiten
X
Das Argument wird als ganze Zahl betrachtet und als Hexadezimal-Wert ausgegeben
(mit Großbuchstaben für die Hex-Zeichen »A« bis »F«).
Alles zusammen sieht dann beispielsweise folgendermaßen aus:
%3\s
Diese Zeichenfolge gibt das dritte Argument (3\) als Zeichenkette (s) aus.
%d
Diese Zeichenfolge gibt das in der Liste nächste Argument als Dezimalzahl
aus.
%082d
Auch dies formatiert eine Dezimalzahl. Die drei Zeichen haben hier folgende
Bedeutung:
1. Füllwert, entweder ein Leerzeichen, die Zahl 0 oder ein beliebiges, von
einem Apostroph ’ eingeleitetes Zeichen
2. Die Anzahl der Stellen vor dem Dezimaltrennzeichen, auf die aufgefüllt
wird.
3. Die Anzahl der Stellen nach dem Dezimaltrennzeichen.
%4\’_-10s
Dieses Format formatiert eine Zeichenkette linksbündig (das macht das
Minuszeichen, rechtsbündig ist der Standard), die das vierte Argument der
Parameterkette (4\) nutzt. Zum Auffüllen wird der Unterstrich benutzt (’_), der
die Zeichenkette auf zehn (10) Zeichen auffüllt. »s« definiert den Datenwert
als Zeichenkette.
Die Beispiele und ihre Wirkung können Sie im folgenden Listing sehen:
Listing 3.22: FormatPrintf.php – Verschiedene Formatierungen
$s1 = "Markt+Technik";
$s2 = 34.90;
echo "$z3 ";
printf("Drittes Argument, Zeichenkette: %3\$s
Nächstes Argument, Zahl: %d
Aufgefüllte 4. Zeichenkette: %4\$'_-10s
Nächstes Argument, Zahl: %08.2f ",
$s2,
$s2,

Formatieren und Ausgeben
$s1,
'16%');
Bei der Auswahl der passenden Werte gilt im Beispiel folgende Zuordnung:
\3 und \4 deuten klar auf den passenden Wert hier: \3 erhält $s1, \4 das Literal
'16%'.
Die übrigen Formate haben keine Präferenzen zu einem spezifischen Wert
und suchen deshalb die Argumente vom ersten beginnend ab: $d erhält $s2
und das letzte Format den zweiten Wert, der ebenfalls $s2 enthält.
Für die Generierung von Farbwerten in HTML lässt sich das Formatzeichen »X«
sehr gut nutzen. Wichtig ist hier, die Anzahl der Stellen mit 2 vorzugeben.
Andernfalls würden kleine Werte (unter 16) lediglich eine Stelle belegen und der
Farbcode damit nicht korrekt aufgebaut werden. Ein Füllzeichen muss nicht angegeben
werden, für Zahlen ist die 0 das voreingestellte Zeichen.
Listing 3.23: FormatSPrintf.php – Formatierung von HTML-Farbwerten
$r = 134;
$g = 211;
$b = 56;
$code = sprintf("#%2X%2X%2X", $r, $g, $b);
echo

124
Daten verarbeiten
Werte erkennen
Die Funktionen sscanf und fscanf drehen den Vorgang um. Erwartet wird eine
Zeichenkette, die bestimmte Wertfragmente enthält. Daraus wird dann der Wert
extrahiert und an eine bereitgestellte Variable übergeben. Das letzte Beispiel eignet
sich besonders gut zur »Umkehrung«:
Listing 3.24: FormatScanf.php – Daten aus einer Zeichenkette extrahieren
$r = 134;
$g = 211;
$b = 56;
$code = sprintf("#%2X%2X%2X", $r, $g, $b);
echo "Die Farbwerte für $code sind: ";
list($rr, $gg, $bb) = sscanf($code, "#%2X%2X%2X");
echo "R = $rr, G = $gg, B = $bb";
Die Ausgabe zeigt, dass alle Farbwerte korrekt erkannt wurden. Trickreich ist hier
die Übernahme des von sscanf erzeugten Arrays mit list in die drei erwarteten
Variablen. Mehr Informationen zu Array folgen im Abschnitt 5.1 »Datenfelder im
Einsatz: Arrays« ab Seite 182.
Allerdings kann sscanf nicht erkennen, wenn die gesuchte Zeichenfolge in einer
anderen eingebettet ist. Dafür kommen nur reguläre Ausdrücke in Frage, die mehr
Formatangaben erlauben, dafür aber ungleich komplexer sind.
3.9 Referenz
Abbildung 3.14:
Die einzelnen dezimalen Farbwerte
wurden aus der hexadezimalen
Folge extrahiert
Dieser Abschnitt enthält eine Übersicht aller in diesem Kapitel behandelten Funktionen
in tabellarischer Form.

Zeichenketten-Funktionen
Referenz
Insgesamt kennt PHP5 knapp 90 Zeichenkettenfunktionen. Es ist sinnvoll, sich
dieser schieren Fülle strukturiert zu nähern. Zuerst einmal kann man Gruppen bilden,
um die Funktionsnamen den bereits erwähnten typischen Operationen zuzuordnen.
Sie finden dann weitaus schneller die passende Funktion.
Funktion Bedeutung
strpos Sucht eine Zeichenfolge in einer anderen und gibt die Position der
Fundstelle zurück. Berücksichtigt Groß- und Kleinschreibung.
stripos Sucht eine Zeichenfolge in einer anderen und gibt die Position der
Fundstelle zurück. Beachtet Groß- und Kleinschreibung nicht.
strrpos Sucht das letzte Auftreten einer Zeichenfolge und gibt die Position
der Fundstelle zurück. Berücksichtigt Groß- und Kleinschreibung.
strchr Sucht ein einzelnes Zeichen in einer Zeichenfolge und gibt den Rest
der Zeichenkette ab der Fundstelle zurück.
strrchr Sucht das letzte Auftreten eines Zeichens in einer Zeichenfolge und
gibt den Rest der Zeichenkette ab der Fundstelle zurück.
strstr Sucht eine Zeichenfolge in einer anderen und gibt den Rest der Zeichenfolge
ab der Fundstelle zurück. Berücksichtigt Groß- und Kleinschreibung.
stristr Sucht eine Zeichenfolge in einer anderen und gibt den Rest der Zeichenfolge
ab der Fundstelle zurück. Beachtet Groß- und Kleinschreibung
nicht.
strcmp Vergleicht zwei Zeichenfolgen.
strspn Ermittelt die Anzahl der Zeichen, die bei zwei zu vergleichenden
Zeichenfolgen übereinstimmen.
strcspn Ermittelt die Anzahl der Zeichen, die bei zwei zu vergleichenden
Zeichenfolgen nicht übereinstimmen.
strcasecmp Vergleicht zwei Zeichenfolgen auf binärer Basis. Beachtet Groß- und
Kleinschreibung.
Tabelle 3.8: Zeichenkettenfunktionen zum Vergleichen, Suchen und Ersetzen
125

126
Daten verarbeiten
Funktion Bedeutung
strnatcasecmp Vergleicht zwei Zeichenfolgen auf binärer Basis und berücksichtigt
die »natürliche« Erscheinungsform. Beachtet Groß- und Kleinschreibung.
strnatcmp Vergleicht zwei Zeichenfolgen auf binärer Basis und berücksichtigt
die »natürliche« Erscheinungsform. Beachtet Groß- und Kleinschreibung
nicht.
strncasecmp Vergleicht nur eine gegebene Anzahl von Zeichen zweier Zeichenfolgen
und beachtet Groß- und Kleinschreibung dabei nicht.
strncmp Vergleicht nur eine gegebene Anzahl von Zeichen zweier Zeichenfolgen
und beachtet Groß- und Kleinschreibung dabei.
str_replace Ersetzt Zeichen in einer Zeichenfolge durch andere Zeichen oder
löscht sie
str_ireplace Wie str_replace, beachtet aber Groß- und Kleinschreibung nicht.
substr_replace Wie str_replace, jedoch kann der Suchbereich eingeschränkt werden.
Tabelle 3.8: Zeichenkettenfunktionen zum Vergleichen, Suchen und Ersetzen (Forts.)
Funktion Bedeutung
strlen Anzahl der Zeichen
crc32 Prüfsumme über eine Zeichenfolge
count_chars Häufigkeitsanalyse über in der Zeichenfolge enthaltenen Zeichen
str_word_count Häufigkeitsanalyse über die Wörter eines Textes
md5 MD5-Hash (Message Digest 5, eine Art Prüfsumme) einer Zeichenfolge
sha1 SHA1-Hash, eine andere Art Prüfsumme
similar_text Diese Funktion berechnet die Ähnlichkeit zweier Zeichenketten als
Prozentwert.
Tabelle 3.9: Zeichenkettenfunktionen zum Ermitteln von Eigenschaften

Funktion Bedeutung
soundex Berechnet die Lautähnlichkeit von Zeichenkette
Referenz
levenshtein Berechnet die Lautähnlichkeit nach dem Levenshtein-Algorithmus
metaphone Lautähnlichkeit analog zu saindex, aber unter Berücksichtigung der
Grundregeln der englichen Sprache.
substr_count Ermittelt, wie oft eine Zeichenfolge in einer anderen steckt
Tabelle 3.9: Zeichenkettenfunktionen zum Ermitteln von Eigenschaften (Forts.)
Funktion Bedeutung
substr Gibt einen Teil einer Zeichenkette zurück.
trim, chop Entfernt Leerzeichen und Zeilenumbrüche vom Anfang und vom
Ende.
ltrim Entfernt Leerzeichen und Zeilenumbrüche vom Anfang.
rtrim Entfernt Leerzeichen und Zeilenumbrüche vom Ende.
ucfirst Macht den ersten Buchstaben einer Zeichenkette zum Großbuchstaben.
ucwords Macht den ersten Buchstaben jedes Wortes zum Großbuchstaben.
strtolower Verwandelt alle Buchstaben in Kleinbuchstaben.
strtoupper Verwandelt alle Buchstaben in Großbuchstaben.
wordwrap Bricht längeren Text durch Einfügen von Zeilenumbrüchen um.
strtr Tauscht einzelne Zeichen auf Basis einer Austauschtabelle aus.
strtok Zerlegt eine Zeichenfolge durch sukzessive Aufrufe in Teile.
strrev Dreht eine Zeichenfolge um.
tr_shuffle Bringt die Zeichen mittels Zufallsgenerator durcheinander.
strip_tags Entfernt HTML-Tags aus einer Zeichenfolge.
chunk_split Teilt eine Zeichenkette in Abschnitte gleicher Größe.
Tabelle 3.10: Zeichenkettenfunktionen zur Auswahl einer Teilzeichenkette und andere
Umwandlungsoperationen
127

128
Daten verarbeiten
Funktion Bedeutung
str_rot13 Führt eine primitive Kodierung nach ROT13 aus.
str_repeat Wiederholt eine Zeichenkette mehrfach und gibt die resultierende
Zeichenfolge zurück.
str_pad Füllt eine Zeichenfolge links oder rechts mit Füllzeichen auf.
Tabelle 3.10: Zeichenkettenfunktionen zur Auswahl einer Teilzeichenkette und andere
Umwandlungsoperationen (Forts.)
Funktion Bedeutung
addslashes,
addcslashes
stripslashes,
stripcslashes
Fügt Backslashes hinzu.
Entfernt Backslashes.
Tabelle 3.11: Zeichenkettenfunktionen zur Behandlung einzelner Zeichen
Funktion Bedeutung
chr Gibt das dem Zeichencode entsprechende Zeichen zurück.
ord Gibt den Zeichencode zum angegebenen Zeichen zurück.
Tabelle 3.12: Zeichenkettenfunktionen zum Ermitteln von bestimmten Zeichen mit besonderer
Bedeutung
Funktion Bedeutung
bin2hex Wandelt binäre Daten in ihre hexadezimale Form um
html_entity_decode Wandelt HTML-Entitäten in Zeichen um
html_entities Wandelt alle Sonderzeichen in HTML-Entitäten um
html_specialchars Wandelt nur XML-Spezialzeichen in HTML-Entitäten um
Tabelle 3.13: Zeichenkettenfunktionen zum Umwandeln in einen anderen Datentyp und
HTML-abhängige Funktionen

Funktion Bedeutung
setlocale Setzt eine bestimmte Lokalisierung
number_format Formatiert Zahlen
Funktionen für reguläre Ausdrücke
Referenz Ausgabe- und Datumsfunktionen
Referenz
money_format Formatiert Währungsangaben, ist jedoch nur auf Linux verfügbar
localeconv Ermittelt die aktuellen Formatierbedingungen für Zahlen
Tabelle 3.14: Zeichenkettenfunktionen zum sprach- oder landesabhängigen Formatieren
Funktion Bedeutung
preg_match Ermittelt ein zutreffendes Suchmuster
preg_match_all Ermittelt alle zutreffendes Suchmuster
preg_grep Durchsucht ein Array nach einem Suchmuster und filtert Fundstellen
preg_split Teilt eine Zeichenkette an einem Suchmuster und gibt jede Fundstelle
al Element eines Arrays zurück
Tabelle 3.15: Funktionen zum Suchen und Ersetzen mittels regulärer Ausdrücke
Funktion Bedeutung
date Formatiert eine Datumsangabe.
strftime Formatiert eine Datumsangabe in Abhängigkeit von der Lokalisierung.
printf Formatiert beliebige Werte und gibt sie sofort aus.
sprintf Formatiert beliebige Werte und gibt sie als Zeichenkette zurück.
Tabelle 3.16: Funktionen zum Erzeugen, Erkennen und Formatieren von Datums-, Zahlen-
und Zeichenkettenwerten
129

130
Daten verarbeiten
Funktion Bedeutung
vprintf Formatiert beliebige Werte aus einem Array und gibt sie sofort aus.
vsprintf Formatiert beliebige Werte aus einem Array und gibt sie als Zeichenkette
zurück.
sscanf Extrahiert nach Formatangaben Werte aus einer Zeichenkette.
fscanf Extrahiert nach Formatangaben Werte aus einer Datei.
Tabelle 3.16: Funktionen zum Erzeugen, Erkennen und Formatieren von Datums-, Zahlen-
und Zeichenkettenwerten (Forts.)
3.10 Kontrollfragen
1. Was ist ein Literal?
2. Wie werden Konstanten definiert?
3. Wozu werden reguläre Ausdrücke eingesetzt?
4. Schreiben Sie ein Skript, dass anhand mehrere Parameter ein span-Tag mit korrekter
hexadezimaler Angabe der Vordergrund- und Hintergrundfarbe mit Hilfe
des style-Attributes erstellt und ausgibt. Tipp: Verwenden Sie printf.

Programmieren
4

132
Programmieren
Jetzt geht es richtig los. Zur richtigen Programmierung benötigen Sie zwangsläufig
Anweisungen, die den Programmfluss steuern. Dieses Kapitel stellt alle Befehle
vor, die dies in PHP erledigen. Wer bereits mit PHP 4 vertraut ist, kann diesen Tag
überspringen, denn PHP5 bietet hier nichts Neues. Alle Flussbefehle, die im
Zusammenhang mit den neuen objektorientierten Eigenschaften eingeführt wurden,
werden am Tag 8 behandelt.
4.1 Verzweigungen
Verzweigungen steuern den Programmfluss. PHP lehnt sich hier stark an die Syntax
der Programmiersprache C an. Auf der gleich Basis sind auch die Befehle von
Sprachen wie JavaScript, Java, C++ und C# entstanden.
Einfache Verzweigungen mit if
Der Befehl if dient der Programmierung einer einfachen Verzweigung. Damit
können Programmteile in Abhängigkeit von einer Bedingung ausgeführt werden.
Als Bedingung verwendet man einen Ausdruck, der einen Booleschen Wert
zurückgibt – also entweder Wahr (TRUE) oder Falsch (FALSE). Zur Verknüpfung
von solchen Ausdrücken gibt es verschiedene Operatoren, die in der Einführung
bereits vorgestellt wurden.
Aufbau von Ausdrücken
Da PHP praktisch über ein sehr schwaches Typkonzept verfügt, werden oft intern
Typumwandlungen vorgenommen. Da Bedingungen Boolesche Werte benötigen,
konvertiert PHP5 hier eventuell vorhandene andere Datentypen einfach. Das entsprechende
Verhalten sollten Sie kennen, um den gewünschten Effekt auch tatsächlich
zu erzielen.
Ausdrücke bestehen generell aus zwei Arten von Operatoren. So genannte Vergleichsoperatoren
vergleichen zwei Werte, entweder zwei Variablen oder eine
Variable und eine Konstante. Zu den Vergleichsoperatoren gehören >, =,

Verzweigungen
Denken Sie daran, dass der Operator »gleich« aus zwei Gleichheitszeichen
besteht!
$a > 3
45
Bei der Erstellung von logischen Ausdrücken ist es wichtig zu wissen, dass diese
eine so genannte Assoziativität besitzen, die die Rangfolge bei der Verarbeitung
bestimmt. Wenn diese intern festgelegte Reihenfolge nicht passt, setzen Sie einfach
Klammern.
Assoziativität Rangfolge Operator
1. (höchster Rang) Links ,
2. Links or
3. Links xor
Tabelle 4.1: Rangfolge und Assoziativität von Operatoren
133

134
Programmieren
Assoziativität Rangfolge Operator
4. Links and
5. Rechts print
6. Rechts = += -= *= /= .= %= &= |= ^= =
7. Links ? :
8. Links ||
9. Links &&
10. Links |
11. Links ^
12. Links &
13. Keine == != === !==
14. Keine < >=
15. Links >
16. Links + – .
17. Links * / %
18. Rechts ! ~ ++ -- (int) (float) (string) (array) (object) @
19. Rechts [
20. (niedrigster Rang) Keine new
Tabelle 4.1: Rangfolge und Assoziativität von Operatoren (Forts.)
In der Praxis bedeutet die Rangfolge »Links«, dass beispielsweise im folgenden
Ausdruck der linke Teil zuerst ausgeführt wird, weil der Operator || Links-assoziativ
ist:
$b == 8 || $c == $d
Wird dagegen eine Typumwandlung mit (float) durchgeführt, wird der Ausdruck
rechts vom Operator zuerst ausgeführt:
(float) $a = 3

Verzweigungen
Weil auch der Operator = Rechts-assoziativ ist, wird beim letzten Beispiel die Auswertung
mit der 3 begonnen, dann erfolgt die Zuweisung an die Variable $a und
erst dann wird $a in eine Gleitkommazahl umgewandelt.
Keine Assoziativität bei den Operatoren == und deren Verwandten heißt, dass es
für das Ergebnis keinen Unterschied ergibt, ob ein Teilausdruck links oder rechts
steht. Dies kann ausgenutzt werden, um einen typischen Fehler zu vermeiden, der
häufig passiert: Die Verwechslung von = und ==. Schreiben Sie nämlich in einem
if-Befehl nur ein einfaches Gleichheitszeichen, so wird PHP als Ergebnis der
Zuweisung den Inhalt zurückgeben und dann diesen Wert automatisch konvertieren.
Sie erhalten also keine Fehlermeldung, wohl aber einen falschen Programmfluss.
Betrachten Sie folgenden Code:
$a = 23;
if ($a = 23)
{
//
}
Hier wird der Variablen $a in der Bedingung ein zweites Mal der Wert 23 zugewiesen
und dann dem if-Befehl als Ergebnis des Ausdrucks übergeben. PHP konvertiert
nun die 23 in TRUE (0 entspräche FALSE, alles andere ist TRUE). Um derartige
Tippfehler zu vermeiden, vertauscht man die Operanden:
$a = 23;
if (23 = $a)
{
//
}
Würde korrekt 23 == $a geschrieben werden, funktionierte der Ausdruck wie
erwartet, denn bei == spielt die Rangfolge keine Rolle. 23 = $a misslingt allerdings,
weil zuerst der rechte Ausdruck ausgewertet wird (gelingt noch) und dann der
linke, was die Zuweisung einer Variablen zu einem Literal bedeuten würde – ein
klarer Fall für einen Syntaxfehler.
Eng verbunden mit der Assoziativität ist auch eine Optimierungseigenschaft von
PHP. Manche Ausdrücke müssen nämlich nicht vollständig ausgewertet werden:
$a = 3;
if ($a == 3 || $b == 7)
Bei dieser Verknüpfung erkennt PHP zuerst einen Oder-verknüpften Ausdruck.
Wenn der linke Zweig ($a == 3) wahr ist, dann wird der gesamte Ausdruck zwangs-
135

136
Programmieren
läufig wahr sein. Es ist also nicht notwendig, den rechten Teil abzuarbeiten, denn
dies würde nie etwas am Ergebnis ändern. Das spart Rechenzeit und verbessert das
Laufzeitverhalten.
Anstatt einer Variablen kann jedoch auch eine Funktion aufgerufen werden:
if (TestFunction1() == 3 || TestFunction2() == 7)
Nun kann es im Programmkontext außerdem erforderlich sein, dass beide Testfunktionen
tatsächlich aufgerufen werden, beispielsweise weil sie anderweitige für
den Programmfluss erforderliche Aktionen ausführen, unabhängig vom jeweiligen
Rückgabewert. Die Optimierung würde aber immer dann die Ausführung von
TestFunction2 verhindern, wenn TestFunction1 den Wert TRUE zurückgibt.
Es gibt zwei Lösungen für das Problem. Zum einen ist diese Art der Programmierung
prinzipiell kein guter Stil. Man spricht von so genannten Nebeneffekten, d.h.
zwei nicht in direktem Zusammenhang stehende Programmteile beeinflussen sich
in Abhängigkeit von konkreten Daten gegenseitig. Das führt in der Praxis zu
schwer beherrschbaren und kaum nachvollziehbaren Programmfehlern. Die erste
Lösung besteht also darin, diese Art der Programmierung zu vermeiden:
$result1 = TestFunction1();
$result2 = TestFunction2();
if ($result1 == 3 || $result2 == 7)
Hier wird sichergestellt, dass beide Testfunktionen aufgerufen werden. Anschließend
findet die Überprüfung statt, wobei es keine Rolle spielt, ob mit oder ohne
Optimierung gearbeitet wird.
Die zweite Lösung heißt PHP und verwendet Operatoren, die die Optimierung
einfach unterdrücken. Dies ist immer dann angebracht, wenn Nebeneffekte ausgeschlossen
werden sollen und die Abfrage der Teilausdrücke nur unnötige Schreibarbeit
verursachen würde.
Alternative Zweige mit else
Der Block, der hinter if folgt, wird immer dann ausgeführt, wenn die Bedingung
Wahr ist. Oft sind jedoch Aktionen auszuführen, wenn die Bedingung nicht erfüllt
ist. Dazu wird ein alternativer Zweig geschrieben, der mit dem Schlüsselwort else
einzuleiten ist. Auch hier gilt die Regel, dass mehrere Befehle nach else als Block
zusammengefasst werden müssen.

Listing 4.2: Else.php – Alternativer Verarbeitungszweig
Verzweigungen
Zweige mit if und else können beliebig geschachtelt werden, um umfangreiche
Bedingungen zu testen.
Mehrfachverzweigungen mit switch
Wenn sich in einem Skript mehrere Auswertungen mit if aneinanderreihen, kann
man schnell die Übersicht verlieren. Da man auch deutlich häufiger auf Gleichheit
testet als mit anderen Operatoren, gibt einen speziellen Befehl dafür: switch.
switch verhält sich analog zu C, fällt allerdings immer von Zweig zu Zweig durch,
wobei jeder Zweig durch das Schlüsselwort case angezeigt wird. Jeder Zweig muss
deshalb explizit mit dem Schlüsselwort break abgeschlossen werden. Der Code
hinter den einzelnen case-Zweigen muss nicht mit einem Blockkennzeichen
umschlossen werden, weil hier immer alles bis zum nächsten break oder dem
Ende von switch abgearbeitet wird.
Ein einfaches switch
Das folgende Skript zeigt eine einfache Anwendung von switch:
Listing 4.3: Switch.php – Mehrfachverzweigungen sind sehr kompakt
$hour = 13;
echo "Tagesabschnitt für Stunde $hour: ";
switch ($hour)
{
case 1:
137

}
138
Programmieren
echo "Nachts";
break;
case 7:
echo "Morgens";
break;
case 9:
echo "Vormittags";
break;
case 13:
echo "Mittags";
break;
case 16:
echo "Nachmittags";
break;
default:
echo "Unbekannte Stunde";
Die Testvariable ($hour) wird in den Kopf der Anweisung geschrieben. PHP vergleicht
diese dann mit jedem Wert der case-Zweige und führt den Zweig aus, für
den Gleichheit der Werte festgestellt wurde. Der Vergleich nutzt die Stärke des ==-
Operators, nicht von ===. Das bedeutet, dass case "13" anstatt case 13 im gezeigten
Beispiel als Gleich erkannt werden würde.
Die break-Anweisungen sind erforderlich, damit der betroffene Zweig wieder verlassen
wird, andernfalls wird einfach der Code des nächsten Zweiges ausgeführt,
ohne dass dort eine erneute Prüfung stattfindet.
Falls kein Vergleich zutrifft, wird ein default-Zweig gesucht und – wenn vorhanden
– ausgeführt. Ist ein solcher Zweig nicht vorhanden, wird mit dem Code nach
dem switch-Block fortgesetzt.
Falls die Prüfung mehrerer Werte denselben Code erfordert, kann man case-
Zweige aneinander setzen, wie es das folgende Beispiel zeigt:
Listing 4.4: switchcase2.php – Mehrfache case-Zweige
$hour = 13;
echo "Tagesabschnitt für Stunde $hour: ";
switch ($hour)
{
case 1:
case 2:

}
case 3:
case 4:
case 5:
echo "Nachts";
break;
case 6:
case 7:
case 8:
echo "Morgens";
break;
case 9:
case 10:
case 11:
echo "Vormittags";
break;
case 12:
case 13:
case 14:
echo "Mittags";
break;
case 15:
case 16:
case 17:
echo "Nachmittags";
break;
default:
echo "Unbekannte Stunde";
Verzweigungen
Beachten Sie hier, dass die Aufeinanderfolge von case nicht bedeutet, dass die
Codeausführung am nächsten Zweig fortgesetzt wird, wie es bei fehlendem break
der Fall ist. Betrachten Sie die folgende Sequenz:
case 15:
case 16:
case 17:
Mit if könnte man dafür folgendes schreiben:
if ($hour == 15 or $hour == 16 or $hour == 17)
Der gesamte Block verhält sich darüber hinaus wie ein allein stehendes case.
139

140
Programmieren
Komplexe Ausdrücke mit switch auswerten
Mit switch lassen sich in PHP auch komplexe Ausdrücke auswerten. Das unterscheidet
PHP von einigen anderen Sprachen, die nur strenge Vergleiche konstanter
Werte zulassen. Mit der Möglichkeit, als Vergleichswerte im case-Zweig auch
Ausdrücke einsetzen zu können, kann man switch deutlich flexibler verwenden.
Hier zeigt sich einer der wenigen Vorteile eines Interpreters gegenüber kompilierenden
Sprachen.
Intern vergleicht PHP freilich auch hier nur auf der Basis eines Booleschen Ausdrucks.
Das Resultat eines Zweiges muss mit einem entsprechenden Gegenstück
verknüpft werden. Dazu setzt man einfach im Kopf eine der Konstanten TRUE oder
FALSE ein und in den case-Zweigen die Ausdrücke:
Listing 4.5: switchcaseplus.php – Variable Nutzung Boolescher Ausdrücke
$hour = 13;
echo "Tagesabschnitt für Stunde $hour: ";
switch (TRUE)
{
case $hour >= 0 and $hour < 5 or $hour > 22:
echo "Nachts";
break;
case $hour >= 5 and $hour < 8:
echo "Morgens";
break;
case $hour >= 8 and $hour < 11:
echo "Vormittags";
break;
case $hour >= 11 and $hour < 13:
echo "Mittags";
break;
case $hour >= 13 and $hour < 17:
echo "Nachmittags";
break;
case $hour >= 17 and $hour < 22:
echo "Abends";
break;
}
PHP löst hier intern zuerst die Booleschen Ausdrücke auf und ermittelt den Wert
TRUE oder FALSE. Dann vergleicht er TRUE==TRUE oder TRUE==FALSE und springt in

Schleifen erstellen
den ersten passenden Zweig. Man muss hier aufpassen, dass immer nur ein Zweig
gefunden wird, auch wenn ein danach liegender ebenso zutreffend wäre. switch
kann immer nur einen Zweig ausführen. Das break wegzulassen ist keine Lösung,
denn dann fällt der Programmablauf durch alle folgenden Zweige bis zum nächsten
break durch. Die Auswertung eines weiteren case-Zweiges erfolgt nicht.
4.2 Schleifen erstellen
PHP verfügt über die in allen gängigen Programmiersprachen verfügbaren Schleifenanweisungen:
do
while
for
do und while sind eng miteinander verwandt und bilden universelle Schleifen mit
einer Abbruchbedingung (do) bzw. einer Eintrittsbedingung (while). for ist eine
Zählschleife, die numerische Werte abzählen kann.
Gemeinsamkeiten aller Schleifenanweisungen
Alle Schleifen weisen einige Gemeinsamkeiten auf, die sehr praktisch sind. Standardmäßig
werden Schleifen solange durchlaufen, bis die Auswertung der Prüfbedingung
einen erneuten Durchlauf verhindert. Dies kann bei falscher
Programmierung zu Endlosschleifen führen. Endlosschleifen sind meist unerwünscht.
Mit PHP sind solche Programmierfehler zwar lästig, aber nicht wirklich
kritisch. Denn standardmäßig verfügt PHP über eine Skriptlaufzeit von 30 Sekunden.
Ist das Skript dann nicht beendet – egal ob es an einem Fehler hängt oder in
einer Schleife feststeckt –, wird es abgebrochen.
Der Schleifenablauf lässt sich aber nicht nur allein durch die Bedingung kontrollieren.
Alle Schleifen verfügen über zwei spezielle Schlüsselwörter zur Steuerung,
die grundsätzlich nur zusammen mit if oder (seltener) switch eingesetzt werden:
break
continue
141

142
Programmieren
Mit Hilfe von break wird die Schleife sofort und ohne weitere Prüfung verlassen.
Natürlich muss man davor eine Bedingung schreiben:
if ($hour == 12) break;
Andernfalls würde die Schleife immer abgebrochen werden, unabhängig von der
eigentlichen Schleifenbedingung, was ziemlich sinnlos ist.
Die Anweisung continue dagegen erzwingt eine sofortige Prüfung der Schleifenbedingung
und springt dazu zum Schleifenkopf (bzw. bei do zum Ende). Der Code,
der innerhalb der Schleife nach dem continue steht, wird nicht ausgeführt. Natürlich
muss man auch hier eine Bedingung schreiben:
if ($hour < 12) continue;
Damit werden alle Schleifenkonstrukte sehr flexibel. Zusammen mit der recht einfachen
Definition ergeben sich starke und universelle Anweisungen.
Die Zählschleife for
for bildet eine Zählschleife – im weitesten Sinne. Aufbau und Bedingungen sind
sehr flexibel einsetzbar. Insgesamt besteht der Kopf der for-Schleife aus drei,
jeweils optional verwendbaren, Abschnitten:
1. Initialisierung
2. Laufbedingung
3. Iterationsanweisung
Alle drei Abschnitte ermöglichen die Angabe mehrere Ausdrücke. Wie der Name
»Laufbedingung« bereits andeutet, muss die Bedingung Wahr ergeben, also beim
Eintritt in die Schleife TRUE ergeben. Ist das nicht mehr der Fall, wird die Schleife
beendet. Nach jedem Schleifendurchlauf wird die Iterationsanweisung ausgeführt,
dann erfolgt die Prüfung der Laufbedingung. Die Initialisierung wird nur beim
Schleifeneintritt ausgeführt.
Die grundsätzliche Syntax sieht folgendermaßen aus:
for (Initialisierung; Laufbedingung; Iterationsanweisung)
{
// Code in der Schleife
}

Schleifen erstellen
Um nun mehrere Ausdrücke in einen Abschnitt zu packen, werden diese durch
Kommata getrennt:
for ($i = 0, $k = 2; $k < 5; $i++, $k++)
Beachten Sie hier, dass es sich wirklich um Ausdrücke handeln muss,
die etwas zurückgeben (was genau, ist erstmal egal). Die Anweisung echo
?Hallo for? gibt nichts zurück, sondern produziert eine Ausgabe. Sie
würde deshalb nicht im Kopf der for-Schleife funktionieren.
Solche Konstruktionen sind aber eigentlich sowieso keine gute Idee, weil sie die
Lesbarkeit erschweren und schnell Programmierfehler hervorrufen. Eigentlich ist
for nämlich eine Zählschleife und nicht dazu gedacht, Ausgaben oder Code des
Schleifenkörpers im Kopf aufzunehmen.
Typische Einsatzfälle
Wie bereits erwähnt, ist der Einsatz mit zählbaren Werten typisch für die for-
Schleife. Im einfachsten (und häufigsten) Fall sieht das dann folgendermaßen aus:
Listing 4.6: forloop.php – Die einfachste for-Schleife
$rows = 7;
echo '';
for ($i = 0; $i < $rows; $i++)
{
echo "$i&nbsp;...";
}
echo '';
Es ist dabei sehr typisch, als Startwert 0 zu wählen, und dann die Anzahl der
Durchläufe mit der Formel $laufwert < ENDWERT zu bestimmen. Die gezeigte
Schleife produziert wie erwartet sieben Durchläufe und zählt dabei von null bis
sechs. Der naive Ansatz wäre sicher, hier von eins bis sieben zu zählen, zumal viele
Ausgaben dies auch erwarten. Intern verwendet PHP jedoch – wie viele andere
Sprachen auch – so genannte null-basierte Indizes. Egal ob Arrays, Datenbankabfragen
oder andere zählbare Quellen verwendet werden, fast immer hat der erste
Wert der Reihe den Index 0. Wenn Sie es sich von vornherein angewöhnen, Zählschleifen
null-basiert zu bauen, wird vieles leichter.
143

144
Programmieren
Abbildung 4.1:
Tabelle, mit einer einfachen Zählschleife erzeugt
Die Trennung von Logik und Benutzerschnittstelle gehört zu den elementaren
Richtlinien der praktischen Informationsverarbeitung. PHP bietet hier nur eine
rudimentäre Unterstützung, aber auch im Kleinen lohnt es, das Programmdesign
nach diesem Prinzip auszurichten. Wenn Sie im gezeigten Beispiel tatsächlich
eine Ausgabe der Zählwerte wünschen und diese Ausgabe mit 1 beginnen soll,
ändern sie nicht den Schleifenkopf. Fügen Sie stattdessen eine Berechnung allein
für die Ausgabe ein:
echo "" . ($i + 1) . "&nbsp;...";
Es wäre übrigens ein echter Programmierfehler, folgendes zu schreiben, wenn die
Iterationsanweisung im Schleifenkopf weiter bestehen bleibt:
echo "" . ($i++) . "&nbsp;...";
Diese Version würde den Wert für die Ausgabe zwar um eins erhöhen, zugleich
aber auch den Inhalt der Laufvariablen verändern. Da diese aber ohnehin bei
jedem Durchgang erhöht wird, würde nun jeder Durchlauf deren Wert um zwei
erhöhen. Da sich die Abbruchbedingung nicht geändert hat, wird nur die Hälfte
der Zeilen ausgegeben.
Aus der Beobachtung des Effekts sollten Sie nicht eine tolle Möglichkeit der nachträglichen
Manipulation der Schleifenvariable erkennen. Dies geht zwar, ist aber
einfach nur schlechter Stil. Die Veränderung der Schleifenvariablen ist ein so
genannter Seiteneffekt, der schwer verständlich ist, wenn jemand anderes den
Code liest1 . Seiteneffekte sind schlecht. Vermeiden Sie es unbedingt, die Schleifenvariable
während des Durchlaufs zu manipulieren.
Prüfen Sie sorgfältig, ob die Iterationsanweisung wirklich dazu führt,
dass die Laufbedingung ungültig wird. Andernfalls haben Sie eine Endlosschleife.
Fügen Sie gegebenenfalls ein break mit einer weiteren
Bedingungen ein, um einen Notausstieg zu haben.
1 Jemand anderes sind auch Sie selbst, sechs Monate später!

Schleifen erstellen
Wenn Sie nun Ausgabewerte und Zählwerte gleichzeitig benötigen, bietet es sich
an, den Kopf zu erweitern. Sie vermeiden so strikt die Manipulation der Schleifenvariablen
und profitieren dennoch von der kompakten Schreibweise der for-
Schleife. Das folgende Beispiel ist die vermutlich einfachste und primitivste
Demonstration dieser Technik, die jemals gefunden wurde:
Listing 4.7: forloop2.php – Trennung von Zählung (Logik) und Ausgabe (Benutzerschnittstelle)
$rows = 7;
echo '';
for ($i = 0, $j = 1; $i < $rows; $i++, $j++)
{
echo "$j&nbsp;...";
}
echo '';
Das Beispiel deklariert eine zweite Variable $j, die nur der Ausgabe dient. Diese
lässt sich gefahrlos manipulieren, weil sie keinen Einfluss auf die Laufbedingungen
hat und damit keine Seiteneffekte auslösen kann.
Auch die Ausgabe ließe sich zu guter Letzt noch in den Schleifenkopf verlegen:
Listing 4.8: forloop3.php – Ausgaben im Kopf einer Schleife
$rows = 7;
echo '';
for ($i = 0, $j = 1;
$i < $rows;
$i++, print "$j&nbsp;...", $j++)
{
}
echo '';
Grundsätzlich sollten sich solche Konstrukte auf seltene, einfache Fälle beschränken.
Sie sind schwer lesbar und Erweiterungen verlangen grobe Änderungen, was
eine zusätzliche Fehlerquelle bedeutet.
Beachten Sie außerdem, dass der Befehl echo hier nicht einsetzbar ist. for erwartet
Ausdrücke und echo hat keinen Rückgabewert, was ein Merkmal eines Ausdrucks
ist. Deshalb wird hier print eingesetzt.
145

146
Programmieren
Noch ein anderes Problem macht den Einsatz der letzten Variante weniger empfehlenswert.
Die Reihenfolge der Parameter im Kopf im Abschnitt »Iterationsanweisung«
ist wichtig. Betrachten Sie beispielsweise Folgendes:
$i++, $j++, print "$j&nbsp;..."
Diese Schleife würde nun mit der Ausgabe des Wertes 2 beginnen, denn der Startwert
für $j ist 1 und die erste Erhöhung $j++ findet vor der Ausgabe statt! Das ist
nicht unbedingt sofort erkennbar und deshalb eine weitere, unnötige Fehlerquelle.
Geschachtelte Schleifen
Wie alle Schleifen lässt sich auch for verschachteln. Hier sollte beachtet werden,
dass sich die Laufvariablen auf keinen Fall gegenseitig beeinflussen. Außerdem
multipliziert sich die Anzahl der Durchläufe zur Anzahl der Gesamtdurchläufe.
Hat die äußere Schleife acht Durchläufe und die innere ebenfalls, sind es insgesamt
64. Das klingt trivial, aber bei mehreren Verschachtelungsebenen erreicht
man schnell Skriptlaufzeiten, die deutlich spürbar sind. Zeitkritische Abfragen
haben in Schleifen sowieso nichts verloren, aber in verschachtelten Schleifen können
auch triviale Berechnungen problematisch werden. Denken Sie beispielsweise
an den Aufbau eines Farbrades für RGB-Farben. Statt ein GIF vorzubereiten
möchten Sie es in PHP »life« erstellen. Das wären dann 256 x 256 x 256 Farben;
leicht mit drei Schleifen erzeugbar. Diese drei Schleifen führen zu 16.777.216
Ausgaben. Abgesehen davon, dass die Darstellung wenig hilfreich ist, führt allein
eine Ausgabezeit von 5 ms pro Durchlauf zu einer Skriptlaufzeit von fast 1 Tag!
Speziell für die Problematik Farbrad benötigt man aber so viele Farben nicht. Kein
System kann alle Farben wirklich darstellen. Für das Web benutzt man 216 so
genannte websichere Farben. Diese sind so definiert, dass als hexadezimale Farbwerte
nur die Zahlen 0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF zum Einsatz kommen.
Folgende Lösung nutzt auch verschachtelte Schleifen, führt aber einige Berechnungen
außerhalb durch, um so mit wenigen Durchläufen zum Ergebnis zu kommen:
Listing 4.9: forllopnested.php – Erzeugen eines Farbwählers mit websicheren Farben
$r = 0;
$g = 0;
$b = 0;
// Farben ermitteln

Schleifen erstellen
$WebSafe = array (0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF);
echo '';
for($y = 0; $y < 12; $y++)
{
$b = $WebSafe[$y % 6];
echo '';
for ($x = 0; $x < 18; $x++)
{
$g = $WebSafe[$x % 6];
$r = ($y < 6) ? $WebSafe[$x / 6] : $WebSafe[($x / 6) + 3];
printf('',
$r, $g, $b);
}
echo "";
}
echo '';
Das Skript nutzt ein Array (Datenfeld, siehe dazu Kapitel 5, Arrays, ab Seite 181),
das die möglichen Basiswerte enthält. Dann wird die Farbfläche als Feld mit
18 mal 12 Rechtecken definiert. Die äußere Schleife zählt die Reihen (12), die
innere die Spalten (18). Dies erzeugt insgesamt 216 Durchläufe. Aus dem Wertefeld
muss dann nur noch der richtige Wert entnommen werden, was durch einfache
Modulus-Berechnungen erfolgt und den gewünschten Schachteleffekt
erzeugt, der ähnliche Farben nebeneinander platziert.
Abbildung 4.2:
forloopnested.php: Farbwähler mit sortierten Farben
Die Ausgabe der Farben erfolgt durch Einfärben des Hintergrundes der erzeugten
Tabellenzellen. Die passenden RGB-Werte erzeugt die printf-Funktion, die mit
der Formatanweisung %2X aus einer Dezimalzahl den passenden zweistelligen
Hexwert erzeugt.
147

148
Programmieren
Die Universalschleifen do/while und while
Die Anweisungen do/while und while werden so lange durchlaufen, wie die
Bedingung Wahr (TRUE) ist. Als Bedingung wird ein beliebiger Boolescher Ausdruck
eingesetzt. Die grundsätzliche Syntax sieht folgendermaßen aus:
while (Bedingung)
{
// Code, der immer wieder ausgeführt wird
}
do funktioniert ebenso, nur erfolgt die Prüfung erst am Ende:
do
{
// Code, der immer wieder ausgeführt wird
} while (Bedingung)
do wird immer dann eingesetzt, wenn sichergestellt werden muss, dass der Inhalt
mindestens einmal durchlaufen wird. Das ist der Fall, weil die Prüfung – wie der
Schleifenkörper suggeriert – erst am Ende erfolgt. Dies ist freilich nicht mehr der
Fall, wenn vorher ein break eingesetzt wird.
Mit dem Training durch die for-Schleifen wird der Einsatz von while sehr einfach.
Das folgende Beispiel zeigt eine fortgeschrittene Version des Farbwählers,
diesmal nicht mit blockweiser, sondern fortlaufender Farbanordnung:
Listing 4.10: while.php – Verschachtelte while-Schleifen zum Aufbau eines Farbwählers
$r = 0;
$g = 0;
$b = 0;
$ContR = array (0xCC, 0x66, 0x00, 0xFF, 0x99, 0x33);
$ContG = array (0xFF, 0xCC, 0x99, 0x66, 0x33, 0x00);
$ContG = array_merge($ContG, array_reverse($ContG));
$ContB = array_merge($ContG, array_reverse($ContG));
echo '';
$y = 0;
while($y < 12)
{
$g = $ContG[$y++];
echo '';
$x = 0;
while($x < 18)

{
$r = $ContR[($x / 6) + (($y < 6) ? 0 : 3)];
$b = $ContB[$x++];
printf('',
$r, $g, $b);
}
echo "";
}
echo '';
Schleifen erstellen
Die Funktionen array, array_merge und array_reverse werden im Kapitel 3
Arrays ab Seite 73 vorgestellt. Sie bauen wieder passende Datenfelder aus den
Farbwerten 0x00, 0x33, 0x66, 0x99, 0xCC und 0xFF auf. Die beiden while-Schleifen
durchlaufen dann die Werte 0 – 11 (12 Reihen) bzw. 0 – 17 (18 Spalten) und
erzeugen so das Muster. Die Ausgabe findet mit einer printf-Funktion statt, die
die Darstellung der von HTML benötigten RGB-Werte übernimmt. Die Erhöhung
der Schleifenwerte findet in der Abfrage der Arrays statt:
$g = $ContG[$y++];
Das ist sehr kompakt und einfach. Wenn Sie es besser lesbar mögen, kann man
auch folgendes schreiben:
$g = $ContG[$y];
$y++ ;
Falls Sie $y anders als zur Zählung verwenden, müssen Sie die Erhöhung (oder
jede andere Änderung) ohnehin so platzieren, dass die Änderung erst am Ende der
Schleife erfolgt.
Abbildung 4.3:
Verschachtelte Schleifen wurden zum Erzeugen
dieser Farbfläche benutzt
149

150
Programmieren
4.3 Benutzerdefinierte Funktionen
Mit Hilfe des Schlüsselwortes function lassen sich eigene Funktionen definieren.
Da man einer Funktion Parameter übergeben kann, gibt es die Möglichkeit, erforderliche
und optionale Parameter zu deklarieren. Da Parameter auch wegfallen
oder in beliebiger Menge eingesetzt werden können, gibt es noch eine Reihe von
Hilfsfunktionen in PHP, die dem Umgang mit Parametern dienen. Funktionsdefinitionen,
wie sie hier vorgestellt werden, finden auch Eingang in die Klassendefinition.
Dort heißen sie dann Methoden. Die hier vorgestellten Techniken sind also
recht allgemeingültig.
Funktionen definieren
Funktionen kennen Sie bereits – praktisch besteht PHP aus Hunderten Funktionen.
Diesen eingebauten Funktionen kann man leicht eigene hinzufügen und
im Skript verwenden. Das ist praktisch, um größere Skripte modular aufzubauen,
Code leichter wieder verwenden zu können und ein und denselben Ablauf mit
verschiedenen Daten auszuführen.
Die Funktionsdefinition
Funktionen werden durch das Schlüsselwort function definiert. Die Definition
umfasst einen Funktionskopf, der Name und Parameter definiert. Diese so
genannte Signatur der Funktion bestimmt, wie die Funktion später aufgerufen
wird. Im einfachsten Fall wird nichts übergeben, wie das folgende Beispiel zeigt:
Listing 4.11: functionsimple.php – Eine einfache Funktionsdefinition
function PrintTableRow()
{
echo 'Reihe';
}
echo '';
for ($i = 0; $i < 3; $i++)
{
PrintTableRow();
}
echo '';

Benutzerdefinierte Funktionen
Der Funktionskopf ist hier in seiner einfachsten Form zu sehen:
function PrintTableRow()
Da keine Parameter verwendet werden, schreibt man nur zwei runden Klammern
zum Abschluss. Schlüsselwort und Name sind ebenso obligatorisch. Der Name
sollte so gewählt werden, dass ein Verb am Anfang steht, denn Funktionen führen
Aktionen aus, die man üblicherweise mit Verben bezeichnet.
Wie das Beispiel zeigt, eignen sich Funktionen zum Einsatz an allen Stellen im
Skript, also auch in Schleifen.
Die Reihenfolge der Definition spielt keine Rolle. PHP5 beherrscht die so
genannte späte Bindung, bei der die Aufrufadressen der Funktionen erst am Ende
der Seitenverarbeitung festgelegt werden. Deshalb funktioniert auch Folgendes:
echo '';
for ($i = 0; $i < 3; $i++)
{
PrintTableRow();
}
echo '';
function PrintTableRow()
{
echo 'Reihe';
}
Wenn in der Funktion Ausgaben erzeugt werden, erscheinen diese im Rahmen
der Ausführung auf der Seite an der Stelle, wo die Ausgabe beim Aufruf der Funktion
gerade war. Das Beispiel nutzt diesen Effekt bereits.
Rückgabewerte
Abbildung 4.4:
Ausgabe einer Tabelle mit einer Funktion
Besser ist es, die Ausgabe von Werten nicht der Funktion zu überlassen. Der Aufrufer
sollte (wieder im Sinne eines besseren Programmierstils) letztlich die Kontrolle
über die Ausgaben behalten. Wenn Funktionen Werte erzeugen, können Sie
diese mit Hilfe des Schlüsselwortes return zurückgeben.
151

152
Programmieren
Eine Unterscheidung zwischen Prozeduren (kein Rückgabewert) und
Funktionen (mit Rückgabewert), wie in BASIC (Visual Basic, VBA,
VBScript), gibt es in PHP nicht. Es ist völlig dem Entwickler überlassen,
ohne weitere Definition mit oder ohne return zu arbeiten. Lediglich der
Aufruf muss entsprechend angepasst werden.
Das letzte Beispiel sieht etwas besser aus, wenn es folgendermaßen definiert wird:
Listing 4.12: functionreturn.php – Eine Funktion mit Datenrückgabe
function PrintTableRow()
{
return 'Reihe';
}
echo '';
for ($i = 0; $i < 3; $i++)
{
echo PrintTableRow();
}
echo '';
Es ist nun dem Aufrufer überlassen, mit echo die sofortige Ausgabe zu veranlassen
oder die erzeugte Zeichenkette vorher noch zu verarbeiten. Letzteres wäre möglich,
wenn der Wert direkt einer Variablen übergeben wird:
$row = PrintTableRow();
Wenn nun die Anzahl der Zellen in der erzeugten Reihe variabel sein soll, müsste
man für jede Variante eine neue Funktion definieren. Besser ist es, hier mit Parametern
zu arbeiten.
Eine Funktion kann immer nur einen Wert zurückgeben. Auch wenn Arrays noch
nicht vorgestellt wurden, sei hier ein kleiner Ausflug präsentiert. Wenn Sie
mehrere Werte zurückgeben müssen, erstellen Sie ein Array:
function RetArray()
{
$result = array(45, 26, 14);
return $result;
}

Benutzerdefinierte Funktionen
Beim Aufruf weisen Sie die Rückgabewerte mit Hilfe der Funktion list wieder
einzelnen Variablen zu:
list($var1, $var2, $var3) = RetArray();
$var1 enthält nun 45, $var2 den Wert 26 usw.
Parameter der Funktionen
Parameter sind Werte, die der Aufrufer an die Funktion übergibt, um deren Verhalten
zu steuern. PHP5 kann pro Funktion mit beliebig vielen Parametern umgehen.
Die Anzahl ist nicht nur insgesamt frei gestellt, sondern kann abweichend von
der Definition schwanken. Dies ist tückisch (wenn auch recht bequem), denn der
Aufruf mit einer zu großen Anzahl Parameter führt nicht zwingend zu einer Fehlermeldung.
Da PHP typlos arbeitet und der Datentyp der Parameter ignoriert
wird, ist die Fehlerquote hier aber ohnehin recht hoch. Der Umgang mit Parametern
wird deshalb etwas detaillierter betrachtet.
Einfache Parameter
Einfache Parameter werden deklariert, indem man diese als Variablen im Kopf der
Funktion aufschreibt:
function PrintTableRow($cells)
Diese Funktion hat einen Parameter. Innerhalb des Funktionskörpers kann über
die Variable $cells darauf zugegriffen werden. Mehrere Parameter werden durch
Kommata getrennt, so wie bei den eingebauten Funktionen:
function PrintTableRow($bgcolor, $cells)
Das folgende Beispiel erzeugt eine Reihe mit beliebig vielen Zellen, prüft die Verwendung
der Parameter und akzeptiert außerdem noch eine Farbe für den Reihenhintergrund:
Listing 4.13: functionparam1.php – Funktion mit Parametern aufrufen
function PrintTableRow($bgcolor, $cells)
{
$cellstring = '';
for ($i = 0; $i < $cells; $i++)
{
153

154
Programmieren
$cellstring .= " $i ";
}
$row =

Benutzerdefinierte Funktionen
return $row;
}
echo '';
echo PrintTableRow('gray');
echo PrintTableRow('red');
echo PrintTableRow('gold');
echo '';
Wenn der zweite Parameter fehlt, wird hier automatisch die Zahl 6 eingesetzt.
Optionale Parameter dürfen nur am Ende der Parameterauflistung stehen. Das ist
logisch, denn PHP kann die Position nur durch Abzählen feststellen. Da PHP
keine Datentypen erkennt, ist eine Auswahl von Parametern schwer zu definieren.
Folgende Definition ist noch zulässig:
function PrintTableRow($bgcolor = 'gray', $cells = 6)
Beim Aufruf sind aber nicht alle Varianten möglich. Ohne Parameter ist die Sache
eindeutig:
PrintTableRow()
Mit beiden Parameter funktioniert es natürlich auch. Aber bei der Angabe nur
eines Parameters versagt der Aufruf. Das folgende Beispiel funktioniert nicht wie
erwartet:
PrintTableRow(4)
PHP5 kann nicht erkennen, dass hier die Anzahl der Zellen gemeint war und
offensichtlich die Standardhintergrundfarbe zum Einsatz kommen soll. Auch mit
den passenden Datentypen ist dies nicht möglich, weil sich die Parametertypen ja
nicht zwingend unterscheiden müssen.
Unzulässig ist auch folgende Definition:
function PrintTableRow($bgcolor = 'gray', $cells)
PHP5 kann hier beim Aufruf nicht erkennen, welcher Parameter weggelassen werden
soll.
Abschließend sei noch bemerkt, dass der Standardwert eine Konstante oder ein
Literal sein muss. Variablen und Ausdrücke sind nicht erlaubt. Deshalb ist die folgende
Variante unzulässig:
function PrintTableRow($bgcolor = $gray, $cells = 3 + 3)
155

156
Programmieren
Beliebige Parameteranzahl
Die Lösung des Dilemmas liegt in der Akzeptanz einer beliebigen Parameteranzahl.
Dazu wird der Kopf der Funktion einfach leer gelassen – wie in der ersten
Variante. Der Aufrufer kann dennoch beliebig viele Parameter angeben. Daneben
ist die nachfolgend vorgestellte Angabe von vielen Parametern auch besser, als
diese in endlosen Schlangen aufzuschreiben. Man findet in der professionellen
Programmierung selten Funktionen mit sechs oder mehr Parametern. Die
dadurch erreichte Steuerbarkeit einer Funktion ist derart umfassend, dass wohl
meist ein Designfehler vorliegt. Komplexere Dinge erledigt man mit Klassen
(siehe Tag 6).
Für den Umgang mit variabler Parameteranzahl stellt PHP5 einige spezielle Funktionen
zur Verfügung:
func_num_args
Diese Funktion, aufgerufen innerhalb einer benutzerdefinierten Funktion,
ermittelt die tatsächliche Anzahl der Parameter, die übergeben wurden.
func_get_args
Hiermit wird ein Array der Parameter erstellt. Der erste Parameter hat den
Index 0. So erhält man Zugriff auf alle Parameter.
func_get_arc
Alternativ zum Array kann jeder Parameter auch direkt über eine Funktion
adressiert werden. Als Argument wird der null-basierte Index verwendet.
Es ist empfehlenswert, Funktionen immer so zu schreiben, dass zuerst die eingehenden
Parameter geprüft werden. Es gehört zu den grundlegenden Regeln der
Programmierung, dass Eingabedaten nie vertraut werden darf. Würden alle Programme
so erstellt werden, gäbe es kaum noch Programmierfehler, denn die
eigentlichen Algorithmen lassen sich meist gut testen.
Listing 4.15: functionparams.php – Intelligente Funktion mit variabler Parameterzahl
function BuildRow()
{
$cells = 4;
$Params = func_num_args();
if ($Params == 0)
{
return "";
}

$row = '';
for ($i = 0; $i < $Params; $i++)
{
$row .= '' . func_get_arg($i) . '';
}
for ($k = $i; $k < $cells; $k++)
{
$row .= '&nbsp;';
}
return "$row";
}
echo '';
echo BuildRow('PLZ', 'Vorwahl', 'Ort', 'Aktiv?');
echo BuildRow('12683', '030', 'Berlin');
echo BuildRow('89315', '089', 'München', 'X');
echo '';
Benutzerdefinierte Funktionen
Diese Funktion prüft zuerst, ob Parameter vorliegen. Ist das nicht der Fall, wird
eine leere Reihe erzeugt:
Ohne diese Abfrage würde eine Reihe ohne Zelle erzeugt werden, was falsch ist:
Diese Funktion reagiert also auch bei falscher Parameterzahl korrekt. Will man
diesen Zustand (keine Parameter) vermeiden, so sollte man einen Laufzeitfehler
erzeugen oder eine entsprechende Ausschrift.
Stehen nun Parameter zur Verfügung, wird zuerst deren Anzahl ermittelt:
$Params = func_num_args();
Mit dieser Anzahl wird die Schleife bedient, die die Zellen erzeugt. Zu jeder Zelle
wird ein Parameter als Zelleninhalt abgerufen:
$row .= '' . func_get_arg($i) . '';
Abbildung 4.6:
Ausgabe einer einfachen Tabelle mit benutzerdefinierter
Funktion
157

158
Programmieren
HTML-Tabellen benötigen immer eine konstante Anzahl Tabellenzellen pro
Reihe. Entweder man fügt für fehlende Zellen colspan-Attribute ein oder füllt die
Zellen auf. Das Auffüllen geschieht hier mit einer weiteren Schleife, die auf dem
letzten Wert der ersten Schleife aufbaut. Diese wird dann durchlaufen, bis die
Anzahl der Zellen jeweils der maximalen Anzahl entspricht, die in der Variablen
$cells definiert wurde.
Der Aufruf ist nun recht flexibel, kann jedoch noch verbessert werden. So ist es
möglich, feste mit optionalen Parametern zu kombinieren. Das zweite Beispiel
legt einen Booleschen Parameter fest, der darüber entscheidet, ob Kopf- oder
Inhaltszellen erzeugt werden. Ein weiterer fester Parameter bestimmt die maximale
Anzahl. Die Prüfung wird so erweitert, dass bei Unterschreiten der Anzahl
eine spezielle Ausgabe erzeugt wird.
Listing 4.16: functionparamsplus.php – Verbesserte Funktion mit variabler Parameterzahl
function BuildRow($bHead, $iCells)
{
$cells = $iCells;
$Params = func_num_args();
$sTag = $bHead ? 'th' : 'td';
if (($Params - 2)

Benutzerdefinierte Funktionen
Die Anzahl der Parameter, die func_num_args ermittelt, bezieht hier die beiden feste
am Anfang der Liste mit ein. Deshalb muss an zwei Stellen (Prüfung und Auffüllen)
im Skript die Anzahl um zwei verringert werden. Ansonsten gibt es kaum Unterschiede,
abgesehen vom Aufruf, wo nun zwei Pflichtargumente erforderlich sind.
Referenzen auf Funktionen und Parameter
Wie in den letzten Abschnitten gezeigt, kann man mit Parametern Daten an eine
Funktion übergeben und deren Wiederverwendungswert damit erhöhen. Die
Rückgabe nur eines Wertes mit return verschafft zusätzliche Flexibilität. Das ist
jedoch nicht immer ausreichend. Sollen von einer Funktion viele Werte geändert
werden, so kann dies auch über die Parameter erfolgen. Um die dazu verwendete
Technik zu verstehen, muss man sich an ein wenig Theorie wagen.
Prinzip der Parameterübergabe
Abbildung 4.7:
Ausgabe einer Tabelle mit eigener Funktion
Einfache Skriptsprachen wie PHP arbeiten meist direkt mit Variablen. Wird der
Wert einer Variablen einer anderen Zugewiesen, findet tatsächlich eine Übertragung
des Wertes statt. Variablen sind die Namen von Speicherbereichen im
Hauptspeicher des Computers. Die folgende Zuweisung überträgt nur den Wert
von einem Platz an einen anderen:
$a = $b;
Änderungen von $b zu einem späteren Zeitpunkt wirken sich nicht auf $a aus. Da
so viele Daten durch den Speicher geschaufelt werden, ist dies nicht optimal.
Moderne Sprachen wie C++ oder C# arbeiten deshalb anders. C++ bietet ein Zeigerkonzept,
bei dem statt mit den Werten nur mit den Speicheradressen (so
genannte Zeiger) gearbeitet wird. C# verwendet intern immer Zeiger, dem Benutzer
werden diese aber nicht zugänglich gemacht und erst beim Schreiben wird der
syntaktisch sichtbare Zusammenhang hergestellt und der Wert kopiert. Wegen der
Verwaltung dieser Vorgänge spricht man von verwaltetem Code. C++ profitiert
von Zeigern durch deutlich höhere Geschwindigkeit, durch den direkten Speicherzugriff
ist es jedoch fehleranfällig. C# ist nicht ganz so schnell, aber schneller
159

160
Programmieren
als andere Sprachen und erzeugt sehr stabilen Code. PHP zu guter Letzt
beherrscht weder Zeiger noch kennt es verwalteten Code. Man kann aber mit
Referenzen arbeiten, die den Zusammenhang zwischen der ursprünglichen Speicherstelle
und einem neuen Namen erhalten.
Übergibt man nun einer Funktion statt des Wertes eine Referenz auf eine Variablen,
wirken sich Änderungen an den Parametern in der Funktion auf den Aufrufwert aus.
Listing 4.17: functionreference.php – Ändern der aufrufenden Variablen
function BuildRow(&$text)
{
$text = "$text";
}
echo '';
$t = 'Reihe';
BuildRow($t);
echo $t;
echo $t;
echo $t;
echo '';
Die Referenzierung wird definiert, indem dem Parameter das &-Zeichen vorangestellt
wird. Damit bestimmt die Definition, ob referenziert wird oder nicht. Leider
kann auch in PHP5 das Prinzip auf den Kopf gestellt und die Referenzierung dem
Aufrufer überlassen werden:
BuildRow(&$t);
Es ist deshalb gefährlich, Parameter zu verändern, wenn dies nicht ausdrücklich
erwünscht ist. Neben der Prüfung der Parameter heißt dies in der Praxis, dass
zuerst alle Werte in lokale Variablen kopiert und dann weiter verwendet werden.
Zum Thema Variablen gibt es darüber hinaus noch einige weitere Besonderheiten
im Zusammenhang mit Funktionen. Sie werden in den folgenden beiden
Abschnitten vorgestellt.
Statische Variablen
Statische Variablen erlauben es, den Wert einer Variablen von Funktionsaufruf zu
Funktionsaufruf zu erhalten. Das Beispiel mit dem Tabellenreihengenerator
könnte so mit einer Zählfunktion erweitert werden. Als Schlüsselwort wird static
eingesetzt.

Benutzerdefinierte Funktionen
Listing 4.18: functionstatic.php – Verwendung statischer Variablen in Funktionen
function BuildRow($bRowNumber, $bHead, $iCells)
{
static $rowNumber = 1;
$cells = $iCells;
$Params = func_num_args();
$sTag = $bHead ? 'th' : 'td';
if (($Params - 2)

162
Programmieren
PHP5 führt diese Zeile nur beim ersten Aufruf aus. Danach gilt die Variable als
bekannt und die 1 wird nicht erneut zugewiesen. Damit kann der Wert bei jedem
Aufruf verändert werden:
$rowNumber++;
Bei der Ausgabe ergibt sich daraus dann eine fortlaufende Zählung der Tabellenreihen:
Die hier vorgestellte Methode mit statischen Variablen hat – trotz gleichen
Namens – nichts mit den statischen Mitgliedern von Klassen zu
tun. Der Name wurde bereits vor langer Zeit in PHP benutzt, in der an
die mit PHP5 eingeführten objektorientierten Konzepte noch nicht zu
denken war.
Globale Variablen und Konstanten
PHP5 kennt, abgesehen von den Schutzmechanismen für Variablen innerhalb
von Klassen, nur globale Variablen. Die Sichtbarkeit beschränkt sich auf das
Basisskript, innerhalb von Funktionen sind globale Variablen normalerweise nicht
sichtbar. In der Regel helfen Parameter, den Zugriff auf Werte zu erlauben. Wenn
nichts Grundlegendes dagegen spricht, sind Parameter der beste Weg. Außerdem
verfügt PHP5 über einige so genannte »Super-Arrays«, die wichtige Werte aus Formularen
oder Cookies enthalten und die auch in Funktionen abgerufen werden
können.
Globale Variablen in Funktionen nutzen
Abbildung 4.8:
Tabelle, gebaut mit einer zählende Spalte mit statischen
Funktionsvariablen
Dennoch besteht manchmal der Wunsch, Variablen aus der obersten Skriptebene
sichtbar zu machen, ohne dafür Parameter einzusetzen. Um das zu erledigen, können
Sie sich den Zugriff mit dem Schlüsselwort global verschaffen. Dies ist
zugleich auch ein Vollzugriff auf die Variable, das heißt, Änderungen innerhalb
der Funktion wirken sich direkt auf das Original aus.

Benutzerdefinierte Funktionen
Listing 4.19: functionglobal.php – Globale Variablen in Funktionen nutzen
$cells = 6;
function PrintTableRow($bgcolor)
{
global $cells;
$cellstring = '';
for ($i = 0; $i < $cells; $i++)
{
$cellstring .= " $i ";
}
$row =

164
Programmieren
$row =

Benutzerdefinierte Funktionen
Da Stapel eine begrenzte Kapazität haben, muss man das Programm so gestalten,
dass nicht endlos Aufrufe möglich sind, auch wenn die aktuellen Daten dies verlangen.
In PHP 4 war die Stapelgröße strikt auf 254 beschränkt. PHP5 kann offensichtlich
dynamisch Speicher anfordern und verkraftet ca. 6.000 rekursive Aufrufe.
Eine genaue Definition gibt es nicht, die Anzahl hängt vom Speicherverbrauch
des Skripts ab. Allerdings muss man beachten, dass Hunderte Funktionsaufrufe zu
erheblichen Laufzeiten führen und die genannte Größe mehr als ausreichend ist.
Sollten Sie mehr rekursive Aufrufe benötigen, liegt vermutlich ein Designfehler
im Programm vor.
Eine gute Demonstrationsmöglichkeit bieten immer wieder mathematische Funktionen.
Die folgende Funktion ist sicher jedem vertraut:
f(x) = xy PHP verfügt dafür über eine passende Funktion. Dennoch könnte man dies auch
rekursiv lösen, indem der folgende Algorithmus angewendet wird:
f(x) = x * x (y-1)
Letzteres wird solange ausgeführt, bis y = 1 und damit x (y-1) = 1 ist, denn mit x × 1 =
x ist der Weg beendet.
Listing 4.21: functionrekursion.php – Potenzrechnung mit rekursiven Aufrufen
function Power($base, $exp)
{
if ($exp > 0)
{
return $base * power($base, $exp - 1);
}
return 1;
}
echo Power(7, 2);
Das Beispiel gibt mit den Testwerten 7 und 2 natürlich 49 aus (72 ). Interessanter ist
der Ablauf der Funktion. Das schrittweise Verfolgen kann sehr hilfreich sein:
1. Der erste Aufruf füllt die Parameter mit den Werten 7 und 2.
2. Nach der Prüfung 2 > 0 (Wahr) erfolgt die erste Berechnung:
7 * (Nächster Aufruf mit 7 und 1)
165

166
Programmieren
3. Prüfung, danach Selbstaufruf mit den neuen Parametern:
7 * (Nächster Aufruf mit 7 und 0)
4. Die Prüfung ist nun nicht mehr Wahr, der Rückgabewert wird mit 1 festgelegt.
5. Der zweite rekursive Aufruf wird ausgeführt, der Rückgabewert ist 7:
7 * 1
6. Der erste rekursive Aufruf wird ausgeführt, der Rückgabewert ist 49:
7 * 7
7. Es sind keine Stapelwerte mehr da und der letzte Rückgabewert geht ans
Hauptprogramm: 49.
Die Rücksprungprüfung im Beispiel wird übrigens durch die if-Anweisung erledigt.
Eine solche Prüfung ist unbedingt erforderlich. Andere rekursive Lösungen
verwenden auch for oder foreach, die irgendwann keine definierten Startwerte
mehr erhalten und deshalb den im Schleifenkörper liegenden rekursiven Aufruf
nicht mehr ausführen.
Variable Funktionen
Neben dem normalen Funktionsaufruf kennt PHP auch dynamische Funktionen,
ähnlichen den dynamischen Variablen. Dabei wird der Name einer Funktion
einer Variablen zugewiesen und diese dann mit der Funktionssyntax aufgerufen.
Der Vorteil dabei: Der Name der Funktion wird wie eine Zeichenkette behandelt
werden.
Das folgende Skript zeigt mehrere Versionen für Definition und Aufruf:
Listing 4.22: functiondynamic.php – Dynamische Funktionen sind sehr flexibel
function MakeB($text)
{
return "$text";
}
function MakeI($text)
{
return "$text";
}
function MakeU($text)

Benutzerdefinierte Funktionen
{
return "$text";
}
$tag = 'I';
$base = 'Make';
$func = $base.$tag;
echo 'Kursiv: ' . $func('Test') . '';
$func = $base.'U';
echo 'Unterstrichen: ' . $func('Test') . '';
$func = "{$base}B";
echo "Fett: {$func('Test')}";
Im Beispiel werden drei Funktionen definiert, die sich nur durch ihr Suffix unterscheiden.
Sie bauen einen als Parameter übergebenen Text jeweils in ein HTML-
Tag ein. Der Funktionsname wird nun dynamisch zusammengesetzt:
$func = $base.$tag;
Der Aufruf erfolgt dann unter Zuhilfenahme der Funktionsschreibweise, angewendet
auf diese Variable:
$func('Test')
PHP kann dies an den runden Klammern erkennen. Der eigentliche Effekt besteht
darin, dass man einen an zentraler Stelle platzierten Funktionsaufruf situationsabhängig
modifizieren kann. Dies kann unter Umständen ein Skript erheblich vereinfachen.
Die Lesbarkeit wird dadurch aber kaum gesteigert. Anfänger dürften
regelmäßig Schwierigkeiten haben, derartige Programme sofort zu durchschauen.
Noch ein weiterer Effekt macht den Einsatz lohnenswert. Die Auflösung von Variablen
in Zeichenketten wird sehr oft eingesetzt. Will man Rückgabewerte von
Funktionen direkt ausgeben, bleibt normalerweise nur eine Zeichenverkettung:
echo 'Kursiv: ' . $func('Test') . '';
Viele Anführungszeichen, viele Punkte, wenig Lesbarkeit; derartige Konstrukte
sind ebenso häufig wie lästig. Eleganter sieht der folgende Aufbau aus:
echo "Fett: {$func('Test')}";
Die geschweiften Klammern sind zwingend erforderlich, um der Auflösungskomponenten
die korrekten Grenzen zu zeigen.
Abbildung 4.9:
Ausgaben, erzeugt mit dynamischen Funktionsaufrufen
167

168
Programmieren
Die dynamischen Funktionen kann man auch mit internen Namen verwenden,
wie das folgende Beispiel zeigt:
Listing 4.23: functiondynintern.php – Interne Funktionen dynamisch aufrufen
$pf = 'sprintf';
$dt = 'date';
echo "Ausgabe: {$pf('Datum: %s', $dt('d.M.Y'))} ";
Hier werden die Funktionen sprintf und date (Datumsausgabe) verwendet und
die Ausgabe in eine Zeichenkette integriert. Die Ausgabe ist wenig spektakulär,
aber die dadurch erreichte Flexibilität reicht hart an selbst modifizierenden Code
heran.
Sprachkonstrukte und Anweisungen, wie beispielsweise echo oder
include, lassen sich nicht mit der dynamischen Funktionssyntax verwenden,
weil es eben keine Funktionen sind.
4.4 Modularisierung von Skripten
Schon bei der Erstellung der ersten Projekte wird der Wunsch aufkommen, einmal
mühevoll fertig gestellte Programme wieder verwenden zu können. PHP
kennt als äußeres Strukturierungskriterium nur Dateien. Will man also Teile eines
anderen Programms wieder verwenden, muss man diese in eigenen Dateien ablegen.
Für das Einbindung solcher Module werden spezielle Funktionen bereitgestellt.
Module einbinden
Abbildung 4.10:
Ausgabe, komplett mit dynamischen Funktionen erzeugt
PHP5 kennt insgesamt vier Anweisungen, die Module aus Dateien aufrufen:

include
Modularisierung von Skripten
require
Beide Anweisungen öffnen eine angegebene Datei und binden den enthaltenen
Code so ein, also ob er an dieser Stelle geschrieben wäre.
include_once
require_once
Auch diese beiden Anweisungen öffnen eine angegebene Datei und binden
den enthaltenen Code so ein, also ob er an dieser Stelle geschrieben wäre. Sie
werden jedoch nur ein einziges Mal ausgeführt, auch wenn sie mehrfach aufgerufen
werden.
Der Unterschied zwischen include und require besteht in der Reaktion auf Fehler.
Das liegt an den verschiedenen Verarbeitungszeitpunkten. require bindet erst
die Datei ein und führt dann das Skript aus. Fehlt das Modul (Datei nicht gefunden),
erscheint sofort ein fataler Fehler und die Ausführung bricht ab. include
wird dagegen erst ausgeführt, wenn der Programmfluss am Befehl angekommen
ist. Eine fehlende Datei führt dann lediglich zu einer Warnung.
Bezüglich der reinen Verarbeitung der Inhalte verhalten sich beide Anweisung
identisch. Im folgenden Text wird deshalb keine Trennung mehr vorgenommen
und nur mit include gearbeitet.
Module und HTML
Jedes Modul wird separat verarbeitet. Das bedeutet, dass PHP erstmal eine HTML-
Datei erwartet. Steht PHP drin, muss dieses in die üblichen Markierungen eingeschlossen werden.
Betrachten Sie zuerst die Anwendung:
Listing 4.24: include.php – Nutzung von Moduldateien
169

170
Programmieren
Der PHP-Block erscheint hier in der üblichen Form. Völlig unabhängig von der
Verwendung steht jedes Modul für sich und deklariert seinen PHP-Bereich – wenn
vorhanden – unabhängig davon.
Listing 4.25: header.inc.php – Variablen der übergeordneten Instanz verwenden
Das erste Modul, für den Kopfbereich, übernimmt die Variable $title. Das ist ohne
weiteres möglich, da sich der Text so verhält, als wäre er an der Stelle der include-
Anweisung geschrieben worden. Das Schlüsselwort global oder vergleichbare
Techniken sind nicht erforderlich.
Listing 4.26: footer.inc.php – Der Fußbereich, ganz ohne PHP
(C) 2004 Markt+Technik
Der Fußbereich zeigt, dass sich die Anweisungen auch bestens zum Einbindung
von reinem HTML eignen. Dies verschafft möglicherweise eine bessere Flexibilität
als die Verwendung der Heredoc-Syntax, wenn größere Textblöcke erforderlich
sind.
Module finden
Im letzten Beispiel wurde der Pfad zu den Modulen – sie waren im Unterverzeichnis
/include platziert – direkt angegeben. Möglicherweise haben Sie eine Sammlung
solcher Module an zentraler Stelle auf dem Server liegen. Dann wäre die
Angabe des Pfades immer und immer wieder sehr lästig. Deshalb kann man einen
speziellen Suchpfad angeben, der von PHP benutzt wird, wenn im aktuellen Ver-

Modularisierung von Skripten
zeichnis die entsprechende Datei nicht aufzufinden war. Der Wert kann entweder
in der php.ini konfiguriert oder mit ini_set angegeben werden.
Listing 4.27: includeset.php – Pfad zu den Modulen über Suchpfade finden
Der Parameter, der gesetzt werden muss, heißt include_path. Der Pfad kann absolut
oder relativ zu aktuellen Skriptposition sein. Damit man von der Verschiebung
des Skripts unabhängig ist, sollten auf Produktionssystemen absolute Pfade eingesetzt
werden – im Gegensatz zur sonst üblichen Praxis, nur relative Pfade zu verwenden.
Mehrfachverwendung verhindern
Wenn innerhalb eines Moduls eine Funktions- oder Klassendefinition steht, ist die
mehrfache Verwendung innerhalb eines Skripts fatal. Denn eine mehrfache Definition
– worauf es hinausläuft – ist nicht zulässig. Ein Laufzeitfehler wäre die
Folge. In solchen Fällen verwendet man include_once. Die Anweisung stellt
sicher, dass der Inhalt nur beim ersten Mal ausgeführt wird. Viele große Projekt
verwenden nämlich verschachtelte Zugriffe auf die Module und andere Module
haben möglicherweise einen bestimmten Code bereits eingebunden. Mangels
anderer Konzepte sind solche Mehrfachverwendungen in PHP durchaus üblich.
Aus informationstechnischer Sicht ist include_once zwar eher als »dirty hack« zu
betrachten, aber es passt zu PHP als primitiver Sprache.
171

172
Programmieren
Automatisches Einbinden mit __autoload
Die Funktion __autoload ist auf globaler Ebene zu definieren. Sie wird immer
dann aufgerufen, wenn eine unbekannte Klasse instanziiert wird. Bei großen Projekten
spart diese Vorgehensweise unter Umständen das Laden großer Bibliotheken,
falls einige Klasse daraus nur sporadisch benötigt werden. Praktisch sieht
das folgendermaßen aus:
function __autoload($classname)
{
include_once("{$classname}.inc.php");
}
$instance = new LibraryClass();
Bei der Ausführung wird folgendes ausgeführt:
include_once("LibraryClass.inc.php");
Ohne weitere objektorientierte Techniken wird man davon allerdings nicht profitieren
können.
Informationen über Module ermitteln
Hat man vollends den Überblick über die gerade eingebundenen Module verloren,
bringen ein paar Hilfsfunktionen Licht in den Dschungel:
get_included_files
get_required_files
Beide Funktionen geben jeweils ein Array der Dateien zurück, die im Skript eingeschlossen
wurden. Um eine vollständige Übersicht zu erhalten, müssen Sie die
Funktion am Ende des Skripts aufrufen, andernfalls werden nur die bis zu diesem
Zeitpunkt eingeschlossenen Module ermittelt. Das Array enthält an erster Stelle
immer auch das eigentliche Hauptskript. Beide Funktionen geben übrigens alle
durch require oder include eingebundene Module an, sind also praktisch völlig
identisch. Vermutlich ist dies ein Bug, denn die Namen suggerieren etwas anderes.
Wenn Sie noch keinen Umgang mit Arrays beherrschen, können Sie die folgende
Ausgabe verwenden, um das Ergebnis zu sehen:

ini_set('include_path', 'include');
$title = "Testseite";
?>
Die Ausgabe erscheint gut lesbar, wenn man sie in -Tags einbaut. Dies eignet
sich vor allem zur schnellen Fehlersuche:
4.5 Fehlerbehandlung
Abbildung 4.11:
Ausgabe der Liste
der eingeschlossenen
Dateien
PHP5 führt einige neue Methoden der Behandlung von Laufzeitfehlern ein.
Damit rückt die Sprache ein wenig in Richtung moderner Sprachen wie Java oder
C. Allerdings gelang den Entwicklern nur eine halbherzige Umsetzung, was den
Wert wieder etwas in Frage stellt. Nichtsdestotrotz lohnt es sich, die neuen Möglichkeiten
auszuprobieren und einzusetzen.
173

174
Programmieren
Aber auch die konventionelle Technik der Fehlerbehandlung ist nicht völlig
außen vor. In der Kombination aller Varianten ist der Umgang mit unvermeidlichen
Fehlern recht brauchbar.
Konventionelle Fehlerbehandlung
Das folgende Skript prüft, ob ein Name in einer Liste von Namen vorhanden ist.
Die Details der Verarbeitung sind hier völlig uninteressant, es geht nur um das
Prinzip. Die Funktion SearchName sucht einen Namen und gibt TRUE zurück,
wenn die Suche erfolgreich war.
Listing 4.29: errorcontrolcon.php – Fehlerbehandlung ohne spezielle Sprachmittel
function SearchName($Name)
{
if (strlen($Name) < 3)
{
return false;
}
$Names = array ('Joerg', 'Uwe', 'Clemens', 'Lukas');
if (in_array($Name, $Names))
{
return true;
}
else
{
return false;
}
}
$name = 'Clemens';
if (SearchName($name))
{
echo 'Name gefunden';
}
else
{
echo 'Name nicht vorhanden';
}
Das Skript ist prinzipiell korrekt geschrieben. Die Funktion folgt den üblichen
Regeln und prüft vor der Verarbeitung, ob sinnvolle Daten vorliegen. Im Beispiel

Fehlerbehandlung
wird eine Mindestlänge von drei Zeichen für den Namen erwartet. Der Rückgabewert
ist das eigentliche Problem: FALSE kann sowohl auf einen Datenfehler als
auch auf eine erfolglose Suche hindeuten. Genau hier setzen üblicherweise Fehlerbehandlungen
an. Falsche Daten sollten einen Laufzeitfehler erzeugen, während
eine misslungene Suche lediglich die passenden Rückgabewerte erzeugt.
Manche Programme behelfen sich mit Hilfslösungen, indem sie Zahlenwerte
zurückgeben und dann -1, 0 und 1 usw. definieren. Das ist nicht schön, denn die
Zustände »gefunden« und »nicht gefunden« sind eindeutig Boolescher Natur.
Laufzeitfehler selbst erzeugen – der klassische Weg
Der erste Ansatz ist bereits in PHP 4 möglich. Hierzu wird zuerst eine Funktion
deklariert, die Laufzeitfehler auffängt und damit eine gezielte Reaktion ermöglicht.
Die Funktion set_error_handler definiert diese Verzweigung. Ist das erfolgt,
wird mit trigger_error im Bedarfsfall der Fehler erzeugt.
Listing 4.30: errorcontroltrigger.php – Benutzerdefinierte Fehlerverwaltung
set_error_handler('SearchError');
function SearchError($errno, $errstr, $errfile, $errline)
{
switch ($errno)
{
case E_USER_ERROR:
echo "Fehler: $errstr";
exit;
default:
echo "$errstr on Line $errline in file $errfile";
}
}
function SearchName ($Name)
{
if (strlen($Name) < 3)
{
trigger_error('Name zu kurz', E_USER_ERROR);
}
$Names = array ('Joerg', 'Uwe', 'Clemens', 'Lukas');
if (in_array($Name, $Names))
{
return true;
}
175

176
Programmieren
else
{
return false;
}
}
$name = 'xx';
if (SearchName($name))
{
echo 'Name gefunden';
}
else
{
echo 'Name nicht vorhanden';
}
Das Skript definiert zuerst eine so genannte Rückruffunktion, die aufgerufen wird,
wenn ein Fehler auftritt:
set_error_handler('SearchError');
Dann muss freilich die Funktion selbst auch definiert werden. Sie hat einen definierten
Aufbau, denn PHP erwartet, dass bestimmte Parameter übergeben werden
können:
function SearchError($errno, $errstr, $errfile, $errline)
Die Parameter haben von links nach rechts folgende festgeschriebene Bedeutung:
Fehlernummer: Eine der internen Fehlernummern.
Fehlertext: Ein Text, der den Fehler beschreibt.
Datei: Die Datei, in der der Fehler ausgelöst wurde. Diese Angabe beachtet
mit include oder require eingebundene Module.
Zeile: Die Zeile, auf der der Laufzeitfehler in der entsprechenden Datei ausgelöst
wurde.
Wie Sie diese Angaben nun verwenden, hängt ganz von der Applikation ab. Wichtig
ist auch, auf die verschiedenen Fehlerklassen reagieren zu können. Sie sind der
folgenden Tabelle zu entnehmen.

Wert Konstante Beschreibung
Fehlerbehandlung
1 E_ERROR Dies zeigt Fehler an, die nicht behoben werden können.
Die Ausführung des Skripts wird abgebrochen.
2 E_WARNING Warnungen während der Laufzeit des Skripts. Führen nicht
zum Abbruch.
4 E_PARSE Parser-Fehler während der Übersetzung. Das Skript startet
gar nicht erst.
8 E_NOTICE Benachrichtigung während der Laufzeit. Wird oft unterdrückt,
was aber keine gute Idee ist.
16 E_CORE_ERROR Fatale Fehler, ähnlich E_ERROR, aber woanders erzeugt.
32 E_CORE_WARNING Warnungen, ähnlich E_WARNING, aber woanders erzeugt.
64 E_COMPILE_ERROR Fataler Fehler zur Übersetzungszeit, erzeugt von der Zend-
Engine.
128 E_COMPILE_WARNING Warnungen zur Übersetzungszeit, erzeugt von der Zend-
Engine.
256 E_USER_ERROR Benutzerdefinierte Fehlermeldungen, erzeugt mit
trigger_error.
512 E_USER_WARNING Benutzerdefinierte Warnung, erzeugt mit trigger_error.
1024 E_USER_NOTICE Benutzerdefinierte Benachrichtigung, erzeugt mit
trigger_error.
2047 E_ALL Alle Fehler und Warnungen die unterstützt werden, mit
Ausnahme von E_STRICT.
2048 E_STRICT Benachrichtigungen des Laufzeitsystems mit Vorschlägen
für Änderungen des Programmcodes, die eine bessere Interoperabilität
und Kompatibilität Ihres Codes gewährleisten.
Wurde mit PHP5 eingeführt.
Tabelle 4.2: Fehlercodes in PHP5
Wie das letzte Beispiel zeigte, eignet sich für den eigenen Code E_USER_ERROR.
Weitere Konstanten kann man selbst definieren, diese sollte dann einfach Werte
größer als 65.535 enthalten, damit keine Konflikte auch in künftigen Versionen
177

178
Programmieren
auftreten. Im Übrigen ist noch zu beachten, dass die Werte Bitfelder darstellen
und immer Zweier-Potenzen sind, damit man die Werte kombinieren kann.
Fehlerbehandlung mit PHP5
Mit PHP5 wurde eine neue Art der Fehlerbehandlung eingeführt, die auf einer
neuen Kontrollstruktur basiert: try/catch. Die Idee dahinter: Man definiert einen
Block, umschlossen von try, in dem mit dem Auftreten von Laufzeitfehlern
gerechnet wird. Um diese selbst zu erzeugen, wird die Anweisung throw verwendet.
Der so ausgelöste Fehler muss nun noch zentral abgefangen und verarbeitet
werden, quasi das Gegenstück zur Rückruffunktion muss her. Dies erledigt catch.
Das mag alles etwas abstrakt und unnütz aufwändig klingen. Es führt jedoch dazu,
dass Applikation und Fehlerbehandlung getrennt werden. Damit wird ein Skript
leichter wartbar, lesbarer und letztendlich stabiler. Die hier gezeigten Trivialbeispiele
wären freilich einfacher zu schreiben, aber in der Praxis sind 5.000 Zeilen
für ein Skript durchaus üblich, und dann ist die Suche nach einem Fehler nicht
mehr trivial, auch für Profis nicht.
Fehlerbehandlung mit try/catch verwenden
Das folgende Skript nutzt die Kombination aus try/catch und throw, um die
besprochene Trennung von Auswertung und Fehler zu realisieren:
Listing 4.31: errorcontroltrycatch.php – Kontrolle über Laufzeitfehler mit try/catch
function SearchName ($Name)
{
if (strlen($Name) < 3)
{
throw new Exception('Name zu kurz');
}
$Names = array ('Joerg', 'Uwe', 'Clemens', 'Lukas');
if (in_array($Name, $Names))
{
return true;
}
else
{
return false;

Fehlerbehandlung
}
}
$name = 'Jo';
try
{
if (SearchName($name))
{
echo 'Name gefunden';
}
else
{
echo 'Name nicht vorhanden';
}
}
catch (Exception $ex)
{
echo $ex->getMessage();
}
Eine Rückruffunktion wird nun nicht mehr benötigt. Es genügt, den Block, in
dem Fehler auftreten können, in try zu verpacken:
try
{
///
}
Im Beispiel ist es die Funktion SearchName, die Probleme machen, also Fehler
»werfen« kann. Der Begriff »werfen« hat hier Methode, denn »geworfen« wird der
Fehler mit throw (engl. werfen). Interessanterweise sind die Fehler in PHP5, die
ausgelöst werden, keine Konstanten mehr, sondern Klassen. Da Klassen erst am
nächsten Tag behandelt werden, nehmen Sie die Syntax hier erstmal kommentarlos
hin:
throw new Exception('Name zu kurz');
Technisch wird hier eine Instanz mit new erzeugt und dann übergeben. Interessanter
ist, was daraus im catch-Zweig wird. Hinter einem try können ein oder
mehrere catch-Zweige stehen. Jeder Zweig prüft nun, welche Art von Fehler hier
ankommt. Im Beispiel wurde dazu nur die Basisklasse Exception verwendet, die
PHP5 bereitstellt:
catch (Exception $ex)
179

180
Programmieren
Die Variable $ex, die hier entsteht, erlaubt den Zugriff auf das Objekt, das new
erzeugt hat, als der Fehler mit throw abgeschickt wurde. Darin steht – wenig überraschend
– der Fehlertext:
echo $ex->getMessage();
Der Aufruf zeigt den Zugriff auf eine Methode der Klasse, getMessage(). Genaueres
dazu finden Sie am Ende des folgenden Tages, wenn es die dann vermittelten
Grundlagen der objektorientierten Programmierung erlauben, tiefer in die
Geheimnisse der Fehlerbehandlung in PHP5 einzusteigen.
Laufzeitfehler, die das interne Laufzeitsystem erzeugt, lassen sich übrigens
mit try/catch nicht abfangen. Hierzu kann nur auf die bereits
beschriebenen »konventionellen« Techniken verwiesen werden.
4.6 Kontrollfragen
1. Schreiben Sie ein Skript, das beliebige Zahlen zwischen 0 und 100 auf ganze
Zehner rundet.
2. Können mit switch-Anweisungen auch Vergleiche mit beliebigen Booleschen
Ausdrücken erfolgen?
3. Welche Schleife wird benutzt, wenn sichergestellt werden muss, dass der Schleifenkörper
mindestens einmal durchlaufen wird?
4. Zu Testzwecken kann es erforderlich sein, eine Schleifenbedingung so zu formulieren,
dass eine Endlosschleife entsteht. Mit welchen Anweisungen kann ein
»Notausstieg« programmiert werden?

Daten mit Arrays
verarbeiten
5

182
Daten mit Arrays verarbeiten
Sehr praktisch ist das Zusammenfassen ähnlicher Daten unter einem gemeinsamen
Namen. Solche Gebilde werden als Arrays (Datenfelder) bezeichnet. PHP
bietet hier eine großartige Unterstützung mit vielen Funktionen an.
5.1 Datenfelder im Einsatz: Arrays
Arrays werden sehr oft benötigt. Ein sehr wichtiger Einsatzfall ist im Zusammenhang
mit Datenbanken zu finden. Abfragen an Datenbanken liefern sehr oft die
Daten als Arrays aus. Mit Arrays kann man dann sehr flexibel umgehen. Typische
Funktionen, die direkt und mit wenig Aufwand ausgeführt werden können, sind:
Ausgaben in Schleifen
Sortieren
Zusammenfügen
Suchen
Für all diese Aufgaben bietet PHP spezielle Funktionen und Sprachkonstrukte.
Das führt zwangsläufig zu einer großen Anzahl von Möglichkeiten und Varianten,
was den Umgang mit Arrays nicht unbedingt vereinfacht. Etwas Systematik kann
da nicht schaden. Die folgenden drei Abschnitte entsprechen deshalb in etwa dem
Lebenszyklus eines Arrays:
1. Das Array erstellen und befüllen
2. Das Array manipulieren
3. Das Array ausgeben
5.2 Arrays erstellen und befüllen
Arrays sind Sammlungen ähnlicher Daten unter einem gemeinsamen Namen. So
könnte man eine Liste von Ländercodes erstellen:
de
en
ca

fr
it
Arrays erstellen und befüllen
es
Will man damit in einem Programm umgehen, wäre die Anlage immer neuer
Variablen wenig hilfreich:
$lang1 = "de"
$lang2 = "en"
Stattdessen schreibt man alle Werte in eine Array-Variable und greift über einen so
genannten Index auf die Inhalte zu.
Die Aussage »ähnliche Daten« ist übrigens in PHP nicht ganz ernst zu
nehmen. Mangels strenger Typkontrolle kann man beliebige Daten in
einem Array zusammenpacken.
Ein einfaches Array erstellen
Um ein einfaches Array zu erstellen, benötigt man eine Angabe, die PHP mitteilt,
dass es sich um ein solches handelt. Das folgende Beispiel zeigt dies:
$lang[] = "de";
$lang[] = "en";
$lang[] = "es";
$lang[] = "fr";
$lang[] = "it";
PHP erzeugt hier nur eine Variable mit dem Namen $lang, die insgesamt fünf
Werte enthält. Im Gegensatz zu normalen Variablen überschreiben sich die
Zuweisungen nicht gegenseitig. Das Geheimnis liegt in den eckigen Klammern.
Intern passiert ein klein wenig mehr, denn PHP muss die Werte unterscheiden
können. Dazu wird ein numerischer Index vergeben, also eine Zahl, mit der jeder
einzelne Wert adressiert werden kann. Ohne weitere Angaben beginnt PHP mit
dem Index 0 – man spricht dann von null-basierten Indizes – und zählt fortlaufend
in ganzen Zahlen weiter. Auf diesem Weg kann man auch gezielt jeden Wert
abrufen:
183

184
Daten mit Arrays verarbeiten
Listing 5.1: arrayindex1.php – Ein einfaches Array erzeugen und darauf zugreifen
$lang[] = "de";
$lang[] = "en";
$lang[] = "es";
$lang[] = "fr";
$lang[] = "it";
echo "Index Nr. 3 enthält den Wert: {$lang[3]}";
Die Schreibweise bei der Ausgabe wurde übrigens nur mit geschweiften Klammern
ergänzt, um die Variablenauflösung in der Zeichenkette mit jeder beliebigen
Arrayart zu ermöglichen. Die »Grundform« sieht folgendermaßen aus:
$lang[3]
Das Beispiel gibt »fr« aus, der vierte Wert im Array. Da mit 0 begonnen wird zu
zählen, führt der Index 3 zum gewünschten Ergebnis.
Die Anzahl der Elemente ermitteln
Um die Anzahl der Elemente zu ermitteln, stellt PHP5 die Funktion count zur
Verfügung:
Listing 5.2: arraycount.php – Anzahl der Elemente ermitteln
$lang[] = "de";
$lang[] = "en";
$lang[] = "es";
$lang[] = "fr";
$lang[] = "it";
echo 'Im Array sind ' . count($lang) . ' Werte';
Die Ausgabe entspricht hier der tatsächlichen Anzahl, also 5 im Beispiel (nicht 4,
nach dem Motto »null-basiert«).
Den Index manipulieren
Der Index muss in PHP nicht fortlaufend sein. Sie können bei der Zuweisung
»wild« Werte vergeben:

Listing 5.3: arrayindex2.php – Freie Vergabe von Indizes
$lang[4] = "de";
$lang[5] = "en";
$lang[17] = "es";
$lang[3] = "fr";
$lang[11] = "it";
echo "Index Nr. 11 enthält den Wert: {$lang[11]}";
Auch dieses Array gibt als Anzahl 5 aus:
echo count($lang);
Arrays erstellen und befüllen
Das Array wird also nicht mit den fehlenden Werten aufgefüllt. Tatsächlich spielt
der Index keine Rolle für die interne Verwaltung. Hauptsache, PHP kann die Indizes
unterscheiden.
Wenn Sie die Angabe zeitweilig weglassen, setzt PHP immer mit dem höchsten
vergebenen Index plus Eins fort. Betrachten Sie dazu folgende Sequenz:
$lang[4] = "de";
$lang[23] = "en";
$lang[17] = "es";
$lang[] = "fr";
Der Wert »fr« wird hier mit dem Index 24 gespeichert, nicht mit 18, denn der bislang
höchste vergebene Wert war 23.
Schlüssel statt Indizes
Das führt schnell zu der Überlegung, ob es nicht möglich wäre, statt der numerischen
Indizes auch Zeichenketten zu verwenden. PHP zeigt sich tolerant und
erlaubt dies jederzeit und in jeder Form:
Listing 5.4: arrayindexhash.php – Sprechende Indizes verwenden
$lang['de'] = "Deutschland";
$lang['en'] = "England";
$lang['es'] = "Spanien";
$lang['fr'] = "Frankreich";
$lang['ir'] = "Italien";
echo "Das Land mit dem Code 'es' heißt: {$lang['es']}";
185

186
Daten mit Arrays verarbeiten
In der Informatik werden solche Schlüssel/Wert-Paare auch als Hashes oder Dictionaries
bezeichnet. Der Fantasie sind bei der Namensvergabe keine Grenzen
gesetzt, sprechende oder logische Namen sind sinnvoll, sehr lange Ungetüme fehlerträchtig.
Auf jeden Fall wird nur dann von numerischen Indizes abgewichen,
wenn es die Lesbarkeit und Verständlichkeit des Skripts deutlich erhöht oder
zusätzliche Informationen in den Schlüsseln gespeichert werden.
Vergessen Sie nie die Anführungszeichen bei der Angabe der Schlüssel.
PHP mag die direkte Angabe $lang[de] anstatt $lang['de'] tolerieren; dies
ist jedoch nur auf einen Trick zurückzuführen. Ist eine Konstante (was
de darstellt) nicht definiert, wird diese in eine Zeichenkette umgewandelt,
was dann vermutlich dem gewünschten Effekt entspricht. Ist die
Konstante jedoch zufällig vorhanden, wird der falsche Schlüssel verwendet.
Entspricht der Wert einem Schlüsselwort aus PHP, wird ein Fehler
erzeugt.
Arraywerte schneller zuweisen
Die Zuweisung von Werten, die nicht automatisch generiert werden, kann in der
beschriebenen Form sehr mühselig sein. Deshalb gibt es ein spezielles Schlüsselwort,
das dies einfacher erledigt. Daraus entsteht dasselbe Array wie bei der bereits
gezeigten Version, die Nutzung von array spart lediglich Tipparbeit:
Listing 5.5: arrayindexarray.php – Arrays schneller anlegen
$lang = array('de', 'en', 'es', 'fr', 'it');
echo "Index Nr. 3 enthält den Wert: {$lang[3]}";
Um nun Schlüssel oder andere als die automatischen Indizes verwenden zu können,
muss die Syntax etwas erweitert werden:
Listing 5.6: arrayindex2array.php – Array mit unregelmäßigen Indizes
$lang = array(4 => 'de',
5 => 'en',
17 => 'es',
3 => 'fr',
11 => 'it');
echo "Index Nr. 11 enthält den Wert: {$lang[11]}";

Arrays manipulieren
Der Operator => wird hier benutzt, um Schlüssel bzw. Indizes und Werte zu trennen.
Es ist nahe liegend, dass dies auch mit Zeichenketten funktioniert:
Listing 5.7: arrayhasharray.php – Hash, ein Array mit Schlüsselwerten als Indizes
$lang = array('de' => "Deutschlang",
'en' => "England",
'es' => "Spanien",
'fr' => "Frankreich",
'ir' => "Italien");
echo "Das Land mit dem Code 'es' heißt: {$lang['es']}";
Die »Ausdehnung« der Definition über mehrere Zeilen dient der besseren Lesbarkeit.
Dies sollten Sie sich unbedingt angewöhnen. Es geht auch nicht darum, hier
gegenüber der ersten Variante Zeilen zu sparen. Kompakter, schlecht lesbarer
Code ist immer eine dumme Idee. Die obige Schreibweise ist leichter zu erfassen
und bei großer Datenzahl schneller geschrieben. Weniger Zeichen zu schreiben
heißt immer auch, die Fehlerquote zu verringern.
5.3 Arrays manipulieren
Nachdem die grundsätzlichen Wege, Daten in ein Array zu bekommen, keine
Hürde mehr darstellen, soll mit den Werten gearbeitet werden.
Werte entfernen
Gelegentlich stört ein Wert – er muss entfernt werden. Ebenso wie eine einfache
Variable kann jeder Teil eines Arrays mit unset entfernt werden:
Listing 5.8: arrayunsethash.php – Entfernen eines Elements aus einem Array
$lang =array('de' => "Deutschlang",
'en' => "England",
'es' => "Spanien",
'fr' => "Frankreich",
'ir' => "Italien");
unset($lang['en']);
echo "Das Land mit dem Code 'en' heißt: {$lang['en']}";
187

188
Daten mit Arrays verarbeiten
Das Beispiel führt zu einer Fehlermeldung:
Der fehlende Wert kann jederzeit mit der am Anfang beschriebenen Syntax wieder
zugewiesen werden.
Der Arrayzeiger
PHP führt intern einen Zeiger für Arrays, der die gezielte Auswahl von Elementen
erlaubt. Dies ist eine bereits mit PHP3 eingeführte Technik, die aber nichts an
ihrer Attraktivität verloren hat. Viele der neuen Arrayfunktionen, von denen auch
mit PHP5 wieder weitere hinzukamen, nutzen diese Zeiger nicht. Einfache Arrays
lassen sich mit den alten Funktionen dennoch gut verarbeiten. Zur Auswahl steht
eine ganze Palette:
reset($array);
Der Zeiger wird auf das erste Element zurückgesetzt.
Abbildung 5.1:
Der Fehlerfall
zeigte den Erfolg
der Aktion, das
Element wurde
aus dem Array
entfernt
current($array);
Die Funktion gibt das Element zurück, auf das der Zeiger zurzeit zeigt.
next($array);
Die Funktion verschiebt den Zeiger zum nächsten Element. Sie gibt false
zurück, wenn kein Element mehr da ist, ansonsten den betreffenden Elementwert.
prev($array);
Die Funktion verschiebt den Zeiger zum vorhergehenden Element. Die Funktion
gibt false zurück, wenn der Zeiger bereits auf dem ersten Element stand,
ansonsten den betreffenden Elementwert.
key($array);
Die Funktion gibt den Schlüssel oder Index des aktuellen Elements zurück.

Arrays manipulieren
Einige Beispiele, die diese Funktionen nutzen, finden Sie im Abschnitt 5.4 »Arrays
ausgeben« ab Seite 193. Darüber hinaus ist der Einsatz immer dann interessant,
wenn die Indizes nicht sequenziell vergeben wurden und einfache Zählschleifen
deshalb nicht in Frage kommen. Für das zuletzt bereits verwendete assoziative
Array sind die Funktionen recht praktisch:
$lang = array('de' => "Deutschland",
'en' => "England",
'es' => "Spanien",
'fr' => "Frankreich",
'ir' => "Italien");
reset($lang);
Listing 5.9: arraynextprev.php – Zugriff auf Array-Elemente mit Zeigerfunktionen
do
{
echo current($lang) . ' hat den Code ' . key($lang);
echo '';
} while(next($lang));
Die Ausgabe zeigt, dass der Zugriff sequenziell in der Reihenfolge der Definition
erfolgt:
Abbildung 5.2:
Sequenzielle Ausgabe eines Arrays mit Zeigerfunktionen
Das Beispiel sieht toll aus und funktioniert auch. Es hat jedoch eine böse Falle, die
nicht offensichtlich ist. Sehen Sie sich zum Vergleich das folgende Array an:
$lang = array('de' => "Deutschland",
'en' => "England",
'es' => "0",
'fr' => "Frankreich",
'it' => "Italien");
Statt dem Wort »Spanien« wurde die Ziffer »0« eingesetzt – nach wie vor als Zeichenkette
wohlgemerkt. Diesmal wird folgende Ausgabe produziert:
189

190
Daten mit Arrays verarbeiten
Abbildung 5.3:
Sequenzielle Ausgabe mit Problemen
Was ist passiert? PHPs Typlosigkeit hat hier einen Streich gespielt. Die Funktion
next gibt nämlich nicht true oder false, sondern den Elementwert oder false
zurück. Der Elementwert ist beim dritten Element jedoch »0«. Da die Prüfung
mit while auf false erfolgt, konvertiert PHP den Wert stillschweigend in sein Boolesches
Äquivalent, und da ist 0 == false, was planmäßig zum Abbruch führt. Die
Korrektur ist einfach:
Listing 5.10: arraynextprevkorr.php – Korrigierter Zugriff mit next
$lang = array('de' => "Deutschland",
'en' => "England",
'es' => "0",
'fr' => "Frankreich",
'it' => "Italien");
reset($lang);
do
{
echo current($lang) . ' hat den Code ' . key($lang);
echo '';
} while(next($lang)!==FALSE);
Der Effekt besteht in der korrekten Auswertung in der while-Bedingung. Mit dem
Operator !== wird auch der ursprüngliche Typ geprüft und der ist auf der rechten
Seite Boolesch, auf der linken jedoch nicht. Nun kann es sein, dass man den
Abbruch durchaus will. Dann setzt man als Wert des Arrays nicht eine Zeichenkette
ein, sondern den passenden Vergleichswert, TRUE oder FALSE. Folgendes Array
bricht wieder ab, diesmal ist es jedoch gewollt und logisch:
$lang = array('de' => "Deutschland",
'en' => "England",
'es' => FALSE,
'fr' => "Frankreich",
'it' => "Italien");
Auch der Zugriff auf key ist tückisch. Beginnt das Array mit dem Index 0 – das ist
der Standardfall – gibt key eben zuerst 0 zurück. Durchläuft man mit einer
Schleife die Indizes, ist schon der erste Wert implizit FALSE. Die Operatoren ===
und !== sind nett, ersetzen aber eine gewisse Typstrenge nur mangelhaft. So einfach
wie PHP manchmal ist, so bösartig kann es im Detail werden.

Arrayfunktionen
Arrays manipulieren
Einige der ersten Arrayfunktionen, mit denen Sie praktisch Bekanntschaft
machen, werden die Sortierfunktionen sein. Sortiert wird in der Programmierung
immer wieder und in allen Varianten. PHP verfügt hier über eine inflationäre
Funktionssammlung.
Die einfachste Sortierfunktion heißt sort. Sie sortiert alphanumerisch aufwärts,
das heißt, zuerst kommen die Zahlen, dann Satzzeichen, dann Buchstaben. Dies
entspricht dem Verlauf der ASCII-Werte der Zeichen. Es gibt weitere Sortierfunktionen,
die ein anderes Verhalten aufweisen. Dazu später mehr.
$lang[] = "fr";
$lang[] = "es";
$lang[] = "it";
$lang[] = "de";
$lang[] = "en";
sort($lang);
Listing 5.11: arraysort.php – Sortierung eines einfache Arrays
reset($lang);
do
{
echo current($lang) . '';
} while (next($lang) !== FALSE);
Das Ergebnis entspricht den Erwartungen:
Abbildung 5.4:
Erfolgreiche Sortierung eines einfachen Arrays
Bei assoziativen Arrays ist das nicht ganz so einfach. Das folgende Beispiel zeigt
einen interessanten Effekt:
$lang =array('de' => "Deutschland",
'en' => "England",
'es' => "Spanien",
'fr' => "Frankreich",
191

sort($lang);
192
Daten mit Arrays verarbeiten
'ir' => "Italien");
Listing 5.12: arrayhashsorterr.php – Sieht gut aus, funktioniert aber nicht (siehe Text)
reset($lang);
do
{
echo current($lang) . ' hat den Code ' . key($lang);
echo '';
} while(next($lang));
Die Ausgabe ist wenig hilfreich:
Für solche Fälle kennt PHP eine spezielle Sortierung: asort. Denn sort sortiert
nur Werte, ignoriert die Schlüssel und legt die dann fehlenden Indizes nach dem
üblichen Schema neu an: aufsteigend mit 0 beginnend.
asort($lang);
Abbildung 5.5:
Sortierung ohne Schlüssel: sort ist sehr primitiv
Listing 5.13: arrayhashasort.php: Ausschnitt aus dem korrigierten Listing
Ersetzt man im letzten Listung sort durch asort, funktioniert wieder alles:
Abbildung 5.6:
Korrekte Sortierung, auch mit Indizes
Eine Liste aller elementaren Sortierfunktionen finden Sie am Ende des Kapitels in
der Kurzreferenz.

Arraydaten manipulieren
Arrays ausgeben
Richtig spannend wird es, wenn man die vielen Array-Funktionen, die PHP5 bietet,
zum Einsatz bringen kann. Vielfach wird erst dadurch die Verarbeitung von
Daten richtig effizient. Alle Funktionen vorzustellen, führt hier zu weit, weil allein
die schiere Masse eine ausführliche Darstellung nur auf breitem Raum erlaubt.
Die Referenz am Ende des Kapitels bietet eine ausreichende Hilfestellung bei der
Suche nach der passenden Funktion.
5.4 Arrays ausgeben
Arrays kann man auf vielen Wegen ausgeben. Was konkret zum Einsatz kommt,
hängt von der Situation und oft auch von den Daten selbst ab.
Arrays zählbar ausgeben: for
Die Anweisung for ist immer dann vorteilhaft, wenn man eine konkrete Anzahl
Elemente eines indizierten Arrays ausgeben möchte. Mit for tun sich assoziative
und verschachtelte Arrays recht schwer, denn diese Arrays kennen die nötigen
numerischen Indizes nicht.
$lang[] = array('de', "Deutschland");
$lang[] = array('en', "England");
$lang[] = array('es', "Spanien");
$lang[] = array('fr', "Frankreich");
$lang[] = array('it', "Italien");
for($i = 0; $i < count($lang); $i++)
Listing 5.14: arrayoutfor.php – Ausgabe der Elemente eines Arrays mit for
{
}
$larray = $lang[$i];
echo "Das Kürzel {$larray[0]} steht für {$larray[1]}";
Das eine Zählschleife einen Start- und einen Endwert benötigt, wird hier die
Funktion count benutzt, um den Endwert zu ermitteln. Als Startwert wird 0 eingesetzt.
Die Formel $Laufwert < $Endwert ist typisch, da der Endwert durch die
193

194
Daten mit Arrays verarbeiten
Anzahl bestimmt wird, während der Laufwert bei 0 beginnt (null-basiertes Array).
Deshalb wird als Endwert die Anzahl minus Eins benutzt.
Beliebige Arrays mit foreach durchlaufen
Das Problem der Indizes hat foreach nicht. Wie der Name bereits suggeriert, wird
hier jedes Element eines Arrays durchlaufen, unabhängig von der Anzahl und Art
der Elemente.
$lang[] = array('de', "Deutschland");
$lang[] = array('en', "England");
$lang[] = array('es', "Spanien");
$lang[] = array('fr', "Frankreich");
$lang[] = array('it', "Italien");
foreach ($lang as $larray)
Listing 5.15: arrayoutforeach.php – Flexibel, schnell, einfach: foreach zur Arrayausgabe
{
echo "Das Kürzel {$larray[0]} steht für {$larray[1]}";
}
Die Syntax der Anweisung ist recht einfach. Der erste Wert ist der Name des auszugebenden
Arrays, danach folgt das Schlüsselwort as. Ab hier gibt es zwei Varianten.
Die einfachste nennt einfach eine Variable ($larray im Beispiel), der der
jeweils aktuelle Wert übergeben wird. Es ist dann Sache des Schleifencodes, dieses
Element gegebenenfalls weiter zu zerlegen. Alternativ kann man auch zwei Variablen
angeben, die Schlüssel und Wert des Elements eines assoziativen Arrays aufnehmen.
Beachten Sie im folgenden Beispiel die andere Art der Definition und
die Angabe der Kopfparameter für foreach:
Listing 5.16: arrayoutforeachas.php – Ausgabe eines assoziativen Arrays
$lang['de'] = "Deutschland";
$lang['en'] = "England";
$lang['es'] = "Spanien";
$lang['fr'] = "Frankreich";
Abbildung 5.7:
Ausgabe eines Arrays mit for

Arrays ausgeben
$lang['it'] = "Italien";
foreach ($lang as $iso => $name)
{
echo "Das Kürzel {$iso} steht für {$name}";
}
Die Ausgabe entspricht Abbildung 5.7. Der Code erscheint aber besser lesbar. In
den allermeisten Fällen wird man assoziative Arrays mit foreach ausgeben.
Einfache Arrays mit while, each, list ausgeben
Die Anweisungen while, each und list sind bereits seit den ersten PHP-Versionen
zur Arraybehandlung im Einsatz. Arbeitet man mit einfachen Arrays, bieten sie
eine erstaunliche Flexibilität.
$lang['de'] = "Deutschland";
$lang['en'] = "England";
$lang['es'] = "Spanien";
$lang['fr'] = "Frankreich";
$lang['it'] = "Italien";
while (list($iso, $name) = each ($lang))
Listing 5.17: arrayoutwhile.php – Anstatt foreach kann man auch mit while arbeiten
{
echo "Das Kürzel {$iso} steht für {$name}";
}
Auf den ersten Blick erscheint dieser Ersatz für foreach unnötig kompliziert. Allerdings
ist die Anzahl der Elemente für list nicht begrenzt, was den Einsatz auch
auf kompliziertere Konstrukte ausdehnen kann. Der Ablauf dieses Beispiels sieht
folgendermaßen aus:
1. Die while-Schleife startet mit dem ersten Aufruf von each
2. each ruft den ersten Wert ab und übergibt ihn an list
3. list zerlegt das Element und packt die Werte in die Variablen
4. Die Schleife wird durchlaufen
5. Der Vorgang beginnt wieder bei 2. Wenn each nichts mehr findet, gibt es
FALSE zurück. Darauf reagiert auch list mit FALSE und der gesamte Ausdruck
wird FALSE, was while zum Abbruch der Schleife veranlasst.
Die Ausgabe entspricht Abbildung 5.7.
195

196
Daten mit Arrays verarbeiten
Array mit array_walk durchlaufen
Eine der wichtigsten Arrayfunktionen ist array_walk. Die Funktion ruft für jedes
Arrayelement eine so genannte Rückruffunktion auf. Damit kann man praktische
alles mit einem Array anstellen, was erforderlich ist. Das folgende Beispiel zeigt, wie
ein Array ausgegeben werden kann, wobei sich die Daten vielfältig behandeln lassen:
function CountryList($element)
{
list($iso, $name) = $element;
echo "Der Code für $name ist: $iso";
}
$lang[] = array('de', "Deutschland");
$lang[] = array('en', "England");
$lang[] = array('es', "Spanien");
$lang[] = array('fr', "Frankreich");
$lang[] = array('it', "Italien");
array_walk($lang, 'CountryList');
Listing 5.18: arraywalk.php – Array mit benutzerdefinierter Funktion durchlaufen
Die Funktion array_walk sorgt dafür, dass die Elemente nacheinander an die
benutzerdefinierte Funktion CountryList übergeben werden. Die weitere Verarbeitung
ist nur ein Beispiel. Es handelt sich hier um ein Array, dessen Elemente
wiederum Arrays sind. Da list zur Übertragung der Elemente in Variablen
benutzt wird, sind numerische Indizes erforderlich. Das folgende Array erfüllt
diese Forderungen:
array('de', 'Deutschland')
Der interne Aufbau ist:
[0] => 'de'
[1] => 'Deutschland'
Für derartige Ausgaben ist übrigens die Funktion print_r sehr hilfreich.
Fehlersuche mit print_r
Zur Fehlersuche braucht man oft einen schnellen Überblick über den aktuellen
Aufbau eines Arrays. Die Funktion print_r erledigt das. Für die reine Program-

Arrays ausgeben
mierung ist der Einsatz kaum zu gebrauchen, die Ausgabe ist eher technischer
Natur und kann nicht formatiert werden.
Listing 5.19: print_r.php – Ausgabe eines Arrays zur Fehlersuche
Die Funktion verwendet außerdem einfache Zeilenumbrüche (\n) zur Formatierung.
Um die Darstellung in HTML zu ermöglichen, müssen diese entweder in
umgewandelt werden oder die Ausgabe steht zwischen -Tags.
Abbildung 5.8:
Ausgabe eines Arrays mit print_r zur Inhaltsanalyse
197

198
Daten mit Arrays verarbeiten
Mehr Analysemöglichkeiten für Skripte werden im Abschnitt 9.3 »Code röntgen:
Die Reflection-API« ab Seite 395 vorgestellt. Außerdem sei auch auf die neue
Funktion var_dump verwiesen, die sehr brauchbare Darstellungen komplexer
Arrays erzeugt.
5.5 Referenz der Arrayfunktionen
Funktion Bedeutung
array Erstellt ein neues Array aus konstanten Werten.
array_change_key_case Liefert das Array mit geänderter Groß- und Kleinschreibung
der Schlüssel.
array_chunk Zerlegt ein Array in zwei Teile und gibt beide Teile als
Arrays zurück.
array_combine Verbindet ein einfaches Array mit Schlüsseln und eines mit
Werten zu einem assoziativen Array.
array_count_values Ermittelt die Häufung von Werten in einem Array.
array_diff Ermittelt die Unterschiede mehrerer Arrays anhand der
Werte.
array_diff_assoc Ermittelt die Unterschiede mehrerer Arrays anhand der
Indizes.
array_diff_uassoc
array_udiff_assoc
Ermittelt die Unterschiede mehrerer Arrays anhand der
Indizes durch Nutzung einer benutzerdefinierten Rückruffunktion.
array_fill Füllt das Array mit bestimmten konstanten Werten unter
Angabe des Startindex.
array_filter Filtert ein Array unter Nutzung einer Rückruffunktion.
array_flip Vertauscht Schlüssel und Werte.
array_intersec Ermittelt die Schnittmenge mehrerer Arrays anhand der
Indizes.
Tabelle 5.1: Arrayfunktionen in PHP5, alphabetisch sortiert

Funktion Bedeutung
Referenz der Arrayfunktionen
array_intersec_assoc Ermittelt die Schnittmenge mehrerer Arrays anhand der
Schlüssel.
array_keys Gibt die Schlüssel eines assoziativen Arrays als einfaches
Array zurück.
array_map Ruft für jedes Arrayelement eine benutzerdefinierte Rückruffunktion
auf und akzeptiert für diese ein Array, das die
Parameter definiert.
array_merge Verbindet zwei oder mehr Arrays miteinander.
array_merge_recursive Verbindet zwei oder mehr Arrays miteinander, wobei identische
Schlüsselwerte sich überschreiben, während numerische
Indizes ignoriert und die Werte angehängt werden.
array_multisort Sortiert mehrdimensionale Arrays.
array_pad Füllt ein Array mit Werten zu einer bestimmten Größe auf.
array_pop Liefert das oberste Element eines Arrays und setzt den Arrayzeiger
zurück.
array_push Fügt ein Element als neues oberstes Element einem Array
hinzu.
array_rand Liefert zufällig ausgewählte Elemente eines Arrays.
array_reduce Verdichtet die Werte eines Arrays zu einem Wert mittels
benutzerdefinierter Rückruffunktion.
array_reverse Vertauscht die Elemente eines Arrays, sodass das letzte Element
nach der Operation das erste ist.
array_shift Liefert das erste Element eines Arrays und setzt den Arrayzeiger
zurück.
array_slice Extrahiert einen Teil aus einem Array und gibt diesen
zurück.
array_splice Entfernt einen Teil eines Arrays und ersetzt ihn durch ein
anderes Array.
Tabelle 5.1: Arrayfunktionen in PHP5, alphabetisch sortiert (Forts.)
199

200
Daten mit Arrays verarbeiten
Funktion Bedeutung
array_sum Die Summe aller numerischen Werte des Arrays.
array_udiff Ermittelt die Unterschiede mehrerer Arrays anhand der
Werte durch Nutzung einer benutzerdefinierten Rückruffunktion.
array_unique Entfernt doppelte vorkommende Werte aus einem Array.
array_unshift Fügt ein Element als erstes Element eines Arrays ein.
array_values Liefert die Werte eines assoziativen Arrays als einfaches
Array.
array_walk Ruft für jeden Wert eine Rückruffunktion auf.
arsort Sortiert assoziative Arrays absteigend.
asort Sortiert assoziative Arrays aufsteigend.
compact Erstellt ein Array aus skalaren Variablen.
count Ermittelt die Anzahl der Werte insgesamt.
current Gibt das aktuelle Element zurück, wenn mit Arrayzeigern
gearbeitet wird.
each Gibt das aktuelle Element zurück, wenn mit Arrayzeigern
gearbeitet wird und setzt den Zeiger eins weiter
end Setzt den Arrayzeiger auf das letzte Element im Array.
extract Exportiert die Werte eines Arrays als skalare Variablen.
in_array Ermittelt, ob ein Wert in einem Array enthalten ist.
key Gibt den aktuellen Schlüssel zurück.
krsort Sortiert assoziative Arrays absteigend nach den Schlüsseln.
ksort Sortiert assoziative Arrays aufsteigend nach den Schlüsseln.
list Übernimmt alle Unterelemente des aktuellen Elements in
Variablen.
Tabelle 5.1: Arrayfunktionen in PHP5, alphabetisch sortiert (Forts.)

Funktion Bedeutung
Referenz der Arrayfunktionen
natcasesort Sortiert »natürlich« aufsteigend ohne Rücksicht auf Groß-
und Kleinschreibung.
natsort Sortiert »natürlich« aufsteigend.
next Gibt das aktuelle Element zurück, wenn mit Arrayzeigern
gearbeitet wird und setzt den Zeiger eins weiter.
pos Gibt die aktuelle Position des Arrayzeigers zurück.
prev Gibt das aktuelle Element zurück, wenn mit Arrayzeigern
gearbeitet wird und setzt den Zeiger eins zurück.
range Erstellt ein Array mit definierten numerischen Werten.
reset Setzt den Arrayzeiger auf die erste Position im Array.
rsort Sortiert einfache Arrays absteigend.
shuffle Sortiert die Werte eines Arrays mit Zufallsgenerator.
sizeof Ein anderer Name für count.
sort Sortiert einfache Arrays aufsteigend.
uasort Sortiert assoziative Arrays durch benutzerdefinierte Funktion.
uksort Sortiert assoziative Arrays nach dem Schlüssel durch benutzerdefinierte
Funktion.
usort Sortiert einfache Arrays durch benutzerdefinierte Funktion.
Tabelle 5.1: Arrayfunktionen in PHP5, alphabetisch sortiert (Forts.)
201

202
Daten mit Arrays verarbeiten
5.6 Kontrollfragen
1. Worin unterscheiden sich normale von assoziativen Arrays?
2. Wie kann ein Element eines Array gezielt entfernt werden?
3. Schreiben Sie ein Skript, dass Arrays nutzt, um Namen von Mitarbeitern zu speichern.
4. Erweitern Sie das Skript, sodass zu jedem Mitarbeiter im selben Array zusätzliche
Informationen gespeichert werden. Tipp: Nutzen Sie verschachtelte assoziative
Arrays dafür.

Objektorientierte
Programmierung
6

204
Objektorientierte Programmierung
PHP5 hat in seiner Entwicklung in Bezug auf die objektorientierte Programmierung
einen großen Sprung vorwärts gemacht. Auch wenn PHP keine im klassischen
Sinne objektorientierte Sprache ist, sind erstmals professionelle Softwareentwicklungstechniken
in gewissem Umfang möglich.
Bei den Programmiersprachen gibt es verschiedene Modelle, wie Syntax und
Semantik aufgebaut sind. Alle Sprachen produzieren letztlich Code, der von
einem Prozessor verarbeitet werden muss. Prozessoren sind so genannte Von-Neumann-Maschinen,
die Befehlsinstruktionen immer sequenziell verarbeiten, wobei
sie vereinfacht einen Zyklus aus Speicheradresse aussenden, Speicher auslesen,
Befehl empfangen, Befehl verarbeiten und Ergebnis ablegen durchlaufen. Die ersten
Programmiersprachen folgten diesem Schema und waren so aufgebaut, dass
primär Befehl für Befehl abgearbeitet wird. Vom lateinischen Wort für Befehlen –
imperare – kommt auch der Name dieser Sprachen: Imperative Programmiersprachen.
Typische Vertreter sind BASIC und C.
Im Laufe der Zeit wurde Code immer komplexer und aufwändiger. Es entstanden
viele andere Versionen, von denen die objektorientierte weiteste Verbreitung fand.
Objektorientierte Sprachen fassen Code zu Objekten zusammen, die aus Eigenschaften
und Methoden bestehen. Wie in der Natur werden Daten und Daten
verarbeitende Funktionen zusammengefasst. Dies erleichtert die Wiederverwendbarkeit
und Organisation von Code erheblich und erlaubt erst größere Applikationen.
Typische Vertreter sind Java, C++, Delphi, C# und alle anderen .NET-
Sprachen.
Neben der Unterscheidung der Art der Programmiersprache ist auch die Konstruktion
des Sprachumsetzers wichtig. Denn der Prozessor versteht nur Maschinencode,
weshalb ein Übersetzungsvorgang stattfinden muss. Die ersten Sprachen
waren Interpretersprachen. Ein entsprechendes Programm übersetzte Befehl für
Befehl in Maschinencode. Weil dies in Schleifen uneffektiv ist – jeder Befehl wird
wieder und wieder übersetzt – entstanden so genannte Compiler. Diese übertragen
in einem Lauf erst alle Codes in die Maschinensprache und das Betriebssystem
lässt diesen Code dann ablaufen. Der Vorgang ist freilich aufwändiger und komplexer
und war deshalb immer »richtigen« Programmiersprachen vorbehalten, die
mit umfangreichen Entwicklungsumgebungen und vielen Hilfswerkzeugen ausgestattet
waren. Die ersten BASIC-Versionen in Homecomputern der 80er Jahre
waren immer Interpretersprachen, weil nicht genug Speicher zum Ablegen der
übersetzten Codes vorhanden war. C und C++ sind typische Compilersprachen.
Java und die .NET-Sprachen sind auch Compilersprachen, nutzen aber einen speziellen
Zwischencode, der eine zweifache Übersetzung erfordert. Dies erlaubt eine
stärkere Kontrolle des Codes durch eine so genannte Laufzeitschicht und macht

Warum objektorientiert programmieren?
die Sprachen systemunabhängiger. Aus den Interpretersprachen entwickelten sich
die Skriptsprachen, die mit reduziertem Sprachumfang und einfachster Verarbeitung
kleine Programmieraufgaben erledigen und geringe Ansprüche an Entwicklungsumgebung
und das Know-how des Entwicklers stellen. Hier sind die
typischen Vertreter VBScript, JavaScript, Perl und auch die ersten Versionen von
PHP.
PHP ist in der Version 5, wie inzwischen auch Perl, ein Zwitter. Denn zum einen
ist es eine Skriptsprache, die per Interpreter verarbeitet wird. Sie ist prinzipiell
imperativ strukturiert. Objektorientierte Sprachelemente sind vorhanden, deren
Verwendung wird aber nicht erzwungen, wie das bei »echten« objektorientierten
Sprachen der Fall ist. Die Verarbeitung basiert auf so genannten Token. Der Interpreter
zerlegt den Code also erst in einen eigenen Zwischencode – quasi ein dem
Kompilieren ähnelnder Vorgang – und führt diesen Code dann interpretativ aus.
Das ist effektiver als bei einem reinen Interpreter und vermeidet die Komplexität
eines echten Compilers. PHP selbst ist übrigens zu großen Teilen in C geschrieben,
was vielleicht als ein Hinweis auf die Leistungsfähigkeit und Einsatzbreite der
Sprachen wichtig zu wissen ist.
6.1 Warum objektorientiert programmieren?
Die Behandlung von Objekten wurde in PHP5 grundlegend überarbeitet. Dies
war von der Community vehement gefordert worden, weil große Projekte von vielen
verfügbaren Bibliotheken leben und derartige Codesammlungen ohne objektorientierte
Mittel kaum beherrschbar sind. Mit der zunehmenden Bedeutung von
PHP waren die Bibliothekenentwickler schnell an die Grenzen des bisherigen
Modells gestoßen.
Unabhängig davon profitieren auch kleine Projekte von objektorientierter Programmierung,
weil sie Code lesbarer und wartbarer macht. Nachteilig ist der etwas
höhere Schreibaufwand, der Anfänger oft davon abhält, sich damit auseinander zu
setzen.
Prinzipien und Paradigmen
Bei der objektorientierten Programmierung werden reale Sachverhalte in eine
Modellumgebung übertragen. Es ist also letztlich eine Technik zur Abstraktion.
205

206
Objektorientierte Programmierung
Bei imperativen Sprachen ist diese Abstraktion allein auf die Fähigkeit des Entwicklers
abgestellt. Objektorientierte Sprachen bieten hier eine explizite Unterstützung
durch Sprachelemente. Der Formalismus, der dazu benutzt wird, ist nicht
unbedingt trivial, hilft aber durch seine Strenge, besseren 1 Code zu entwickeln.
Die folgende Darstellung ist so weit vereinfacht, wie es zum Verständnis
von PHP5 erforderlich ist. Objektorientierte Techniken, die PHP5 nicht
unterstützt, werden nicht weiter betrachtet.
Das objektorientierte Modell nutzt folgende Begriffe:
Objekte und Klassen
Beziehungen und Eigenschaften von Objekten und Klassen
Kommunikation mit und zwischen Objekten
Objekte sind Abstraktionen von im Problembereich existierenden Einheiten, die
für das System relevante Informationen zusammenfassen oder mit denen im System
zusammengearbeitet wird. Ein solches Objekt besitzt statische und dynamische
Eigenschaften, die den Zustand des Objekts beschreiben, und Dienste, die
ein Objekt ausführen kann bzw. anbietet, abgebildet durch Methoden.
Objekte mit gleichen Eigenschaften und gleichen Methoden werden zu Klassen
zusammengefasst. Ein Objekt ist also Exemplar einer Klasse. Anders gedeutet ist
eine Klasse eine Vorlage, nach der gleichgeartete Objekte erzeugt werden. Die
Ableitung eines Objekts aus einer Klasse wird in der Literatur häufig als Instanziieren
bezeichnet. Auch wenn dies auf einer falschen Übersetzung des englischen
Begriffs »instance« basiert, ist der Begriff inzwischen etabliert (ähnlich wie beim
»Handy«).
Klassen können Hierarchien bilden. Ausgehend von einer Basisklasse »erben«
untergeordnete Strukturen deren Eigenschaften und Methoden, verändern einige
davon oder ergänzen weitere. Aus einfachen Klassen entstehen so immer komplexere
Gebilde. Das hat Vorteile bei der Wiederverwendbarkeit und Wartbarkeit von
Code. Ändert man Details einer Basisklasse, ändern sich die abgeleiteten Klassen
automatisch mit, was Eingriffe in Code oft drastisch reduziert – entsprechend clever
entworfene Modelle vorausgesetzt. Letzteres ist übrigens der Grund, warum
Anfänger davon kaum profitieren. Ohne lange Erfahrung werden Modelle falsch
oder unbrauchbar entworfen und statt des erhofften Designvorteils entsteht Chaos
und Konfusion.
1 Besser war im letzten Kapitel bereits als: »Schneller, Wartbarer, Lesbarer« definiert worden.

Syntax der Klassen
Wenn Klassen Abhängigkeiten haben, so haben deren Objekte diese auch.
Objekte können einander enthalten und Teil eines anderen sein – ebenso wie es
die Klassenhierarchie vorschreibt. Da Objekte alles enthalten, was Code zum
Ablauf braucht – Daten in Form von Eigenschaften und verarbeitbare Anweisungen
in Form von Methoden – führen sie gewissermaßen ein Eigenleben.
Ein reines objektorientiertes System kennt übriges ausschließlich Objekte. Das ist
ein Paradigma der objektorientierten Sprachen – sie erzwingen eine derartige Programmierweise.
Das heißt in der Praxis, dass auch die einfachste Ausgabe (wie mit
echo) das Anlegen wenigstens einer Klasse erfordert. Soweit geht PHP5 nicht –
imperative und objektorientierte Elemente können parallel verwendet werden.
6.2 Syntax der Klassen
Bevor so richtig objektorientiert gearbeitet werden kann, muss wenigstens eine
Klasse definiert werden. Dieser Abschnitt führt in die grundlegenden Prinzipien
der objektorientierten Programmierung ein.
Eine Klasse definieren
Objektorientierte Programmierung beginnt immer mit der Definition einer Klasse.
In PHP5 erledigt dies das in vielen Sprachen verwendete Schlüsselwort class.
Listing 6.1: ClassIntro1.php (erster Teil) – Definition einer Klasse

208
Objektorientierte Programmierung
Definiert wurde hier eine Klasse mit dem Namen FontElement. Später sollen daraus
Objekte erzeugt werden, die -Tags erzeugen und ausgeben, vielfältig
und flexibel formatiert, ohne dass HTML-Code geschrieben werden soll.
Sie enthält drei Eigenschaften: $face, $size und $color, die mit Standardwerten
belegt werden. Das Schlüsselwort public vor den Variablennamen deklariert sie als
öffentliche Mitglieder. Dazu und zu Alternativen später mehr. Neben den Eigenschaften
wurde auch eine Methode definiert: Output. Dies ist die einzige Aktion,
die ausgeführt werden kann.
Das Programm ist soweit zwar fehlerfrei lauffähig, tut jedoch gar nichts. Die Klasse
erlaubt die Erzeugung von Objekten, dies ist aber hier noch nicht passiert.
Ein Objekt erzeugen und benutzen
Objekte können Aktionen ausführen. Dazu muss man erst über ein solches verfügen.
In PHP5 erledigt dies das Schlüsselwort new:
Listing 6.2: ClassIntro1.php (zweiter Teil): Definition einer Klasse
$myfont = new FontElement();
echo 'Formatierte Ausgabe: ';
$myfont->Output('Mustertext');
Das neue Objekt wird in einer Variablen ($myfont) gespeichert. new erzeugt es und
dazu wird ihm der Name der Klasse mitgeteilt (FontElement). Das neue Objekt
kann nun sofort benutzt werden. Auf Eigenschaften und Methoden wird über die
Verweissyntax -> zugegriffen.
Freilich ist hier noch kein Vorteil gegenüber einem einfachen Funktionsaufruf zu
erkennen, wie er am Tag 7 behandelt wurde. Tatsächlich bietet das objektorientierte
Modell viel mehr.
Eine Klasse erweitern
Zuerst soll die Klasse erweitert werden. Dazu wird sie aber nicht einfach umgeschrieben,
denn möglicherweise ist sie in dieser Form bereits woanders im Projekt
im Einsatz. Besser ist es, von der Klasse zu erben und darauf aufbauend eine erweiterte
Version zu erzeugen. Das erfolgt in PHP5 mit dem Schlüsselwort extends.

Syntax der Klassen
Bei der Vorüberlegung, welche Struktur entstehen soll, ist leicht zu erkennen, dass
das -Tag keine brauchbare Basis darstellt. Besser wäre es, erstmal über ein
allgemeines »HTML-Element« zu verfügen und daraus speziellere Elemente
abzuleiten. Ein solches Basiselement könnte nun folgendermaßen aussehen:
Listing 6.3: ClassIntro2.php – Eine flexible Basisklasse für HTML-Elemente

210
Objektorientierte Programmierung
$element = new Element();
$element->name = 'font';
$element->style = 'font-size:22pt; font-weight:bold; color:red;';
$element->selfClosed = FALSE;
$element->Output('Mustertext');
?>
Die Basisklasse ist offensichtlich in der Lage, alle Arten von Elementen zu erzeugen.
Auf dieser Grundlage ist es nun leicht, spezialisiertere Klassen zu entwerfen,
die den Aufwand zur Erzeugung neuer Elemente reduzieren.
Listing 6.4: ClassIntro3.php – FontElement profitiert von den Fähigkeiten von Element
class FontElement extends Element
{
function __construct()
{
$this->name = 'font';
$this->selfClosed = FALSE;
}
}
$element = new FontElement();
$element->style = 'font-size:22pt; font-weight:bold; color:red;';
$element->Output('Mustertext');
Der einzige Unterschied zur Klasse Element ist die Einführung eines so genannten
Konstruktors, der bestimmte Eigenschaften fixiert.
Konstruktoren und Destruktoren
Immer wenn ein neues Objekt entsteht, also in dem Augenblick, wenn new ausgeführt
wird, beginnt das Leben des Objekts in einem undefinierten Zustand. Sie
haben bereits gesehen, wie das Objekt durch das Setzen der Eigenschaften nutzbar
wird. Oft wird jedoch der undefinierte Zustand nie benötigt, sondern das Objekt
soll von vornherein bestimmte Grundeigenschaften enthalten. Der Vorgang des
Erzeugens und Definierens kann daher zusammengefasst werden. Das passiert
durch die Einführung einer speziellen Methode, die im Augenblick der Erzeugung
automatisch aufgerufen wird: des Konstruktors.
Ein Konstruktor entsteht in PHP5 durch den reservierten Namen __construct.
(Achtung! Das sind zwei Unterstriche vor dem Wort.) Im letzten Beispiel wurde

Syntax der Klassen
dies benutzt, um dem Objekt vom Typ FontElement gleich die richtigen Eigenschaften
mitzugeben.
Ein Objekt existiert, wie alle anderen Variablen auch, bis zum Ende des Skripts
oder bis es gezielt zerstört, also auf NULL gesetzt oder mit unset vernichtet wird.
Normalerweise ergeben sich daraus keine Konsequenzen, PHP kümmert sich um
das Aufräumen des belegten Speichers. Es gibt jedoch Anwendungsfälle, in denen
externe Programme an der Kommunikation beteiligt sind, Datenbanken oder
Dateien beispielsweise. Nun wäre es fatal, wenn ein Objekt eine Verbindung zur
Datenbank herstellt und dann zerstört wird, während die Verbindung offen bleibt.
Es entstehen verwaiste Verbindungen – Zombies. Verfügt eine Datenbank nur
über primitive Kontrolltechniken oder eine begrenzte Anzahl von erlaubten Verbindungen,
führt dies früher oder später zu Fehlern, die zudem sporadisch und
schwer nachvollziehbar auftreten. Um das Verhalten am Ende der Existenz eines
Objekts zu kontrollieren, werden Destruktoren eingesetzt. Sie werden unmittelbar
vor der endgültigen Vernichtung aufgerufen.
Ein Destruktor entsteht in PHP5 durch den reservierten Namen __destruct.
(Noch einmal – das sind zwei Unterstriche vor dem Wort.)
Verhalten der Konstruktoren und Destruktoren bei der Vererbung
Bei der Vererbung wird die Sache etwas komplizierter. Denn jede Klasse in der
Hierarchie kann einen eigenen Konstruktor 2 haben. Wenn nun ein Objekt erzeugt
wird, könnten sich die Effekte der Konstruktoren überlagern. Deshalb führt PHP5
nur den letzten Konstruktor aus. Hätte im letzten Beispiel auch die Klasse Element
einen Konstruktor, so wäre dieser beim Aufruf von FontElement nicht ausgeführt
worden. Es bleibt dem Entwickler überlassen, den Aufruf des Konstruktors der
Elternklasse explizit zu erzwingen:
function __construct()
{
parent::__construct();
}
Das reservierte Wort parent verweist auf die Klasse, von der mit extends geerbt
wurde. Der Konstruktor wird über seinen Namen aufgerufen. Hinter parent darf
nur mit dem statischen Verweisoperator :: gearbeitet werden, weil zum Zeitpunkt
des Konstruktoraufrufs das Objekt noch nicht existiert und deshalb die Definition
2 Für Destruktoren gilt das ebenso, auch wenn diese nicht immer explizit erwähnt werden.
211

212
Objektorientierte Programmierung
direkt benutzt wird. Mehr zu statischen Mitgliedern und dem neuen Verweisoperator
folgt im nächsten Abschnitt.
Konstruktoren können Parameter wie jede andere Methode besitzen. Die Angabe
erfolgt zusammen mit dem new-Operator hinter dem Namen der Klasse:
$object = new SuperFontElement('color:red');
Die Verwendung von Parametern ist meist sinnvoll, um dem künftigen Objekt
zusätzlich individuelle Eigenschaften zu verpassen.
Statische Mitglieder und Konstanten
Statische Mitglieder von Klassen existieren nicht im Kontext des Objekts, sondern
der Klasse. Damit teilen sich alle Objekte einer Klasse diese Mitglieder, ganz
gleich ob es sich dabei um Eigenschaften oder Methoden handelt.
Es sind viele Einsatzfälle denkbar:
Nutzen Sie statische Mitglieder für Aufgaben, die keinen Bezug zu den spezifischen
Daten eines Objekts haben, beispielsweise Umrechnungen.
Statische Mitglieder erlauben die Implementierung von Verweiszählern, wie
beispielsweise Eigenschaften, die allen Objekten gleich sind.
Statische Mitglieder erlauben den direkten Aufruf ohne vorherige Instanziierung.
Dies ist sinnvoll, wenn man ohnehin nur ein Objekt benötigt.
Ein Zähler, der die Anzahl der bereits erzeugten Objekte ermittelt, kann beispielsweise
folgendermaßen implementiert werden:
Listing 6.5: ClassStatic.php – Die Anzahl von Objektinstanzen ermitteln

Syntax der Klassen
}
}
$obj1 = new ElementCounter();
$obj2 = new ElementCounter();
$obj3 = new ElementCounter();
printf('Es wurden %s Objekte erzeugt.', $obj3->GetObjectNumber());
?>
Der Trick besteht hier im Schlüsselwort static, das die Variable $counter in den
Klassenkontext überführt. Diese Variable existiert für alle Objekte nur einmal.
Wird nun ein neues Objekt erzeugt, wird der Wert im Konstruktor um Eins
erhöht. Beachten Sie hier, dass der Verweis mit $this nicht gelingen kann, weil es
kein Objekt- sondern ein Klassenverweis ist, der benötigt wird. Für letzteren wird
der Klassenname benutzt, gefolgt vom statischen Verweisoperator :: und dem vollständigen
Namen der Variablen, inklusive dem $-Zeichen. Das gilt sowohl für
Zugriffe innerhalb der Klasse, wie im Beispiel gezeigt, als auch für externe. Dabei
gelingen externe Zugriffe nur, wenn kein oder der Modifizierer public verwendet
wird.
Ein sehr typisches Designelement in der objektorientierten Programmierung sind
so genannte Singleton-Klassen. Dies sind Klassen, die nur ein einziges Objekt
erzeugen dürfen. Oft sind auch in objektorientierten Ansätzen nämlich nicht Dutzende
Objekte im Spiel. Ein imperativer Ansatz würde jedoch das Konzept der
Wiederverwendbarkeit stören. Der Ausweg sind Singleton-Klassen. Um dies zu
sichern, benötigt man zwei Techniken. Zum einem muss der Konstruktor »versteckt«
werden. Dies erfolgt mit dem Schlüsselwort private. So wird verhindert,
dass der verwendende Code fälschlicherweise mit new weitere Objekte erzeugt.
Stattdessen wird eine statische Methode angeboten, die die Instanziierung übernimmt
und dabei prüft, ob bereits ein Objekt existiert. Der erneute Aufruf von new
referenziert dann immer wieder dasselbe Objekt.
Listing 6.6: ClassSingleton.php – Volle Kontrolle über die Objekterzeugung

214
{
Objektorientierte Programmierung
Singleton::$instance = new Singleton();
}
return Singleton::$instance;
}
function setText($text)
{
$this->text = $text;
}
function getText()
{
return $this->text;
}
}
class Hello
{
function __construct()
{
$single = Singleton::instance();
$single->setText('Hallo Welt!');
}
}
class Goodbye
{
function __construct()
{
$single = Singleton::instance();
$single->setText('Und tschüß...');
}
}
$single = Singleton::instance();
echo ( $single->getText().'' );
$hello = new Hello();
echo ( $single->getText().'' );
$hello = new Goodbye();
echo ( $single->getText().'' );
?>
Das Beispiel nutzt in jeder Klasse, die Singleton verwendet, immer wieder dasselbe
Objekt, weil eine erneute Erzeugung im Rahmen eines einfachen Methodenaufrufs
völlig sinnlos wäre – man hätte am Ende nur eine Anzahl verwaister Objekte
im Speicher. In der Praxis wird diese Technik benutzt, um Ressourcen schonend

Syntax der Klassen
zu programmieren. Verbindungen zu Ressourcen, die nur einmalig vorhanden
sind, wie beispielsweise Dateien, werden über Singleton-Klassen verwaltet.
Konstanten in Objekten
Konstanten können auch in Objekten verwendet werden. Vor PHP5 waren Konstanten
immer global, was den Einsatz etwas problematisch machte, weil leicht
Namenskonflikte auftraten. Da sich Konstanten von Objekt zu Objekt nicht
ändern, verhalten sie sich wie statische Mitglieder und werden auch genau wie
diese verwendet. Der einzige Unterschied besteht darin, dass sich der Inhalt zur
Laufzeit nicht verändern lässt.
Im Gegensatz zu den globalen Konstanten, die mit define erzeugt werden, erfolgt
die Vereinbarung in Klassen mit dem Schlüsselwort const:
const WIDTH = 800;
Da Konstanten zwangsläufig in allen Instanzen identisch sind, verhalten sie sich
wie statische Mitglieder. Der einzige Unterschied besteht darin, dass sie nicht
geschrieben werden können – außer bei der Definition. Diese Definition erfolgt
auf Ebene der Klasse, wo auch alle anderen Eigenschaften, Methoden und Variablen
definiert werden.
Zugriffskontrolle
Meins, deins, für alle: private, public, protected
Generell sind in PHP5 alle Variablen global. Definitionen innerhalb einer Funktion
sind dort lokal. Zum Übergang benutzt man das Schlüsselwort global. In der
objektorientierten Programmierung ist das bei weitem nicht genug. PHP5 bietet
hier gleich drei neue Schlüsselwörter für den Variablenschutz:
public
Der Standardwert hat nun sein eigenes Schlüsselwort. Derart deklarierte Variablen
oder Methoden sind im gesamten Skript sichtbar. Aus Gründen der
Abwärtskompatibilität kann die Angabe entfallen.
private
Die so deklarierte Variable oder Methode ist nur innerhalb der Klasse sichtbar,
abgeleitete Klassen oder Aufrufe von Objekten können nicht zugreifen.
215

216
Objektorientierte Programmierung
protected
Dieses Schlüsselwort macht eine Variable oder Methode in den eigenen und
abgeleiteten Klassen sichtbar, aber nicht darüber hinaus (mehr als private und
weniger als public als Kurzformel).
Wenn Sie sich überlegen, wie die Deklaration konkret erfolgen soll, versuchen Sie
zuerst so restriktiv wie möglich zu deklarieren, also alles private zu machen. Dann
ändern Sie gezielt die Werte, die unbedingt woanders im Zugriff sein müssen.
Generell ist es jedoch ein gute Idee, den Zugriffsweg zu kontrollieren. So könnte
man eine Klasse mit einer öffentlichen Eigenschaft immer folgendermaßen erstellen:
class Test
{
public $sTest;
}
Besser ist es, den Weg der Daten in die Variablen und hinaus zu kontrollieren:
class Test
{
private $sTest;
public GetTestString()
{
return $this->sTest;
}
public SetTestString($st)
{
$this->sTest = $st;
}
}
Es ist nun leicht, in den Zugriffsmethoden Prüfungen und ein ordentliches Fehlermanagement
einzubauen, was ein öffentlicher Zugriff auf eine Mitgliedsvariable
nicht erlaubt.
Finale Klassen und Methoden: final
Dass sich Klassen leicht vererben lassen, wurde anhand des Schlüsselworts extends
bereits gezeigt. Manchmal soll dies aber nicht so sein, entweder für eine Klasse als
solche oder auch nur für einzelne Methoden. Denn manche Methoden sind für
die Funktion der Objekte von elementarer Bedeutung. Gelingt der Schutz mit

Syntax der Klassen
private nicht, weil der Zugriff von außen anderweitig benötigt wird, muss das
Überschreiben verhindert werden. Dies erledigt das Schlüsselwort final. Von
einer so gekennzeichneten Klasse kann nicht geerbt werden, bei »finalen« Methoden
ist das Überschreiben verboten.
Aufforderung zur Implementierung: abstract
Werden Klassen oder Methoden als abstract gekennzeichnet, wird der Benutzer
explizit dazu aufgefordert, hier eigenen Code zu schreiben. Praktisch ist dies das
Gegenteil zu final – statt dem ausdrücklichen Verbot folgt nun das ausdrückliche
Gebot. Der Schreiber der Klassen gibt damit Struktur, Namen und Aufbau vor,
nicht jedoch die konkrete Implementierung, weil dies möglicherweise von der
Anwendung abhängt.
Eine Ableitung von Objekten von abstrakten Klassen ist nicht möglich. Es muss
deshalb immer eine Implementierung erfolgen. Das gilt auch für abstrakte Methoden.
Es ist jedoch möglich, eine Klasse als abstrakt zu definieren und einige der
Methoden bereits voll auszuformulieren. Das folgende Beispiel zeigt dies. Während
eine Instanziierung der Klasse Senior nicht gelingt, ist diese mit Junior möglich.
Auch der Aufruf der in der abstrakten Klasse Senior (als nicht abstrakt)
definierten Methode GetText gelingt wie erwartet:
Listing 6.7: ClassAbstract.php – Abstrakte Klassen können nur über extends benutzt werden
217

218
Objektorientierte Programmierung
Um den Benutzer der Klasse zu zwingen, auch die Methode GetText selbst zu
schreiben, wird diese ebenfalls als abstract definiert und der Inhalt entfernt:
abstract class Senior
{
protected $text = 'Hallo Senior!';
abstract function GetText();
}
PHP5 reagiert mit zwei typischen Fehlermeldungen, wenn die Zuordnung hier
nicht stimmt. Der erste Fall tritt auf, wenn eine abstrakte Methode Code enthält:
Abbildung 6.1:
Es wurde versucht, eine abstrakte Methode zu definieren
Der zweite Fall tritt auf, wenn vergessen wurde, eine abstrakte Methode in einer
abgeleiteten Klasse zu implementieren:
Abbildung 6.2:
Eine abstrakte Methode wurde nicht implementiert
An dieser Stelle sei bereits auf Schnittstellen – Interfaces genannt – verwiesen die
eine ähnliche Rolle wie abstrakte Klassen übernehmen. Mehr dazu finden Sie im
Abschnitt 6.3 »Schnittstellen zur Außenwelt«.
Klonen erlaubt: clone und die Methode __clone()
Klonen ist ein typischer Vorgang in der objektorientierten Welt. Bislang wurde in
PHP immer eine vollständige Kopie eines Objekts übergeben, wenn die Zuweisung
an eine andere Variable erfolgte. Damit sind natürlich auch Verweise, die das
ursprüngliche Objekt hatte, Teil der Kopie. Das kann gewollt sein, meist ist es
jedoch so, dass man eher mit einem einzigen Verweis, beispielsweise auf eine
Datenbank oder Datei, arbeiten will, unabhängig von der Anzahl der Objekte. Die
folgende Version erlaubt mehr Kontrolle über den Kopiervorgang:
$clone = clone $object;

Syntax der Klassen
Dies entspricht dem Aufruf der Methode __clone() des Quellobjekts. Sie können
nun diese Methode (mit exakt diesem Namen) anlegen und den Kopiervorgang
kontrollieren. Oder Sie können den internen Mechanismus nutzen, der alle
Eigenschaften des Quellobjekts kopiert.
Betrachten Sie zuerst folgenden Code:
Listing 6.8: ClassClone.php – Klassen und direkte Verwendung von Objektkopien
class CloneClass
{
var $id;
}
$o1 = new CloneClass();
$o1->id = "1";
$o2 = $o1;
$o2->id = "2";
echo 'ID: ' . $o1->id;
Die Ausgabe zeigt, dass die beiden Objekte $o1 und $o2 auf dasselbe Basisobjekt
verweisen:
ID: 2
Anders sieht es aus, wenn die Zuweisung den clone-Befehl nutzt:
Listing 6.9: CloneClass2.php – Der Klon enthält eine Kopie aller Eigenschaften
class CloneClass
{
var $id;
}
$o1 = new CloneClass();
$o1->id = "1";
$o2 = clone $o1;
$o2->id = "2";
echo 'ID: ' . $o1->id;
Dann wird ein unabhängiges Objekt instanziiert und die Zuweisung zu $o1 wirkt
sich in $o2 nicht mehr aus:
ID: 1
Das Verhalten der Klonierung kann mit __clone() beeinflusst werden. Diese
Methode existiert intern und kopiert alle Eigenschaften. Man kann sie jedoch
überschreiben und dann entscheiden, welche Eigenschaften zu kopieren sind.
219

220
Objektorientierte Programmierung
Listing 6.10: CloneClass3.php – Beeinflussung des Klonvorgangs über __clone()
class CloneClass
{
var $x;
var $y;
function __clone()
{
$this->y = 300;
}
}
$o1 = new CloneClass();
$o1->x = "100";
$o1->y = "100";
$o2 = clone $o1;
echo "XY: {$o2->x} x {$o2->y}";
Hier wird die Methode __clone() benutzt, um die Übertragung der Eigenschaften
zu beeinflussen.
Der in frühen Betaversionen kolportierte Zugriff über $that auf das zu
klonende Objekt war seit der RC1 nicht mehr verfügbar. Abgesehen von
der mangelnden Flexibilität erscheint der Verlust kruder Syntax verschmerzbar.
Insgesamt bleibt der Eindruck, dass ein wichtiges OOP-
Feature miserabel implementiert wurde.
6.3 Schnittstellen zur Außenwelt
Nicht jeder schreibt PHP-Skripte nur für sich selbst. Entwickler von Bibliotheken
– ganz gleich ob für die Öffentlichkeit oder das eigene Team – benötigen ganz spezielle
Techniken, um lesbaren, klar strukturierten und wieder verwendbaren Code
zu schreiben. Schnittstellen (Interfaces) sind eine sehr gute Methode dafür. Sie
sind neu in PHP5 eingeführt.

Schnittstellen (Interfaces)
Schnittstellen zur Außenwelt
Schnittstellen bieten eine gute Möglichkeit, die Verwendung eigener Klassen zu
kontrollieren. Ähnlich wie abstrakte Klassen bieten Interfaces nur eine Definition
der Struktur an, sie enthalten jedoch keinen Code. Dem potenziellen Nutzer einer
Bibliothek bieten sie die Chance, einen »gefilterten« Blick auf die Klassen zu werfen,
die die Bibliothek anbietet. Es kann nämlich aus technischen Gründen erforderlich
sein, bestimmte Teile der Bibliothek als öffentlich zu kennzeichnen.
Wenn nun in einem anderen Teil des Projekts Ableitungen von Klassen erfolgen,
so sollte sich die Verwendung an bestimmte Regeln halten. Aus der Tatsache, dass
Methoden oder Eigenschaften öffentlich sind, folgt nicht zwingend, dass diese zur
Implementierung geeignet sind. Die Information darüber, was wirklich »öffentlich«
im Sinne der freien Verwendung ist, definiert eine Schnittstelle. Der Name
ist Programm – es handelt sich um eine Vereinbarungsschnittstelle zwischen dem
ursprünglichen Entwickler der Klasse und dem Entwickler, der die Klasse später
verwendet. Zielgruppe sind also vor allem Programmierer, die Bibliotheken schreiben,
welche in Projekten angepasst und modifiziert werden sollen.
Schlüsselwörter
Wenn Sie kleinere Projekte erstellen und keinen Code anderen Entwicklern
zur Verfügung stellen, ist die Verwendung von Schnittstellen
meist nicht angebracht. Die Tatsache, dass PHP5 diese Funktionen bietet,
soll nicht dazu verleiten, sie unbedingt nutzen zu müssen.
Die Definition einer Schnittstelle wird mit dem Schlüsselwort interface eingeleitet.
Es darf keine Eigenschaften enthalten und von allen Methoden darf nur der
»Kopf« geschrieben werden; direkt abgeschlossen mit einem Semikolon, statt der
geschweiften Klammern.
Bei der Implementierung wird wie bei der Klassenvererbung vorgegangen, anstatt
extends wird jedoch das Schlüsselwort implements verwendet.
Herkunft und Mitgliedschaft
Beim Umgang mit komplexen Klassenhierarchien ist es oft notwendig, bei einem
Objekt zu ermitteln, von welcher Klasse es abstammt. Im Beispiel der HTML-Element-Klassen
lässt sich leicht eine solche Hierarchie entwickeln:
221

Element
StylableElement
ContainerElement
222
Objektorientierte Programmierung
FontElement
Die oberste Ebene definiert nur Elemente als solche, beispielsweise mit den
Eigenschaften Tag-Name und ID. Danach folgen weitere, speziellere Eigenschaften
bis hin zu einem konkreten HTML-Element (FontElement). Bei der Untersuchung,
ob ein Objekt nun ein Element aus der Hierarchie ist, wäre eine
Erkennung sehr aufwändig, weil es Dutzende HTML-Elemente gibt, die in verschiedenen
Stufen der Hierarchie stehen. Gleichzeitig stellt sich die Frage, was an
diesem Element öffentlich verwendet werden kann. Die Vereinbarung darüber
trifft man mit Hilfe einer Schnittstelle, beispielsweise IElement genannt.
Listing 6.11: ClassInterface.php – Schnittstellen definieren und implementieren

Schnittstellen zur Außenwelt
echo " ist ein Element";
}
?>
Das Beispiel definiert zuerst eine einfache Schnittstelle, die die Grundstruktur
aller Elemente enthält. Anschließend wird die erste Ebene der Implementierung
vorgenommen. Diese Klasse ist als abstrakt gekennzeichnet, weil ein »Element«
ohne weitere Definition seiner Eigenschaften unsinnig ist. Der Benutzer wird also
gezwungen, seine eigenen Elemente darauf aufbauend zu implementieren. Das
letzte Element in der Kette (die Zwischenstufen StylableElement und Container-
Element wurden hier zur Vereinfachung weggelassen) ist dann als final markiert,
weil es keine Varianten von gibt. Der Konstruktor legt die typischste Eigenschaft
des Elements fest, den Namen. Anschließend prüft das Skript, ob das Element
von einer bestimmten Schnittstelle abstammt:
if ($font instanceof IElement)
Ohne die Schnittstelle müsste man hier auf alle Element-Klassen prüfen, was
sicher deutlich aufwändiger ist. Außerdem kann man der Schnittstelle per Reflektion
(siehe dazu Abschnitt 9.3 »Code röntgen: Die Reflection-API«. Die zulässigen
öffentlichen Methoden entlocken, was die Gestaltung der abstrakten Basisklassen
vereinfacht.
Der Operator instanceof funktioniert freilich auch mit Klassen, er zeigt lediglich
an, dass ein Objekt von einer bestimmten Klasse oder Schnittstelle abstammt, ohne
Rücksicht auf die Vererbungskette. Alternativ kann die Funktion is_a verwendet
werden, die jedoch nicht so gut lesbaren Code ergibt:
if (is_a($font, 'IElement'))
Informationen über Klassen und Objekte
Typ-Informationen
PHP5 ist, wie alle Vorgängerversionen, seiner Tradition als Skriptsprache treu
geblieben. Dazu gehört neben anderen Merkmalen auch der Verzicht auf typisierte
Variablen. PHP5 legt intern selbst fest, welchen Datentyp eine Variable
annimmt oder eine Funktion zurückgibt. Es gibt zwar die bereits behandelten
Umwandlungsfunktionen, letztlich besteht aber kein Typzwang, wie er in »richtigen«
Programmiersprachen üblich ist.
223

224
Objektorientierte Programmierung
Bei kleineren Projekten ist der fehlende Zwang zur Deklaration (und Einhaltung)
des Typs meist zu tolerieren, weil sich Fehler mit überschaubarem Aufwand finden
lassen. Werden jedoch größere Bibliotheken entworfen, ist die Fehlersuche
ungleich schwerer und oft erst mit Hilfe spezieller Testapplikationen zu bewerkstelligen.
An dieser Stelle fehlt dann ein Typzwang, der zumindest elementare
Zuweisungs- und Konvertierfehler bereits auf der Parserebene verhindert.
Da die Programmierung in objektorientierter Art und Weise mit den hier vorgestellten
neuen Möglichkeiten von PHP5 zunimmt, wird sich der fehlende Typzwang
umso drastischer auf die Qualität des Codes auswirken – im negativen
Sinne. Um das ein wenig zu umgehen, wird die Typisierung quasi über die Hintertür
und nur für selbst definierte Klassen eingeführt. Erstaunlich inkonsequent,
wenn man bedenkt, dass nun dafür eine Syntax zur Verfügung steht, gleichwohl
aber nicht für eingebaute Typen verwendet werden darf.
Einzig für eigene als Klasse definierte Typen besteht die Möglichkeit, bei der
Angabe von Parametern einen »Typ-Hinweis« mitzugeben. Dies unterstützt die
Nutzbarkeit von Objekten, die aus einer Hierarchie entstammen.
Eigene Fehlerklassen erstellen
Bereits im letzten Kapitel war die neue Fehlerbehandlung ein Thema. Richtig leistungsfähig
wird man damit aber erst, wenn man eigene Fehlerklassen erstellen
kann. Dazu sind freilich Kenntnisse der objektorientierten Programmierung erforderlich,
weshalb dieser Teil erst jetzt folgt.
Eigene Fehlerklassen basieren immer auf einer Vererbung der internen Fehlerklasse
Exception. Dies verschafft der neuen Klasse einen Satz an Basismethoden,
die sehr hilfreich sind.
Zuerst ist ein Blick auf die eingebauten Methoden hilfreich, wie ihn das folgende
Beispiel ermöglicht:
Listing 6.12: TryCatchBasis.php – Die Leistungen der Exception-Klasse testen
try
{
throw new Exception('Das ist ein provozierter Fehler', 12345);
}
catch (Exception $e)
{

}
Schnittstellen zur Außenwelt
echo ('Fehlermeldung: ' . $e->getMessage() . '' );
echo ('Fehlercode: ' . $e->getCode() . '' );
echo ('Skriptname: ' . $e->getFile() . '' );
echo ('Zeilennnummer: ' . $e->getLine() . '' );
Die Ausgabe zeigt, dass die wichtigsten Informationen vorliegen, erzeugt durch die
folgenden Methoden:
getMessage
Die eigentliche Fehlermeldung, am Ort der Instanziierung übergeben.
getCode
Der Fehlercode, frei wählbar und hilfreich, um weiterführende Informationen
abzurufen.
getFile
Die Datei, in der der Fehler auftrat. Das ist das aktuelle Skript oder eine mit
include oder require eingebundene Datei.
getLine
Die Zeile, in der throw ausgelöst wurde. Dies ist hilfreich bei der Fehlersuche,
wenn man clever genug ist, mögliche Tests und throw eng beieinander zu
halten.
Listing 6.13: TryCatchExceptionClass.php – Eigene Exception-Implementierung

226
Objektorientierte Programmierung
}
}
function divide($by)
{
if ($by == 0)
{
throw new DivideByZeroError ('&nbsp;Division durch Null');
}
return 1 / $by;
}
$test = 0;
try
{
echo (divide($test));
}
catch (DivideByZeroError $ex)
{
echo $ex->getCode() . ' ' . $ex->getMessage();
}
?>
Um eigene Fehlerklassen zu schreiben, müssen Sie lediglich von der Basisklasse
Exception ableiten:
class DivideByZeroError extends Exception
Es steht Ihnen dann frei, das Verhalten der Basisklasse zu modifizieren. Im Beispiel
wird der Konstruktor überschrieben und der Aufruf des Konstruktors der
Basisklasse mit eigenen Fehlertexten ergänzt:
function __construct($message)
{
parent::__construct(self::PREFIX.$message, self::CODE);
}
Beliebt ist auch das Überschreiben von __toString. Diese Methode liefert eine
Zeichenkettenentsprechung der Klasse und verkürzt die Ausgabe der Meldung.
Beachten Sie außerdem die Syntax des Aufrufs des Konstruktors der Basisklasse mit
parent::.
Die Anwendung ist einfach. Haben Sie im Code einen Fehler festgestellt, wird
eine Instanz der Fehlerklasse mit new erzeugt und mittels throw ausgelöst:
throw new DivideByZeroError ('&nbsp;Division durch Null');

Schnittstellen zur Außenwelt
Es ist jetzt Aufgabe des Hauptprogramms, den Block von Code mittels try zu
umschließen, wo der Fehler auftreten könnte:
try
{
echo (divide($test));
}
Dann ist für jeden denkbaren Fehler (im Beispiel kann nur ein Fehler ausgelöst
werden) der passende catch-Zweig anzugeben:
catch (DivideByZeroError $ex)
Innerhalb des catch-Blocks kann dann auf den Fehler reagiert werden, beispielsweise
durch Ausgabe einer Fehlermeldung:
echo $ex->getCode() . ' ' . $ex->getMessage();
Die Ausgabe zeigt, wie die modifizierten Daten der selbst definierten Fehlerklasse
arbeiten:
Im nächsten Abschnitt zu __get und __set (siehe Seite 229) finden Sie eine weitere
Anwendung.
Spezielle Zugriffsmethoden für Klassen
Einige spezielle Zugriffsmethoden für Klassen erlauben sehr flexible und kompakte
Lösungen.
Der universelle Methodenaufruf mit __call()
Abbildung 6.4:
Spezifische Fehlermeldung, mittels try/catch verwaltet
Eine Funktion mit dem reservierten Namen __call wird immer dann aufgerufen,
wenn keine andere Funktion mit dem benutzten Namen existiert. Als Parameter
werden der Name der versuchsweise aufgerufenen Funktion und ein Array mit den
verwendeten Parametern übergeben. Theoretisch könnte man alle Methoden – bis
auf den Konstruktor – hier bündeln. Praktisch dürfte es sich eher um Ausnahmen
handeln, weil die exzessive Anwendung die Lesbarkeit beeinträchtigt.
227

228
Objektorientierte Programmierung
Das folgende Beispiel zeigt die Anwendung. Es speichert Namen und gibt diese
über Methodenaufrufe in verschiedenen Versionen wieder aus:
Listing 6.14: ClassCall.php – Methodenaufrufe über die Sammelstelle __call()
Das Beispiel zeigt, dass Code durchaus kompakter werden kann. Voraussetzung ist
jedoch, dass der Inhalt der so zusammengefassten Methoden überschaubar ist. Bei
den hier zur Demonstration eingesetzten Einzeilern ist dies sicher ideal.
Abbildung 6.5:
Ausgabe des Skripts ClassCall.php

Schnittstellen zur Außenwelt
Der universelle Eigenschaftenaufruf mit __get() und __set()
In ganz engem Zusammenhang mit dem universellen Methodenaufruf steht die
Bildung von Eigenschaften. Echte Eigenschaften gab es bislang in PHP nicht, die
Bereitstellung von öffentlichen Variablen reicht dazu allein nicht aus. Eigenschaften
erlauben es nämlich, die Daten, die hinein geschrieben werden, bei der
Zuweisung oder Rückgabe zu kontrollieren. Ebenso kann vor dem Abruf der
Daten eingegriffen werden. Im Sinne einer sicheren Programmierung ist es nun
möglich, den Datenfluss besser zu kontrollieren. Allerdings stellt PHP keinen dedizierten
Weg zur Bildung von Eigenschaften bereit, wie dies andere Sprachen tun,
sondern nur einen universellen über die Pseudoeigenschaftsmethoden __get
(Lesen) und __set (Schreiben).
Das folgende Beispiel zeigt eine Anwendung, in der verhindert wird, dass der Aufrufer
versehentlich den Namen löscht und – falls dies trotzdem passiert ist – daran
gehindert wird einen leeren Namen zu lesen. Diese Klasse ist quasi »gentlemanlike«
programmiert. Sie akzeptiert alles und liefert dennoch nur sinnvolle Werte
zurück. Damit eventuelle Fehlermeldungen auch einen gesicherten Weg aus der
Klasse herausfinden, werden zwei eigene Exception-Klassen benutzt und die Fehler
mit try/catch abgefangen:
Listing 6.15: ClassProperties.php – Kontrolle über den Datenfluss mit Eigenschaften

230
{
}
Objektorientierte Programmierung
switch ($property)
{
case 'Name':
if (preg_match('~^[A-Z][a-z]{3,}$~', $this->name))
{
return $this->name;
}
else
{
throw new NameException('Name hat falsches Format: '
. $this->name);
}
break;
case 'Age':
if (preg_match('~^\d{1,2}$~', $this->age))
{
return $this->age;
}
else
{
return 0;
}
break;
}
public function __set($property, $value)
{
switch ($property)
{
case 'Name':
if (preg_match('~^[A-Z][a-z]{3,}$~', $value))
{
$this->name = $value;
}
else
{
throw new NameException('Name hat falsches Format: '
. $value);
}
break;

Schnittstellen zur Außenwelt
case 'Age':
if (preg_match('~^\d{1,2}$~', $value))
{
$this->age = $value;
}
else
{
throw new AgeException('Alter hat falsches Format: '
. $value);
}
break;
}
}
}
$m1 = new Member();
try
{
$m1->Name = 'Mustermann';
$m1->Age = 43;
echo "{$m1->Name} ist {$m1->Age} alt.";
}
catch (NameException $nex)
{
echo $nex->getMessage();
}
catch (AgeException $aex)
{
echo $aex->getMessage();
}
?>
Die beiden Exception-Klassen unterscheiden sich nicht vom Original, sie werden
lediglich benutzt, um die Fehlermeldungen selbst mittels catch auseinander
zuhalten. Entsprechend bescheiden sieht die Definition aus:
class AgeException extends Exception
{
}
Die eigentliche Klasse definiert für die Eigenschaften sowohl __get als auch __set.
Mittels einer switch-Anweisung werden zwei Eigenschaften gebildet, name und
age. In beiden Fällen werden die Daten mittels regulärer Ausdrücke geprüft. Entsprechen
sie nicht den erwarteten Wertebereichen, wird mittels throw new eine
231

232
Objektorientierte Programmierung
spezifische Ausnahme ausgelöst. Die fest programmierten Daten des Musterskripts
funktionieren. Die folgende Zeile sorgt für die Ausgabe:
echo "{$m1->Name} ist {$m1->Age} alt.";
Diese Zeile wird nicht erreicht, wenn die Daten nicht den Erwartungen entsprechen.
Beträgt beispielsweise die Altersangabe 112, wird bei der Zuweisung (__set)
die Ausnahme AgeException ausgelöst:
throw new AgeException('Alter hat falsches Format: ' . $value);
Der try-Zweig bricht dann sofort ab und PHP sucht nach einem passenden catch:
catch (AgeException $aex)
Hier kann nun eine Fehlerbehandlung stattfinden. Im einfachsten Fall besteht
diese aus einer schlichten Ausgabe der Fehlermeldung:
echo $aex->getMessage();
Abbildung 6.6:
Ausgabe, wenn die Daten gültig waren
Abbildung 6.7:
Ausgabe, wenn die Daten fehlerhaft sind
Auch wenn die Eigenschaftsmethoden __get und __set auf den ersten
Blick unsinnig erscheinen, entfalten sie jedoch im Zusammenspiel mit
anderen neuen OOP-Techniken eine hohe Leistungsfähigkeit. Dies
unterstützt vor allem die sichere, saubere Programmierung und damit
stabilere Software.
6.4 Analyse und Kontrolle von Objekten
Der Analyse und Kontrolle von Objekten kommt vor allem bei der Fehlersuche
eine große Bedeutung zu. Darüber hinaus kann man Bibliotheken universeller
und sicherer aufbauen, wenn die entsprechenden Techniken zum Einsatz kommen,
die in diesem Abschnitt beschrieben werden.

__METHOD__
Analyse und Kontrolle von Objekten
Die Konstante – gedacht als Erweiterung der bereits in PHP3 und 4 benutzten
__LINE__ und __FILE__ – enthält den Namen der aktuellen Methode. Vor allem
zur Fehlersuche ist die Angabe durchaus geeignet.
Beachten Sie, dass es sich in allen Fällen um zwei Unterstriche vor und
nach dem Namen handelt.
Listing 6.16: ClassMETHOD.php – Informationen über die Methoden einer Klasse
class BaseClass
{
public $x;
public $y;
public function SetX($x)
{
$this->x = $x;
echo __METHOD__ . '';
}
public function SetY($y)
{
$this->y = $y;
echo __METHOD__ . '';
}
}
$o1 = new BaseClass();
$o1->SetX(100);
$o1->SetY(100);
echo "XY: {$o1->x} x {$o1->y}";
Die Ausgabe klärt darüber auf, wann welche Methode aufgerufen wurde:
Abbildung 6.8:
Ausgabe der aktuellen Methode mit __METHOD__
233

234
Objektorientierte Programmierung
Zeichenkettenform: __toString()
Generell gibt es von jedem Objekt eine Zeichenkettenform. PHP5 erstellt diese
automatisch, wenn der Kontext es verlangt. Für die explizite Definition gibt es die
Methode __toString(). Betrachten Sie zuerst den Standardfall:
Listing 6.17: ClassToString.php – Ein einfaches echo gibt die Zeichenkettenform aus
class BaseClass
{
public $x;
public $y;
public function SetX($x)
{
$this->x = $x;
}
public function SetY($y)
{
$this->y = $y;
}
}
$o1 = new BaseClass();
$o1->SetX(100);
$o1->SetY(100);
echo $o1;
Die interne Form folgt etwa dem folgenden Muster:
Abbildung 6.9:
Zeichenkettendarstellung eines Objekts
Das ist meist wenig hilfreich, weshalb die Möglichkeit besteht, das Verhalten zu
ändern. Dazu wird eine öffentliche Methode __toString definiert, deren Rückgabewert
die Ausgabe bestimmt.
class BaseClass
{
public $x;
public $y;
public function SetX($x)
{
$this->x = $x;

}
public function SetY($y)
{
$this->y = $y;
}
public function __toString()
{
return 'Object BaseClass';
}
Analyse und Kontrolle von Objekten
Listing 6.18: ClassToStringO.php – Überschriebene __toString()-Methode
}
$o1 = new BaseClass();
$o1->SetX(100);
$o1->SetY(100);
echo $o1;
Mit der nun erfolgten Ausgabe kann man im Zweifelsfall etwas mehr anfangen.
Beachten Sie wieder, dass es sich bei der Methode __toString() um
zwei Unterstriche vor dem Namen handelt.
Abstammung von Klassen und Objekten
Die Abstammung von Klassen und Objekten ist immer dann interessant, wenn die
Erstellung dynamisch erfolgt (Factory-Klassen) oder fremder Code benutzt wird.
Wovon ein Objekt abstammt
Abbildung 6.10:
Kundenspezifische Zeichenkettenentsprechung
Verschiedene Funktionen können in PHP benutzt werden, um die Abstammung
eines Objekts von einer Klasse festzustellen. Das mag auf den ersten Blick trivial
erscheinen, weil man ja beim Schreiben des Codes genau weiß, wovon ein Objekt
abstammt. Bei großen Bibliotheken, fremdem Code oder komplexen Hierarchien
235

236
Objektorientierte Programmierung
ist das nicht immer der Fall. Betrachten Sie zuerst ein triviales Beispiel, das das
Schlüsselwort instanceof nutzt:
Listing 6.19: ClassInstanceOf.php – Abstammung eines Objekts mit instanceof klären
class BaseClass
{
public $x;
public $y;
public function SetX($x)
{
$this->x = $x;
}
public function SetY($y)
{
$this->y = $y;
}
}
$o1 = new BaseClass();
$o1->SetX(100);
$o1->SetY(100);
if ($o1 instanceof BaseClass)
{
echo 'Object $o1 stammt von BaseClass';
}
else
{
echo 'Object $o1 stammt nicht von BaseClass';
}
Hat man eine Hierarchie, lässt sich die Frage nach der Abstammung klären:
Listing 6.20: ClassInstanceOfExt.php – Die Abstammung eines Objekts wird geklärt
class BaseClass
{
protected $x;
protected $y;
public function SetX($x)
{
$this->x = $x;
}
public function SetY($y)

Analyse und Kontrolle von Objekten
{
$this->y = $y;
}
}
class DerivedClass extends BaseClass
{
protected $x;
protected $y;
public function GetXY()
{
return "{$this->x}x{$this->y}";
}
}
$o1 = new DerivedClass();
$o1->SetX(100);
$o1->SetY(100);
if ($o1 instanceof BaseClass)
{
echo 'Object $o1 stammt von BaseClass';
}
else
{
echo 'Object $o1 stammt nicht von BaseClass';
}
Die Ausgabe beider Skripte ist identisch und zeigt im Fall des zweiten Beispiels,
dass ein Objekt immer auch von der Basisklasse abstammt:
Alternativ zu instanceof kann auch die Funktion is_a genutzt werden:
is_a($object, 'ClassName')
Die Lesbarkeit ist, nicht zuletzt wegen des wenig transparenten Namens, etwas eingeschränkt.
Dafür funktioniert die letzte Variante auch mit PHP 4, während
instanceof erst mit PHP5 eingeführt wurde.
Abstammungshierarchie von Objekten
Abbildung 6.11:
Jedes Objekt ist immer eine Instanz auch der Basisklasse
Um die Abstammungshierarchie von Objekten festzustellen, eignet sich die Funktion
is_subclass_of.
237

238
Objektorientierte Programmierung
Listing 6.21: ClassSubclassOf.php – Feststellen, ob eine Klasse von einer anderen
abstammt
class BaseClass
{
protected $x;
protected $y;
public function SetX($x)
{
$this->x = $x;
}
public function SetY($y)
{
$this->y = $y;
}
}
class DerivedClass extends BaseClass
{
protected $x;
protected $y;
public function GetXY()
{
return "{$this->x}x{$this->y}";
}
}
$o1 = new DerivedClass();
$o1->SetX(100);
$o1->SetY(100);
if (is_subclass_of($o1, 'BaseClass'))
{
echo 'DerivedClass stammt von BaseClass';
}
else
{
echo 'DerivedClass stammt nicht von BaseClass';
}
Im Beispiel ist der folgende Ausdruck wahr:
if (is_subclass_of($o1, 'BaseClass'))
Dagegen wäre der folgende Ausdruck falsch:

if (is_subclass_of($o1, 'DerivedClass'))
Referenz der OOP-Funktionen
Damit kann man, im Gegensatz zu instanceof, die tatsächliche Hierarchie feststellen
und nicht nur eine globale Zugehörigkeit.
Test- und Informationsmethoden
Weitere Testmethoden für Objekte und Klassen finden Sie in der Kurzreferenz am
Ende des Kapitels. Vor allem bei der Fehlersuche und zur Analyse fremden Codes
sind die Testmethoden interessant. Als Programmiermittel dürften sie sich weniger
anbieten.
6.5 Referenz der OOP-Funktionen
OOP-Schlüsselwörter
Schlüsselwort Beschreibung
class Deklariert eine Klasse.
var Deklariert eine öffentliche Mitgliedsvariable (veraltet, PHP 4-Syntax).
new Legt eine neue Instanz eines Objekts an.
extends Erweitert eine Klasse.
interface Deklariert eine Schnittstelle.
implements Implementiert eine Schnittstelle.
private Deklariert ein Mitglied einer Klasse als privat. Es ist damit für Aufrufer
der Klasse nicht sichtbar.
public Deklariert ein Mitglied einer Klasse als öffentlich. Es ist damit für alle
Aufrufer der Klasse sichtbar. Dies ist der Standardwert, das heißt, ohne
Angabe des Schlüsselwortes sind alle Mitglieder öffentlich.
protected Deklariert ein Mitglied einer Klasse als geschützt. Es ist damit für Aufrufer
der Klasse nicht sichtbar, kann jedoch in direkt abgeleiteten Klassen
benutzt werden.
239

OOP-Funktionen
240
Objektorientierte Programmierung
Schlüsselwort Beschreibung
parent Erlaubt den statischen Zugriff auf die Basisklasse.
Self Erlaubt den statischen Zugriff auf die eigene Klasse.
$this Pseudovariable zum Zugriff auf die Instanzform der eigenen Klasse.
const Deklariert eine Konstante im Kontext der Klasse.
try Leitet einen Block ein, der der Ausnahmebehandlung unterliegt
catch Leitet einen Block ein, der eine spezifische Ausnahme behandelt
throw Generiert eine Ausnahme
Funktion Beschreibung
call_user_method Ruft eine benutzerdefinierte Methode auf, verwendet jedoch
dazu die Funktionssyntax und nicht den direkten Aufruf mittels
des Operators ->. Dies kann sinnvoll sein, wenn der Programmkontext
explizit einen Funktionsaufruf verlangt oder
einer der Parameter dynamisch verändert werden soll.
call_user_method_array Ruft eine benutzerdefinierte Methode auf, verwendet jedoch
dazu die Funktionssyntax und nicht den direkten Aufruf mittels
des Operators ->. Außerdem kann ein Array mit den Parametern
übergeben werden, die die Methode erwartet.
class_exists Prüft, ob eine bestimmte Klasse deklariert wurde. Sinnvoll
beispielsweise nach dem dynamischen Einbinden von
Modulen.
get_class_methods Gibt ein Array der Methoden einer Klasse zurück. Dient vor
allem Analysezwecken.
get_class_vars Gibt ein Array der Eigenschaften einer Klasse zurück. Dient
vor allem Analysezwecken.
get_declared_classes Gibt ein Array mit allen deklarierten Klassen in PHP5 zurück.
Dies umfasst sowohl die eingebauten als auch die im Augenblick
der Abfrage selbst definierten.

Funktion Beschreibung
Referenz der OOP-Funktionen
get_object_vars Ermittelt die Eigenschaften eines Objekts. Dies ist gut zur
Analyse des Zustands, wenn nicht völlig klar, wie und wo das
Objekt instanziiert wurde.
get_parent_class Gibt die Klasse zurück, von der eine abgeleitete Klasse
abstammt.
is_a Gibt TRUE zurück, wenn das Objekt von der angegebenen
Klasse abstammt.
is_subclass_of Gibt TRUE zurück, wenn ein Objekt von der angegebenen
Basisklasse abstammt.
method_exists Gibt TRUE zurück, wenn die Methode existiert.
instanceof Gibt TRUE zurück, wenn das Objekt von einer Klasse
abstammt.
__toString() Verändert beim Überschreiben in einer Klasse die Zeichenkettenform
des Objekts. Die Zeichenkettenform wird immer
dann benutzt, wenn die Ausgabe eines Objekts direkt mit
echo oder print erfolgt oder der Kontext des Codes eine Zeichenkettenform
verlangt.
__call() Ruft dynamisch Methoden auf. Die so deklarierte Funktion
wird immer dann aufgerufen, wenn PHP in der betreffenden
Klasse keine Methode des verlangten Namens findet.
__get() Ruft dynamisch Eigenschaften zum Lesen auf. Die so deklarierte
Funktion wird immer dann aufgerufen, wenn PHP in
der betreffenden Klasse keine Methode des verlangten
Namens findet. Wenn man mit __set eine Eigenschaft definiert
und mit __get nicht, erhält man eine »Nur-Schreib«-
Eigenschaft.
__set() Ruft dynamisch Eigenschaften zum Schreiben auf. Die so
deklarierte Funktion wird immer dann aufgerufen, wenn PHP
in der betreffenden Klasse keine Methode des verlangten
Namens findet. Wenn man mit __get eine Eigenschaft definiert
und mit __set nicht, erhält man eine »Nur-Lese«-Eigenschaft.
241

242
Objektorientierte Programmierung
Funktion Beschreibung
__construct() Reservierter Name für den Konstruktor einer Klasse. Der Konstruktor
wird aufgerufen, bevor das Objekt erzeugt wird. Er
wird vor allem verwendet, um einen definierten Zustand zu
erzeugen. Auslöser ist der Aufruf des Schlüsselwortes new.
__destruct() Reservierter Name für den Destruktor einer Klasse. Der Destruktor
wird aufgerufen unmittelbar bevor das Objekt zerstört
wird. Er wird vor allem verwendet, um mit dem Objekt verbundene
Ressourcen zu bereinigen.
6.6 Kontrollfragen
1. Schreiben Sie ein Skript, dass die Namen von Mitarbeitern in einer eigens dafür
entwickelten Klasse speichert.
2. Erklären Sie den Unterschied zwischen private, public und protected.
3. Sie haben nur eine einzige Klasse in Ihrem Skript. Ist die Anwendung des Schlüsselwortes
protected sinnvoll? Begründen Sie die Antwort.
4. Welchen Vorteil bietet die Verwendung von __get und __set anstatt des direkten
Zugriffs auf öffentliche Eigenschaften, die mit public $name gekennzeichnet
sind?
5. Wie schreiben Sie eine Klasse, deren Objekte beim Aufruf von new einen definierten
Anfangszustand unabhängig von Parametern erhalten soll?
6. Wie schreiben Sie eine Klasse, von der nur eine Instanz erzeugt werden darf? Wie
nennt man dieses Entwurfsmuster?

Das Dateisystem
entdecken
7

244
Das Dateisystem entdecken
7.1 Dateizugriff organisieren
Das Dateisystem verwaltet Dateien und Ordner. PHP verfügt über einen umfassenden
Satz an Funktionen zum Lesen, Schreiben und Erzeugen von Dateien und
Verzeichnissen. Die Anwendung ist unkritisch, wenn man sich mit einigen grundlegenden
Techniken angefreundet hat.
Grundlagen
Der Begriff Dateisystem wird in PHP übrigens etwas weiter gefasst und
kann sich durchaus auf andere Server ausdehnen, die über HTTP oder
FTP benutzt werden.
Beim Umgang mit Datei- und Verzeichnisfunktionen sind einige Dinge wichtig.
Zum einen ist immer wieder von so genannten Handles die Rede. Dahinter verbergen
sich Variablen, die einen Zeiger auf eine Datei oder ein Verzeichnis enthalten.
Das Handle wird von jeder Funktion benutzt, um eine ganze bestimmte Datei
aufzurufen oder Verbindung zu einem Verzeichnis herzustellen. Intern handelt es
sich dabei um eine so genannte Ressource. Der prinzipielle Ablauf des Dateizugriffs1
erfordert fast immer folgenden Ablauf:
1. Anfordern der Ressource
2. Erstellen des Handles mit dem Verweis auf die Ressource
3. Benutzen des Handles zum Zugriff auf die Ressource
4. Schließen der Ressource, damit andere darauf zugreifen können
5. Vernichten des Handles (optional, meist automatisch am Skript-Ende erledigt)
Ein ähnlicher Ablauf wird auch für Datenbanken benutzt. In allen Fällen heißen
die im ersten und im vierten Schritt benötigten Funktionen typischerweise
xxx_open und xxx_close, wobei xxx die spezifische Art der Ressource näher
beschreibt. Bei den Dateifunktionen von PHP5 steht dafür meist »f« oder »file«.
Wichtig ist auch, dass die Ressourcen meist exklusiv geöffnet werden. Das heißt,
wenn ein Benutzer eine Datei liest oder schreibt, kann dies gleichzeitig kein anderer
tun. Das ist unproblematisch, wenn immer wieder mit neuen Dateien gearbeitet
wird, wie bei der Sitzungsverwaltung. Greifen aber alle Benutzer auf dieselbe
1 Soweit nicht explizit etwas anderes erwähnt wird, gelten diese Ausführung auch für den Verzeichniszugriff.

Dateizugriff organisieren
Datei zu , kann es entweder zu Programmfehlern (»Zugriff verweigert«) oder zu
langen Wartezeiten kommen. Dateien als Datenspeicher sind deshalb nur
begrenzt einsatzfähig. Stoßen sie an ihre Grenzen, kommen Datenbanken ins
Spiel, die fein granulierter sperren können (mal von SQLite abgesehen, dass
Dateien zum Speichern nutzt).
Der Zugriff über das Schema »Handle à Ressource« ist nicht allein auf Dateien
beschränkt, auch entfernte Server sind über die Protokolle http:// oder ftp://
erreichbar. Das erweitert den Einsatzspielraum gewaltig, weil man sich über die
eigentlichen Protokolle kaum Gedanken machen muss. Beim HTTP ist lediglich
zu beachten, dass die Laufzeiten eines Skripts erheblich länger sein können, weil
erst eine Verbindung aufgebaut werden muss. Das impliziert auch, dass diese Verbindung
fehlschlagen kann, was zusätzliche Fehlerabfragen erfordert. Daneben ist
auch zu beachten, dass meist nur lesend auf andere Server zugegriffen werden
kann.
Einsatzfälle
Einsatzfälle für den Datei- und Verzeichniszugriff gibt es ungeheuer viele. Hier
sollen nur ein paar Anregungen gegeben werden:
Abspeichern von Formulardaten
Datei-Explorer auf dem Server
Nachrichtenquelle für die News-Seite
Speicher fürs Gästebuch
Steuerung des Hochladens von Dateien
Informationsspeicher für ein Content Management System
Template-System-Steuerung
Protokolldateien erzeugen
Das ist sicher nur ein kleiner Ausschnitt. Anhand vieler kleiner Beispiele wird im Folgenden
eine Übersicht über die Anwendung der wichtigsten Funktionen gegeben.
245

246
Das Dateisystem entdecken
7.2 Praktischer Dateizugriff
Der Dateizugriff ist mit PHP relativ einfach. Eine breite Palette von Funktionen
steht zur Verfügung, um alle erdenklichen Zugriffe zu erledigen. Dabei werden
immer wieder einige Basistechniken benutzt, die Sie kennen sollten.
Prinzipien des Dateizugriffs
Es gibt mehrere Prinzipien beim Dateizugriff, die nicht nur für PHP gelten. Diese
sollten Sie kennen, damit die Wirkungsweise der verschiedenen Funktionen transparent
wird.
Dateizugriff
Grundsätzlich kann man zwei Gruppen von Funktionen unterscheiden, die PHP
beim Dateizugriff einsetzt:
Funktionen mit direktem Dateizugriff
Funktionen mit Datei-Handle auf eine geöffnete Datei
Funktionen mit direktem Dateizugriff benötigen einen Pfad. Sie lesen oder schreiben
die Daten und geben die Datei danach wieder frei. Ein späterer Zugriff benötigt
erneut diese Pfadangabe.
Anders funktionieren die zahlreichen Funktionen mit einem so genannten Datei-
Handle. Dabei wird mit einer Funktion ein Verweis auf die geöffnete Datei
erstellt, das Handle. Intern ist dies eine Ressource. Andere Funktionen benutzten
dann nur noch dieses Handle – gespeichert in einer Variablen – zum flexiblen
Zugriff. Am Ende der Zugriffe wird die Verbindung geschlossen, die Datei freigegeben
und das Handle weggeworfen. Vor allem bei wiederholten Zugriffen in
Schleifen ist dieses Verfahren einfacher und schneller.
Universeller Quellzugriff
PHP beherrscht das Konzept des Wrapper-Zugriffs (manchmal wird das auch als
Moniker bezeichnet). Dabei gilt als Dateipfad jede den Prinzipien einer URI (Uniform
Resource Identifier) entsprechende Form als zulässig. Der prinzipielle (vereinfachte)
Aufbau sieht etwa folgendermaßen aus:

wrapper://pfad/pfad/pfad/datei.extension
Praktischer Dateizugriff
Der Standard-Wrapper für Dateien heißt file:///. Er kann entfallen, weil PHP
ohne Angabe davon ausgeht, dass es sich um eine lokale Datei handelt. Gültige
lokale Pfadangaben sind beispielsweise:
/pfad/pfad2/datei.ext
Dies kennzeichnet einen absoluten Pfad auf dem aktuellen Laufwerk.
pfadrelativ/datei.ext
Dies kennzeichnet einen relativen Pfad, berechnet vom Ausführungsort des
Skripts an.
C:\pfad\datei.ext oder C:/pfad/datei.ext
Pfad mit Laufwerk unter Windows. Die Art der Schrägstriche spielt in PHP
keine Rolle.
\\sambasrv\sharedpath\local\datei.ext
Ein Pfad zu einem gemeinsamen Laufwerk auf einem Windows- oder Samba-
Server
file:///pfad/datei.ext oder file://c|pfad/datei.ext
Vollständige Angabe eines Pfades mit dem Wrapper. Beachten Sie, dass dieser
Wrapper mit absoluten Unix-Pfaden arbeitet, wenn der Pfad seinerseits mit /
beginnt, was oft zu Pfadangaben wie file:///pfad führt..
Neben dem Dateizugriff sind folgende Wrapper erlaubt:
http:// und https://
Hier erfolgt der Zugriff über HTTP auf einen remoten Server. https:// nutzt
eine verschlüsselte Verbindung. PHP arbeitet mit dem Standard HTTP 1.0
und löst eine GET-Anfrage aus. Grundsätzlich kann die Datei auf dem entfernten
Server nur gelesen werden.
Wenn der Zugriff durch Kennwort geschützt ist, kann folgende Syntax verwendet
werden, um per Skript einen Zugang zu bekommen:
http://benutzername:kennwort@www.adresse.de
ftp:// und ftps://
Hier erfolgt der Zugriff über FTP auf einen remoten Server. ftps:// nutzt eine
verschlüsselte Verbindung, wenn der Server dies unterstützt (sehr selten) und
benötigt eine PHP-Version, die SSL unterstützt. PHP kann die Datei auf dem
entfernten Server lesen und schreiben.
247

248
Das Dateisystem entdecken
Wenn der Zugriff durch Kennwort geschützt ist, kann folgende Syntax verwendet
werden, um per Skript einen Zugang zu bekommen:
ftp://benutzername:kennwort@www.adresse.de
php://
PHP verwendet intern bestimmte Kanäle (so genannte Streams) für den
Zugriff auf Datenquellen. Der php://-Wrapper gestattet den Zugriff darauf. Die
folgende Tabelle zeigt die möglichen Kanäle:
Kanal Bedeutung
stdin Standardeingabe des Betriebssystems
stdout Standardausgabe des Betriebssystems
stderr Fehlerausgabe des Betriebssystems
output Zugriff auf den Ausgabepuffer, der von print oder echo verwendet wird
input Zugriff auf den Eingabepuffer, der unverarbeitete Daten aus POST-Anfragen
enthält (Formulardaten)
filter Filter für Funktionen, die keine derartige Parametrisierung von Hause aus
unterstützten.
compress.zlib:// oder compress.bzip2://
Zugriff auf komprimierte Dateien, die beim Lesen automatisch entpackt
werden.
Zugriff auf Dateiinhalte
Eine andere Technik ist mit dem Zugriff auf den Inhalt der Datei verbunden.
Wenn man eine Datei liest, gibt es auch hier wieder mehrere Varianten:
Die gesamte Datei lesen oder schreiben
Die Datei zeilenweise lesen oder schreiben
Die Datei zeichenweise lesen oder schreiben
Das Lesen der gesamten Datei erfolgt entweder als Zeichenkette oder als Array.
Die Benutzung eines Arrays setzt voraus, dass es eine Möglichkeit gibt, den Inhalt
in Elemente zu trennen. Das gilt in der Regel nur für Dateiinhalte, die Text

Praktischer Dateizugriff
umfassen, der mit Zeilenumbrüchen arbeitet. Binäre Dateiinhalte (das sind auch
solche mit proprietären Formaten wie MS Word oder Excel) lassen sich damit
nicht verarbeiten. Beim Schreiben einer kompletten Datei muss beachtet werden,
dass von der Zielapplikation eventuell erwartete Zeilenumbrüche erzeugt werden.
Beim zeilenweisen Lesen wird davon ausgegangen, dass die Daten auch tatsächlich
in Zeilen angeordnet sind. Dann bieten sich Funktionen an, die das Erreichen
eines Zeileumbruchs anzeigen und damit eine bestimmte Aktion auslösen.
Binäre Daten kennen keine Zeilenumbrüche und können – ebenso wie natürlich
Textdateien – zeichenweise gelesen werden. Dazu wird ein so genannter Dateizeiger
eingesetzt. Der Dateizeiger zeigt auf ein konkretes Zeichen, das als nächstes
gelesen bzw. nach dessen Position geschrieben wird. Typischerweise wird während
der Abfrage von Zeichen in einer Schleife permanent überprüft, ob das Dateiende
bereits erreicht wurde.
Wichtige Konstanten
PHP liefert einige wichtige Konstanten, die den Umgang mit Pfadangaben und
Dateinamen vereinfachen:
DIRECTORY_SEPARATOR
Der Verzeichnistrenner. Unter Windows ist dies der Doppelpunkt.
PATH_SEPARATOR
Der Pfadtrenner. Unter Windows ist dies der Backslash, unter Unix der Schrägstrich.
GLOB_BRACE
GLOB_ONLYDIR
GLOB_MARK
GLOB_NOSORT
GLOB_NOCHECK
GLOB_NOESCAPE
Konstanten, die das Verhalten der glob-Funktion steuern.
PATHINFO_DIRNAME
PATHINFO_BASENAME
PATHINFO_EXTENSION
Konstanten, die das Verhalten der pathinfo-Funktion steuern.
249

250
Das Dateisystem entdecken
FILE_USE_INCLUDE_PATH
FILE_APPEND
FILE_IGNORE_NEW_LINES
FILE_SKIP_EMPTY_LINES
Konstanten, die das Verhalten verschiedener Datei-Funktionen steuern.
Nachrichtenquelle für eine News-Seite
Als erstes Beispiel soll eine Nachrichtenquelle für eine News-Seite mit Hilfe der
Dateifunktionen programmiert werden. Die Nachrichten werden in einer Textdatei
abgelegt. Sie sind dort zeilenweise angeordnet, das heißt, jede Nachricht
steht auf einer Zeile. Zuerst ein Blick auf die Textdatei:
Listing 7.1: news.txt (im Verzeichnis /data) – Die Nachrichten des Tages im Textformat
Das neue Buch "PHP5 und MysQL in 14 Tagen" ist erschienen.
PHP für Profis und Agenturen: www.phptemple.de!
PHP erneut erfolgreichste Skriptsprache im Web.
Auf der Website sollen diese Nachrichten untereinander ausgegeben werden:
Listing 7.2: filenewsreader.php – Ausgabe von Informationen aus einer Textdatei
$fh = fopen('data/news.txt', 'r');
if (is_resource($fh))
{
while ($line = fgets($fh))
{
echo

Praktischer Dateizugriff
{
echo "Datei nicht gefunden";
}
Dieses Skript nutzt zuerst fopen, um das Datei-Handle zu erhalten. Angegeben
werden muss der Pfad zur Datei und ein Parameter, der die Art des Zugriffs
bestimmt (siehe unten). Dann wird geprüft, ob tatsächlich eine Ressource zurückgegeben
wurde, was is_resource erledigt. In der Schleife wird dann Zeile für Zeile
mit fgets gelesen, wobei die Funktion den Inhalt der Zeile zurückgibt. Sind keine
Daten mehr vorhanden, wird FALSE zurückgegeben und die Schleife ist beendet.
Anschließend ist der Zugriff mit fclose zu beenden.
Die Funktion fopen ist enorm wichtig und wird nachfolgend genauer vorgestellt.
Dateizugriff mit der Funktion fopen
Abbildung 7.1:
Daten aus einer Datei lesen und formatiert ausgeben
Der Dateizugriff mit fopen ist elementar. Die Funktion ist deshalb unbedingt eine
nähere Betrachtung wert. Der grundsätzliche Aufbau kann dem folgenden Syntaxdiagramm
entnommen werden:
fopen (string pfad, string mode [, int incl [, resource ctx]])
Lediglich die ersten beiden Parameter sind Pflichtangaben. Interessant ist dabei
der zweite, eine Zeichenkette, die folgende Bedeutung hat:
251

252
Das Dateisystem entdecken
Modus Beschreibung
r Nur lesen, der Dateizeiger wird an den Anfang positioniert
r+ Lesen und Schreiben, der Dateizeiger wird an den Anfang positioniert
w Nur Schreiben. Der Dateizeiger wird an den Anfang gesetzt und eine vorhandene
Datei auf die Länge 0 gesetzt. Existiert die Datei nicht, wird sie erzeugt.
w+ Lesen und Schreiben. Der Dateizeiger wird an den Anfang gesetzt und eine
vorhandene Datei auf die Länge 0 gesetzt. Existiert die Datei nicht, wird sie
erzeugt.
a Nur Schreiben. Der Dateizeiger wird an das Ende gesetzt, zu schreibende
Daten werden angehängt. Existiert die Datei nicht, wird sie erzeugt.
a+ Lesen und Schreiben. Der Dateizeiger wird an das Ende gesetzt, zu schreibende
Daten werden angehängt. Existiert die Datei nicht, wird sie erzeugt.
x Erzeugen und Schreiben einer lokalen Datei. Wrapper außer file:/// können
nicht verwendet werden. Wenn die Datei bereits existiert, gibt fopen FALSE
zurück.
x+ Erzeugen und Öffnen zum Lesen und Schreiben einer lokalen Datei. Wrapper
außer file:/// können nicht verwendet werden. Wenn die Datei bereits existiert,
gibt fopen FALSE zurück.
Tabelle 7.1: Modi für fopen
Die einzelnen Dateisysteme gehen unterschiedlich mit dem Zeilenumbruch um.
Intern ist dieser durch ein Sonderzeichen definiert. Dabei gilt folgende Regel:
\n: Zeilenumbruch unter Unix
\r\n: Zeilenumbruch unter Windows
\r: Zeilenumbruch unter MacOS
PHP versucht möglichst flexibel damit umzugehen, damit unter Windows erstellte
Dateien auch auf Linux laufen und umgekehrt. Da es dennoch Probleme mit
anderen Applikationen geben kann, besteht die Möglichkeit ein »Transfer«-Flag
zu definieren, das PHP zur fortlaufenden Konvertierung veranlasst. Das Flag t
wird beim Öffnen dem Modus nachgestellt. Der Transfer funktioniert nur unter
Windows und veranlasst PHP, Dateien mit Unix-Zeilenumbrüchen in solche mit
Windows-Zeilenumbrüchen zu verwandeln. Damit das funktioniert, muss das t

Praktischer Dateizugriff
and einen der anderen Modifizierer vor dem optionalen +-Zeichen angehängt werden,
beispielsweise wt oder at+. Alternativ dazu kann man auch b (auf allen Systemen)
verwenden, um explizit mit Binärdateien zu arbeiten, wo jegliche Zugriffe
auf die Daten zu unterbleiben haben (rb, wb oder ab beispielsweise).
Wenn Sie bezüglich der Flags unsicher sind, verwenden Sie immer die
Kombination mit b. Es ist immer besser, die Daten in ihrer ursprünglichen
Form zu belassen, als unqualifizierte Änderungen anzubringen.
Der dritte Parameter ist optional. Er wird entweder auf TRUE oder FALSE gesetzt,
wobei FALSE der Standard ist. Die Angabe von TRUE veranlasst die Funktion beim
Öffnen der Datei den Suchpfad für Include-Dateien mit einzubeziehen, wenn die
Datei (bei relativen Pfadangaben) im aktuellen Verzeichnis nicht gefunden werden
konnte.
Der vierte Parameter ist nur sinnvoll einsetzbar, wenn der verwendete Wrapper
(http://, ftp:// oder php://) zusätzliche Angaben verlangt. Diese werden dann hier
platziert. Das erforderliche Format kann mit stream_context_create erstellt werden.
Diese Funktion selbst akzeptiert wiederum ein Array. Das folgende Code-
Fragment zeigt, wie die Anwendung erfolgt:
Für HTTP sind folgende Optionen vorgesehen:
253

254
Das Dateisystem entdecken
Option Beschreibung
method Methode, beispielsweise GET oder POST.
header Die Kopfzeilen (siehe Beispiel).
user_agent Information darüber, wie sich das Skript identifiziert. Man kann hier beispielsweise
den Namen eines Browsers eintragen.
content Daten, die an POST-Anforderungen angehängt werden.
proxy URI eines Proxy-Servers, beispielsweise tcp://proxy.zielserver.de:9900
request_fulluri TRUE oder FALSE, wobei die Angabe TRUE in der HTTP-Anforderung die
vollen Angabe der Zieladresse erzwingt (nicht üblich).
Tabelle 7.2: Kontext-Optionen für HTTP
Weitere Optionen der anderen Wrapper können der Online-Dokumentation entnommen
werden.
Beliebige Code-Dateien ausgeben
Im nächsten Beispiel werden PHP-Quelltexte angezeigt. Für diesen einfachen Fall
zeigt sich die Datei einfach selbst an.
Listing 7.3: filefile.php – Ausgaben einer Datei mit Zeilennummern
$path = basename($_SERVER['PHP_SELF']);
$file = @file($path);
if (is_array($file))
{
echo '';
for ($i = 0; $i < count($file); $i++)
{
printf('%04d: %s', $i, htmlspecialchars($file[$i]));
}
echo '';
}
Das Skript ermittelt zuerst den eigenen Namen aus der Servervariablen
$_SERVER['PHP_SELF'] mit der Funktion basename. Dann wird die Funktion file
benutzt, um den Inhalt der Datei in ein Array zu überführen. Sicherheitshalber

Praktischer Dateizugriff
wird noch mit is_array geprüft, ob dies auch gelang. Dann wird die Schleife vom
ersten bis zum letzten Arrayelement durchlaufen. Da Zeilennummern ausgegeben
werden sollen, bietet sich hier for an, womit gleich eine Zählvariable zur Verfügung
steht.
Die Funktion htmlspecialchars verhindert, dass die HTML-Zeichen und &
bei der Ausgabe ausgeführt werden. Zuletzt wird die Ausgabe noch mit printf formatiert,
wodurch die Zeilennummern auf gleiche Breite gebracht werden.
Protokolldatei
Das Schreiben einer Datei ist ebenso einfach wie das Lesen, entsprechende
Zugriffsrechte vorausgesetzt. Eine Protokolldatei zu schreiben, ist ein guter Test
für ein einfaches Skript. Benötigt werden der Zugriff auf eine Datei mit fopen und
die Schreibfunktion fwrite. Außerdem sind noch einige Daten zu beschaffen, die
geschrieben werden sollen:
Das aktuellen Datum und eine Zeitangabe (strftime)
Informationen über den Browser (Servervariablen aus $_SERVER):
Abbildung 7.2:
Ausgabe einer
Datei mit Zeilennummern
HTTP_USER_AGENT
Ermittelt die Kennung des Browsers, der gerade das Skript ausführt
HTTP_ACCEPT_LANGUAGE
Ermittelt Informationen über die Spracheinstellungen des Browsers
255

256
Das Dateisystem entdecken
REMOTE_ADDR
Die IP-Adresse, mit der der Rechner des Nutzers mit dem Internet verbunden
ist
Die praktische Umsetzung zeigt das folgende Skript:
Listing 7.4: fileprotocol.php – Daten über den aktuellen Benutzer speichern
$dt = strftime('%d.%m.%Y %H:%M:%S', time());
$bi = $_SERVER['HTTP_USER_AGENT'];
$al = $_SERVER['HTTP_ACCEPT_LANGUAGE'];
$ra = $_SERVER['REMOTE_ADDR'];
$fh = fopen('data/protocol.txt', 'a');
fwrite ($fh, sprintf("%s '%s' '%s' %s\n", $dt, $bi, $al, $ra));
fclose($fh);
$log = file_get_contents('data/protocol.txt');
echo

7.3 Verzeichniszugriff
Verzeichniszugriff
Der Verzeichniszugriff geht eng zusammen mit dem Dateizugriff. Die Funktionen
lassen sich gut kombinieren und für umfangreiche dateiorientierte Projekte nutzen.
Inhalt eines Verzeichnisses anzeigen
Um den Inhalt eines Verzeichnisses anzuzeigen, ist glob ein gute Funktion. Die
Angabe von Platzhaltern erlaubt eine höhere Flexibilität, als die reinen Verzeichnisfunktionen
bieten.
Einfache Dateiliste
Eine einfache Dateiliste lässt sich sehr leicht mit der Funktion glob erstellen. Das
folgende Skript zeigt alle PHP-Skripte an, die mit den Buchstaben »e« oder »f«
beginnen:
Listing 7.5: fileglob.php – Gefilterte Dateiliste
$path = basename($_SERVER['PHP_SELF']);
$files = glob("{[ef]*.php}", GLOB_BRACE);
if (is_array($files))
{
foreach ($files as $filename)
{
echo "$filename";
}
}
Die Funktion glob kann mit einigen Schaltern gesteuert werden, die in der folgenden
Tabelle erklärt werden:
Schalter Funktion
GLOB_BRACE Die Platzhalter verwenden Aufzählungssymbolik: {*.txt,*.php} usw.
GLOB_ONLYDIR Es werden nur Verzeichnisse erkannt
Tabelle 7.3: Schalter für die Funktion glob
257

258
Das Dateisystem entdecken
Schalter Funktion
GLOB_MARK Fügt einen Schrägstrich an alle erkannten Einträge an
GLOB_NOSORT Verhindert die Sortierung (Standard ist ein alphabetische Sortierung)
GLOB_NOCHECK Gibt das Suchmuster zurück, wenn keine Dateien gefunden
wurden
GLOB_NOESCAPE Meta-Zeichen (Verzeichnistrennzeichen) werden nicht mit einem
Backslash markiert (unter Windows unbedingt sinnvoll)
Tabelle 7.3: Schalter für die Funktion glob (Forts.)
Mehrere Schalter können über eine einfache Oder-Verknüpfung | kombiniert
werden:
GLOB_BRACE | GLOB_ONLYDIR
Die Platzhalterzeichen erlauben folgende Angaben:
{Platzhalter,Platzhalter}
Eine Serie von Platzhaltern, die ODER-verknüpft sind, werden durch Kommata
getrennt in geschweifte Klammern gesetzt. Dies funktioniert nur, wenn
der Schalter GLOB_BRACE verwendet wird.
*
Keines oder eine beliebige Anzahl Zeichen.
?
Genau ein beliebiges Zeichen.
[]
Genau ein Zeichen aus einer Zeichengruppe, die durch die Angabe in der
Klammer bestimmt wird. Dies kann eine Aufzählung aus Zeichen sein, beispielsweise:
[aef]
Steht für die Buchstaben »a« oder »e« oder »f«.
[a-f]
Steht für die Buchstaben »a«, »b«, »c«, »d«, »e« oder »f«.
[0-9]
Steht für die Zahlen 0 bis 9.

Verzeichniszugriff
Der gesamte Ausdruck in der Klammer kann negiert werden, indem das Zeichen
»!« vorangestellt wird:
[!eEfF]
Alle Zeichen außer »e«, »E«, »f« und »F«
Dieser Ausdruck muss in geschweiften Klammern stehen und funktioniert nur,
wenn der Schalter GLOB_BRACE verwendet wird.
Insgesamt betrachtet ist glob schnell und einfach einzusetzen. Reicht die Konstruktion
der Suchmuster jedoch nicht aus, muss man auf reguläre Ausdrücke ausweichen.
Abbildung 7.4:
Gefilterte Dateiliste mit der glob-Funktion
Manchmal soll nur festgestellt werden, ob eine Datei einem bestimmten Muster
entspricht. Dieselbe Syntax wie bei glob kann mit fnmatch verwendet werden. Um
eine Dateiliste zu durchsuchen, wird das dir-Objekt bemüht und dann mit
fnmatch untersucht.
259

260
Das Dateisystem entdecken
Das Verzeichnisobjekt dir und verwandte Funktionen
PHP kennt eine Klasse dir, aus der sich ein Verzeichnisobjekt erstellen lässt. Die
prinzipielle Anwendung zeigt das folgende Skript. Dazu wird auch gleich die
Funktion fnmatch definiert. Diese mit PHP 4.3 eingeführte Funktion steht leider
auch mit PHP5 nicht unter Windows zur Verfügung, was unverständlich ist, weil
die ebenso dem Unix-System entstammende Variante glob vorhanden ist. Um das
Skript universell zu machen, wird eine fnmatch-Variante selbst definiert.
Listing 7.6: filefnmatch.php – Verwendung von fnmatch und alternative Definition
if (!function_exists('fnmatch'))
{
function fnmatch($pattern, $file)
{
for($i=0; $i

}
foreach ($letter_set as $letter)
{
if(fnmatch($letter.substr($pattern, $k+1),
substr($file, $i)))
{
return TRUE;
}
}
return false;
}
if($pattern[$i] == "?")
{
continue;
}
if($pattern[$i] != $file[$i])
{
return FALSE;
}
}
return TRUE;
Verzeichniszugriff
}
$path = $_SERVER['SCRIPT_FILENAME'];
$self = dirname($path);
$dir = dir($self);
if (is_object($dir))
{
$dir->rewind();
while ($file = $dir->read())
{
if (fnmatch("[ef]*.php", $file))
{
echo "$file";
}
}
$dir->close();
}
Betrachten Sie zuerst nur den unteren Teil, der die Klasse dir verwendet. Hier
wird zuerst der physikalische Pfad zur aktuellen Datei ermittelt, weil das Verzeichnis
gelesen werden soll, in dem das Skript selbst liegt.
$path = $_SERVER['SCRIPT_FILENAME'];
261

262
Das Dateisystem entdecken
Die Servervariable SCRIPT_FILENAME wird hier verwendet, weil sie den kompletten
Pfad enthält und als einzige Variable sowohl unter dem IIS- als auch Apache-Webserver
zur Verfügung steht. Es gibt zwar viele vermeintliche Alternativen,
aber die funktionieren nie auf allen Systemen. Aus der Pfadangabe wird dann das
aktuelle Verzeichnis gewonnen:
$self = dirname($path);
Nun wird eine Instanz des Verzeichnisobjekts erstellt:
$dir = dir($self);
Nach einer Prüfung, ob es wirklich gelang, das Objekt zu erzeugen, wird die
interne Liste der Dateien auf den Anfang gesetzt:
$dir->rewind();
Dann wird in einer Schleife Eintrag für Eintrag gelesen:
while ($file = $dir->read())
Abbildung 7.5:
Gefilterte Dateiliste mit fnmatch

Verzeichniszugriff
Die Methode read gibt FALSE zurück, wenn keine Einträge mehr da sind. Innerhalb
der Schleife wird dann jeder Dateiname mit fnmatch untersucht:
if (fnmatch("[ef]*.php", $file))
Die Funktion fnmatch, ob eingebaut oder selbst definiert, durchsucht nun den
Dateinamen entsprechend dem angegebenen Suchmuster Zeichen für Zeichen
und gibt einen Booleschen Wert zurück (siehe Abbildung 7.5).
Zum Schluss sollen noch die Möglichkeiten, die dir bietet, auf einen Blick gezeigt
werden:
Eigenschaft Beschreibung
path Pfad, der zum Erzeugen des Objekts benutzt wurde
handle Verzeichnis-Handle, das andere Funktionen benutzen können
Tabelle 7.4: Eigenschaften der Klasse dir
Eigenschaft Beschreibung
read Liest den nächsten Eintrag aus dem Verzeichnis und gibt entweder
eine Zeichenkette oder FALSE zurück.
rewind Setzt den Lesezeiger wieder auf den ersten Eintrag zurück.
close Schließt das Handle zum Verzeichnis.
Tabelle 7.5: Methoden der Klasse dir
Die Benutzung des Handles ist dann interessant, wenn – aus welchen Gründen
auch immer – mit den anderen Verzeichnisfunktionen gearbeitet werden soll.
Diese Funktionen sind nicht objektorientiert, sondern werden ebenso wie die
Dateifunktionen benutzt. Eine Auflistung finden Sie in der Kurzreferenz am Ende
des Kapitels.
Rekursive Dateiliste
Das folgende Beispiel erweitert die Ausgabe der Dateiliste auf eine beliebige
Anzahl von Unterverzeichnissen. Die Technik der Rekursion bietet eine einfache
Lösung dafür:
263

264
Das Dateisystem entdecken
Listing 7.7: filerecursiveglob.php – Rekursive Version, um untergeordnete Verzeichnisse
zu lesen
function rglob($sDir, $sPattern, $nFlags = NULL)
{
$sDir = escapeshellcmd($sDir);
$aFiles = glob("$sDir/$sPattern", $nFlags);
foreach (glob("$sDir/*", GLOB_ONLYDIR) as $sSubDir)
{
$aSubFiles = rglob($sSubDir, $sPattern, $nFlags);
if (is_array($aSubFiles))
{
$aFiles = array_merge($aFiles, $aSubFiles);
}
}
return $aFiles;
}
$path = dirname(getcwd() . '/php5MuT');
echo "Liste der PHP-Skripte in $path:";
$aFiles = rglob($path, '{*.txt,a*.php}', GLOB_BRACE);
foreach ($aFiles as $filepath)
{
echo dirname(realpath($filepath)) . ' : ';
echo basename($filepath) . '';
}
Auch dieses Skript bietet wieder eine reiche Verwendung von Dateifunktionen.
Zuerst wird der Pfad ermittelt. Im Beispiel wird das aktuelle Arbeitsverzeichnis
(getcwd) und dort das Unterverzeichnis »php5MuT« genommen. Eine tiefere Verzeichnisstruktur
kann Probleme bereiten, da die Laufzeit des Skripts bei tiefer
Verschachtelung erheblich ist:
$path = dirname(getcwd() . '/php5MuT');
Nun wird die rekursiv programmierte Funktion rglob vorgestellt. Sie gibt ein Array
mit allen Dateien zurück, die dem Suchmuster entsprechen, wobei alle Dateien in
allen untergeordneten Verzeichnissen mit eingeschlossen werden. Bevor die
Details der rekursiven Funktion diskutiert werden, ist ein Blick auf die Ausgabe
interessant. glob liefert komplette Dateipfade. Um diese zu trennen wird zuerst der
vollständige Pfad mit realpath ermittelt, dann mit dirname der Pfad extrahiert. Für
basename, genutzt zum Abtrennen des Dateinamens, reicht die Nennung des
Pfades ohne Veränderungen.

Verzeichniszugriff
Die Funktion rglob selbst basiert im wesentlichen auf glob. Zuerst wird die aktuelle
Dateiliste gemäß dem gewählten Suchmuster erstellt:
$aFiles = glob("$sDir/$sPattern", $nFlags);
Das Muster folgt dabei den üblichen Platzhalterregeln. Zusammen mit der Konstanten
GLOB_BRACE kann außerdem eine Kette von Platzhalter angegeben
werden. Im Beispiel sieht dieses Muster folgendermaßen aus:
{*.txt,a*.php}
Dieses Muster betrifft alle Dateien mit der Endung »txt« und alle Dateien, die mit
dem Buchstaben »a« beginnen und auf »php« enden. Nach der Erstellung der
Dateiliste werden die untergeordneten Verzeichnisse gesucht:
glob("$sDir/*", GLOB_ONLYDIR)
Hier sorgt der Schalter GLOB_ONLYDIR für das gewünschte Resultat. Um die Dateien
innerhalb des gefundenen Verzeichnisses zu lesen, erfolgt als erste Maßnahme
innerhalb der foreach-Schleife der rekursive Aufruf. Die Ergebnisse werden dann
mit array_merge an das bestehende Array angehängt. Damit leere Verzeichnisse
nicht stören, wird noch eine Abfrage mit is_array davor geschaltet.
Verzeichniszugriff mit Iteratoren
Iteratoren durchlaufen Auflistungen, vorzugsweise mit foreach. Das Konzept
wurde neu in PHP5 eingeführt und ist Teil der so genannten Standard PHP
Library. Alle Iteratoren implementieren die Schnittstelle Iterator. Dies führt zu
den folgenden Methoden:
current()
Die Methode gibt das aktuelle Element der Auflistung zurück.
next()
Die Methode setzt einen Schritt in der Auflistung weiter.
valid()
Die Methode gibt TRUE zurück, wenn ein weiteres Element beim vorhergehenden
Aufruf von next gefunden wurde, sonst FALSE.
rewind()
Mit dieser Methode wird der Zeiger wieder an den Anfang gesetzt.
265

266
Das Dateisystem entdecken
Einige Iterator-Klassen bieten eine Reihe weiterer Methoden an, die den Zugriff
auf spezifischen Eigenschaften der Elemente der Auflistung ermöglichen.
Verzeichnisse werden mit Instanzen des DirectoryIterators verarbeitet. Folgende
Methoden sind zusätzlich zu den Standardmethoden verfügbar:
Methode Beschreibung
fileATime Zeitpunkt des letzten Zugriffs.
fileCTime Zeitpunkt der letzten Änderung.
fileGroup Gruppe, der diese Datei zugeordnet ist.
fileInode Inode dieser Datei (nur Unix).
fileOwner Eigentümer dieser Datei.
filePerms Zugriffsrechte an dieser Datei.
fileSize Die Dateigröße.
fileType Der Dateityp.
getFileName Der Dateiname.
getPath Pfad zu dieser Datei.
hasMore Dieser Eintrag hat weitere Einträge.
isDir TRUE, wenn der Eintrag ein Verzeichnis ist.
isDot TRUE, wenn der Eintrag das Verzeichnis ».« oder »..« ist.
isExecutable Die Datei ist ausführbar.
isFile Dieser Eintrag ist eine Datei.
isLink Dieser Eintrag ist ein Link (nur Unix-Links).
isReadable Dieser Eintrag ist lesbar.
isWritable Dieser Eintrag ist schreibbar.
Tabelle 7.6: Methoden der Klasse DirectoryIterator

Das folgende Beispiel zeigt, wie der Iterator verwendet wird:
Listing 7.8: dirIterator.php – Verzeichnisauflistung mittels SPL-Iterator
Verzeichniszugriff
* { font-family: Verdana; font-size:12pt}
.dir { background-color:silver; margin-left:5px}
.file { background-color:white; margin-left:15px}

268
Das Dateisystem entdecken
7.4 Funktions-Referenz
Datei-Funktionen
Funktion Bedeutung
basename Dateiname in einer vollständigen Pfadangabe.
chgrp Ändert die Gruppenzugehörigkeit eines Dateieintrags (nur Unix).
chmod Ändert den Zugriffsmodus eines Dateieintrags.
chown Ändert den Eigentümer eines Dateieintrags (nur Unix * ).
clearstatcache Löscht den Status-Cache mit den letzten Dateiinformationen.
copy Kopiert eine Datei oder benennt sie um.
delete Löscht eine Datei (ein Alias für unlink).
dirname Verzeichnisname in einer vollständigen Pfadangabe.
disk_free_space Ermittelt den freien Speicherplatz eines Datenträgers.
disk_total_space Ermittelt den gesamten Speicherplatz eines Datenträgers
fclose Schließt einen Dateizeiger.
feof Testet einen Dateizeiger auf das Dateiende.
fflush Überträgt den gesamten Inhalt in den Ausgabepuffer.
fgetc Liest ein Zeichen aus einer Datei an der Position des
Dateizeigers.
fgetcsv Holt eine Zeile aus einer Datei und ermittelt CSV ** -Felder .
fgets Holt die nächste Zeile ohne weitere Verarbeitung.
fgetss Holt die nächste Zeile und entfernt alle HTML-Tags.
Tabelle 7.7: Funktions-Referenz für Datei-Funktionen
* Windows bietet dies auch, aber PHP unterstützt dies nicht auf Windows.
** CSV = Comma Separated Values, allgemein: Dateien mit Feldtrennzeichen, beispielsweise Kommata, Semikola
oder Tabulatoren.

Funktion Bedeutung
file_exists Prüft, ob eine Datei existiert.
file_get_contents Liest die gesamte Datei in eine Zeichenkette.
file_put_contents Schreibt eine Zeichenkette in eine Datei.
file Liest die gesamte Datei in ein Array.
fileatime Ermittelt den Zeitpunkt des letzten Dateizugriffs.
Funktions-Referenz
filectime Ermittelt den Zeitpunkt der letzten Änderung des Dateizeigers
Inode.
filegroup Ermittelt die Gruppenzugehörigkeit einer Datei (nur Unix).
fileinode Ermittelt den Inode einer Datei (nur Unix).
filemtime Ermittelt den Zeitpunkt der letzten Änderung der Datei.
fileowner Ermittelt den Eigentümer einer Datei (nur Unix).
fileperms Ermittelt die Dateizugriffsregeln.
filesize Ermittelt die Dateigröße.
filetype Ermittelt den Dateitype.
flock Blockiert eine Datei für exklusiven Zugriff.
fnmatch Prüft einen Dateinamen gegen ein bestimmtes Muster.
fopen Öffnet eine Datei oder ein URL.
fpassthru Liefert alle ausstehenden Daten an einen Dateizeiger.
fputs Schreibt Daten in eine Datei, angegeben durch ein Dateihandle.
fread Liest eine Datei binär.
fscanf Liest aus einer Datei und interpretiert den Inhalt gemäß dem
angegebenen Suchmuster.
fseek Setzt den Dateizeiger.
fstat Ermittelt Statusinformationen über eine Datei.
Tabelle 7.7: Funktions-Referenz für Datei-Funktionen (Forts.)
269

270
Das Dateisystem entdecken
Funktion Bedeutung
ftell Ermittelt die Position des Dateizeigers.
ftruncate Schneidet eine Datei an der angegebenen Position ab.
fwrite Schreibt Binärdaten in eine Datei.
glob Sucht Pfadnamen anhand eines Suchmusters.
is_dir Ermittelt, ob die Pfadangabe ein Verzeichnisname ist.
is_executable Ermittelt, ob die Pfadangabe eine ausführbare Datei darstellt.
is_file Ermittelt, ob die Pfadangabe eine Datei bezeichnet.
is_link Ermittelt, ob die Pfadangabe ein symbolischer Link ist (nur Unix).
is_readable Ermittelt, ob die Pfadangabe auf eine lesbare Datei zeigt.
is_uploaded_file Ermittelt, ob die Pfadangabe auf eine per HTTP-Upload hochgeladene
Datei zeigt.
is_writable Ermittelt, ob die Pfadangabe auf eine beschreibbare Datei zeigt .
link Erzeugt eine Verknüpfung (nur Unix * ).
linkinfo Liefert Informationen über einen Dateilink.
lstat Liefert Informationen über einen symbolischen Link.
move_uploaded_file Verschiebt eine hochgeladene Datei in ihr finales Verzeichnis.
parse_ini_file Untersucht eine Konfigurationsdatei.
pathinfo Ermittelt Informationen über eine Pfadangabe.
readfile Liest eine Datei und gibt den Inhalt sofort aus.
readlink Liest das Ziel eines symbolischen Links (nur Unix).
realpath Ermittelt den tatsächlichen vollständigen Pfad aus einer relativen
Angabe.
rename Benennt ein Verzeichnis oder eine Datei um.
Tabelle 7.7: Funktions-Referenz für Datei-Funktionen (Forts.)
* Windows kennt auch Verknüpfungen, die jedoch anders realisiert sind und von PHP nicht als Links erkannt
werden.

Funktion Bedeutung
Funktions-Referenz
rewind Setzt die Position des Dateizeigers zurück auf den Anfang.
stat Ermittelt Statusinformationen über eine Datei und speichert
diese. Spätere Anforderungen rufen die zwischengespeicherten
Daten ab, bis der Puffer mit clearstatcache gelöscht wird.
symlink Erzeugt einen neuen symbolischen Link (nur Unix).
tempnam Erzeugt einen temporären Dateinamen.
tmpfile Erzeugt einen temporären Dateinamen und die entsprechende
Datei.
touch Ändert die letzte Zugriffszeit einer Datei.
umask Ändert die Umask einer Datei (nur Unix).
unlink Löscht eine Datei (auch Windows).
Tabelle 7.7: Funktions-Referenz für Datei-Funktionen (Forts.)
Funktion Bedeutung
chdir Ändert das aktuelle Verzeichnis, aus dem gelesen wird.
chroot Ändert das Stammverzeichnis.
closedir Schließt das Verzeichnis-Handle.
dir Instanziiert die Verzeichnisklasse (siehe Text).
dirname Ermittelt den Verzeichnisnamen in einer vollständigen Pfadangabe.
getcwd Ermittelt das aktuelle Arbeitsverzeichnis.
mkdir Erzeugt ein Verzeichnis.
opendir Öffnet ein Handle auf ein Verzeichnis prozedural.
readdir Liest einen Eintrag aus einem Verzeichnis-Handle.
rewinddir Setzt den Zeiger vor dem Lesen der Einträge auf den Anfang
zurück.
Tabelle 7.8: Funktions-Referenz für Verzeichnis-Funktionen
271

272
Das Dateisystem entdecken
Funktion Bedeutung
rmdir Entfernt ein Verzeichnis.
scandir Liest Dateien eines bestimmten Pfades.
Tabelle 7.8: Funktions-Referenz für Verzeichnis-Funktionen (Forts.)
Prozess-Funktionen
Funktion Bedeutung
escapeshellarg Behandelt eine Zeichenkette so, dass sie als Argument für Shell-
Aufrufe verwenden werden kann, indem die Anführungszeichen
maskiert werden.
escapeshellcmd Maskiert Shell-Zeichen so, dass sie nicht zum Missbrauch bei der
Ausführung von Kommandos verwendet werden können.
exec Führt ein externes Programm aus. Die Funktion erzeugt keine Ausgabe
und gibt lediglich die letzte Zeile der Antwort des Programms
zurück.
passthru Führt ein externes Programm aus und zeigt die Ausgabe an.
pclose Schließt ein Prozesshandle (einfache Form).
popen Öffnet einen Prozess und erzeugt das passende Prozesshandle (einfache
Form).
proc_close Schließt ein Prozesshandle.
proc_get_status Ermittelt Statusinformationen über den Prozess. Die Rückgabe
erfolgt als Array, dessen Elemente Angaben wie das verwendete
Kommando (command), die Prozess-ID (pid) oder den Rückgabecode
(exitcode) enthalten.
proc_nice Ändert die Priorität des Prozesses (nicht auf Windows verfügbar).
proc_open Öffnet einen Prozess und erzeugt das passende Prozesshandle.
proc_terminate Beendet einen Prozess.

Funktion Bedeutung
7.5 Kontrollfragen
1. Auf welche Datenquellen können die Dateifunktionen zugreifen?
Kontrollfragen
shell_exec Führt ein Kommando über die Shell (Eingabeaufforderung) aus.
Alternativ kann auch der »Backtick«-Operator ’kommando’ verwendet
werden.
system Führt ein externes Programm aus und zeigt die Ausgabe an.
2. Warum muss eine Datei nach der Benutzung wieder geschlossen werden?
3. Schreiben Sie ein Skript, dass eine beliebige Datei aus dem aktuellen Verzeichnis
im Quelltext anzeigt, wobei der Benutzer die Datei selbst wählen kann. Tipp:
Benutzen Sie HTML-Links und ermitteln
Sie den übergebenen Namen mittels $_GET[’name’].
4. Warum ist das in der letzten Übung verlangte Prinzip auf einer öffentlichen
Website nicht unmodifiziert einsetzbar? Tipp: Denken Sie an mögliche Sicherheitsprobleme.
273

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

Formular- und
Seitenmanagement
8

278
Formular- und Seitenmanagement
8.1 Grundlagen in HTML
Formulare sind das wichtigste Element einer Website. Kaum eine Seite kann praktisch
ohne Eingabeelemente betrieben werden, denn nur darüber kann der Nutzer
wirklich Kontakt mit Ihnen aufnehmen.
Viel HTML – wenig PHP
Formulare haben viel mit HTML und wenig mit PHP zu tun. Das ist eigentlich
eine der herausragenden Stärken von PHP, denn für den Programmierer ist wenig
zu tun, damit man bequem an die Daten herankommt. Freilich müssen Sie sicher
im Umgang mit den entsprechenden HTML-Tags sein. Springen Sie zum nächsten
Abschnitt, wenn es keine Fragen mehr im Umgang mit ,
und gibt. Besteht doch noch die eine oder andere Unsicherheit, lesen Sie
unbedingt diesen Abschnitt.
Die HTML-Formularelemente kurz vorgestellt
Dieses Buch soll kein HTML-Buch ersetzen. Eine kompakte Darstellung auf den
folgenden Seiten ist jedoch hilfreich, vor allem wenn man alternativ vor einem
1000-Seiten-Schinken eines HTML-Gurus sitzt.
Zuerst eine prinzipielle Aussage: Ein Formular entsteht, indem man die entsprechenden
Elemente in ein -Tag packt. In den vorangegangenen Kapiteln
wurde dies bereits häufig getan.
Nun müssen Sie alle Tags kennen, mit denen HTML-Formulare erstellt werden
können. Die folgende Tabelle fasst diese zusammen:
Element Elementtyp
type="..."
Beschreibung Wichtige Attribute
input text Einzeiliges Eingabefeld size, value, name
checkbox Kontrollkästchen value, checked, name
radio Optionsschaltfläche value, checked, name
submit Sendeschaltfläche value, name
Tabelle 8.1: Formular-Elemente in HTML

Element Elementtyp
type="..."
reset Schaltfläche zum Rücksetzen
Grundlagen in HTML
value, name
password Verdecktes Eingabefeld size, value, name
hidden Unsichtbares Feld value, name
button Schaltfläche value, name
image Bild, ersetzt submit und ist
damit wie eine Sendeschaltfläche
file Eingabefeld und Schalter
zum Hochladen von Dateien
src, name,
Bildattribute
name, accept
select Dropdown-Liste multiple, name, size
option Element der Dropdown-Liste
(nur Sub-Element)
value
textarea Mehrzeiliges Textfeld name, rows, cols
Tabelle 8.1: Formular-Elemente in HTML (Forts.)
Die Attribute sind für die Steuerung des Verhaltens erforderlich und haben die in
der folgenden Tabelle gezeigte Bedeutung:
Attributname Beschreibung
name Name des Feldes. Unter diesem Namen wird es in PHP erreicht.
size Breite des Feldes, bei select ist dies die Anzahl der sichtbaren Zeilen.
value Der Wert des Felds. Kann aus Sicherheitsgründen bei type="file" und
type="password" nicht gesetzt werden.
multiple Erlaubt die Mehrauswahl in Listen (select)
rows Anzahl der Zeilen bei textarea.
cols Anzahl der Spalten bei textarea.
Beschreibung Wichtige Attribute
Tabelle 8.2: Attribute der Formular-Elemente (nur formularspezifische wurden aufgeführt)
279

280
Formular- und Seitenmanagement
Daneben können alle Elemente natürlich mit den Standardattributen wie class,
style, id usw. bestückt werden.
8.2 Auswerten der Daten aus Formularen
Die Nutzung von Formularen erfolgt immer in einer zweiteiligen Form. Zum
einen wird ein Formular benötigt, das die Namen der Felder und den potenziellen
Inhalt festlegt. Zum anderen wird ein PHP-Skript erstellt, das die Daten auswertet
und beispielsweise in eine Datenbank schreibt. Die Aufnahme der Daten und die
Auswertung umfasst immer einige elementare Schritte.
Grundlegende Schritte
Vor der ersten Auswertung muss klar sein, wohin ein Formular gesendet werden
soll. Dies ist, bestimmt durch das Attribut action des -Tags, natürlich der
Name eines PHP-Skripts.
Die einfachste Form ist der Selbstaufruf. Dabei ist das Skript, das das Formular
definiert, selbst das Ziel. Es ist sinnvoll, das Ziel am Anfang des Skripts zu definieren:
$action = $_SERVER['PHP_SELF'];
Die Variable $action wird dann im Formular verwendet, beispielsweise bei einer
mit print oder echo erzeugten Ausgabe direkt, wie nachfolgend gezeigt:
echo

…
Den Zustand des Formulars erkennen
Auswerten der Daten aus Formularen
Es gibt prinzipiell zwei Zustände, in denen ein Skript aufgerufen werden kann,
bestimmt durch die verwendete HTTP-Methode. Um Formulardaten zu versenden,
wird POST verwendet. Um ein Skript direkt auszuführen, wird GET verwendet.
Damit kann man unterscheiden, ob das Skript das erste Mal zur Anzeige des
Formulars aufgerufen wurde, oder ob der Benutzer es bereits ausgefüllt und wieder
abgesendet hat.
Der erste Schritt bei der Auswertung besteht also darin, überhaupt zu erkennen, ob
das Formular einer Auswertung bedarf. Das folgende Beispiel zeigt, wie die Servervariable
REQUEST_METHOD dazu verwendet wird:
Listing 8.1: formmethod.php – Erkennen der verwendeten HTTP-Methode

282
Formular- und Seitenmanagement
Die Herkunft erkennen
Abbildung 8.2:
Anzeige des Formulars, nachdem es mit der Schaltfläche abgesendet
wurde
Manchmal ist es wichtig zu wissen, woher ein Formular kommt. Entweder aus
Sicherheitsgründen oder zur Organisation des Zusammenhangs der einzelnen
Skripte einer Applikation muss auf den so genannten »Referer« zugegriffen werden.
Auch hierfür steht eine Servervariable zur Verfügung: HTTP_REFERER. Die
Abfrage ist meist nur sinnvoll, wenn das Formular bereits abgesendet wurde, weil
der erste Aufruf eines Skripts auch durch direkte Eingabe der Adresse im Browser
erfolgen kann. In diesem Fall existiert jedoch kein Referer und die Variable ist
leer.
Das folgende Skript kontrolliert den Selbstaufruf und sichert sich dagegen ab, von
einer anderen Quelle aus aufgerufen zu werden.
Listing 8.2: formmethodreferer.php – Die Herkunft eines Aufrufs ermitteln

}
?>

284
Formular- und Seitenmanagement
Zustandsabfrage für Felder
Über den Datentyp müssen Sie sich bei Formularen keine Gedanken machen.
HTML kennt nur Zeichenketten und als solche kommen alle Daten im Skript an.
Umwandlungen müssen dann bei Bedarf explizit vorgenommen werden. Wichtiger
bei der ersten Auswertung ist die Erkennung leerer Felder. PHP erzeugt leere
Arrayelemente für unausgefüllte Felder. Man kann deshalb immer überprüfen, ob
ein spezifisches Element auch vorhanden ist und die Abfrage danach gestalten.
Am einfachsten erfolgt die Auswertung mit empty. Im Skript sieht das dann folgendermaßen
aus:
Listing 8.3: formisset.php – Prüfung, ob ein Feld ausgefüllt wurde

Auswerten der Daten aus Formularen

286
Formular- und Seitenmanagement
{
if (!empty($_POST['Loginname']))
{
echo "LoginName: {$_POST['Loginname']}";
}
if (!empty($_POST['Subject']))
{
$rawsubject = $_POST['Subject'];
$htmsubject = nl2br($rawsubject);
echo

Auswerten der Daten aus Formularen
Das Skript verwendet die übliche Auswertung mit empty zum Erkennen leerer Felder.
Wie die Daten dann aufbereitet werden, hängt von der Anwendung ab. Im
Beispiel werden die Daten in beiden Varianten ausgegeben.
Wenn Sie die Felddaten innerhalb von -Tags anzeigen, dann werden
die integrierten Zeilenumbrüche ausgegeben. In einem solchen
Fall wäre die zusätzliche Angabe von fatal, weil sich die Umbrüche
verdoppeln würden.
Optionsfelder und Kontrollkästchen
Abbildung 8.5:
Verarbeitung von Zeilenumbrüchen
aus einem
Textfeld
Ebenso wichtig wie die übrigen Feldarten sind auch Optionsfelder und Kontrollkästchen.
Beide sind eng miteinander verwandt und werden ähnlich eingesetzt:
Optionsfelder (Radiobutton) werden zu Gruppen zusammengefasst und erlauben
die Auswahl genau einer Option (daher der Name 1 ) aus einer Liste
1 Der englische Name rührt von der Anzeigeform her: Die runden Optionsfelder sehen aus wie runde Knöpfe
an alten Radios.
287

288
Formular- und Seitenmanagement
Kontrollkästchen (Checkbox) sind nicht miteinander verbunden und lassen
eine Mehrfachauswahl zu, beispielsweise zur Konfiguration oder Kontrolle
(daher der Name 2 ).
Optionsfelder
Optionsfelder werden gruppiert, indem allen Feldern derselbe Name gegeben
wird. Da immer nur ein Feld ausgewählt werden kann, übermittel der Browser zu
dem gemeinsamen Namen den Wert, den man dem Feld vorher zugeordnet hat.
Der Wert wird mit dem Attribut value festgelegt. Im $_POST-Array taucht dann
genau ein Wert auf.
Es ist möglich, dass kein Feld ausgewählt wurde. Erst wenn der Benutzer
ein Feld einmal angeklickt hat, kann er den Zustand »nichts ausgewählt«
nicht wieder herstellen. Es ist prinzipiell eine schlechte Benutzerführung,
einen Zustand vorzugeben, der nicht wieder hergestellt
werden kann. Sie sollten deshalb unbedingt den Anfangszustand dediziert
setzen.
Das folgende Beispiel zeigt eine Auswahl von mehreren Werten und setzt den
Anfangszustand durch das Attribut checked auf den ersten Wert.
Kontrollkästchen
Jedes Kontrollkästchen setzt seinen eigenen Wert, weshalb jedes auch einen eigenen
Namen erhält. Der Wert ist standardmäßig entweder leer oder »on« (aktiviert).
Wenn Sie einen anderen Wert benötigen, wird das Attribute value benutzt.
Ebenso wie bei den Optionsfeldern dient das Attribute checked dazu, das Kontrollkästchen
bereits beim ersten Aufruf aktiviert erscheinen zu lassen.
Beispiel für Optionsfelder und Kontrollkästchen
Das folgende Beispiel zeigt, wie die Informationen aus Optionsfeldern und Kontrollkästchen
verwendet werden. Beachten Sie vor allem die Benennung der Felder
in HTML:
2 Der englische Name rührt auch hier von der Anzeigeform her: Kontrollkästchen lassen sich ankreuzen oder
auswählen (engl. »to check«).

Auswerten der Daten aus Formularen
Listing 8.5: formcheckradio.php – Umgang mit Kontrollkästchen und Optionsfeldern

290
Formular- und Seitenmanagement
Welche Sprachen kennen Sie?
Perl
VBScript
PHP
C#
C++
Delphi
Fortran
Wie beurteilen Sie PHP?
1
2
3
4
5
6
Dieses Beispiel zeigt bereits einige wichtige Techniken beim Umgang mit Formularelementen.
Vor allem die Auswertung einer großen Anzahl von Elementen
bereitet mitunter Schwierigkeiten.
Beim Optionsfeld wurde der Name »PHPNote« für alle Elemente gewählt. In
PHP ist die Auswertung relativ einfach, denn es genügt die Abfrage des Arrayelements
$_POST['PHPNote']. Im Beispiel wurde durch die Angabe des Attributes checked
beim Formularelement eine Erstauswahl erzwungen. Damit ist sichergestellt,
dass dieses Element immer einen Eintrag im Array erzeugt, denn der Benutzer
kann Optionsfelder nicht abwählen. Die folgende Bedingung kann deshalb, theoretisch,
nie FALSE sein:

if (!empty($_POST['PHPNote']))
Auswerten der Daten aus Formularen
Sie wurde dennoch im Skript belassen, um zu zeigen, wie man mit einer leeren
Auswahl umgehen muss.
Die Auswertung der Kontrollkästchen bereitet unter Umständen größere Probleme.
Die Namen lassen sich natürlich alle einzeln auswerten. Bei Änderungen
am Code ist die Fehlerquote aber relativ hoch. Das Skript reduziert die Abhängigkeit
von den Namen auf eine einzige Stelle. Zuerst wird abgefragt, ob überhaupt
Felder ausgefüllt wurden:
if (count($_POST) > 0)
Dann werden alle Felder mit einer Schleife durchlaufen. Darin tauchen natürlich
auch die auf, die nicht zu den Kontrollkästchen gehören:
foreach ($_POST as $name => $value)
Jetzt werden die benötigten Felder mit einer switch-Anweisung extrahiert. Wurde
ein passendes Feld gefunden, wird der Wert ermittelt. Die Zahl 1 ist nur dann vorhanden,
wenn das entsprechende Kontrollkästchen aktiviert wurde. Standardmäßig
wird hier »on« übermittelt, man muss die 1 explizit mit dem HTML-Attribut
value vereinbaren.
if ($value == 1)
{
$result[] = $name;
}
Wenn das entsprechende Kontrollkästchen aktiviert war, wird der Name in das
Array $result geschrieben. Der Trick mit dem Array dient der schnellen Generierung
einer kommaseparierten Liste. Dies erledigt am Ende, bei der Ausgabe die
implode-Funktion:
implode($result, ',')
Gegenüber dem systematischen Anhängen erkannter Einträge an die Zeichenkette,
beispielsweise nach dem Schema $result .= $value . ',', vermeidet man
damit das abschließende Komma (siehe Abbildung 8.6).
Der Umgang mit einer großen Anzahl von Kontrollkästchen und ähnlicher Elemente
verlangt in der Praxis noch nach weiteren Lösungen. Das erste Beispiel in
diesem Abschnitt soll deshalb noch etwas verbessert werden. Um die Anzahl der
Elemente flexibel zu halten, wäre auch eine dynamische Generierung der Kontrollkästchen
wünschenswert. Dazu werden Feldnamen und Typen in einem Array
festgelegt. Die Namen enthalten ein Präfix, das die spätere Selektierung erleichtert.
Die Präfixe können etwa diesem Schema folgen:
291

292
Formular- und Seitenmanagement
Kontrollkästchen: chk
Optionsfelder: rdb
Textfelder: txt
Textarea: txa
Dropdown-Listen: drp
Schaltflächen: btn
Das folgende Skript zeigt, wie das praktisch aussieht:
Abbildung 8.6:
Das Formular in Aktion
Listing 8.6: formcheckauto.php – Dynamisch Listen von Feldern ersetzen
$action = $_SERVER['PHP_SELF'];
$checkboxes = array (
'chkPerl' => array('Perl', 'Perl', '1', FALSE),
'chkPHP' => array('PHP', 'PHP', '1', TRUE),
'chkVBS' => array('VBScript', 'Visual Basic Script', '1', TRUE),
'chkCSharp' => array('C#', 'C# (.NET)', '1', FALSE),
'chkCPlusPlus' => array('C++', 'C++ (VSC++)', '1', FALSE),
'chkDelphi' => array('Delphi', 'Delphi (Pascal)', '1', FALSE),
'chkFortran' => array('Fortan', 'Fortran', '1', FALSE));
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
foreach ($_POST as $fName => $fValue)
{
if (substr($fName, 0, 3) == 'chk')
{

Auswerten der Daten aus Formularen
echo
Hier wird zuerst ein Array definiert, das alle Daten enthält, die zur Konstruktion
der Kontrollkästchen erforderlich sind. Die Struktur zeigt ein verschachteltes
Array. Die erste Ebene enthält als Schlüssel den künftigen Namen des Felds:
$checkboxes = array ('chkPerl' => …
293

294
Formular- und Seitenmanagement
Jedes Kontrollkästchen bekommt dann einen Satz von Eigenschaften als weiteres
Array:
… array('Perl', 'Perl', '1', FALSE)
Die Bedeutung der Elemente ist willkürlich gewählt. Im Beispiel gilt folgendes
(nach den Indizes):
[0]: Kurzname
[1]: Langname oder Beschreibung
[2]: Wert, der gesendet wird, wenn das Kontrollkästchen aktiviert ist
[3]: Boolescher Wert, der den Zustand »checked« beim ersten Aufruf bestimmt
Die Generierung der Elemente lässt sich sehr praktisch mit printf erreichen. Hier
wird – angeordnet in einer Schleife – der Inhalt des Arrays als Parameter an die
Stellen im Feld übergeben, wo sie benötigt werden:
printf('
%s (%s)',
$boxName,
($boxData[3]) ? 'checked' : '',
$boxData[2],
$boxData[0],
$boxData[1]
);
Die Variable $boxData repräsentiert hier das innere Array aus der Definition. Die
Auswahl der Elemente erfolgt über die beschriebenen Indizes.
Bei der Auswertung wird die Tatsache ausgenutzt, dass die Feldnamen mit »chk«
beginnen. Für die Auswahl sorgt eine if-Anweisung:
if (substr($fName, 0, 3) == 'chk')
Damit funktioniert die ganze Konstruktion auch, wenn weitere Formularelemente
im Spiel sind, vorausgesetzt man hält sich konsequent an das Präfix-Schema.
Das hier vorgestellte Schema der automatischen Feldgenerierung wurde
exemplarisch für Kontrollkästchen gezeigt. Es gilt in ähnlicher Form für
alle Feldelemente und sollte generell zur dynamischen Generierung
eingesetzt werden.

Dropdown-Listen
Auswerten der Daten aus Formularen
Zu Dropdown-Listen pflegen Benutzer wie Webmaster eine gewisse Hassliebe. Sie
bieten den Vorteil, sehr viele vorbereitete Informationen in sehr kompakter Form
anzeigen zu können. Formulare mit vielen Dropdown-Listen verbergen aber auch
Informationen vor dem Benutzer; sie zwingen dazu, die Liste aufzuklappen, zu
scrollen und dann eine Auswahl zu treffen. Statt eines Klicks sind oft zwei oder
mehr erforderlich. Dies ist unter Umständen lästig. In der Praxis muss man einen
guten Kompromiss zwischen dem Volumen des Gesamtformulars und dem sichtbaren
Informationsvolumen wahren. Listen mit Hunderten Einträgen sind schwer
beherrschbar und Listen mit nur zwei Einträgen besser durch Optionsfelder darstellbar.
Die Wahrheit für die optimale Anzahl der Elemente liegt irgendwo zwischen
drei und zwanzig Optionen.
Aufbau der Dropdown-Listen
Der prinzipielle Aufbau folgt folgendem Muster:
Angezeigter Text
Die Anzahl der Option-Tags ist nicht begrenzt, sollte aber in den bereits erwähnten
Grenzen liegen, um den Benutzer nicht mit unnützen Klicks zu quälen.
Standardattribute
Die Attribute des Select-Tags verlangen eine genauere Untersuchung, denn die
Angaben können sich auch auf den PHP-Code auswirken, der zur Auswertung
benötigt wird. Am einfachsten ist name, das wie bei allen anderen Tags zur Generierung
des Eintrags im $_POST-Array führt. Für die Anzeige entscheidend ist size.
Hiermit legen Sie fest, wie viele Elemente gleichzeitig sichtbar sind. Der Standardwert
»1« erzeugt eine echte Klappliste, bei der nur der erste Eintrag sichtbar ist.
Jeder andere Wert größer als 1 erzeugt eine Listbox, die die bestimmte Anzahl Elemente
anzeigt. Sind mehr Optionen vorhanden, wird ein Rollbalken erzeugt. Sind
weniger Werte vorhanden, bleiben die Zeilen der Listbox leer (was sehr unprofessionell
aussieht).
295

296
Formular- und Seitenmanagement
Listing 8.7: formselect.php – Aufbau und Auswertung einer Dropdown-Liste
$action = $_SERVER['PHP_SELF'];
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
if (!empty($_POST['Language']))
{
echo "Ihre Auswahl: {$_POST['Language']}";
}
}
else
{
echo 'Erster Aufruf der Seite';
}
?>

Mehrfachauswahl
Auswerten der Daten aus Formularen
Abbildung 8.7:
Die Dropdown-Liste in Aktion
Die Dropdown-Liste kann mit der Angabe des Attributes multiple dazu veranlasst
werden, mehrere Werte gleichzeitig auswählbar zu machen. Wie die Mehrfachauswahl
erfolgt, hängt vom Betriebssystem ab. Unter Windows ist dazu die Steuerungs-Taste
(Strg) zu drücken, während Einträge mit der Maus gewählt werden.
Da das Element nach wie vor nur einen Namen besitzt, stellt sich die Frage, wie
mehrere Werte in PHP ankommen.
Der Trick besteht darin, PHP die Möglichkeit der Auswahl mehrerer Werte anzuzeigen.
Dazu wird dem Namen im HTML-Element einfach das Arraykennzeichen
[] angehängt. PHP verpackt die Werte dann in ein Array, aus dem sie sich leicht
wieder entnehmen lassen. Das letzte Beispiel wird dazu im HTML-Teil leicht verändert
und im PHP-Abschnitt um die Ausgabe des Arrays erweitert. Außerdem
wird die bereits bei den Kontrollkästchen und Optionsfeldern gezeigte Technik
der automatischen Generierung gezeigt, die auch bei Optionsfeldern gute Dienste
tut:
Listing 8.8: formselectauto.php – Mehrfachauswahl von Listen

298
Formular- und Seitenmanagement
if (is_array($_POST['Language']))
{
echo "Auswahl: " . implode($_POST['Language'], ', ');
}
}
else
{
echo 'Erster Aufruf der Seite';
}
?>
Dieses Skript enthält zum einen wieder die Generierung der Optionen über eine
als Array angelegte Definition, ähnlich wie bei den Kontrollkästchen gezeigt. Das
Array enthält die nötigen Angaben zum Options-Wert (value) und dem Text, der
dem Benutzer angezeigt wird. Der dritte Wert wird hier noch nicht verwendet; das
nächste Beispiel nimmt darauf Bezug. Die Ausgabe des Arrays erfolgt mit einer
foreach-Schleife, in der eine printf-Funktion die -Tags sachgerecht
erzeugt. Wichtig ist bei der Definition des Select-Tags, dass hinter dem Namen die
eckigen Klammern stehen, wenn das Attribut multiple benutzt wird:

Auswerten der Daten aus Formularen
Im PHP-Teil geht es nun anders zur Sache. Es ist sinnvoll, statt auf ein leeres Feld
auf ein Array zu prüfen:
if (is_array($_POST['Language']))
Das Array wird auch erzeugt, wenn nur ein Element angeklickt wurde. Danach
steht natürlich jede Array-Funktion zur Weiterverarbeitung zur Verfügung. Im
Beispiel wird eine kommaseparierte Liste mit implode erzeugt.
Die Größe der Liste wurde übrigens auf 5 gesetzt (size="5"), sodass immer fünf
Werte sichtbar sind. Bei einer Mehrfachauswahl ist dies unbedingt zu empfehlen,
weil die Bedienung so einfacher ist als bei einer echten Klappliste.
Vorauswahl
Abbildung 8.8:
Mehrfachauswahl einer automatisch
erzeugten Box
Auch mit Listen ist die Vorauswahl möglich und sinnvoll. Dazu wird das -
Tag um das Attribut selected erweitert. Das letzte Beispiel enthielt bereits einen
Booleschen Wert (der dritte Wert im Array $select), der die Vorauswahl steuern
sollte. Eine Erweiterung der printf-Funktion zeigt, wie es geht:
Listing 8.9: formselectautoselect.php – Vorauswahl per Skript steuern

300
Formular- und Seitenmanagement
{
if (is_array($_POST['Language']))
{
echo "Auswahl: " . implode($_POST['Language'], ', ');
}
}
else
{
echo 'Erster Aufruf der Seite';
}
?>
Der Boolesche Wert wird genutzt, um direkt das entsprechende Attribut zu erzeugen:
$option[2] ? 'selected' : ''
Zur besseren Übersicht wurden außerdem die Parameter der printf-Funktion
nummeriert:
printf('%2$s', …

Professionelle Formulare und »Sticky Forms«
Probleme mit klassisch programmierten Formularen
Freilich ist die letzte Lösung nicht optimal, weil bei einem erneuten Aufruf der
Seite immer wieder der Ursprungszustand wiederhergestellt wird. Besser ist es,
wenn der Anfangs- und der Arbeitszustand getrennt gesteuert werden können.
Denn der Benutzer erwartet bei Fehleingaben und ähnlichen Problemen, dass
seine Werte erhalten bleiben. Man spricht bei solchen Formularen von so genannten
»Sticky Forms« oder »klebrigen Formularen«, die so heißen, weil sie die letzten
Werte behalten. Weil dies eine sehr wichtige Technik ist, wurde ihr ein
eigener Abschnitt gewidmet.
8.3 Professionelle Formulare und »Sticky Forms«
Professionelle Formulare verlangen nach mehr Funktionen als bislang gezeigt
wurde. Die Auswertung der eingegebenen Daten in PHP ist nur eine Seite der
Medaille. Die Programmierung muss auch eine gute Benutzerführung erlauben.
Dazu gehört, dass dem Benutzer
sinnvolle Ausfüllhinweise gegeben werden,
hilfreiche Ausfüllhilfen mit clientseitigen Funktionen angeboten werden,
er auf Fehler bei der Eingabe hingewiesen wird und
Abbildung 8.9:
Vorauswahl beim ersten Aufruf der Seite
der Inhalt des Formulars beim erneuten Laden nach Fehlern erhalten bleibt.
Sinnvolle Ausfüllhinweise sind Teil des Designs. Zu den typischen Vorgaben
gehört die Markierung von Pflichtfeldern und Informationen über die in Textfeldern
zu platzierenden Daten. Ausfüllhilfen werden meist in JavaScript erstellt und
betreffen beispielsweise die Prüfung von Feldinhalten, das Vorausfüllen auf der
301

302
Formular- und Seitenmanagement
Grundlage anderer Daten oder die Formatierung von Eingaben. Sie helfen, die
Fehlerquote bei der Eingabe zu senken, und vereinfachen die serverseitige Prüfung
in PHP. Hinweise auf Eingabefehler sind in letzter Konsequenz immer serverseitig
zu klären. Dazu gehören aussagekräftige Fehlermeldungen, Hinweise auf
den Ort des Fehlers und Wege, diesen zu beseitigen. Nicht zuletzt ist all dies mit
der Technik der »Sticky Forms« zu kombinieren, denn der fatalste Entwurfsfehler
einer Seite ist ein Formular, das minutenlang mühevoll ausgefüllt wurde und nach
dem Senden und erneuten Laden mit einer Fehlermeldung und ohne die Daten
erscheint.
Neben diesen Techniken ist auch die Größe eines Formulars von Bedeutung.
Wenn sehr viele Felder erforderlich sind, muss eventuell über ein mehrseitiges
Formular nachgedacht werden.
Ausfüllhinweise und Feldvorgaben
Tabellen haben beim Bau von Formularen eine große Bedeutung. Sie dienen vor
allem der eindeutigen Platzierung von Feldbeschriftungen und Feldelementen.
Das Formular bauen
Eine der elementaren Techniken beim Formularbau betrifft den Einsatz von
Tabellen. Damit Feldbeschriftungen und Felder vernünftig angeordnet erscheinen,
benutzt man zu ihrer Positionierung eine feste Struktur in Form einer
Tabelle nach folgendem Schema:
Text Feld
Text Feld
...
In HTML sieht das dann folgendermaßen aus:

Kennwort:
Hinweistexte platzieren
Professionelle Formulare und »Sticky Forms«
Als nächstes sollten Hinweistexte platziert werden, um den Benutzer durch das
Formular zu führen. Dies erfolgt meist rechts vom Feld, sodass man bei der
Tabelle mit einem dreispaltigen Layout arbeitet. Ist das Formular nicht sehr hoch,
die Felder aber recht breit, kann man den Text auch unter die Feldnamen oder
unter die Felder selbst stellen. Er sollte sich dann aber optisch abheben, beispielsweise
durch eine andere Farbe und eventuell durch eine verkleinerte Schrifthöhe.
Wenn man nun bereits Eingabehilfen in Form von Erklärungen platziert, wären
auch aktive Hilfen interessant. Dabei hilft JavaScript.
Ausfüllhilfen mit JavaScript
Abbildung 8.10:
Das perfekte Formular mit einer Tabelle erstellt
Abbildung 8.11:
Zum Vergleich: Unprofessionelles Formular ohne Tabelle
Es ist grundsätzlich falsch, auf JavaScript zu verzichten. Es ist ebenso grundsätzlich
falsch, allein darauf zu vertrauen. Erst die Kombination aus JavaScript (client-
303

304
Formular- und Seitenmanagement
seitig) und PHP (serverseitig) erlaubt wirklich gute und professionelle Lösungen.
Es ist sicher so, dass dieses Buch sich dem Thema PHP widmet. Bei der Formularverarbeitung
hat JavaScript aber eine ganz bedeutende Stellung und der Verzicht
auf eine clientseitige Unterstützung ist einfach nur dumm. Glauben Sie nicht Leuten,
die die Verwendung von JavaScript verteufeln – die haben das Web nicht verstanden.
Interaktion zwischen JavaScript und PHP
Die komplette Betrachtung um JavaScript füllt gleichfalls Bücher. Dieser
Abschnitt zeigt lediglich das Zusammenspiel mit PHP. Informationen über den
genauen Umgang mit allen Möglichkeiten, die JavaScript bietet, sind anderen
Quellen vorbehalten. Prinzipiell gibt es zwei Wege der Interaktion:
PHP steuert JavaScript durch dynamische Code-Erstellung
Abbildung 8.12:
Platzierung von
Hinweistexten
und Eingabehilfen
JavaScript erzeugt Werte und übergibt sie an PHP
Da JavaScript im Browser abläuft und PHP auf dem Server, muss man sich Gedanken
über die Schnittstelle machen. Damit PHP die Reaktion von JavaScript beeinflussen
kann, ist es möglich, den JavaScript-Code dynamisch zu erstellen. Ist die
Seite aber erstmal an den Browser abgesendet worden, funktioniert das nicht mehr.
Es ist deshalb eine mehr oder wenig einseitige Steuerung. Interessant ist es dennoch,
denn Sie sollten Ihren JavaScript-Code so steuern, dass Sie auf den Erst- und
Zweitaufruf des Formulars gegebenenfalls unterschiedlich reagieren. Das ist wichtig,
weil JavaScript von Hause aus nicht unterscheiden kann, aufgrund welcher
HTTP-Anforderung die Seite gesendet wurde. Das folgende Beispiel erzeugt eine
Anzeigebox in JavaScript, deren Inhalt von der HTTP-Methode gesteuert wird,
indem der Anzeigetext in PHP dynamisch ausgewählt wurde:

Professionelle Formulare und »Sticky Forms«
Listing 8.10: formjavascriptalert.php – JavaScript per PHP steuern
Formulare
function Box(text)
{
alert(text);
document.logon.submit();
}

306
Formular- und Seitenmanagement
Die Funktion erzeugt eine Ausgabebox (alert), die vor allem zur Demonstration,
Fehlersuche und für einfache Meldungen an den Benutzer geeignet ist. Entscheidender
ist die zweite Zeile:
document.logon.submit();
Hiermit wird das Formular dazu veranlasst, sich abzusenden. Das entspricht dem
Anklicken einer »Submit«-Schaltfläche. Es spielt dabei keine Rolle, ob eine solche
vorhanden ist oder nicht. In PHP können Sie übrigens nicht direkt unterscheiden,
ob der Benutzer auf »Submit« geklickt hat oder das Skript das Absenden übernahm.
JavaScript arbeitet mit dem so genannten Document Object Model (DOM)
der HTML-Seite. Dieses erlaubt eine objektorientierte Darstellung. document verweist
auf das Dokument. Eines der darin definierten Elemente heißt »logon« – der
Name des Formulars. Der wurde hier willkürlich folgendermaßen festgelegt:

Clientseitig auf Eingaben reagieren
Professionelle Formulare und »Sticky Forms«
Da es in JavaScript einen Zugriff auf das Formular gibt, kann auch auf alle Felder
zugegriffen werden. Das ist hilfreich, damit Formulare mit offensichtlichen Fehlern
gar nicht erst gesendet werden. Das folgende Beispiel zeigt, wie bei einem
Feld geprüft wird, ob ein Text darin steht. Diese Prüfung ist für Pflichtfelder sinnvoll.
JavaScript spart das Zurücksenden des Formulars zum Server und damit dem
Benutzer Zeit und Bandbreite. Natürlich muss jede clientseitige Prüfung mit einer
serverseitigen kombiniert werden, damit die Bedienung auch dann möglich ist,
wenn JavaScript nicht aktiviert ist.
Listing 8.11: formjavascriptmand.php – Eingabeprüfungen mit JavaScript
Formulare
function Check()
{
var ok = true;
if (document.logon.Loginname.value == '')
{
alert ('Login Name wurde nicht angegeben');
ok = false;
}
if (document.logon.Password.value == '')
{
alert ('Kennwort wurde nicht angegeben');
ok = false;
}
if (ok)
{
document.logon.submit();
}
Abbildung 8.13:
Diese Box erscheint beim
ersten (links) und beim zweiten
(und folgenden) Klick
(rechts)auf die Schaltfläche
307

308
Formular- und Seitenmanagement
}

if (document.logon.Loginname.value == '')
Professionelle Formulare und »Sticky Forms«
document.logon verweist wieder auf das Formular, Loginname ist der Name des
Feldes und value eine Eigenschaft, die den momentanen Wert zurückgibt. Der
Rest ist Standardprogrammierung und wird nur durch die eigene Fantasie
begrenzt.
Der PHP-Abschnitt wiederholt diese Prüfung, weil Sie nie darauf vertrauen dürfen,
dass jeder Browser auch tatsächlich JavaScript ausführt.
Was nun noch fehlt, ist eine vernünftige Anzeige der Fehlertexte im Formular.
Das ist ein Fall für CSS und natürlich JavaScript. Dabei muss man als Mittel zur
Fehlerausgabe nicht nur JavaScript sehen. Auch die in PHP erzeugten Fehlerinformationen
werden hier eingebunden.
Fehlerangaben
Fehlerangaben sind ein wichtiges Instrument der Benutzerführung. Dazu gibt es
mehrere Techniken, die die Kombination aus JavaScript und PHP erfordern.
Eine wichtige Frage ist die Platzierung der Fehlertexte. Eine optimale Benutzerführung
verlangt, dass ein direkter Bezug zwischen Fehlerquelle und Fehlertext
hergestellt werden muss. Dazu ist die Fehlerausgabe direkt neben (oder unter)
dem Feld zu platzieren, das den Fehler verursachte. An zentraler Stelle – vorzugsweise
oberhalb des Formulars (damit der Fehler ohne Rollen sichtbar ist) – wird
eine Zusammenfassung aller Fehler gegeben. Wichtig ist auch, alle Fehler gleichzeitig
zur Anzeige zu bringen und damit zu verhindern, dass der Benutzer sich mit
dem Trial-and-Error-Prinzip durch die Reaktionen des Formulars klickt. Falls das
Layout keinen Platz für detaillierte Meldungen neben den Feldern liefert, kann
man mit Fußnoten arbeiten. Dabei wird eine Fehlernummer neben dem betroffenen
Feld eingeblendet und unterhalb des Formulars eine ausführliche Erläuterung
geboten.
Techniken mit Style-Definitionen
Eine Problematik, die fast jedes Formular betrifft, ist die Platzierung der Fehlertexte.
Generell benötigen Fehlertexte Platz. Wird dieser von vornherein freigehalten,
wirkt ein Formular möglicherweise recht »locker«, was dem Layout der Seite
widersprechen kann. Nimmt man auf Fehler dagegen keine Rücksicht und blendet
sie einfach in einem fertigen Layout ein, kann die Seite »zerfallen«.
309

310
Formular- und Seitenmanagement
Was genau zu machen ist, hängt von der konkreten Situation ab. Häufig bietet es
sich an, den Platz der Fehlermeldung zu reservieren, indem man den Text schon
beim ersten Aufruf des Formulars auf die Seite schreibt. Dort wird er mit der Stil-
Anweisung visibility:hidden unsichtbar gemacht. Dieser Stil wird in erster Instanz
durch JavaScript oder – wenn JavaScript nicht funktioniert – durch PHP ersetzt.
Das folgende Skript zeigt, wie das funktioniert.
Listing 8.12: formjavascriptdisplay.php – Nutzung von CSS für die Fehlerausgabe
Formulare
function Check()
{
var ok = true;
if (document.logon.Loginname.value == '')
{
document.getElementById('errName').style.visibility
= "visible";
ok = false;
}
if (document.logon.Password.value == '')
{
document.getElementById('errPass').style.visibility
= "visible";
ok = false;
}
if (ok)
{
document.logon.submit();
}
document.logon.submit();
}

Professionelle Formulare und »Sticky Forms«
{
$displayName = 'visible';
}
else
{
$displayName = 'hidden';
}
if (empty($_POST['Password']))
{
$displayPass = 'visible';
}
else
{
$displayPass = 'hidden';
}
}
else
{
$displayName = 'hidden';
$displayPass = 'hidden';
}
?>

312
Formular- und Seitenmanagement
style="color:red;visibility:">
Kennwort wurde nicht angegeben
Dieses Skript erledigt alle dynamischen Darstellaufgaben hervorragend. Betrachten
Sie zuerst den PHP-Abschnitt. Darin werden zwei Variablen festgelegt, die die
Vorauswahl der Sichtbarkeit der Fehlertexte festlegen, $displayName und $displayPass.
Beim ersten Aufruf, REQUEST_METHOD ist gleich GET, werden
natürlich keine Fehler angezeigt. Schaut man in den generierten HTML-Quelltext,
sehen die Span-Tags, die die Fehlertexte umschließen, folgendermaßen aus:
Neben der Steuerung der Sichtbarkeit mit visibility:hidden wird dem Tag auch das
id-Attribut mitgegeben. Dies ist notwendig, um per JavaScript darauf zugreifen zu
können. Die JavaScript-Prüfung ist dann auch der erste Versuch, den Fehlerzustand
zu erkennen. Wie bereits beim letzten Beispiel gezeigt, führt ein Klick auf
die Schaltfläche zu einer Prüffunktion:
onClick="Check();"
Diese wiederum greift in der schon bekannten Weise auf die Felder zu und überprüft
deren Inhalt. Ist eines der Fehler leer, wird nun einfach der Fehlertext sichtbar
gemacht, indem die Voreinstellung überschrieben wird:
document.getElementById('errName').style.visibility = "visible";
getElementById ist eine Methode, die das Element mit dem betreffenden Namen
beschafft und bereitstellt. Für die Nutzung dieser Methode wurde das id-Attribut
benötigt. Von dem betroffenen Element wird nun die Style-Auflistung ermittelt
(.style) und aus dieser wiederum das Attribut .visibility. Dann ist nur noch der entsprechende
Wert zu setzen, der den Angaben entspricht, wie man sie direkt mit
HTML machen würde (»hidden« oder »visible«).
War die Prüfung erfolgreich, wird das Formular gesendet.

JavaScript geht nicht...
Professionelle Formulare und »Sticky Forms«
Wenn JavaScript ganz abgeschaltet ist, funktioniert die letzte Variante noch nicht
zufrieden stellend, weil das Absenden der Form überhaupt nicht stattfindet. Eine
kleine Modifikation hilft, das Problem zu umgehen.
Listing 8.13: formjavascriptdisplaymod.php – Komplexe Verarbeitung von Eingaben mit
JavaScript und CSS
Formulare
function Check()
{
var ok = true;
if (document.logon.Loginname.value == '')
{
document.getElementById('errName').style.visibility
= "visible";
ok = false;
}
if (document.logon.Password.value == '')
{
document.getElementById('errPass').style.visibility
= "visible";
ok = false;
}
return ok;
}

314
Formular- und Seitenmanagement
{
$displayName = 'hidden';
}
if (empty($_POST['Password']))
{
$displayPass = 'visible';
}
else
{
$displayPass = 'hidden';
}
}
else
{
$displayName = 'hidden';
$displayPass = 'hidden';
}
?>

Professionelle Formulare und »Sticky Forms«
Hier wurde nun die Schaltfläche wieder durch die originäre Variante type="submit"
ersetzt. Ohne JavaScript wird das onClick-Ereignis nicht erkannt und das Formular
sofort gesendet. Die Prüfung in PHP wird dann aktiviert und die Variable
entsprechend gesetzt:
$displayName = 'visible';
Die JavaScript-Funktion Check wurde auch ein wenig geändert. Sie gibt nun
einen Booleschen Wert zurück, der das Ergebnis der Prüfung bestimmt:
return ok;
Dieses Ergebnis wird mit einem weiteren return an das Klickereignis übergeben
und bestimmt dessen Rückgabewert. Ist der Wert false, wird der Klick nicht ausgeführt,
ist er true, wird er ausgeführt.
In der Kombination der Maßnahmen erhält man das (fast) perfekte Formular:
Ist JavaScript an, wird die Prüfung im Client durchgeführt
Ohne JavaScript funktioniert es auch, dann kommt PHP zum Zuge
Fehlermeldungen werden in jedem Fall dynamisch erzeugt und der Platz ist
immer reserviert
Was jetzt noch fehlt ist der Erhalt der Werte im Fehlerfall. Dazu wird eine als
»Sticky Forms« bezeichnete Technik verwendet.
Sticky Forms
Sticky Forms sind eigentlich nur ein simpler Programmierstil. Formulare gewinnen
dadurch jedoch signifikant an Professionalität und Benutzerfreundlichkeit.
Das Prinzip ist einfach. Man nutzt die im POST-Zyklus erkannten Werte, um die
value-Attribute der Felder mit den alten Werten zu belegen.
Die JavaScript-Abschnitte aus den letzten Beispielen wurden in diesem Abschnitt
nicht erneut in die Beispiele eingebaut, weil bei einer rein clientseitigen Prüfung
die Werte ohnehin erhalten bleiben und die hier beschriebenen Techniken nicht
315

316
Formular- und Seitenmanagement
sinnvoll einsetzbar sind. Für ein optimales »Fallback«, also die volle Funktion
auch ohne JavaScript, sind jedoch beide Maßnahmen erforderlich.
Textfelder
Bei Eingabefeldern für Text ist dies besonders einfach. Das letzte Beispiel lässt sich
leicht erweitern, um im Fehlerfall nun auch die Inhalte zu erhalten.
Listing 8.14: formstickytext.php – Fehlerprüfung mit Werterhalt in allen Feldern

Professionelle Formulare und »Sticky Forms«
}
?>

318
Formular- und Seitenmanagement
Die Kombination aus dynamischer Fehlererzeugung und Werterhaltung macht
aus einem einfachen HTML-Formular durch den Einsatz von PHP und JavaScript
eine hochwertige, benutzerfreundliche Lösung.
Textarea-Tags werden übrigens ebenso behandelt, nur wird hier statt des Attributes
value der Wert zwischen die Tags geschrieben:
Optionsfelder und Kontrollkästchen
Optionsfelder und Kontrollkästchen unterscheiden sich kaum von der Behandlung
der Textfelder. Statt des Wertes wird hier das Attribut checked gesetzt. Wenn man
sich für die dynamische Erzeugung der Felder per Skript entschieden hat, ist die
Umsetzung nicht schwer. Das folgende Beispiel zeigt, wie es geht:
Listing 8.15: formstickycheckauto.php – Startwerte festlegen und Auswahlzustand bei
einer dynamisch erzeugten Auswahl von Kontrollkästchen erhalten

Professionelle Formulare und »Sticky Forms«
}
$action = $_SERVER['PHP_SELF'];
$checkboxes = array (
'chkPerl' => array('Perl', 'Perl', '1', FALSE),
'chkPHP' => array('PHP', 'PHP', '1', TRUE),
'chkVBS' => array('VBScript', 'Visual Basic Script', '1', TRUE),
'chkCSharp' => array('C#', 'C# (.NET)', '1', FALSE),
'chkCPlusPlus' => array('C++', 'C++ (VSC++)', '1', FALSE),
'chkDelphi' => array('Delphi', 'Delphi (Pascal)', '1', FALSE),
'chkFortran' => array('Fortan', 'Fortran', '1', FALSE));
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
foreach ($_POST as $fName => $fValue)
{
if (substr($fName, 0, 3) == 'chk')
{
echo

320
Formular- und Seitenmanagement
$boxData[0],
$boxData[1]
);
}
?>
Das Geheimnis liegt hier im Aufruf von IsChecked innerhalb der Ausgabefunktion
printf:
IsChecked($boxName, $boxData)
Übergeben werden der Name der aktuellen Box und die Daten, die im Array $box-
Data stehen. Diese Daten bestimmen das Aussehen des jeweiligen Kontrollkästchens.
Die eigentliche Arbeit wird nun in IsChecked erledigt. Beim Erstaufruf (GET)
wird die Vorgabe aus dem Array benutzt, um eine Voreinstellung zu erreichen.
return ($boxData[3]) ? 'checked' : '';
Im POST-Zyklus wird dagegen der Zustand der gesendeten Felder mit dem gerade
in Bearbeitung befindlichen verglichen:
if (!empty($_POST[$boxName]))
Ist da ein Wert drin, dann gilt das Feld als gesetzt und die Zeichenkette »checked«
wird zurückgegeben.
Optionsfelder werden mit demselben Attribut gesetzt, nur muss man hier die Mehrfachauswahl
verhindern, was die Sache aber im Prinzip noch weiter vereinfacht.
Listfelder
Listen aller Art sind etwas schwerer zu beherrschen. Der Erhalt des Wertes erfolgt
hier über das Setzen von selected-Attributen in den Option-Tags. Da dies jedes Tag
betreffen kann, muss man quasi über eine ausreichende Anzahl Variablen für jede
Option verfügen.

Professionelle Formulare und »Sticky Forms«
Listing 8.16: formstickyselect.php – Einfache Listbox, die den gewählten Wert erhält

322
Formular- und Seitenmanagement

Professionelle Formulare und »Sticky Forms«
Listing 8.17: formstickyselectmulti.php – Mehrfachauswahl einer Liste mit automatischem
Erhalt der Werte

324
Formular- und Seitenmanagement

Professionelle Formulare und »Sticky Forms«
Mehrseitige Formulare mit versteckten Feldern
Mehrseitige Formulare sind immer dann sinnvoll, wenn die Anzahl der Felder zu
groß ist, um ohne heftiges Umherscrollen gelesen werden zu können. Nun stellt
sich natürlich die Frage, wie man von einer Seite zu nächsten gelangt, ohne dass
die Daten der vorhergehenden Seiten verloren gehen. Es gibt hier mehrere
Lösungsansätze, die je nach Situation den einen oder anderen Vorteil bringen.
Prinzipien und Forderungen
Vor der Erstellung der Formulare muss man sich klar machen, dass ein Zurückblättern
vom Browser mehr oder weniger wirkungsvoll verhindert wird. Es ist wichtig,
dass die Fehlerprüfungen auf jeder Seite stattfinden und nicht erst am Ende,
weil ein gezielter Rückschritt sehr aufwändig zu programmieren ist und dem
Benutzer keinen wirklichen Vorteil bringt.
Das Zurückblättern ist ohnehin eine aufwändige Angelegenheit. Für den Benutzer
ist es unter Umständen jedoch durchaus hilfreich, wenn er sich in einem mehrseitigen
Formular frei bewegen kann. Typischerweise werden dann oberhalb des Formulars
Fortschrittsanzeigen platziert, die Auskunft über den aktuellen Stand
geben. So etwas ist vertrauensbildend und sorgt für einen unverkrampften Umgang
mit den Seiten, was mithin den Erfolg steigert, dass ein Benutzern auch am Ende
ankommt.
Wie bereits bei den bisherigen Beispielen, macht erst eine geschickte Kombination
aus Styles, JavaScript, HTML und PHP wirklich das aus, was ein Benutzer als
brauchbar empfindet. Wie es geht, soll anhand eines längeren Beispiels erläutert
werden. Es basiert im Wesentlichen auf der Nutzung versteckter Felder.
Versteckte Felder
HTML erlaubt die Verwendung von Feldern mit dem Typ »hidden«. Eine Anzeigeform
hat dieser Typ nicht, das Feld ist versteckt. Im Quelltext der Seite bleibt es
freilich sichtbar, aus Sicherheitsgründen ist der Einsatz sinnlos. Versteckte Felder
erlauben es aber, die aktuell erfassten Werte mitzunehmen und damit auf der
nächsten Seite im Kontext der Seite zu sehen, ohne dass dies zusätzlichen Programmieraufwand
verursacht. Denn die Inhalte versteckter Felder sind so wie
jedes andere Formularfeld Teil des $_POST-Arrays.
325

326
Formular- und Seitenmanagement
Die Definition in HTML sieht folgendermaßen aus:

Professionelle Formulare und »Sticky Forms«
{
color: red;
background-color:#ddddff;
text-align:center;
font-size: 14pt;
}
.inactiveNumber
{
color: #cccccc;
background-color:#ddddff;
text-align:center;
font-size: 14pt;
}
.activeTable
{
display:visible;
height:100px;
width:500px;
}
.inactiveTable
{
display:none
}

328
Formular- und Seitenmanagement
}
if (!empty($_POST['next']))
{
$currentPage++;
if ($currentPage == 4)
{
$nextDisabled = 'disabled';
}
}
$fldName = GetField('Name');
$fldAddress = GetField('Address');
$fldZip = GetField('Zip');
$fldCity = GetField('City');
$fldConditions = GetField('Conditions');
$fldLogonName = GetField('LogonName');
$fldPassword = GetField('Password');
$fldNews = GetField('News');
if (!empty($_POST['Send']))
{
$currentPage = 0;
echo "Vielen Dank für das Ausfüllen des Formulars";
exit;
}
?>

Professionelle Formulare und »Sticky Forms«
Name

330
Formular- und Seitenmanagement
/>
Type 2 type="submit"
name="prev" value="Zurück"/>

Professionelle Formulare und »Sticky Forms«
Das ist sicher nicht mehr ganz so kompakt wie die anderen Beispiele. Deshalb soll
der Blick auf den Ablauf vorangestellt werden. Die folgenden Abbildungen zeigen
die vier Seiten in Aktion.
Abbildung 8.16:
Schritt1 umfasst
die Anmeldedaten
Abbildung 8.17:
Schritt 2 enthält
nur die Bestätigung
Abbildung 8.18:
Schritt 3 erlaubt
die Erfassung von
Anmeldename
und Kennwort
Abbildung 8.19:
In Schritt 4 kann
noch ein Newsletter
bestellt werden
331

332
Formular- und Seitenmanagement
Das Skript verwendet Stildefinitionen zur Kontrolle der Anzeige. Da sich die
Tabellen mit den Formulardaten immer an derselben Stelle befinden sollen, wird
zum Ausblenden der nicht benötigten Teile das Attribut display verwendet. Das
bereits benutzte visibility kann Elemente zwar auch unsichtbar machen, diese nehmen
aber weiterhin den im sichtbaren Zustand okkupierten Platz ein. Bei der Ausgabe
der Fehlermeldungen war das gewollt. Hier dürfte es eher störend sein,
weshalb mit display mehr erreicht werden kann. Um die Umschaltung zu vereinfachen,
werden innerhalb des Style-Tags am Anfang CSS-Klassen definiert, die die
nötigen Einstellungen enthalten. Die aktive Tabelle erhält folgenden Stil:
display:visible;
Die inaktive (unsichtbare) Tabelle wird mit dem folgenden Code vom Bildschirm
verbannt:
display:none;
Auch der Balken, der oberhalb des Formulars den Fortschritt anzeigt, nutzt Stile.
Hier wird ebenfalls nur die Klasse umgeschaltet, die passenden Definitionen
wurden entsprechend vorbereitet. Dann wird der Wert für die aktuelle Seite in
$currentPage ermittelt und bei der betreffenden Tabelle auf »activeNumber«
umgeschaltet:
Die Variable $currentPage spielt ohnehin eine herausragende Rolle, denn sie steuert
den aktuellen Zustand des Formulars. Beim ersten Aufruf ist sie undefiniert
und wird in einen Anfangszustand versetzt:
$currentPage = empty($_POST['currentPage']) ? 1
: (int) $_POST['currentPage'];
Hier wird geprüft, ob das Formular bereits abgesendet wurde. Wenn das der Fall
ist, steht die aktuelle Seite in $_POST['currentPage'], andernfalls wird hier der
Startwert 1 eingesetzt. Damit das Formular nun ständig den Wert mitnehmen
kann, kommt wie angekündigt ein verstecktes Feld zum Einsatz:

Professionelle Formulare und »Sticky Forms«
Position 1 steht, ist die Schaltfläche (Zurück) inaktiv (es geht nicht weiter zurück)
und auf Position 4 die Schaltfläche (Weiter). Beispielhaft soll hier der Vorgang für
eine Schaltfläche erläutert werden. Zuerst ein Blick auf die Definition:

334
Formular- und Seitenmanagement
8.4 Dateien hochladen
Dateien hochladen gehört zu den Formularfunktionen. In der Praxis bereitet dies
gelegentlich Schwierigkeiten, weil mehrere Prozesse zusammenspielen müssen.
Dieser Abschnitt klärt über Hintergründe, Anwendung und praktische Beispiele
auf.
Grundlagen
Um Dateien hochladen zu können, müssen diese vom Browser speziell verpackt
werden. Prinzipiell können per HTTP nur Text-Daten übertragen werden. Da
Dateien im allgemeinen Binärdaten sind (HTML-Felder enthalten dagegen nur
Text), müssen sie entsprechend kodiert werden. Um Kodierung und Dekodierung
muss man sich keine Gedanken machen. Alle Browser beherrschen das Kodieren
ebenso, wie PHP mit dem Dekodieren keine Probleme hat und dies intern erledigt.
Der Vorgang basiert auf der Nutzung der Methode POST und der üblichen
Formularübertragung.
PHP unterstützt auch Dateiuploads nach der PUT-Methode, die beispielsweise
vom Netscape Composer und dem W3C Amaya benutzt
wird. In der Praxis hat dies wenig Bedeutung, weil die meisten Provider
FTP und neuerdings auch WebDAV anbieten, was einfacher und transparenter
ist und keine Skriptsteuerung verlangt.
Das Formular vorbereiten
Um ein Formular für das Hochladen von Dateien benutzen zu können, muss es
zwei Dinge enthalten:
Die Kodierungsanweisung im Form-Tag
Ein spezielles Feld mit dem Attribut type="file"
Das Form-Tag sieht nun folgendermaßen aus:
Das Attribut enctype ist hier entscheidende Teil. Nun muss noch das Feld eingebaut
werden, dass die Auswahl der Datei lokal ermöglicht.

Dateien hochladen
Ein Feld mit dem Attribut type="file" unterliegt aus Sicherheitsgründen
bestimmten Einschränkungen. So kann die Beschriftung nicht geändert
werden. Die Schaltfläche zum Durchsuchen ist immer mit dem Text
(Durchsuchen) oder – in der englischen Version – mit (Browse) beschriftet.
Das ist einsichtig, weil man mit anderen Beschriftungen (»Gewinnen
Sie 1 Million €«) den Benutzer zu einem ungewollten Klick
verleitet könnte. Im Zusammenhang damit kann auch der Wert (Attribut
value) nicht vom Programm gesetzt werden. Denn sonst könnte man
eine Vorauswahl hineinschreiben und die Aktion dann mit JavaScript
auslösen, sodass die Website lokale Dateien systematisch beschafft. Deshalb
fällt das Thema »Sticky Forms« hier auch aus.
Nach dem Hochladen
Die empfangenen Dateien stellt PHP nicht wie die übrigen Felder als Variablen
zur Verfügung, sondern speichert sie in einem temporären Verzeichnis ab. Die
beim Hochladen erzeugten Variablen enthalten nur Informationen über die
Datei, wie beispielsweise den Dateinamen und die Größe. Das Skript, das die
Daten empfängt, muss die Dateien aus dem temporären Speicher in das finale
Verzeichnis kopieren.
Das Kopieren kann entweder mit der Funktion copy oder mit move_uploaded_files
ausgeführt werden. Die Funktion move_uploaded_files kann ausschließlich die
temporären Dateien kopieren. Das ist sicherer als copy, weil ein offen programmiertes
Skript mit freier Wahl der Pfade eventuell missbraucht werden könnte, um
vorhandene Dateien aus einem anderen Verzeichnis zu kopieren und so die Kontrolle
über den Server zu erlangen.
Prinzip
Das folgende Beispiel zeigt eine einfache Anwendung. Zur Erfolgskontrolle wird
das Verzeichnis, in dem die hochgeladenen Dateien landen, anschließend ausgegeben.
Listing 8.19: formuploadsimple.php – Formular zum Hochladen von Dateien

336
Formular- und Seitenmanagement
$err = "Kein Fehler ($num)";
switch ($num)
{
case UPLOAD_ERR_OK:
break;
case UPLOAD_ERR_INI_SIZE:
$err = "Die in der php.ini festgelegte
Größe wurde überschritten";
break;
case UPLOAD_ERR_FORM_SIZE:
$err = "Die im Formular festgelegte Größe
wurde überschritten";
break;
case UPLOAD_ERR_PARTIAL:
$err = "Es wurde nur ein Teil der Datei
hochgeladen (Abbruch)";
break;
case UPLOAD_ERR_NO_FILE:
$err = "Es wurde keine Datei hochgeladen";
break;
}
return $err;
}
$action = $_SERVER['PHP_SELF'];
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
if (is_array($_FILES))
{
$tmp = $_FILES['MyFile']['tmp_name'];
$target = "upload/{$_FILES['MyFile']['name']}";
$error = GetFileError($_FILES['MyFile']['error']);
echo "Dateien wurden hochgeladen:";
echo

}
Dateien hochladen
if (move_uploaded_file($tmp, $target))
{
echo "Datei übertragen. Aktueller Inhalt des
Verzeichnisses:";
foreach (glob(dirname($target).'/*') as $file)
{
printf('%1$s', $file);
}
}
else
{
echo "Keine Datei übertragen";
}
}
else
{
echo "Bitte Datei hochladen (100 KB maximal)";
}
?>

338
Formular- und Seitenmanagement
eine Überschreitung der Größe zu einem Fehler und die Generierung der temporären
Datei wird unterbunden. Trotz erfolgreicher Übertragung wird zumindest
verhindert, dass jemand böswillig den Server zumüllt.
Der spannende Teil ist die Auswertung des Hochladevorgangs. PHP erzeugt ein
Array mit dem Namen $_FILES, das alle Informationen über die Dateien enthält.
Dabei wird ein Eintrag für jedes mit type="file" gekennzeichnetes Feld erzeugt.
Dieser Eintrag enthält wiederum ein Array, dessen Schlüssel folgende Bedeutung
haben:
Schlüssel Bedeutung
name Ursprünglicher Namen der Datei auf der Festplatte des Benutzers
type Der MIME-Typ, der die Art der Datei beschreibt, beispielsweise »image/
gif« für ein GIF-Bild
size Die Größe der Datei in Byte
tmp_name Der Name der Datei im temporären Verzeichnis
error Der Fehlercode, der beim Hochladen erzeugt wurde (0 = Fehlerfrei)
Tabelle 8.3: Bedeutung der Schlüssel des Arrays, die zu einer Datei erzeugt werden
Mit diesen Angaben kann man praktisch alles über die Datei erfahren und die weitere
Vorgehensweise steuern. Der Name des Hauptschlüssels im Array $_FILES
wird durch den Namen des Felds bestimmt:
Der Arrayschlüssel lautet also »MyFile«. Für die Übertragung der Datei in das
finale Verzeichnis benötigt man nun zwei Angaben. Zuerst wird der temporäre
Name als Quelle ermittelt:
$tmp = $_FILES['MyFile']['tmp_name'];
Dann der Zielname, erstellt aus einem frei wählbaren Verzeichnis und dem
ursprünglichen Namen:
$target = "upload/{$_FILES['MyFile']['name']}";
Nun wird der Kopiervorgang ausgelöst:
if (move_uploaded_file($tmp, $target))

Dateien hochladen
Die Funktion gibt FALSE zurück, wenn es sich nicht um eine hochgeladene Datei
handelt. Ist die Datei dagegen bereits vorhanden, wird sie einfach überschrieben.
Das nächste Beispiel behandelt mehr solcher »Feinheiten«.
Hier wird im Anschluss lediglich noch der aktuelle Inhalt des Verzeichnisses angezeigt:
foreach (glob(dirname($target).'/*') as $file)
Das Kapitel zu Dateifunktionen geht ausführlich auf die eingesetzten Funktionen
glob und dirname ein.
Die Dateien werden außerdem als Link angeboten:
printf('%1$s', $file);
Nach ein paar Ladevorgängen sieht die Ausgabe dann ungefähr wie im folgenden
Bild aus:
Typische Probleme
Abbildung 8.20:
Hochladen von Dateien mit Auswertung
und Dateiliste
Es gibt einige Probleme, die in der Praxis auftreten können und die bisher nicht
beachtet wurden:
Laden mehrere Benutzer gleichnamige Dateien hoch, überschreiben sich
diese gegenseitig
339

340
Formular- und Seitenmanagement
Will ein Benutzer mehrere Dateien hochladen, ist das sehr umständlich
Es besteht keine Einschränkung des Dateityps; ein Benutzer könnte auch ausführbare
Dateien hochladen
Die Größenbegrenzung ist mit ein paar Tricks zu umgehen
Es gibt Probleme mit exotischen Zeichen in Dateinamen
An dieser Stelle sollen nur einige Lösungsansätze aufgezeigt werden. Um ein
Überschreiben zu vermeiden, wird die Funktion file_exists eingesetzt. Wie
dann darauf reagiert wird, hängt von der Applikation ab. Eine andere Lösung
besteht darin, jedem Benutzer ein eigenes Verzeichnis zu geben, aber dann müsste
man ein Skript implementieren, das eine Benutzeranmeldung umfasst. Ist diese
ohnehin vorhanden, sind persönliche Verzeichnisse optimal.
Für den Dateityp bietet es sich an, ein Array mit zulässigen Typen zu erstellen.
Typisch sind folgende Werte:
Bilder: image/gif, image/jpg, image/jpeg, image/png, image/x-png
Text und HTML: text/txt, text/html
Binärdaten: application/octet-stream
Sounddaten: audio/basic
Videos: video/mpeg
Prüfen Sie dann mit der Funktion in_array, ob der gesendete Typ in der Liste der
erlaubten Werte enthalten ist.
Für einen zuverlässigen Schutz gegen sehr große Dateien finden Sie im Folgenden
Abschnitt zu den Konfigurationsmöglichkeiten mehr Informationen.
Probleme mit exotischen (beispielsweise asiatischen) Zeichen in Dateinamen
kann man in den Griff bekommen, indem das iconv-Modul geladen und zur
Umwandlung benutzt wird.
Konfigurationsmöglichkeiten
Zahlreiche Konfigurationsmöglichkeiten bietet die Datei php.ini. Wenn Sie keinen
Zugriff darauf haben, bietet sich die Funktion ini_set an, mit der sich die
Einstellungen zeitweilig ändern lassen.

Konfigurationsmöglichkeiten mit der Datei php.ini
Von der Seite zum Projekt
In der Datei php.ini sind mehrere Optionen versteckt, die das Hochladeverhalten
steuern:
Option Beschreibung
file_uploads Boolescher Wert, der bestimmt, ob überhaupt ein Hochladen
erlaubt ist. »0« verhindert das Hochladen, der Standardwert
»1« erlaubt es.
upload_max_filesize Maximale Größe in Byte, die Dateien haben dürfen. Statt Bytes
kann auch eine Kombination mit »K« (beispielsweise »50K«)
für Kilobyte oder »M« (beispielsweise »1M«) für Megabyte
benutzt werden. Der Standardwert beträgt »2M« (2 Megabyte).
upload_tmp_dir Verzeichnis für die temporären Dateien. Hier müssen Schreibrechte
bestehen, sonst geht gar nichts.
post_max_size Maximale Größe in Byte, die der gesamte Umfang des Formulars
haben darf. Der Wert muss größer als upload_max_filesize
sein, damit keine weitere Einschränkung besteht.
Tabelle 8.4: Optionen zur Konfiguration des Hochladeverhaltens
8.5 Von der Seite zum Projekt
Bislang waren immer nur einzelne Seiten zu erstellen. Praktisch besteht jedoch
jede Website aus mehreren Seiten. Die Verbindung mit Hyperlinks ist Sache von
HTML und dürfte kaum Probleme bereiten. Spannender ist es, wie Daten von
Seite zu Seite übertragen werden.
Die HTTP-Methode GET
Die HTTP-Methode GET wird immer dann benutzt, wenn der Benutzer auf
einen Link klickt. Außer dem einfachen Aufruf der nächsten Seite verfügt GET
jedoch auch über Möglichkeiten, Daten mitzugeben. Damit wird der Zusammenhalt
zwischen den Seiten gesteuert.
341

342
Formular- und Seitenmanagement
Bevor es richtig losgeht, sollten Sie den Aufbau des URL komplett kennen. Hier
ein Muster:
http://www.comzept.de/pfad/index.php?val1=wert&val%202=wert#hash
Die einzelnen Teile haben nun folgende Bedeutung:
URL-Teil Bedeutung
http Protokoll
:// Trennzeichen
www Servername (kann entfallen)
comzept Domain
de Toplevel-Domain
/pfad Pfad (kann entfallen)
/index.php Datei, die aufgerufen wird (Ressource)
Alle weiteren Angaben sind optional:
? Trennzeichen zur Abtrennung der Parameter
val1=wert Parameterpaar
val1 Parametername
wert Parameterwert
& Trennzeichen zwischen Parametern
val%202=wert Weiteres Parameterpaar, kodiert
val%202 Parametername, kodiert
wert Parameterwert
# Abtrennung des Hash-Zeichens
hash Hash-Wert als Sprungziel (Sprungsmarken werden mit gebildet)
Tabelle 8.5: Aufbau eines URL

Einen URL untersuchen
Von der Seite zum Projekt
Liegt ein URL im Skript vor und Sie benötigen spezielle Angaben daraus, hilft die
Funktion parse_url:
Listing 8.20: getparseurl.php – Informationen über den Aufbau eines URL ermitteln
Die Ausgabe des von parse_url erzeugten Arrays zeigt die wichtigsten Komponenten:
Der Rest dieses Abschnitts rankt sich mehr oder minder intensiv um das als
»Query« bezeichnete Element.
Kodierung des URL
Abbildung 8.21:
Teile eines URL
Da einige Zeichen eine Sonderfunktion erfüllen, ist eine Kodierung der URL-
Daten erforderlich. Das betrifft vor allem den Inhalt der im Muster als »wert«
gekennzeichneten Bereiche. Die übliche Kodierung ersetzt Sonderzeichen durch
ihren Hexwert. So wird ein Leerzeichen durch %20 ersetzt. »%« leitet den Code
ein, 20 steht für dezimal 32 und dies ist der ASCII-Wert des Leerzeichens.
Damit es nicht so schwierig ist, kennt PHP die Funktionen url_encode und
url_decode. Dabei ist die Rückumwandlung meist nicht erforderlich, weil dies
PHP intern erledigt. Der folgende Abschnitt zeigt die praktische Anwendung.
343

344
Formular- und Seitenmanagement
Die Länge eines URL ist auf ca. 2.000 Zeichen begrenzt. Es ist wichtig,
das zu beachten, weil überhängende Werte einfach abgeschnitten werden.
Für große Datenmengen ist GET deshalb nicht geeignet. Weichen
Sie dann auf POST aus, wie im vorhergehenden Abschnitt beschrieben.
Die im letzten Beispiel als »Query« bezeichnet Folge kann damit dekodiert und
weiter untersucht werden:
Listing 8.21: getparseurldecode.php – »Händische« Zerlegung eines URL
$url = "http://www.comzept.de/pfad/
index.php?val1=wert&val%202=wert#hash";
$p = parse_url($url);
foreach ($p as $name => $content)
{
if ($name == 'query')
{
$pairs = explode('&', urldecode($content));
foreach ($pairs as $values)
{
foreach (explode('=', $values) as $w => $v)
{
echo "$w = '$v'";
}
}
}
else
{
echo "$name: $content";
}
}
Die systematische Zerlegung erfolgt hier anhand der Trennzeichen mit explode
und die Ausgabe mit foreach-Schleifen. Dies war nur als kleine Übung zum
Warmwerden gedacht, wie es einfacher geht, folgt gleich.
Daten per URL übermitteln
Um Daten per URL übermitteln zu können, werden an den Link entsprechende
Paare aus Namen und Werten angehängt. Damit ergibt sich ein ähnliches Schema
wie bei den POST-Daten aus einem Formular. Folgerichtig stellt PHP die Daten

Von der Seite zum Projekt
auch wieder zur Verfügung, und zwar als Array mit dem Namen $_GET. Dekodierung
und Splittung der Werte aus dem Query-Fragment wird automatisch erledigt.
Das funktioniert freilich nur, wenn der Benutzer auch auf einen Link klickt und
die Auswertung im aufgerufenen Skript stattfindet. Um einen als Zeichenkette vorliegenden
Link zu zerlegen, muss man wie im letzten Beispiel gezeigt vorgehen.
Listing 8.22: get_page1.php: Übergabe von Werten per URL

346
Formular- und Seitenmanagement
?>

Von der Seite zum Projekt
leicht erkennen. In solchen Fällen wird immer wieder auf die Startseite der Applikation
zurückgesprungen. Eine Möglichkeit, die Kodierung vorzunehmen, sind so
genannte Hashes. Dazu werden die vorbereiteten Daten in eine gesonderte Datei
geschrieben und per include eingebunden. Eine solche Datei könnte am Beispiel
der Navigation folgendermaßen aussehen:
Listing 8.25: get_includenav.php – Definition der Basisdaten
Vor dem Absenden an die Folgeseite werden diese Daten nun mit Hilfe der Funktion
md5 zu einem Hash verpackt.
Hashfunktionen liefern eine Art Prüfsumme über Daten, die generell
nicht wieder in den ursprünglichen Wert umgewandelt werden (sie enthalten
meist viel weniger Daten als die Datenquelle hatte). MD5 steht
für Message Digest Version 5 und ist sehr weit verbreitet.
Listing 8.26: get_navigationmd5.php – Linkgenerierung mit Kodierung

348
Formular- und Seitenmanagement
Impressum
Produkte
AGBs
Anmeldung
Nun muss auf der Zielseite der Code wieder aufgelöst werden. Dazu kodiert man
die Werte aus dem Array $titles erneut und vergleicht sie mit den gesendeten
Hashcodes:
Listing 8.27: get_navigationtargetmd5.php – Mit MD5 kodierte Links
Bla bla bla, ...
Der entscheidende Punkt ist hier der Vergleich zwischen dem am Ziel berechnet
Hash (linker Term) und dem per GET übertragenen:
if (md5($name) == $t)
Der URL der Seite sieht nun folgendermaßen aus:
get_navigationtargetmd5.php?t=3d87a30682721340bdfe22c3a1dfae28
Dahinter kann auch ein Profi nicht mehr Ansatzweise vermuten, welche Art von
Daten übertragen werden könnte. Bedenkt man, dass die Datenquelle in der Praxis
keine einfachen Zeichenketten sind, sondern durchaus schon an sich kryptische
Parameter, dann ist das Verfahren sehr sicher.

Grenzen des Verfahrens
Cookies und Sessions
Man stößt freilich auf eine andere Grenze des Verfahrens. Wenn die zu übertragenden
Daten nicht statisch sind, also bereits beim Laden der Seite feststehen,
kann man Hashes nicht einsetzen. Kryptografische Verfahren wären zwar möglich,
erhöhen aber den Aufwand erheblich. Die entstehenden URLs sind sehr lang und
der Rechenaufwand ist teilweise erheblich. Man kann Daten jedoch noch eleganter
transportieren: Mit Sessions und passend dafür entworfenen Cookies.
8.6 Cookies und Sessions
Cookies und Sessions sind untrennbar miteinander verbunden, weshalb sie auch
hier zusammen behandelt werden. Sie werden zwar noch sehen, dass Sessions
auch ohne Cookies funktionieren, aber Cookies sind als Grundlage unerlässlich.
Dieser Abschnitt zeigt, was Cookies und Sessions überhaupt sind, wozu sie dienen
und wie man sie praktisch programmiert.
Cookies
Cookies sind Daten, die der Browser im Auftrag eines Servers ablegt und immer
dann wieder ausliefert, wenn der Benutzer vom selben Server erneut Daten abruft.
Die entscheidende Aussage dabei ist, dass der Browser darüber entscheidet, was er
an den Server zurück sendet und ob überhaupt Daten gespeichert werden. Alle
modernen Browser verfügen über Möglichkeiten, Cookies abzuschalten.
An sich sind Cookies ungefährlich. Sie können lediglich Name/Wert-Paare enthalten
und entsprechen damit dem bereits behandelten Schema der POST- und
GET-Daten. Sie sind halt ein weiterer Weg, Daten von Seite zu Seite mitzunehmen.
Hintergrund
Cookies genießen leider einen recht schlechten Ruf, was an einigen missbräuchlichen
Einsätzen liegt. Generell verfügen Cookies über ein Verfallsdatum. Dem
Browser wird darin mitgeteilt, für welchen Zeitraum er das Cookie behalten und
wieder ausliefern soll. Ein Sonderfall stellen so genannten Sessioncookies dar, die
349

350
Formular- und Seitenmanagement
am Ende der Benutzersitzung verfallen – im Allgemeinen dann, wenn der Browser
geschlossen wird.
Viele Benutzer akzeptieren inzwischen nur noch Sessioncookies, weshalb
deren Anwendung unkritisch ist. Auf reguläre Cookies sollte man
sich als Webentwickler besser nicht verlassen.
Die Entwicklung der Cookies geht auf das Protokoll HTTP zurück. HTTP gilt als
so genanntes status- oder zustandsloses Protokoll. Der Browser initiiert die Verbindung
und fordert vom Server eine Ressource (HTML, PHP-Skript, Bild, ...) an.
Der Server liefert die Ressource aus und beide Seiten beenden den Vorgang. Ob
die nächste Anfrage vom selben Browser oder einem anderen kommt, kann nicht
sicher festgestellt werden. Die IP-Nummern der Browser sind nämlich meist dynamisch
und wechseln bei manchen großen Providern auch während der Benutzersitzung.
Die Firma Netscape hatte schon sehr früh die Idee, dass der Server eine kleine
Informationsdatei zusammen mit den Daten sendet, die der Browser speichert.
Die Daten enthalten eine Identifikationsnummer. Der Browser sendet bei der
nächsten Anfrage an den Server dies Nummer wieder zurück. Daran kann der Server
(bzw. das Programm, das dort abläuft) dann erkennen, um welchen Browser es
sich handelt. Das Cookie war geboren.
Den schlechten Ruf erhielten Cookies, weil die Wiedererkennung pro Ressource
passiert. Der Server verpackt die Cookies nämlich im Kopf (Header) jeder HTTP-
Antwort. Jedes Element einer Seite wird durch eine Anforderung geholt und mit
der Antwort geliefert. Eine Seite enthält neben dem eigentlichen Inhalt auch Bilder
oder Flash-Objekte. Diese werden alle mit einzelnen HTTP-Anforderungen
beschafft. Dabei kann es sein, dass ein Bild, das als Werbebanner auf der Seite
steht, von einem anderen Server geholt wird, als die eigentliche Seite. Derartige
Ad-Server (Werbefirmen betreiben die) liefern nun für viele Seiten die Banner
und damit auch Cookies aus. Natürlich gelangen die Cookies wieder zurück und
so kann man leicht Bewegungsprofile erstellen, die den Weg des Benutzers über
verschiedene ans Netzwerk angeschlossene Seiten aufzeichnen. Der Benutzer
selbst bleibt zwar anonym, aber für eine kritische Presse hat es dennoch gereicht
und flugs war der Ruf der Cookies versaut. Der Übeltäter, der als erster auf die Idee
kam, war übrigens die Firma Doubleclick, die dieses Geschäft auch heute noch
(neben vielen anderen) erfolgreich betreibt.

Cookies und Sessions
Nichtsdestotrotz sind Cookies ein wertvolles und zudem leicht beherrschbares
Instrument des Webprogrammierers und deshalb sollten Sie sich damit unbedingt
auseinandersetzen.
Cookies in PHP
Am Anfang wurde bereits erwähnt, dass Cookies ähnliche Name/Wert-Paare enthalten
wie die POST- oder GET-Werte. Folgerichtig stehen auch Cookies als
Array mit dem Namen $_COOKIE zur Verfügung. Die Erzeugung übernimmt
dagegen eine spezielle Funktionen: setcookie. Die Parameter dieser Funktion
reflektieren den Inhalt des Cookies:
name
Dies ist der einzige Pflichtparameter (alle anderen sind optional) und er enthält
den Namen des Cookies. Beim Abruf empfangener Cookies ist dies der
Schlüssel des Arrays.
value
Dies ist der Wert, der ins Cookie gesetzt wird. Die Angabe erfordert eine Zeichenkette.
Wenn der Wert leer bleibt, wird das Cookie gelöscht. Das Cookie
wird auch gelöscht, wenn das Verfallsdatum in der Vergangenheit liegt, weshalb
meist beide Angaben zum Löschen kombiniert werden.
expire
Dies ist das Verfallsdatum als Unix-Zeitstempel. Auch diese Angabe ist optional.
Wird nichts angegeben, entsteht ein Sessioncookie.
path
Ein relativer Pfad innerhalb der Applikation, damit nicht immer alle Cookies
zurückgesendet werden. Selten benutzt.
domain
Schränkt die Domain ein, wenn der Server über Subdomains verfügt. Wenn
das Cookie von www.comzept.de kommt, wird es auch nur dahin wieder
zurückgesendet. Soll es auch auf www1.comzept.de landen, muss die Domain
auf comzept.de eingeschränkt werden.
secure
Wird der Wert auf 1 gesetzt, wird das Cookie nur gesendet, wenn eine sichere
Verbindung besteht. Der Standardwert ist 0.
351

352
Formular- und Seitenmanagement
Die setcookie-Funktion kodiert Daten automatisch nach dem URL-
Schema. Wenn Sie das nicht wünschen, setzen Sie setrawcookie ein.
Abgesehen von der Kodierung sind beide Funktionen identisch.
Beschränkungen
Cookies sind auch wegen grundsätzlicher Beschränkungen nicht über längere
Zeiträume zuverlässig. Diese Grenzen sind in der Spezifikation festgelegt:
Der Browser muss nur 300 Cookies speichern
Ein Cookie darf maximal 4 KByte groß sein, inklusive des Namens
Jede Domain darf nur 20 Cookies senden
Wird eine der Grenzen erreicht, werden die im Kontext ältesten Cookies gelöscht.
Zu große Cookies werden gekürzt.
Personalisierung mit Cookies
Cookies lassen sich zur Personalisierung einsetzen. Das folgende Beispiel setzt
Schriftart und -größe einer Website nach Benutzervorgaben. Wenn der Benutzer
später wiederkommt, findet er die letzte Einstellung wieder vor. Die Daten werden
in einem Cookie gespeichert.
Listing 8.28: cookiestandard.php – Cookies setzen und wieder auslesen

Cookies und Sessions
$size = 3;
}
?>
Ihre Auswahl für Schriftart und -größe:

354
Formular- und Seitenmanagement
Damit ist das Skript in dieser Phase praktisch beendet. Die Cookies sind jetzt im
Browser angekommen. Das wirkt sich auf die Einstellungen nicht sofort aus, sondern
erst beim nächsten (zweiten) Abruf der Seite durch den Browser. Nun sendet
der Browser die Daten zurück und das $_COOKIE-Array ist gefüllt:
if (!empty($_COOKIE['face']))
Dann werden die beiden Cookies zurückgeholt:
$face = $_COOKIE['face'];
$size = $_COOKIE['size'];
Mit einem Font-Tag wird dann noch die Ausgabe kontrolliert:
Ihre Auswahl für Schriftart und -größe:

Cookies und Sessions
-- Ihre Auswahl --
Verdana
Arial
Tahoma
Times Roman
-- Ihre Auswahl --
1
2
3
4
5
6
7

356
Formular- und Seitenmanagement
Das Skript ist nun schon sehr weit entwickelt. Was als nächste Aufgabe ansteht,
wäre die Kodierung der Cookie-Werte.
Andere Daten in Cookies speichern
Cookies können nur Zeichenketten speichern. PHP kann andere Skalare leicht
umwandeln. Arrays sind dagegen schwerer zu verpacken. Eine gute Idee ist die
Verwendung von serialize. Diese Funktion erstellt eine Zeichenkettenform auch
aus komplexen Variablen. Das folgende Beispiel verpackt die Daten aus dem letzten
Skript in ein Array und muss deshalb nur noch ein Cookie senden. Das erhöht
– nebenbei – durchaus die Chance, dass es auch wiederkommt.
Listing 8.30: cookieserialize.php – Cookies zum Speichern verpackter Arrays verwenden
(das verwendete Formular entspricht exakt dem letzten Listing 8.29)

Cookies und Sessions
$super = array_merge($cookies, $_POST);
if (count($super) > 1)
{
$face = $super['face'];
$size = $super['size'];
}
else
{
$face = 'Courier New';
$size = 3;
}
?>
Zuerst werden die Daten, die das Cookie speichern soll, in ein Array gepackt:
$array = array('face' => $_POST['face'],
'size' => $_POST['size']);
Dann wird das Array serialisiert und gesendet:
setcookie('font', serialize($array), $expires);
Beim Auspacken des Cookies geht man dann genau umgekehrt vor:
$cookies = unserialize($_COOKIE['font']);
Das entstehende Array entspricht genau dem ursprünglich verpackten und kann
sofort verwendet werden:
$super = array_merge($cookies, $_POST);
Der Rest ist gegenüber der letzten Version unverändert.
Als Letztes ist ein Blick auf die Daten interessant, die PHP beim Serialisieren
erzeugt:
a:2:{s:4:"face";s:5:"Arial";s:4:"size";s:1:"3";}
Aus diesen Daten kann PHP alles entnehmen, was zur Regenerierung der Daten
erforderlich ist.
Cookies und Sicherheit
Cookies sind nicht zuverlässig und nicht sicher. Es ist generell ein sehr schlechte
Idee, Benutzernamen und Kennwörter in Cookies zu speichern. Bemächtigt sich
jemand eines Computers, auf dem Kennwörter in Cookies gespeichert sind,
könnte er sich damit unter einem fremden Namen anmelden. Außerdem liegen
357

358
Formular- und Seitenmanagement
die Cookies in allen Browsern im Klartext vor, sodass »Schnüffelprogramme«
intime Daten finden könnten.
Am besten ist es, wenn man nur IDs speichert und alle anderen Daten konsequent
auf dem Server belässt. Genau das ist die Aufgabe der Session-Verwaltung.
Session-Verwaltung
Bei der Session-Verwaltung geht es im weitesten Sinne darum, zu einem bestimmten
Benutzer gehörende Daten während der gesamten Sitzung zu speichern und
die Zuordnung aufrecht zu erhalten. Cookies sind ursprünglich zu diesem Zweck
entworfen worden. Nun darf man die Dinge nicht durcheinander bringen. Es ist
nicht der Sinn des Cookies, diese Daten zu speichern. Wie bereits gezeigt wurde,
sind Cookies nicht wirklich sicher. Die Session-Verwaltung macht es sich zur Aufgabe,
zum einen jeden technisch möglichen Weg zum Erhalt des Zustands zu nutzen
und außerdem die Speicherung der eigentlichen Daten als integrierte Aufgabe
zu übernehmen.
Datenspeichermethoden
Werden Daten zu einem Benutzer gespeichert, muss zuerst die Frage gestellt werden,
wo diese abgelegt werden. Speichern ist ein weitläufiger Begriff. Grundsätzlich
bietet sich folgendes an:
Dateisystem
Datenbank
Computer-Speicher
Andere Server
PHP verwendet davon standardmäßig das Dateisystem. Es ist auf Unix-Systemen
mit Apache Webserver und PHP-Modul möglich, auch den Computer-Speicher
zu nutzen. Der Preis für höhere Leistung ist die Inkompatibilität der Skripte mit
anderen Systemen. Datenbanken sind schnell, elegant und meist optimal, das
Modul zum Speichern aber muss selbst implementiert werden. Andere Server sind
eher Notlösungen, um Cluster zu ermöglichen, wenn keine Datenbank vorhanden
ist. Apropos Cluster: Sind mehrere Webserver zur Lastverteilung zusammengeschlossen,
so ist nicht unbedingt sicherzustellen, dass Abrufe ein und desselben
Browsers immer beim gleichen Server landen. Wenn nun die Sitzungsdaten auf

Cookies und Sessions
der einen Maschine auf der Festplatte liegen und der nächste Start des Skripts von
einer anderen erfolgt, geht der durch die Session-Verwaltung erreichte Zusammenhang
wieder verloren. Alle größeren Systeme nutzen deshalb Datenbanken.
Damit aber nicht schon bei den ersten Versuchen eine Datenbank benötigt wird,
nutzt PHP ohne weitere Einstellungen das Dateisystem.
Methoden zur Übertragung der Session-ID
Die Session-ID spielt eine herausragende Rolle bei der Session-Verwaltung. Sie
sorgt dafür, dass der Benutzer beim erneuten Abruf wieder erkannt wird. Nur die
Session-ID wird letztlich auf seinem Computer gespeichert. Die Daten verlassen
niemals den Server. Der Erhalt der Session-ID ist also wesentlich für die Funktion.
Damit das funktioniert, muss diese mit dem Code der HTML-Seite zum Browser
und von dort wieder zurück gelangen. Es gibt drei Wege, die in PHP5 dafür zur
Verfügung stehen:
1. GET
2. POST
3. Cookies
Cookies sind übrigens eigens zu diesem Zweck erfunden worden und PHP5
nimmt diese als Standard. Nur wenn Cookies – aus welchen Gründen auch immer
– nicht benutzt werden sollen, kommen andere Techniken zum Zuge. Letztlich
geht es immer nur darum, die Session-ID hin und her zu transportieren.
Wird GET verwendet, erfolgt die Verpackung im URL, als einfacher GET-Parameter:
http://www.comzept.de/test.php?sid=ASD934DE42BC906876AF73F10932B
Es ist dann natürlich erforderlich, dafür zu sorgen, dass dieser Parameter in jeden
internen Seitenaufruf eingebaut wird. PHP erledigt dies intern sehr zuverlässig,
wenn es sich um einfaches HTML oder komplette Links in JavaScript handelt.
Bei POST muss die Session-ID Teil des Formulars werden. Dazu wird ein verstecktes
Feld eingebaut:
359

360
Formular- und Seitenmanagement
Die Session-Verwaltung in PHP5 erledigt nun mehrere Dinge intern:
Verwendung von Sessioncookies, wenn möglich
Übergang auf GET und POST, wenn erforderlich oder explizit verlangt
Speicherung von Variablen im Kontext einer Sitzung in Dateien
Kontrolle der Sitzungsdauer
Wenn Sie die Daten nicht in Dateien, sondern anders speichern möchten, müssen
die entsprechenden Behandlungsfunktionen manuell ausprogrammiert werden.
PHP5 stellt dafür einen Schnittstelle über Rückruffunktionen bereit, die dies recht
einfach macht. Für »normale« Applikationen reicht es jedoch, die interne Verwaltung
zu verwenden und so schnell von Session-Variablen zu profitieren.
Vorbereitung
Wie bereits erwähnt, speichert PHP5 standardmäßig die Sitzungsdaten in Dateien.
Als Ziel wird das temporäre Verzeichnis benutzt. In der Auslieferungsversion der
php.ini wird der Unix-Dateipfad verwendet. Da 90% aller Entwicklungsumgebungen
unter Windows laufen, kommt es regelmäßig zu einer Fehlermeldung beim
ersten Start der Session-Verwaltung.
Wenn dieser Fehler auftritt, öffnen Sie die für Ihre Installation zuständige Datei
php.ini. Wenn Sie nicht wissen, wo diese liegt, erstellen Sie ein Skript, in dem die
Funktion phpinfo aufgerufen wird. Im Kopf der Seite steht die benötigte Angabe:
In dieser Datei suchen Sie nun nach folgender Zeile:
session.save_path = "/tmp"
Abbildung 8.25:
Fehler, die Session-Verwaltung
konnte die Daten
nicht speichern
Abbildung 8.26:
So ermitteln Sie
die richtige
php.ini

Cookies und Sessions
Ändern Sie die Zeile so, dass sie auf ein existierendes Verzeichnis zeigt:
session.save_path = "C:\Windows\Temp"
Noch ein Problem ergibt sich, wenn Skripte aus dem Internet übernommen werden,
die Funktionen wie session_register verwenden. Es ist mit PHP5 nicht
empfehlenswert, diese Funktionen einzusetzen, weil aus Sicherheitsgründen
einige damit verbundene Automatismen ausgeschaltet wurden. Das erschwert den
Umgang. Einfacher ist es, das bereits mehrfach verwendete Schema mit dem globalen
Array zu nutzen und das für die Session-Verwaltung zuständige Array
$_SESSION zu verwenden.
Anwendung
Um die Session-Verwaltung zu verwenden, genügt es, am Anfang des Skripts folgende
Funktion aufrufen:
session_start();
Nun sind noch die Variablen festzulegen, die als Teil der Session-Verwaltung
gespeichert werden sollen. Dazu dient das $_SESSION-Array:
$_SESSION['VariablenName'] = $Variable;
Springt nun der Benutzer auf eine Folgeseite, steht dort, nachdem erneut
session_start aufgerufen wurde, das Array mitsamt Inhalt wieder zur Verfügung.
Das folgende Beispiel zeigt, wie es in der Praxis funktioniert. Es realisiert eine einfache
Benutzeranmeldung. Nach erfolgreicher Anmeldung sollen alle Seiten
zugänglich sein:
Listing 8.31: sessionlogon.php – Anmeldeseite mit Speicherung der Anmeldedaten in
einer Session-Variablen

362
Formular- und Seitenmanagement
{
$links .= sprintf('%2$s',
$target,
$title);
}
return $links;
}
function CheckLogon()
{
global $names;
if ($_SERVER['REQUEST_METHOD'] != 'POST') return FALSE;
foreach ($names as $Logon => $Password)
{
echo '#';
if (!empty($_POST['Logon']) && $_POST['Logon'] == $Logon
&&
!empty($_POST['Password'])
&& $_POST['Password'] == $Password)
{
$_SESSION['LogonName'] = $Logon;
return TRUE;
}
}
return FALSE;
}
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
CheckLogon();
}
?>

Cookies und Sessions
Kennwort:
Der erste Prozess, der erkannt werden muss, ist das Absenden des Formulars. Nur
dann kann der Benutzer eine Anmeldung versucht haben:
if ($_SERVER['REQUEST_METHOD'] == 'POST')
Ist das der Fall, wird die Funktion zum Prüfen der Anmeldedaten ausgeführt:
CheckLogon();
Diese Funktion sollte in praktischen Anwendungen durch eine spezifischeren
Variante ersetzt werden. Hier wird nur gegen die Daten eines fest programmierten
Arrays geprüft. Ist diese Prüfung erfolgreich, wird der Anmeldename in die Session
geschrieben:
$_SESSION['LogonName'] = $Logon;
Dieser Vorgang ist sicher, weil der Benutzer keine Möglichkeit hat, den Inhalt dieses
Arrays zu manipulieren. Beim Erzeugen der Links wird nun die erfolgreiche
Anmeldung zur Anzeigesteuerung benutzt. Es ist nun wichtig, dass auf jeder beliebigen
Folgeseite die Information darüber vorliegt, ob die Anmeldung erfolgte. Das
Skript sessionpages.php zeigt, wie dies aussehen kann:
Listing 8.32: sessionpages.php – Zugriff auf die Session-Variablen

364
Formular- und Seitenmanagement
$$name = $value;
}
}
ReCreateVariables();
$title = empty($_GET['title']) ? 'Startseite' : $_GET['title'];
?>
Sie sind angemeldet als:
Mit dem Aufruf von session_start stehen die gespeicherten Variablen im
$_SESSION-Array wieder bereit. Sie können nun direkt darauf zugreifen. Falls es
einfacher oder praktikabler ist, alle Variablen wieder als globale verfügbar zu
machen. Die Funktion ReCreateVariables() erledigt das. Dazu durchläuft man das
Array mit foreach:
foreach($_SESSION as $name => $value)
Nun wird über die Syntax der variablen Variablennamen die aktuelle lokale Variable
$name zur globalen Variablen erklärt:
global $$name;
Dieser nun global deklarierten Variablen wird der entsprechende Wert zugewiesen:
$$name = $value;
Wichtig ist hier nur, die zwei $$-Zeichen statt des normalerweise verwendeten einzelnen
anzugeben, damit der Text in $name den Namen der Variable bestimmt,
nicht die Variable selbst (indirekter Zugriff).
Wenn nun im $_SESSION-Array ein Eintrag mit dem Namen LogonName existiert,
steht dieser als Variable zur Verfügung, sodass folgendes funktioniert:
Die Referenz Session-Verwaltung zeigt weitere Session-Funktionen. Deren Anwendung
unterliegt teilweise Restriktionen der konkreten PHP-Installation. Der
hier beschriebene Weg mit dem $_SESSION-Array ist nicht die einzige Möglichkeit,
aber er funktioniert garantiert immer.

8.7 Referenz
Wichtige Systemarrays
Name Beschreibung
Server- und Umgebungsvariablen
Referenz
$_GET Variablen einer GET-Anforderung, die als Teil des URL übertragen wurden.
$_POST Variablen einer POST-Anforderung, die als Teil eines Formulars übertragen
wurden.
$_REQUEST Alle Variablen, egal ob per GET oder POST übertragen.
$_COOKIES Auflistung aller definierten und empfangenen Cookies der letzten
Anforderung.
$_SESSION Auflistung aller Sitzungsvariablen und deren Werte. Dieses Array ist nur
nutzbar, wenn die Sitzungsverwaltung aktiviert wurde.
$_FILES Informationen über zuletzt hochgeladene Dateien, deren Größe, MIME-
Typ, Name und temporärer Name. Dieses Array ist nur gefüllt, wenn Formulare
mit der entsprechenden Kodierung gesendet werden.
Tabelle 8.6: Systemarrays in PHP5
Name der Variable Beschreibung
ALL_HTTP Alle HTTP-Header, die vom Client zum Server gesendet
wurden. Das Ergebnis sind Header, die mit HTTP_
beginnen.
ALL_RAW Alle HTTP-Header, die vom Client zum Server gesendet
wurden. Im Ergebnis werden Header gesendet, die
kein Präfix haben.
APPL_MD_PATH Gibt den Pfad zur Metabasis der Applikation an (nur
IIS/Windows).
Tabelle 8.7: Server- und Umgebungsvariablen
365

366
Formular- und Seitenmanagement
Name der Variable Beschreibung
APPL_PHYSICAL_PATH Gibt den physischen Pfad zur Metabasis der Applikation
an (nur IIS/Windows).
AUTH_NAME Name des Nutzers bei Eingabe in das Kennwortfeld des
Browsers.
AUTH_PASSWORD Das Kennwort einer Autorisierung, wenn es im Kennwortfeld
des Browsers eingegeben wurde (nur Windows).
AUTH_TYPE Art der Autorisierung, wenn Nutzer Zugriff auf ein
geschütztes Dokument haben möchten (nur Windows).
CERT_COOKIE Eindeutige ID eines Clientzertifikats.
CERT_FLAGS Flag des Clientzertifikats, Bit 0 ist 1, wenn das Clientzertifikat
vorhanden ist, Bit 1 ist 1, wenn das Clientzertifikat
nicht überprüft wurde.
CERT_ISSUER Das Issuer-(Herausgeber)-Feld des Clientzertifikats.
CERT_KEYSIZE Bitzahl bei einer SSL-Verbindung.
CERT_SECRETKEYSIZE Anzahl der Bits eines privaten Zertifikatschlüssels.
CERT_SERIALNUMBER Die Seriennummer des Zertifikats.
CERT_SERVER_ISSUER Das Issuer-(Herausgeber)-Feld des Serverzertifikats
(Issuer-Feld).
CERT_SERVER_SUBJECT Beschreibung des Zertifikats (Server).
CERT_SUBJECT Beschreibung des Zertifikats (Client).
CONTENT_LENGTH Länge des zu sendenden Inhalts.
CONTENT_TYPE Art des Inhalts (MIME-Type).
DATE_GMT Datum/Uhrzeit des Servers in Zone GMT.
DATE_LOCAL Datum/Uhrzeit des Servers.
DOCUMENT_NAME Name des ausführenden Dokuments.
Tabelle 8.7: Server- und Umgebungsvariablen (Forts.)

Name der Variable Beschreibung
DOCUMENT_ROOT Pfad zum Dokument ohne Dateiname.
GATEWAY_INTERFACE Art des Interfaces, das der Server benutzt.
Referenz
HTTP_ACCEPT Enthält die MIME-Typen, die der Browser akzeptieren
kann und will.
HTTP_COOKIE Die Cookie-Daten, wenn Cookies gesendet wurden.
HTTP_REFERER Die letzte Adresse, von welcher der Browser kam.
Wurde die Seite direkt aufgerufen, ist der Wert leer.
HTTP_USER_AGENT Kennung des Browsers, beispielsweise Mozilla/4.0
(compatible; MSIE 5.0; Windows NT). Der Wert kann
auf vielen Systemen manipuliert werden und ist deshalb
mit Vorsicht zu betrachten.
HTTPS Ist ON, wenn der Server SSL benutzt.
HTTPS_KEYSIZE Schlüssellänge der HTTPS-Verbindung (40bit,
128bit...).
HTTPS_SECRETKEYSIZE Schlüssellänge bei privaten Zertifikaten.
HTTPS_SERVER_ISSUER Issuer-Feld des Serverzertifikats bei sicherer Übertragung.
HTTPS_SERVER_SUBJECT Eine Beschreibung des Servers.
INSTANCE_ID ID-Nummer der Instanz (nur IIS).
INSTANCE_META_PATH Der Metabasispfad (nur IIS).
LOCAL_ADDR Die in der Anforderung benutzte Serveradresse.
LOGON_USER Das lokale Benutzerkonto.
PATH_INFO Pfadinformation für den Client.
PATH_TRANSLATED Übertragung der Pfadinformation ins physische Format.
QUERY_STRING Inhalt des Querystrings (Parameter-URL).
REMOTE_ADDR Die IP-Adresse des Nutzers.
Tabelle 8.7: Server- und Umgebungsvariablen (Forts.)
367

368
Formular- und Seitenmanagement
Name der Variable Beschreibung
REMOTE_HOST Der Name des Computers des Nutzers.
REQUEST_METHOD Die Methode der Datenübertragung eines Formulars.
Kann GET, PUT oder POST sein.
REQUEST_URI URI der Anforderung.
SCRIPT_FILENAME Name eines Skripts.
SCRIPT_NAME Name eines Skripts.
SERVER_NAME Der Hostname des Servers, eine DNS- oder IP-Adresse.
SERVER_PORT Port, der vom Server benutzt wird (normalerweise 80).
SERVER_PORT_SECURE Port, der bei sicherer Übertragung benutzt wird
(Standard: 443).
SERVER_PROTOCOL Das verwendete Protokoll und die Version (beispielsweise
HTTP1.1).
SERVER_SIGNATURE Signatur des Servers (einstellbare Info).
SERVER_SOFTWARE Der Name und die Version der auf dem Server laufenden
Software.
Tabelle 8.7: Server- und Umgebungsvariablen (Forts.)
Der Abruf erfolgt immer mit $_SERVER['NAME']. Beachten Sie, dass nicht auf allen
Servern alle Variablen zur Verfügung stehen und dass sich die Inhalte teilweise
geringfügig unterscheiden, beispielsweise bei Pfadangaben.
Session-Verwaltung
Funktion Beschreibung
session_cache_expire Die aktuelle Cache-Verfallszeit.
session_cache_limiter Art der Cacheverwaltung.
session_decode Dekodiert die Daten einer Session.
Tabelle 8.8: Funktionen der Session-Verwaltung

Funktion Beschreibung
session_destroy Beendet die Session und zerstört alle Daten.
session_encode Kodiert die Daten der aktuellen Session.
session_get_cookie_params Liefert die Session-Cookie Parameter.
session_id Setzt oder ermittelt die aktuelle Session-ID.
Referenz
session_is_registered Überprüft, ob eine globale Variable in einer Session
bereits registriert ist.
session_module_name Ermittelt oder setzt das aktuelle Session-Modul.
session_name Ermittelt oder setzt den Namen der aktuellen Session.
session_regenerate_id Erzeugt eine neue Session-ID, ohne die Session dabei
zu beenden.
session_register Registriert eine Variable als Session-Variable.
session_save_path Ermittelt oder setzt den aktuellen Speicherpfad der
Session (zum temporären Verzeichnis).
session_set_cookie_params Setzt die Parameter für das Session-Cookie.
session_set_save_handler Setzt benutzerdefinierte Rückruffunktionen.
session_start Initialisiert eine Session.
session_unregister Nimmt eine Variable aus den Session-Variablen wieder
raus.
session_unset Löscht alle Session-Variablen.
session_write_close Speichert alle Session-Daten und beendet die Session.
Tabelle 8.8: Funktionen der Session-Verwaltung (Forts.)
Initialisierungseintrag Beschreibung
session.name Der Name der Session. Dieser Wert wird für den Url-Parameter
und das Cookie verwendet. Der Standardwert ist
PHPSESSID.
Tabelle 8.9: Konfiguration der Session-Verwaltung
369

370
Formular- und Seitenmanagement
Initialisierungseintrag Beschreibung
session.auto_start Wenn aktiviert, wird bei einer neuen Anfrage eine neue
Session gestartet, nicht erst beim Aufruf von session_start.
Standardmäßig deaktiviert (0), zum Aktivieren auf 1 setzen.
session.serialize_handler Name der Methode, mit der die Daten serialisiert werden.
Standardwert ist »php«, Alternative ist »wddx«.
session.gc_probability Regelt die Wahrscheinlichkeit, mit der die Aufräumroutine
alte Session-Daten beseitigt. Standardwert ist 1.
session.gc_divisor Regelt die Wahrscheinlichkeit, mit der die Aufräumroutine
alte Session-Daten beseitigt, im Verbund mit
»gc_probability«. Die finale Wahrscheinlichkeit beträgt
gc_probability/gc_divisor. Der Standardwert ist 100, dass
heißt die Aufräumroutine startet mit einer Wahrscheinlichkeit
von 1%.
session.gc_maxlifetime Lebensdauer einer Session in Sekunden. Der Standardwert
beträgt 1440 (24 Minuten).
session.referer_check Zeichenkette, die im Referer (Quelle des HTTP-Abrufs)
enthalten sein muss. Wenn aktiviert, verhindert man damit
den Einsprung in eine Session von außerhalb. Standardmäßig
nicht verwendet.
session.entropy_file Pfad einer Quelldatei, die beim Erzeugen der Session-ID
benutzt wird. Standardmäßig nicht verwendet.
session.entropy_length Anzahl der Bytes, die aus der Entropie-Datei gelesen werden.
Standardwert ist 0.
session.use_cookies Erlaubt Cookies. Standardwert ist 1 (aktiviert).
session.use_only_cookies Erzwingt (!) Cookies. Cookies werden auch so verwendet,
aber mit dieser Option kann man alternative Wege aus
Kompatibilitätsgründen verhindern. Standardmäßig nicht
aktiviert (0).
session.cookie_lifetime Lebensdauer des Cookies. Standardwert ist 0, was typische
Session-Cookies erzeugt.
session.cookie_path Pfad-Angabe des Session-Cookies.
Tabelle 8.9: Konfiguration der Session-Verwaltung (Forts.)

Initialisierungseintrag Beschreibung
session.cookie_domain Domain-Angabe des Session-Cookies.
Referenz
session.cookie_secure Erzwingt die Verwendung sicherer Verbindungen für das
Cookie.
session.cache_limiter Methode der Cacheverwaltung. Standardwert ist »nocache«
(nicht verwendet).
session.cache_expire Verfallszeitpunkt des Cache in Minuten. Standardwert ist
180.
session.use_trans_sid Aktiviert die transparente SID-Umsetzung, bei der versteckte
Felder und URL-Erweiterung zur Übergabe der
Session-ID verwendet werden.
session.bug_compat_42 Erzeugt eine Warnung, wenn versucht wird, mit einem
Trick globale Variablen mit Session-Daten zu erzeugen,
obwohl dies durch andere Einstellungen verboten ist und
zusätzlich bug_compat_warn aktiviert wurde.
session.bug_compat_warn Erzeugt eine Warnung, wenn versucht wird, mit einem
Trick globale Variablen mit Session-Daten zu erzeugen,
obwohl dies durch andere Einstellungen verboten ist.
session.hash_function Prüfsummenfunktion für die Session-ID. 0 = MD5
(128 Bit), 1 = SHA-1 (160 Bit). Standard ist MD5.
session.hash_bits_per_
character
Gespeicherte Bits pro Zeichen in der Session-ID. Kann 4, 5
oder 6 sein. 4 ist der Standardwert.
url_rewriter.tags Tags, die zur Aufnahme der Session-ID umgeschrieben
werden dürfen.
Tabelle 8.9: Konfiguration der Session-Verwaltung (Forts.)
371

372
Formular- und Seitenmanagement
8.8 Kontrollfragen
1. Warum sollten unbedingt immer »Sticky Forms« verwendet werden?
2. Welche Funktionen unterstützen das Hochladen von Dateien? Was ist beim Aufbau
des Formulars zu beachten?
3. Welche Methoden verwenden Sessions, um die Session-Daten zu speichern?
4. Wie können Cookies missbraucht werden?

Professionelle
Programmierung
9

374
Professionelle Programmierung
9.1 Mehrsprachige Webseiten
Immer häufiger wird gefordert, Webseiten mehrsprachig anzubieten. Es ist gerade
für kleine Unternehmen ein Segen, Kunden überall auf der Welt ansprechen zu
können. Mit Deutsch allein kommt man dabei aber nicht weit, mit Englisch wiederum
kann man hierzulande nicht viel erreichen. Es ist deshalb oft notwendig,
Websites in mehreren Sprachen anzubieten. Damit der Aufwand nicht ins Unermessliche
steigt, gibt es verschiedene Techniken, Gestaltung und Inhalt zu trennen,
sodass die aufwändige Grafik nur einmal existiert, die variablen Inhalte
dagegen getrennt gehalten werden.
Vor der Auswahl der Sprache steht jedoch die Erkennung der Daten durch den
Benutzer. Dies erfolgt durch Auswertung der vom Browser übermittelten Daten.
Browserdaten erkennen
Der Browser überträgt verschiedene Informationen an den Server, die sich dann in
PHP-Skripten auswerten lassen. Neben Betriebssystem, Name des Browsers und
verschiedenen Angaben zu akzeptierten Daten gehört auch die bevorzugte Sprache
dazu.
Sprache im Browser einrichten
Jeder Benutzer sollte in seinem Browser die bevorzugte Sprache einrichten, damit
Skripte, wie die nachfolgend vorgestellten, auch funktionieren. Die entsprechenden
Menükommandos zeigt die folgende Liste:
Netscape/Mozilla: Bearbeiten | Einstellungen | Navigator | Sprachen
Internet Explorer: Extras | Internetoptionen | Allgemein | Sprachen
Opera: Datei | Einstellungen | Sprachen
Tango: Sprache | Spracheinstellungen
Lynx 2.7: O (Options) | G (lanGuage)
Nach dieser Angabe ist natürlich interessant zu wissen, was davon in PHP5
ankommt. Benutzt wird eine Servervariable aus dem Array $_SERVER:
HTTP_ACCEPT_LANGUAGE.

Mehrsprachige Webseiten
Diese enthält eine Liste der akzeptierten Sprachen mit einer Angabe der Wertigkeit.
Die erste Sprache ist immer die bevorzugte, der Rest teilt sich mit abnehmender
Wichtung in Relation zu 1. Das »q« steht für »Quality«. Die in der letzten
Abbildung gezeigte Angabe sendet der Browser folgendermaßen:
de,en-us;q=0.7,fr;q=0.3
Das bedeutet, die Hauptsprache ist Deutsch, Englisch wird mit 0,7 gegenüber
Französisch mit 0,3 bevorzugt, wobei 1 = ideal wäre. Die meisten Browser legen
die Werte selbst fest, sodass hier wenig Wahl besteht. Tatsächlich wäre es auch
möglich, folgende Angabe zu machen:
de,en-us;q=0.8,e-gb;q=0.7
Hier wird mitgeteilt, dass Deutsch ideal ist, amerikanisches Englisch akzeptiert
wird und alternativ auch britisches Englisch gern gelesen wird.
Sie sollten als Programmierer nicht darauf vertrauen, dass irgendwer
mehr als die Standardsprache halbwegs sinnvoll eingestellt hat. Die folgenden
Anwendungen werten deshalb auch nur diesen Teil aus.
Sprache auswerten
Abbildung 9.1:
Spracheinstellungen im Internet
Explorer
Das Auswerten der Sprache ist nun recht einfach. Man muss nur die Servervariable
abfragen und den ersten Teil, bis zum Komma, abtrennen:
375

376
Professionelle Programmierung
Listing 9.1: browserlang.php – Sprachakzeptanz abfragen und Hauptsprache ermitteln
Das Skript nutzt Zeichenkettenfunktionen, um den Anfang der Sprachinformation
und damit die Hauptsprache herauszufinden. Für die Auswertung der übrigen
Informationen bietet sich der Zugriff auf reguläre Ausdrücke oder die Zerlegung
mit explode an.
Steht die Sprache fest, muss nur noch entsprechend darauf reagiert werden.
Lokalisierung und Formatierung von Zeichen
Abbildung 9.2:
Sprachinfo und extrahierte
Hauptsprache
Die Lokalisierung basiert meist auf der Anwendung der Funktion setlocale, die
das Verhalten anderer Funktionen beeinflusst. Allerdings ist der Umgang damit
recht tückisch. Leider hat sich dies mit PHP5 nicht gebessert, was umso unverständlicher
ist, als dass neuere Programmierumgebungen wie .NET auch unter Windows
den gängigen Standards folgen und es keinen Grund gibt, dies nicht zu adaptieren.
Generell gilt folgende Regel für Linux-Systeme:
Das Basisformat ist »Sprache_Land«, also beispielsweise »de_DE« oder
»de_AT«
Braucht man bestimmte Sonderzeichen einer Sprache, die bei der Ausgabe
angezeigt werden sollen, kann man eine Codeseite angeben: »kr_KR.949«.
Windows-Systeme erwarten statt der Ländercodes Sprachnamen, abgekürzt oder
ausgeschrieben:
Das Basisformat ist »Germany« oder »ge« bzw. »German_Germany« oder
»German_Austria«. Es ist also in den allermeisten Fällen erforderlich, das vom
Browser gesendete Sprachkürzel »de« in die passende Form umzuwandeln.

Die Funktion setlocale anwenden
Mehrsprachige Webseiten
Alle Formate, die printf und verwandte Funktionen benutzen, reagieren auf die
Einstellungen mit setlocale. Damit ist es möglich, die korrekten Formatierungen
für Zahlen zu erhalten, also Komma als Dezimaltrennzeichen in deutschen Texten
usw. Außerdem lassen sich Zeitangaben bei der Ausgabe mit strftime in die
passende Sprache setzen.
Für die Formatierung von Zahlen muss setlocale entweder mit der Konstanten
LC_ALL oder LC_NUMERIC bedacht werden:
setlocale(LC_NUMERIC, "German_Germany");
Die Angabe muss vor der ersten Ausgabe mit einer der printf-Funktionen erfolgen.
Um die Rückstellung der vorherigen Angabe zu ermöglichen, können Sie den
Rückgabewert von setlocale abfragen.
Die folgende Tabelle zeigt alle Konstanten, die setlocale benutzt:
Konstante Bedeutung Betroffene Funktion
LC_ALL Beeinflusst alle Formate printf
LC_COLLATE Beeinflusst Zeichenkettenvergleiche strcoll
LC_CTYPE Klassifizierung von Zeichen strtoupper
LC_MONETARY Betrifft Währungsangaben localeconv
LC_NUMERIC Betrifft Zahlenangaben localeconv
LC_TIME Beeinflusst Datums- und Zeitangaben strftime
Tabelle 9.1: Konstanten, die setlocale benutzt
strcoll entspricht der Funktion strcmp mit dem Unterschied, dass die
Lokalisierung berücksichtig wird. strcmp ignoriert diese.
Die Anwendung der Funktion kann auch auf Bedingungen des Betriebssystems
abgestimmt werden. Wenn der zweite Parameter leer ist (nicht fehlend, sondern
eine leere Zeichenkette), dann wird versucht, eine Umgebungsvariable zu lesen,
deren Namen der Konstanten entspricht. Der folgende Ausdruck liest die Umgebungsvariable
LC_NUMERIC und setzt setlocale entsprechend:
377

378
Professionelle Programmierung
setlocale(LC_NUMERIC, "");
Clever ist es auch, eine Fallbackmöglichkeit zu schaffen. Wie anfangs bereits
beschrieben, sind auf den verschiedenen Betriebssystemen die Lokalisierungszeichenfolgen
zu beachten. Deshalb kann an dieser Stelle auch ein Array angegeben
werden:
setlocale(LC_NUMERIC, array("de", "de_DE", "German_Germany"));
Es gibt natürlich auch die Möglichkeit, hier die Sprache zu wechseln, um unter
allen Umständen ein reproduzierbares Ergebnis zu erzielen.
Das Format der aktuellen Lokalisierung ermitteln
Um festzustellen, wie PHP5 intern arbeitet und wie sich die Parameter der Lokalisierung
auswirken, gibt es die Funktion localeconv. Sie gibt ein Array zurück, das
die entsprechenden Angaben enthält. Die folgende Abbildung zeigt die Ausgabe
für die Lokalisierung Deutsch:
Abbildung 9.3:
Ausgabe der Lokalisierungszeichen
für
Deutsch/Deutschland
(links) und Deutsch/
Schweiz (rechts)
Die Angaben können hilfreich sein, um den Platzbedarf von Zeichenketten zu
berechnen oder die Wirkung der Lokalisierung zu überwachen. Um die Tabellen
zu erstellen, wurde folgendes Skript verwendet:

Listing 9.2: localeconv.php – Lokalisierungsangaben ausgeben
Dynamisch Bilder erzeugen
9.2 Dynamisch Bilder erzeugen
Das dynamische Erzeugen von Bildern gehört mit zu den am häufigsten diskutierten
Möglichkeiten von PHP. Die mit PHP5 verfügbare neue Grafikbibliothek
GD2 stellt neue Funktionen bereit, um professionell wirkende Grafiken dynamisch
zu erstellen.
Prinzip
Um das Prinzip der Erzeugung dynamischer Bilder zu verstehen, muss man sich
noch mal den Ablauf des Seitenaufbaus im Browser in Erinnerung rufen. Nach
dem Laden der HTML-Seite analysiert der Browser den Inhalt und beginnt mit
der Darstellung. Findet er ein Bild, leitet er für die angegebene Bildquelle eine
weitere asynchrone 1 HTTP-Anforderung ein. Der dann zurückgegebene binäre
Datenstrom wird wiederum interpretiert und, ins entsprechende Bildformat
zurückgewandelt, zur Darstellung verwendet. Bei dem Vorgang an sich ist es dem
Browser egal, woher das Bild kommt. Er erwartet letztlich nur einen simplen
Datenstrom. Den kann man erzeugen, indem man auf dem Server ein Bild ablegt
und dem Webserver die Auslieferung überlässt. Es ist aber auch möglich, die
Arbeit von einem Skript erledigen zu lassen, das die Daten fachgerecht generiert.
Als Quelle wird dann einfach ein PHP-Skript genommen:
1 Deswegen erscheinen die Bilder manchmal erst viel später.
379

380
Professionelle Programmierung
Dem Skript kann man selbstverständlich auch GET-Parameter übergeben, um das
Verhalten zu steuern:
Aufbau eines bilderzeugenden Skripts
Für ein bilderzeugendes Skript muss man mehrere Dinge beachten:
Es dürfen ausschließlich Bilddaten erzeugt werden. Schon ein einziges Leerzeichen
zerstört das Bild.
Es müssen die passenden Kopfzeilen erzeugt werden, damit der Browser weiß,
welcher Bildtyp zu den Binärdaten passt.
Das Skript sollte relativ schnell und effizient sein, sonst verzögert sich der Bildaufbau
erheblich.
Die passenden Kopfzeilen werden mit der Funktion header erzeugt. Die Ausgaben
selbst können wie üblich mit printf oder echo gesendet werden. Für header wird
die Angabe des Inhaltstyps (Content-type) benötigt. Der konkrete Typ richtet sich
nach der Bildart. Möglich sind folgende Werte:
image/gif
image/jpg
image/png
image/wbmp (für WAP)
Der Aufruf der Funktion sieht dann beispielsweise für ein PNG-Bild folgendermaßen
aus:
header ('Content-type: image/png');
Es ist übrigens gut möglich, zusätzlich noch Cookies an das Bild anzuhängen,
was oft bei Werbebannern gemacht wird. Werbebanner sind
letztlich auch nur Bilder (mal von Flash-Bannern abgesehen) und lassen
sich sehr gut dynamisch erzeugen.
Typische Probleme
Gleich vorab soll auf einige typische Probleme hingewiesen werden. Da der Browser
ein Bild erwatet, wird er eine Fehlerausgabe des Skripts nicht interpretieren

Dynamisch Bilder erzeugen
können. Der Internet Explorer zeigt beispielsweise ein Ersatzbild mit einem roten
Kreuz – aber eben keine Fehlermeldung. Hierfür gibt es mehrere Lösungen:
Erzeugen Sie im Fehlerfall andere Kopfzeilen, die die Ausgabe von Text erlauben.
Geben Sie ein (vorher korrekt programmiertes) Ersatzbild aus, das den Fehler
anzeigt.
Verwenden Sie try/catch und den @-Operator, um Fehler abzufangen und die
Fehlertexte in eine Protokolldatei zu schreiben.
Allen Varianten gemeinsam ist, dass die Fehlerausgabe mehr Aufwand verursacht
als bei normalen Skripten. Der erreichte Effekt einer dynamischen Bildausgabe ist
allerdings oft diesen Mehraufwand wert.
Einführung in die Grafikbibliothek GD2
Vor den ersten Versuchen mit der Grafikbibliothek GD2 sollten Sie testen, ob die
Erweiterung aktiviert wurde und zur Verfügung steht. Der Aufruf von phpinfo ist
der ideale Platz dafür.
Prinzip der Bilderzeugung
Die Bilderzeugung erfolgt in zwei Stufen. Zuerst muss eine Zeichenfläche erstellt
werden, auf der anschließend alle Zeichen- und Textoperationen stattfinden.
Dazu dient die Funktion imagecreate:
$img = imagecreate(480, 80);
Abbildung 9.4:
GD2 wurde erfolgreich
aktiviert
381

382
Professionelle Programmierung
Der Bildtyp, also GIF oder PNG, muss hier noch nicht festgelegt werden. Das Zeichenmodul
arbeitet generell mit einem internen Format, aus dem alle anderen
Formate verlustfrei erstellt werden können.
Der Rückgabewert $img enthält nun ein Handle auf die interne Abbildung des Bildes.
Alle folgenden Funktionen nutzen dieses Handle zum Zugriff.
Sind alle Bildoperationen fertig, wird das Bild erzeugt und an den Browser gesendet.
Dazu dienen die Funktion imagegif, imagepng, imagejpeg usw.:
imagegif($img);
Der Suffix bestimmt dabei den Bildtyp, der sich je nach Applikation unterscheiden
kann.
Alternativ zur Erzeugung eines neuen Bilds kann die Bilddatei auf einem bereits
existierenden Bild basieren. Dazu dienen die Funktionen imagecreatefromgif,
imagecreatefrompng, imagecreatefromjpeg usw.
$img = imagecreatefromgif('pfad/zur/datei.gif');
Die Bildgröße wird dabei zwangsläufig von der Quelldatei bestimmt. Liegt das Bild
vor, kann man nun entweder Text darauf schreiben oder mit Bildfunktionen
malen. Die Vielfalt der Funktionen lässt eine ausführliche Betrachtung in diesem
Rahmen nicht zu, deshalb sollen zwei Beispiele das Prinzip demonstrieren.
Textausgabe
Die Textausgabe ist deshalb ein schwieriges Thema, weil der Text auf der Fläche
platziert werden muss, was nicht einfach ist, wenn die Menge nicht passt. Hier
muss gegebenenfalls gerechnet werden. Ausgangspunkt ist die Funktion
imagettfbbox, die die voraussichtlichen Maße des Textes in Abhängigkeit vom
Font (Schriftart) und der verlangten Größe ermittelt. Die Funktion gibt ein
Array zurück, dessen Elemente die entsprechenden Angaben enthalten:
Index Beschreibung
0 Links oben, X
1 Links unten, Y
2 Rechts unten, X
Tabelle 9.2: Bedeutung der Elemente des mit imagettfbbox erzeugten Arrays

Index Beschreibung
3 Rechts unten, Y
4 Oben rechts, X
5 Oben rechts, Y
6 Oben links, X
7 Oben links, Y
Dynamisch Bilder erzeugen
Tabelle 9.2: Bedeutung der Elemente des mit imagettfbbox erzeugten Arrays (Forts.)
Die Funktion kann einen Winkel einbeziehen, um den der Text gedreht
erscheint. Die Koordinaten, die den Platzbedarf angeben, sind jedoch immer absolut
in den Ecken eines virtuellen Rechtecks, das im Fall einer Drehung entsprechend
groß ist, um den Text aufzunehmen.
Aus den Daten lässt sich nun entnehmen, ob der Text passt und man kann entsprechend
reagieren, um den Text gegebenenfalls passend zu machen. Stimmt alles,
erfolgt die eigentliche Ausgabe mit imagettftext. Benötigt werden folgende Angaben:
Position der linken, oberen Ecke in zwei Werten für x und y.
Winkel, um den der Text gedreht erscheint.
Schriftart, in Form eines Pfades zu einer TrueType-Datei.
Schrifthöhe in Punkt (1 Punkt entspricht 1/72«).
Die Farbe, die benutzt werden soll.
Der Text, der dargestellt wird.
Die Schriftart wird als Pfad zu einer TrueType-Datei angegeben. Achten Sie hier
darauf, dass nur Dateien verwendet werden, zu denen auch die erforderlichen
Rechte vorhanden sind. Das Herauskopieren aus anderen Anwendungen funktioniert
zwar meist, ist aber nur selten legal. Frei Fonts sind im Internet leicht zu finden,
wenngleich diese auch eine schwankende Qualität haben. Wer seinen Server
unter Windows betreibt hat es da leichter, denn er kann die typischen Windows-
Fonts nutzen, beispielsweise Verdana oder Tahoma.
Die Farbe wird als RGB-Wert erwartet, der vorher in der Farbtabelle der Bildbasis
registriert werden muss. Dabei geht die GD2-Bibliothek so vor, dass die erste Farbzuweisung
immer die Hintergrundfarbe festlegt, während alle Folgenden der Farb-
383

384
Professionelle Programmierung
tabelle zugeordnet werden. Jede Zuweisung gibt ein Handle auf die Farbe zurück
und dieses Handle ist zu verwenden. Im folgenden Fragment ist $img das Handle
auf das Bild und $handle_black das Handle auf die Farbe (nach der Ausführung).
Die definierte Farbe ist schwarz:
$handle_black = imagecolorallocate($img, 0, 0, 0);
Die drei Werte stehen für die Farbkanäle Rot, Grün und Blau. Erlaubt sind Angaben
zwischen 0 (kein Anteil der Farbe) und 255 (voller Anteil).
Um hexadezimale Angaben zu verwenden, bietet sich die Angabe von
Hex-Literalen der Art 0xFF an.
Das folgende Beispiel erzeugt einen Text auf einer grauen Grundfläche:
Listing 9.3: imagettftext.php – Text auf einer Bildfläche ausgeben
Das Skript wendet sehr direkt die zuvor beschriebenen Funktionen an. Es erzeugt
die folgende Ausgabe:
Abbildung 9.5:
Dynamisch
erzeugtes Bild
Soweit das Skript nicht unmittelbar nach der Ausgabe endet, ist es empfehlenswert,
den belegten Speicherplatz sofort freizugeben. Bedenken Sie, dass Bilder
erheblichen Speicherplatz in Anspruch nehmen können. Das sehr einfache Bild
des letzten Beispiels benötigt etwa 115 KByte.

Bildfunktionen
Dynamisch Bilder erzeugen
Ähnlich wie bei Text geht es auch bei den Bildfunktionen. Typische Operationen
umfassen hier das Zeichnen von Rechtecken, Kreisen, Linien oder Punkten. Teil
der Bildfunktionen ist aber auch das Verarbeiten anderer Bilder, das Filtern, Verzerren,
Kopieren, Zerschneiden usw.
Das folgende Beispiel zeichnet olympische Ringe (es ist während der Sommerolympiade
2004 in Athen entstanden):
Listing 9.4: imagerings.php – Dynamisches Zeichnen olympischer Ringe

386
Professionelle Programmierung
{
for ($i = 0; $i < 15; $i++)
{
imagearc($img, $point->x, $point->y,
Circle::RAD+$i, Circle::RAD+$i,
0, 360, $point->color);
}
imagearc($img, $point->x, $point->y,
Circle::RAD+$i, Circle::RAD+$i,
0, 360, $white);
}
header ('Content-type: image/gif');
imagegif($img);
?>
Das Skript ist keineswegs perfekt, aber es zeigt das Prinzip und die Möglichkeiten.
Vor allem die korrekte Verschlingung der Ringe wäre weitaus aufwändiger. Die
Anwendung der Klasse Circle demonstriert dennoch, wie die Zeichenfunktionen
von objektorientierten Ansätzen profitieren können. Die Darstellung der Kreise als
Objekte vereinfacht das Skript erheblich und trägt wesentlich zur Lesbarkeit bei.
Abbildung 9.6:
Vereinfachte Version der olympischen Ringe,
mit GD2 erstellt
Wenn Sie das Skript laufen lassen, können sie die farbige Version erleben, die der
Druck nur mangelhaft wiedergeben kann.
Anwendungsbeispiel »Dynamischer Werbebanner«
Das folgende Beispiel zeigt die Anwendung der GD2-Bibliothek anhand einer
Klasse, die dynamisch rechteckige Bereiche erstellt und mit Bildern, Farben und
Texten füllt. Anhand von weiteren Parametern kann man daraus beispielsweise
dynamisch Banner erstellen, deren Inhalt je nach Situation und Benutzer variiert.

Nutzung
Dynamisch Bilder erzeugen
Die Klasse erwartet die Werte als GET-Parameter. Dieser Teil lässt sich freilich
leicht anpassen. Die folgende Tabelle zeigt Namen und Bedeutung der Parameter:
Parameter Bedeutung
W Breite
H Höhe
A Ausrichtung, beispielsweise »left«
C Farbe des Textes
FF Font, der verwendet werden soll
FS Schrifthöhe in Punkt
BG Pfad zu einem Hintergrundbild. Das Bild bestimmt die Größe des Banners,
sodass die Werte H und W ignoriert werden
BC Hintergrundfarbe, wird nur akzeptiert, wenn kein Hintergrundbild angegeben
wird
B Randbreite in Pixel
TXT Der Text, der auf dem Banner angezeigt wird
Tabelle 9.3: Bedeutung der Parameter zur Steuerung der Grafikklasse
Quellcode der Klasse
Die Klasse nutzt konsequent die neuen Möglichkeiten von PHP5 und eignet sich
ideal für den Einbau in eigene Projekte. Ein kleines Testskript folgt am Ende.
Listing 9.5: gd2lib.inc.php – Hilfsklasse zum Erstellen von Bannern

388
Professionelle Programmierung
public function __construct($msg)
{
parent::__construct($msg);
}
}
class LSImage
{
private $intWidth;
private $intHeight;
private $strAlign;
private $strColor;
private $strFontFace;
private $strFontSize;
private $intBorder;
private $strBackColor;
private $strBackImage;
private $strText;
private $strType;
private $im;
private $dx;
private $dy;
const FONTPATH = 'fonts/';
public function __construct($strSetType = 'png')
{
set_error_handler(array($this, 'throwError'));
$this->strType = $strSetType;
$arrURI = $_GET;
if ($arrURI['LSF'] = 'image')
{
if (isset($arrURI['BG']))
{
$this->strBackImage = $arrURI['BG'];
}
else
{
$this->strBackColor= $arrURI['BC'];
}
$this->intWidth = $arrURI['W'];
$this->intHeight = $arrURI['H'];
$this->strAlign = $arrURI['A'];

}
}
Dynamisch Bilder erzeugen
$this->strColor = $arrURI['C'];
$this->strFontFace = self::FONTPATH
. strtolower($arrURI['FF']);
if (substr($this->strFontFace, -4) != '.ttf')
$this->strFontFace .= '.ttf';
if (!file_exists ($this->strFontFace))
$this->strFontFace = self::FONTPATH . 'verdana.ttf';
$this->strFontSize = $arrURI['FS'];
$this->intBorder = $arrURI['B'];
$this->strText=stripslashes(urldecode($arrURI['TXT']));
private function throwError($errno, $err, $line, $file)
{
throw new NoticeException("$errno, $err, $line, $file");
}
private function getcolor($strColor)
{
$r = hexdec(substr($strColor, 0, 2));
$g = hexdec(substr($strColor, 2, 2));
$b = hexdec(substr($strColor, 4, 2));
return imagecolorallocate($this->im, $r, $g, $b);
}
private function CheckBackgroundSize()
{
if ($this->intWidth != imagesx($this->im)
or $this->intHeight != imagesy($this->im))
{
return true;
} else {
return false;
}
}
private function create()
{
$pi = pathinfo($this->strBackImage);
$extension = isset($pi['extension']) ? $pi['extension'] : '';
switch ($extension)
{
389

390
Professionelle Programmierung
case 'jpg':
case 'jpeg':
$this->im = imagecreatefromjpeg($this->strBackImage);
break;
case 'gif':
$this->im = imagecreatefromgif($this->strBackImage);
break;
case 'png':
$this->im = imagecreatefrompng($this->strBackImage);
break;
default:
$this->im = imagecreate($this->intWidth,
$this->intHeight);
}
if ($this->im === FALSE)
{
throw new ImageException('Kein Hintergrund und
keine Bildgröße angegeben');
}
if ($this->CheckBackgroundSize())
{
$bi = imagecreate($this->intWidth, $this->intHeight);
if (function_exists('imagecopyresampled'))
imagecopyresampled($bi, $this->im, 0, 0, 0, 0,
imagesx($bi),
imagesy($bi),
imagesx($this->im),
imagesy($this->im));
else
imagecopyresized($bi, $this->im, 0, 0, 0, 0,
imagesx($bi),
imagesy($bi),
imagesx($this->im),
imagesy($this->im));
$this->im = $bi;
}
$this->getcolor($this->strBackColor);
$arr = imagettfbbox($this->strFontSize, 0,
$this->strFontFace, $this->strText); //
if ($arr === FALSE)
{
throw new ImagingException('TTF wird nicht unterstützt');

Dynamisch Bilder erzeugen
}
else
{
$this->dy = $this->intHeight -
(($this->intHeight / 2) - (abs($arr[7]) / 2));
$this->dy = $this->dy < 0 ? $this->intHeight : $this->dy;
switch (strtolower($this->strAlign))
{
case 'center':
case 'middle':
$this->dx = ($this->intWidth / 2) - ($arr[2] / 2);
break;
case 'right':
$this->dx = $this->intWidth - $arr[2];
break;
case 'left':
default:
$this->dx = 0;
break;
}
}
$this->dx += $this->intBorder;
for ($i = 0; $i < $this->intBorder; $i++)
{
imagerectangle($this->im, $i, $i,
$this->intWidth-$i-1,
$this->intHeight-$i-1,
$this->getColor($this->strBackColor));
}
}
public function image()
{
try
{
$this->create();
header( "Content-type: image/" . $this->strType);
$fg = $this->getcolor($this->strColor);
imagettftext($this->im, (int) $this->strFontSize, 0,
$this->dx, $this->dy, $fg,
$this->strFontFace, $this->strText);
call_user_func('Image' . $this->strType, $this->im);
ImageDestroy($this->im);
391

}
392
}
Professionelle Programmierung
}
catch (ImagingException $ex)
{
echo $ex->getMessage();
}
$objImg = new LSImage;
$objImg->image();
?>
Das Skript beginnt mit der Erstellung zweier Fehlerklassen, damit die Fehlerbehandlung
über die neue Ausnahmesteuerung mit try/catch erfolgen kann. Die
erste Klasse soll lediglich Warnungen erfassen:
class NoticeException extends Exception
Auslöser ist die Umleitung der klassischen Laufzeitfehler im Konstruktor:
set_error_handler(array($this, 'throwError'));
Tritt ein Fehler auf, wird die Methode throwError aufgerufen, die ihrerseits den
Fehler in eine Ausnahme verwandelt:
private function throwError($errno, $err, $line, $file)
{
throw new NoticeException("$errno, $err, $line, $file");
}
Das eigentliche Bilderzeugungsprogramm beginnt im Konstruktor mit der Übernahme
der GET-Parameter in lokale Eigenschaften. Danach muss das Hauptprogramm
die Methode image aufrufen, um das Bild zu erstellen. Die Bilderzeugung
ist in einem try-Block untergebracht, um Ausnahmen abfangen zu können. Im
Fehlerfall werden dann andere Header erzeugt, was die Fehlersuche vereinfacht.
Die Ausführung der Bilderzeugung erfolgt in der privaten Methode create:
$this->create();
Gelingt die Bilderzeugung, wird der Text auf dem Bild platziert. Hier könnte man
Cache-Techniken ansetzen, um die mit create erzeugten Daten zu erhalten und
die aufwändige Erstellungsprozedur zu vermeiden.
Die Ausgabe vollzieht sich in mehreren Schritten. Zuerst wird die Vordergrundfarbe
ermittelt:
$fg = $this->getcolor($this->strColor);

Dynamisch Bilder erzeugen
Dann wird anhand der vorausberechneten Größen der Text im verlangten True-
Type-Font geschrieben:
imagettftext($this->im, (int) $this->strFontSize, 0,
$this->dx, $this->dy, $fg,
$this->strFontFace, $this->strText);
Dann wird die Kopfzeile für den Browser erzeugt, die den Bildtyp bestimmt:
header( "Content-type: image/" . $this->strType);
Passend dazu wird der entsprechende Typ erzeugt und gesendet:
call_user_func('Image' . $this->strType, $this->im);
Der Funktionsaufruf »baut« aus dem Wort Image und dem Typ den Funktionsnamen
zusammen, also beispielsweise ImagePng. Anschließend wird das Bild zerstört,
um den belegten Speicher sofort freizugeben:
ImageDestroy($this->im);
Der eigentliche Bildaufbau findet in create statt. Es wird zunächst ermittelt, ob der
Pfad eines Hintergrundbildes vorliegt:
$pi = pathinfo($this->strBackImage);
$extension = isset($pi['extension']) ? $pi['extension'] : '';
Je nach Bildtyp erfolgt dann im switch-Zweig der Aufbau der Zeichenfläche aus
dem Hintergrundbild. Das Hintergrundbild bestimmt bis hierher die Bildgröße:
$this->im = imagecreatefromgif($this->strBackImage);
Nur wenn kein Hintergrundbild existiert, werden die Größen- und Breitenparameter
übernommen:
$this->im = imagecreate($this->intWidth, $this->intHeight);
Alle folgenden Funktionen beziehen sich dann auf das Handle in der Eigenschaft
$this->im. Stimmen Hintergrundbild und verlangte Bildgröße nicht überein, wird
das Hintergrundbild auf die erforderliche Größe skaliert. Dazu wird folgende
Funktion verwendet:
imagecopyresampled($bi, $this->im, 0, 0, 0, 0,
imagesx($bi), imagesy($bi),
imagesx($this->im), imagesy($this->im));
Die Basis für die Platzierung des Textes ist die Berechnung der erforderlichen
Größe:
$arr = imagettfbbox($this->strFontSize, 0, $this->strFontFace,
$this->strText);
393

394
Professionelle Programmierung
Je nach Ausrichtung wird dann der Startpunkt basierend auf den von imagettfbox
zurückgegebenen Werten berechnet. Für zentrierte Texte beispielsweise wird ausgehend
von den Mittelpunkten die Verschiebung nach folgender Formel ermittelt:
$this->dx = ($this->intWidth / 2) - ($arr[2] / 2);
Für den Rand erfolgt die Generierung von Rechtecken, die dem Bild überlagert
werden. Die folgende Funktion erledigt dies auch für Randbreiten > 1, wenn der
Aufruf in einer Schleife erfolgt und mit der Schleifenvariablen $i gesteuert wird:
imagerectangle($this->im, $i, $i,
$this->intWidth-$i-1,
$this->intHeight-$i-1,
$this->getColor($this->strBackColor));
Die Randfarbe wird von der Hintergrundfarbe bestimmt. Der Einsatz ist vor allem
im Zusammenhang mit Hintergrundbildern sinnvoll.
Beispielaufruf
Das folgende Skript enthält ein IMG-Tag, das einen passenden Aufruf enthält:
Listing 9.6: gd2libTest.php – Test der Bibliothek aus einer HTML-Datei heraus
Beachten Sie hier, dass der Text gegebenenfalls URL-kodiert werden muss. Die
Bibliothek sorgt für die entsprechende Dekodierung.
Abbildung 9.7:
Banner, der mit
der Bibliothek
erzeugt wurde.
Der Text kann als
Parameter ausgetauscht
werden.

9.3 Code röntgen: Die Reflection-API
Code röntgen: Die Reflection-API
PHP5 verfügt über eine Programmierschnittstelle, die die Analyse von Code
erlaubt. Dies ist sinnvoll, um aus anderen Programmen heraus die Eigenschaften
und den Aufbau von Klassen und Bibliotheken zu ermitteln. Hilfreich können
diese Techniken zum einen für die Entwickler von Editoren sein, zum anderen
aber auch für Bibliotheksprogrammierer, die flexibel auf veränderte Bedingungen
reagieren möchten und damit weniger Probleme mit Updates, Versionen und
Varianten haben. Ein dritter und sehr wichtiger Komplex ist die Entwicklung von
automatischen Code-Dokumentierern. Dies sind Programme, die Code analysieren
und daraus Quelltextdokumentationen erstellen.
Die Reflection-API als Objektmodell
Der Zugriff auf die Reflection-Informationen erfolgt über ein Objektmodell, das
folgenden Aufbau hat:
Das Prinzip ist einfach. Um Informationen über alle Funktionen eines Skripts
herauszufinden, wird eine Instanz der Klasse ReflectionFunction erzeugt und
benutzt. Die Basisklasse Reflection stellt Hilfsfunktionen zur Verfügung, um die
ermittelten Daten auslesen zu können.
Listing 9.7: ReflectionBase.php – Die Struktur der internen Klasse Exception ermitteln
395

396
Professionelle Programmierung
Diese Zeile erzeugt folgende Ausgabe:
Abbildung 9.8:
Ausgabe der Reflection-
Abfrage einer Klasse
Praktisch ist die Ausgabe eine Kopie der Definition, wobei alle theoretisch möglichen
Mitglieder des abgefragten Objekts – hier also einer Klasse – angezeigt wer-

Code röntgen: Die Reflection-API
den. Die gezeigte Klasse hat also keine Konstanten, keine statische Eigenschaften,
keine statische Methoden, sechs normale Eigenschaften und neun Methoden.
Die Reflection-Klassen im Detail
Der folgende Abschnitt zeigt die zur Verfügung stehenden Klassen, deren Definition
und einfache Anwendungsbeispiele.
Informationen über Funktionen ermitteln
Mit ReflectionFunction werden Funktionen analysiert. Die folgende Tabelle zeigt
die zur Verfügung stehenden Methoden, die jeweils konkrete Informationen über
die Funktion zurückgeben.
Methode Bedeutung
__construct(string name) Konstruktor, erwartet den Namen einer Funktion
string getName() Gibt den Namen der Funktion zurück
bool isInternal() Wahr, wenn dies eine eingebaute Funktion ist
bool isUserDefined() Wahr, wenn dies eine benutzerdefinierte Funktion ist
string getFileName() Den Namen der Datei, wo diese Methode definiert ist
int getStartLine() Den Namen der Zeile, wo die Definition beginnt
int getEndLine() Den Namen der Zeile, wo die Definition endet
string getDocComment() Kommentare, die die Funktion dokumentieren
array getStaticVariables() Array der statischen Variablen
mixed invoke(mixed* args) Führt die Funktion mit bestimmten Argumenten aus
string toString() Zeichenkettendarstellung der Funktion
bool returnsReference() Wahr, wenn der Rückgabewert eine Referenz ist
Reflection_Parameter[]
getParameters()
Die Parameter der Funktion
Tabelle 9.4: Methoden der Klasse ReflectionFunction
397

398
Professionelle Programmierung
Um eine Funktion zu untersuchen, muss natürlich erst ein Objekt der Klasse
erzeugt werden.
Informationen über Parameter ermitteln
Da Funktionen oft Parameter haben, besteht ein enger Zusammenhang zwischen
ReflectionFunction und ReflectionParameter. Das folgende Beispiel zeigt beide
Klassen in der Anwendung:
Listing 9.8: ReflectionFunction.php – Analyse einer Funktion mit Parametern
/**
* Eine einfache Zählfunktion
*
* @return int
*/
function counter($debug, $multiplier = 6)
{
static $c = 1;
echo $debug;
return $c++ * $multiplier;
}
$func= new ReflectionFunction('counter');
printf(
"===> Die %s Function'%s'\n".
" deklariert in %s\n".
" von Zeile %d bis %d\n",
$func->isInternal() ? 'interne' : 'benutzerdefinierte',
$func->getName(),
$func->getFileName(),
$func->getStartLine(),
$func->getEndline()
);
printf("---> Dokumentation:\n %s\n",
var_export($func->getDocComment(), 1));
if ($statics = $func->getStaticVariables())
{
printf("---> Statische Variablen: %s\n",
var_export($statics, 1));
}
foreach ($func->getParameters() as $name => $param)

Code röntgen: Die Reflection-API
{
printf("Parameter '%s' %s [%s]\n",
$name,
$param->getName(),
$param->isPassedByReference() ? '&' : '');
}
printf("\n\n---> Aufrufergebnisse: ");
var_dump($func->invoke(array('Test', 2)));
»Reflektiert« wird hier die Funktion counter. Das Ergebnis zeigt alle erforderlichen
Details, um die Funktion zu verstehen:
Vor allem Programme, die Dokumentationen automatisch erstellen, können
davon erheblich profitieren.
Daten einer Klasse ermitteln
Mit Hilfe der Klasse ReflectionClass lassen sich andere Klassen – eingebaute oder
eigene – analysieren. Das folgende Skript versucht diese Analyse möglichst umfassend.
Es verwendet einige der bereitgestellten Methoden:
Listing 9.9: ReflectClass.php – Ermittlung von Daten einer Klasse
interface Serializable
{ // ...
}
class Object
Abbildung 9.9:
Ergebnis der Analyse einer benutzerdefinierten
Funktion
399

400
Professionelle Programmierung
{ // ...
}
class Counter extends Object implements Serializable
{
const START= 0;
private static $c= Counter::START;
public function count()
{
return self::$c++;
}
public static function ReflectMe($config)
{
$class = new Reflection_Class($config);
printf(
"===> Die %s%s%s %s '%s' [extends %s]\n".
" deklariert in %s\n".
" von Zeile %d bis %d\n".
" mit dem Modifikatoren %d [%s]\n",
$class->isInternal() ? 'interne' : 'benutzerdefinierte',
$class->isAbstract() ? ' abstrakte' : '',
$class->isFinal() ? ' finale' : '',
$class->isInterface() ? 'Schnittstelle' : 'Klasse',
$class->getName(),
var_export($class->getParentClass(), 1),
$class->getFileName(),
$class->getStartLine(),
$class->getEndline(),
$class->getModifiers(),
implode(' ',
Reflection::getModifierNames($class->getModifiers()))
);
printf("---> Dokumentation:\n %s\n",
var_export($class->getDocComment(), 1));
printf("---> Implementiert:\n %s\n",
var_export($class->getInterfaces(), 1));
printf("---> Konstanten: %s\n",
var_export($class->getConstants(), 1));
printf("---> Eigenschaften: %s\n",
var_export($class->getProperties(), 1));
printf("---> Methoden: %s\n",
var_export($class->getMethods(), 1));

}
if ($class->isInstantiable())
{
$counter = $class->newInstance();
echo '---> $counter ist Instanz? ';
var_dump($class->isInstance($counter));
echo '---> new Object() ist Instanz? ';
var_dump($class->isInstance(new Object()));
}
Code röntgen: Die Reflection-API
}
Counter::ReflectMe('Counter');
Die Funktion newInstance kann mit einer variablen Anzahl von Argumenten aufgerufen
werden, die durch den Konstruktor der analysierten Klasse bestimmt werden.
Es wird eine Warnung ausgegeben, wenn die Instanziierung nicht korrekt
erfolgt.
Folgende Sequenz ermittelt, ob ein Objekt eine Instanz einer bestimmten Klasse
ist:
$class= new Reflection_Class('Foo');
$class->isInstance($arg)
Diese Information kann auch folgendermaßen gewonnen werden:
if ($arg instanceof Foo)
Information über Methoden einer Klassen ermitteln
Die Informationen über eine Klasse enthalten bereits die Namen der Methoden.
Das folgende Beispiel zeigt die Anwendung:
Listing 9.10: ReflectMethod.php – Daten über eine Methode ermitteln
class Counter
{
private static $c= 0;
/**
* Zähler erhöhen
*
* @final
* @static
* @access public
* @return int
401

402
Professionelle Programmierung
*/
final public static function increment()
{
self::$c++;
return self::$c;
}
}
// Create an instance of the Reflection_Method class
$method= new ReflectionMethod('Counter', 'increment');
// Print out basic information
Abbildung 9.10:
Informationen über eine Klasse und
deren Mitglieder

Code röntgen: Die Reflection-API
printf(
"===> Die %s%s%s%s%s%s%s Methode '%s' (welche %s ist)\n".
" Deklariert in %s\n".
" von Zeile %d bis %d\n".
" hat die Modifikatoren %d[%s]\n",
$method->isInternal() ? 'interne' : 'benutzerdefinierte',
$method->isAbstract() ? ' abstrakte' : '',
$method->isFinal() ? ' finale' : '',
$method->isPublic() ? ' öffentliche' : '',
$method->isPrivate() ? ' private' : '',
$method->isProtected() ? ' geschützte' : '',
$method->isStatic() ? ' statische' : '',
$method->getName(),
$method->isConstructor() ? 'ein Konstruktor'
: 'eine reguläre Methode',
$method->getFileName(),
$method->getStartLine(),
$method->getEndline(),
$method->getModifiers(),
implode(' ',
Reflection::getModifierNames($method->getModifiers())));
printf("---> Dokumentation:\n %s\n", var_export($method->getDocComment(),
1));
if ($statics= $method->getStaticVariables())
{
printf("---> Statische Variables: %s\n", var_export($statics, 1));
}
printf("---> Aufrufergebnisse: ");
var_dump($method->invoke(NULL));
Das Aufrufen einer privaten oder geschützten (protected) Methode führt auch
über Reflektion zu einem Fehler. Das ist durchaus unverständlich, weil ein derartiger
Schutz vor allem ungewollte Zugriffen verhindert. Der explizite Einsatz einer
Reflektionstechnik benötigt jedoch einen derartigen Schutz nicht. Der Zugriff auf
Methoden verlangt als erstes Argument eine Instanz der Klasse. Bei statischen Aufrufen
gibt es diese Instanz nicht, deshalb wird hier der Wert NULL angegeben.
Klassen haben neben Methoden meist auch Eigenschaften. Neben der einfachen
Liste, die bereits die Reflektion der Klasse erbrachte, können auch Detaildaten
ermittelt werden. Das folgende Beispiel zeigt, wie mit ReflectionProperty gearbeitet
wird.
403

404
Professionelle Programmierung
Abbildung 9.11:
Informationen über eine Methode
Listing 9.11: ReflectMethodProps.php – Eigenschaften einer Klasse
class PropTest
{
public $number = 5;
}
$prop= new ReflectionProperty('PropTest', 'number');
printf(
"===> Die %s%s%s%s Eigenschaft '%s'
(welche %s deklariert wurde)\n".
" hat die folgenden Modifizierer %s\n",
$prop->isPublic() ? ' öffentlich' : '',
$prop->isPrivate() ? ' privat' : '',
$prop->isProtected() ? ' geschüttz' : '',
$prop->isStatic() ? ' statisch' : '',
$prop->getName(),
$prop->isDefault() ? 'zur Kompilierzeit' : 'zur Laufzeit',
var_export(Reflection::getModifierNames(
$prop>getModifiers()),
1)
);
$obj= new PropTest();
print("---> Der Wert ist: ");
var_dump($prop->getValue($obj));
$prop->setValue($obj, 10);
print("---> Setze den Wert 10, der Wert ist jetzt: ");
var_dump($prop->getValue($obj));
var_dump($obj);
Das Aufrufen einer privaten oder geschützten (protected) Methode führt auch
über Reflektion zu einem Fehler.

Daten über PHP-Erweiterungen ermitteln
Code röntgen: Die Reflection-API
Mit ReflectionExtension lassen sich Informationen über Erweiterungen ermitteln.
Das ist manchmal hilfreich, um die Kompatibilität eines Skripts zu sichern
oder die Konfiguration eines entfernten Computers, beispielsweise beim Provider,
zu untersuchen.
Zuerst müssen alle vorhandenen Erweiterungen ermittelt werden, was mit dem folgenden
Beispiel demonstriert wird.
Listing 9.12: ReflectGetExtension.php – Eine Erweiterung untersuchen
$aExtensions = get_loaded_extensions();
foreach ($aExtensions as $num => $name)
{
echo "$num. $name ";
}
Hat man einmal die Namen, kann eine weitere Untersuchung mit Reflection-
Extension erfolgen.
Die einzelnen Daten können sehr umfangreich werden; die im folgenden Beispiel
gezeigte umfassende Darstellung einer Erweiterung dient mehr der Demonstration
der Möglichkeiten. In der Praxis dürfte die gezielte Abfrage einer bestimmten
Teilinformation sinnvoller sein. Um konkret festzustellen, ob eine Erweiterung
vorhanden ist, wird am besten in_array eingesetzt und dann die Ausgabe gestartet:
Listing 9.13: ReflectGetExtensionDetails.php – Details von PHP-Erweiterungen ermitteln
$aExtensions = get_loaded_extensions();
if (in_array('SQLite', $aExtensions))
{
echo "Erweiterung 'sqlite' existiert";
$ext= new ReflectionExtension('sqlite');
Abbildung 9.12:
Aufruf einer Methode über Reflection
405

}
406
Professionelle Programmierung
Abbildung 9.13:
Liste der geladenen Erweiterungen
einer typischen PHP-Installation
printf(
"Name : %s\n".
"Version : %s\n".
"Funktionen : [%d] %s\n".
"Konstanten : [%d] %s\n".
"INI-Einträge : [%d] %s\n",
$ext->getName(),
$ext->getVersion() ? $ext->getVersion() : 'NO_VERSION',
sizeof($ext->getFunctions()),
var_export($ext->getFunctions(), 1),
sizeof($ext->getConstants()),
var_export($ext->getConstants(), 1),
sizeof($ext->getINIEntries()),
var_export($ext->getINIEntries(), 1)
);
Die Ausgabe zeigt die Klassen der Erweiterung. Mit den bereits vorgestellten Techniken
der Reflektion kann man so schnell alle Details ermitteln und damit Editoren
oder Debugger steuern, Code robuster gestalten oder einfach nur lernen.
Damit stehen alle wichtigen Techniken zur Verfügung, Code per Skript zu analysieren,
zu dokumentieren und fremde Bibliotheken im Kontext korrekt zu verarbeiten.

9.4 Funktions-Referenz GD2
Funktion Bedeutung
Funktions-Referenz GD2
exif_imagetype Ermittelt Daten über ein vorhandenes Bild.
Abbildung 9.14:
Ausschnitt aus der
Beschreibung
einer einzigen
Extension
(SQLite)
exif_read_data Liest eingebettet EXIF-Daten aus einer JPG- oder TIF-
Datei. Solche Daten werden beispielsweise von Digitalkameras
erzeugt.
exif_thumbnail Extrahiert in JPG- oder TIF-Dateien eingebettete Thumbnail
* -Dateien.
gd_info Beschafft Informationen über die Bibliothek selbst.
Tabelle 9.5: Funktions-Referenz für GD2-Funktionen
* Verkleinertes Abbild der Hauptdatei.
407

408
Professionelle Programmierung
Funktion Bedeutung
getimagesize Ermittelt die Ausmaße einer GIF-, JPEG-, PNG- oder
SWF-Grafik-Datei.
image_type_to_mime_type Ermittelt die MIME-Typen für getimagesize,
exif_read_data, exif_thumbnail, exif_imagetype.
image2wbmp Gibt das Bild im BMP-Format an den Browser aus.
imagealphablending Setzt den Modus für Alpha-Blending.
imageantialias Schaltet das Antialiasing ein oder aus.
imagearc Zeichnet eine Teil-Ellipse.
imagechar Stellt ein Zeichen mit horizontaler Ausrichtung dar.
imagecharup Zeichnet einen vertikal ausgerichteten Charakter.
imagecolorallocate Bestimmt die Farbe einer Grafik.
imagecolorallocatealpha Bestimmt die Farbe unter Verwendung eines Alpha-
Werts.
imagecolorat Ermittelt den Farbwert eines Bildpunktes.
imagecolorclosest Ermittelt den Farbwert-Index, der den angegebenen
Farben am nächsten liegt.
imagecolorclosestalpha Gibt den Index der Farbe in der Farbtabelle, die dem
angegebenen Wert am Nächsten liegt.
imagecolorclosesthwb Gibt den Index der Farbe in der Farbtabelle, die dem
angegebenen Wert am Nächsten liegt. Als Werte werden
Helligkeit, Sättigung und Kontrast verwendet.
imagecolordeallocate Löscht eine Farbdefinition.
imagecolorexact Ermittelt den Index-Wert der angegebenen Farbe.
imagecolorexactalpha Index einer Farbe.
imagecolormatch Versucht die Werte der Farbtabelle in Übereinstimmung
mit den tatsächlichen Farben zu bringen.
Tabelle 9.5: Funktions-Referenz für GD2-Funktionen (Forts.)

Funktion Bedeutung
Funktions-Referenz GD2
imagecolorresolve Ermittelt den Index-Wert der angegebenen Farbe oder
die nächstmögliche Alternative dazu.
imagecolorresolvealpha Ermittelt den Index einer Farbe oder – wenn die Farbe
nicht existiert – die bestmögliche Entsprechung.
imagecolorset Setzt die Farbe für den angegebenen Paletten-Index.
imagecolorsforindex Ermittelt die Farbwerte einer angegebenen Farb-Palette.
imagecolorstotal Ermittelt die Anzahl der definierten Farben eines Bildes.
imagecolortransparent Definiert eine Farbe als transparent
imagecopy Kopiert einen Bildausschnitt
imagecopymerge Kopiert einen Bildausschnitt und verbindet mit einem
anderen.
imagecopymergegray Kopiert einen Bildausschnitt und verbindet mit einem
anderen mit Graustufen.
imagecopyresampled Kopiert einen Bildausschnitt und verbindet mit einem
anderen mit erneuter Kompression.
imagecopyresized Kopiert einen Bildausschnitt und verbindet mit einem
anderen mit Größenänderung.
imagecreate Erzeugt ein neues Bild.
imagecreatefromgd2 Erzeugt ein neues Bild aus GD2-Rohdaten.
imagecreatefromgd2part Erzeugt ein neues Bild aus GD2-Rohdaten und Fragmenten
eines Bilds.
imagecreatefromgd Erzeugt ein neues Bild aus GD-Rohdaten.
imagecreatefromgif Erzeugt ein neues Bild aus GIF-Daten.
imagecreatefromjpeg Erzeugt ein neues Bild aus JPG-Daten.
imagecreatefrompng Erzeugt ein neues Bild aus PNG-Daten.
imagecreatefromstring Erzeugt ein neues Bild aus einem Stream.
Tabelle 9.5: Funktions-Referenz für GD2-Funktionen (Forts.)
409

410
Professionelle Programmierung
Funktion Bedeutung
imagecreatefromwbmp Erzeugt ein neues Bild aus WBMP-Daten.
imagecreatefromxbm Erzeugt ein neues Bild aus XBM-Daten.
imagecreatefromxpm Erzeugt ein neues Bild aus XPM-Daten.
imagecreatetruecolor Erzeugt ein neues Bild mit voller Farbunterstützung.
imagedashedline Zeichnen einer gestrichelten Linie.
imagedestroy Löscht ein Bild.
imageellipse Zeichnete eine Ellipse oder einen Kreis.
imagefill Füllen mit Farbe (»flood fill«).
imagefilledarc Zeichnet einen gefüllten elliptischen Kreisbogen.
imagefilledellipse Zeichnet eine gefüllte Ellipse.
imagefilledpolygon Zeichnet ein gefülltes Vieleck (Polygon).
imagefilledrectangle Zeichnet ein gefülltes Rechteck.
imagefilltoborder Flächen-Farbfüllung (»flood fill«) mit einer angegebenen
Farbe bis zum nächsten Rand.
imagefontheight Ermittelt die Font-Höhe.
imagefontwidth Ermittelt die Font-Breite.
imageftbbox Ergibt Daten über die Fläche, die ein TrueType-Text in
Anspruch nimmt.
imagefttext Schreibt Text in das Bild.
imagegammacorrect Anwendung einer Gamma-Korrektur auf ein GD-Bild.
imagegd2 Ausgabe im internen GD2-Format.
imagegd Ausgabe im internen GD-Format.
imagegif Ausgabe eines Bildes an den Browser oder in eine Datei .
Tabelle 9.5: Funktions-Referenz für GD2-Funktionen (Forts.)

Funktion Bedeutung
Funktions-Referenz GD2
imageinterlace Schaltet die Interlaced-Darstellung eines Bildes an oder
aus.
imageistruecolor Ermittelt, ob das Bild Vollfarbunterstützung hat.
imagejpeg Ausgabe des Bildes im Browser oder als Datei als JPG.
imagelayereffect Setzt Alpha-Blending mit Layer-Effekten.
imageline Zeichnen einer Linie.
imageloadfont Lädt einen neuen Font.
imagepalettecopy Kopiert eine Farbpalette.
imagepng Ausgabe des Bildes im Browser oder als Datei als PNG.
imagepolygon Zeichnen eines Vielecks (Polygons).
imagepsbbox Ermittelt die Ausmaße des Rechtecks, das für die Ausgabe
eines Textes unter Verwendung eines PostScript-Fonts
(Typ 1) notwendig ist.
imagepscopyfont Erstellt eine Kopie eines bereits geladenen Fonts für weitere
Veränderungen.
imagepsencodefont Ändert die Vektor-Beschreibung eines Fonts.
imagepsextendfont Vergrößert oder komprimiert einen Font.
imagepsfreefont Gibt den durch einen Typ 1 PostScript-Font belegten
Speicher wieder frei.
imagepsloadfont Lädt einen Typ 1 PostScript-Font aus einer Datei.
imagepsslantfont Setzt einen Font schräg.
imagepstext Ausgabe eines Textes auf einem Bild unter Verwendung
von Typ 1 PostScript-Fonts.
imagerectangle Zeichnet ein Rechteck.
imagerotate Rotiert ein Bild um einen Winkel.
imagesavealpha Speichert Alpha-Kanal-Informationen.
Tabelle 9.5: Funktions-Referenz für GD2-Funktionen (Forts.)
411

412
Professionelle Programmierung
Funktion Bedeutung
imagesetbrush Setzt ein Bild, das als Füllung für Linien dient.
imagesetpixel Setzt ein einzelnes Pixel.
imagesetstyle Setzt einen Stil für Linien.
imagesetthickness Setzt die Breite für Linien und andere Figuren.
imagesettile Setzt ein kachelbares Bild für Füllungen.
imagestring Zeichnet eine horizontalen Zeichenfolge.
imagestringup Zeichnet eine vertikale Zeichenfolge.
imagesx Ermittelt die Bild-Breite.
imagesy Ermittelt die Bild-Höhe.
imagetruecolortopalette Konvertiert eine Vollfarbpalette in ein Palettenbild.
imagettfbbox Ermittelt die Rahmenmaße für die Ausgabe eines Textes
im TrueType-Format.
imagettftext Erzeugt TTF-Text im Bild.
imagetypes Gibt die von der aktuell verwendeten PHP-Version unterstützten
Grafik-Formate zurück.
imagewbmp Gibt das Bild im WBMP-Format aus.
iptcembed Bettet binäre IPTC-Informationen ins Bild ein.
iptcparse Holt binäre IPTC-Informationen aus einem Bild ein.
Informationen zu IPTC sind unter http://www.iptc.org/ zu
finden.
jpeg2wbmp Konvertiert JPEG nach WBMP.
png2wbmp Konvertiert PNG nach WBMP.
read_exif_data Liest die EXIF Header-Infos einer JPEG-Grafik
Tabelle 9.5: Funktions-Referenz für GD2-Funktionen (Forts.)

9.5 Kontrollfragen
Kontrollfragen
1. Welche Servervariable wird benutzt, um die bevorzugte Sprache des Benutzers zu
ermitteln?
2. Welcher Header wird in HTTP benötigt, um dem Browser anzuzeigen, dass ein
Bild gesendet wird?
3. Schreiben Sie ein Skript, dass dezimale Farbangaben wie 255, 192, 128 in hexadezimale
Zeichenfolgen der Art »#FFCC99« umrechnet und umgekehrt.
4. Wozu dient das Werkzeug Reflection?
413

Kommunikation per
HTTP, FTP und
E-Mail
10

416
Kommunikation per HTTP, FTP und E-Mail
10.1 Konzepte in PHP5
Bedingt durch die Vielzahl möglicher Datenquellen kommt der Server-Server-
Kommunikation immer stärkere Bedeutung zu. PHP5 stellt eine ganze Reihe von
Methoden zum Zugriff auf andere Server zur Verfügung, einiges davon ist völlig
neu. Damit ergeben sich spannende Möglichkeiten für die Nutzung von PHP5.
Einige Anregungen finden Sie hier:
Holen von News-Daten von einem anderen Server (HTTP)
Senden von Status-Informationen an einen anderen Server (HTTP)
Versenden von Formularinhalten per E-Mail (SMTP)
Aktualisierung von Inhalten auf einem Download-Server (FTP)
In Klammern finden Sie die jeweils bevorzugten Protokolle.
Prinzip der Streams und Wrapper
PHP5 nutzt ein einheitliches Konzept zur Organisation des Zugriffs auf Daten, so
genannte Wrapper. Dies sind protokollähnliche Bezeichner (im Englischen oft als
Moniker, Spitznamen, bezeichnet):
wrapper://dateiname
Ein Wrapper gilt als Standard: file://, diese Angabe kann entfallen. Das vereinfacht
den Zugriff auf lokalen Dateien, die besonders häufig benötigt werden. Wrapper
finden immer dann Anwendung, wenn Daten von einer Datenquelle geholt oder
in eine Datenquelle geschrieben werden. Das gilt beispielsweise für sämtliche
Dateifunktionen. Statt also für neue Zugriffsarten (per HTTP oder FTP) immer
neue Bibliotheken zu verwenden, bietet PHP5 einen vereinheitlichten Weg des
Zugriffs an. Damit die Verwaltung intern funktioniert, werden ergänzend so
genannte Streams eingesetzt. Diese bietet elementare Zugriffsfunktionen wie Öffnen,
Lesen, Schreiben, Schließen. Wenn man eigene Wrapper entwickeln will –
auch dies ist Teil des universellen Konzepts – programmiert man praktisch diese
Stream-Funktion für einen spezifischen Fall.

Die eingebauten Wrapper
Konzepte in PHP5
PHP5 kommt mit einigen eingebauten Wrappern daher, die für die meisten Zwecke
ausreichend sind. Konkret sind dies:
file:///
Die Angabe file:// kann entfallen, sodass normale Pfadangaben weiterhin nutzbar
sind. Als mögliche Varianten sind relative Pfade (/pfad/name.ext), absolute
Pfade (D:\pfad\name.ext oder /pfad/pfad/datei.ext) oder Netzwerkshares (\\server\freigabe\name)
erlaubt. Wenn die Angabe mit file:// erfolgt und unter Windows
Laufwerkbuchstaben adressiert werden, sind dies mit | abzutrennen.
http://, https://
Um auf andere Webserver zuzugreifen, werden diese Wrapper benutzt. https://
baut eine verschlüsselte Verbindung auf. Der URL wird in der übliche Form
angegeben. Um Name und Kennwort für eine geschützte Verbindung anzugeben,
wird die Form http://:@ benutzt.
ftp://, ftps://
Um auf andere Server per FTP zuzugreifen, werden diese Wrapper benutzt.
ftps:// baut eine verschlüsselte Verbindung auf. Um Name und Kennwort für
eine geschützte Verbindung anzugeben, wird die Form ftp://:@
benutzt.
php://
Um auf die internen Ein- und Ausgabekanäle des Betriebssystems zuzugreifen,
bietet PHP einen speziellen Wrapper an. Zulässige Kanalnamen sind »stdin«
(Eingabe, beispielsweise Tastaturabfragen am Systemprompt), »stdout« (Ausgabe),
»stderr« (Fehlerausgaben), »output« (Ausgabepuffer, der von echo, print
usw. verwendet wird), »input« (Rohdaten aus einem Formular bei POST-
Anforderungen und »filter« (benutzerspezifische oder eingebaute Filter, die
Daten während der Übertragung verändern).
compress.zlib://, compress.bzip2://
Komprimiert oder dekomprimiert die Daten während der Übertragung nach
dem ZIP-Verfahren. Beim Schreiben in eine Datei entstehen GZ-Dateien,
keine Archive.
417

Filter
418
Kommunikation per HTTP, FTP und E-Mail
Filter werden im Stream eingebunden, um – für den Aufrufer transparent – Daten
während der Übertragung zu ändern. Der Vorteil liegt in der Anwendung. Der
Benutzer eines Filters arbeitet weiter wie gewohnt mit Standardfunktionen wie
fopen und fread. Dabei gibt er lediglich an, einen bestimmten Filter benutzen zu
wollen. Wie dieser funktioniert, eingebunden wird und wie dieser konkret mit den
Daten interagiert, bleibt völlig im Hintergrund. Eingebaute Filter können folgende
Aktionen ausführen (zuvor der Name des Filters):
string.rot13
Eine ROT13-Kodierung, bei der die Buchstaben um 13 Stellen im Alphabet
verschoben werden, um eine sehr schwache Verschlüsselung zu erreichen.
string.toupper
Verwandelt alle Zeichen in Großbuchstaben.
string.tolower
Verwandelt alle Zeichen in Kleinbuchstaben.
string.strip_tags
Entfernt alle Tags aus dem Datenstrom.
convert.base64-encode
Konvertiert die Daten in das Base64-Format.
convert.base64-decode
Konvertiert die Base64-Daten aus dem Base64-Format in eine lesbare Form.
convert.quoted-printable-encode
Konvertiert die Daten in das Quoted-Printable-Format (in E-Mails benutzt).
convert.quoted-printable-decode
Konvertiert die Quoted-Printable-Daten aus dem Quoted-Printable-Format in
eine lesbare Form.
Damit die Filter wirklich universell sind, kann man auch bei der Angabe von
php://filter wiederum Pfade angeben, die ihrerseits die Wrapper http:// oder ftp://
verwenden.

10.2 Streams und Wrapper anwenden
Streams und Wrapper anwenden
Die Anwendung der Wrapper ist relativ einfach. Eigentlich müssen Sie lediglich
mit den Dateifunktionen umgehen können, die bereits ausführlich vorgestellt
wurden.
Daten von einer fremden Website beschaffen
Das folgende Skript holt sich Daten von einer fremden Website. Es liest die Daten
ein und ermittelt die Inhalte bestimmter META-Tags, wenn diese vorhanden sind.
Das klingt weitaus aufregender, als es ist:
Listing 10.1: wrapperhttp.php – Zugriff mit Standardfunktionen auf Webserver
Der eigentliche Aufwand – also das Herstellen der Verbindung – erledigt der Wrapper.
Die Filterung und Ausgabe derw META-Tags erfolgt mit Hilfe der Funktion
get_meta_tags. Die Anwendung unterscheidet sich nicht von der beim Lesen normaler
Dateien. Allerdings kann die Ausführzeit des Skripts etwas länger sein, da
einige Zeit für den Verbindungsaufbau und die Übertragung der Seite benötigt wird.
Abbildung 10.1:
Ausgabe der META-Tags der
Website www.apache.org
Sie sollten außerdem auf eine Fehlerbehandlung achten, da Internet-
Verbindungen aus den verschiedensten Gründen fehlschlagen können.
419

420
Kommunikation per HTTP, FTP und E-Mail
Das folgende Skript liest den Inhalt einer Webseite direkt ein und speichert die
Seite (ohne Bilder oder andere Ressourcen) lokal ab:
Listing 10.2: wrapperhttppage.php – Zugriff mit Dateifunktionen
Auch hier wird lediglich eine Standardfunktion, file_get_contents, benutzt. Zur
Kontrolle wird noch die Dateigröße angezeigt. Zum Testzeitpunkt waren dies
stolze 12 KByte.
Daten komprimiert speichern
Weitaus kompakter geht es, wenn man die Daten komprimiert speichern kann.
Das folgende Beispiel verwendet einen weiteren Wrapper beim Speichern der
Datei, der das erledigt:
Listing 10.3: wrapperhttpcompress.php – Abspeichern einer Datei in komprimierter
Form

Streams und Wrapper anwenden
Das Ergebnis unterscheidet sich vor allem im Platzverbrauch von der vorherigen
Version. Die Startseite der Apache Group belegt nun nur noch 3,6 KByte. Eine
verbesserte Version liest die Datei wieder aus und zeigt sie zeilenweise an. Dabei
wird wiederum ein Wrapper benutzt, der auf die abgespeicherte Version zugreift.
Listing 10.4: wrappedecompress.php – Komprimierte Datei erzeugen und dekomprimieren
Hier wird eine weitere Dateifunktion, file, benutzt und diesmal reagiert derselbe
Wrapper in genau umgekehrter Weise. Da die Daten gelesen werden, erwartet er
komprimierte Daten und diese werden folgerichtig wiederhergestellt. Der eigentliche
Vorgang des Komprimierens und Dekomprimierens ist für den Anwender
transparent – man muss weder bei der Benutzung noch bei der Wahl der Funktionen
darauf Rücksicht nehmen.
Damit ist zum Thema Wrapper eigentlich schon fast alles gesagt. Der Fantasie
sind beim Anwenden kaum Grenzen gesetzt. Vor allem aber kann man komplizierte
Zugriffe mit den Socket-Funktionen meist vermeiden.
421

422
Kommunikation per HTTP, FTP und E-Mail
10.3 Filter verwenden
Das folgende Skript holt sich wie bereits beim vorhergehenden Beispiel Daten von
einer fremden Website. Es liest im Gegensatz dazu nur den Inhalt der Seite, also
ohne HTML-Tags. Dies kann beispielsweise für eine Indizierung sinnvoll sein.
Anstatt also die Ausgabe mit htmlspecialchars sichtbar zu machen, soll nun ein
Filter die Arbeit erledigen.
Wie bereits angedeutet, basieren Filter auf der Wrapper-Syntax und haben folgende
Struktur:
php://filter:/=
Aus den verfügbaren Filtern kann man nun wählen. string.strip_tags ist dabei von
der Funktion mit strip_tags vergleichbar, spart jedoch den expliziten Aufruf dieser
Funktion.
Listing 10.5: wrapperfilter.php – Filtern von Daten während des Lesevorgangs

}
?>
Filter verwenden
$file = "data/$url.gz";
$f = fopen("$file", 'w');
fwrite($f, $page);
fclose($f);
echo 'Dateigr&ouml;&szlig;e: ' . filesize($file) . ' Byte';
echo '';
$farray =
file("php://filter/read=string.strip_tags/resource=$file");
foreach($farray as $num => $content)
{
if (strlen(trim($content)) == 0) continue;
printf('%03d: %s', $num, $content);
}
Die einzige Ergänzung zu den vorhergehenden Beispielen besteht in der Angabe
des Filters:
file("php://filter/read=string.strip_tags/resource=$file")
Die Syntax wird transparent, wenn man das zuvor gezeigte Muster zu Rate zieht.
php://filter leitet die Sequenz ein. Danach folgen bis zu drei Aktionen, die entsprechende
Parameter verlangen:
resource=
Diese Angabe ist zwingend erforderlich. Nutzen Sie für die Angabe von
wieder die bereits bekannten Wrapper.
read
Geben Sie an, welche Filteraktion beim Lesen ausgeführt werden soll. Der
Abschnitt »Filter« auf Seite 418 zeigte die möglichen Filter bereits.
write
Geben Sie an, welche Filteraktion beim Schreiben ausgeführt werden soll.
Der Abschnitt »Filter« auf Seite 418 zeigte die möglichen Filter bereits.
Es bietet sich nun an, alle Möglichkeiten miteinander zu kombinieren, was tatsächlich
funktioniert.
Listing 10.6: wrapperfiltercompress.php – Filtern und Komprimieren in einem Schritt

424
Kommunikation per HTTP, FTP und E-Mail
if (strlen($page) > 0)
{
$file = "data/$url.gz";
$f = fopen("compress.zlib://$file", 'w');
fwrite($f, $page);
fclose($f);
echo 'Dateigr&ouml;&szlig;e: ' . filesize($file) . ' Byte';
echo '';
$farray = file("php://filter/read=string.strip_tags/
resource=compress.zlib://$file");
foreach($farray as $num => $content)
{
if (strlen(trim($content)) == 0) continue;
printf('%03d: %s', $num, $content);
}
}
?>
Der Aufruf des Filters sieht nun folgendermaßen aus:
php://filter/read=string.strip_tags/resource=compress.zlib://$file
Der Wrapper compress.zlib:// wurde in die resource-Aktion eingebaut. Die Ausgabe
zeigt die Wirkung des Filters und zugleich die erzeugte Dateigröße an:
Abbildung 10.3:
Komprimieren und Filtern in einem Schritt
Damit sind die eingebauten Anwendungen erschöpft. In der Praxis dürfte das für
die meisten Fälle ausreichen.

10.4 Die Stream-Funktionen
Die Stream-Funktionen
Generell kann man mit den Stream-Funktionen, auf denen Wrapper und Filter
basieren, sehr viel mehr anstellen. Sie sind aber recht komplex in der Anwendung.
Sie bieten einen generellen und vereinheitlichten Weg für den Umgang mit
Datenübertragungen.
Eigene Wrapper und Filter
Es gibt allerdings noch die Möglichkeit, eigene Wrapper und natürlich auch
eigene Filter zu schreiben. Diese tauchen dann unter eigenem Namen auf. Dies
ist jedoch ein deutlich größerer Aufwand und lohnt sich vermutlich nur für Bibliotheksentwickler.
Die Darstellung sprengt auch den Rahmen dieses Buches. Wenn
Sie eigene Versuche in dieser Richtung unternehmen möchten, müssen Sie für
einen eigenen Wrapper eine Klasse schreiben, die auf den Stream-Funktionen aufbaut,
also stream_open zum Öffnen, stream_read zum Lesen und stream_close
zum Schließen, um nur einige zu nennen. Diese Klasse wird dann mit
stream_register_wrapper in Verbindung mit einem eigenen Moniker registriert.
Auch eigene Filter lassen sich entwickeln. Dies funktioniert etwas anders. Hier
müssen Sie eine Klasse erstellen, die von php_user_filter erbt. Dort ist dann die
Methode filter zu schreiben. Mit Hilfe der bereits für Wrapper benutzten Stream-
Funktionen erfolgt dann der Zugriff auf den Datenstrom, der beim Durchlaufen
der filter-Methode verändert werden kann.
Anwendung spezifischer Stream-Funktionen
Zusätzlich zu den vorgestellten Techniken gibt es hier noch den Begriff des
Stream-Kontexts. Dies sind Parametersammlungen, die einer Stream-verarbeitenden
Instanz übergeben werden, um das Verhalten global zu beeinflussen.
Beim Zugriff mittels http:// (als Beispiel) werden Sie sicher schnell bemerken, dass
sich bestimmte Seiten nicht ohne weiteres benutzen lassen. Möglicherweise fehlen
einige Kopfzeilen der HTTP-Anforderung, wie beispielsweise die akzeptierte
Sprache.
Die meisten Dateifunktionen erlauben es, einen so genannten Kontext-Parameter
anzugeben.
425

426
Kommunikation per HTTP, FTP und E-Mail
Listing 10.7: streamcontext.php – Parameter für Wrapper
Das Skript übermittelt an den Wrapper http zwei Informationen: Die Methode für
den Abruf ist GET (dies ist auch die Standardmethode) und die akzeptierte
Sprache. Im Beispiel wird die Startseite von Google abgerufen. Nutzt man
www.google.com (nicht »de«), versucht Google die Sprache dem Parameter Acceptlanguage
zu entnehmen und schaltet auf die entsprechende Landesversion um.
Damit lassen sich Webseiten recht komfortabel steuern und nutzen.
Beachten Sie jedoch unbedingt die Urheberrechte und täuschen Sie
niemals fremde Inhalt vor. Vereinbaren Sie besser Kooperationen mit
den Anbietern der Datenquellen und profitieren Sie so von den unbegrenzten
Möglichkeiten des Webs.
10.5 E-Mail versenden
Abbildung 10.4:
Google auf
Deutsch – Statt
per Browser über
einen parametrisierten
Wrapper
aufgerufen
Das Versenden von E-Mail gehört zu den häufiger benötigten Aufgaben. Es dient
auf fast jeder Website dazu, die Nutzerkommunikation zu verbessern. PHP5 unter-

E-Mail versenden
stützt E-Mail auf vielfältige Weise, angefangen von der einfachen mail-Funktion,
über Socket-Programmierung für die Kommunikation per POP3 bis hin zu ganzen
Bibliotheken für IMAP-Postfächer.
Grundlagen
Auch wenn das einfache Versenden von E-Mail verhältnismäßig leicht zu programmieren
ist, sollten Sie einige elementare Grundlagen beherrschen. Dies hilft,
bei größeren Projekten den richtigen Ansatz zu finden und schneller zu brauchbaren
Ergebnissen zu kommen. Bedenken Sie auch, dass eine Server-zu-Server-
Kommunikation immer auch fremde Maschinen beeinflusst. Dem sauberen Protokollfluss
kommt deshalb eine große Bedeutung zu.
Generell werden in der E-Mail-Kommunikation sowohl verschiedene Protokolle
als auch Kodierungsverfahren verwendet. Als Transportprotokolle kommen zum
Einsatz:
SMTP
SMTP (Simple Mail Transfer Protocol) dient der Weiterleitung von E-Mail von
einem Server zu einem anderen. Es dient auch dazu, die erstmalig auf einem
Client erzeugte E-Mail an den ersten Server der Übertragungskette weiterzuleiten.
POP3
POP3 (Post Office Protocol, Version 3) ruft E-Mail von einem Server ab, um
diese auf einem Client dem Benutzer zur Verfügung zu stellen.
IMAP4
IMAP4 (Internet Message Access Protocol, Version 4) ist ein Protokoll zum
Empfang von E-Mail (wie POP3) und zur Verwaltung der E-Mails eines
Clients auf einem Server. Das vollständige Herunterladen, wie bei POP3 erforderlich,
ist nicht notwendig.
Im Internet kommen praktisch nur SMTP und POP3 zum Einsatz. Clients wie
Outlook benutzen beide Protokolle, SMTP zum Senden und POP3 zum Empfangen.
Als Kodierungsverfahren stehen folgende zur Auswahl:
UUEncode
Der Name steht für Unix-to-Unix-Encode, ein Kodierverfahren aus der Unix-
Welt. Das Verfahren ist inzwischen relativ selten anzutreffen, war in der
427

428
Kommunikation per HTTP, FTP und E-Mail
Anfangszeit des Internet jedoch das am weitesten verbreitete. Viele Clients
beherrschen es heute noch.
Vorteile bietet es bei der Kodierung von binären Daten über Transportsysteme,
die nur 7-Bit-Zeichen verarbeiten können. Dateien werden um ca. 40% vergrößert.
PHP5 verfügt über Funktionen zur Kodierung und Dekodierung dieses Verfahrens.
Quoted Printable
Diese Verfahren wird häufiger benutzt. Es lässt den Text praktisch unverändert
und kodiert nur Sonderzeichen, beispielsweise wird das Leerzeichen zu =20.
Das Verfahren eignet sich nur für die Kodierung von Text, nicht für Binärdaten
für Anhänge.
PHP5 verfügt über Funktionen zur Kodierung und Dekodierung dieses Verfahrens.
Base64
Ein anderes Verfahren, dessen Schwerpunkt auf Dateianhängen liegt. Es
kodiert ebenfalls auf 7-Bit und vergrößert die Daten dabei um 37%. Es wird
heute am häufigsten eingesetzt, weil es das Standardverfahren für Anhänge ist,
die nach MIME (siehe unten) verpackt werden.
PHP5 verfügt über Funktionen zur Kodierung und Dekodierung dieses Verfahrens.
BinHex
Ein Verfahren aus der Apple-Welt, das sich außerhalb dieser nicht durchsetzen
konnte. Gute Clients sollten es beherrschen. Das Verfahren komprimiert,
sodass die ursprüngliche Größe trotz der Umsetzung auf 7-Bit oft unterschritten
wird.
PHP5 verfügt nicht über Funktionen zur Kodierung und Dekodierung dieses
Verfahrens.
MIME
Ein globaler Standard (Multipurpose Internet Mail Extensions), der nicht selbst
ein reines Kodierverfahren beschreibt, sondern eine vollständige Anweisung
zum Aufbau kompletter Nachrichten ist. Zur Kodieren von Binärdaten wird
das bereits erwähnt Base64 empfohlen. MIME beschreibt den Aufbau der
E-Mail einschließlich der Art der Verpackung von Text, Anhängen, Informationszeilen
(Kopfzeilen) usw.

Vorbereitung
E-Mail versenden
Wenn Sie auf einem Entwicklungssystem die E-Mail-Funktion ausprobieren wollen,
müssen Sie über einen SMTP-Server verfügen. Der SMTP-Server Ihres Internet-Providers
ist vermutlich nicht nutzbar, weil externe Zugriffe eine Autorisierung
verlangen, um den Missbrauch durch SPAM-Versender zu vermeiden. Dies ist mit
zusätzlichem Aufwand verbunden. Meist verlangen die SMTP-Server, dass unmittelbar
zuvor ein autorisierter POP3-Zugriff erfolgt.
Als Lösung können Sie lokal einen eigenen SMTP-Server betreiben. Hier gibt es
mehrere Varianten. Windows 2000 Professional, Server, Windows Server 2003 und
Windows XP Professional werden mit den Internet-Informationsdiensten geliefert,
die einen SMTP-Server enthalten. Der Server ist sehr einfach zu konfigurieren
und harmoniert bestens mit PHP. Die Windows 9X/Me- und XP Home-Varianten
sind leider außen vor. Hier muss man freie Programme bemühen, die es zuhauf
gibt. Linux kommt ebenfalls mit dem integrierten Sendmail-Programm. Hier ist
die Konfiguration etwas aufwändiger, außerdem erwartet PHP bei der Nutzung
von Sendmail, dass es selbst auf Linux läuft.
Steht der SMTP-Server, muss PHP noch ein wenig dafür konfiguriert werden.
Wenn Sie einen SMTP-Server für Windows benötigen, weil Sie mit XP
Home oder Windows 9x/Me arbeiten, schauen Sie sich den ArGoSoft
Mail Server an:
http://www.argosoft.com/applications/mailserver/
Läuft er lokal, ist als Name des SMTP-Servers localhost anzugeben.
Konfiguration für Windows
In der php.ini sind einige Parameter zu setzen:
SMTP = localhost
smtp_port = 25
Der erste, SMTP, bezeichnet die Adresse des SMTP-Server. Geben Sie den Netzwerknamen,
die IP-Adresse oder einen vollqualifizierten Domänennamen ein. Der
zweite, smtp_port, bezeichnet den Port, an dem der SMTP-Server läuft. 25 ist der
Standardport.
429

430
Kommunikation per HTTP, FTP und E-Mail
Dann ist noch die Absenderadresse zu setzen:
sendmail_from = webmaster@domain.net
Ohne diese Angabe wird die Funktion mail nicht arbeiten.
Konfiguration für Linux
Unter Linux erledigt nicht PHP in Kombination mit SMTP die Arbeit, sondern
alleine Sendmail. Damit entfallen die für Windows erforderlichen Konfigurationsschritte.
Dafür müssen Sie Sendmail konfigurieren, wozu der folgende Parameter
dient:
sendmail_path = -t –i
Welche Parameter hier nötig und möglich sind, ist der Dokumentation zu Sendmail
zu entnehmen. Sie hängen außerdem von der konkreten Installation ab.
Praktische Umsetzung
Das Versenden von E-Mail mit PHP ist sehr einfach. Voraussetzung ist allerdings
eine Installation, in der PHP einen SMTP-Server erreichen kann, wie zuvor
beschrieben. Wird beim Provider gehostet, ist dies in der Regel gewährleistet.
Einfache E-Mails versenden
Eine einfache E-Mail zu versenden basiert auf nur einer einzigen Funktion: mail.
Die Funktion kennt mehrere Parameter:
to
Eine Zeichenkette, die die Mail-Adresse angibt, an die gesendet werden soll.
Sie können mehrere Adressen angeben und durch Kommata trennen. Beachten
Sie aber, dass die Empfänger dann alle Adressen sehen können. Besser ist
es, Blind Carbon Copy zu verwenden (siehe unten).
subject
Eine Zeichenkette, die als Betreff benutzt wird.
message
Eine Zeichenkette, die die eigentliche Nachricht darstellt.

E-Mail versenden
header
Zusätzliche benutzerdefinierte Kopfzeilen, die das Verhalten der E-Mail
beeinflussen. Hier können Angaben zur Priorität, Cc (Carbon Copy), Bcc
(Blind Carbon Copy) usw. eingetragen werden. Die Kopfzeilen müssen im
Rohformat geschrieben werden. Die Angabe des Parameters ist optional.
parameters
Diese Option ist nur anwendbar, wenn PHP auf Linux läuft und zum Versenden
Sendmail. Geben Sie dann Parameter für Sendmail an. Es ist möglich, die
Verwendung dieser Option in der Datei php.ini zu sperren. Deshalb kann der
Einsatz bei einem Massenhoster nicht garantiert werden.
Die Funktion gibt einen Booleschen Wert zurück, der den Erfolg repräsentiert.
Außerdem wird eine Fehlermeldung angezeigt, wenn etwas schief läuft. Da Fehlermeldungen
meist stören und die E-Mail-Übertragung in der Praxis durchaus
ihre Tücken hat, ist ein Abfangen und Auswerten der Fehler unerlässlich. Das folgende
Skript zeigt, wie das aussieht:
Listing 10.8: sendmail.php – E-Mail versenden und auf mögliche Fehler reagieren

432
Kommunikation per HTTP, FTP und E-Mail
}
?>
Folgendes ist zu beachten. Wenn Sie mit Windows arbeiten und den Windows-
SMTP-Server verwenden, muss die Angabe »From:« in der Datei php.ini eingestellt
werden. Um dies zu vereinfachen, wird der Parameter im Skript dynamisch
gesetzt:
ini_set('sendmail_from', 'test@test.net');
Außerdem wird das Abfangen des Fehlers programmiert. Dazu ist zuerst die Fehlerverfolgung
in PHP5 einzuschalten:
ini_set('track_errors', 1);
Beim Senden wird der mail-Funktion ein @ zum Unterdrücken des Fehlers vorangestellt:
$success = @mail($to, $subject, $message, $from);
Die Variable $success enthält nun im Fehlerfall FALSE. Darauf kann entsprechend
reagiert werden. Trat ein Fehler auf, wird die interne Fehlervariable
$php_errormsg benutzt:
echo $php_errormsg;
Programmierung mit Kopfzeilen
Abbildung 10.5:
Fehlerausgabe des Programms:
Hier war der
Mail-Server falsch konfiguriert
Um weitere Verwendungsmöglichkeiten zu erkunden, müssen Sie sich mit den
Kopfzeilen beschäftigen. Diese werden als vierter Parameter in der folgenden
Form angegeben:
: \r\n
Dabei ist durch den Namen, beispielsweise »From« zu ersetzen und
durch die von dieser Kopfzeile verlangten Parameter:
From: test@absender.de\r\n
\r\n bezeichnet einen Zeilenumbruch, der in der E-Mail zum Abtrennen der
Kopfzeilen benötigt wird.

E-Mail versenden
Die Zeilenendezeichen \r\n werden unter Windows verwendet. Wenn
der SMTP-Server unter Unix läuft, ist meist \n ausreichend, manchmal
erforderlich. Probieren Sie Ihr Skript sorgfältig aus, bevor Sie es ausliefern.
Die folgende Tabelle zeigt einige typische Kopfzeilen, die Sie verwenden können:
Name Parameterbeispiel Bedeutung
To Empfänger, kann auch eine Liste sein
From test@test.de Absender. Die Angabe in spitzen
Klammern ist optional. Die Klammern
selbst müssen hier geschrieben werden,
wenn die Angabe erfolgt.
Cc test@test.de, weiter@weiter.de Kopie an. Liste von Empfängern, die
die E-Mail auch erhalten und die
sichtbar ist (Cc = Carbon copy).
Trennung durch Kommata.
Bcc test@test.de, weiter@weiter.de Kopie an. Liste von Empfängern, die
die E-Mail auch erhalten und die
nicht sichtbar ist (Bcc = Blind carbon
copy). Trennung durch Kommata.
Date Mon, 16 Aug 2004 11:29:28 +02 Datum, das beim Empfänger als das
Absendedatum angezeigt wird. Nutzen
Sie am einfachsten date('r').
Reply-To Gewünschte Antwortadresse. Fehlt die
Angabe, wir »To« verwendet.
X-Mailer PHP-Mail Version 5 Ein Hinweis, welches Programm zum
Versenden benutzt wurde.
X-Priority
X-MSMail-
Priority
MIME-
Version
1
High
Priorität (niedrig, hoch, …) in der allgemeinen
Variante und in einer für
Outlook/Outlook Express
1.0 Version der MIME-Kodierung
Tabelle 10.1: Namen und Parameter typischer Kopfzeilen für E-Mails
433

434
Kommunikation per HTTP, FTP und E-Mail
Name Parameterbeispiel Bedeutung
Content-type multipart/alternative Inhaltstyp nach MIME-Kriterien
Content-
Transfer-
Encoding
Content-
Disposition
Dies ist nur eine kleine Auswahl der Möglichkeiten. Sie reicht aber für die häufigsten
Fälle aus:
Versenden von HTML-Mails
Versenden von Anhängen
Anhänge versenden
base64 Kodierungsverfahren für Anhänge
attachment;\n\tfilename=anhang.txt
Anhänge und HTML werden in ähnlicher Weise versendet. Die Kodierung folgt
dem MIME-Standard. Dabei wird der Inhalt der Nachricht in mehrere Blöcke aufgeteilt,
die jeweils eigene Kopfzeilen haben und zusätzlich durch spezielle Grenzen
voneinander getrennt sind. Die Kopfzeilen helfen dem Client, die Nachricht
wieder zusammenzubauen. Binäre Daten, wie beispielsweise Bilder, werden meist
Base64-kodiert, damit sie auch über 7-Bit-Übertragungssysteme geliefert werden
können. Beachten Sie, dass sich Nachrichten dabei um bis zu 30% vergrößern
können.
Zuerst ein Beispiel: eine Klasse, die Anhänge versenden kann:
Listing 10.9: sendattachments.php – Anhänge zusammen mit E-Mail versenden

}
E-Mail versenden
$types = array(
".jpg" => "image/jpeg",
".jpeg" => "image/jpeg",
".png" => "image/png" );
$filename = basename($filename);
$ext = strtolower(substr($filename, strrpos($filename, ".")));
return $types[$ext];
public function sendMail($to, $from, $headers, $subject,
$message, $attachments="")
{
$bound = uniqid(time()."_");
$header = "From: $from\r\n";
$content = '';
foreach($headers as $head => $value)
$header .= "$head: $value\r\n";
if(is_array($attachments))
{
$header .= "MIME-Version: 1.0\r\n";
$header .= "Content-Type: multipart/mixed;
boundary=\"$bound\"\r\n";
$content .= "--$bound\r\n";
$content .= "Content-Type: text/html;
charset=\"iso-8859-1\"\r\n";
$content .= "Content-Transfer-Encoding:
8bit\r\n\r\n$message\r\n\r\n";
foreach($attachments as $attch)
{
if($fp = fopen($attch, "rb"))
{
$bn = basename($attch);
$content .= "--$bound\r\n" ;
$content .= "Content-Type: ".$this->getMime($attch).";
name=\"$bn\"\r\n" ;
$content .= "Content-Transfer-Encoding: base64\r\n";
$content .= "Content-Disposition: inline;
filename=\"$bn\"\r\n\r\n" ;
$content .= chunk_split(base64_encode(fread($fp,
filesize($attch))))."\r\n";
435

436
}
Kommunikation per HTTP, FTP und E-Mail
fclose($fp);
}
else
{
throw new MailException("Fehler, kann Anhang $attch
nicht öffnen.");
}
}
$content .= "--$bound--\r\n";
}
else
{
$content .= "Content-Type: text/html;
charset=\"iso-8859-1\"\r\n";
$content .= "Content-Transfer-Encoding:
8bit\r\n\r\n$message\r\n\r\n";
}
ini_set('track_errors', 1);
if (!@mail($to, $subject, $content, $header))
{
throw new MailException($php_errormsg);
}
}
$sm = new SendHtmlMail();
$to = 'joerg@krause.net';
$from = 'joerg@krause.net';
$headers = array('X-Mailer:' => 'PHP '.phpversion());
$msg = 'Test für Anhänge';
$subject = 'Test Nr. 5';
$attachment = array('data/Telefon.jpg', 'data/7650Nokia.jpg');
try
{
$sm->sendMail($to, $from, $headers, $subject, $msg, $attachment);
echo "An: $to, Von: $fromKopfzeilen: ";
print_r($headers);
}
catch (MailException $ex)
{
die($ex->getMessage());
}
?>

E-Mail versenden
Das Skript verwendet die neuen objektorientierten Möglichkeiten in PHP5. So
wird eine eigene Ausnahmenklasse MailException definiert, um Ausnahmen
gezielt abfangen zu können:
class MailException extends Exception
Die Klasse ist noch recht einfach. Als Anhänge sind nur Bilder zulässig, deren
MIME-Typ die private Methode getMime ermittelt:
private function getMime($filename)
Für JPEG-Bilder ist der MIME-Typ beispielsweise »image/jpeg«. Der MIME-
Standard verlangt die Vereinbarung einer eindeutigen Zeichenkette zur Trennung
von Datenblöcken. Eine sichere Methode ist die Nutzung der folgenden Funktionen:
$bound = uniqid(time()."_");
Daraus entstehen Zeichenfolgen wie beispielsweise »1092655372_4120990c6010f«.
Nach der Generierung der Kopfzeilen, die hier bequemerweise als Array übergeben
werden, sind die Anhänge als Nachrichtenblöcke aufbereitet dem Text der
E-Mail anzufügen. Zuerst wird dabei geprüft, ob Anhänge vorliegen. Die Methode
erwartet diese als ein Array aus Dateinamen:
if(is_array($attachments))
Ist das der Fall, soll MIME verwendet werden. Diese Angabe gehört in den Header:
$header .= "MIME-Version: 1.0\r\n";
Dazu muss mitgeteilt werden, dass mehrere Blöcke verschiedenen Inhalts (mixed)
folgen:
$header .= "Content-Type: multipart/mixed; boundary=\"$bound\"\r\n";
In dieser Zeile wird auch die Blockgrenze mit Hilfe des Parameters boundary festgelegt.
Der Inhalt beginnt nun mit einem solchen Abgrenzungszeichen. Die beiden
Minuszeichen leiten die Grenze ein und sind zwingend erforderlich:
$content .= "--$bound\r\n" ;
Vor die Anhänge wird der Text der Nachricht gestellt. Die Klasse ist in der Lage,
auch gleich HTML-E-Mails zu versenden:
$content .= "Content-Type: text/html; charset=\"iso-8859-1\"\r\n";
437

438
Kommunikation per HTTP, FTP und E-Mail
Wenn Sie Text versenden möchten, nutzen Sie den MIME-Typ »text/text« anstatt
»text/html«. Der Zeichensatz erlaubt die Verwendung des üblichen westeuropäischen
Standardzeichensatzes für Windows, sodass auch Umlaute übertragen werden.
Dann folgt die Kodierung und die Nachricht selbst:
$content .= "Content-Transfer-Encoding: 8bit\r\n\r\n
$message\r\n\r\n";
Hier wird nichts zusätzlich kodiert, da es sich nur um ASCII handelt. Das Übertragungsmedium
wird aber angewiesen, nach Möglichkeit mit 8 Bit zu übertragen,
damit die erweiterten Zeichen des Zeichensatzes erhalten bleiben.
Nun beginnt der Zusammenbau der Anhänge. Jeder Anhang wird einzeln erstellt.
foreach($attachments as $attch)
Zuerst wird die Datei im Binärmodus geöffnet:
if($fp = fopen($attch, "rb"))
Dann wird der Basisname ermittelt. Diese Angabe wird übertragen, während der
lokale Pfad, aus dem die Dateien gelesen werden, dem Empfänger nicht mitgeteilt
wird:
$bn = basename($attch)
Der Anhang wird dann wieder mit einem Grenzzeichen eingeleitet:
$content .= "--$bound\r\n" ;
Es folgen drei Kopfzeilen, die den Anhang beschreiben. Sie sehen nach der Verarbeitung
folgendermaßen aus:
Content-Type: image/jpg; name="telefon.jpg"
Content-Transfer-Encoding: base64
Content-Disposition: inline; filename="telefon.jpg";
Nun muss der Anhang noch gemäß den MIME-Kriterien zerlegt und kodiert werden.
Die folgenden Funktionen erledigen dies:
chunk_split(base64_encode(fread($fp, filesize($attch))))
Lesen Sie den Ablauf von innen nach außen:
1. fread liest die Datei komplett, die Dateigröße wird dabei mit filesize ermittelt

E-Mail versenden
2. base64_encode kodiert die Datei mit dem Base64-Verfahren (wie in der Kopfzeile
gefordert)
3. chunk_split zerlegt den Datenstrom in Blöcke, die verhindern, dass Mail-Server
störende Leerzeilen oder Umbrüche einfügen
Am Ende aller Anhänge wird eine weitere Grenze eingefügt, die mit zwei Minuszeichen
abschließt und so dem Mailclient mitteilt, dass keine weiteren Anhänge
folgen:
$content .= "--$bound--\r\n";
Der Rest ist trivial. Die E-Mail wird versendet und der Erfolg mit einer if-Anweisung
überwacht:
if (!@mail($to, $subject, $content, $header))
Trat ein Fehler auf, wird eine Ausnahme ausgelöst:
throw new MailException($php_errormsg);
Das Hauptprogramm definiert die nötigen Angaben zum Betrieb der Klasse. Die
einzige öffentliche Methode sendMail macht die Verwendung extrem einfach.
Abbildung 10.6:
E-Mail mit zwei
Anhängen in
einem E-Mail-
Client, mit der
Klasse SendHtml-
Mail versendet
Um HTML zu versenden, muss der Nachrichtenkörper lediglich eine gültige
HTML-Seite enthalten, also wenigstens mit den Tags umschlossen
sein.
Abbildung 10.7:
HTML-Mail, mit
demselben Programm
versendet
439

Andere Lösungen
440
Kommunikation per HTTP, FTP und E-Mail
Das Versenden von HTML oder Anhängen wird von Hunderten im Internet kursierenden
Klassen und Funktionssammlungen unterstützt. Die vorliegende Variante
ist insofern dennoch interessant, weil sie ausreichend kompakt ist, um
komplett verstanden zu werden. Außerdem nutzt sie die neuen Funktionen in
PHP5, was nahezu alle anderen Lösungen nicht tun. Sie ist außerdem hinreichend
alltagstauglich und leicht erweiterbar, wenn es erforderlich sein sollte.
10.6 Funktions-Referenz Stream-Funktionen
Funktion Bedeutung
stream_context_create Erzeugt ein Kontext-Handle, das andere Funktionen
nutzen, um auf so konfigurierte Streams zurückzugreifen.
Der Kontext-Parameter ist neu in vielen Dateifunktionen
in PHP5 hinzugekommen.
stream_context_get_default Ermittelt den aktuellen Kontext eines Streams.
stream_context_get_options Ermittelt gesetzte Optionen für Kontexte, Streams oder
Wrapper.
stream_context_set_option Setzt Optionen für Kontexte, Streams oder Wrapper.
stream_context_set_params Setzte Parameter für Kontexte, Streams oder Wrapper.
stream_copy_to_stream Kopiert Daten von einem Stream zu einem anderen.
stream_filter_append Fügt einem Stream ein Filter hinzu. Die Filteraktion
wird nach dem Übertragen der Daten ausgeführt.
stream_filter_prepend Fügt ein Filter vor einem Stream an. Die Filteraktion
wird vor dem Übertragen der Daten ausgeführt.
stream_filter_register Registriert einen benutzerspezifischen Filter. Das Filter
kann durch eine Klasse implementiert werden, die von
php_user_filter abgeleitet wird.
Tabelle 10.2: Funktions-Referenz für Stream-Funktionen

Funktion Bedeutung
Funktions-Referenz Stream-Funktionen
stream_get_contents Liest ausstehende Daten eines Streams in eine Zeichenkette.
stream_get_filters Ermittelt eine Liste von registrierten Filtern.
stream_get_line Liest eine Zeile aus einem Stream bis zu einem vereinbarten
Trennzeichen.
stream_get_meta_data Ermittelt Kopfzeilen und Metadaten aus einem Stream.
stream_get_transports Ermittelt eine Liste von Sockets, die Transportaufgaben
auf niedriger Ebene übernehmen.
stream_get_wrappers Ermittelt eine Liste registrierter Streams.
stream_register_wrapper Alias für stream_wrapper_register.
stream_select Äquivalent für den select-Systemaufruf.
stream_set_blocking Setzt blocking/non-blocking-Mode für einen Stream.
stream_set_timeout Setzt die Abbruchzeit für einen Stream.
stream_set_write_buffer Setzt Dateipufferung für einen Stream.
stream_socket_accept Akzeptiert eine Socket-Verbindung für den Stream. Die
Verbindung muss mit stream_socket_server erstellt
worden sein.
stream_socket_client Eröffnet eine Socket-Verbindung ins Internet oder zu
einer Unix-Domain.
stream_socket_enable_crypto Schaltet die Verschlüsselung für eine bestehende Verbindung
ein oder aus.
stream_socket_get_name Ermittelt den Namen eines lokalen oder remoten
Sockets.
stream_socket_recvfrom Empfängt Daten von einem Socket, unabhängig davon,
ob die Verbindung noch besteht oder nicht.
stream_socket_sendto Sendet eine Nachricht an einen Socket, unabhängig
davon, ob die Verbindung noch besteht oder nicht.
Tabelle 10.2: Funktions-Referenz für Stream-Funktionen (Forts.)
441

442
Kommunikation per HTTP, FTP und E-Mail
Funktion Bedeutung
stream_socket_server Erstellt eine Socket-Verbindung ins Internet oder zu
einer Unix-Domain.
stream_wrapper_register Registriert einen benutzerspezifischen Wrapper, der als
PHP-Klasse implementiert sein muss.
Tabelle 10.2: Funktions-Referenz für Stream-Funktionen (Forts.)
10.7 Kontrollfragen
1. Welche Aufgabe erfüllen Wrapper?
2. Was muss ein fremder Entwickler beachten, wenn er einen von Ihnen entwickeltes
Filter verwendet?
3. Was bedeuten die Kopfzeilen Cc: und Bcc: in einer E-Mail?
4. Welches Protokoll nutzt die mail-Funktion zur Übertragung der Daten?

Datenbankprogrammierung
11

444
Datenbankprogrammierung
11.1 Prinzip der Datenbankprogrammierung
Die Datenbankprogrammierung ist für fast alle Webseiten von elementarer Bedeutung.
Es geht dabei immer wieder darum, anfallende Daten zustands- und seitenunabhängig
zu erfassen und wieder bereitzustellen. Der Datenbankserver arbeitet
– auch wenn das entsprechende Programm auf derselben Maschine wie der Webserver
läuft – unabhängig von PHP oder Apache.
Um eine Datenbank zu nutzen, sind deshalb mehrere Schritte erforderlich, die
den Einstieg nicht einfach machen (wenn man es kann, mag dies primitiv klingen):
Aufsetzen oder Beschaffen eines Datenbankservers
Aktivierung eines Client-Moduls in PHP, das mit dem Server kommunizieren
kann
Herstellen einer Verbindung zum Datenbankserver am Beginn des Skripts,
meist unter Angabe der IP-Adresse oder des Netzwerknamens
Herstellen einer Verbindung zu einer konkreten Datenbank, die der Datenbankserver
verwaltet
Aufbau einer Abfrageverbindung, um SQL-Kommandos an den Datenbankserver
zu senden
Auswerten der Antwort und Aufbereitung der Daten, um diese für die Ausgabe
oder für weitere Abfragen verwenden zu können
Insgesamt ist also einiger Aufwand zu treiben. Dafür hat man ein System, das mit
drei Datensätzen ebenso gut zurechtkommt wie mit 3 Millionen. Außerdem lassen
sich auch komplexe Daten mit vielfältigen Verknüpfungen verwalten.
Einiger Lernaufwand ist dennoch nötig. Während Sie das Aufsetzen und Verwalten
des Datenbankservers an den Provider oder einen Administrator abschieben
können, bleibt die Last der Programmierung allein beim Entwickler der Website.
Unerlässlich sind deshalb SQL-Kenntnisse.
11.2 Die universelle Abfragesprache SQL
Dieser Abschnitt führt ganz allgemein in SQL ein. Dabei wird, soweit nichts anderes
explizit erwähnt wird, sowohl MySQL als auch SQLite unterstützt. Das heißt,

Die universelle Abfragesprache SQL
die entsprechende Abfragen funktionieren in beiden Fällen. Auf die Besonderheiten
der beiden Systeme wird in eigenen Abschnitten eingegangen.
Wenn Sie SQL bereits kennen, nutzen Sie diesen Abschnitt zum Auffrischen und
Wiederholen. SQL ist im Zusammenhang mit der PHP-Programmierung enorm
wichtig und sollte unbedingt beherrscht werden.
Was ist SQL?
SQL, am besten englisch ausgesprochen (»ess-kju-ell«), steht für Structured Query
Language – Strukturierte Abfragesprache. SQL wird verwendet, um mit einer
Datenbank zu kommunizieren. Nach der Definition der Normungsinstitution
ANSI (American National Standards Institute) ist SQL der verbindliche Industriestandard
für die Abfrage relationaler Datenbankmanagementsysteme (RDBMS).
SQL-Anweisungen bestimmen, wie eine Abfrage oder Befehl aussehen soll, den
das System empfängt und ausführt. Der Standard erlaubt es, mit einem Basisbefehlssatz
nahezu alle RDBMS zu bedienen. Abweichend von den Basisbefehlen
verfügen alle am Markt operierenden System – egal ob kommerziell oder Open
Source – über mehr oder wenige sinnvolle und natürlich zu allen anderen inkompatible
Erweiterungen. MySQL ist hierin ebenso wenig eine Ausnahme wie
SQLite, Oracle, MS SQL, Sybase oder Access. Der Basisbefehlssatz, den man
unbedingt beherrschen muss, wird jedoch weitgehend identisch unterstützt. Dazu
gehören SELECT (Abfragen), UPDATE (Aktualisieren), DELETE (Löschen),
INSERT (Einfügen) und DROP (Entfernen).
Tabellen und Abfragen
Relationale Datenbanken halten Daten in Tabellen. Tabellen werden durch einen
eindeutigen Namen identifiziert, der in den Abfragebefehlen anzugeben ist.
Tabellen bestehen aus Spalten, die jeweils einen ganz bestimmten Datentyp aufnehmen
können. Sie bestehen auch aus Reihen, in denen zusammengehörende
Daten gespeichert sind. Eine einfache Tabelle mit Daten kann in etwa folgendermaßen
dargestellt werden:
445

446
Datenbankprogrammierung
Stadt Bundesland Tief Hoch
Berlin Berlin 5 13
München Bayern 2 16
Hamburg Hamburg 7 12
Frankfurt Hessen 7 11
Tabelle 11.1: Eine sehr einfache SQL-Tabelle mit Wetterdaten (Tabellenname: Wetter)
Die Tabelle abfragen: SELECT
Grundsätzlich lässt sich jede Datenbank vollständig über SQL-Befehle bedienen.
Gerade am Anfang wird das eher weniger der Fall sein. Alle Datenbankprogramme
bieten mehr oder weniger elegante dialogorientierte Oberflächen, die zumindest
das Anlegen der Tabellen und das Eingeben der ersten Daten erlauben, ohne die
Anweisungen selbst zu beherrschen.
Bei Abfragen sieht es anders aus. Für viele kommerzielle Datenbanken gibt es so
genannte Query Builder und einige freie Programme mit entsprechender Funktion
sind auch verfügbar. Derartige Tools verhindern jedoch, dass man SQL wirklich
lernt. Das ist fatal, denn früher oder später stößt jedes dieser Programme an
seine Grenzen. Das sind aber selten die Grenzen von SQL. Die Beschäftigung mit
der Abfragesyntax ist deshalb unbedingt zu empfehlen.
Der prinzipielle Aufbau einer Abfrage folgt folgendem Schema:
SELECT Spaltename1 [, Spaltenname2, ...]
FROM Tabelle
[WHERE Bedingungen]
Die eckigen Klammern deuten optionale Angaben an. Die Anweisungen sollten
außerdem, auch wenn sie hier aus Gründen der Lesbarkeit mehrzeilig erscheinen,
als eine Zeichenkette gelesen werden. Auf die oben gezeigte Tabelle »Wetter«
bezogen, sieht eine konkrete Abfrage beispielsweise folgendermaßen aus:
SELECT Stadt, Bundesland FROM Wetter WHERE Tief > 5
Entfällt die mit WHERE eingeleitete Bedingung, werden alle Reihen der Tabelle
zurückgegeben. Die Auswahl der Spalten bestimmt die Liste unmittelbar hinter
SELECT. Hier kann alternativ auch das Sternchen (*) angegeben werden, um alle
Spalten zu holen.

Die universelle Abfragesprache SQL
SELECT * FROM ist die häufigste Abfrage – zumindest in der Literatur. In
der Praxis sollte dies nicht so sein, weil die Abfrage von Spalten, die
nicht benötigt werden, unnütz Zeit kostet. Die Darstellung auf dem
Papier lässt sich aber verkürzen und die Angaben sind weniger spezifisch,
was zur Erklärung manchmal hilfreich ist.
Hat eine Abfrage mit SELECT Erfolg, besteht die Antwort aus einem oder mehreren
so genannten Datensätzen. Jeder Datensatz kann wiederum ein oder mehrere Felder
enthalten. Der Datensatz ist quasi eine konkrete Version einer Reihe der
Datenbank, ergänzt um berechnete Spalten oder reduziert auf ausgewählte Spalten.
Nur wenn die Abfrage aus dem einfachen * besteht, entspricht ein Datensatz
einer Reihe.
Bedingungen formulieren: WHERE
Die WHERE-Bedingung ist sehr wichtig. Sie folgt denselben Prinzipien wie if in
PHP5, das heißt, es muss sich ein Boolescher Ausdruck formulieren lassen. Dazu
gehören in erster Linie die Vergleichsoperatoren:
>
Größer als; meist nur mit numerischen Werten sinnvoll
<
Kleiner als; meist nur mit numerischen Werten sinnvoll
>=
Größer als oder gleich; meist nur mit numerischen Werten sinnvoll

448
Datenbankprogrammierung
Neben diesen kennt SQL aber auch einige sehr spezielle Operatoren, die in PHP
nicht vorhanden sind:
LIKE
Dieser Operator erlaubt eine Ähnlichkeitssuche mit Platzhaltern. SQL verwendet
sehr untypische Platzhalter: % steht für jedes beliebige Zeichen in beliebiger
Anzahl und _ für genau ein beliebiges Zeichen.
Beispiel:
SELECT * FROM Wetter WHERE Stadt LIKE 'B%'
Diese Anweisung gibt alle Städte zurück, die mit dem Buchstaben »B« beginnen.
IN
SQL verwendet zur Referenz auf Datensätze oft deren Schlüsselnummern
(darauf wird noch genauer eingegangen). Listen solcher Referenzen kann man
mit IN verwenden. Aber auch einfache Zahlenvergleich sind gut möglich.
Beispiel:
SELECT * FROM Wetter WHERE Tief IN (1,3,5,7)
Dieser Befehl fragt alle ungeraden Tiefsttemperaturwerte aller Datensätze ab.
BETWEEN
Hiermit lassen sich Wertebereiche abfragen.
Beispiel:
SELECT * FROM Wetter WHERE Hoch BETWEEN 10 AND 15
Zeichenketten müssen in SQL mit einfachen Anführungszeichen umschlossen
werden. Die meisten Systeme verkraften zwar auch doppelte, die Zusammenarbeit
mit PHP profitiert aber erheblich von einer einheitlichen Schreibweise, weshalb
einfache Anführungszeichen zum Standard gehören sollten.
Die SELECT-Anweisung kann weitaus mehr. Dazu gehören Befehle zum Sortieren,
Filtern, Verknüpfen mit anderen Tabellen usw. Um dies ausprobieren zu können,
brauchen Sie jedoch mehr Tabellen, die erstmal erzeugt und befüllt sein müssen.
Tabellen anlegen und füllen
Werden Tabellen per Code erzeugt, braucht man eine spezielle Anweisung dafür.
Dieser Abschnitt zeigt, wie Tabellen erzeugt und gefüllt werden.

Tabelle erzeugen: CREATE TABLE
Die universelle Abfragesprache SQL
In SQL heißt diese CREATE TABLE. Die grundlegende Syntax lautet:
CREATE TABLE Tabellenname
(SpaltenName DatenTyp [Einschränkung],
[SpaltenName DatenTyp [Einschränkung], ...]
)
Die Angabe der Einschränkung bestimmt nähere Eigenschaften der Spalte, abhängig
vom gewählten Datentyp. Die Angabe ist optional, weil alle Datentypen mit
bestimmten Basiseigenschaften ausgestattet sind. Der Spaltenname ist frei wählbar.
Die meisten Systeme verkraften sogar Leerzeichen (keine gute Idee), wenn der
Name in Anführungszeichen steht.
Der Datentyp einer Spalte
Der Datentyp ist eine sehr wichtige Eigenschaft einer Spalte. SQL ist prinzipiell
typstreng und überwacht die Einhaltung der Daten in den Feldern umfassend. In
der Praxis wird dies etwas aufgeweicht betrachtet. So konvertiert SQLite intern
alles so lange, bis es passt, und akzeptiert meist alles. MySQL hält die Typen streng
ein, konvertiert aber auch weit reichend, und die Daten »passend« zu machen.
Andere Datenbanken sind strenger und reagieren mit Fehlermeldungen auf falsche
Typen. Generell geht SQL aber nie so locker mit Datentypen um wie PHP.
SQL verfügt über eine Vielzahl von Funktionen, die speziell für Zeichenketten
oder Zahlen gedacht sind. Der falsche Datentyp für die zu berechnende Spalte
führt dann in jedem Fall zu einer Fehlermeldung.
Die Angabe des Datentyps erfolgt durch ein aussagekräftiges Schlüsselwort und
optional durch Parameter. Die folgende Tabelle zeigt die wichtigsten Angaben, die
von fast allen SQL-Datenbanken akzeptiert werden.
Datentyp Beschreibung
CHAR(Anzahl) Feld mit fester Anzahl von Zeichen.
VARCHAR(Maximum) Feld mit variabler Anzahl Zeichen, begrenzt auf ein Maximum.
INT(Breite) Ganzzahlfeld mit der durch Breite angegebenen Anzahl
Stellen
449

450
Datenbankprogrammierung
Datentyp Beschreibung
DATE Ein Datumsfeld (nur die Angabe des Datums ist möglich).
DATETIME Ein Datums- und Zeitfeld (enthält Datums- und Zeitinformationen).
FLOAT(Breite, Dezimal) Gleitkommazahl mit Breite Stellen und Dezimal Nachkommastellen.
TEXT Längere Textdaten (VARCHAR und CHAR sind auf
255 Zeichen begrenzt).
BLOB Größere Binärdaten (BLOB = Binary Large Objects).
Die meisten Datenbanken bieten vordefinierte Variationen von INT für verschiedene
Mengen, beispielsweise BIGINT oder TINYINT in MySQL.
Tabellen erzeugen
Das folgende Beispiel zeigt, wie die am Anfang benutzte Tabelle erzeugt wird:
CREATE TABLE Wetter
(Stadt VARCHAR(100),
Bundesland VARCHAR(30),
Tief INT(2),
Hoch INT(2))
Generell gilt die Regel, dass die Datentypen so fein und begrenzend wie möglich
ausgelegt werden sollten. So dürfte es in Mitteleuropa kaum vorkommen, dass dreistellige
Temperaturen auftreten. Deshalb wird INT(2) geschrieben. Es gibt kein
Bundesland, das mehr als 30 Zeichen für den Namen benötigt (Mecklenburg-Vorpommern
ist der längste Name mit genau 22 Zeichen). Beachten Sie, dass die
Temperaturangabe -11°C in einem INT-Feld auch nur zwei Stellen benötigt, weil
das Vorzeichen separat gespeichert wird.
Derartige Beschränkungen verhindern zumindest teilweise, dass unsinnige Daten
in die Datenbank gelangen. Sie führen freilich, wenn es dennoch versucht wird,
zu Fehlermeldungen im Skript, die gesondert behandelt werden müssen. Inkonsistente
Datenbestände sind jedoch weitaus schlimmer als Fehler bei der Eingabe,
die frühzeitig auf das Problem hinweisen.

Einschränkungen
Die universelle Abfragesprache SQL
Bei der Definition der Syntax für CREATE TABLE war von Einschränkungen die
Rede. Dies sind Angaben, die den möglichen Inhalt unabhängig vom Datentyp
bestimmen. Drei solcher Zusatzangaben sind besonders wichtig:
UNIQUE
Hiermit wird bestimmt, dass alle Werte in der Spalte nur ein Mal vorkommen
dürfen, das heißt, sie müssen eindeutig (engl. unique) sein.
PRIMARY KEY
Bestimmt, dass diese Teile den Primärschlüssel stellt. Zur Bedeutung der
Schlüssel folgt noch eine detaillierte Betrachtung. PRIMARY KEY impliziert
immer UNIQUE.
AUTO_INCREMENT
Nicht offizieller SQL-Standard aber dennoch von fast allen Datenbank unterstützt
sind Felder, deren Werte automatisch erzeugt werden, ohne dass dies
beim Einfügen angegeben werden muss.
NULL, NOT NULL
NULL erklärt, dass das betreffende Feld beim Schreiben der Daten leer bleiben
darf, NOT NULL bestimmt, dass dies nie der Fall sein darf.
DEFAULT
Bestimmt einen Standardwert, wenn bei der Eingabe der Daten kein Wert
angegeben oder das Feld überhaupt nicht spezifiziert wurde.
Es gibt weitaus mehr Einschränkungen als die gezeigten, allerdings werden die
meisten weder von MySQL noch von SQLite unterstützt, weshalb die Ausführungen
auf die elementaren Angaben beschränkt werden.
Daten einfügen
Nachdem die Tabelle existiert, kann sie mit Daten gefüllt werden. Dazu wird die
Anweisung INSERT benutzt. INSERT verlangt die Angabe des Tabellennamens, einer
Liste der Spalten, die mit Daten bestückt werden, und eine Liste der Werte, die
hineingeschrieben werden. Die Angabe der Spalten kann entfallen, wenn alle
beschrieben werden. Eine weitere Wetterangabe in der Mustertabelle könnte folgendermaßen
eingefügt werden:
451

452
Datenbankprogrammierung
INSERT INTO Wetter
(Stadt, Bundesland, Hoch, Tief)
VALUES
('Dresden', 'Sachsen', 17, 8)
Beachten Sie, dass Zeichenketten in einfachen Anführungszeichen stehen, numerische
Werte jedoch nicht. Die Anzahl der Werte hinter VALUES muss exakt der
Anzahl der Spalten entsprechen, damit die Zuordnung stimmt. Spalten, die hier
nicht auftreten, werden entsprechend den Einschränkungsregeln befüllt, also mit
Standardwerten (DEFAULT), automatischen Werten (AUTO_INCREMENT) oder NULL-
Werten (NULL).
Aktualisieren und Löschen von Daten
Nachdem die Daten nun in der Tabelle sind und auch gelesen werden können,
sind Lösch- und Aktualisierungsvorgänge an der Tagesordnung.
Aktualisierung von Daten: UPDATE
Die Änderung der Inhalte wird mit der Anweisung UPDATE vorgenommen. Die
grundlegende Syntax folgt folgendem Schema:
UPDATE TabellenName
SET SpaltenName = Wert [, SpaltenName = Wert, ...]
[WHERE Bedingung]
Die Bedingung entspricht weitgehend den bei SELECT möglichen Angaben. Ohne
Bedingung werden immer alle Spalten geändert. Die Zuweisung neuer Werte
kann mit Konstanten oder Berechnungen, auch mit Referenzen auf andere Spalten
erfolgen.
Im Beispiel lässt sich die Temperatur für eine bestimmte Stadt folgendermaßen
ändern:
UPDATE Wetter SET Hoch = 17, Tief = 23 WHERE Stadt = 'Berlin'
Man kann auch alle Temperaturen einfach erhöhen:
UPDATE Wetter SET Hoch = Hoch + 1

Löschen von Daten: DELETE
Die universelle Abfragesprache SQL
Dem Löschen dient die Anweisung DELETE. Die Anwendung entspricht dem
Schema der bisher vorgestellten Befehle:
DELETE FROM TabellenName [WHERE Bedingung]
Auch wenn die Bedingung optional ist, die Angabe dürfte in den allermeisten Fällen
unbedingt erforderlich sein – sonst ist die Tabelle nämlich leer.
Für die Bedingung kann wieder ein Ausdruck nach dem bei SELECT gezeigten
Schema benutzt werden. Beachten Sie, dass SQL kein »Undo/Rückgängig« etc.
kennt – was weg ist, ist endgültig weg.
Löschen und Leeren von Tabellen: DROP und TRUNCATE
Um eine Tabelle komplett wieder loszuwerden, nutzen Sie die Anweisung DROP:
DROP TabellenName
Ebenso einfach geht das Leeren, das alle Daten entfernt, aber die Tabelle selbst
erhält:
TRUNCATE TabellenName
Gegenüber der Anweisung DELETE FROM TabellenName (ohne Bedingung) ist, TRUN-
CATE schneller. Der Effekt ist derselbe – alles ist weg.
Fortgeschrittene Abfragen mit SELECT
SELECT allein ist ungeheuer mächtig. Der korrekte Umgang damit verlangt aber
einiges an Hintergrundwissen. Dennoch kommt man sehr schnell nicht mehr
ohne die Basisabfragen aus. Dieser Abschnitt zeigt die Anwendung von SELECT auf
dem Niveau, wie es auf durchschnittlich komplexen PHP-Seiten durchaus zur
Anwendung kommen kann. Wenn Sie noch weiter lernen möchten, ist der Zugriff
auf spezielle Literatur erforderlich.
SELECT komplett betrachtet
Mit SELECT werden Datenbanken abgefragt. Dabei ist FROM die einzige Angabe, die
zwingend erforderlich ist. Das bereits vorgestellte WHERE ist optional. Insgesamt sind
es fünf derartige Operatoren, die zum Einsatz kommen können:
453

454
Datenbankprogrammierung
FROM
Bestimmt die Tabelle (oder mehrere Tabellen), aus denen gelesen wird.
WHERE
Schränkt die Auswahl durch eine global wirkende Bedingung ein.
GROUP BY
Gruppiert Ergebnisse, sodass sie mit anderen zusammengefasst werden können.
HAVING
Wendet Auswahleinschränkungen auf Gruppen an.
ORDER BY
Sortiert die Ergebnisse.
Bei der Auswahl der Spalten kann zudem bestimmt werden, ob alle oder nur eindeutige
Ergebnisse zurückgegeben werden sollen:
ALL
DISTINCT
Die Angabe ALL entfällt in den allermeisten Fällen, weil dies der Standardwert ist.
Für die Abfrage eindeutiger Werte schreiben Sie beispielsweise:
SELECT DISTINCT Bundesland FROM Wetter
Dies verhindert, dass die mehrfach in der Tabelle auftretenden Bundesländer auch
mehrfach ausgegeben werden.
GROUP BY gruppiert Ergebnisse und wenn Einschränkungen bei der Auswahl der
Gruppen gefragt sind, dann ist HAVING die erste Wahl. Nach HAVING können dieselben
Booleschen Ausdrücke stehen wie nach WHERE. Mehr dazu weiter unten.
Aggregierende Funktionen
Aggregierende Funktionen führen Berechnungen mit der durch SELECT erstellten
Auswahl von Daten aus. Die häufigste und einfachste ist COUNT – hiermit wird
schlicht die Anzahl der Reihen ermittelt. Wichtig sind folgende Funktionen:
COUNT, COUNT(*)
Hiermit wird die Anzahl der ausgewählten oder (*) aller Reihen der Abfrage
ermittelt.

Die universelle Abfragesprache SQL
MAX, MIN
Enthält die betroffene Spalte Werte, die eine Ordnung bilden, kann hiermit
der größte bzw. kleinste Wert ermittelt werden.
SUM
Für numerische Spalten ermittelt diese Funktion die Summe.
AVG
Für numerische Spalten ermittelt diese Funktion den Durchschnitt.
Beachten Sie, dass die Aggregatfunktionen keine Liste von Daten erzeugen, sondern
skalare Werte. Dies muss bei der Auswertung mit PHP-Funktionen berücksichtigt
werden. Bei den PHP-Beispielen wird darauf nochmals explizit eingegangen.
Die Anwendung in SQL sieht folgendermaßen aus:
SELECT AVG(Hoch) FROM Wetter
Damit erhält man die durchschnittliche Tageshöchsttemperatur aus der Wetter-
Tabelle. Selbstverständlich sind auch hier WHERE-Bedingungen eine gute Idee:
SELECT AVG(Hoch) FROM Wetter WHERE Bundesland = 'Bayern'
Nun erhalten Sie die durchschnittliche Tageshöchsttemperatur aller bayerischen
Städte.
Gruppierungen
Gruppierungen mit GROUP BY wurden bereits kurz erwähnt. Der Sinn ist weniger
der damit erreichbare Sortiereffekt, sondern die Möglichkeit, die Aggregatfunktionen
auf die Gruppen anzuwenden.
SELECT MAX(Hoch), Bundesland
FROM Wetter
GROUP BY Bundesland
HAVING Bundesland LIKE 'B%'
Diese Abfrage ermittelt die höchste Tagestemperatur aller Bundesländer, die mit
»B« beginnen. Die Einschränkung mit HAVING ist freilich optional, meist genügt
die Gruppierung alleine. Wichtig ist, dass die Liste der Spalten hinter GROUP BY in
der Liste der Spalten hinter SELECT enthalten sein muss. Gruppierung und Ausgabe
korrespondieren immer. Die Aggregatfunktionen sind davon nicht betroffen,
deshalb kann die Funktion MAX im Beispiel hinzugefügt werden.
455

456
Datenbankprogrammierung
Ergebnisse sortieren
Tabellen sind in SQL niemals sortiert oder geordnet. Allein die Abfrage entscheidet,
wie die Daten auszugeben sind. Um die entsprechende Kontrolle zu bekommen,
wird ans Ende der Anweisung ORDER BY angehängt. Zwei zusätzliche
Klauseln bestimmen die Richtung:
ASC
Dies steht für »ascending«, also aufsteigend.
DESC
Dies steht für »descending«, also absteigend.
Hinter ORDER BY lassen sich mehrere Spalten angeben, um uneindeutige Sortierungen
nach nur einer Spalte zu vermeiden:
SELECT * FROM Wetter ORDER BY Bundesland, Stadt ASC
Das konkrete Sortierverhalten kann SQL nicht bestimmen. Dazu bietet jedes
Datenbanksystem verschiedene Einstellmöglichkeiten, die nicht standardisiert
sind. Dies betrifft beispielsweise die Einordnung von Umlauten ins Alphabet.
Die Klausel ASC kann auch entfallen, denn die aufsteigende Sortierung ist der
Standardfall. Dies gilt aber nur, wenn ORDER BY angegeben wurde. Ohne dieses
Schlüsselwort wird unsortiert ausgegeben.
Funktionen
SQL verfügt über eine reiche Funktionspalette, unter anderem:
Mathematische Funktionen
Zeichenkettenverarbeitung
Datumsfunktionen
Systemfunktionen
Leider ist der Standard hier kaum beachtet worden. Deshalb gibt es teilweise drastische
Unterschiede in Ausstattung und Syntax bei verschiedenen Datenbanken.
Der Abschnitt 11.4 »Erste Schritte mit MySQL und MySQLi« ab Seite 477 zeigt
die konkreten Funktionen für MySQL und im Kapitel Die integrierte Datenbank
SQLite ab Seite 497 finden Sie entsprechende Auflistung für SQLite.

Verknüpfungen zwischen Tabellen
Die universelle Abfragesprache SQL
Der Name »Relationale Datenbanken« enthält einen Hinweis auf eine ganz spezifische
Eigenschaft – die Relationen oder Beziehungen. Richtig wertvoll wird der
Umgang mit Datenbanken erst, wenn man zwischen Tabellen derartige Beziehungen
aufbaut.
Das ist in fast allen Anwendung auch notwendig, um die Datenhaltung effektiv und
nicht redundant zu halten. Wenn Sie die gut gefüllte Wetter-Tabelle sehen, werden
Sie bemerken, dass dieselben Bundesländer immer wieder aufgeführt sind. Ändert
man nun den Namen, beispielsweise wegen eines Schreibfehlers, dann müsste man
alle betreffenden Felder ändern. Hat man dabei schon einen Fehler, beispielsweise
aus früheren Einträgen, wird die Datenbank inkonsistent. Deshalb versucht man,
redundante Daten zu vermeiden. Dazu wird eine zweite Tabelle erstellt und mit
der ersten verknüpft. Damit das Verknüpfen funktioniert, erhält außerdem jede
Tabellen einen Primärschlüssel, der jeden Datensatz eindeutig kennzeichnet.
Normalisierungen
Folgende neue Tabelle ist also für die Wetter-Anwendung erforderlich:
ID Name
1 Berlin
2 Bayern
3 Hamburg
4 Hessen
Tabelle 11.2: Tabelle für Bundesländer (Ausschnitt)
Nun wird die Wetter-Tabelle so geändert, dass nur noch mit Relationen gearbeitet
wird:
ID Stadt BundeslandID Hoch Tief
1 Berlin 1 7 13
2 München 2 8 16
Tabelle 11.3: Tabelle für Wetterdaten (Ausschnitt)
457

458
Datenbankprogrammierung
ID Stadt BundeslandID Hoch Tief
3 Regensburg 2 9 15
4 Altötting 2 8 15
Tabelle 11.3: Tabelle für Wetterdaten (Ausschnitt) (Forts.)
Die Verknüpfung ist nun noch zu definieren. Je nach Datenbank ist dies eine einfache
Festlegung oder ein fest programmierter Wert, der von der Datenbank überwacht
wird. MySQL und SQLite überwachen nichts und deshalb genügt die
Angabe der Verknüpfung bei der Abfrage, was durch Vergleich der beiden betroffenen
Felder geschieht:
Bundesland.ID = Wetter.BundeslandID
Damit das in einer Anweisung gelingt, muss man etwas beachten. So kann jedem
Spaltennamen immer der Tabellenname vorangestellt werden, getrennt durch
einen Punkt. Das ist meist notwendig, weil sich die Spaltennamen gleichen können
und der SQL-Server dann nicht mehr weiß, welche Spalte gemeint ist.
Das Aufbrechen einer Tabellen in mehrere zur Vermeidung von Redundanzen
wird als Normalisierung bezeichnet. Es gibt mehrere Stufen der Normalisierung,
für deren vollständige Darstellung jedoch mehr Platz erforderlich ist. An dieser
Stelle sei auf entsprechende Spezialliteratur zu Datenbanken verwiesen.
Prinzipien verknüpfter Abfragen
Verknüpfte Abfragen können auf mehreren Wegen erstellt werden. Der einfachste
weg ist ein so genannter »Inner Join«, bei dem ein Kreuzprodukt aus beiden Tabellen
erstellt wird:
SELECT * FROM Wetter, Bundesland
Das führt dazu, dass jede Zeile der einen Tabelle mit jeder der anderen Tabelle
»gekreuzt« wird. 100 Wetterdaten für 16 Bundesländer ergeben dann 1.600 Reihen.
Damit kann in der Praxis niemand etwas anfangen. Also ist die benötigte
Verknüpfung anzugeben:
SELECT * FROM Wetter, Bundesland
WHERE Bundesland.ID = Wetter.BundeslandID
Nun werden die Datensätze aus der ersten Tabelle mit den passenden aus der
zweiten verknüpft. Da jeder Wettereintrag nur in einem Bundesland platziert sein

Die universelle Abfragesprache SQL
kann, sind es nun nur noch die benötigten 100 Datensätze. Im Unterschied zur
einfachen Abfrage der ersten Tabelle steht nun aber auch der Name des Bundeslandes
zur Verfügung. Korrekter (im Sinne von: effizienter) ist folgende Version:
SELECT W.Stadt, W.Hoch, W.Tief, B.Name
FROM Wetter W, Bundesland B
WHERE B.ID = W.BundeslandID
Damit ist die mit der ersten Abfrage erreichte Ausgabe wieder da, allerdings diesmal
basierend auf einer verbesserten Datenstruktur.
Zum »Inner Join« kann eine alternative Syntax verwendet werden:
SELECT W.Stadt, W.Hoch, W.Tief, B.Name
FROM Wetter W INNER JOIN Bundesland B
ON B.ID = W.BundeslandID
Weitere Bedingungen, die in der ersten Variante mit AND angehängt werden, müssten
hier in einer zusätzlichen WHERE-Bedingung stehen. Der »Inner Join« bezieht
NULL-Felder nicht mit ein. Es kann nämlich sein, dass zu einer Stadt noch keine
Zuordnung des Bundeslandes erfolgte. Was passiert mit solchen Feldern? Grundsätzlich
ist NULL in SQL kein unmöglicher Zustand. Es gibt nun mehrere Varianten:
Die linke Tabelle (links vom JOIN) enthält NULL-Werte und die entsprechenden
Zeilen sollen trotzdem verarbeitet werden.
In diesem Fall wird als Schlüsselwort LEFT JOIN gewählt.
Die rechte Tabelle (rechts vom JOIN) enthält NULL-Werte und die entsprechenden
Zeilen sollen trotzdem verarbeitet werden.
In diesem Fall wird als Schlüsselwort RIGHT JOIN gewählt.
Freilich kann man auch die Tabellen vertauschen und die Schlüsselwörter genau
umgekehrt einsetzen.
Es gibt weitere JOIN-Varianten, die hier jedoch zu weit führen und die – leider –
auch nicht alle von MySQL unterstützt werden.
Fortgeschrittene SQL-Techniken
Einige fortgeschrittene SQL-Techniken seien an dieser Stelle kurz erwähnt. Sie
sind leicht zu verstehen und einzusetzen. Das Handbuch zu MySQL gibt hier ausführlich
Auskunft.
459

Primärschlüssel
460
Datenbankprogrammierung
Bislang wurde einfach angenommen, dass die Tabellen einen Schlüssel haben.
Generell ist dies keine Option, sondern ein Primärschlüssel ist erforderlich, damit
die Datenbank die Datensätze unterscheiden kann. Praktischerweise definiert man
meist eine Spalte als INT (oder größer, beispielsweise BIGINT) und versieht sie mit
dem Attribut AUTO_INCREMENT. MySQL legt die benötigten Schlüssel dann automatisch
an. Andere Tabellen können dann Referenzen dazu nutzen. Ohne Primärschlüssel
könnte die Datenbank die Datensätze nicht eindeutig unterscheiden und
Abfragen wären nicht ausführbar.
Alternativ zur automatischen Vergabe ist freilich auch die Nutzung anderer Spalten
mit eindeutigen Werten möglich, ebenso wie sich der Primärschlüssel aus
mehreren Spalten zusammensetzen kann, um eindeutig zu sein.
Unterabfragen
Manchmal benötigt man die Ergebnisse einer Abfrage für eine andere. SQL kann
diese Verknüpfung direkt ausführen, also ohne PHP dazwischen. Man spricht von
so genannten Sub-Selects:
SELECT * FROM Wetter
WHERE BundeslandID
NOT IN
(SELECT ID FROM Bundesland WHERE NAME LIKE 'B%')
Zuerst wird hier die innere Abfrage ausgeführt. Sie ergibt eine Liste der Primärschlüssel
der Tabelle Bundesland für alle Länder, die mit »B« beginnen. Diese
Liste (beispielsweise 1,2,4,8) wird für den IN-Operator benutzt. Dann wird die
Abfrage für alle Bundesländer ausgeführt, die nicht (NOT IN) mit »B« beginnen.
Sub-Selects sind vor allem bei verknüpften Tabellen häufiger im Einsatz.
Sub-Selects sind meist langsamer als JOIN und äquivalent verwendbar. Es gibt aber
auch Fälle, in denen sie sich nicht gegenseitig ersetzen können. In der Praxis
braucht man beides.
UNION
Mit UNION lassen sich zwei Abfragen kombinieren. Das Resultat können zwei verschiedene,
aber auch zwei gleichartig strukturierte Tabellen sein. Die Kombina-

Der MySQL-Dialekt
tion von Abfragen hebt einige Beschränkungen der JOIN-Verfahren auf. Das
Schlüsselwort muss immer zwischen zwei gültigen SELECT-Abfragen stehen:
SELECT * FROM Wetter UNION SELECT * FROM Stadt
Beim programmtechnischen Zugriff mittels PHP5 müssen spezielle Abfragemethoden
verwendet werden, um die unterschiedlich strukturierten Tabellen auslesen
zu können.
11.3 Der MySQL-Dialekt
Dieser Abschnitt zeigt die Besonderheiten, Funktionen und Eigenarten von
MySQL 4 und teilweise auch MySQL 5. Soweit MySQL sich an das im vorhergehenden
Abschnitt beschriebene Standard-SQL hält, wird dies nicht nochmals wiederholt.
Grobe Abweichungen vom SQL92-Standard
Die folgende Liste zeigt in loser Folge einige der wichtigsten Erweiterungen,
Funktionen und Einschränkungen in MySQL. Die meisten Angaben gelten für
MySQL ab Version 4.1, MySQL 5 zeichnet sich demgegenüber vor allem durch
höhere Stabilität, Geschwindigkeit und (nach der finalen Version) Zuverlässigkeit
aus.
CREATE TABLE t2 LIKE t1
Erzeugt eine neue Tabelle t2, die exakt denselben Aufbau wie t1 hat.
INSERT ON DUPLICATE KEY UPDATE
Fügt Daten ein, bzw. aktualisiert, wenn der Primärschlüssel bereits existiert.
Das ist eine elegante Kombination aus INSERT und UPDATE.
Erweiterungen bei den GROUP BY-Funktionen: STD, BIT_OR, BIT_AND,
GROUP_CONCAT(SpaltenName SEPARATOR ',')
Die neue Aggregat-Funktion GROUP_CONCAT, kann die Werte einer Abfrage als
Zeichenkette zusammenfassen. Es kann ein Trennzeichen ähnlich wie in
PHPs join-Funktion angegeben werden.
LIKE kann auch auf numerische Spalten angewendet werden.
461

462
Datenbankprogrammierung
Der SELECT-Befehl ist um zwei Schlüsselwörter erweitert worden: INTO OUTFILE
und STRAIGHT_JOIN.
Neu sind die Befehle OPTIMIZE TABLE und SHOW.
GROUP BY muss nicht alle Spalten enthalten, die ausgegeben werden.
Zusätzlich zu den Operatoren OR und AND können die Symbole || und &&
genutzt werden. Für die Verknüpfung von Zeichenketten muss anstatt || die
Funktion CONCAT verwendet werden.
Der Operator % kann als Synonym für MOD eingesetzt werden.
Logische Operatoren können auch auf der linken Seite eines SELECT-Befehls
geschrieben werden:
SELECT spalte1 >= 100 FROM table
Der Abruf der letzten automatisch generierten ID erfolgt mit der Funktion
LAST_INSERT_ID().
Diverse neue Funktionen, unter anderem versteht MySQL reguläre Ausdrücke
mit REGEXP und RLIKE (siehe Liste im nächsten Abschnitt).
Neue Befehle: REPLACE ersetzt UPDATE und INSERT. Ist der Datensatz vorhanden
(identifiziert am Primärschlüssel), wird INSERT ausgeführt, andernfalls UPDATE.
FLUSH löscht Statusinformationen.
Datentypen
Die Datentypen sind in MySQL sehr umfangreich. Die folgende Tabelle zeigt
alles, was geht, unabhängig davon, ob es dem SQL92-Standard entspricht oder
nicht.
Datentyp Beschreibung
TINYINT [(M)] [UNSIGNED] [Z] Kleine Ganzzahlen, von 0 bis 255 oder -128 bis 127
SMALLINT [(M)] [UNSIGNED] [Z] Ganzzahlen, entweder von 0 bis 65.535 oder von
-32.768 bis +32.767
MEDIUMINT [(M)] [UNSIGNED] [Z] Ganzzahlen, entweder von 0 bis 16.777.215 oder
von -8.388.608 bis +8.388.607
Tabelle 11.4: Datentypen in MySQL (Z steht für ZEROFILL, M für die Stellenzahl)

Datentyp Beschreibung
INT [(M)] [UNSIGNED] [Z]
INTEGER
Der MySQL-Dialekt
Ganzzahlen, entweder von 0 bis 4.294.967.295 oder
von -2.147.283.648 bis +2.147.283.647
BIGINT [(M)] [UNSIGNED] [Z] Ganzzahlen, entweder von 0 bis
18.446.744.073.709.551.615 oder von
-9.223.372.036.854.775.808 bis
+9.223.372.036.854.775.807
FLOAT(precision) [Z] Fließkommazahl, immer vorzeichenbehaftet.
precision kann 4 oder 8 sein; 4 steht für einfache
Genauigkeit, 8 für doppelte.
FLOAT[(M,D)] [Z] Fließkommazahl, deren Wertebereich von
-3,402823466 38 bis -1,175494351- 38 reicht und die 0
sowie den Wertebereich von +1,175494351 -38 bis
+3,402823466 38 umfasst.
DOUBLE[(M,D)] [Z]
DOUBLEPRECISION[(M,D)] [Z]
REAL[(M,D)] [Z]
DECIMAL(M,D) [Z]
NUMERIC
Fließkommazahl, deren Wertebereich von
-1,7976931348623157 308 bis -2,2250738585072014 -308 ,
und von -2,2250738585072014 -308 bis
+1,7976931348623157 308 reicht, inklusive der 0.
Ungepackte Fließkommazahl, immer vorzeichenbehaftet.
Zahlen werden als Zeichenkette gespeichert,
jede Ziffer steht in einem Byte. Das Komma, Vorzeichen
usw. belegen jeweils ein Byte.
DATE Datum im Format »YYYY-MM-DD«. Der Wertebereich
geht vom 1.1.1000 bis zum 31.12.9999.
DATETIME Datum und Zeit im Format
»YYYY-MM-DD hh:mm:ss«.
TIMESTAMP[(M)] Zeitstempel, Wertebereich von 1.1.1970 bis zum
31.12.2036. Für die Angabe des Anzeigebereiches
M gilt:
14: YYYYMMDDhhmmss
12: YYMMDDhhmmss
8: YYYYMMDD
6: YYMMDD
Tabelle 11.4: Datentypen in MySQL (Z steht für ZEROFILL, M für die Stellenzahl) (Forts.)
463

Funktionen
464
Datenbankprogrammierung
Datentyp Beschreibung
TIME Zeit im Wertebereich von -838:59:59 bis +838:59:59
mit dem Ausgabeformat »hh:mm:ss«.
YEAR Jahr, Wertebereich 1901 bis 2155, Ausgabe YYYY.
CHAR(M) [BINARY] Zeichenkette fester Länge M. Wertebereich 1 bis
255. Leerzeichen am Ende werden automatisch für
die Ausgabe entfernt. Sortieren und Selektieren
berücksichtigt Groß- und Kleinschreibung nicht,
wenn Sie nicht BINARY verwenden.
VARCHAR(M) [BINARY] Zeichenkette variabler Länge, maximal M. Wertebereich
1 bis 255. Leerzeichen am Ende werden
automatisch für die Ausgabe entfernt. Sortieren und
Selektieren berücksichtigt Groß- und Kleinschreibung
nicht, wenn Sie nicht BINARY verwenden.
TINYBLOB, TINYTEXT BLOB oder TEXT mit maximal 255 Byte
BLOB, TEXT BLOB oder TEXT mit maximal 65.535 Byte
MEDIUMBLOB, MEDIUMTEXT BLOB oder TEXT mit maximal 16.777.215 Byte
LONGBLOB, LONGTEXT BLOB oder TEXT mit maximal 4.294.967.295 Byte
ENUM('wert1', 'wert2', ...,) Aufzählung. Ein Feld dieses Typs kann nur eine
Zeichenkette enthalten, die einem Objekt der Aufzählung
entspricht.
SET('wert1', 'wert2' , ...,) Wie ENUM, kann aber mehrere Werte aus der Liste
enthalten.
Tabelle 11.4: Datentypen in MySQL (Z steht für ZEROFILL, M für die Stellenzahl) (Forts.)
Funktionen sind schlecht standardisiert. Jede Datenbank kocht ihr eigenes Süppchen.
MySQL ist da keine Ausnahme. Deshalb finden Sie an dieser Stelle alle
Funktionen der aktuellen Version mit entsprechenden Einsatzhinweisen.

Funktionen für mathematische Berechnungen
Funktion Beschreibung
ABS(x) Absoluter Betrag der Zahl x.
ACOS(x) Der Arkuskosinus der Zahl x.
ASIN(num) Der Arcussinus der Zahl x.
ATAN(num) Der Arkustangens der Zahl x.
Der MySQL-Dialekt
ATN2(num1, num2) Der Arkustangens (Winkel) zwischen num1 und num2.
BIT_COUNT(num) Die Anzahl der Bits, die in einer Zahl 1 sind.
CEILING(x) Die kleinste Ganzzahl größer oder gleich dem Ausdruck
COS(x) Der Kosinus der Zahl x.
COT(x) Der Kotangens der Zahl x.
CRC32(expr) Die zyklische Prüfsumme eines Ausdrucks als 32-Bit-Wert.
DEGREES(x) Eine Umrechnung von Radiant in Grad.
num1 DIV num2 Eine Ganzzahldivision, funktioniert auch mit sehr großen
Zahlen (BIGINT).
EXP(x) Die Potenz zur Basis e.
FLOOR(x) Die größte Ganzzahl kleiner oder gleich dem angegebenen
numerischen Ausdruck.
GREATEST(x1,x2,..) Gibt den größten Wert der Liste zurück.
LEAST(x1,x2,...) Gibt den kleinsten Wert der Liste zurück.
LN(x) Der natürliche Logarithmus der Zahl x.
LOG(x), LOG(b, x) Der natürliche Logarithmus (ohne b) oder Logarithmus
zur Basis b.
LOG2(x) Der Logarithmus zur Basis 2 der Zahl x.
LOG10(x) Der dekadische Logarithmus der Zahl x.
Tabelle 11.5: Mathematische Funktionen
465

466
Datenbankprogrammierung
Funktion Beschreibung
MOD(n, m)
n % m
n MOD m
PI() Die Konstante π
POWER(x,y) Potenzrechnung (x hoch y).
Funktionen zur Steuerung des Kontrollflusses
Modulus, das ist der Rest einer Ganzzahldivision. Alle drei
Schreibweisen sind völlig identisch im Verhalten.
RADIANS(x) Umrechnung von Grad in Radiant der Zahl x.
RAND(x) Ermittelt eine Zufallszahl, x ist dabei optional und
bestimmt, wenn angegeben, den Startwert.
ROUND(x, d) Rundet Werte mathematisch, die Angabe der Stellen d ist
optional, ohne Angabe wird auf ganze Zahlen gerundet
SIGN(x) Das Vorzeichen der Zahl x, gibt -1, 0 oder 1 zurück.
SIN(x) Der Sinus der Zahl x.
SQRT(x) Die Quadratwurzel der Zahl x.
TAN(x) Der Tangens der Zahl x.
TRUNCATE(x, d) Gibt die Zahl x, gekürzt auf d Dezimalstellen, zurück.
Tabelle 11.5: Mathematische Funktionen (Forts.)
Funktion Beschreibung
ISNULL(expr) Wertet den Ausdruck expr aus und gibt 1 zurück, wenn der
Ausdruck NULL ist, sonst 0.
IFNULL(expr1, expr2) Wertet den Ausdruck expr1 aus und gibt expr2 zurück,
wenn der Ausdruck NULL ist, sonst expr1
IF(expr1,expr2,expr3) Wenn der Ausdruck expr1 Wahr ist, wird expr2 zurückgegeben,
sonst expr3
Tabelle 11.6: Diese Funktionen können die Auswahl Bedingungsabhängig ändern

Funktion Beschreibung
CASE val
WHEN cval THEN result
[WHEN cval THEN
result]
[ELSE result]
END
Funktionen für aggregierende Berechnungen
Der MySQL-Dialekt
Eine Mehrfachverzweigung, die etwa dem switch in PHP
entspricht. Der Wert val wird mit cval verglichen und bei
Gleichheit wird result zurückgegeben. Ansonsten wird mit
dem nächsten Zweig fortgesetzt.
NULLIF(expr1, expr2) Gibt NULL zurück, wenn expr1 gleich expr2 ist.
Tabelle 11.6: Diese Funktionen können die Auswahl Bedingungsabhängig ändern (Forts.)
Funktion Beschreibung
AVG(Ausdruck) Der Durchschnitt der Felder.
COUNT(Ausdruck) Die Anzahl der Felder.
COUNT(DISTINCT Ausdruck) Die Anzahl eindeutiger Felder.
COUNT (*) Repräsentiert die Anzahl aller Datensätze einer Tabelle.
GROUP_CONCAT(Ausdruck) Verbundene Zeichenkette aller Teilfelder.
SUM(Ausdruck) Die Summe der Felder (Addition).
MAX(Ausdruck) Das Feld mit dem größten Wert bestimmt das Ergebnis.
MIN(Ausdruck) Das Feld mit dem kleinsten Wert bestimmt das Ergebnis.
STD(Ausdruck)
STDDEV(Ausdruck)
Statistische Standardabweichung aller Werte der Liste
BIT_OR(Ausdruck) Führt ein bitweises Oder aus.
BIT_AND(Ausdruck) Führt ein bitweises Und aus.
BIT_XOR(Ausdruck) Führt ein bitweises Exklusives Oder aus.
Tabelle 11.7: Aggregat-Funktionen
467

468
Datenbankprogrammierung
Funktionen für Systeminformationen
Funktion Beschreibung
BENCHMARK(count, expr) Die Funktion führt einen Ausdruck expr so oft aus, wie count
angibt. Bei der Ausführung auf Kommandozeile wird die
gesamte Ausführungszeit ausgegeben. Man kann damit die
Effizienz seiner Ausdrücke testen.
CHARSET(str) Ermittelt, in welchem Zeichensatz eine Zeichenfolge
definiert ist.
COERCIBILITY(str) Ermittelt die Zugehörigkeit einer Zeichenfolge zu einem
Vergleichszeichensatz. Gibt einen Wert zwischen 0 und 3
zurück, wobei 0 explizite Vergleichbarkeit (höchster Rang),
1 keine Vergleichbarkeit, 2 implizite Vergleichbarkeit und 3
übergehende Vergleichbarkeit bedeutet.
COLLATION(str) Ermittelt den Vergleichszeichensatz, der die Sortierkriterien
bestimmt.
CONNECTION_ID() Nummer des Threads, der die aktuelle Verbindung verarbeitet.
CURRENT_USER() Aktueller MySQL-Nutzername mit Rechnernamen.
DATABASE() Gibt den Namen der aktuellen Datenbank aus.
USER() SYSTEM_USER()
SESSION_USER()
Aktueller MySQL-Nutzername
FORMAT(n, d) Formatiert eine Zahl n mit Kommata als Tausendergruppensymbol
und Punkt als Dezimaltrennzeichen mit d Dezimalstellen.
FOUND_ROWS() Anzahl der Reihen, so wie die Abfrage ohne LIMIT erfolgt
wäre, auch wenn LIMIT benutzt wurde.
LAST_INSERT_ID() Gibt den zuletzt erzeugten Wert einer AUTO_INCREMENT-Spalte
zurück.
VERSION() Gibt die Versionsnummer des MySQL-Server an.
Tabelle 11.8: Die System- und Informationsfunktionen

Funktion Beschreibung
Verschlüsselungsfunktionen
Der MySQL-Dialekt
GET_LOCK(str, to) Erzeugt eine Verriegelung (Lock) mit dem Namen str und
dem Zeitüberschreitungswert to.
RELEASE_LOCK(str) Gibt die Verriegelung str wieder frei.
IS_FREE_LOCK(str) Prüft, ob die Verriegelung str frei ist.
INET_ATON(expr) Die Numerische Entsprechung einer als Zeichenkette angegebenen
IP.
INET_NTOA(expr) Die IP-Nummer in Punktschreibweise aus einer Zahl.
UUID() Universal Unique Identifier für RPC-Verbindungen.
Tabelle 11.8: Die System- und Informationsfunktionen (Forts.)
Funktion Beschreibung
PASSWORD(str) Erzeugt ein Kennwort zur Zeichenkette str.
ENCRYPT(str, seed) Erzeugt ein Kennwort zur Zeichenkette str und mit dem
Startwert seed. Nutzt das Unix-Kommando crypt. Unter
Windows wird NULL zurückgegeben.
ENCODE(str, pass) Einfaches Verschlüsselungsverfahren auf Basis des Kennworts
pass. Zum Speichern sollten BLOB-Spalten verwendet
werden.
DECODE(str, pass)
SHA(str)
SHA1(str)
Erstellt einen Hashwert nach SHA bzw. SHA1.
MD5(str) Erstellt einen Hashwert nach MD5.
DES_ENCRYPT(str, key) Triple-DES-Ver- und Entschlüsselung. Kann nur genutzt
werden, wenn MySQL mit SSL-Unterstützung kompiliert
wurde.
DES_DECRYPT(str, key)
Tabelle 11.9: Verschlüsselungsfunktionen
469

470
Datenbankprogrammierung
Funktion Beschreibung
AES_ENCRYPT(str, key) AES-(Advanced Encryption Standard)-Ver- und Entschlüsselung.
Kann nur genutzt werden, wenn MySQL mit SSL-
Unterstützung kompiliert wurde.
AES_DECRYPT(str, key)
Tabelle 11.9: Verschlüsselungsfunktionen (Forts.)
Zeichenkettenfunktionen
Funktion Beschreibung
ASCII(str) Gibt den ASCII-Code des Zeichens str zurück. Hat str
mehr als ein Zeichen, wird nur das erste Zeichen überprüft.
CHAR(n,...) Wandelt die Zahlen n in die entsprechenden ASCII-Zeichen
um. Mehrere Argumente werden zu einer Zeichenkette
kombiniert.
CHAR_LENGTH(str)
CHARACTER_LENGTH(str)
Die echte Zeichenlänge einer Zeichenkette. Manche Zeichen
bestehen aus mehreren Bytes, sodass LENGTH die falsche
Länge liefert, während CHAR_LENGTH die erwartete
Zahl liefert.
COMPRESS(str) Komprimiert eine Zeichenfolgen nach dem ZIP-Verfahren.
CONCAT(str,...) Verknüpft alle Argumente zu einer Zeichenkette. Wenn
eines der Argumente NULL ist, wird NULL zurückgegeben.
ELT(n, str1, str2,...) Gibt die durch n bezeichnete Zeichenkette zurück: str1,
wenn n=1 usw.
EXPORT_SET(bit, on, off,
sep, number)
Tabelle 11.10: Zeichenkettenfunktionen
Exportiert einen Bitwert in eine Zeichenfolge, in der jedes
Zeichen ein Bit repräsentiert. Das Zeichen on bestimmt
Bits mit dem Wert 1, off steht für 0, sep bestimmt ein
Trennzeichen und number die Anzahl der Bits, die aus
dem Wert bit ausgewertet werden sollen.

Funktion Beschreibung
Der MySQL-Dialekt
FIELD(str,str1,str2..) Gibt die Position von str in str1, str2 usw. zurück: Wenn
str2=str, wird 2 zurückgegeben.
FIND_IN_SET(str, list) Gibt die Position von str in der Liste list zurück. Die Liste
besteht aus kommaseparierten Werten.
INSERT(str,st,len,new) Fügt len Zeichen der Zeichenkette new an der Stelle st der
Zeichenkette str ein.
INSTR(str, sub) Entspricht LOCATE, nur die Argumente sind vertauscht.
LCASE, LOWER(str) Wandelt in Kleinbuchstaben um.
LEFT(str, len) Gibt len Zeichen vom linken Ende der Zeichenkette str
zurück.
LENGTH(str) Länge der Zeichenketten str.
LOAD_FILE(name) Lädt eine Datei und gibt den Inhalt als Zeichenkette
zurück.
LOCATE(sub, str)
POSITION(sub IN str)
Bestimmt die Position der Zeichenkette sub in der Zeichenkette
str.
LPAD(str,len,pad) Fügt pad links an str an, gibt jedoch nur len Zeichen
zurück.
LTRIM(str) Entfernt Leerzeichen vom linken Ende.
MAKE_SET(bits,list) Wählt die Elemente der Liste list anhand der gesetzten
Bits in bits aus.
MID(str, pos, len) Gibt len Zeichen von Position pos an der Zeichenkette str
zurück.
QUOTE() Fügt Anführungszeichen hinzu und markiert solche
im Text mit einem Backslash. NULL-Werte werden als
Zeichenfolge "NULL" zurückgegeben.
REPEAT(str, count) Wiederholt die Zeichenkette str count mal.
REPLACE(str,from,to) Ersetzt alle Vorkommen von from in der Zeichenkette str
durch to.
Tabelle 11.10: Zeichenkettenfunktionen (Forts.)
471

472
Datenbankprogrammierung
Funktion Beschreibung
REVERSE(str) Dreht eine Zeichenkette um.
RIGHT(str, len) Gibt len Zeichen vom rechten Ende der Zeichenkette str
zurück.
RPAD(str,len,pad) Fügt pad rechts an str an, gibt jedoch nur len Zeichen
zurück.
RTRIM(str) Entfernt Leerzeichen vom rechten Ende.
SOUNDEX(str) Gibt die Lautfolge für str zurück.
SPACE(n) Gibt n Leerzeichen zurück.
SUBSTRING(str FROM len
SUBSTRING(str,pos,len)
SUBSTRING(str FROM pos
FOR len)
Andere Schreibweisen für RIGHT und MID.
SUBSTRING(str, pos) Gibt Teile von str ab Position pos zurück.
SUBSTRING_INDEX(str,
delimiter, count)
TRIM
BOTH|LEADING|TRAILING
rem FROM str
Gibt den linken Teil einer Zeichenkette zurück, nachdem
count mal das Zeichen delimiter aufgetreten ist.
BOTH entspricht TRIM, LEADING entspricht LTRIM, TRAILING
entspricht RTRIM, FROM ist optional, rem ist optional und
steht für das zu entfernende Zeichen, str wird bearbeitet.
TRIM(str) Entfernt Leerzeichen von beiden Enden der Zeichenkette
str.
UCASE, UPPER(str) Wandelt Zeichen in Großbuchstaben um.
UNCOMPRESS(str) Hebt ein Komprimierung wieder auf (siehe auch
COMPRESS).
Tabelle 11.10: Zeichenkettenfunktionen (Forts.)

Zahlenformatierungen
Funktion Beschreibung
Datums- und Zeitfunktionen
Der MySQL-Dialekt
CONV(n,from,to) Konvertiert Zahlen zwischen verschiedenen Zahlenbasen.
Zurückgegeben wird immer eine Zeichenkette mit der ermittelten
Zahl. n ist die Zahl, from die ursprüngliche Zahlenbasis, to
die Zielbasis.
BIN(n) Gibt eine Zahl n als Zeichenkette im Binärformat zurück,
BIN(7) ergibt beispielsweise »111«.
BIT_LENGTH(n) Gibt die Länge einer Zeichenkette in Bits zurück.
OCT(n) Gibt eine Zahl n als Zeichenkette im Oktalformat zurück.
HEX(n) Gibt eine Zahl n als Zeichenkette im Hexadezimalformat
zurück.
UNHEX() Umkehrfunktion zu HEX
Tabelle 11.11: Zeichenkettenfunktionen für Zahlen
Funktion Beschreibung
DAYOFWEEK(date) Der Tag der Woche, 1 ist Sonntag (1 – 7).
WEEKDAY(date) Der Tag der Woche, 0 ist Montag (0 – 6).
DAYOFMONTH(date) Der Tag des Monats (1 – 31).
DAYOFYEAR(date) Der Tag des Jahres (1 – 366).
MONTH(date) Der Monat (1 – 12).
DAYNAME(date) Der Wochentag (englisch, ausgeschrieben).
MONTHNAME(date) Der Monat (englisch, ausgeschrieben).
QUARTER(date) Das Quartal (1 – 4).
Tabelle 11.12: Datums- und Zeitfunktionen
473

WEEK(date)
WEEK(date, first)
474
Datenbankprogrammierung
Funktion Beschreibung
YEAR(date) Das Jahr (1000 – 9999).
HOUR(time) Die Stunde (0 – 23).
MINUTE(time) Die Minute (0 – 59).
SECOND(time) Die Sekunde (0 – 59).
Die Woche im Jahr (0 – 52). Das optionale Argument
first bestimmt, welcher Wochentag als Beginn gezählt
wird. 0 entspricht dem Sonntag.
PERIOD_ADD(p,n) Addiert n Monate zur Periode p. Die Periode wird im Format
YYYYMM oder YYMM erwartet. Zurückgegeben wird
immer die Langform YYYYMM.
PERIOD_DIFF(p1,p2) Gibt die Differenz in Monaten zwischen p1 und p2
zurück
TO_DAYS(date) Die Anzahl der Tage seit dem Jahr 0.
FROM_DAYS(dn) Ermittelt ein Datum aus der Tageszahl dn.
CURDATE()
CURRENT_DATE
CURTIME()
CURRENT_TIME
NOW()
SYSDATE()
CURRENT_TIMESTAMP
Das aktuelle Datum (Systemzeit des Servers).
Die aktuelle Zeit (Systemzeit des Servers)
Datum und Uhrzeit (Systemzeit des Servers)
UNIX_TIMESTAMP Unix Timestamp (Sekunden in GMT seit den 1.1.1970, 0
Uhr). Die Funktion wird auch von der Windows-Version
unterstützt.
FROM_UNIXTIME(stp) Gibt ein Datum entsprechend dem Unix Timestamp stp
zurück.
FROM_UNIXTIME(stp,
format)
Tabelle 11.12: Datums- und Zeitfunktionen (Forts.)
Gibt ein Datum entsprechend dem Unix Timestamp stp
zurück. Das Datum ist entsprechend format formatiert.

Funktion Beschreibung
Datumsformatierungen
Der MySQL-Dialekt
SEC_TO_TIME(sec) Rechnet die Angabe in Sekunden in das Format
HH:MM:SS um.
TIME_TO_SEC(time) Rechnet eine Zeitangabe in Sekunden um.
Tabelle 11.12: Datums- und Zeitfunktionen (Forts.)
Typ-Konstante Bedeutung Formatangabe
SECOND Sekunde ss
MINUTE Minute mm
HOUR Stunde hh
DAY Tag DD
MONTH Monat MM
YEAR Jahr YY
MINUTE_SECONDS Minute und Sekunde mm:ss
HOUR_MINUTE Stunde und Minute hh:mm
DAY_HOUR Tag und Stunde DD hh
YEAR_MONTH Jahr und Monat YY-MM
HOUR_SECOND Stunde, Minute, Sekunde hh:mm:ss
DAY_MINUTE Tag, Stunde, Minute DD hh:mm
DAY_SECONDS Tag, Stunde, Minute, Sekunde DD hh:mm:ss
Tabelle 11.13: Zeittypen für Datumsberechnungen
475

476
Datenbankprogrammierung
Funktion Berechnung
DATE_FORMAT(date, format) Formatiert den Wert date mit dem Format format, dessen
Elemente wurden in der vorherigen Tabelle bereits
beschrieben.
TIME_FORMAT(time, format) Formatiert den Wert time mit dem Format format, dessen
Elemente wurden in der vorherigen Tabelle bereits
beschrieben.
Tabelle 11.14: Datumsformatierungen
Code Bedeutung (Wertebereich) Code Bedeutung (Wertebereich)
%M Monatsname (January – December) %k Stunde (0 – 23) ohne führende Null
%W Wochenname (Monday – Sunday) %h Stunde (01 – 12) mit führender
Null
%D Monat mit engl. Suffix
(1 st , 2 nd , 3 rd usw.)
%I Stunde (1 – 12) ohne führende Null
%Y Jahr mit 4 Stellen %l Minuten (0 – 59)
%y Jahr mit 2 Stellen %i Minuten (00 – 59) mit führender
Null
%a Abgekürzter Wochentag
(Mon – Sun)
%n Zeit, 12-Stunden-Format: hh:mm:ss
AM|PM
%d Tag des Monats (00 – 31) %T Zeit, 24-Stunden-Format: hh:mm:ss
%e Tag des Monats (0 – 31) %S Sekunde (00 – 59) mit führender
Null
%m Monat (00 – 12) mit führender Null %s Sekunde (0 – 59)
%c Monat (0 – 12) ohne führende Null %p AM oder PM
%b Abgekürzter Monatsname
(Jan–Dec)
%w Wochentag
(0=Sonntag, 6=Samstag)
%j Tag des Jahres (000 – 366) %U Woche, Sonntag ist der erste Tag
der Woche (00 – 52)
Tabelle 11.15: Platzhalter für Datumsformatierungen

Erste Schritte mit MySQL und MySQLi
Code Bedeutung (Wertebereich) Code Bedeutung (Wertebereich)
%H Stunde (00 – 23) mit führender
Null
%% Prozentzeichen
Tabelle 11.15: Platzhalter für Datumsformatierungen (Forts.)
11.4 Erste Schritte mit MySQL und MySQLi
MySQLi (MySQL improved) ist eine neue Erweiterung von PHP zur besseren
Unterstützung von MySQL. Im Bundle mit dem neuen, objektorientierten Ansatz
und der neuen MySQL-Version 4 ergibt sich ein außerordentlich leistungsfähiges
System.
MySQLi vorbereiten
Seit PHP5 gehört die MySQL-Unterstützung aus rechtlichen Gründen nicht mehr
zum integrierten Paket. In PHP 4 waren die MySQL-Module noch fest in den
Kern kompiliert. Mit der Version 5 ist nun alles wieder wie bereits bei PHP3 – man
muss die MySQL-Dateien zusätzlich einbinden. Auf dem Entwicklungssystem
unter Windows erfolgt dies durch das Auskommentieren der entsprechenden Zeile
in der Datei php.ini:
extension=php_mysql.dll
%u Woche, Montag ist der erste Tag der
Woche (00 – 52)
Dann haben Sie noch die Wahl, statt der alten MySQL-Module die neuen, objektorientierten
MySQLi-Dateien zu nutzen:
extension=php_mysqli.dll
In diesem Buch werden die neuen Module vorgestellt. Über weite Strecken ist
Syntax und Nutzung praktisch identisch, sodass eine Umstellung nicht schwer ist.
477

478
Datenbankprogrammierung
Verbindung testen
Nach der Installation von MySQL steht ein kurzer Test an, ob alles geklappt hat.
Unter XP muss dazu der entsprechende Dienst gestartet sein, unter Linux der
MySQL-Daemon.
Dann kommt folgendes Skript zum Zuge, um alles zu testen:
Listing 11.1: mysqliconnect.php – Ein erster Versuch mit MySQL und PHP
$mysqli = new mysqli("localhost", "root", "", "test");
$query = $mysqli->query("SELECT version() AS version");
$result = $query->fetch_assoc();
echo "Wir arbeiten mit MySQL Version {$result['version']}";
$mysqli->Close();
Das Skript geht davon aus, dass das Standardkennwort (leer) und der Benutzername
(»root«) nicht geändert wurden und dass die Datenbank auf derselben
Maschine wie der Webserver läuft (»localhost«). Haben Sie eine andere Installation,
müssen Sie die Daten in der ersten Zeile entsprechend anpassen.
Die Klasse mysqli1 stellt nun den Zugriff auf die neuen Funktionen bereit. Im Beispiel
führt die Instanziierung des Objekts in $mysqli auch gleich zum Öffnen der
Verbindung. Die SQL-Abfrage ermittelt dann die Versionsnummer des Datenbankservers:
SELECT version() AS version
Die Methode zur Abfrage der Datenbank heißt query:
$mysqli->query()
Wenn Ergebnisse entstehen, kann man diese mit fetch_assoc in ein assoziatives
Array überführen:
$result = $query->fetch_assoc();
Der Zugriff auf das Array entspricht wieder einfachem PHP, als Schlüsselname
taucht der Alias der SQL-Abfrage auf.
Hat alles geklappt, wird die Verbindung wieder geschlossen. Die Ausgabe sollte
nun in etwa wie nachfolgend gezeigt aussehen:
1 Es gibt auch nach wie vor einen prozeduralen Zugriff, der hier nicht weiter betrachtet wird.

Erste Schritte mit MySQL und MySQLi
Nun kann man voll loslegen und praktisch mit der Datenbank arbeiten.
Die folgenden Skripte wurden mit MySQL 4.1 getestet. Die einwandfreie
Funktionsweise von MySQL 5 kann derzeit nicht garantiert werden.
Außerdem ist mindestens die Version PHP5.1 für die MySQLi-
Erweiterungen zu empfehlen. Die erste Final, PHP5.0.0, versagte bei
einigen Abfragen.
Genereller Datenbankzugriff
Für die folgenden Skript wird immer wieder dieselbe Methode zum Datenbankzugriff
verwendet und als Include-Datei eingebunden. Dies erleichtert Änderungen:
Listing 11.2: mysqli.inc.php – Inhalt der Include-Datei, noch ohne Fehlermanagement
Die Variable $mysqli wird in allen Skripten dieses Kapitels verwendet. Das Einbinden
erfolgt über folgende Zeile:
include("mysqli.inc.php");
Diese Anweisung wird nicht in jedem Listing immer wieder abgebildet.
Mit der Datenbank arbeiten
Abbildung 11.1:
Alles neu: PHP5 mit MySQLi und
MySQL 5.0-alpha
Um mit der Datenbank arbeiten zu können, werden zuerst Tabellen benötigt.
Diese können Sie entweder mit einem Werkzeug oder per Skript anlegen. Als
Werkzeug kommen unter Windows das MySQLCC (MySQL Control Center)
oder phpMyAdmin in Frage. Dieser Abschnitt zeigt alle nötigen Schritte in Skriptform.
479

480
Datenbankprogrammierung
Tabellen vorbereiten
Zuerst werden die passenden Tabellen benötigt. MySQL verfügt über eine sehr
gute Funktion beim Anlegen von Tabellen. Es kann prüfen, ob die Tabelle bereits
existiert. Damit muss man sich erstmal nicht darum kümmern, ob das Skript
bereits aufgerufen wurde.
Die beiden Tabellen, die hier benötigt werden, enthalten die Bundesländer und
Wetterdaten. Sie haben folgende Definitionen:
Listing 11.3: Definition der Wetter-Tabelle
CREATE TABLE IF NOT EXISTS wetter (
ID bigint(20) NOT NULL auto_increment,
Stadt varchar(100) NOT NULL default '',
Hoch int(2) NOT NULL default '0',
Tief int(2) NOT NULL default '0',
BundeslandID bigint(20) default '0',
PRIMARY KEY (ID),
KEY StadtIndex (Stadt)
);
Listing 11.4: Definition der Tabelle der Bundesländer
CREATE TABLE IF NOT EXISTS bundesland (
ID int(2) NOT NULL auto_increment,
Name varchar(30) NOT NULL default '',
PRIMARY KEY (ID)
);
Das folgende PHP-Skript nutzt diese Anweisungen, um die Tabellen anzulegen.
Die Angabe von IF NOT EXISTS verhindert, dass die Tabellen erneut erzeugt werden,
wenn sie bereits existieren.
Listing 11.5: mysqlicreatetables.php – Die benötigten Datentabellen erzeugen
$tables['Wetter'] =

Erste Schritte mit MySQL und MySQLi
PRIMARY KEY (ID),
KEY StadtIndex (Stadt)
);
TABLE1;
$tables['Bundesland'] =

482
Datenbankprogrammierung
echo "Fehler: {$mysqli->error}";
Provozieren Sie einen Fehler, indem Sie die Syntax der SQL-Anweisung ein
wenig »unqualifiziert« verändern. Sie erhalten dann beispielsweise folgende Ausgabe:
Die Tabellen füllen
Es gibt mehrere Wege, Tabellen zu füllen:
Formulare werden verwendet – dann gibt der Benutzer die Daten von Hand
ein.
Abfrage einer anderen Datenbank oder Tabelle.
Durch das Auslesen von Textdateien.
Durch den Import von XML.
Für die Generierung der Bundesländer bietet es sich an, eine Textdatei zu verwenden,
die die Namen enthält. Das ist einfacher als alle INSERT-Anweisungen aufzuschreiben.
Die nötigen Techniken wurden alle bereits behandelt. Zuerst die
Textdatei:
Listing 11.6: bl.txt im Verzeichnis /data – Textdatei mit Bundesländern
'Baden-Württemberg'
'Bayern'
'Berlin'
'Brandenburg'
'Bremen'
'Hamburg'
'Hessen'
'Mecklenburg-Vorpommern'
'Niedersachsen'
'Nordrhein-Westfalen'
'Rheinland-Pfalz'
'Saarland'
'Sachsen'
Abbildung 11.3:
Ausgabe mit
Fehlermeldung

'Sachsen-Anhalt'
'Schleswig-Holstein '
'Thüringen'
Erste Schritte mit MySQL und MySQLi
Auch für ein paar Wetterdaten wurde eine Textdatei vorbereitet. Da hier mehrere
Spalten existieren, wurde ein Trennzeichen definiert, das Komma. Die erste Zeile
enthält die Feldnamen:
Listing 11.7: wetter.txt im Verzeichnis /data – Textdatei mit Wetterdaten
Stadt,Hoch,Tief,BundeslandID
'Berlin',22,12,3
'Hamburg',20,10,6
'Stuttgart',24,18,1
'München',23,17,2
'Regensburg',23,19,2
'Dresden',19,12,13
'Leipzig',19,12,13
'Wittenberge',19,12,4
'Angermünde',18,12,4
'Frankfurt/Oder',19,13,4
'Cottbus',22,17,4
'Hof',19,14,2
'Nürnberg',19,11,2
'Würzburg',19,16,2
'Augsburg',22,18,2
Die einfachen Anführungszeichen in den Datendateien vereinfachen
die Verarbeitung erheblich. Dies ist hier vor allem gemacht worden, um
die ersten Skripte überschaubar zu halten. In der Praxis gibt es freilich
Lösungen, die beliebige Daten korrekt einfügen.
Das folgende Skript zeigt eine mögliche Lösung:
Listing 11.8: mysqliinsert.php: Programmgesteuert Datensätze einfügen
$path = 'data';
$imports = array('Wetter' => 'wetter.txt',
'Bundesland' => 'bl.txt');
if (is_object($mysqli))
{
foreach ($imports as $table => $file)
483

484
{
Datenbankprogrammierung
$content = file("$path/$file");
$fields = array_shift($content);
$mysqli->query("TRUNCATE $table");
foreach ($content as $line)
{
$sql = "INSERT INTO $table ($fields) VALUES ($line)";
$result = $mysqli->query($sql);
if ($result === FALSE)
{
echo "Konnte Anweisung nicht ausführen";
echo "Fehler: {$mysqli->error}";
}
else
{
echo "Anweisung ausgeführt: $sql";
}
}
}
}
Dieses Skript beginnt mit der Definition eines Arrays, das die Tabellennamen und
Dateinamen enthält und miteinander verknüpft:
$imports = array('Wetter' => 'wetter.txt', 'Bundesland' => 'bl.txt');
Der Vorteil der vorgestellten Lösung liegt in ihrer leichten Erweiterbarkeit. Um
weitere Tabelle mit Daten zu beschicken, muss man lediglich dieses Array erweitern
und natürlich die Daten bereitstellen.
Dann durchläuft die erste foreach-Schleife alle Elemente dieses Arrays:
foreach ($imports as $table => $file)
So erhält man Tabellen- und Dateinamen. Dann werden die Daten in ein weiteres
Array überführt, wozu die Funktion file hervorragend geeignet ist:
$content = file("$path/$file");
Die erste Zeile enthält die Feldnamen. Das erste Element eines Arrays lässt sich
mit array_shift extrahieren, sodass in $fields die Feldliste steht:
$fields = array_shift($content);

Erste Schritte mit MySQL und MySQLi
Dann wird die jeweils zu bearbeitende Tabelle gelöscht, um zu verhindern, dass
bei mehrfachem Aufruf des Skripts die Daten doppelt erscheinen:
$mysqli->query("TRUNCATE $table");
Hier ist etwas Vorsicht angebracht! Wenn Sie mit anderen Skripten der
Wetter-Tabelle weitere Daten hinzugefügt haben, gehen diese durch
den Aufruf von TRUNCATE unwiderruflich verloren.
Für den Rest der Datei (array_shift extrahiert nicht nur, sondern entfernt auch
gleich die erste Zeile) werden nun die Zeilen gelesen und zu INSERT-Anweisungen
verarbeitet:
foreach ($content as $line)
$sql = "INSERT INTO $table ($fields) VALUES ($line)";
Der Aufbau einer SQL-Anweisung in einer eigenen Variable ist sinnvoll, um das
dynamisch konstruierte Gebilde leicht überwachen zu können. Die fertige Anweisung
wird dann an den SQL-Server gesendet:
$result = $mysqli->query($sql);
Zuletzt folgt noch die bereits bekannte Fehlerausgabe.
Mit den so erstellten Tabellen kann nun gearbeitet werden. Die folgenden
Abschnitte behandeln die bereits im Einführungsteil zu SQL präsentierten Abfragen
im praktischen Kontext eines PHP-Skripts.
Einfache Abfragen
Die Abfragetechnik in PHP folgt immer ein und demselben Schema:
1. Verbinden mit der Datenbank.
2. Senden der Abfrage und Erhalt des Ergebnisobjekts.
3. Überführen des Ergebnisobjekts in ein Array.
4. Ausgaben oder Verarbeiten des Arrays.
In selteneren Fällen werden nur einzelne Daten abgefragt und ohne Arrays gearbeitet.
Aufgrund der starken Arrayfunktionen in PHP ist die Nutzung jedoch meist
angebracht.
485

486
Datenbankprogrammierung
Listing 11.9: mysqlselectfrom.php – Einfache Abfrage mit Ausgabe
if (is_object($mysqli))
{
$sql = "SELECT Stadt, Hoch, Tief FROM Wetter";
$result = $mysqli->query($sql);
while ($rs = $result->fetch_assoc())
{
echo

Komplexe Abfragen
Erste Schritte mit MySQL und MySQLi
Abbildung 11.4:
Ausgabe einer Datenbanktabelle in formatiertem
HTML
Als nächstes sollen die durchschnittlichen Höchst- und Tiefsttemperaturen ermittelt
werden. Dazu eignet sich die Aggregat-Funktion AVG:
Listing 11.10: mysqlselectavgfrom.php – Durchschnittswerte ermitteln
$sql = "SELECT AVG(Hoch) AS MittelHoch,
AVG(Tief) AS MittelTief FROM Wetter";
$result = $mysqli->query($sql);
$data = $result->fetch_object();
echo "Die mittlere Höchsttemperatur
beträgt {$data->MittelHoch} °C";
echo "Die mittlere Tiefsttemperatur
beträgt {$data->MittelTief} °C";
487

488
Datenbankprogrammierung
Eingesetzt wird hier die Methode fetch_object. Sie gibt den aktuellen Datensatz
als Objekt zurück, oder FALSE, falls keine Daten mehr da sind. Da hier nur skalare
Werte abgefragt werden, ist eine Schleife nicht erforderlich.
Das Objekt enthält eine Eigenschaft für jedes Feld, der Name entspricht auch dem
Feldnamen:
$data->MittelHoch
Im Beispiel wurden die Namen gegenüber den originalen Spaltennamen noch
durch den Alias-Operator AS geändert. Das ist sinnvoll, wenn die Spaltennamen
selbst auch abgefragt werden sollen.
Abbildung 11.5:
Berechnung der Durchschnittstemperaturen
Das folgende Beispiel zeigt, wie gleichzeitig die höchsten und niedrigsten Werte
ermittelt werden.
Listing 11.11: mysqlselectmimaxfrom.php – Minimale und maximale Temperaturen
$sql = "SELECT AVG(Hoch) AS MittelHoch,
AVG(Tief) AS MittelTief,
MIN(Tief) AS Tief,
MAX(Hoch) AS Hoch
FROM Wetter";
$result = $mysqli->query($sql);
$data = $result->fetch_object();
echo "Die mittlere Höchsttemperatur
beträgt {$data->MittelHoch} °C";
echo "Die mittlere Tiefsttemperatur
beträgt {$data->MittelTief} °C";
echo "Die höchste Höchsttemperatur beträgt {$data->Hoch} °C";
echo "Die niedrigste Tiefsttemperatur beträgt {$data->Tief} °C";
Das Prinzip der Abfrage entspricht hier dem vorhergehenden Beispiel.
Abbildung 11.6:
Der höchste und niedrigste Wert werden
ermittelt

Erste Schritte mit MySQL und MySQLi
Bei der Ausgabe fällt auf, dass die Kommastellen wenig praxistauglich sind. Bevor
Sie jetzt auf die Idee kommen, dafür printf oder number_format einzusetzen, ist
ein Blick in die Funktionssammlung von MySQL interessant. Hier wird man bei
ROUND fündig:
Listing 11.12: mysqlselectroundfrom.php – Rundung der Ausgabewerte vor der Ausgabe
$sql = "SELECT ROUND(AVG(Hoch),2) AS MittelHoch,
ROUND(AVG(Tief),2) AS MittelTief
FROM Wetter";
$result = $mysqli->query($sql);
$data = $result->fetch_object();
echo "Die mittlere Höchsttemperatur
beträgt {$data->MittelHoch} °C";
echo "Die mittlere Tiefsttemperatur
beträgt {$data->MittelTief} °C";
Diese Ausgabe ist schon eher überzeugend, allerdings muss MySQL vorerst bei der
sprachabhängigen Darstellung passen:
Verknüpfungen abfragen
Abbildung 11.7:
Gerundete Temperaturwerte
Als nächstes soll wieder eine Ausgabe der Temperaturen der einzelnen Städte
erfolgen, jedoch mit der Angabe des jeweiligen Bundeslandes.
Listing 11.13: mysqlselectjoin1.php: Zusatzinformationen aus verknüpfter Tabelle holen
$sql = "SELECT Stadt, Hoch, Tief, Name AS Bundesland
FROM Wetter W JOIN Bundesland B
ON W.BundeslandID = B.ID";
$result = $mysqli->query($sql);
while($rs = $result->fetch_object())
{
echo "{$rs->Stadt} ({$rs->Bundesland}):";
echo "&uarr; {$rs->Hoch}°C, &darr; {$rs->Tief}°C";
}
Die Abfrageform in PHP ändert sich hier nicht – die gesamte Arbeit erledigt die
SQL-Anweisung. Die Ausgabe zeigt ein für den geringen Aufwand durchaus
489

490
Datenbankprogrammierung
respektables Ergebnis (die Pfeile werden durch die Entitäten &uarr; und &darr;
erzeugt):
Abbildung 11.8:
Informationen aus zwei Tabellen: Städte und Bundesländer
Etwas kniffliger wird es, wenn die Verknüpfung mit Aggregierungen verbunden
werden soll. So könnte man die mittleren Temperaturen in einem Bundesland
abfragen. Dazu werden die Städte aus demselben Bundesland gruppiert und aus
den Werten einer Gruppe der Durchschnittswert berechnet.
Listing 11.14: mysqlselectjoingroup.php – Mittlere Temperaturen nach Bundesland
$sql = "SELECT ROUND(AVG(Hoch),2) AS MittelHoch,
ROUND(AVG(Tief),2) AS MittelTief,
Name AS Bundesland

Referenz MySQLi
FROM Wetter W JOIN Bundesland B
ON W.BundeslandID = B.ID
GROUP BY W.BundeslandID
";
$result = $mysqli->query($sql);
while($rs = $result->fetch_object())
{
echo "{$rs->Bundesland}:";
echo "&uarr; {$rs->MittelHoch}°C,";
echo "&darr; {$rs->MittelTief}°C";
}
Der Trick besteht hier in der Anwendung von GROUP BY. Erst nach der Gruppierung
werden die Aggregat-Funktionen zur Berechnung des Durchschnitts angewendet.
11.5 Referenz MySQLi
Alle Methoden werden auf einer Instanz der Klasse mysqli oder auf einem Resultatobjekt
ausgeführt, beispielsweise:
$mi = new mysqli('localhost', 'root', '', 'test');
$mi->commit();
Alternativ ist immer auch der direkte prozedurale Aufruf möglich:
mysqli_commit();
Abbildung 11.9:
Mittelwerte der Temperaturen pro Bundesland
491

492
Datenbankprogrammierung
Eigenschaft Beschreibung
affected_rows Anzahl der Datensätze, die von der letzten Anweisung betroffen
waren (nur für UPDATE/INSERT/REPLACE, nicht jedoch für
SELECT).
errno Die Nummer des Fehlercodes.
error Eine Beschreibung des Fehlers (englisch).
field_count Anzahl der Spalten, die die letzte Abfrage zurückgegeben hat.
host_info Informationen über den Server und die Art der Verbindung, beispielsweise
»localhost via TCP/IP«.
info Informationen über die letzte Abfrage.
insert_id Die letzte durch INSERT in einem AUTO_INCREMENT-Feld erzeugte
ID.
protocol_version Die Version des MySQL-Protokolls (aktuell: 10).
sqlstate Status einer vorher gesendeten Abfrage.
thread_id ID des Threads in dem die Abfrage abgearbeitet wird .
thread_safe Ermittelt, ob Threadsicherheit besteht.
warning_count Anzahl der Warnungen, die die letzte Abfrage auslösten.
Tabelle 11.16: Eigenschaften des MySQLi-Objekts
Methode Beschreibung
autocommit Schaltet die automatische Bestätigung von Transaktionen ein
oder aus.
change_user Ändert den Benutzer für die aktuelle Verbindung.
character_set_name Gibt den aktuellen Zeichensatz zurück.
close Schließt die Verbindung.
commit Bestätigt die aktuelle Transaktion.
Tabelle 11.17: Methoden des MySQLi-Objekts

Methode Beschreibung
Referenz MySQLi
connect Öffnet eine neue Verbindung zum MySQL-Server.
get_client_info Gibt Informationen über die verwendet MySQL-Version
zurück.
get_client_version Gibt Informationen über den MySQL-Client zurück.
get_host_info Gibt Informationen über den Server und die Verbindung
zurück.
init Vorbereiten eines MySQLi-Objekts für spätere Verwendung.
info Gibt die automatisch erstellte ID der letzten Abfrage zurück.
kill Versucht den von MySQL belegten Thread zu beenden.
multi_query Sendet eine Abfrage an die Datenbank.
more_results Ermittelt, ob weitere Ergebnissätze von Mehrfachabfragen vorhanden
sind.
next_result Nächste Ergebnissätze von Mehrfachabfragen abholen.
options Setzt verschiedene Optionen.
ping Sendet einen Ping zur Kontrolle der Verbindung an den Server.
prepare Kann eine Abfrage vorbereiten. Vorbereitete Abfragen sind
schneller bei wiederholter Ausführung.
query Eine Abfrage direkt an den Server senden.
real_connect Kann eine Verbindung öffnen.
real_query Kann eine Abfrage ausführen.
rollback Kann eine Transaktion rückabwickeln.
select_db Wird eine andere Datenbank als Standard auswählen. Entspricht
dem SQL-Befehl USE.
send_query Sendet eine Abfrage an die Datenbank.
sqlstate SQL Status und Fehlercodes einer vorhergehenden Abfrage
ermitteln.
Tabelle 11.17: Methoden des MySQLi-Objekts (Forts.)
493

494
Datenbankprogrammierung
Methode Beschreibung
ssl_set Kann eine gesicherte SSL-Verbindung aufbauen.
stat Der aktuellen Status des Systems.
stmt_init Initialisiert eine Abfrage und gibt ein Objekt zurück, mit dem
diese Abfrage gesteuert werden kann. Tabelle 11.18 und Tabelle
11.19 zeigen die Eigenschaften und Methoden dieses Objekts.
thread_safe Ermittelt, ob Threadsicherheit gegeben ist oder nicht.
use_result Bereitet einen Ergebnissatz zur Verwendung vor.
Tabelle 11.17: Methoden des MySQLi-Objekts (Forts.)
Eigenschaft Beschreibung
affected_rows Anzahl der von der Anweisung betroffenen Datensätze. Damit
kann man den Erfolg von UPDATE oder DELETE überwachen.
errno Der letzte Fehlercode.
error Eine Beschreibung des Fehlers (englisch).
param_count Die Anzahl der Parameter.
sqlstate Ermittelt SQL Status und Fehlercodes einer vorhergehenden
Abfrage.
ssl_set Kann eine gesicherte SSL-Verbindung aufbauen.
Tabelle 11.18: Eigenschaften des Anweisungs-Objekts
Methode Beschreibung
bind_param Erstellt Parameter für die Anweisung.
bind_result Erstellt ein Ergebnisobjekt.
close Schließt die Verbindung.
data_seek Setzt den Ergebnissatzzeiger auf einen bestimmten Datensatz.
Tabelle 11.19: Methoden des Anweisungs-Objekts

Methode Beschreibung
execute Führt die Anweisung aus.
Referenz MySQLi
fetch Holt den Ergebnissatz mit verschiedenen Optionen.
fetch_result Holt den Ergebnissatz.
get_metadata Holt globale Informationen zur Anweisung.
prepare Bereitet die Anweisung vor (vorab Kompilierung).
send_long_data Sendet große Datenpakete.
store_result Speichert die Ergebnisse zwischen.
Tabelle 11.19: Methoden des Anweisungs-Objekts (Forts.)
Eigenschaft Beschreibung
current_field Ermittelt das aktuelle Feld des Ergebnissatzes.
field_count Ermittelt die Anzahl der Felder.
length Ermittelt die Länge (Breite) eines Feldes.
num_rows Ermittelt die Anzahl der Reihen im Ergebnissatz.
Tabelle 11.20: Eigenschaften des Ergebnis-Objekts
Methode Beschreibung
close Schließt die Verbindung.
data_seek Setzt den Ergebnissatzzeiger auf eine bestimmte Reihe.
fetch_field_direct Holt direkt ein bestimmtes Feld.
fetch_field Holt das nächste Feld einer Liste.
fetch_fields Holt Felder als Array.
fetch_lengths Ermittelt die Breite des aktuellen Feldes.
fetch_object Holt die Reihe als Objekt. Felder sind nun Eigenschaften.
Tabelle 11.21: Methoden des Ergebnis-Objekts
495

496
Datenbankprogrammierung
Methode Beschreibung
fetch_row Holt die Reihe als numerisches (einfaches) Array.
fetch_assoc Holt die Reihe als assoziatives Array. Die Schlüssel sind die Spaltennamen.
field_seek Setzt den Zeiger auf ein spezifisches Feld.
Tabelle 11.21: Methoden des Ergebnis-Objekts (Forts.)
11.6 Kontrollfragen
1. Warum sollte die neue Bibliothek MySQLi anstatt der alten eingesetzt werden?
2. Was versteht man unter Normalisierung?
3. Sie müssen bei der Ausgabe von Daten aus einer MySQL-Datenbank Datumsformate
anpassen und \n in umwandeln. Wie gehen Sie vor?
4. Wie würden Sie eine Abfrage formulieren, bei der aus zwei Tabellen Daten
zugleich entnommen werden müssen? Welche Voraussetzungen müssen die
Tabellen erfüllen?

Die integrierte
Datenbank SQLite
12

498
Die integrierte Datenbank SQLite
Nicht immer muss es MySQL sein. Statt einer ausgewachsenen Datenbank reicht
oft ein einfacheres System. Die Lücke zwischen einfachen Textdateien als Datenspeicher
und einem relationalen Datenbankmanagementsystem schließt in PHP5
das SQLite-Modul.
12.1 Hintergrund
SQLite ist fest in PHP integriert. Ein weiteres Modul oder Treiber sind nicht erforderlich.
Sie können deshalb immer davon ausgehen, dass jede PHP5-Installation
wenigstens SQLite bereitstellt. Wenn kleine Datenbankprojekte erstellt werden,
die auf Funktionen großer Datenbankmanagementsysteme nicht angewiesen sind,
ist SQLite völlig ausreichend. Allerdings muss man sich auch der Grenzen bewusst
sein, um gegebenenfalls rechtzeitig wechseln zu können.
SQLite ist eine einfache Datenbank-Lösung, die als »Public Domain« entwickelt
wurde. Dies ist eine sehr freie Art der Softwareverteilung, bei der völlig auf Rechte
und Lizenzen verzichtet wird. Der Code wird jedermann ohne Beschränkungen
zur Verfügung gestellt.
Der Entwickler ist D. Richard Hipp der Firma Hipp, Wyrick & Company, Inc. Die
neueste Version wird unter folgender Adresse bereitgestellt:
http://www.hwaci.com/sw/sqlite
SQLite soll dabei kein Ersatz für MySQL oder PostgreSQL sein. Nur einfachste
Anwendungen werden auf größere Datenbank verzichten können. Wenn Sie
bereits einige Erfahrung mit Datenbanken haben und Oracle oder MS SQL Server
kennen, wird Ihnen MySQL möglicherweise primitiv vorgekommen sein. Dass
es noch deutlich einfacher geht, zeigt SQLite. Dafür profitiert auch SQLite von
der Vereinfachung. Zugriffe sind extrem schnell und die Speicherung der Daten
nutzt den Speicher effektiv. Einige Benchmarks versprechen etwa doppelte
Geschwindigkeit gegenüber dem bereits recht flotten MySQL.
Einige der typischen Aufgaben, denen SQLite ohne weiteres gewachsen ist, sind:
Konfigurationsdaten einer Applikation speichern.
Serialisierte Objekte zur Mitnahme von Seite zu Seite speichern.
Speicherung von Anmeldeinformationen.
Ein Gästebuch.
Eine News-Site, auf der aktuelle Nachrichten zu finden sind.

Vor- und Nachteile
Ein komplettes Content Management System oder größere Foren dürften allein
aufgrund der komplexeren SQL-Abfragen mit MySQL besser bedient sein.
12.2 Vor- und Nachteile
Bevor Sie intensiv in SQLite einsteigen, sollten Sie einige technische Hintergründe
und deren Auswirkungen auf Projekte kennen.
Wann SQLite vorteilhaft ist
SQLite bietet sich an, wenn einfache Projekte völlig unabhängig von der PHP5-
Konfiguration laufen müssen. Die Zugriffe sollten vorrangig lesend erfolgen.
Außerdem sollte PHP5 nur auf einem einzigen System laufen, nicht im Cluster
oder mit Lastverteilung. Der Anspruch an die Sicherheit der Daten sollte eher
gering sein oder eine häufige Datensicherung ist vorhanden.
Vorteilhaft ist SQLite deshalb, weil sie vielen Entwicklern mit wenig Datenbankerfahrung
die Chance bietet, ohne großen Aufwand eine datenbankgestützte Applikation
zu bauen. Denn mit der Integration reduziert sich die Lernkurve auf PHP
und sehr wenige SQL-Befehle selbst. Eine kleinere Einstiegbarriere erlaubt dann
vielleicht den Ersatz uneffektiver Bastellösungen durch eine halbwegs saubere Programmierung,
was insgesamt schon als Vorteil betrachtet werden kann.
Wann SQLite nachteilig ist
SQLite speichert die gesamte Datenbank in einer einzigen Datei. Schreibzugriffe
von einer Benutzersitzung aus führen dazu, dass die gesamten Datei kurzzeitig
gesperrt wird. Das führt bei häufigen Schreibzugriffen sehr schnell dazu, dass
PHP5 ständig auf die erneute Freigabe der Datenbank wartet und dies verschlechtert
drastisch die Antwortzeiten des Systems.
Die Speicherung von Sitzungsdaten in SQLite ist deshalb eher nachteilig. Sollte
das Dateisystem feststellen, dass die Datenbankdatei korrupt ist, wird man alle Sitzungsdaten
aller Sitzungen verlieren. Beim bisherigen System beträfe dies nur
eine Sitzung. Außerdem verfügt SQLite über keine »Selbstheilungskräfte«, wie sie
andere DBMS kennen. John Lim von PHPEverywhere und Sterling Hughes
499

500
Die integrierte Datenbank SQLite
haben einige Benchmarks erstellt, die klar beweisen, das SQLite bei schreibintensiven
Aufgaben wie der Sitzungsverwaltung deutlich langsamer ist als die eingebaute
Sitzungsverwaltung oder andere Datenbanklösungen.
Allerdings muss auch gesagt werden, dass die in den Tests erreichten Zugriffszahlen
weit höher liegen, als die meisten Webseiten jemals erreichen. Insofern sind
derartige Aussagen immer auch akademischer Natur.
12.3 Einführung
Die Implementierung von SQLite folgt weitgehend den Vorgaben der C-Implementierung
1 . Wo immer es an Dokumentation mangelt, kann man also gut auf die
Originalausgabe der Datenbank zurückgreifen.
Eine einfache Beispielanwendung
Ein einfaches Beispiel soll zeigen, wie der Zugriff prinzipiell aussieht. Das Skript
geht davon aus, dass ein Verzeichnis data unterhalb des Speicherorts des Skripts
existiert, wo die Datenbankdatei erzeugt werden kann:
Listing 12.1: SQLiteCreate.php – Erzeugen einer Datenbank und einer Tabelle

Einführung
)";
if ( !sqlite_query($sql, $db) )
die(sqlite_last_error($db).': '.
sqlite_error_string(sqlite_last_error($db)));
echo ( "Datenbank $sqliteDb erfolgreich angelegt." );
sqlite_close($db);
?>
Dieses Skript erzeugt eine neue SQLite-Datenbank und darin eine einfache
Tabelle mit vier Spalten: id, login, password und email zur Implementierung einer
Benutzeranmeldung.
Eine Benutzerverwaltung mit SQLite
Das folgende Listing zeigt ein weiteres Skript auf einen Blick, eine Erläuterung der
wichtigen Passagen folgt danach. Es handelt sich um die noch rudimentäre Benutzerverwaltung,
die die bereits erzeugte Tabelle mit zwei Datensätzen befüllt und
einen Anmeldevorgang simuliert:
Listing 12.2: SQliteSelect.php – Primitive Benutzerverwaltung mit SQLite

502
Die integrierte Datenbank SQLite
{
foreach ($users as $user)
{
$sql = "INSERT INTO users (login, password, email)
VALUES
(
'{$user['login']}',
'{$user['password']}',
'{$user['email']}'
)";
echo "$sql";
if (!sqlite_query($db, $sql))
{
die ("Fehler: " . sqlite_last_error($db).': '.
sqlite_error_string(sqlite_last_error($db)));
}
}
echo 'Daten erfasst';
}
else
{
echo 'Daten bereits vorhanden';
}
sqlite_close($db);
?>
Abfrage der Datenbank

Einführung
echo "{$row['id']} Name: {$row['login']}
E-Mail: {$row['email']}";
}
if ($_SERVER['REQUEST_METHOD']=='POST' && $_POST['action']=='test')
{
$pw_encrypted = md5($_POST['logpass']);
$sql = "SELECT * FROM users WHERE login='{$_POST['logname']}'
AND password='$pw_encrypted'";
$result = sqlite_query($db, $sql);
echo sqlite_error_string(sqlite_last_error($db));
if (sqlite_num_rows($result) == 1)
{
echo 'Anmeldung erfolgreich';
}
else
{
echo 'Benutzername oder Kennwort konnten
nicht gefunden werden.';
}
}
?>
Test der Anmeldung

504
Die integrierte Datenbank SQLite
&nbsp;
Um Kennwortdaten in der Datenbank zu schützen, werden die Zeichenfolgen als
MD5-Hash abgelegt. Dies ist eine irreversible Abbildung beliebiger Daten. Um
später das Kennwort verifizieren zu können, wird die Eingabe erneut mit MD5
berechnet und die kodierten Werte werden verglichen.
Das Skript ist relativ primitiv, es erfasst nur zwei Musterdatensätze, die hart kodiert
sind. Um festzustellen, ob die Daten schon vorhanden sind, erfolgt zuerst eine einfache
Abfrage:
$result = sqlite_query($db, "SELECT * FROM users");
Dann wird ermittelt, wie viele Daten vorliegen:
$num = sqlite_num_rows($result);
Die Funktion sqlite_num_rows ermittelt die Anzahl der von der in $result gespeicherten
Abfrage zurückgegebenen Datensätze.
Sind keine Datensätze vorhanden, werden die als Array vorliegenden Daten mittels
INSERT gespeichert. Geht dabei etwas schief, enthält sqlite_last_error($db) den
letzte Fehlercode. Um den passenden Text anzuzeigen, was meist hilfreicher ist,
wird eine weitere Funktion benötigt:
sqlite_error_string(sqlite_last_error($db))
Für die Ausgabe von Datensätzen kann der Inhalt zeilenweisen einem Array zugeführt
werden. Auch hier dient der Verweis auf den Ergebnissatz, wiederum in
$result abgelegt, als Datenquelle:
while ($row = sqlite_fetch_array($result, SQLITE_ASSOC))

Einführung
Der Vergleich des eingegebenen Kennworts mit dem gespeicherten erfolgt in
einer weiteren Abfrage. Damit dieser Programmteil nur ausgeführt wird, wenn ein
Formular gesendet wurde, wird eine Servervariable verwendet:
$_SERVER['REQUEST_METHOD']=='POST'
Das Kennwort muss wieder mit MD5 verpackt werden:
$pw_encrypted = md5($_POST['logpass']);
Dieser Wert wird dann für die Abfrage verwendet. Der Rest ist bekannt – es folgt
eine Abfrage und diese wird mit sqlite_num_rows untersucht. Nur wenn genau ein
Datensatz gefunden wurde, war die Prüfung erfolgreich.
Am Ende des Skripts sollten Sie nicht vergessen, die Verbindung zu schließen,
damit SQLite die Datei freigeben kann, in der die Datenbank gespeichert ist.
sqlite_close($db);
Ausblick
SQLite kann Daten auch im Speicher des Computers halten, was für temporäre
Daten sehr vorteilhaft ist. Unter Linux konnten dafür bislang die Shared-Memory-
Funktionen eingesetzt werden, die jedoch unter Windows nicht zur Verfügung
standen, was echte Cross-Plattform-Entwicklung natürlich verhindert. Hier bietet
SQLite nun eine einfache und elegante Lösung. Natürlich hat SQLite seine Grenzen.
Bei sehr vielen konkurrierenden Zugriffen führt die Sperrung der gesamten
Datenbankdatei dazu, dass neu eintreffende Abfragen verzögert werden. Das kann
praktisch bis zum Deadlock führen – dem Skriptstillstand. Allerdings ist das
Gespann Dateisystem-Speicher-SQLite äußerst leistungsfähig und die allergrößte
Masse aller Sites erreicht niemals die kritische Benutzerzahl.
Spannend sind auch die Möglichkeiten, SQLite beliebige Funktionen hinzuzufügen,
die innerhalb von SQL-Abfragen benutzt werden können. Damit kann man
sehr effizient die Defizite der Datenbank ausgleichen und erreicht eine mithin
höhere Leistungsfähigkeit als bei größeren Datenbanksystemen. Es ist durchaus
denkbar, dass auch anspruchsvolle Lösungen für geringen oder mittlere Last mit
SQLite programmiert werden.
505

506
Die integrierte Datenbank SQLite
12.4 Referenz SQLite
Funktion und Parameter Beschreibung
sqlite_array_query Führt eine Abfrage aus und gibt ein Array mit den Ergebnissen
zurück.
sqlite_busy_timeout Maximale Wartezeit auf ein Kommando. Der Standardwert
beträgt 60 Sekunden, die Angabe muss in Millisekunden
erfolgen.
sqlite_changes Anzahl der Spalten, die das letzte Kommando verändert
hat.
sqlite_close Schließt die Verbindung.
sqlite_column Holt eine Spalte anhand des angegebenen Indizes aus der
aktuellen Ergebnisreihe.
sqlite_create_aggregate Nutzt eine PHP-Funktion zur Verarbeitung von Daten aus
einer Tabelle.
sqlite_create_function Definiert eine PHP-Funktion callback unter dem Namen
function zur Verwendung in künftigen SQL-Befehlen.
sqlite_current Holt einen Ergebnissatz aus dem Ergebnisarray zurück.
sqlite_error_string Zeigt eine Fehlermeldung an. Siehe auch
sqlite_last_error.
sqlite_escape_string Markiert in SQLite unzulässige Zeichen.
sqlite_fetch_array Holt die nächste Reihe aus dem Ergebnissatz.
sqlite_fetch_single Holt die erste Spalte aus dem Ergebnissatz.
sqlite_fetch_string Alias für sqlite_fetch_single.
sqlite_field_name Name eines Feldes
sqlite_has_more TRUE, wenn weitere Reihen verfügbar sind.
sqlite_last_error Letzte Fehlernummer.
sqlite_last_insert_rowed Letzte ID, die in einer INTEGER PRIMARY KEY Spalte eingefügt
wurde.

Funktion und Parameter Beschreibung
Referenz SQLite
sqlite_libencoding Zeichenkodierung der Bibliothek, beispielsweise ISO-
8859-1.
sqlite_libversion Die Versionsnummer der Bibliothek.
sqlite_next Sucht einen Ergebnisdatensatz zur Ausgabe, gibt aber
selbst nichts aus. Wird zur Schleifensteuerung verwendet.
sqlite_num_fields Anzahl der Felder im Ergebnis.
sqlite_num_rows Anzahl der Reihen im Ergebnis.
sqlite_open Öffnet die Datenbank und erzeugt die Datei, wenn sie
nicht existiert, mit dem angegebenen Zugriffsmode (Unix-
Dateiparameter, beispielsweise 0666 (oktal)).
sqlite_popen Wie sqlite_open, aber persistent.
sqlite_query Fragt die Datenbank ab und gibt ein Handle auf die Ergebnisse
zurück.
sqlite_rewind Setzt den Zeiger auf die erste Reihe. Wird für die Schleifensteuerung
verwendet.
sqlite_seek Setzt den Zeiger auf die angegebene Reihe. Wird für die
Schleifensteuerung verwendet.
sqlite_udf_decode_binary Dekodiert Binärdaten, bevor diese an eine benutzerdefinierte
Funktion gesendet werden.
sqlite_udf_encode_binary Kodiert Binärdaten, bevor diese von einer benutzerdefinierte
Funktion zurückgenommen werden.
sqlite_unbuffered_query Wie sqlite_query, aber das Ergebnis wird nicht sofort
komplett geholt, sondern erst, wenn es andere Funktionen
anfordern. Schneller bei einfachen sequenziellen Lesezugriffen.
507

508
Die integrierte Datenbank SQLite
12.5 Kontrollfragen
1. Was müssen Sie tun, um SQLite benutzt zu können?
2. Welche Datentypen kennt SQLite?
3. Sie möchten mehrere Tausend Datensätze für eine hoch frequentierte Website
verwalten. Ist SQLite dafür die beste Wahl? Begründen Sie die Antwort?
4. Welche Aufgabe hat der Befehl VACUUM?

Datenbanklösungen
mit MySQL
13

510
Datenbanklösungen mit MySQL
13.1 Bibliotheks-Verwaltung mit MySQL
Dieses Kapitel widmet sich einem Praxisprojekt: Der Verwaltung einer Bibliothek.
Dabei soll, neben der einfachen Auflistung von Büchern auch deren Position in
einem Regalsystem erfasst werden.
Schrittfolge
Um das Programm komplett zu erstellen, werden zwei Schritte erforderlich:
Entwicklung einer Datenbankstruktur
Aufbau der Oberfläche
Programmierung der Geschäftslogik
Die Trennung von Oberfläche und Logik erfolgt durch ein primitives Template-
System, einer Verwaltung von Vorlagen. Dies erleichtert die Erweiterung der
Funktionalität erheblich.
Weitere Aufgaben
Das Programm ist ein guter Start in Richtung komplexer Datenbankanwendungen.
Es ist zugleich Grundlage des nächsten Kapitels, indem die Daten der Bücher
eleganter beschafft werden. Das eigentliche Problem bei der Nutzung des Programms
ist nämlich nicht dessen Erstellung, sondern dessen Nutzung. Das Erfassen
aller Buchdaten ist rech mühselig. Glücklicherweise bietet Amazon einen
Webservice, der die Beschaffung der Daten erleichtert. Vorerst wird jedoch – auch
zur Korrektur später automatisch erfasster Daten – ein Eingabeformular benutzt.
Funktionen
Das Programm soll grundsätzlich folgende Funktionen anbieten:
Erfassung von Büchern
Suchen nach Titel, Autor und ISBN
Erfassung der Regalposition und optional einer Anzahl vorhandener
Exemplare

Bibliotheks-Verwaltung mit MySQL
Erfassung von Lesern, an die die Bücher ausgeliehen werden
Verwaltung der Leihvorgänge
Da ein Benutzer ein Buch immer nur einmal ausleihen kann, sind nur sehr einfache
Beziehungen erforderlich. Allerdings kann jeder Benutzer mehrere verschiedene
Bücher ausleihen, was zu folgenden Tabellen führt:
Tabelle »Books« für die Erfassung der Bücher
Tabelle »Reader« für die Leser, die Bücher ausleihen können
Tabelle »LendOut« für die Leihvorgänge
Der Vorteil bei der Ausleihtabelle besteht im Aufbau einer Historie, das heißt, hier
kann man schnell nach der Häufigkeit und Dauer der Ausleihe suchen.
Nebenbei bemerkt eignet sich das Programm auch für eine private Bibliothek.
Wer mit seinen Kumpels und Kollegen einen Buchpool bildet und sich gegenseitig
Bücher ausleiht, kann hier verwalten, welches Exemplar gerade wo unterwegs
ist.
Für die eigentliche Funktionalität muss außerdem festgelegt werden, welche Seiten
und Formulare erforderlich sind. Dabei sind zwei »Betriebsarten« zu beachten:
Ausleih- und Verwaltungsmodus. Im Ausleihmodus sollen Leser oder der
Bibliothekar suchen und Ausleihvorgänge steuern können, im Verwaltungsmodus
können neue Bücher erfasst oder alte entfernt werden. Benötigt werden dazu folgende
Seiten:
Startseite mit Auswahl der Betriebsart
Seite zum Suchen von Büchern
Seite zum Steuern des Ausleih- und Rücknamevorgangs
Seite zum Erfassen, Anzeigen und Löschen von Benutzern
Seite zum Erfassen, Anzeigen und Löschen von Büchern
Auf eine Verwaltung der Bediener durch eigene Anmeldenamen und Kennwörter
soll hier – vor allem aus Platzgründen – verzichten werden. Die dazu benötigten
Techniken unterscheiden sich nicht grundlegend von den gezeigten und die
Umsetzung sollte nach der Absolvierung des Kapitels nicht schwer fallen.
511

512
Datenbanklösungen mit MySQL
13.2 Vorbereitung der Datenbank
Für den Entwurf der Datenbank müssen Sie sich zuerst über eine Struktur der
Tabellen im Klaren sein. Die drei benötigten Tabellen wurden bereits erwähnt.
Der Aufbau wird so gewählt, dass alle Daten im passenden Datenformat gespeichert
werden können.
Das Anlegen kann mit einem Werkzeug erfolgen. Im Beispiel wurde das MySQL
Control Center verwendet. Für dieses Projekt wurde lokal eine eigene Datenbank
angelegt. Wenn Sie ausschließlich auf dem Server eines Providers arbeiten und
dort nur eine fertige Datenbank verwenden können, müssen Sie diesen Schritt auslassen
und bei der Nutzung der Skripte den Namen der Datenbank anpassen. Wie
das zu erfolgen hat, wird im entsprechenden Code-Abschnitt erläutert.
Datenbank anlegen
Falls noch nicht geschehen, legen Sie die für die Datenbank-Übungen erforderliche
Datenbank »marktundtechnik« an. Sie können auch jeden anderen Namen
nehmen, müssen dann aber die Skripte entsprechend anpassen. Dies ist nicht sehr
schwer, weil es eine zentrale Konfigurationsdatei für die Datenbankparameter gibt.
Datenbank mit SQL
Wenn Sie mit SQL arbeiten, geben Sie am Prompt der MySQL-Konsole folgendes
ein:
CREATE DATABASE marktundtechnik;
Weitere Parameter werden für diese Projekt nicht benötigt.
Datenbank mit MySQL Control Center anlegen
Um die Datenbank mit MySQL Control Center anzulegen, starten Sie das Programm.
Beim ersten Mal müssen Sie den Server angeben (vermutlich »localhost«,
wenn es lokal läuft) und gegebenenfalls Anmeldename und Kennwort. Nach einer
frischen Installation ist der Anmeldename »root« und das Kennwort ist leer. Im
Zweig Datenbanken des Servers klicken Sie mit der rechten Maustaste und wählen
dann im Kontextmenü den Eintrag Neue Datenbank.

Vorbereitung der Datenbank
Danach erscheint ein Eingabefeld, wo der Name der Datenbank eingetragen wird.
Weitere Optionen sind nicht erforderlich.
Tabellen anlegen
Nun werden die drei benötigten Tabellen angelegt. Zuerst wird wieder der dazu
erforderliche SQL-Code vorgestellt. Danach wird der entsprechende Dialog im
Control Center gezeigt. Die Tabellen weisen keine Besonderheiten auf, wenngleich
einige Dinge zu beachten sind.
Jede Tabelle enthält ein Feld id, das als Typ BIGINT und AUTO_INCREMENT definiert
wurde. Dieses Feld ist zugleich der Primärschlüssel der Tabelle (PRIMARY KEY).
Des Weiteren wurde bei einigen Feldern explizit NOT NULL angegeben, um zu verhindern,
dass beim Anlegen der Datensätze Spalten leer bleiben. Felder, nach
denen gesucht werden könnte, wurden außerdem mit einem Index bedacht.
Tabellen mit SQL anlegen
Das folgende Listing zeigt die SQL-Anweisungen, mit denen die drei Tabellen
erzeugt werden können:
Listing 13.1: SQL-Anweisungen zum Erstellen der Tabellen
#
# Tabellenstruktur für Tabelle `books`
#
CREATE TABLE books (
id bigint(20) NOT NULL auto_increment,
title varchar(100) NOT NULL default '',
subtitle varchar(255) default '',
isbn varchar(10) NOT NULL default '',
author varchar(100) default '',
number int(11) NOT NULL default '1',
Abbildung 13.1:
Eine neue Datenbank mit MySQL
Control Center anlegen
513

514
Datenbanklösungen mit MySQL
shelf varchar(15) default '',
PRIMARY KEY (id),
KEY idx_title (title)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;
# --------------------------------------------------------
#
# Tabellenstruktur für Tabelle `lendout`
#
CREATE TABLE lendout (
id bigint(20) NOT NULL auto_increment,
books_id bigint(20) NOT NULL default '0',
reader_id bigint(20) NOT NULL default '0',
lendingdate datetime NOT NULL default '0000-00-00 00:00:00',
lendingperiod timestamp NOT NULL,
PRIMARY KEY (id)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;
# --------------------------------------------------------
#
# Tabellenstruktur für Tabelle `reader`
#
CREATE TABLE reader (
id bigint(20) NOT NULL auto_increment,
name varchar(100) NOT NULL default '',
surname varchar(100) NOT NULL default '',
address varchar(150) NOT NULL default '',
zip varchar(5) NOT NULL default '',
city varchar(100) NOT NULL default '',
active tinyint(1) NOT NULL default '0',
created datetime NOT NULL default '0000-00-00 00:00:00',
PRIMARY KEY (id),
KEY idx_name (name),
KEY idx_surname (surname)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
Beachten Sie, dass die Anweisungen nur Tabellen erzeugen. Um das Skript erneut
anzuwenden, müssen eventuell vorhandene Tabellen mit DROP TABLE entfernt werden.

Tabellen mit MySQL Control Center anlegen
Vorbereitung der Datenbank
Zuerst wird die Buchtabelle erzeugt. Neben Titel, Autor und ISBN werden auch
die Regalnummer und die Anzahl der Exemplare erfasst.
Wenn im Control Center eine entsprechende Zeile der Tabelle ausgewählt wird,
lassen sich die Parameter, beispielsweise die Anzahl der Zeichen beim Datentyp
VARCHAR, erfassen.
Die Kundentabelle weist keine Besonderheiten auf:
Als letztes folgt die Ausleihtabelle:
Abbildung 13.2:
Struktur der Tabelle
»Books«
Abbildung 13.3:
Die Tabelle »Reader« zur
Erfassung der Bibliotheksnutzer
Abbildung 13.4:
Struktur der Tabelle
»LendOut«
Nach diesem Schritt steht die Datenbank bereit, um Daten aufzunehmen und später
natürlich Abfragen zu beantworten.
515

516
Datenbanklösungen mit MySQL
13.3 Die Seiten des Projekts
Am Anfang wurde bereits eine Übersicht über die benötigten Formulare gezeigt.
Diese werden hier nacheinander in der genannten Reihenfolge vorgestellt.
Vorbereitungen – das Template-System
Wie bereits kurz erwähnt, sollen Geschäftslogik und Design weitgehend getrennt
werden. Dazu wird ein kleines Template-System entwickelt, das die Verwaltung
der Seiten übernimmt. Das Prinzip ist recht einfach. Eine zentrale Instanz,
index.php, verwaltet alle Seiten. Diesem Skript wird mitgeteilt, welche Vorlage
(Template) aufgerufen werden soll. Die Vorlage besteht immer aus zwei Teilen:
Dem PHP-Code und dem HTML-Code. Damit beide interagieren können, gibt es
ein paar Steuerzeichen, die im HTML eingebaut werden und die in PHP aufzulösen
sind.
Der Sinn der Übung besteht nicht darin, ein professionelles Template-System wie
phpTemple (http://www.phptemple.de) oder Smarty (http://smarty.php.net) zu
ersetzen, sondern die prinzipielle Arbeitsweise und den Nutzen transparent werden
zu lassen. Die Technik lässt sich leicht auf andere Projekte übertragen. Hat
man erstmal das Gefühl dafür, wann ein solches System Vorteile bringt, fällt es
leichter, sich für den Einarbeitungsaufwand in ein kommerzielles Produkt zu entscheiden.
Die Steuerzeichen des Template-Systems
Die wichtigste Funktion besteht in der Datenausgabe. Dazu werden Variablen
erforderlich. Diese sehen – der Einfachheit halber – genauso aus, wie in PHP.
Allerdings kann man sie direkt ins HTML schreiben:
{$variable}
Die geschweiften Klammern verhindern Konflikte mit Währungsangaben mit Dollarzeichen.
Zum Ausgeben von Tabellen braucht man eine Konstruktion, die Datenwiederholungen
erzeugt. In PHP sind dies Schleifen. In HTML wird einfach ein Kommentar
eingefügt, den das Skript verarbeiten kann (Editoren ignorieren diesen
Kommentar):

Die Seiten des Projekts
${readers:name}
${readers:surname}
Das Programm wiederholt jetzt das Tag mit sämtlichen darin befindlichen Codes
so oft, wie das Array readers dies ermöglicht. Das Array muss assoziativ sein. Der
Index mit dem Namen surname wird über ${readers:surname} abgerufen. Technisch
werden dazu reguläre Ausdrücke und simple Ersetzungsfunktionen benutzt.
Funktionsweise des Template-Systems
Das eingesetzte Template-System beschränkt sich auf eine einzige Klasse, die in
der Datei engine.inc.php definiert ist. Sie dient dazu, die HTML-Vorlagen zu
erkennen, Variablen zu suchen und zu ersetzen und gegebenenfalls Blöcke mit
sich wiederholenden Daten zu bilden. Das Resultat wird direkt ausgegeben.
Damit die Steuerung funktioniert, ist folgender Einsatz vorgesehen:
$engine = include_once('engine.inc.php');
Diese Zeile schließt die Klasse ein, erzeugt eine Instanz und gibt sie wieder
zurück. Dadurch hat die Klasse sowohl Zugriff auf die globalen Variablen, deren
Werte benutzt werden können, als auch die Möglichkeit, sich selbst dem aufrufenden
Code bereitzustellen.
Der aufrufende Code muss nun den Namen des Templates zuweisen:
$engine->Html = 'Start.html';
Alternativ kann dies entfallen; dann wird versucht, die Daten aus der GET-Variablen
TEMPLATE zu übernehmen. Die Steuerung kann damit vom Code in das
Template selbst verlagert werden:
Zur Startseite
517

518
Datenbanklösungen mit MySQL
Wenn ein expliziter Code-Block erforderlich ist, muss man diesen lediglich wie
die Vorlage benennen und ihm die Dateierweiterung .php geben. Damit das funktioniert,
wurde die Startseite index.php folgendermaßen definiert:
Listing 13.2: index.php – Universelle Startseite für das Template-System

Die Seiten des Projekts
Zwei private Variablen speichern den Namen der Vorlage und optional inkludierten
und implizit ausgeführten Code (ebenso als Dateiname übergeben). Der
Zugriff erfolgt später über die __set-Methode und den Konstruktor:
private $templateCode;
private $templateHtml;
Die Steuerung der Vorlage erfolgt durch eingebettete Kommentare, die von dem
folgenden regulären Ausdruck erkannt werden:
const COMMENT = '/

520
Datenbanklösungen mit MySQL
$html = file_get_contents($this->templateHtml);
}
if (strlen($this->templateCode) > 0)
{
include_once($this->templateCode);
}
Nun werden die Wiederholungen aufgelöst. Dazu werden zuerst alle Blöcke
ermittelt, die mit der Kommentarsyntax umschlossen sind:
$matches = array();
$blocksFound = preg_match_all(self::COMMENT, $html,
$matches, PREG_OFFSET_CAPTURE);
if ($blocksFound)
{
$page = '';
Der reguläre Ausdruck produziert ein Array in $matches, dessen Elemente folgende
Bedeutung haben:
0: Array der Kommentaranfänge
1: TAGs
2: Variablen
3: Ende-Offset
Liegt ein solches Array vor, beginnt die eigentliche Analyse. Anhand der Blockdaten
wird mit Hilfe von schnellen Zeichenkettenfunktionen der umschlossene Teil
ermittelt, weil diese Daten gegebenenfalls wiederholt werden müssen. Das passiert
innerhalb der for-Schleife praktisch für jeden Block:
if (is_array($matches))
{
$startBlock = $lastStartBlock = 0;
for ($i = 0; $i < count($matches[1]); $i++)
{
$token = strtoupper($matches[1][$i][0]);
$offsetComment = (int)$matches[0][$i][1];
$offsetContent = ((int)$matches[3][$i][1]) + 1;
$variableName = $matches[2][$i][0];
Die Auflösung der Daten erfolgt in zwei Schritten. Beim Start des Blocks werden
die Anfangspositionen gespeichert (REPEAT), beim Ende werden die Daten zur

Die Seiten des Projekts
Wiederholung benutzt (END). Die eigentliche Arbeit erledigt die Methode repeat-
Block, die nachfolgend erläutert wird:
switch ($token)
{
case 'REPEAT':
$startBlock = $offsetContent;
$startComment = $offsetComment;
break;
case 'END':
$block = substr($html, $startBlock,
$offsetComment - $startBlock);
$block = $this->repeatBlock($block, $variableName);
$len = $startComment - $lastStartBlock;
$page .= substr($html, $lastStartBlock, $len).$block;
$lastStartBlock = $offsetContent;
break;
}
Die wiederholten Daten werden der fertigen Seite, die in $page gespeichert wird,
hinzugefügt:
}
$page .= substr($html, $offsetContent);
}
Zum Schluss werden noch die übrig gebliebenen Variablen ersetzt:
echo ($this->varReplace($page));
}
else
{
echo 'Nicht gefunden';
}
}
Wie bereits angedeutet, kommt repeatBlock eine große Bedeutung zu. Der
Methode wird der Code eines Blockes und der Name einer Variablen übergeben.
Ist diese Variable ein Array, wird der Block für jedes Array-Element einmal ausgegeben
und die Daten des jeweiligen Elements werden benutzt, um die Blockvariablen
zu ersetzen. Letzteres findet in einer eigenen Methode statt, arrayReplace.
Damit der Zugriff auf globale Variablen gelingt, wird der Name der Variablen als
dynamische Variable ($$-Syntax) benutzt:
521

522
Datenbanklösungen mit MySQL
private function repeatBlock($block, $varName)
{
global $$varName;
$result = '';
if (is_array($$varName))
{
$this->index = 0;
foreach ($$varName as $value)
{
$result .= $this->arrayReplace($block);
$this->index++;
}
}
else
{
$result = $block;
}
return $result;
}
arrayReplace nutzt einen regulären Ausdruck, um die Variablen in der Vorlage zu
finden und zu ersetzen. Das eigentliche Ersetzen passiert in der Rückruffunktion
replaceArray, die ihrerseits Zugriff auf den globalen Adressraum hat:
private function arrayReplace($block)
{
$block = preg_replace_callback('/\{\$([^:}]*):(.+)\}/U',
array($this, 'replaceArray'), $block);
return $block;
}
private $index = 0;
private function replaceArray($repl)
{
global $$repl[2];
$arr = $$repl[2];
return $arr[$this->index];
}
Vergleichbar arbeitet die Ersetzung der normalen skalaren Variablen, wo ebenso
eine Rückruffunktion benutzt wird. Auch hier geht es nur um einen vereinfachten
Zugriff auf den globalen Adressraum:

Die Seiten des Projekts
private function varReplace($block)
{
$block = preg_replace_callback('/\{\$(.+)\}/U',
array($this, 'replaceSkalar'), $block);
return $block;
}
private function replaceSkalar($repl)
{
global $$repl[1];
return $$repl[1];
}
Der Rest der Datei steht außerhalb der Klassendefinition. Er erzeugt eine Instanz
der Klasse und gibt das entsprechende Objekt als Ergebnis der Ausführung zurück.
Damit kann die include-Funktion (oder include_once) als Quelle einer Zuweisung
benutzt werden. Zuvor wird noch versucht, den Namen des Templates aus
der GET-Variablen TEMPLATE zu entnehmen, wobei dieser Schritt optional ist,
das heißt, er schlägt nicht fehl, wenn die Angabe fehlt:
$__template = isset($_GET['TEMPLATE']) ? $_GET['TEMPLATE'] : '';
return new SimpleTemplate($__template);
?>
Das vorgestellte Prinzip ist einfach und schnell und bietet einigen Raum für Verbesserungen.
Es zeigt vor allem, wie effektiv mit regulären Ausdrücken und der
neuen objektorientierten Syntax von PHP5 gearbeitet werden kann.
Der Code der Seiten
Die folgenden Skripte zeigen eine kurze Übersicht über die Vorlagen, also den
HTML-Code der Seiten (befreit von gestalterischen Elementen, um die Lesbarkeit
zu verbessern) und die Variablen, die die dynamischen Daten enthalten.
Startseite mit Auswahl der Betriebsart
Die Startseite ist relativ einfach, denn es sind nur folgende Zustände zu unterscheiden:
Ausleihen oder Rücknehmen eines Buches (Betriebszustand)
Anlegen oder Sperren von Kunden (Betriebszustand)
Anlegen oder Herausnehmen von Büchern (Administrationszustand)
523

524
Datenbanklösungen mit MySQL
Das vorliegende Beispiel ist vergleichsweise rudimentär und unterscheidet nicht
explizit zwischen Betriebs- und Administrationszustand. Dies ist jedoch leicht zu
implementieren. Solange eine solche Bibliotheksverwaltung lokal im Intranet
läuft, ist die Unterscheidung möglicherweise nicht erforderlich. Eine öffentliche
Seite müsste um entsprechende Sicherheitsfunktionen ergänzt werden.
Da keine weitere Logik erforderlich ist, besteht diese Seite lediglich aus einigen
Links auf die anderen Vorlagen:
Listing 13.3: start.html – Startseite der Bibliotheksverwaltung
Bibliotheksverwaltung
Willkommen in der Bibliotheksverwaltung mit PHP5
Funktionsauswahl
Kundenverwaltung
B&uuml;cherverwaltung
Heute ist der {$today}.
PHP-Code wird hier kaum benötigt, lediglich eine Variable zur Anzeige des
Datums ist zu definieren:
Listing 13.4: start.php – Erzeugen einer deutschen, systemunabhängigen Datumsanzeige

Die Seiten des Projekts
Seite zum Steuern des Ausleih- und Rücknahmevorgangs
Die Seite zum Steuern des Ausleih- und Rücknahmevorgangs benötigt folgende
elementare Funktionen:
Suchen des Kunden, wenn nicht vorhanden, Sprung zur Kundenerwaltung
Suche des Buches (wird vorausgesetzt, dass nur vorhandene Bücher genutzt
werden)
Ausleihe oder Rücknahmevorgang
Hier wird auf jeden Fall der Datenbankzugriff benötigt, der in einer Include-Datei
abgelegt wird, die auch den anderen Modulen zur Verfügung steht. In dieser Datei
wird ein MySQLi-Objekt erzeugt, das in allen folgenden Codes den Zugriff auf die
Datenbank erlaubt:
Listing 13.5: database.inc.php – Include-Datei für den Datenbankzugriff
Seite zum Erfassen, Anzeigen und Löschen von Kunden
Die Seite umfasst folgende Funktionen:
Liste aller Kunden anzeigen
Anzeige von Details
Ändern bestehender Kunden
Anlegen neuer Kunden
Setzen einer Sperre (anstatt eines endgültigen Löschens)
Die HTML-Vorlage ist sehr direkt aufgebaut und enthält mehrere Tabellen, die
jeweils die Darstellung einer Funktion steuern:
525

526
Datenbanklösungen mit MySQL
Listing 13.6: kunden.html – Vorlage für die Verwaltung der Kunden
Bibliotheksverwaltung
Startseite
|
Ausleihe
|
B&uuml;cherverwaltung
Kundenverwaltung
Informationen
Kundenliste
Status
Name
Aktion
{$reader:state}
{$reader:name}, {$reader:surname}
Details ansehen

Die Seiten des Projekts
Details f&uuml;r Kunde {$detail_name}
Name, Vorname:
{$detail_name}, {$detail_surname}
Anschrift:
{$detail_zip} {$detail_city}
&Auml;ndern
Kundendaten
Daten:
,
PLZ&nbsp;Ort:
527

528
Datenbanklösungen mit MySQL
Status
Neuer Kunde
Kundendaten
Daten:
,
PLZ&nbsp;Ort:

Die Seiten des Projekts
Besonderheiten gibt es hier nicht. Beachten Sie den Aufruf der anderen Vorlagen
im Menü:
index.php?TEMPLATE=ausleihe
Die Steuerung des Codes erfolgt durch versteckte Felder in den Formularen:
Dabei werden auch dynamische Daten ({$detail_id}) übergeben, wodurch Vorlage
und Code miteinander in Verbindung stehen. Die Vorlage verwendet außerdem
eine #IF-Anweisung, um einen Teil der Seite nur bei Bedarf anzuzeigen.
Weitaus aufschlussreicher ist der PHP-Code, der mit dieser Vorlage verknüpft ist:
Listing 13.7: kunden.php – Steuerung der Vorlage mittels Datenbankabfragen

530
}
Datenbanklösungen mit MySQL
'{$_POST['reader_surname']}',
'{$_POST['reader_zip']}',
'{$_POST['reader_city']}',
1, CURDATE())");
break;
case 'change':
$state = isset($_POST['reader_state']) ? 1 : 0;
$mysqli->query("UPDATE reader SET
name='{$_POST['reader_name']}',
surname='{$_POST['reader_surname']}',
zip='{$_POST['reader_zip']}',
city='{$_POST['reader_city']}',
active=$state
WHERE id = {$_POST['id']}");
break;
}
// Liste fuellen
$query = $mysqli->query("SELECT id, name, surname,
IF(active=0,'Gesperrt','Aktiv') AS state FROM reader");
while($arr = $query->fetch_assoc())
{
$reader[] = $arr;
}
// Details abrufen, wenn gefordert
if (isset($_GET['id']))
{
$query = $mysqli->query("SELECT * FROM reader WHERE id =
{$_GET['id']}");
$detail = $query->fetch_assoc();
$detail_id = $detail['id'];
$detail_name = $detail['name'];
$detail_surname = $detail['surname'];
$detail_zip = $detail['zip'];
$detail_city = $detail['city'];
$detail_state = ($detail['active']==1) ? 'checked' : '';
}
?>
Am Anfang des Codes werden die beiden Formulare ausgewertet, erst danach
erfolgt der Aufbau der Liste für die Ausgabe. Auf diese Weise wird sichergestellt,
dass die soeben erfolgten Änderungen sofort in der Anzeige reflektiert werden.

Die Seiten des Projekts
Unbedingt erforderlich ist auch der Einschluss der Vorbereitung der Datenbankabfrage:
include('database.inc.php');
Die Aktionen werden nur ausgewertet, wenn ein Formular abgesendet wurde.
Dazu wird die Servervariable REQUEST_METHOD auf den Wert »POST« hin untersucht:
if ($_SERVER['REQUEST_METHOD']=='POST' && isset($_POST['action']))
Anschließend werden die passenden INSERT- bzw. UPDATE-Befehle gebildet, um die
Daten in der Datenbank zu verändern. Als Quelle dienen die Felder der Formulare.
Sind alle Kommandos abgearbeitet, werden die aktuellen Daten aus der Datenbank
gelesen:
$query = $mysqli->query("SELECT id, name, surname,
IF(active=0,'Gesperrt','Aktiv') AS state FROM reader");
Der SELECT-Befehl sorgt gleich für die korrekte Aufbereitung der Daten für die Ausgabe.
Das Feld active der Tabelle reader kann die Werte 0 oder 1 enthalten. Für
die Anzeige werden diese Werte mit der MySQL-Funktion IF in die Zeichenketten
»Gesperrt« bzw. »Aktiv« umgewandelt. Es ist generell eine gute Idee, fest verdrahtete
Berechnungen in der Datenbank erledigen zu lassen, und damit den
lokalen Code zu entlasten. Nur dann, wenn die Berechnungen selbst dynamisch
sind und möglicherweise häufig verändert werden oder wenn sie sehr komplex
sind, ist PHP besser geeignet.
Die fertige Abfrage muss nun noch in ein Array überführt werden, damit die Template-Engine
die Daten in einer Schleife ausgeben kann:
while($arr = $query->fetch_assoc())
{
$reader[] = $arr;
}
Damit kann dann innerhalb des Abschnitts folgende
Syntax zum Abruf der Felder benutzt werden:
{$reader:name}
Für das Füllen der Detaildaten und der Formulare wird keine Schleife benötigt.
Die erforderlichen Variablen werden deshalb in skalarer Form abgerufen (nach
einer erneuten SELECT-Anweisung):
531

532
Datenbanklösungen mit MySQL
$detail_id = $detail['id'];
In der Vorlage wird dieser Wert beispielsweise benutzt, um die aktuelle Auswahl
im Formular zu halten:
Die folgende Abbildung zeigt, wie die Seite in Aktion aussieht:
Abbildung 13.5:
Die Kundenverwaltung der Bibliothek
Seite zum Erfassen, Anzeigen und Löschen von Büchern
Die Seite zur Verwaltung der Bücher ist praktisch gleichartig zur Verwaltung der
Kunden aufgebaut. Lediglich die Daten unterscheiden sich und damit Anzahl und
Benennung der Spalten der Tabellen.

Zuerst wird wieder die Vorlage gezeigt:
Listing 13.8: buecher.html – Die Vorlage zur Verwaltung der Bücher
Die Seiten des Projekts
Bibliotheksverwaltung
Startseite
|
Ausleihe
|
Kundenverwaltung
B&uuml;cherverwaltung
Informationen
B&uuml;cherliste
Anzahl
ISBN
Titel
Aktion
{$books:number}
{$books:isbn}
{$books:title}
533

534
Datenbanklösungen mit MySQL
Details
Neues Buch erfassen
&Auml;ndern&nbsp;/&nbsp;Erfassen
Buchdaten
Titel:
Untertitel:
Autor:

Die Seiten des Projekts
ISBN:
Anzahl
Ausgeliehen
Die Vorlage ist bewusst etwas anders als die für die Kunden verwendete aufgebaut.
Detailanzeige, Änderung und Erfassung sind in einem Formular zusammengefasst,
dessen Funktion sich damit dynamisch ändert. Ein verstecktes Feld, dessen
Wert über eine Variable gesteuert wird, macht es möglich:
535

536
Datenbanklösungen mit MySQL
Auch die Beschriftung der Sendeschaltfläche ist dynamisch:
Die eigentliche Arbeit erledigt der Code-Teil:
Listing 13.9: buecher.php – Logik zur Verwaltung der Bücher

Die Seiten des Projekts
break;
}
}
$query = $mysqli->query("SELECT * FROM books");
while($arr = $query->fetch_assoc())
{
$books[] = $arr;
}
// Details abrufen, wenn gefordert
if (isset($_GET['id']))
{
$query = $mysqli->query("SELECT *,
(SELECT COUNT(*) FROM lendout WHERE books_id = b.id) AS lend
FROM books b WHERE id = {$_GET['id']}");
$detail = $query->fetch_assoc();
$detail_id = $detail['id'];
$detail_title = $detail['title'];
$detail_subtitle= $detail['subtitle'];
$detail_author = $detail['author'];
$detail_number = $detail['number'];
$detail_isbn = $detail['isbn'];
$detail_lend = $detail['lend'];
}
?>
Der erste Teil steuert die Umschaltung des Formulars. Danach folgen das Einfügen
(INSERT) und Aktualisieren (UPDATE) der Datenbank. Im letzten Teil werden
wieder die frisch aktualisierten Daten abgefragt, damit stets die aktuelle Liste zu
sehen ist. Eine Besonderheit stellt die letzte Abfrage dar, die auf einem so genannten
Sub-Select basiert. (Achtung! Dazu ist mindestens MySQL 4 erforderlich.)
Diese Unterabfrage sichert den Zugriff auf die Tabelle lendout, um die Anzahl der
bereits ausgeliehenen Bücher zu erhalten.
Die Geschäftslogik des Ausleihvorgangs
Die Logik des Ausleihvorgangs muss folgende Aufgaben erfüllen:
Suchen des Kunden, beispielsweise anhand der Kundennummer
Suchen des Buches, beispielsweise anhand der ISBN
»Buchen« des Ausleihvorgangs oder der Rücknahme eines Buches
537

538
Datenbanklösungen mit MySQL
Außerdem sind noch einige Verwaltungsfunktionen denkbar, die hier nicht vollständig
ausgeführt wurden:
Auflistung komplett ausgeliehener Bücher
Auflistung nicht pünktlich zurückgegebener Bücher
Auflistung säumiger Kunden
Die Vorlage der Ausleihseite
Abbildung 13.6:
Die Bücherseite mit Details über ein Buch
Auch die Ausleihseite besteht aus einer Vorlage und einer Code-Seite. Die Vorlage
ist vergleichsweise schlicht. Auch hier werden wieder mehrere Formulare eingesetzt,
um die Daten zu sammeln. Die Daten (Kunde, Buch) werden in Sitzungsvariablen
gespeichert, damit sie bis zum Ende des Vorgangs erhalten bleiben. Der
Teil der Seite, der die eigentliche Buchung ausführt, wird erst sichtbar, wenn alle
Daten vorliegen.

Listing 13.10: ausleihe.html – Vorlage für die Ausleihseite
Die Seiten des Projekts
Bibliotheksverwaltung
Startseite
|
Kundenverwaltung
|
B&uuml;cherverwaltung
Kunden
Kunden suchen
Name
Buch suchen
ISBN
Ausleihe- oder R&uuml;cknahme
Ausleih- oder R&uuml;cknahmeinformationen:
Kundenname:&nbsp;{$reader_name}
Kundennummer: {$reader_id}
Buchtitel: {$book_title}
ISBN: {$book_isbn}
Es sind noch {$available} B&uuml;cher verf&uuml;gbar.
539

540
Datenbanklösungen mit MySQL
&Uuml;bersicht aller Vorg&auml;nge des Kunden
Buch ID
Ausleihdatum
F&auml;lligkeit
Aktion
{$history:books_id}
{$history:lendingdate}
{$history:due}
R&uuml;ckgabe
Fehler:&nbsp;{$reader_error}{$book_error}
Diese Seite nutzt die Wiederholungs-Anweisungen zum Aufbau und definiert
einen Sprung auf die Ausleihseite.

Der Code der Ausleihseite
Die Seiten des Projekts
Listing 13.11: ausleihe.php – Die Steuerung der Vorlage nutzt intensiv die Datenbank

542
}
Datenbanklösungen mit MySQL
$arr = $result->fetch_assoc();
$reader_name = $arr['name'];
$reader_id = $arr['id'];
}
else
{
$reader_error = 'Auswahl des Kunden war
nicht eindeutig';
$error = true;
}
break;
case 'book':
$result = $mysqli->query("SELECT * FROM books
WHERE title LIKE '%{$_POST['book']}%'
OR isbn = '{$_POST['book']}'");
if ($result->num_rows == 1)
{
$arr = $result->fetch_assoc();
$book_title = $arr['title'];
$book_id = $arr['id'];
$book_isbn = $arr['isbn'];
$number = $arr['number'];
}
else
{
$book_error = 'Auswahl des Buches war
nicht eindeutig';
$error = true;
}
break;
}
if (!isset($error))
{
$result = $mysqli->query("SELECT COUNT(*) AS lent
FROM lendout
WHERE books_id=$book_id AND active=1");
$books_to_lend = $result->fetch_object();
$available = $number - $books_to_lend->lent;
$disabled = ($available

}
?>
Die Seiten des Projekts
$_SESSION['book_title'] = $book_title;
$_SESSION['book_id'] = $book_id;
$_SESSION['book_isbn'] = $book_isbn;
$_SESSION['number'] = $number;
// Ermittle die Liste aller bisherigen Buchungen fuer diesen Benutzer
$sql = "SELECT id, books_id,
DATE_FORMAT(lendingdate, '%d.%m.%Y') AS lendingdate,
IF(TO_DAYS(CURDATE())-TO_DAYS(lendingdate)
> lendingperiod, 'Überfällig',
CONCAT('Noch ', 30 - (TO_DAYS(CURDATE())
- TO_DAYS(lendingdate)), ' Tage') ) AS due
FROM lendout
WHERE reader_id=$reader_id
AND active=1";
$result = $mysqli->query($sql);
if ($result != false)
{
while($arr = $result->fetch_assoc())
{
$history[] = $arr;
}
}
$noerror = true;
Der Code basiert wieder auf dem bereits mehrfach verwendeten Prinzip der Übertragung
eines Kommandos, dessen Erkennen in einem switch-Zweig und der
Steuerung der entsprechenden SQL-Anweisungen auf Basis der Auswahl. Freilich
ist bei der Ausleihe (und Rückgabe) etwas mehr zu tun, da nun alle drei Tabellen
an der Aktion beteiligt sind.
Da Kunden und Bücher getrennt gesucht werden, werden die bereits gefundenen
Werte in Sitzungsvariablen festgehalten. Damit das Sitzungsmanagement funktioniert,
wird es am Beginn des Skripts gestartet:
session_start();
Dann werden die bestehenden Sitzungsvariablen wiedergeholt, soweit vorhanden.
Die Fehlervariable $error dient der Steuerung des entsprechenden #IF-Blockes.
Der Inhalt eines solchen Blockes wird ausgeführt, wenn die Variable existiert. Um
unter allen Umständen zu verhindern, dass die Variable ohne Vorliegen eines
Fehlergrunds einen Wert enthält, wird sie zunächst zurückgesetzt:
unset($error);
543

544
Datenbanklösungen mit MySQL
Dann werden die entsprechenden Abfragen an die Datenbank gesendet. Beim
Einfügen wird die zulässige Ausleihzeit des Buches fest auf 30 Tage gesetzt. Die
Tabelle nutzt außerdem die Spalte active, um festzuhalten, welche Datensätze
aktiv sind. Um eine Historie des Benutzerverhaltens zu erhalten, werden die
Datensätze bei Rückgabe des Buches nicht gelöscht, sondern der Wert in der
Spalte active wird lediglich auf 0 gesetzt:
UPDATE lendout SET active = 0 WHERE id = {$_GET['id']}
Die Anzeige der noch verfügbaren Bücher nutzt dieselbe Spalte, was die Abfrage
sehr einfach macht:
SELECT COUNT(*) AS lent FROM lendout
WHERE books_id=$book_id AND active=1
Etwas komplexer ist die Abfrage der Liste der Ausleihvorgänge (Historie). Hier werden
Datumsfunktionen von MySQL benutzt, um die Anzahl der noch verbleibenden
Ausleihtage festzustellen und gegebenenfalls eine Meldung anzuzeigen, wenn
ein Buch überfällig ist. Damit kann verhindert werden, dass säumige Nutzer weitere
Bücher ausleihen.
SELECT id, books_id,
DATE_FORMAT formatiert das interne Datumsformat für die Ausgabe im Deutschen
Format:
DATE_FORMAT(lendingdate, '%d.%m.%Y') AS lendingdate,
Die IF-Funktion ermittelt die Datumsdifferenz. Dazu wird mit TO_DAYS ein Tageszähler
ermittelt und mit dem aktuellen Datum (CURDATE) verglichen. Als Vergleichswert
wird die individuelle Ausleihdauer (in lendingperiod) herangezogen,
sodass die Funktion auf vereinbarte Verlängerungen korrekt reagieren kann. Die
IF-Funktion gibt bei wahrer Bedingung den ersten Teil zurück (hier das Wort
»Überfällig«), andernfalls einen Text, der mittels CONCAT zusammengesetzt wird.
IF(TO_DAYS(CURDATE())-TO_DAYS(lendingdate) > lendingperiod,
'Überfällig',
CONCAT erlaubt die Angabe mehrerer Parameter, die zu einer Zeichenkette zusammengefasst
werden, unabhängig vom Datentyp. Der Name der damit neu erzeugten
Spalte wird als due (fällig) bezeichnet:
CONCAT('Noch ',
30 - (TO_DAYS(CURDATE())-TO_DAYS(lendingdate)),
' Tage') ) AS due

Die Seiten des Projekts
Als Auswahlkriterium gilt logischerweise der ausgewählte Nutzer. Außerdem werden
nur offene Leihvorgänge angezeigt:
FROM lendout
WHERE reader_id=$reader_id
AND active=1
Die Übergabe der Abfrageergebnisse an das Array $history korrespondiert wieder
mit der Vorlage:
while($arr = $result->fetch_assoc())
{
$history[] = $arr;
}
In der Vorlage wird beispielsweise die Fälligkeit folgendermaßen ausgegeben:
{$history:due}
Wie das fertig aussieht, kann der nächsten Abbildung entnommen werden:
Abbildung 13.7:
Die Ausleihseite in Aktion
545

13.4 Ausblick
546
Datenbanklösungen mit MySQL
Die vorgestellte Bibliothek zeigte zwei entscheidende Techniken:
Funktionsweise eines rudimentären Template-Systems
Praktische Anwendung der MySQLi-Bibliothek
Freilich bleibt noch einiges zu tun, um ein solches System praxistauglich zu
machen. Dazu gehört zuerst sicher eine vernünftige Gestaltung, die mit einer
Reihe von Maßnahmen einhergeht. Zuerst sollte eine zentrale Datei erstellt werden,
die CSS-(Style)-Definitionen enthält und in allen Vorlagen Verwendung findet.
Außerdem fehlen noch einige grundlegende Funktionen:
Benutzerverwaltung und Absicherung gegen unbefugten Zugriff.
Regalverwaltung. Es gibt zwar bereits eine Spalte shelf, aber diese wird nicht
benutzt. Für Benutzer könnte sich daran eine Suchfunktion anschließen, über
die die Bücher schnell gefunden werden.
Fehlermanagement. Datenbank- und Bedienfehler führen meist zum Programmabbruch
Online-Zugriff. Die derzeitige Lösung ist praktisch nur intranet-tauglich. Für
eine auch online betreibbare Bibliothek sind noch einige Ergänzungen
(Benutzeranmeldung, Benutzerdienste, Sicherheitsfunktionen) einzubauen.
Hilfen bei der Erfassung von Buchdaten.
Zumindest der letzte Punkt kann eine echte Erleichterung sein. Dazu finden Sie
im nächsten Kapitel XML und Webservices ein entsprechendes Projekt, das den
Amazon-Webservice nutzt, um vollständige bibliografische Daten zu einem Buch
auf Grundlage der ISBN zu beschaffen. So ist auch der Katalog schnell gefüllt.
Nicht zuletzt kann auch die Umstellung auf ein kommerzielles Templatesystem
wie phpTemple ein Schritt hin zu einer schnell erstellten und leicht zu wartenden
Lösung sein, weil hier beispielsweise die SQL-Abfragen unverändert übernommen
werden können. Auf PHP kann weitgehend verzichtet werden, weil einige Makrofunktionen
– gesteuert über XML-Tags – die Arbeit erledigen.

13.5 Kontrollfragen
1. Wozu werden Template-Systeme eingesetzt?
Kontrollfragen
2. Erweitern Sie die Applikation, sodass zu jedem Leser der Bibliothek mehrere Telefonnummern
gespeichert werden können. Wie gehen Sie vor?
3. Formulieren Sie eine SQL-Abfrage, die die nötigen Daten zur Erstellung von
Mahnschreiben erzeugt, um säumige Leser auf die bereits abgelaufene Rückgabefrist
hinzuweisen.
547

XML und
Webservices
14

550
XML und Webservices
XML ist inzwischen für viele Anwendungen eine fest etablierte Technologie. Mit
PHP5 fanden auch neue, vereinheitlichte Bibliotheken Verwendung, die die Verarbeitung
und Erzeugung von XML noch einfacher machen.
14.1 Vorbemerkungen
Dieser Abschnitt klärt in knapper Form über einige Grundlagen auf, die Sie unbedingt
beherrschen sollten, bevor Sie praktisch mit XML arbeiten.
XML
XML ist eine Auszeichnungssprache für Dokumente, die strukturierte Informationen
enthalten. Derartige Informationen enthalten beliebigen Inhalt, also Text,
Bilder usw. und Angaben darüber, was dieser Inhalt bedeutet; eine Art Semantik
des Inhalts. In einem XML-Dokument wird eine Überschrift nicht deshalb zur
Überschrift, weil Sie in einer bestimmten Weise erscheint, sondern weil sie explizit
als Überschrift markiert wurde. Überhaupt spielt die Formatierung keine Rolle
und ist auch technisch nicht möglich. Erst das Ausgabegerät kann die Informationen
anhand ihrer Struktur in eine für den Menschen (oder andere Maschinen)
sinnvoll formatierte Form überführen.
XML ist eine so genannte Markup-Sprache (XML = Extensible Markup Language).
Sie dient der Erstellung von Strukturen für Dokumente. XML ist ein Standard,
der die Art der Strukturierung beschreibt.
Was ist ein Dokument?
Die Anzahl der Applikationen, die XML bereits nutzen, unterstützen oder sogar
darauf angewiesen sind, wächst drastisch. XML ist längst im Alltag angekommen
und keineswegs mehr ein Exot unter den Datenformaten. Webprogrammierer, vor
allem mit einem Hintergrund im grafischen Bereich, werden das vielleicht noch
nicht so empfunden haben. Wer jedoch mit Datenformaten hantiert, kommt
inzwischen fast unweigerlich mit XML in Berührung. Allerdings ist XML kein Allheilmittel
und auch kein Ersatz für relationale Datenbanken. Es ist eine sinnvolle
Ergänzung, die vor allem den systemübergreifenden Datenaustausch stark vereinfacht.

Vorbemerkungen
XML-Dokumente sind die Basis dieses Datenaustauschs. Letztlich ist XML immer
wieder eine Datei, gleich ob sie als solche im Dateisystem abgelegt oder als Teil
einer HTTP-Anforderung gesendet wird. Der Sinn eines solchen Dokuments
ergibt sich aus der gewählten Strukturbeschreibung. Ein XML-Dokument kann
deshalb Webseiten beschreiben (XHTML), Vektorgrafiken enthalten (SVG),
mathematische Formeln darstellen (MathML) oder sogar Rechnungen beinhalten
(EMC). Es gibt Tausende derartige vordefinierte Formate und weitere lassen sich
jederzeit mit bestimmten Werkzeugen (und entsprechenden Fachkenntnissen)
entwickeln. XML selbst ist also nur eine Art Metasprache, die eine Vorschrift zur
Definition von Datenformaten darstellt. XML-Dokumente entstehen, indem sie
dieser globalen Vorschrift genügen, egal ob die konkrete Struktur im Einzelfall
sinnvoll ist oder nicht.
XML versus HTML
XML und HTML haben nur oberflächlich etwas gemeinsam. In HTML ist sowohl
der Satz an Formatanweisungen als auch deren Semantik festgelegt. Das Tag
bezeichnet seinen Inhalt als fett und es wird erwartet, dass ein Ausgabegerät dies
auch so darstellt. Das Tag ist dagegen bedeutungslos und wird ignoriert.
Zugleich wird ein Ausgabegerät (der Browser) definiert und damit das Verhalten
der mit HTML markierten Dokumente fixiert.
XML ist universeller und legt solche Regeln nicht fest. Die Ähnlichkeit hat ihren
Ursprung in den gemeinsamen Wurzeln. HTML wurde auf der Basis der Urform
aller Auszeichnungssprachen, SGML, entworfen und letztlich ist XML eine vereinfachte
Form von SGML. Daher rührt die Ähnlichkeit.
XML definiert niemals selbst eine Semantik oder ein Satz von Tags. Dies ist Aufgabe
der anwendenden Instanz. Ein Sinn aus einem XML-Dokument ergibt sich
erst, wenn eine bestimmte, konkrete Auszeichnungssprache, den Regel von XML
folgend, entworfen wurde. In diesem Abschnitt wird noch die Variante RSS vorgestellt,
die der Erstellung von Dokumenten dient, die Einträge in einem Weblog
beschreiben. Für HTML gibt es auch eine Entsprechung in XML, XHTML
genannt.
Um nun die Semantik (den Sinn) in ein Dokument zu bekommen, benötigt man
eine Instanz, die in der Lage ist, XML zu interpretieren. Einen Sinn kann man freilich
nur erkennen, wenn man das Ziel der Darstellung kennt. Ohne ein Programm,
das eine Weiterverarbeitung vornimmt, bleibt XML Selbstzweck. Deshalb kommt
diesem Verarbeitungsprozess, nicht zuletzt in PHP, eine große Bedeutung zu.
551

Warum XML?
552
XML und Webservices
Aus der einleitenden Darstellung wird sich nicht zwingend ableiten lassen, warum
XML nun eine so große Bedeutung zukommt. XML wurde für reichhaltig strukturierte
Dokumente entworfen, die ein hohes Maß an Automation bei der Verarbeitung
erfordern.
Weder HTML noch SGML können dies in dieser exzessiven Form leisten. HTML
scheitert an der Vermischung von Struktur und Semantik, was die Nutzbarkeit einschränkt1
. SGML ist universell, zugleich aber sehr viel komplizierter und mit vielen
Nebeneffekten durch die komplexe Syntax belegt. Programme, die SGML gut
verarbeiten, sind sehr teuer. Viele Anwendungen benötigen eine derartige Komplexität
nicht, weshalb sich SGML außerhalb der Druckindustrie nie durchgesetzt
hat.
XML ist einfacher, klar strukturiert und leicht zu lesen. Programme, die XML verarbeiten
– so genannte Parser – sind leicht zu erstellen und zu perfektionieren.
Praktisch existieren sie für alle Sprachen, Plattformen und Systeme in vollkommen
ausgereifter Form. Im Verbund mit der technischen Unterstützung wird XML
praktisch einsetzbar – deshalb ist XML so wichtig.
Wie XML definiert ist
XML wird durch eine Reihe von Dokumenten definiert, die alle im Web zugänglich
sind. Sie sind teilweise äußerst abstrakt und sehr technisch, im Alltag also
wenig hilfreich. Ein Blick hinein kann dennoch nicht schaden, um ein Gefühl für
den Hintergrund zu bekommen. Wer selbst XML-Formate entwerfen möchte,
muss diese Dokumente tatsächlich verstanden haben. Hier folgt eine Auswahl:
Extensible Markup Language (XML) 1.0 (http://www.w3.org/TR/WD-xml)
Definiert die Syntax von XML, sozusagen die Mutter aller Dokumente.
XML Pointer Language (XPointer, http://www.w3.org/TR/1998/WD-xptr-
19980303) and XML Linking Language (Xlink, http://www.w3.org/TR/1998/
WD-xlink-19980303)
Beide Standards definieren Wege, um Links (Verknüpfungen) zwischen
Datenquellen zu definieren. Sie sind quasi der Ersatz des HTML-Tags in
der XML-Welt. XPointer beschreibt, wie eine Ressource adressiert wird (wo
1 Für seinen ureigenen Zweck, nämlich Webseiten, war dies jedoch sehr sinnvoll.

Vorbemerkungen
man sie findet), während XLink die Beziehungen zwischen zwei oder mehr
Ressourcen definiert.
Extensible Style Language (XSL) (http://www.w3.org/TR/WD-xsl)
Dieser Standard definiert die globale Methodik der Formatierung und Transformation
(letzteres im wichtigen Teilstandard XSLT). Damit wird für XML
die Brücke zur realen Welt der Ausgabegeräte geschaffen. Eine einführende
Beschreibung folgt im nächsten Abschnitt.
XPath und XQuery
Für die gezielte Auswahl von Teilstrukturen aus einem XML-Dokument dient
die Abfragesprache XPath. XQuery dient ähnlichen Zwecken und ist bei sehr
datenorientierten Strukturen von Vorteil, da es Ähnlichkeiten mit SQL aufweist.
XPath ist bereits seit einiger Zeit etabliert, XQuery noch in der Entwicklung
begriffen.
DTD und Schema
Vor der Struktur steht die Strukturdefinition. Eine DTD (Document Type Definition)
definiert, welche Tags wie von anderen abhängen. Leider ist die DTD
selbst nicht in einem XML-Format definiert, was die automatisierte Verarbeitung
etwas erschwert. Das neuere XML Schema ist dagegen selbst ein XML-
Dialekt. Im Gegensatz zur DTD weist es einen starke Unterstützung für Strukturen
auf, wie sie Datenbank nutzen. So sind beispielsweise viele elementare
Datentypen definiert.
Für die Arbeit mit XML und PHP sollten Sie mit XML, XSLT und in Grundzügen
mit XPath und DTD vertraut sein. Das ist mitnichten trivial, aber der Einsatz lohnt
sich.
XSLT
XSLT ist die Transformationssprache für XML-Dokumente. Mit Hilfe von XSLT
kann beispielsweise ein Teil eines XML-Datenpaketes in HTML umgewandelt
werden, damit der Browser es anzeigen kann. XSLT ist nicht einfach, aber
unglaublich mächtig.
Einführung
XSLT erlaubt eine weitgehend eigene Kontrolle der weiteren Verarbeitungsschritte
gegenüber dem, was fertige Programm anbieten. XSLT erlaubt es außer-
553

554
XML und Webservices
dem, fertige Vokabulare einfach zu übernehmen und an eigene Bedingungen
anzupassen. Damit wird der Datenaustausch weiter vereinfacht und verbessert.
Neben der Transformation von XML nach XML ist vor allem, die Umwandlung
von XML nach HTML und von XML nach Text von Bedeutung. XSLT erzeugt in
der Regel eine frei formatierte Datei. Dies ist meist XML, muss jedoch nicht. Als
Eingabe muss jedoch immer XML vorliegen. XSLT nutzt zur Auswahl von Knoten
die Abfragesprache XPath, womit sich der Kreis zu den anderen Standards wieder
schließt. Sie müssen also mindestens XPath und XSLT beherrschen, um praktisch
Umwandlungsprogramme schreiben zu können. PHP wird hierbei zur reinen
Hilfsschicht degradiert, es dient lediglich dem Laden der Dateien von der Festplatte
(oder von einem Server) und dem Rückschreiben der Ergebnisse.
Eine kompakte Einführung in XSLT
XSLT ist eine so genannte funktionale Programmiersprache. Das Prinzip unterscheidet
sich grundlegend von den objektorientierten oder imperativen Sprachen,
wie beispielsweise PHP. Der Programmfluss selbst wird in erster Linie durch Automatismen
initiiert, in zweiter Linie dann durch Regeln. Regeln definieren Sie, um
bestimmte Effekte beim Auftreten von bestimmten Daten zu erreichen. Vorteil
derartiger Systeme ist die weitgehende – bei XSLT per Definition die vollkommene
– Befreiung von Seiteneffekten. Wenn eine Regel gilt, dann wird diese und
nur diese ausgeführt und dies in immer der gleichen Art und Weise. Dazu gehört
auch, dass Variablen zwar verfügbar sind, beispielsweise um einer Regel einen
Wert zu übergeben, ihren Inhalt aber nachträglich nicht ändern können. Sie verhalten
sich also eher wie die Konstanten in PHP, abgesehen davon, dass der Inhalt
dynamisch definiert werden kann. Nachträgliche Änderungen könnten Seiteneffekte
erzeugen, was nicht erlaubt ist.
Dennoch kann man damit erstaunlich effektiv programmieren und verblüffende
Resultate erzielen. Nicht immer ist XSLT die perfekte Sprache. Richtig leistungsfähig
wird sie erst in Kombination mit einer modernen objektorientierten Sprache,
die hinreichende imperative Merkmale aufweist. Es ist nahe liegend, Transformation
und Programm mit PHP in einen Kontext zu überführen. Zuvor sind jedoch
wenigstens elementare Kenntnisse von XSLT notwendig.

Die Basisregeln in XSLT
Vorbemerkungen
XSLT basiert auf XML, weshalb jede Datei durch die entsprechende Deklaration
eingeleitet wird. Dann folgt das Wurzelelement . Das W3C empfiehlt
als Standardnamensraum xsl; diese Angabe ist aber im Prinzip freiwillig. Es
ist jedoch empfehlenswert, generell den Standardnamensraum zu verwenden.
Daraus ergibt sich folgendes Grundgerüst für XSLT:
Listing 14.1: Ein leeres XSLT-Programm-Fragment
Durch die Erweiterung des Attributes xmlns wird der Namensraumalias xsl festgelegt.
Zwischen den Wurzelelementen wird nun das Regelwerk aufgebaut. Eine
zentrale Rolle spielt das Element . Templates (dt. Vorlagen) bilden
die Stufen der eigentlichen Transformation. Dabei gibt es zwei Arten von Templates.
Zum einen können sie durch eine XPath-Anweisung in ihrer Zuständigkeit
programmiert werden. Die folgende Regel zeigt, wie jedes Element zu
einer Ausgabe im Ausgabedatenstrom führt:
NAME
Eine andere Methode ist der Aufruf benannter Vorlagen, dazu später mehr. Der
Inhalt des Elements findet hier freilich noch keine Berücksichtigung. Text kann,
wie gezeigt, direkt ausgegeben werden. Beachten Sie dabei, dass es sich auch hier
um wohlgeformtes XML handeln muss; HTML muss also gegebenenfalls den
Regeln von XHTML 1.0 entsprechend modifiziert werden.
Wenn Sie eine Vorlage mit benennen, können
Sie diese folgendermaßen aufrufen:
Soll explizit Text ausgegeben werden, der mit dem verwendeten XML-Editor 2
nicht darstellbar ist, muss das -Element eingesetzt werden. Das ist
eigentlich – nach der Spezifikation – immer notwendig. Die direkte Angabe von
Text oder Tags ist eine Vereinfachung.
2 Schreibt man XSLT mit einem einfachen Editor, trifft dies nur bedingt zu.
555

556
XML und Webservices
Hier folgt ein Zeilenumbruch: 0x0A
Wo Text ist, sind Kommentare nicht weit. Diese entsprechen, XML-konform, den
aus HTML bekannten und werden nicht in den Ausgabedatenstrom übernommen:
Vorlagen werden meist verschachtelt angewendet. Das folgende Beispiel zeigt das
Grundgerüst einer HTML-Seite, wie sie mit XSLT erzeugt wird:
Zuerst erkennt der XSLT-Prozessor hier, dass die Vorlage das Wurzelelement der
XML-Quelle verarbeitet. Dann wird das Grundgerüst der HTML-Seite erstellt.
Innerhalb des Body-Tags wird versucht, alle übrigen Elemente durch Aufruf der
passenden Vorlagen zu verarbeiten. Dass keine Parameter
hat, ist ein spezieller Fall. Er setzt voraus, dass alle Elemente irgendwo auf eine
passende Vorlage stoßen, wobei der Prozessor den besten Treffer auswählt und diesen
– und nur diesen – ausführt.
Allerdings besitzt der Prozessor eine Fallback-Funktion. Wenn kein Template
zutrifft, wird der Inhalt des aktuellen Tags genommen und als gültiger Ausgabewert
betrachtet. Voraussetzung ist aber, dass wenigstens an einer Stelle
steht, um die Ausgabe auszulösen.
Sollen Inhalte von Tags gezielt ausgegeben werden, was sicher der häufigste Weg
ist, findet Verwendung. Das Attribut select wählt den Inhalt des
durch eine XPath-Anweisung ermittelten Knotens und die gesamte Anweisung gibt
diesen als Zeichenkette aus.
Beim Einsatz innerhalb einer Vorlage bezieht sich der Pfad, den select akzeptiert,
auf den übergebenen Knoten, ist also relativ. Sie können aber absolute Angaben

Vorbemerkungen
verwenden. Der allein stehende Punkt reflektiert in XPath den aktuellen Knoten,
im Beispiel also den Inhalt des Tags . Auf eben diesem Wege werden auch
Attribute gelesen. Das folgende Beispiel sucht nach Elementen vom Typ und
gibt den Inhalt des Attributes href aus:
Der direkte Zugriff mit einer absoluten XPath-Anweisung wäre a/@href. Sie können
auf den Parameter eines Attributes auch direkt zugreifen. Ein -Tag
wird folgendermaßen in transformiert:
Die Schreibweise mit den geschweiften Klammern ist immer dann angebracht,
wenn der Einsatz eines Tags aufgrund der Syntax nicht möglich ist. Andererseits ist
es mit und möglich, beliebige Tags indirekt zu
erzeugen.
Mit XSLT programmieren
Bei XSLT spricht man von einer funktionalen Programmiersprache. Zum Programmieren
gehören jedoch nicht nur Regeln, wie sie in XSLT durch die Vorlagen
gebildet werden, sondern auch Programmanweisungen.
Zuerst soll eine einfache Verzweigung mit vorgestellt werden:
Dieses Verzeichnis enthält Dateien
Der Test kann verschiedene Operatoren und Funktionen verwenden, um Knoten
nach allerhand Kriterien zu untersuchen. Eine Else-Anweisung gibt es übrigens
nicht, hierfür ist die Mehrfachverzweigung gedacht:
Archiv
Compressed
557

558
XML und Webservices
Hidden
Unknown
Wollen Sie Listen von bestimmten Tags an einer Stelle ausgeben, ist
sehr praktisch, was ähnlich wie das foreach von PHP funktioniert. for-Schleifen
im Sinne imperativer Programmierung gibt es jedoch nicht, weil veränderliche
Zustände nicht erlaubt sind.
Die -Anweisung gibt, wie auch, jeweils einen aktuellen
Knoten für jedes Element aus, das gefunden wurde. Deshalb funktioniert
auch hier der verkürzte Zugriff auf den Inhalt mit dem Punkt-Alias.
Von Interesse ist oft auch eine Sortiermöglichkeit. Sie können dazu innerhalb
einer Schleife mit eine Anweisung platzieren, die das zuverlässig erledigt:
Das Element ist übrigens auch in anwendbar.
Es versteht freilich einige Attribute mehr, mit denen die Steuerung der Sortierung
erfolgen kann.
Was Sie in XSLT nicht finden, sind die Anweisungen »for« und »while«. Beide
benötigen Variable, deren Zustand sich ändert. Das ist in funktionalen Sprachen
nicht möglich, weswegen die Anweisungen nicht sinnvoll sind. Komplexere
Schleifen werden durch Rekursion (Selbstaufruf einer Vorlage) und Parameter
ermöglicht. Oft ist dies kompakter als vergleichsweise imperative Programme, für
PHP-Programmierer aber möglicherweise ungewohnt.
Variablen sind dennoch verwendbar, sie verhalten sich aber ähnlich den Konstanten
in anderen Sprachen. Sie können Werte, Knoten oder Knotenbäume speichern:

Variable können natürlich auch komplexere Inhalte aufnehmen:
Vorbemerkungen
TRUE
FALSE
Sie sehen im letzten Beispiel auch die Verwendung von XPath-Funktionen. Variablen
gelten nur innerhalb der Vorlage oder der Schleife, in der sie definiert
wurden. Dieses Verhalten ist nicht modifizierbar, das heißt, es gibt keine Modifikatoren
wie public oder private, wie sie bei den objektorientierten Funktionen von
PHP anwendbar sind.
Ähnlich wie Variablen werden auch Parameter verwendet. Damit können Sie
einer Vorlage verschiedene Werte übergeben, damit diese sich je nach Art des Aufrufs
unterschiedlich verhält. Der Aufruf sieht folgendermaßen aus (am Beispiel
einer benannten Vorlage):
no
Innerhalb der Vorlage werden die übergebenen Parameter dann so verwendet:
...
Das select-Attribut in bestimmt einen Standardwert, wenn der Parameter
nicht übergeben wurde.
XSLT praktisch verwenden
XSLT verfügt über einige komplexere Anweisungen, die für größere Projekte von
Bedeutung sind. Dazu gehört zum Erzeugen fortlaufender Nummern
oder Buchstabenfolgen.
Oft ist auch der Umgang mit ganzen Knoten notwendig, statt dem Textinhalt des
Knotens. Dann findet Verwendung. Sollen Knoten und Attribute
559

560
XML und Webservices
kopiert werden, können mehrere Anweisungen mit zusammengefasst
werden.
Das folgende Beispiel kopiert ein XML-Dokument vollständig in ein anderes:
Wenn Sie sich die Frage stellen, warum ein Dokument ausgerechnet mit XSLT
unverändert kopiert werden sollte, ist ein Blick auf angebracht. Mit
dieser Anweisung kann die Kodierung des Ausgabestromes gesteuert werden. Das
Tag steht immer am Anfang des Dokumentes. Wenn Ihr XML-Dokument UTF-8
kodiert ist, können Sie es mit der Kopiervorlage des letzten Beispiels leicht in ein
anderes Format bringen, nebenbei auch ins HTML 4.0-Format:
Sie können weitere XSLT-Dateien mit Hilfe der Anweisungen und
importieren. Die erste Funktion kann ein Dokument so einfügen,
als wäre der Inhalt an dieser Stelle geschrieben worden. Der Import hat eine
geringe Priorität. Stehen vorhandene und importierte Regeln miteinander im Konflikt,
unterliegen die importierten.
Die XSLT-Funktionen
Transformationen laufen oft in Abhängigkeit von konkreten Daten ab. XSLT stellt
deshalb einige elementare Funktionen zur Verfügung, die meist in select- und test-
Attributen benutzt werden.
Funktion Beschreibung
boolean()
number()
string()
Typumwandlungen ausführen. Manche Funktionen brauchen
einen bestimmten Typ als Parameter.
format_number() Formatiert Zahlen für die Ausgabe.
Tabelle 14.1: XSLT-Funktionen

Funktion Beschreibung
ceiling()
floor()
round()
Vorbemerkungen
Zahlenberechnungen und Runden. Die Funktionsweise
entspricht den Funktion ceil, floor und round in PHP.
concat() Verbindet Zeichenketten, ähnlich der Kombination mit
dem Punkt-Operator in PHP.
contains()
starts-with()
Ermittelt, ob eine Zeichenkette bestimmte Zeichen enthält
bzw. ob sie mit einer bestimmten Zeichenfolge beginnt.
normalize_whitespace() Kontrolliert den Umgang mit Leerzeichen.
string-length() Ermittelt die Anzahl Zeichen einer Zeichenkette.
substring()
substring-before()
substring-after()
translate() Tauscht Zeichen aus.
count()
sum()
generate-id()
local-name()
name()
false()
true()
not()
current()
last()
position()
Ermittelt Teile einer Zeichenkette, entweder nach der Position
oder in Abhängigkeit von einem Schlüsselzeichen
Zählt Knoten und summiert Werte aus Knotenlisten.
Funktionen zum Umgang mit Knoten, der Erzeugung von
Identifikatoren usw.
Diese Funktionen können Boolesche Werte für Boolesche
Ausdrücke beschaffen. Dies ist erforderlich, weil innerhalb
von Ausdrücken kein Zugriff auf Schlüsselwörter (wie true)
besteht.
Bestimmt die Position des Zeigers in Knotenlisten .
document() Realisiert den Dateizugriff, lädt ein anderes Modul.
key()
id()
Einen Knoten mit bestimmten Eigenschaften finden.
element-available() Eine Parserfunktion suchen und mitteilen, ob der Parser
diese unterstützt.
Tabelle 14.1: XSLT-Funktionen (Forts.)
561

562
XML und Webservices
Die Funktionen finden auch bei der Knotenselektion mit XPath Verwendung.
Mehr dazu im nächsten Abschnitt.
XPath
XPath ist eine Abfragesprache, die direkt oder über XSLT zum Einsatz kommt, um
Knoten oder Knotenlisten zu ermitteln.
Daten mit XPath suchen
Mit Hilfe einer Transformation wurde im letzten Abschnitt bereits eine Auswahl
aus XML-Daten vorgenommen. Immer dann, wenn auf Knoten oder Inhalte mit
match="" oder select="" zugegriffen wurde, kam bereits XPath zum Einsatz. Diese
einfache Form reicht in der Praxis nur selten aus. Der vollständige Name für
XPath lautet XML Path Language 1.0.
Um in der hierarchischen Struktur eines XML-Dokuments gezielt Knoten adressieren
zu können, wird XPath eingesetzt. Ohne eine solche Sprache würden Dokumente
immer sequenziell durchlaufen werden, was wenig praxistauglich ist.
Gerade bei Webanwendungen, die oft vielen Benutzern einen Ausschnitt aus
einer großen Datenmenge zur Verfügung stellen, ist die schnelle Auswahl eminent
wichtig. Die Abfrage durch Beschreibung eines Pfades und verzichtet dabei auf
Schleifen oder andere zyklische Elemente. Damit ist die Konstruktion zur Laufzeit
und in Abhängigkeit vom aktuellen Auftreten von Knoten möglich. Wie der Name
der Sprache andeutet, ähnelt die Auswahl von Knoten den Pfadangaben im Dateisystem
eines Betriebssystems. Das ist nahe liegend, weil auch dort Daten hierarchisch
angeordnet sind. Eine typische XPath-Anweisung könnte also folgendermaßen
aussehen:
eintrag/name/vorname
Sie adressiert einen Knoten , der Kind von ist, was wiederum
Kind von sein muss:
Es gibt verschiedene Knotentypen in XML. XPath muss diese adressieren können.
Konkret unterschieden werden die in der folgenden Tabelle dargestellten Typen:

Tabelle 14.2: Knotentypen, die mit XPath adressiert werden können
Grundlagen für die Entwicklung von Ausdrücken
Vorbemerkungen
XPath-Knoten Darstellung Kurzform
Wurzelknoten /
Elementknoten ElementName (keine Kurzform)
Kindknoten child:: (kann entfallen)
Attributknoten attribute::AttributName @AttributName
Textknoten self::node() .
Elternknoten parent::node() ..
Prozessinformation Nicht darstellbar
Namensraum alias:
XPath basiert auf Ausdrücken, die den Weg zu einem Knoten beschreiben. Der
Weg kann – ebenso wie beim Dateisystem – durch absolute oder relative Pfadangaben
beschrieben werden. Absolute Angaben beginnen immer an der Dokumentenwurzel.
Wenn der Ausdruck einen Pfad über mehrere Knoten hinweg beschreibt,
werden die Elemente durch Schrägstriche getrennt:
dirlist/directory/file
Jedes dieser Elemente wird allgemein als Lokalisierungsschritt bezeichnet. Die
eben gezeigte und häufig verwendete Darstellung durch einen Knotennamen ist
eine verkürzte Form. Tatsächlich kann jeder Schritt aus drei Teilen bestehen:
1. Achsenbezeichner
2. Knotentest
3. Prädikate
Der Achsenbezeichner modifiziert die Auswahl des Knotens auf der Grundlage
seiner Position im Baum. Als Trennzeichen zwischen dem Achsenbezeichner und
dem nächsten Teil des Ausdrucks werden zwei Doppelpunkte geschrieben "::".
Dies wird im nächsten Abschnitt noch weiter erläutert.
563

564
XML und Webservices
Der Knotentest beschreibt den Knoten selbst, beispielsweise eine direkte Auswahl
durch Nennung des Tagnamens. Die Prädikate stehen in eckigen Klammern und
werden meist zur Auswahl von Attributen verwendet. Insgesamt ergibt sich beispielsweise
folgender Ausdruck:
child::directory[attribute::hasfiles='true']
child:: ist der Achsenbezeichner, hier wird also beginnend von der aktuellen Position
das nächste Kindelement gesucht. Dann wird das Element selbst benannt:
directory. Es wird also das nächste Kindelement mit dem Namen
gesucht. Das Prädikat schränkt die Suche weiter ein; hier auf das Vorhandensein
eines Attributes hasfile mit dem Parameter 'true'3 .
Um solche Ausdrücke nun entwickeln zu können, ist in erster Linie eine Kenntnis
der Achsenbezeichner notwendig.
Die XPath-Achsenbezeichner
Achsenbezeichner können einen oder mehrere Knoten auswählen. Die konkrete
Auswahl hängt vom aktuellen Knoten ab. Wenn ein Dokument sequenziell durchlaufen
wird, können die Bezeichner mehrere Knoten selektieren. Die folgende
Tabelle zeigt alle Achsenbezeichner für Elemente auf einen Blick.
Elemente sind hier Tag-Namen, also keine Attribute und keine Namensraumbezeichnungen:
Achsenname Suchrichtung Beschreibung
self – Der aktuelle Knoten.
child vor Die Kinder des Knotens.
parent Die Eltern des Knotens.
descendant vor Alle Nachfahren (Kinder und Kindeskinder) .
descendant-or-self vor Alle Nachfahren und der Knoten selbst.
ancestor rück Alle Vorfahren (Eltern und deren Eltern).
ancestor-or-self rück Alle Vorfahren und der Knoten selbst.
3 Die einfachen Anführungszeichen innerhalb der doppelten gehören bei XPath dazu.

Achsenname Suchrichtung Beschreibung
Tabelle 14.3: Achsenbezeichner für Element-Knoten
Vorbemerkungen
following vor Alle folgenden Knoten im Dokument, die
nicht direkte Nachfahren sind.
following-sibling vor Alle folgenden Geschwister.
preceding rück Alle vorhergehenden Knoten, die nicht
Eltern sind.
preceding-sibling rück Alle vorhergehenden Geschwister.
Neben den Achsenbezeichnern für Elemente gibt es noch zwei spezielle: attribute
zur Auswahl von Attributen und namespace zur Lokalisierung von Namensräumen.
Es bietet sich an dieser Stelle an, die Wirkung der Achsenbezeichner mit
einem Testprogramm zu lernen. Damit alle erdenklichen Kombinationen auch
getestet werden können, wird eine XML-Datei entworfen, die entsprechende Achsen
auch aufweist:
Listing 14.2: axischeck.xml – Testdatei zum Testen von Achsenzugriffen
Diese Datei dient im folgenden Beispiel als Basis für die ersten Programmierversuche
mit PHP und XPath. Sie ist so aufgebaut, dass aus den Elementnamen die
565

566
XML und Webservices
Position im Baum ablesbar ist, was für das Verständnis der XPath-Abfragen sinnvoll
ist.
Mit PHP5 XPath-Ausdrücke verarbeiten
Lesen Sie zunächst das folgende Listing:
Listing 14.3: xpathcheck.php – XPath-Achsenbezeichner ausprobieren

{
}
Vorbemerkungen
echo '';
echo 'Element-Beziehungen, ausgehend von
"Ebene1_2"';
foreach ($this->expressions as $expression)
{
$this->nodes =
$this->xp->query("//Ebene1_2/$expression::*");
echo "$expression";
echo "";
$this->PrintNodeList();
echo "";
}
echo '';
}
$x = new XPathCheck('data/axischeck.xml');
$x->ShowNodeList();
?>
Führt man diese Schritte für alle XPath-Standardanweisungen aus, bezogen auf
den Knoten als Startknoten, ergibt sich folgende Abbildung:
Abbildung 14.1:
Ausgabe der Knotenlisten
für alle
typischen Achsenbezeichner
Der Ausdruck selektiert lediglich die Achse (achsenbezeichner::*), wobei das *
zur Auswahl aller Elemente der Achse führt. In der Praxis könnten sich hier Elementnamen
anschließen, um die Auswahl einzuschränken, sowie eines oder
mehrere Attribute, die auftreten oder bestimmte Parameter aufweisen müssen.
567

568
XML und Webservices
Ein konkretes XML-Format: RSS
RSS dient dem Austauschen von Nachrichten und Inhalten über Nachrichtenseiten.
Auch große Nachrichtendienste wie Wired oder Slashdot bieten Informationen
zur Übernahme auf anderen Seiten an. Eine private Seite kann dies
deutlich aufwerten. Das Prinzip ist dabei einfach. Der RSS-Feed (ein XML-Fragment)
wird von der Spenderseite abgeholt. Enthalten ist der Nachrichtentext in
einer Art Zusammenfassung und ein Link zurück zum Spender, der zum Volltext
führt. Davon profitieren beide Seiten. Der Spender erhält Zugriffe durch Nutzer
fremder Seiten und der Empfänger hat ständig aktuelle Inhalte zu bieten, ohne
dafür irgendwelchen Aufwand treiben zu müssen.
RSS kann bis zu einzelnen Nachrichten und Stichwörtern herunter gebrochen
werden, nur die letzten Änderungen oder Aktualisierungen enthalten oder auch
zum Verfolgen von Einträgen in einer Änderungsliste dienen. Der Einsatzzweck
ist keineswegs auf Nachrichten beschränkt, die aus Sport oder Politik stammen,
sondern kann ebenso die Informationen einer Serverüberwachung umfassen.
RSS-fähige Programme werden als Aggregatoren bezeichnet, das sind quasi Datensammler
der Weblog-Gemeinschaft. Weblogs wiederum zeichnen sich selbst oft
durch die Fähigkeit aus, Inhalte im RSS-Format bereitstellen zu können. Auf diese
Art und Weise werden Weblogs gleichzeitig zu Spendern und Empfängern – ein
wilder Kreislauf aus Nachrichtenaustauschprogrammen entsteht.
Rückblick
RSS umfasst allerdings weit mehr als ein einfaches XML-Format zum Nachrichtenaustausch.
Ein Blick zurück ist hilfreich, um die Zusammenhänge zu verstehen
und die richtige Strategie zur Programmierung eigener RSS-Programme zu finden.
Die erste Version war RSS 0.90, entworfen von Netscape als Format zum Aufbau
von Portalen, die sich die wichtigsten aktuellen Nachrichten von großen Nachrichtenanbietern
holen. Diese Version war äußerst komplex, was einer schnellen
Verbreitung eher abträglich ist. Daraus entstand in kurzer Zeit RSS 0.91, eine vereinfachte
Ausgabe. Netscape verlor schnell das Interesse am Betrieb von Portalen
und die Fa. UserLand Software übernahm die weitere Entwicklung als Basis ihrer
kommerziellen Weblog-Produkte. In der Zwischenzeit spaltete sich eine weitere,
nicht kommerzielle Gruppe ab und entwarf ein weiteres Format, basierend auf
dem alten 0.90, bevor es die Vereinfachungen der 0.91 erfuhr. Dieses Format, sei-

Vorbemerkungen
nerseits mit dem ebenso sehr komplexen RDF verwandt, wurde als RSS 1.0
bezeichnet. UserLand war in diesen Prozess nicht involviert worden und torpediert
seitdem die Entwicklung mit einer Reihe eigener Versionen, die aus der 0.91-
Reihe fortgeführt wurden. Auf diesem Wege entstanden RSS 0.92, RSS 0.93 und
RSS 0.94. Weil die 1.0 bereits vergeben war, heißt die finale UserLand-Version
RSS 2.0. Womit das Chaos perfekt ist.
Welche Version man verwenden sollte
Es gibt mittlerweile sieben Versionen. Normalerweise macht eine derartige Versionspolitik
ein Produkt nachhaltig kaputt. RSS hat sich dennoch rasend verbreitet,
vermutlich aufgrund des anhaltenden Bedarfs am automatischen Informationsaustausch.
Die folgende Tabelle hilft, die richtige Version zu wählen:
Version Ursprung Hinweis Status Empfehlung
0.90 Netscape Obsolet
wegen 1.0
0.91 UserLand Besonders
einfach
0.92,
0.93,
0.94
1.0 RSS-
DEV
Working
Group
UserLand Umfassender
als 0.91
RDF-basiert,
erweiterbar,
offener
Standard
2.0 UserLand 0.9X
kompatibel,
erweiterbar
Offiziell obsolet
wegen 2.0,
aber noch sehr
populär
Obsolet
wegen 2.0
Tabelle 14.4: Übersicht über die RSS-Versionen
Nicht mehr verwenden.
Leicht zu verwenden für einfache
Ansprüche, interessant,
wenn spätere Migration auf 2.0
geplant ist.
Nicht mehr verwenden, besser
auf 2.0 setzen.
Stabil, aktuell Wird verwendet, wenn auch
mit RDF-Quellen gearbeitet
wird.
Stabil, aktuell Generell empfehlenswert.
569

570
XML und Webservices
Wie RSS praktisch aussieht
Für den Einsatz von RSS auf einer mit PHP programmierten Webseite braucht
man zuerst ein Programm, das RSS-Feeds anderer Seiten liest. Eigene Angebote
setzen immerhin auch eigene Nachrichten voraus, und die sind ungleich schwerer
zu produzieren. Das Lesen der Datenquelle ist einfach – sie ist unter einer spezifischen
URL zu erreichen. Auf Webseiten kann man diese meist hinter dem Bildchen
zu finden.
Das folgende Beispiel stammt von xml.com und ist in RSS 0.91 erstellt:
Listing 14.4: Ein RSS 0.91-Feed, gefunden auf xml.com
XML.com
http://www.xml.com/
XML.com features a rich mix of information and services
for the XML community.
en-us
Normalizing XML, Part 2
http://www.xml.com/pub/a/2002/12/04/normalizing.html
In this second and final look at applying relational
normalization techniques to W3C XML Schema data modeling, Will
Provost discusses when not to normalize, the scope of uniqueness
and the fourth and fifth normal forms.
The .NET Schema Object Model
http://www.xml.com/pub/a/2002/12/04/som.html
Priya Lakshminarayanan describes in detail the use of
the .NET Schema Object Model for programmatic manipulation of W3C
XML Schemas.
SVG's Past and Promising Future

Vorbemerkungen
http://www.xml.com/pub/a/2002/12/04/svg.html
In this month's SVG column, Antoine Quint looks back
at SVG's journey through 2002 and looks forward to 2003.
Die Datenquelle präsentiert einen Kanal (Thema), der einen Titel, den Link
zurück zur Quelle und eine Beschreibung enthält. Optional kann eine Sprache
angegeben werden, gefolgt von einer Reihe konkreter Einträge, die jeweils wieder
einen Titel, den Rücklink und eine Beschreibung enthalten.
In RSS 1.0 sieht exakt derselbe Inhalt etwas anders aus:
Listing 14.5: RSS1.0-Feed, identisch mit dem Inhalt aus Listing 14.4
XML.com
http://www.xml.com/
XML.com features a rich mix of information and services
for the XML community.
en-us
Normalizing XML, Part 2
http://www.xml.com/pub/a/2002/12/04/normalizing.html
571

572
XML und Webservices
In this second and final look at applying relational
normalization techniques to W3C XML Schema data modeling, Will
Provost discusses when not to normalize, the scope of uniqueness
and the fourth and fifth normal forms.
Will Provost
2002-12-04
The .NET Schema Object Model
http://www.xml.com/pub/a/2002/12/04/som.html
Priya Lakshminarayanan describes in detail the use of
the .NET Schema Object Model for programmatic manipulation of W3C
XML Schemas.
Priya Lakshminarayanan
2002-12-04
SVG's Past and Promising Future
http://www.xml.com/pub/a/2002/12/04/svg.html
In this month's SVG column, Antoine Quint looks back at
SVG's journey through 2002 and looks forward to 2003.
Antoine Quint
2002-12-04
Die Informationen sind hier ein wenig ausführlicher. So gehören auch der Name
des Autors und ein Datum dazu. Das Datum ist sehr sinnvoll, wenn man aus einer
großen Anzahl von Nachrichten nur die aktuellsten anzeigen möchte. Die Struktur
ist dennoch weitgehend der früherer RSS-Versionen angepasst. Wer kompatible
Software schreiben möchte, die mit Datenquellen beider Arten umgehen
kann (das ist heute leider notwendig, weil beide Versionen gleichermaßen benutzt
werden), kann sich mit folgenden »Umrechnungsregeln« zwischen 1.0 und 0.91
behelfen (aus der Sicht von 1.0):
1. Das Stammelement ist rdf:RDF statt rss. Beim Lesen mit PHP ist es nicht zwingend
erforderlich, dies zu prüfen – man kann der Quelle durchaus vertrauen.
2. RSS 1.0 verwendet den Namensraum http://purl.org/rss/1.0/ als Standardnamensraum.
Die RDF-spezifischen Elemente sind durch den eigenen RDF-

Vorbemerkungen
Namensraum http://www.w3.org/1999/02/22-rdf-syntax-ns# abgetrennt. Die
Spezifika von RDF kann man aber getrost ignorieren für einen einfachen
Nachrichtenleser. Metadaten (Autor, Datum) befinden sich im Namensraum
des so genannten Dublin Core4 http://purl.org/dc/elements/1.1/.
Wenn Sie nun mit einem Parser arbeiten, der Namensräume nur beschränkt
verarbeiten kann – wie SimpleXML in PHP5 – dann ignorieren Sie das einfach.
Innerhalb eines vollständigen RDF-basierten RSS 1.0-Feed dürften Elementnamenskonflikte
kaum auftreten. Der blanke Leseprozess ist also
unkritisch. Erzeugen lassen sich RSS-Quellen damit freilich nicht. Sie müssen
lediglich vertrauen, dass bei der Definition der Quelle die Standardaliase nicht
verändert wurden. Ein Parser, der Namensräume nicht kennt, wird den Elementnamen
als dc:creator lesen, nicht als creator. Solange Sie von einem fixen
Alias dc ausgehen, ist das in Ordnung. Tauscht das jemand gegen dublc aus,
versagt das Skript. Programme mit vollständiger Namensraumunterstützung
würden eine solche Änderung tolerieren. Letztere können auch erkennen, welche
Version benutzt wurde und ihre Strategie beim Verarbeiten anpassen.
3. Ein bedeutender Unterschied ist die Tatsache, dass das -Element außerhalb
des -Elements steht, bei RSS 0.91 war es genau umgekehrt. Zur
Verarbeitung beider Versionen muss man damit zwangsläufig Teile des Codes
doppelt schreiben. Nebenbei bemerkt: RSS 0.90 (außerhalb) und RSS 2.0
(innerhalb) zeugen von leichten Designzweifeln bei den Erfindern.
4. Das zusätzliche -Element innerhalb des -Elements kann ignoriert
werden. Es bedient lediglich native RDF-Parser.
RSS 2.0 wurde bereits mehrfach angesprochen. Auch hierfür ist ein Blick auf denselben
Inhalt im RSS 2.0-Format empfehlenswert:
XML.com
http://www.xml.com/
XML.com features a rich mix of information and services
for the XML community.
en-us
Normalizing XML, Part 2
4 Der Name geht zurück auf die Dublin Core Metadata Initiative, eine Organisation, die Beschreibungsformate
für Metadaten von Dokumenten entwirft (siehe http://dublincore.org).
573

574
XML und Webservices
http://www.xml.com/pub/a/2002/12/04/normalizing.html
In this second and final look at applying relational
normalization techniques to W3C XML Schema data modeling, Will
Provost discusses when not to normalize, the scope of uniqueness
and the fourth and fifth normal forms.
Will Provost
2002-12-04
The .NET Schema Object Model
http://www.xml.com/pub/a/2002/12/04/som.html
Priya Lakshminarayanan describes in detail the use of
the .NET Schema Object Model for programmatic manipulation of W3C
XML Schemas.
Priya Lakshminarayanan
2002-12-04
SVG's Past and Promising Future
http://www.xml.com/pub/a/2002/12/04/svg.html
In this month's SVG column, Antoine Quint looks back
at SVG's journey through 2002 and looks forward to 2003.
Antoine Quint
2002-12-04
RSS 2.0 verwendet Namenräume analog zu RSS 1.0, aber es wird kein RDF verwendet.
Ebenso wie bei RDF 0.91 gibt es keinen Standardnamensraum und die Inhalt
sind innerhalb des -Elements. Code, der flexibel mit RSS 0.91 und 1.0
umgehen kann, wird mit nur geringem Aufwand auch RSS 2.0 lesen können.

14.2 Einführung in die libxml2
Einführung in die libxml2
Generell ist XML ein Thema für Website-Entwickler, denn es gibt vielfältige
Anwendungen:
Webservices (basieren weitgehend auf XML)
Datenim- und -export aus und zu unbekannten oder inkompatiblen Datenquellen
Aufbereitung von XHTML für verschiedene Medien
Bereitstellung oder Konsumierung von RSS-Kanälen
In PHP 4 war nur der SAX-Parser Expat fester Teil des Pakets. Alle anderen Erweiterungen
waren entweder nicht immer vorhanden oder noch im Entwicklungsstadium
(und sind es bis heute). Applikationen, die XML nutzen, waren damit etwas
eingeschränkt, denn nicht alle Provider und Webhoster boten die nötige Unterstützung.
PHP DOM wurde zwar heiß diskutiert und oft als Wunderwaffe der XML-
Entwickler gepriesen, dümpelte aber mangels Provider-Unterstützung eher vor
sich hin. Wichtige Applikationen wie das Templatesystem phpTemple (http://
www.phptemple.de) sind jedoch auf XML angewiesen, um hohe Performance auch
bei anspruchsvollen Seiten zu ermöglichen.
Neu in PHP5
Anstatt des Sammelsuriums von teilweise unfertigen und inkompatiblen Bibliotheken
(XSLT von Ginger Alliance, Expat, XML DOM) wurde nun auf das sehr
weit entwickelten Projekt Gnome XML Parser libxml gesetzt. Die Vorgängerversion
war bereits die Basis für die XML DOM-Erweiterungen. Vielleicht haben Sie
bereits mit den DOM-Erweiterungen gearbeitet und herausgefunden, dass diese
von den drei Bibliotheken der schwächste Teil waren. Dies als die herausragende
XML-Neuerung in PHP5 anzupreisen erscheint nicht einsichtig. Allerdings lag die
schlechte Qualität nicht an der verwendeten Bibliothek, sondern an den Mängeln
der Integration in PHP. Dieses Problem wurde durch den Wechsel der Entwickler
und Verbesserungen in der Struktur der Programmierung beseitigt.
Die Gnome-Bibliothek liefert einen der schnellsten Parser, die es gibt. Sie ist relativ
jung und die Entwickler konnten von den Fehlern der anderen Parser lernen.
Und nicht zuletzt werden viele in der XML-Welt dringend benötigte Standards
unterstützt:
575

576
XML und Webservices
SAX- und DOM-Programmierschnittstellen
Validierung mit DTDs und XML Schema
XSLT, XPath, XPointer und Xinclude
Integrierte Parser für HTML und Docbook-XML
XMLSec (XML Security Library)
Insgesamt gewinnt PHP dadurch deutlich und es lohnt sich unbedingt, sich mit
der Bibliothek und den neuen Möglichkeiten intensiver auseinander zu setzen.
Für viele Projekte gibt es dazu auch keine Alternative, weil die weitere Unterstützung
der alten Bibliotheken nicht geplant ist. Andererseits bleiben die Funktionsschnittstellen
erhalten, um eine Abwärtskompatibilität zu gewährleisten. Es ist also
nicht zwingend erforderlich, alle XML-basierten Skripte nun umzuschreiben. Bis
auf wenige Ausnahmen sollten alle Programme unverändert laufen. Es lohnt sich
dennoch, den vorhandenen Code zu untersuchen, weil sich eventuell bessere oder
schnellere Möglichkeiten bieten und der eine oder andere »Work-Around« oder
»Dirty-Hack« sich nun sauber programmieren lässt.
Die neuen DOM-Funktionen
Die Kernfunktionen der DOM-Erweiterung sind inzwischen weitgehend stabil aus
Sicht der Entwicklung. Das ist sehr wichtig, weil ständige Änderungen an den Bibliotheken
den Einsatz in ernsthaften Projekten arg gefährden. Hier hatte PHP bislang
das Nachsehen gegenüber .NET und Java, wo es eine sehr solide und lange
Zeit stabile Basisplattform gab und gibt.
HTML verarbeiten
Webseiten bestehen aus HTML und HTML ist verwandt mit XML. Es sollte also
möglich sein, HTML mit einem XML-Parser zu verarbeiten. Weit gefehlt, denn
tatsächlich stammt HTML von der alten Auszeichnungssprache SGML ab, aus der
auch XML entwickelt wurde. XML definiert eine strengere Syntax und erlaubt
damit schnellere und stabilere Parser. Prinzipiell kann also ein XML-Parser einfache
HTML-Seiten nicht verarbeitet, bevor diese nicht »XML-tauglich« gemacht
werden. Auch dazu gibt es einen entsprechenden Standard: XHTML. In der Praxis
ist dies jedoch nicht immer einfach, weil man dazu spezielle Programme braucht,
die die Umwandlung vornehmen – oder PHP5.

Einführung in die libxml2
Das folgende Beispiel zeigt ein typisches, aus XML-Sicht nicht »wohlgeformtes«
XML-Dokument:
Listing 14.6: XmlDomBadHtml.html – Ein einfaches HTML-Dokument, nicht wohlgeformt
XML
HTML mit DOM verarbeiten
Diese Seite enthält nach XML-Regeln nicht wohlgeformte Tags.
Red
Blue
Green
Dem neuen DOM-Parser ist dies ziemlich egal, er liest diese HTML-Seite problemlos
ein. Das folgende Skript verarbeitet die Seite und agiert dabei mit Knoten,
Knotenauflistungen, Elementen und Attributen:
Listing 14.7: XmlDomHtml.php – Laden und Verarbeiten von nicht wohlgeformtem
HTML
getElementsByTagName('head');
$body = $doc->getElementsByTagName('body');
function getTitle ($head)
{
foreach ( $head as $header )
{
if ( $header->tagName == 'title' )
577

}
578
}
XML und Webservices
echo ("Page Title: ".$header->textContent.
"\n");
function parseBody($body)
{
$bodyTag = $body->item(0);
foreach ($bodyTag->childNodes as $element)
{
$content = htmlspecialchars(
utf8_decode($element->textContent));
switch ($element->tagName)
{
case 'h2':
echo "Header 2: $content\n";
break;
case 'p':
echo "Paragraph: $content\n";
break;
case 'form':
foreach ($element->childNodes as $input)
{
if ($input->nodeType != XML_ELEMENT_NODE) continue;
if ($input->tagName == 'select')
parseSelect($input);
}
break;
default:
echo $content->tagName.'';
break;
}
}
}
function parseSelect($select)
{
echo "Select:\n\n";
$options = $select->childNodes;
foreach ($options as $option)
{
$content = htmlspecialchars(

}
utf8_decode($option->textContent));
echo "{$content}";
if ($option->hasAttribute('selected'))
{
echo '

580
XML und Webservices
rung. Zusätzlich ist noch darauf zu achten, dass das Dokument gegebenenfalls
UTF-8-kodiert ist. UTF-8 ist das Standardzeichenformat für XML. Für die Ausgabe
im Beispiel wird außerdem noch HTML-Code sichtbar gemacht:
$content = htmlspecialchars(utf8_decode($element->textContent));
Die weitere Verarbeitung richtet sich nach dem gefundenen Elementnamen:
switch ($element->tagName)
Wenn man weitere Untersuchungen anstellt ist es wichtig zu wissen, welchen Typ
ein Knoten hat. Denn die von der Knotenliste extrahierten Knoten sind nicht
immer Elemente, sondern können auch Kommentare, Zeichen, Namensräume,
Prozessanweisungen usw. sein:
if ($input->nodeType != XML_ELEMENT_NODE) continue;
Informationen über die verwendbaren Konstanten finden Sie in der
Kurzreferenz am Ende des Kapitels.
In der Funktion parseSelect ist noch eine weitere Methode zu finden, die hier dazu
dient, die Existenz eines Attributes zu ermitteln:
if ($option->hasAttribute('selected'))
Die Abbildung zeigt, wie das Skript arbeitet:
Abbildung 14.2:
Verarbeitung
einer HTML-Seite
mit dem DOM-
Modul
Das DOM-Modul ist äußerst leistungsfähig und konnte hier nur oberflächlich
angerissen werden. Für größere XML-Projekte ist es unbedingt zu empfehlen und
die hier gezeigten Techniken lassen sich in jeder Richtung ausbauen. Informieren
Sie sich in der Kurzreferenz über die verfügbaren Methoden und Eigenschaften,
um einen schnellen Einstieg zu finden.

14.3 SimpleXML
SimpleXML
Neben der DOM-Erweiterung, die auf libxml basiert, fand eine zweite XML-
Schnittstelle Eingang in PHP5: SimpleXML. Diese Bibliothek ist bekannt als
»Object Mapping XML API«.
Unterschiede zur DOM-Schnittstelle
DOM (Document Object Model) erzeugt aus einem XML-Dokument einen vollständigen
Baum von Objekten. Der Zugriff in einer Applikation ist sehr direkt
möglich, dafür ist der Speicherverbrauch erheblich, weil immer die gesamte Struktur
im Speicher steht. Ein vollständiges Abbild eines Dokuments als DOM ist
nicht trivial – auch in der Verarbeitung. SimpleXML nutzt ebenso eine objektorientierte
Sicht, vereinfacht diese jedoch drastisch. Statt der »offiziellen« DOM-API,
die alle Programmiersprachen mit DOM-Unterstützung anbieten, überführt SimpleXML
die Daten direkt in eine einfache, an PHP angepasste Objektstruktur.
Als Ausgangspunkt für erste Versuche soll folgendes Dokument dienen:
Listing 14.8: data/dbconfig.xml – Eine einfache XML-Datei zum Testen
joerg@krause.net
localhost
MySQL
dbuser
geheim
simpletest
Ein Parser, der dies verarbeitet, könnten nun folgendermaßen aussehen:
Listing 14.9: SimpleXML1.php – Einfachste Verarbeitung von XML mit SimpleXML

582
XML und Webservices
echo ('');
print_r($config);
echo ('');
?>
Die print_r-Funktion zeigt die vollständige Objektstruktur an, wie sie von Simple-
XML erkannt wurde:
Abbildung 14.3:
Objektstruktur eines
XML-Dokuments
Das folgende Skript nutzt diese Struktur, um auf eine MySQL-Datenbank zuzugreifen.
Dazu werden die Daten aus der XML-Datei zur Konfiguration benutzt:
Listing 14.10: SimpleXMLConfig.php – Nutzung von XML zur Konfiguration
database;
try
{
if (!@mysql_connect($db->host,$db->user,$db->pass))
{
throw new Exception('Database Connect Error'.mysql_error());
}
}
catch (Exception $e)
{
echo 'Error: ' . $e->GetMessage();
echo '';
echo 'Sende E-Mail an: ' . $config->email;
}
?>

SimpleXML
Wie der Name verspricht, ist SimpleXML tatsächlich sehr einfach. Parsen und
Nutzen ist praktisch unmittelbar miteinander verbunden und eignet sich hervorragend
für kleinere Sequenzen, beispielsweise Konfigurationsdateien.
Ein Schritt weiter
XML ist großartig und äußerst vielseitig einsetzbar. Der erste Abschnitt zeigte
bereits, dass es mit den neuen XML-Funktionen in PHP5 nicht schwer ist, damit
umzugehen. PHP 4 verlangte hier einiges mehr an Programmierung stellte damit
eine zu große Hürde dar, um auch einfache Problemstellungen mit XML zu lösen.
Prinzipiell gibt es drei Wege, um auf XML zuzugreifen. Die meisten Programmierumgebungen
nutzen alle drei, SAX, DOM und XSLT:
SAX (Simple API for XML) bietet eine ereignisbasierte Verarbeitung und verlangt,
dass die Elemente manuell gelesen werden, indem das aktuell verarbeitete
auf einem Stapelspeicher abgelegt und von da wieder entnommen wird.
DOM (Document Object Model) ist sehr flexibel und verständlich, verlangt
jedoch reichlich Ressourcen. Außerdem ist der Aufwand bei sehr trivialen Aufgabenstellungen
recht hoch.
XSLT (XSL Transformation) ist eine funktionale Programmiersprache zum
Transformieren von XML in anderes XML oder in Text oder HTML. Es ist
sehr mächtig, aber auch sehr gewöhnungsbedürftig.
SimpleXML ist eine neue und allein stehende Erweiterung in PHP5 und dient
dazu, den Zugriff auf XML-Dokumente zu erledigen. Dabei geht es in erster Linie
darum, die Daten in eine interne Datenstruktur zu übertragen, die sich besser weiterverarbeiten
lässt. Dazu gehören beispielsweise Arrays oder Datenbanken. XML
dient also keineswegs dazu, intern nur noch damit zu arbeiten, sondern soll vor
allem den vollkommen plattformneutralen Datenaustausch gewährleisten. Nebenbei
kann man seine Daten nun auch in einem der vielen XML-Editoren bearbeiten,
was recht bequem sein kann. Mit einem PHP-Array können eben nur sehr
wenige andere Systeme irgendwas anfangen.
Besonders leistungsfähig ist SimpleXML, wenn man gezielt auf die Attribute eines
Elements oder dessen Inhalt zugreifen möchte. Andere, komplexere Zugriffsmethoden
verlangen andere Erweiterungen. Der Namensteil »Simple« kann hier
wörtlich genommen werden. Damit wird die Erweiterung aber richtig praxistauglich,
denn die Lernkurve ist verhältnismäßig flach.
583

584
XML und Webservices
In diesem Abschnitt wird gezeigt, wie mit SimpleXML eine XML-Datei gelesen
und verarbeitet wird. Dazu wird der Inhalt teilweise extrahiert und eine Abfrage
mit der Abfragesprache XPath realisiert. Als Beispielformat soll das beliebte RSS
dienen, das bereits am Anfang des Kapitels kurz vorgestellt wurde. RSS wird zum
Datenaustausch der beliebten Weblogs benutzt. Hier wird die einfachste Version
von RSS verwendet, nicht die komplexere »Muttersprache« RDF, die einiges
mehr an XML-Techniken nutzt und die meisten Anwendungen massiv überfordert.
Wer mag, findet im Web reichlich Quellen zu RDF. Auf jeden Fall müssen
Sie mit XML-Namensräumen und XPath vertraut sein, um alle folgenden Skripte
lesen zu können.
XML Lesen
Als Ausgangspunkt der ersten Versuche mit SimpleXML soll die folgende RSS-
Datei dienen:
PHP: Hypertext Preprocessor
http://www.php.net/
The PHP scripting language web site
PHP 5.0.0 Beta 4 Released
http://www.php.net/downloads.php
PHP 5.0 Beta 4 has been released. The third beta of PHP
is also scheduled to be the last one (barring unexpected
surprises).
PHP Template Project
http://www.phptemple.de
A design oriented template system for PHP is announced by Comzept
Systemhaus GmbH. It compiles dynamic HTML into native PHP.

Listing 14.11: rssfeed091.xml – Eine erste RSS-Datei als Datenbasis
SimpleXML
Um mit dieser Datei arbeiten zu können, wird in SimpleXML ein entsprechendes
Objekt erzeugt:
$rss = simplexml_load_file('/data/rssfeed091.xml');
Danach steht das Objekt in der Variablen $rss zur Verfügung, vorausgesetzt die
Datei liegt im Verzeichnis /data und heißt rss091.xml. Diese Angaben entsprechen
den Daten auf der Buch-CD.
Auf die Elemente (Tags) kann nun mit der üblichen Objektsyntax zugegriffen werden,
so als wären es Eigenschaften:
echo $rss->channel->title;
Das vollständige Skript sieht folgendermaßen aus:
Listing 14.12: SimpleXMLRss091.php – Einfachster Zugriff auf eine RSS-Quelle
channel->link}\">{$rss->channel->link})";
?>
Mit der Musterdatei sollte nun folgendes ausgegeben werden:
Abbildung 14.4:
Ausgabe der Channel-Daten
einer RSS-Quelle
Falls ein Element auf einer Stufe in der Hierarchie mehr als einmal vorkommt,
legt PHP diese Daten in einem Array an. Im Beispiel finden Sie zwar nur ein Element
, darunter aber zwei Element . Der Zugriff darauf sieht dann
folgendermaßen aus:
Wie üblich kann zum Zugriff auf alle Elemente eines Arrays die Anweisung
foreach zum Einsatz kommen:
channel->link}\">{$rss->channel->link})";
echo "";
585

586
XML und Webservices
foreach ($rss->item as $item)
{
echo "{$item->title} ";
}
?>
Listing 14.13: SimpleXMLRss091b.php – Ausgabe mehrerer Elemente
Die folgende Abbildung zeigt, wie die Titel der RSS-Quelle erscheinen:
Nach den Elementen sind nun die Attribute an der Reihe. Diese stehen ebenfalls
als Arrayelemente zur Verfügung und können über ihre Namen erreicht werden:
Listing 14.14: SimpleXMLRssVersion.php (Ausschnitt) – Ermittlung der Version aus
dem Attribute version des Stammelements
echo $rss['version'];
Damit kann man in der Praxis schon eine Menge erreichen, denn Sie können nun
XML lesen und mit den bereits bekannten Mitteln in PHP weiterverarbeiten. Das
reicht nicht immer aus, macht aber die ersten Schritte sehr einfach.
Andere XML-Funktionen, wie Kommentare oder Prozessanweisungen, lassen sich
mit dieser Technik freilich nicht nutzen. Sie können diese Entitäten nicht erreichen.
Essentielle Informationen werden auf diesem Wege jedoch selten übermittelt,
sodass SimpleXML durchaus seine Daseinsberechtigung hat.
SimpleXML-Methoden
Abbildung 14.5:
Ausgabe aller Elemente einer
Auflistung
Der Zugriff auf Attribute gestaltet sich bei den Objekten der tiefer liegenden Struktur
ebenso. Hier können Sie jederzeit die Arraysyntax ansetzen. Wenn Sie dagegen
eine Auflistung der Attribute benötigen, beispielsweise um mit foreach zugreifen
zu können, nutzen Sie die Methode attributes():

SimpleXML
foreach($rss->item[0]->attributes() as $a => $b)
{
echo $a,'="',$b,"\"\n";
}
Der erste Parameter ergibt dabei immer den Namen des Attributes, der zweite den
Inhalt.
Hat man komplexe Strukturen, sind Vereinfachungen hilfreich. Eine Methode
hilft dabei, einen Zweig von Knoten gesondert weiterzuverarbeiten: children().
Zurückgegeben wird ein Objekt, das ähnlich wie das Stammobjekt aufgebaut ist
und nur die Kindelemente enthält.
Selbstverständlich kann mit SimpleXml der Inhalt der Knoten geändert werden.
Um die geänderte Version wieder schreiben zu können, ist die Methode AsXml()
hilfreich. Die Methode gibt den Inhalt als Zeichenkette zurück. Die Speicherung
in einer Datei müssen Sie dagegen selbst organisieren.
Hilfreich ist – für umfassendere XML-Zugriffe – das Laden von Objekten, die
mit den regulären DOM-Erweiterungen erzeugt wurden. Die Methode
simplexml_import_dom dient diesem Zweck. Der Abschnitt über DOM zeigt die
Anwendung.
Komplexere Abfragen mit XPath gestalten
Der Zugriff auf eine tief liegende Ebene oder eine Parametrisierung misslingt mit
dem direkten Objektzugriff meist oder wird so kompliziert, dass die ganze Vereinfachung,
die erreicht wurde, wieder aufgebraucht ist. Will man mehr, kommt
XPath zum Einsatz.
Der folgende Code findet alle Texte, die innerhalb aller -Element stehen:
Listing 14.15: SimpleXMLXpath.php – Abfrage mit XPath
xpath('//title') as $title)
{
echo "$title ";
}
?>
587

588
XML und Webservices
Die xpath-Methode durchsucht das SimpleXML-Objekt und gibt ein Array mit
den Fundstellen zurück. Der Parameter enthält die XPath-Anweisung, die recht
komplex werden kann. Die beiden Schrägstriche sagen: »Suche Elemente mit
dem Namen title an jeder beliebigen Stelle im Dokument«. Im Beispiel heißt
das, dass sowohl die Titel des als auch der -Elemente gefunden
werden.
Sollen dagegen nur die -Elemente gefunden werden, die sich innerhalb
von befinden, wäre folgende Anweisung einzusetzen:
//item/title
Spätestens hier wäre der Zugriff über das Objektmodell nur noch mit sehr viel Programmierung
zu erreichen und außerdem unglaublich langsam. XPath ist dagegen
sehr schnell.
XML-Namensräume
SimpleXML erledigt den XML-Zugriff leicht und einfach. Das Lesen von RSS 1.0-
Quellen wird so für jeden beherrschbar. Allerdings benutzt RSS 1.0 auch XML-
Namensräume, was die Sache wieder etwas komplizierter werden lässt. Da
Namensräume generell eine herausragende Rolle in XML übernehmen, ist eine
Auseinandersetzung damit unerlässlich.
Der Namensraum eines XML-Elements ist immer durch einen URL definiert. Im
Dokument wird aus Gründen der Lesbarkeit ein Alias benutzt, der dann zu folgenden
Elementformen führt:
Abbildung 14.6:
Abfrage mit XPath: Schnell und flexibel
my: ist dabei der Alias für einen Namensraum. Treffen mehrere XML-Dialekte aufeinander,
kann man diese mit Hilfe der Namensräume auseinander halten. Den
Alias wählt man im Zieldokument so, dass er konfliktfrei aufgelöst werden kann.
Mit Hilfe von Namensräumen können Sie leicht zwischen dem RSS-Element
und dem HTML-Element mit demselben Namen unterscheiden.

SimpleXML
Aus Sicht des XML-Zugriffs mit SimpleXML werden die Dinge nun plötzlich
komplizierter. Denn ein Zugriff über das Objektmodell wird mit $rss->my:title
nicht gelingen. Wird nur ->title geschrieben, verfügt der Prozessor jedoch über
keine Informationen, welches -Element denn nun gemeint ist. Schreibt
man die vollständigen Namensräume mit auf, stehen nun zwei Arten von -
Elementen zur Auswahl:
{http://www.w3.org/1999/xhtml}:title
{http://purl.org/rss/1.0}:title
Der gesamte Name wird als »qualifizierter Name« (qualified name) bezeichnet.
Der Alias ändert nichts an der Bezeichnung. Wie bereits erwähnt, dient dies lediglich
der Lesbarkeit. Es vereinfacht aber auch den Zugriff ein wenig. Es gibt keine
korrekten Aliasnamen im Sinne einer Vorgabe oder Norm, sondern lediglich Vorschläge,
welche Namen ohne den konfliktfrei gewählt werden sollten. Vergessen
Sie jedoch nicht, dass der Alias primär der Konfliktauflösung dient und deshalb
bewusst Änderungen unterliegt. Typische Aliase für die beiden erwähnten Namen
sind die folgenden:
Der URL, der den Namensraum definiert, führt nicht dazu, dass die verarbeitende
Software online auf Informationen zugreift. Auch muss die
verlinkte Seite nicht wirklich existieren. Die Angabe sichert lediglich die
weltweite Eindeutigkeit und sollte deshalb den Namen der Firmen-
Domain enthalten.
Um den Umgang von SimpleXML mit Namensräumen kennen zu lernen, wird
die bereits bekannte RSS-Datei mit einem solchen ausgestattet, was der Übergang
zur Version 1.0 erledigt:
PHP: Hypertext Preprocessor
http://www.php.net/
The PHP scripting language web
589

590
XML und Webservices
site
PHP 5.0.0 Beta 3 Released
http://www.php.net/downloads.php
PHP 5.0 Beta 3 has been released. The third beta of
PHP is also scheduled to be the last one (barring
unexpected surprises).
2004-01-02
PHP Community Site Project Announced
http://shiflett.org/archive/19
Members of the PHP community are seeking volunteers to
help develop the first web site that is created both by
the community and for
the community.
2003-12-18
Listing 14.16: rssfeed100.xml – RSS-Datei mit Namensräumen
(explizite Aliase rdf und dc)
Dieses Dokument enthält drei Namensräume, davon sind im Kopf zwei explizit
definiert und den Aliasnamen rdf und dc zugeordnet. Die folgende Syntax zeigt,
wie der Alias definiert wird:
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#
Die Definition wird immer als Attribut xmlns im Wurzelelement des den Namensraum
benutzenden Dokumentteils geschrieben. Man kann die Definition auch in
jedem einzelnen betroffenen Element wiederholen. Nach dem Doppelpunkt folgt
der gewählte Alias und danach der eigentlichen Namensraum als vollständiger
URL.
Die Elemente , und zeigen die Anwendung.

SimpleXML
RDF ist die »Mutterdefinition« von RSS und steht für Resource Description
Format. Dies ist eine sehr komplexe Form der Beschreibung von
verlinkten Dokumenten. Unter http://www.w3.org/RDF/ finden Sie eine
eingehende technische Beschreibung.
Eine Definition im gezeigten Dokument hat keinen Alias:
xmlns="http://purl.org/rss/1.0/"
Das ist der Standardnamensraum, der für alle Elemente gilt, die keinen Alias aufweisen
(der dritte im Bunde der oben erwähnten). RSS 1.0 verlangt diese Angabe,
während die erste öffentliche Version 0.91 ausdrücklich keinen Namensraum verlangt,
was freilich zu praktischen Problemen beim Datenaustausch führen kann.
Mehr dazu finden Sie im Abschnitt »Ein konkretes XML-Format: RSS« ab Seite
568.
Namensräume mit SimpleXML verwenden
Die Suche von Elementen mit bestimmten Namensräumen verlangt nach einem
neuen Satz von Methoden, über den SimpleXML nicht verfügt. In der Praxis versagt
die Anwendung dennoch nicht, denn SimpleXML ignoriert die Namensräume
einfach. Damit sind auch Dateien mit Namensraumaliasen lesbar,
zumindest solange die interne Vereinfachung nicht zu Namenskonflikten führt.
XML Namensräume und XPath
SimpleXML ignoriert die Namensräume jedoch nicht völlig. Es existiert lediglich
keine dedizierte Syntax für den Zugriff. Mit XPath sieht es anders aus. Hier kann
der Namensraum bei der Abfrage durchaus angegeben werden. Freilich ist dies
keine Leistung von SimpleXML, sondern vom intern verwendeten XPath-Modul.
Damit die Übergabe der Namensräume auch mit dem Standardnamensraum
funktioniert, muss wenigstens dieser registriert werden. Dann funktioniert auch die
Auflösung der übrigen Namensräume, wie es das nächste Beispiel weiter unten
zeigt.
Um alle Titel aus den Elementen zu finden, muss der Namensraum-
Alias registriert werden. Der vollständige Namensraum kann beispielsweise folgendermaßen
aussehen:
http://purl.org/rss/1.0/
591

592
XML und Webservices
Der Alias ist frei wählbar, aber der RSS-Standard empfiehlt für das vorliegende Beispiel
die Verwendung von »rss«. Die XPath-Abfrage sollte dann folgendermaßen
aussehen:
//rss:item/rss:title
Leider gibt es keinen Weg, in XPath einen Standardnamensraum zu definieren,
wie es in XML selbst möglich ist. Das ist in der Praxis aber nur selten problematisch.
Wichtig ist es, an den Namensraum bei der Abfrage zu denken, auch wenn
im Dokument ein Standardnamensraum verwendet wird und der Alias nicht in
allen Tags auftaucht.
Das folgende Listing zeigt die fertige Lösung:
Listing 14.17: simplens.php – Abfrage eines RSS-Feed mit Namensräumen
registerXPathNamespace('rss', 'http://purl.org/rss/1.0/');
$titles = $s->xpath('//rss:item[
starts-with(dc:date, "2004-01-")]/rss:title');
foreach ($titles as $title)
{
print "$title\n";
}
?>
Die erste Zeile entspricht den letzten Beispielen. Dann folgt die Registrierung des
Namensraums:
$s->registerXPathNamespace('rss', 'http://purl.org/rss/1.0/');
Die Abfrage selbst greift außerdem demonstrativ auf XSLT-Funktionen zurück,
um die Ergebnisse einzuschränken. Die Funktion starts-with prüft, ob eine Zeichenkette
mit einer bestimmten Zeichenfolge beginnt. Der Alias dc deutet darauf
hin, dass die Daten der Namensraumdefinition aus den Dublin Core Metadata
entstammen, die Datumswerte spezifiziert.
Abbildung 14.7:
Auswahl des Titels aus dem RSS-Feed

Andere Funktionen
SOAP-Webservices
Wie bereits erwähnt, ist es möglich, Attribute und Elementinhalte auszutauschen,
indem ein neuer Wert zugewiesen wird. Der geänderte Inhalt des Dokuments
kann komplett als Zeichenkette zurückgegeben werden, wozu die Methode
AsXml() auf den Wurzelknoten angewendet wird.
Insgesamt ist SimpleXML ein feines und kleines Modul, das den Zugriff auf XML
stark vereinfacht und ohne tief gehende Kenntnisse leicht bedienbar ist. Große
Projekte können davon weniger profitieren, weil die Einschränkungen programmiertechnisch
kaum zum umschiffen sind. Hier können Sie jedoch mit dem zweiten
XML-Modul, der libxml2, nahtlos ansetzen.
14.4 SOAP-Webservices
Webservices sind bereits seit einiger Zeit heftig umworben und immer wieder
Titelthema von Entwicklerkonferenzen und Produktankündigungen. Eine breite
Nutzung ist indes nicht auszumachen. Die ersten Anfänge sind trotzdem ermutigend
und die technischen Vorteile sind so gravierend, dass eine Beschäftigung mit
den Möglichkeiten unbedingt lohnt.
Grundlagen
PHP5 stellt mit dem SOAP-Erweiterungen ein integriertes Paket zur Verfügung,
mit dem sich Webservices anbieten und nutzen lassen. Damit ist der Einsatz derart
einfach geworden, dass man sich deutlich mehr Gedanken um mögliche Anwendungen
als um deren Realisierung machen muss.
Gedanken
Webservices sind im Grund genommen nur entfernte Methodenaufrufe. Auf
irgendeinem Server läuft ein Programm, das öffentliche Methoden zur Verfügung
stellt. Werden diese – mit oder ohne Parameter – aufgerufen, gibt eine spezielle
Methode Daten zurück oder führt Aktionen aus. Das Ganze nennt man dann
einen Webservice (oder Web-Dienst oder XML-Webdienst), wenn sich der Anbieter
des Dienstes an bestimmte Standards hält. Das ist sehr sinnvoll, denn damit öff-
593

594
XML und Webservices
net er sich einer Palette von Clients, die denselben Standard benutzen.
Prominente Beispiele solcher Anbieter sind Amazon und Google, deren Dienste
»Bücher kaufen« und »Suchen« so anderen Servern zur Verfügung gestellt werden.
Dabei umfasst die Definition »Webservice« bereits sehr viel, lediglich die
Ausformulierung der Abfragen muss bekannt gemacht werden. Da entsprechende
Clients für alle Betriebssysteme und Programmierumgebungen zur Verfügung stehen,
muss sich der Anbieter keine Gedanken über die Nutzbarkeit seines Angebots
machen. Entsprechend zahlreich sollten Anbieter und Nutzer sein – theoretisch.
In der Praxis setzen sich Webservices recht zögerlich durch. Vermutlich hat dies
keine technischen Ursachen, sondern deutet eher auf mentale Hemmnisse hin.
Webservices sind primär für die Server-Server-Kommunikation geschaffen. Auch
bei der Abwicklung von automatisierten Abfragen in der Server-Client-Kommunikation
sind Webservices stark. Das massiv clientgeprägte Web mit einem nicht
Webservice-tauglichen Browser steht dem natürlich entgegen. Es existieren
schlicht keine Strukturen in Unternehmen und deren IT-Abteilungen, in der Kategorie
»Dienst« zu denken. Dabei ist eigentlich alles ganz einfach.
Prinzipien
Die Kommunikation zwischen Server und Server oder zwischen Client und Server
benutzt zwei bereits etablierte Techniken:
1. HTTP oder SMTP
HTTP und SMTP sind die möglichen Transportprotokolle, die die Daten
übertragen. Meist kommt nur HTTP zum Einsatz. Das bedeutet, dass Aufrufe
von Webservices problemlos Firewalls überwinden. Der Anbieter muss seine
massiven Sicherheitseinrichtungen also kein bisschen öffnen, was äußerst
attraktiv ist.
SMTP ist kaum in Benutzung, würde jedoch auch interessant sein, weil es eine
asynchrone Kommunikation zulässt. Man stelle sich vor, ein Client, beispielsweise
ein Handy, sendet eine Anfrage an einen solchen Dienst über die MMS-
Funktion. Der Dienstanbieter setzt dies auf SMTP um und der Webservice-
Anbieter beantwortet die Anforderung auf gleichem Wege. Der Dienstanbieter
erstellt aus der Antwort wiederum eine MMS und schon kann man billig interaktiv
kommunizieren – ohne wie bei WAP ständig online zu sein. Liest hier
eigentlich jemand von Vodafone mit?

SOAP-Webservices
2. XML
Die Nachrichten selbst – also die Parameterdaten einer Anfrage und die Ergebnisse
– werden mittels SOAP (Simple Object Access Protocol) kodiert. Dies ist
ein XML-Dialekt. Damit ist die Weiterverarbeitung schnell und einfach, denn
XML-Parser stehen immer und überall zur Verfügung. Die Dienstinformationen
selbst, also die Namen der Methoden und die Datentypen der Parameter
werden über eine Informationsdatei im Format WSDL (Web Services Description
Language) angeboten, wobei es sich hier selbstverständlich wiederum um
XML handelt.
Auf der Grundlage der Basistechnologien HTTP und XML ist es für Hersteller
nicht schwer, Webservices in Programmiersprachen und Betriebssysteme zu integrieren.
Jeder neuere Website, die mit PHP5, Java oder ASP.NET in den letzten
drei bis fünf Jahren entstanden ist, steht die Technologie praktisch zur Verfügung.
Technisch läuft das Ganze dann so ab, dass zuerst der Dienst selbst programmiert
wird, meist eine Klasse mit einer Anzahl öffentlicher Methoden, die den Benutzern
bereitgestellt werden. Zu diesem Angebot wird dann die Beschreibungsdatei
im WSDL-Format erstellt. Dann wird der SOAP-Server der Programmierumgebung
damit beauftragt, Anfragen anzunehmen, an die Methoden weiterzuleiten
und deren Beantwortung zu überwachen. Die Außenkommunikation wird, wenn
sie über HTTP abgewickelt wird, vom Webserver erledigt, der selbst nichts von
SOAP oder XML wissen muss. Für ihn sind es lediglich HTTP-Anforderungen,
deren Körper (Body) statt HTML-Seiten SOAP-Nachrichten enthält.
Technische Grundlagen
Um nicht völlig im Dunkeln zu tappen, was den technischen Ablauf betrifft, sollten
Sie sich kurz mit den technischen Grundlagen vertraut machen. Die hier vorliegende
Beschreibung ist stark vereinfacht, reicht aber für das Verständnis der
ersten Beispiele aus.
An allererster Stelle steht immer SOAP. SOAP realisiert den eigentlichen Funktionsaufruf.
Die SOAP-Nachricht besteht aus drei Teilen:
Umschlag (SOAP Envelope)
Kopf (SOAP Header)
Inhalt (SOAP Body)
595

596
XML und Webservices
Der Inhalt kann in einer Nachricht in mehrere Blöcke verteilt sein. In XML sieht
das Ganze dann folgendermaßen aus:
Listing 14.18: Rumpf einer SOAP-Nachricht (ohne Daten)
Zusätzlich zur eigenen Namensraumdefinition werden meist noch XML-Schema
für die Datentypen und Schema-Instance vereinbart. Als Namensraumaliase kommen
die Abkürzungen »xsd« und »xsi« zum Einsatz.
Was auch immer im Inhalt der SOAP-Body-Tags steht, hängt bereits von der konkreten
Anwendung ab. Der Aufbau ist zwar sehr streng, die Benennung der Tags
und die Struktur variieren jedoch. Damit sich die beiden Kommunikationspartner
über diese Struktur einig werden – und zwar automatisch – kommt WSDL zum
Einsatz.
WSDL steht für Web Services Description Language. Dies ist eine vom Anbieter zu
erstellende XML-Datei, die auf Anforderung des Clients gesendet wird. Sie muss
genaue Informationen über folgende Dienstmerkmale enthalten:
Kommunikationsport, also den URL, unter dem der Dienst bereitsteht
Bindung, also die Verknüpfung zwischen Dienst und Ein- und Ausgabeoperationen
Porttypen, eine Definition der Kommunikationsrichtung der zulässigen Operationen
Nachrichten, die Namen der von den Ports angebotenen Methoden und deren
Parameter- und Rückgabedefinitionen
Datentypen, also die konkret von einem Parameter oder Rückgabewert benutzten
Datentypen
Bei den Datentypen wird zur Beschreibung XML-Schema benutzt. Zulässig sind
sowohl die in XML-Schema definierten elementaren Typen (string, integer) als
auch so genannte Komplextypen, die benutzerdefinierte Datensammlungen
beschreiben.

SOAP-Webservices
Mit diesen Informationen ist der Client nun in der Lage, die vom Server bereitgestellten
Methoden so umzusetzen, dass dem Programmierer tatsächlich eine Klasse
mit den ursprünglich definierten Methoden vorgehalten wird. Das ist die eigentliche
Faszination: Während auf der einen Seite der Dienst mit PHP und den SOAP-
Erweiterungen benutzt wird, als Betriebssystem Unix läuft und als Datenbank
MySQL benutzt wird, steht dem Client möglicherweise ein Windows XP und ein
in Access geschriebene Benutzeroberfläche zur Verfügung. Und wenn der Server
später auf das Gespann Java/Sun Solaris wechselt, sollte der Client davon nichts
mitbekommen. Das ist die schöne neue Welt der Webservices.
Alle Theorie ist jedoch langweilig, wenn man nichts praktisch unternimmt. Deshalb
schließt dieses Kapitel mit zwei kleinen Projekten ab. Eines konsumiert einen
im Internet öffentlich angebotenen Webservice, das andere bietet selbst einen solchen
an.
Der Amazon-Webservice: ein Überblick
Dieser Abschnitt stellt die Amazon-Webservices kurz vor und gibt einen ersten
Einblick in mögliche Anwendungen. Dies erhebt keinerlei Anspruch auf Vollständigkeit.
Die Definition der Dienste: WSDL
Die folgende WSDL-Datei stellt den Zustand und das Angebot des Dienstes Mitte
2004 dar. Auf die Datei wird im folgenden Bezug genommen. Man kann ihr
sowohl die Struktur der aufrufbaren Funktionen als auch die Datentypen der Parameter
und Rückgabewerte entnehmen:
Listing 14.19: WSDL-Datei des Amazon-Webservices (stark gekürzt)

598
XML und Webservices
targetNamespace="http://soap.amazon.com">

SOAP-Webservices

600
XML und Webservices
minOccurs="0"/>

SOAP-Webservices
type="typens:SimilarProductsArray"
minOccurs="0"/>
601

602
XML und Webservices
Lesen Sie diese Datei am besten von unten nach oben. In dieser Reihenfolge
bauen nämlich die Informationen aufeinander auf. Beachten Sie auch, dass die
Daten, um hier überhaupt druckbar zu sein, sehr stark gekürzt wurden (auch wenn
es nicht so aussieht). Praktisch sind nur die Informationen enthalten, die im Folgenden
direkt benötigt werden – für die ISBN-Suche mit AsinSearchRequest. Aber
wie liest man nun solch eine Datei?
Alles beginnt bei der Deklaration eines Dienstes und der Festlegung seines
Namens:
Der Dienst definiert einen Port und eine Bindung:
Die Bindung definiert die Namen der Funktionen (Operation genannt) und deren
Kodierung und Namensräume. Für AsinSearchRequest sieht das folgendermaßen
aus:

SOAP-Webservices
Der Port-Typ definiert dieselbe Funktion und nennt dazu die konkrete Ein- und
Ausgabefunktion, die getrennt definiert werden:
Der SOAP-Client baut aus diesen Angaben dann einen normalen PHP-Funktionsaufruf
zusammen. Der Port nennt für die in der Bindung vereinbarte Operation
die Namen der Funktionen für beide Transportrichtungen, input ist die Abfrage,
output die Rückgabe:
Diese Funktionen wiederum erscheinen als Nachrichten und definieren die
Datentypen, die benutzt werden. Der Typ AsinRequest wird für die Anfrage
benutzt:
Der Typ ProductInfo wird bei der Antwort verwendet:
Beides sind offensichtlich keine elementaren Typen, weshalb sich weiter oben die
Typdefinition im XML-Schema-Stil anschließt. Komplexe Typen setzen sich,
gegebenenfalls über mehrere Schritte, aus einfachen Typen zusammen. Die Definition
eines komplexen Typs wird folgendermaßen eingeleitet:
Darunter folgen entweder weitere komplexe Typen oder – in letzter Konsequenz –
elementare:
Erscheint der Zusatz minOccurs="0", ist das Feld optional:
Freilich kann hier auch eine bestimmte Mindest- oder Maximalanzahl festgelegt
werden. XML-Schema erlaubt eine sehr feine Definition von Datentypen.
603

604
XML und Webservices
Ein Datentyp für die Antwort ProductInfo, Details, enthält beispielsweise einen
Verweis auf DetailsArray:
Dieses ist als SOAP-Array (Achtung! Basisdatentyp) definiert, das Elemente des
Typs Details (Achtung! benutzerdefinierter Komplextyp) enthält:
Details seinerseits enthält nun nur noch Basistypen (wie string), wie der folgende
Ausschnitt zeigt:
Es können jedoch auch weitere komplexe Typen folgen, die andernorts in der
WSDL-Datei definiert sind (möglicherweise aber nicht abgedruckt, weil sonst das
halbe Buch voll WSDL-Code wäre):
Mit diesen Informationen ist der SOAP-Client nun in der Lage, die Daten für eine
Anfrage zu erstellen und aus der Antwort die Daten wieder zu entnehmen. Eine
korrekte Anfrage, wie sie das nachfolgend vorgestellte Beispiel erzeugt, sieht folgendermaßen
aus:
Listing 14.20: Anfrage an Amazon: Aufruf der Funktion AsinSearchRequest
3827264553
activeserverpa0e
heavy
XXXXXXXXXXX

SOAP-Webservices
de
Man kann hier sehr gut erkennen, wie im Body der Nachricht die Anfrage getreu
der Datentyp-Definition aufgebaut ist. Erkennbar ist aber auch, dass mehr als 50%
der Daten keine realen Daten sind. Der so genannte Overhead einer SOAP-Verbindung
ist bei vielen kurzen Anfragen erheblich.
Etwas umfassender fällt die Antwort aus (hier die »lite«-Version, ohne Kundenrezensionen):
Listing 14.21: Eine SOAP-Antwort (auf exakt die zuvor gezeigte Anfrage)
http://www.amazon.de/exec/obidos/ASIN/3827264553/
activeserverpa0e?dev-t=D3D53F5TPPE230%26
camp=2025%26link_code=sp1
3827264553
.NET Windows Forms in 21 Tagen . Oberflächen programmieren
Book
605

606
XML und Webservices
Chris Payne
15. Januar 2003
Markt+Technik
http://images-eu.amazon.com/images/P/3827264553.03.THUMBZZZ.jpg
http://images-eu.amazon.com/images/P/3827264553.03.MZZZZZZZ.jpg
http://images-eu.amazon.com/images/P/3827264553.03.LZZZZZZZ.jpg
EUR 46,68
EUR 49,95
EUR 12,70
Man kann gut erkennen, dass XML ideal für die Übertragung komplexer hierarchischer
Daten geeignet ist. Die Rückübertragung nach PHP ist nun wieder Sache
des SOAP-Clients. Dieser erstellt übrigens ein Objekt daraus. Angeschaut mit
var_dump sieht es folgendermaßen aus (wieder exakt dieselbe Anfrage).
Der Zugriff auf die Daten ist nun recht einfach. Man muss lediglich wissen, wo die
Daten die man benötigt, in der Hierarchie stehen. Man muss außerdem natürlich
auf Arrays, Indizes usw. achten, um gegebenenfalls mit Schleifen arbeiten zu können.
Um das zu erfahren, ist jedoch das Lesen der Rohdaten und der WSDL-
Dateien erforderlich, falls sich niemand die Mühe gemacht hat, eine umfassende
verbale Beschreibung mitzuliefern.

Webservices konsumieren
SOAP-Webservices
Um einen Webservice zu konsumieren, benötigen Sie zuerst einen solchen Dienst
und dessen Dienstbeschreibung. Steht das bereit, erledigen PHP5 und dessen
SOAP-Erweiterungen die ganze Arbeit.
Als Beispiel soll die im letzten Kapitel erstellte Bibliotheks-Anwendung erweitert
werden. Das Erfassen von möglicherweise hunderten Büchern ist recht mühevoll.
Wenn der Server ohnehin online ist, bietet es sich an, die Daten von einem Buchhändler
zu beschaffen. Dankbares Opfer wird in diesem Fall Amazon, da dort ein
entsprechender Dienst angeboten wird.
Die Daten beschaffen
Abbildung 14.8:
Das vom SOAP-Client aus der zuvor
gezeigten Antwort erzeugte Objekt
Der Start beginnt auf der folgenden Website (ab hier in Englisch):
http://www.amazon.com/webservices
Melden Sie sich zuerst bei Amazon an, um die kostenlose Zugangsberechtigung
zu erhalten. Dazu sind lediglich eine E-Mail-Adresse und ein Kennwort erforderlich,
das selbst gewählt werden kann. Optional laden Sie dort zuerst des SDK (Entwicklerpaket)
herunter. Das Paket hat den Namen kit.zip und ist auch auf der CD
zum Buch unter /Bibliothek/SOAP zu finden (Version vom August 2004). Das
607

608
XML und Webservices
SDK enthält Beispielprogramme, Hilfen und Hinweise, auch für PHP. Das enthaltene
Programm nutzt jedoch die für PHP 4 entwickelte Version, die auf dem
PEAR-Paket NuSOAP basiert. Die in diesem Buch gezeigte Version wurde dagegen
vom Autor explizit für PHP5 geschrieben und soweit vereinfacht, dass ein
schneller Einstieg gelingt.
Versuchsaufbau und Vorbereitung von PHP5
Die SOAP-Erweiterung in PHP5 steht unter Windows als php_soap.dll zur Verfügung,
deren Aktivierung wie üblich in der php.ini erfolgt. Unter Linux wird PHP5
mit dem Schalter --with-soap kompiliert. Ein Blick in die Anzeige der Funktion
phpinfo zeigt, ob es geklappt hat:
Dann ist noch zu überprüfen, ob die Konfigurationsparameter in der Datei php.ini eingetragen
sind. Wenn der folgende Abschnitt nicht zu finden ist, fügen Sie ihn hinzu:
[soap]
soap.wsdl_cache_enabled=1
soap.wsdl_cache_dir="c:\windows\temp"
soap.wsdl_cache_ttl=86400
Achten Sie auf den Pfad zum Verzeichnis temporärer Daten (das Beispiel gilt für
Windows).
Ziel des SOAP-Projekts
Abbildung 14.9:
Die SOAP-Erweiterungen
wurden erfolgreich
aktiviert
Ziel der Anwendung ist die Vereinfachung der Datenerfassung bei der Aufnahme
von Büchern in die im vorigen Kapitel vorgestellte Bibliotheksverwaltung. Dabei
soll die Angabe der ISBN genügen, alle übrigen Daten sollen aus der Amazon-
Datenbank geholt werden. Dazu gehört beispielsweise auch ein Bild des Buches,
was sonst sicher nur mühevoll zu beschaffen wäre. Wie das am Ende aussehen soll,
zeigt die Abbildung14.10.

SOAP-Webservices
Dies spart vor allem viel Zeit bei der Erfassung, vermeidet aber auch lästige Tippfehler.
Die hier benutzten Daten stellen nur einen kleinen Teil der Möglichkeiten
dar, die Amazon bietet.
Erweiterung der Anwendung
Abbildung 14.10:
Erfassung von
Büchern: Alle
Daten außer der
ISBN liefert der
Webservice
Die Erweiterung der Anwendung umfasst nur zwei Schritte:
1. Aufbau eines Moduls, das den Webservice abfragt
2. Erweiterung der bisherigen Bibliotheksverwaltung
Das Modul wird natürlich PHP5-typisch als Klasse implementiert. Sie kann dann
auch von anderen Anwendungen benutzt werden. Diese ist allerdings – im Gegensatz
zu vielen fertigen Lösungen im Internet – bewusst minimalistisch programmiert
worden, um die mindestens notwendigen Funktionen demonstrieren zu
können, ohne dabei erschlagend viele Code zu benutzen.
609

610
XML und Webservices
Listing 14.22: soapclient.inc.php – Eine primitive Klasse zur Benutzung des Amazon-
Webservice

SOAP-Webservices
}
return isset($result) ? $result : '';
}
}
?>
Die Klasse definiert einige Informationen, die der Dienst benötigt, als Konstanten:
const LANG = 'de'
Die Sprache des Katalogs, der abgefragt werden soll. Wenn Sie deutsche
Bücher bearbeiten, muss die Sprache »de« sein.
const MODE = 'heavy'
Der Modus, hier kann »lite« für kurze Ergebnisse oder »heavy« für ausführliche
stehen. Untersuchen Sie zuerst »lite« und nutzen Sie »heavy« nur dann,
wenn Sie die benötigten Angaben andernfalls nicht finden.
const TAG = 'activeserverpa0e'
Der Token eines Affiliate-Programms. Diese Angabe ist optional.
const WSDL_FILE =
'http://soap.amazon.com/schemas2/AmazonWebServices.wsdl'
Die Adresse, unter der der Webservice zur Verfügung steht.
const TOKEN = 'IHR_AMAZON_TOKEN'
Der Token, den Sie bei der Anmeldung von Amazon erhalten haben.
Zuerst wird immer eine Instanz des SOAP-Clients benötigt:
$this->Client = new SoapClient(self::WSDL_FILE,
array('trace' => 1));
Der zweite Parameter, array('trace' => 1), kann entfallen, wenn die Anwendung
stabil läuft und der Zugriff auf die originalen SOAP-Nachrichten nicht mehr benötigt
wird. Sie können Methoden wie __getLastResponse() nur benutzen, wenn mit
trace die Speicherung der Daten eingeschaltet wurde. Dies ist allerdings mit mehr
Speicher und damit höherer Serverbelastung verbunden und sollte deshalb nur
während der Aufbauphase benutzt werden.
Die eigentliche Abfrage wird in der Methode searchISBN ausgeführt:
public function SearchISBN($Keyword)
Dort wird zunächst ein Array aus den Parametern zusammengestellt. Die Namen
der Schlüsselfelder müssen den Anforderungen in der WSDL-Datei entsprechen,
andernfalls reagiert der Amazon-Server mit einer Fehlermeldung. Stehen alle
Daten bereit, erfolgt die Abfrage:
611

612
XML und Webservices
$result = $this->Client->AsinSearchRequest($params);
Der Name AsinSearchRequest ist wiederum in der WSDL-Datei als mögliche
Dienstfunktion festgelegt. Der Einbau in einen try-Block fängt Fehler ab. Da es
sich hier um eine Internetverbindung handelt, kann diese natürlich fehlschlagen
und dann hilft der Block bei der Fehlerverarbeitung. Wenn Sie außerhalb wieder
mit try/catch arbeiten, sollten Sie mögliche Fehler mit throw new weiterreichen
und gegebenenfalls eigene Fehlerklassen für Ihre Zwecke entwerfen. Im Beispiel
ist die Fehlerverwaltung dem angesprochenen minimalistischen Prinzip zum
Opfer gefallen. Für andere Fehler ersetzen Sie SoapFault durch Exception:
catch (SoapFault $ex)
Am Ende sind die ermittelten Daten nur noch zurückzugeben:
return isset($result) ? $result : '';
Die hier zurückgegebenen Daten sind ein Objekt, das in seinen Eigenschaften
weitere Objekte und Arrays enthält. Der Aufbau entspricht der Struktur der in der
WSDL-Datei für die spezifische Anfrage verwendeten Rückgabedaten.
Einbau in das Bibliotheksskript
Der Einbau in das Bibliotheksskript ist relativ einfach. Die Funktionalität wurde
dabei etwas erweitert und in der Vorlage musste Platz für die zusätzlichen Daten
geschaffen werden. Zuerst ein Blick auf die erweiterte Vorlage:
Listing 14.23: buecher.html: Die Vorlage zur Organisation der Buchdatenbank
Bibliotheksverwaltung
Startseite
|
Ausleihe
|
Kundenverwaltung
B&uuml;cherverwaltung
Informationen
B&uuml;cherliste

SOAP-Webservices
Anzahl
ISBN
Titel
Aktion
{$books:number}
{$books:isbn}
{$books:title}
Details
L&ouml;schen
Neues Buch erfassen
&Auml;ndern&nbsp;/&nbsp;Erfassen
Buchdaten
613

614
XML und Webservices
Titel:
Verlag:&nbsp;{$detail_publisher}
Untertitel:
Autor:
ISBN:

SOAP-Webservices
Anzahl
Ausgeliehen
Neu – gegenüber der im letzten Kapitel vorgestellten Variante – ist die Ausgabe
der Zusatzdaten:
Verlag:&nbsp;{$detail_publisher}
615

616
XML und Webservices
Dies ist optional, weil die Daten nicht zwingend vorliegen. Deshalb erfolgt der
Einbau in IF-Abschnitte.
Der PHP-Code zu dieser Vorlage ist ebenfalls nur wenig umfassender als die letzte
Version:
Listing 14.24: buecher.php – Steuerung der Vorlage mit allen Datenbankzugriffen

}
SOAP-Webservices
= utf8_decode($data->Details[0]->Authors[0]);
$detail_isbn = $_POST['book_isbn'];
$detail_title
= utf8_decode($data->Details[0]->ProductName);
$detail_image
= utf8_decode($data->Details[0]->ImageUrlMedium);
$detail_publisher
= utf8_decode($data->Details[0]->Manufacturer);
}
else
{
$detail_subtitle = $_POST['book_subtitle'];
$detail_author = $_POST['book_author'];
$detail_isbn = $_POST['book_isbn'];
$detail_title = $_POST['book_title'];
}
$detail_number = empty($_POST['book_number']) ? 1 :
(int) $_POST['book_number'];
$mysqli->query("INSERT INTO books
(title, subtitle, author, isbn, number)
VALUES ('{$detail_title}',
'{$detail_subtitle}',
'{$detail_author}',
'{$detail_isbn}',
{$detail_number}
)");
break;
case 'change':
$mysqli->query("UPDATE books SET
title='{$_POST['book_title']}',
subtitle='{$_POST['book_subtitle']}',
author='{$_POST['book_author']}',
isbn='{$_POST['book_isbn']}',
number={$_POST['book_number']},
WHERE id = {$_POST['id']}");
break;
}
// Liste fuellen
$query = $mysqli->query("SELECT * FROM books");
while($arr = $query->fetch_assoc())
{
617

618
XML und Webservices
$books[] = $arr;
}
// Details abrufen, wenn gefordert
if (isset($_GET['id']))
{
$query = $mysqli->query("SELECT *, (SELECT COUNT(*)
FROM lendout
WHERE books_id = b.id) AS lend
FROM books b
WHERE id = {$_GET['id']}");
$detail = $query->fetch_assoc();
$detail_id = $detail['id'];
$detail_title = $detail['title'];
$detail_subtitle= $detail['subtitle'];
$detail_author = $detail['author'];
$detail_number = $detail['number'];
$detail_isbn = $detail['isbn'];
$detail_lend = $detail['lend'];
}
?>
Hier sollen nur die Aspekte erläutert werden, die gegenüber der letzten Version
neu sind. Zuerst muss natürlich das SOAP-Modul eingebunden werden:
include('soapclient.inc.php');
Die Abfrage der Amazon-Datenbank erfolgt, wenn ein neues Buch erfasst wurde
und keine Daten außer der ISBN-Nummer im Formular angegeben wurden:
if ((empty($_POST['book_author'])
|| empty($_POST['book_title'])) && isset($_POST['book_isbn']))
Für die Abfrage müssen die Trennzeichen aus der ISBN entfernt werden, andernfalls
funktioniert AsinSearchRequest nicht:
$asin = str_replace('-', '', $_POST['book_isbn']);
Dann wird eine Instanz der SOAP-Klasse erstellt:
$ws = new AmazonSearch();
In diesem Augenblick wird bereits die WSDL-Datei gelesen. Da die Speicherzeit
im Cache 1 Tag beträgt, muss man beim ersten Abruf und nach jedem weiteren
Tag hier mit einer etwas längeren Wartezeit rechnen. Die Größe beträgt ca.
52 KByte.

SOAP-Webservices
Dann erfolgt die Abfrage, dies ist immer »life«, benötigt eine Internetverbindung
und dauert fast immer eine oder mehrere Sekunden (auch bei DSL):
$data = $ws->SearchISBN($asin);
Die Daten werden nun entsprechend der erwarteten Struktur entnommen, beispielsweise
der erste Autor:
$detail_author = utf8_decode($data->Details[0]->Authors[0]);
Beachten Sie hier, dass die Daten UTF-8-kodiert sind. Dies ist XML-Standard.
PHP liefert die passende Funktion zum Dekodieren mit: utf8_decode.
Der Aufruf $data->Details[0]->Authors[0] sollte Ihnen keine Rätsel bereiten:
$data Das Datenobjekt
->Details Die Eigenschaft Details (ergibt ein Array)
[0] Das erste Element des Arrays, dies ist wieder
ein Objekt, diesmal vom Typ Details
->Authors Darin ist eine Eigenschaft Authors definiert
[0] Die Eigenschaft enthält ein Array, dessen erstes
Element benutzt wird
Das das erste Element direkt benutzt werden kann, ist der WSDL-Beschreibung
oder dem Antwortpaket zu entnehmen. Der Datentyp für einen Autor ist »string«,
also eine simple Zeichenkette. Die übrigen Abrufe folgen demselben Schema,
wobei beispielsweise der Titel keine Unterteilung in ein Array mehr besitzt:
utf8_decode($data->Details[0]->ProductName)
Fazit
Damit ist eigentlich alles gesagt. Die Amazon-Webservices sind äußerst komplex
und für jeden Entwickler eine Herausforderung. Es lohnt sich jedoch, denn man
kann mit den Affiliate-Programmen oder den zShops Geld verdienen. Der automatisierte
Zugriff erlaubt einen personalarmen Betrieb eines solchen Shops und
damit werden auch kleine Einnahmen attraktiv, weil sie nicht sofort wieder von
Kosten aufgefressen werden. Wer übrigens eine Bibliothek betreibt, der kann
direkt Kosten sparen, denn er muss nun künftig eingehende Bücher, die ohne elektronische
Datensätze ankommen, nicht mehr von Hand erfassen. Mit Hilfe eines
kleinen, preiswerten Barcode-Scanners lässt sich die ISBN vom Buchrücken
abnehmen und schon sind die kompletten Daten von Amazon geholt und in der
Datenbank. Was will man mehr?
619

620
XML und Webservices
14.5 Referenz
Die Referenz zeigt die in diesem Kapitel behandelten XML-Module SimpleXML
und DOM.
Referenz SimpleXML
Funktion Beschreibung
simplexml_import_dom Die Funktion importiert ein SimpleXML-Objekt aus
einem DOM-Knoten und gibt das SimpleXML-Objekt
zurück.
simplexml_export_dom Exportiert ein SimpleXML-Objekt als DOM-Knoten.
simplexml_load_file Lädt eine XML-Datei und gibt ein SimpleXML-Objekt
zurück.
simplexml_load_string Lädt XML aus einer Zeichenkette und gibt ein Simple-
XML-Objekt zurück.
Tabelle 14.5: Funktionen, die SimpleXML-Objekte erzeugen oder verarbeiten
Methode Beschreibung
AsXML Exportiert den Inhalt als XML-Zeichenkette.
attributes Die Liste der Attribute eines Elements.
children Die Aufzählung der Kindelemente eines Elements.
xpath Führt eine XPath-Abfrage aus.
registerXPathNamespace Registriert einen Namensraumalias für die Verwendung in
XPath-Ausdrücken
Tabelle 14.6: Methoden des SimpleXML-Objekts

Referenz DOM
Klasse Bedeutung
DomAttr Repräsentiert ein Attribut.
DomCData Repräsentiert einen CDATA-Abschnitt.
DomComment Repräsentiert einen Kommentar.
DomDocument Die Basisklasse, das Dokument selbst.
Referenz
DomDocumentType Die DOCTYPE-Deklaration des Dokuments.
DomElement Repräsentiert ein Element.
DomEntity Repräsentiert eine Entität, beispielsweise &amp;.
DomEntityReference Repräsentiert eine Verweis-Entität (auf eine externe
Datei).
DomNode Allgemeine Knotenklasse (kann alles außer DomDocument
sein).
DomProcessingInstruction Repräsentiert eine Prozessanweisung, beispielsweise
DomText Frei stehender Text zwischen Elementen.
DomXPath Erlaubt Zugriff per XPath-Abfrage auf das Dokument.
Tabelle 14.7: Liste der Klassen, die im DOM-Modul definiert sind
Methode Bedeutung
createAttributeNS Erzeugt ein Attribut mit Namensraum.
createAttribute Erzeugt ein Attribut.
createElementNS Erzeugt ein Element mit Namensraum.
createElement Erzeugt ein neues Element.
createTextNode Erzeugt einen Textknoten.
Tabelle 14.8: Methoden der Klasse DomDocument
621

622
XML und Webservices
Methode Bedeutung
createDocumentFragment Erzeugt ein Fragment neuer Knoten.
createComment Erzeugt einen Kommentarknoten .
createCDATASection Erzeugt einen CDATA-Abschnitt.
createProcessingInstruction Erzeugt eine Prozessanweisung.
createAttribute Erzeugt ein Attribut.
createEntityReferenz Erzeugt einen Verweis.
getElementsByTagName Gibt eine Liste aller Elemente mit dem gegebenen
Namen zurück.
getElementsByTagNameNS Gibt eine Liste aller Elemente mit dem gegebenen
Namen in einem bestimmten Namensraum zurück.
getElementById Gibt ein Element mit einem bestimmten ID-Attribut
zurück.
renameNode Benennt einen Knoten um.
load Lädt ein Dokument aus einem Stream (beispielsweise
eine Datei).
save Speichert das Dokument.
loadXML Lädt XML aus einer Zeichenkette.
saveXML Speichert XML als Zeichenkette.
loadHTML Lädt eine HTML-Datei.
saveHTML Speichert eine HTML-Datei.
validate Prüft gegen eine DTD.
validateSchema Prüft gegen ein Schema (XSD).
validateRelaxNG Prüft gegen ein RelaxNG-Schema.
insertBefore Fügt vor einem anderen Knoten ein.
replaceChild Ersetzt ein Kindelement.
Tabelle 14.8: Methoden der Klasse DomDocument (Forts.)

Methode Bedeutung
removeChild Entfernt ein Kindelement.
appendChild Hängt ein Kindelement an.
hasChildNodes Prüft, ob Kindelemente vorhanden sind.
cloneNode Klont einen Knoten.
hasAttributes Ermittelt, ob ein Element Attribute hat.
isSameNode Vergleicht zwei Knoten auf Identität.
Referenz
isDefaultNamespace Prüft, ob der Knoten im Standardnamensraum ist.
isEqualNode Vergleicht zwei Knoten auf Gleichheit.
Tabelle 14.8: Methoden der Klasse DomDocument (Forts.)
Die Methode getElementById gibt Element-Objekte vom Typ DomElement zurück.
Die Methoden getElementsByTagName und getElementsByTagNameNS geben Auflistungen
mit Elementen des Typs DomNode zurück (interne Klasse DomNodeList).
Methode Bedeutung
getAttribute Ermittelt ein Attribut.
setAttribute Erzeugt und definiert ein Attribut.
removeAttribute Entfernt das Attribut.
getAttributeNS Ermittelt ein Attribut in einem bestimmten Namensraum.
setAttributeNS Erzeugt und definiert ein Attribut in einem bestimmten Namensraum.
removeAttributeNS Entfernt das Attribut in einem bestimmten Namensraum.
getAttributeNode Ermittelt das Attribut als Objekt vom Typ DomAttr.
setAttributeNode Setzt ein Attribut auf Basis eines DomAttr-Objekts.
setIdAttribute Setzt das Attribut mit den Namen ID.
Tabelle 14.9: Methoden der Klasse DomElement
623

624
XML und Webservices
Methode Bedeutung
setIdAttributeNS Setzt das Attribut mit den Namen ID in einem bestimmten
Namensraum.
isSameNode Vergleicht zwei Attribute auf Identität.
isDefaultNamespace Prüft, ob der Attribute im Standardnamensraum ist.
isEqualNode Vergleicht zwei Attribute auf Gleichheit.
Tabelle 14.9: Methoden der Klasse DomElement (Forts.)
Die Methode getAttributeNode gibt ein Objekt vom Typ DomAttr zurück.
Eigenschaft Bedeutung
textContent Inhalt des Elements als Text (ohne Kindelemente).
nodeType Siehe DomNode. Ist bei Elementen immer XML_ELEMENT_NODE.
childNodes Auflistung von Kindelementen als DomNodeList, eine aufzählbare
Liste von DomNode-Objekten.
tagName Name des Elements
Tabelle 14.10: Eigenschaften der Klasse DomElement
Methode Bedeutung
isId Das Attribut ist ein ID-Attribut.
insertBefore Fügt ein Attribut vor dem aktuellen ein.
isSameNode Vergleicht zwei Attribute auf Identität.
isDefaultNamespace Prüft, ob das Attribut im Standardnamensraum ist.
isEqualNode Vergleicht zwei Attribute auf Gleichheit.
Tabelle 14.11: Methoden der Klasse DomAttribute

Eigenschaft Bedeutung
value Wert des Attributes.
name Name des Attributes.
Referenz
specified Gibt TRUE zurück, wenn das Attribut seinen aktuellen Wert
aus dem Dokument erhielt und nicht erst durch spätere
Änderung.
ownerElement Gibt das DomElement zurück, zu dem dieses Attribut gehört.
Tabelle 14.12: Methoden der Klasse DomAttribute
Name der Konstanten Bedeutung
XML_ELEMENT_NODE Element
XML_ATTRIBUTE_NODE Attribut
XML_TEXT_NODE Textknoten
XML_CDATA_SECTION_NODE CDATA-Abschnitt
XML_ENTITY_REF_NODE Entity-Verweis
XML_ENTITY_NODE Entity-Knoten
XML_PI_NODE Prozessanweisung
XML_COMMENT_NODE Kommentar
XML_DOCUMENT_NODE Dokument
XML_DOCUMENT_TYPE_NODE Document Type Deklaration
XML_DOCUMENT_FRAG_NODE Dokumentfragment
XML_NOTATION_NODE Notation (in einer DTD)
XML_GLOBAL_NAMESPACE Globaler Namensraum
XML_LOCAL_NAMESPACE Lokaler Namensraum
XML_HTML_DOCUMENT_NODE Dokument im HTML-Modus
Tabelle 14.13: Konstanten des DOM-Moduls
625

626
XML und Webservices
Name der Konstanten Bedeutung
XML_DTD_NODE Document Type Definition
XML_ELEMENT_DECL_NODE Element-Deklaration einer DTD
XML_ATTRIBUTE_DECL_NODE Attribut-Deklaration einer DTD
XML_ENTITY_DECL_NODE Entitäts-Deklaration einer DTD
XML_NAMESPACE_DECL_NODE Namensraum-Deklaration
XML_ATTRIBUTE_CDATA CDATA-Teil eines Attributes
XML_ATTRIBUTE_ID ID-Attribut
XML_ATTRIBUTE_IDREF IDREF-Attribut
XML_ATTRIBUTE_IDREFS Kollektion von IDREF-Attributen
XML_ATTRIBUTE_ENTITY Entität in einem Attribut
XML_ATTRIBUTE_NMTOKEN NMTOKEN
XML_ATTRIBUTE_NMTOKENS Aufzählung von NMTOKEN Elementen
XML_ATTRIBUTE_ENUMERATION Attribut-Aufzählung
XML_ATTRIBUTE_NOTATION Attribut-Notation
Tabelle 14.13: Konstanten des DOM-Moduls (Forts.)
14.6 Kontrollfragen
1. Welche Technologien sind wichtig, wenn mit XML gearbeitet wird?
2. Welche Methode der Verarbeitung ist bei einem ca. 12 MByte großen XML-
Dokument wahrscheinlich die beste, SAX oder DOM? Begründen Sie die Antwort.
3. Nennen Sie typische Erscheinungsformen eines so genannten Knotens in einem
XML-Dokument.
4. Welche Bedeutung hat die DTD (Document Type Definition)?

Antworten auf die
Kontrollfragen
15

1. Tag
628
Antworten auf die Kontrollfragen
1. Wann wurde PHP das erste Mal unter diesem Namen bekannt?
A 1995, als PHP/FI. Damals war es noch einen Sammlung von Perl-Skripten.
2. Was bedeutet »PHP«?
A Dies ist ein so genanntes rekursives Acronym: PHP Hypertext Preprocessor.
3. Worauf ist der Name »Zend« zurückzuführen?
A Ein Kunstwort aus Namensteilen der Gründer der Firma Zend, Ze von
Zeev Suraski und nd aus Andi Gutmans. Zend stellt den Sprachkern für
PHP bereit und vertreibt außerdem kommerzielle Werkzeuge für PHP, wie
beispielsweise eine IDE, Verschlüsselungs- und Cachetools.
4. Anhand welcher Begrenzungszeichen werden PHP-Fragmente in HTML-Code
erkannt?
A . Andere Varianten werden nicht empfohlen. De Kurzform
zum Einbetten von Variablen sollte nur in Ausnahmefällen
benutzt werden.
5. Welches Protokoll wird zur Übertragung von HTML-Seiten vom Server zum
Browser verwendet?
A HTTP – Hypertext Transfer Protocol.
6. Welcher Webserver kann auf allen Betriebssystemen zur Entwicklung eingesetzt
werden?
A Der Apache-Webserver ist auf allen Plattformen zu Hause.
7. Wofür steht der Begriff WAMP?
A W = Windows, A = Apache, M = MySQL, P = PHP. Die beliebteste Kombination
für PHP-Entwickler, wird von weit über 90% der Anwender
benutzt.
8. Welche Bedeutung hat die Adresse »http://localhost«?
A Verweis auf den lokalen Webserver (!). Der Name weicht meist vom
Namen des lokalen Computers ab. Die zugehörigen IP-Adresse ist
127.0.0.1.

9. Mit welcher Funktion kann PHP5 ausführlich getestet werden?
2. Tag
A phpinfo() heißt die Funktion. Folgendes Skript zeigt, wie die Funktion
genutzt wird:
2. Tag
1. Wie geben Sie mehrzeilige Texte aus PHP-Code heraus am besten aus?
A Mit der Heredoc-Syntax werden mehrzeilige Texte aus PHP-Code heraus
ausgegeben:
2. Welche Funktion eignet sich zur Ausgabe hexadezimaler Farbangaben?
A printf könnte hilfreich sein. Die Option %2X erzeugt zweistellige hexadezimale
Zahlen. Als Eingabewert dienen alle Zahlenliterale, also beispielsweise
32 (Dezimal) oder 0x20 (Hexadezimal) oder 040 (Oktal).
3. Welche Kommentarform wird am besten verwendet, wenn hinter einer Codezeile
ein kurzer, auf die Zeile bezogener Kommentar stehen soll? Mögliche Varianten
sind: /* */, // oder #.
A Es sollte immer // verwendet werden. # ist unüblich und /* scheitert, wenn
umschließende mehrzeilige Kommentare benutzt werden, um den Block
auszukommentieren.
629

3. Tag
1. Was ist ein Literal?
630
Antworten auf die Kontrollfragen
A Jede Form von im Quellcode direkt geschriebener konstanter Werte, also
beispielsweise 0x22, 345.66, "string" usw.
2. Wie werden Konstanten definiert?
A Konstanten werden mit der Funktion define erstellt.
3. Wozu werden reguläre Ausdrücke eingesetzt?
A Reguläre Ausdrücke werden zum Suchen und Ersetzen benutzt, wenn die
Suchmuster komplex oder in sich variabel sind.
4. Schreiben Sie ein Skript, dass anhand mehrerer Parameter ein span-Tag mit korrekter
hexadezimaler Angabe der Vordergrund- und Hintergrundfarbe mit Hilfe
des style-Attributes erstellt und ausgibt. Tipp: Verwenden Sie printf.
A printf ist aufgrund der Parameter gut geeignet, um Tags übersichtlich zu
erstellen.
4. Tag

Ausgegeben werden die Zahlen : 0, 30, 70 und 100.
2. Können mit switch-Anweisungen auch Vergleiche mit beliebigen Booleschen
Ausdrücken erfolgen?
4. Tag
A Ja, denn PHP behandelt die Ausdrücke erst zur Laufzeit und erledigt dann
den Vergleich. Wenn man im Verzweigungskopf den Wert TRUE schreibt,
müssen die Ausdrücke auch TRUE oder FALSE zurückgeben, sodass ein Test
auf Gleichheit funktioniert. Wichtig ist jedoch darauf zu achten, dass
immer nur ein (oder kein) Zweig die Bedingung zum Zeitpunkt der
Abfrage erfüllt, sonst ist die Reaktion nicht korrekt.
switch(TRUE)
{
case $test < 9 && $test > 4:
// Reaktion
break;
}
3. Welche Schleife wird benutzt, wenn sichergestellt werden muss, dass der Schleifenkörper
mindestens einmal durchlaufen wird?
A Die do-Schleife. Da der Test erst am Ende mit Hilfe der while-Bedingung
erfolgt, wird der Körper garantiert einmal durchlaufen, auch wenn die
Bedingung dann nicht erfüllt ist und die Schleife sofort wieder verlassen
wird.
4. Zu Testzwecken kann es erforderlich sein, eine Schleifenbedingung so zu formulieren,
dass eine Endlosschleife entsteht. Mit welchen Anweisungen kann ein
»Notausstieg« programmiert werden?
A Die Bedingung für den Ausstieg wird mit if erstellt, der Ausstieg erfolgt
dann mit break. switch ist nicht geeignet, weil die Zweige selbst mit break
enden und ein weiteres break nicht mehr ausgeführt wird.
631

5. Tag
632
Antworten auf die Kontrollfragen
1. Worin unterscheiden sich normale von assoziativen Arrays?
A Assoziative Arrays verwenden Schlüsselwerte, die meist als Zeichenketten
vorliegen, zur Adressierung der Elemente, beispielsweise $arr[?name?].
»Normale« Arrays haben dagegen immer Zahlen, über die Elemente
erreicht werden, beispielsweise $arr[8].
2. Wie kann ein Element eines Array gezielt entfernt werden?
A Mit unset kann ein Element entfernt werden. PHP organisiert die Schlüsselwerte
einfacher Arrays danach nicht neu. Sie müssen das selbst erledigen,
wozu die Funktion array_values dient:
A Die Ausgabe der Indizes lautet 0, 1, 2. Ohne array_values wäre es 0, 1, 3.
3. Schreiben Sie ein Skript, dass Arrays nutzt um Namen von Mitarbeitern zu speichern.
Erweitern Sie das Skript, sodass zu jedem Mitarbeiter im selben Array
zusätzliche Informationen gespeichert werden. Tipp: Nutzen Sie verschachtelte
assoziative Arrays dafür.
A Sie können innerhalb einer array-Definition für den Wert ein weiteres
Array verwenden. Als Schlüssel sind dagegen nur Zahlen oder Zeichenketten
erlaubt. Beachten Sie jedoch, dass mehr als drei Ebenen nur schwer
handhabbar sind und meist auf einen Designfehler beim Entwurf des
Datenmodells hindeuten.

6. Tag
foreach ($ma as $name => $details)
{
echo "$name => $details[0], $details[1]";
echo '';
}
?>
1. Schreiben Sie ein Skript, dass die Namen von Mitarbeitern in einer eigens dafür
entwickelten Klasse speichert.
6. Tag
A Sie sollten auch bei derart einfachen Aufgabenstellungen grundsätzlich
versuchen, die elementaren OOP-Techniken zu verwenden. Dazu gehört
der Schutz der Daten in privaten Mitgliedern und der Zugriff über __get
bzw. __set und die Verwendung eines sinnvollen Konstruktors.

634
Antworten auf die Kontrollfragen
return $this->_room;
}
}
}
$ma = array(new Employee('Bernd Muster', '0172/654321', '215'),
new Employee('Katja Muster', '0172/123456', '948'));
foreach ($ma as $em)
{
echo "{$em->name} => {$em->telephon}, {$em->room}";
echo '';
}
?>
2. Erklären Sie den Unterschied zwischen private, public und protected.
A Mitglieder, die in einer Klasse als private gekennzeichnet sind, können
nur von Methoden der Klasse selbst benutzt werden. Mitglieder, die in
einer Klasse als public gekennzeichnet sind, können von Methoden oder
Funktionen des gesamten Skripts benutzt werden. Mitglieder, die in einer
Klasse als protected gekennzeichnet sind, können nur von Methoden der
Klasse selbst und solchen einer von dieser Klasse abgeleiten Klasse benutzt
werden.
3. Sie haben nur eine einzige Klasse in Ihrem Skript. Ist die Anwendung des Schlüsselwortes
protected sinnvoll? Begründen Sie die Antwort.
A Nein, die Anwendung ist nicht sinnvoll. Sie können das so gekennzeichnete
Mitglied nicht aus Ihrem Skript erreichen und für die Benutzung
innerhalb der Klasse wäre private ausreichend.
4. Welchen Vorteil bietet die Verwendung von __get und __set anstatt des direkten
Zugriffs auf öffentliche Eigenschaften, die mit public $name gekennzeichnet
sind?
A Die Pseudo-Eigenschaften können den Weg der Daten in die Eigenschaft
hinein und wieder heraus kontrollieren. Man kann so sicherstellen, dass
niemals ungültige Daten im Objekt gespeichert sind. Man kann auch
sicherstellen, dass niemals ungültige Daten das Objekt verlassen. Beides
trägt zur Codesicherheit bei. Außerdem kann eine Klasse weitaus mehr
Eigenschaften bereitstellen, als Mitgliedsvariablen vorhanden sind. Die
interne Form der Datenspeicherung kann also anderen Optimierungskriterien
unterliegen als die Darstellung der Daten nach außen.

5. Wie schreiben Sie eine Klasse, deren Objekte beim Aufruf von new einen definierten
Anfangszustand unabhängig von Parametern erhalten soll?
7. Tag
A Sollen die Daten des Anfangszustands nicht variabel sein, bietet sich der
Einsatz von Konstanten an. Im Konstruktor werden die Konstanten dann
den Eigenschaften zugewiesen. Dies erleichtert die Wartung der Klasse.
6. Wie schreiben Sie eine Klasse, von der nur eine Instanz erzeugt werden darf? Wie
nennt man dieses Entwurfsmuster?
A Das Muster wird Singleton genannt. Man deklariert den Konstruktor privat,
um den wiederholten Aufruf zu verhindern. Ersatzweise schafft man
eine Methode, in der mittels new eine Instanz erzeugt und zurückgegeben
wird. Die Methode speichert die erzeugte Instanz in einer Variablen und
prüft beim erneuten Aufruf, ob die Instanz bereits existiert. Ist das der Fall,
wird die bereits existente Version zurückgegeben, die zugleich die einzige
Instanz der Klasse ist.
7. Tag
1. Auf welche Datenquellen können die Dateifunktionen zugreifen?
A Dank des universellen Stream-Konzeptes können Dateifunktionen aus
beliebigen Datenquellen zurückgreifen. Bereits fertig implementiert ist der
Zugriff auf Dateien des Dateisystems, Ein-/Ausgabekanäle des Betriebssystems,
Webserver per HTTP und FTP-Server. Für andere Datenquellen lassen
sich benutzerdefinierte Wrapper erstellen.
2. Warum muss eine Datei nach der Benutzung wieder geschlossen werden?
A Der schreibende Zugriff auf Dateien ist exklusiv, damit sich die Änderungen
nicht unbemerkt überschreiben. Um künftige Zugriffe nicht zu verzögern,
sollten Dateien schnell wieder geschlossen werden. Bedenken Sie,
dass Webserver Multiuser-Zugriffe gestatten, ein Skript also gleichzeitig
mehrfach starten kann.
635

636
Antworten auf die Kontrollfragen
3. Schreiben Sie ein Skript, dass eine beliebige Datei aus dem aktuellen Verzeichnis
im Quelltext anzeigt, wobei der Benutzer die Datei selbst wählen kann. Tipp:
Benutzen Sie HTML-Links und ermitteln
Sie den übergebenen Namen mittels $_GET[’name’].
A Zuerst benötigt man eine Dateiliste. Hier ist das Verzeichnisobjekt dir
oder der DirectoryIterator der SPL eine gute Wahl.
4. Warum ist das in der letzten Übung verlangte Prinzip auf einer öffentlichen
Website nicht unmodifiziert einsetzbar? Tipp: Denken Sie an mögliche Sicherheitsprobleme.
A Der GET-Parameter lässt sich im Browser leicht manipulieren. Da die
meisten Dateifunktionen auch Pfade mit relativen Angaben wie ../../../ verarbeiten
können, lassen sich so leicht Dateien auslesen, die nicht zum
freien Zugriff gedacht sind. Auch wenn das Betriebssystem meist verhindert,
dass Systemdateien gelesen werden können, reicht oft die Auswahl
einer Include-Datei oder anderer PHP-Skripte, um an Kennwörter oder
Systeminformationen zu gelangen.
Zur Lösung arbeitet man mit Hashwerten oder ID-Nummern, sodass im
Link nur Werte stehen, die keinen Rückschluss auf die Datei zulassen.
Den Dateinamen einfach als MD5-Hash abzulegen ist freilich keine
Lösung, denn Profis erkennen derartige Hashes sehr schnell und können
sie ebenso schnell auch erzeugen.
8. Tag
1. Warum sollten unbedingt immer »Sticky Forms« verwendet werden?
A Es ist ausgesprochen lästig für den Benutzer, wenn er nach einem Fehler
die mühevoll eingegebenen Daten verliert. Formulare sind ohnehin die
Stelle mit der höchsten Abbruchquote. Schlecht gemachte Formulare steigern
den Misserfolg der Site enorm.
Inzwischen gilt der Verzicht auf »Sticky Forms« auch einfach nur als
unprofessionell.

2. Welche Funktionen unterstützen das Hochladen von Dateien? Was ist beim Aufbau
des Formulars zu beachten?
9. Tag
A Die wichtigste Funktion ist move_uploaded_file, eingesetzt zum Transport
der Dateien zum endgültigen Ziel. Beim Formular ist zu beachten, dass
das Attribut enctype im Form-Tag angegeben wird, damit der Browser die
Daten korrekt verpackt.
3. Welche Methoden verwenden Sessions, um die Session-Daten zu speichern?
A Zum Speichern werden Dateien oder Datenbanken benutzt, seltener der
Systemspeichern. PHP5 unterstützt standardmäßig Dateien. Beachten Sie,
dass die Sessiondaten, die im Sessioncookie gespeichert werden, lediglich
eine Referenznummer auf die im Webserver oder einer Datenbank gespeicherten
Daten enthalten.
4. Wie können Cookies missbraucht werden?
A Cookies können mit jeder Anforderung gesendet werden. Da die Objekte
einer Website nicht vom selben Server stammen müssen, können beim
Laden einer Website auch Cookies verschiedener Server übermittelt werden.
Besucht derselbe Benutzer eine andere Website, wobei ein Objekt
von demselben Server stammt wie beim Besuch der vorhergehenden Site,
erhält der Server das Cookie von der zweiten Site wieder zurück. Damit
kann man Bewegungsprofile erstellen, die den Weg des Benutzers durchs
Web markieren. Firmen wie Doubleclick nutzen dies als Geschäftsmodell,
um kundenspezifische Werbebanner zu schalten.
9. Tag
1. Welche Servervariable wird benutzt, um die bevorzugte Sprache des Benutzers zu
ermitteln?
A HTTP_ACCEPT_LANGUAGE kann verwendet werden. Zur Abfrage
schreiben Sie:
$lang = $_SERVER['HTTP_ACCEPT_LANGUAGE'];
637

638
Antworten auf die Kontrollfragen
2. Welcher Header wird in HTTP benötigt, um dem Browser anzuzeigen, dass ein
Bild gesendet wird?
A Benötigt wird Content-type:. Als Parameter ist image/ anzugeben,
wobei der Typ dem Bildformat entspricht:
Content-type: image/gif
3. Schreiben Sie ein Skript, dass dezimale Farbangaben wie 255, 192, 128 in hexadezimale
Zeichenfolgen der Art »#FFCC99« umrechnet und umgekehrt.
A Nutzen Sie die Funktion printf dafür. Folgende Zeile muss nur noch in
eine Funktion eingebaut werden:
printf('#%2X%2X%2X', 255, 192, 128);
4. Wozu dient das Werkzeug Reflection?
A Mittels Reflection kann Code analysiert werden.
10. Tag
1. Welche Aufgabe erfüllen Wrapper?
A Wrapper dienen dazu, benutzerspezifische Ein-/Ausgabekanäle zu schaffen,
sodass beispielsweise die normalen Dateifunktionen darauf zugreifen
können.
2. Was muss ein fremder Entwickler beachten, wenn er einen von Ihnen entwickeltes
Filter verwendet?
A Nichts – Filter sind für die Benutzung transparent.
3. Was bedeuten die Kopfzeilen Cc: und Bcc: in einer E-Mail?
A Cc: (Carbon Copy, Durchschlag) sendet eine Kopie der E-Mail an den
angegebenen Empfänger, wobei alle anderen Empfänger dessen Adresse
sehen. Bcc: dagegen sendet ebenso eine Kopie, andere Empfänger können
dies aber nicht sehen (Blind Carbon Copy, Blinddurchschlag).
4. Welches Protokoll nutzt die mail-Funktion zur Übertragung der Daten?
A Diese Funktion überträgt die Daten mittels SMTP zum Server.

11. Tag
11. Tag
1. Warum sollte die neue Bibliothek MySQLi anstatt der alten eingesetzt werden?
A MySQLi ist auf die Datenbank MySQL 4 abgestimmt. Außerdem unterstützt
das neue Modul die objektorientierte Programmierung.
2. Was versteht man unter Normalisierung?
A Stark vereinfacht die Vermeidung redundanter Datenhaltung in einer relationalen
Datenbank.
3. Sie müssen bei der Ausgabe von Daten aus einer MySQL-Datenbank Datumsformate
anpassen und \n in umwandeln. Wie gehen Sie vor?
A MySQL verfügt über einen reichen Vorrat an Zeichenkettenfunktionen.
Suchen Sie eine Funktion zum Suchen und Ersetzen, die dies erledigt.
Dies ist meist schneller als nl2br im PHP-Skript.
4. Wie würden Sie eine Abfrage formulieren, bei der aus zwei Tabellen Daten
zugleich entnommen werden müssen? Welche Voraussetzungen müssen die
Tabellen erfüllen.
A Dies ist ein so genannter JOIN:
12. Tag
SELECT t1.feldname, t2.feldname
FROM tabelle1 t1 INNER JOIN tabelle2 t2 ON t1.id = t2.id
Die Schreibweise tabelle1 t1 definiert einen Aliasnamen für tabelle1.
Damit lassen sich gleichnamige Felder auseinander halten, ohne die möglicherweise
langen Tabellennamen schreiben zu müssen. t1.id = t2.id verknüpft
die beiden Tabellen miteinander, indem die Primärschlüssel
verglichen werden. t1.feldname, t2.feldname ruft dann aus jeder Tabelle
eine bestimmte Spalte ab.
1. Was müssen Sie tun, um SQLite benutzt zu können?
A Nichts, SQLite gehört zum Standardumfang von PHP5.
639

640
Antworten auf die Kontrollfragen
2. Welche Datentypen kennt SQLite?
A Zahlen und Zeichen, alle anderen Datentypnamen sind nur aus Kompatibilitätsgründen
im Umfang reservierter Namen. SQLite prüft sonst keine
Daten sondern behandelt diese immer als Zeichenketten.
3. Sie möchten mehrere Tausend Datensätze für eine hoch frequentierte Website
verwalten. Ist SQLite dafür die beste Wahl? Begründen Sie die Antwort?
A SQLite ist dafür nicht geeignet, weil die Verwaltung der Datenbank auf
Dateiebene stattfindet. Während des Zugriffs auf eine Tabelle ist die Datei
gesperrt, was konkurrierende Zugriffe unmöglich macht. Bei hoher Last
wird SQlite deshalb sehr langsam.
4. Welche Aufgabe hat der Befehl VACUUM?
A Der Befehl verdichtet die Datenbank nach Löschvorgängen. Die separate
Optimierung verhindert, dass einfache Löschvorgänge zu lange dauern.
13. Tag
1. Wozu werden Template-Systeme eingesetzt?
A Template-Systeme dienen dazu, Code und Layout zu trennen.
2. Erweitern Sie die Applikation, sodass zu jedem Leser der Bibliothek mehrere Telefonnummern
gespeichert werden können. Wie gehen Sie vor?
A Legen Sie eine weitere Tabelle in der Datenbank an. Erweitern Sie die
Tabelle der Leser um einen ID-Spalte. Verknüpfen Sie die Spalte mit der
neuen Telefon-Tabelle und einer dort befindlichen Korrespondenz-Spalte.
Sie benötigen also mindestens drei Spalten in der Telefon-Tabelle: id (Primärschlüssel),
telephon-id (Verknüpfung, gleiche Werte können freilich
mehrfach auftreten, wenn ein Kunde mehrere Telefonnummern hat), telephon
(die eigentlichen Daten).
3. Formulieren Sie eine SQL-Abfrage, die die nötigen Daten zur Erstellung von
Mahnschreiben erzeugt, um säumige Leser auf die bereits abgelaufene Rückgabefrist
hinzuweisen.
A Der folgende Ausdruck (Teil der Abfrage) wird TRUE, wenn die Ausleihfrist
abgelaufen ist:
TO_DAYS(CURDATE())-TO_DAYS(lendingdate) > lendingperiod

14. Tag
1. Welche Technologien sind wichtig, wenn mit XML gearbeitet wird?
14. Tag
A Neben XML benötigen Sie eine Definitionssprache, also DTD oder XML-
Schema. Außerdem zur Verarbeitung XSLT und XPath.
2. Welche Methode der Verarbeitung ist bei einem ca. 12 MByte großen XML-
Dokument wahrscheinlich die beste, SAX oder DOM? Begründen Sie die Antwort.
A SAX ist besser. Die sequenzielle ereignisbasierte Verarbeitung ist optimal
bei großen Datenmengen. DOM würde das Dokument als Ganzes versuchen
im Speicher zu halten und dabei sehr viel Speicherplatz benötigen,
sodass der Zugriff sehr langsam wird.
3. Nennen Sie typische Erscheinungsformen eines so genannten Knotens in einem
XML-Dokument.
A Neben Elementen sind auch Kommentare, Attribute, CDATA-Abschnitte
und Prozessanweisungen Teil eines XML-Dokuments. Da das gesamte
Dokument als Baum dargestellt werden kann, dessen Verzweigungen Knoten
sind, können Knoten praktisch jeden Teil des Dokuments darstellen.
4. Welche Bedeutung hat die DTD (Document Type Definition)?
A Die DTD definiert die in einem XML-Dokument zulässigen Elemente
(deren Namen) und deren Attribute sowie die Abhängigkeiten zwischen
diesen. Dazu gehört beispielsweise, welche Elemente in welcher Zahl Kindelemente
anderer sein dürfen. Ohne DTD kann man lediglich prüfen, ob
ein XML-Dokument wohlgeformt ist. Mit DTD kann man prüfen, ob es
außerdem gültig ist. Jedes XML-Dokument sollte eine DTD haben oder
alternativ das neuere XML-Schema, das einem vergleichbaren Zweck
dient.
641

Stichwortverzeichnis
Symbols
$_COOKIE 351
$_REQUEST 355
-> 208
__autoload 172
__call 227
__clone 218
__construct 210
__destruct 211
__FILE__ 233
__get 229
__LINE__ 233
__METHOD__ 233
__set 229
__toString 226, 234
_subclass_of 237
A
Abfragesyntax 446
Abstammung 235
abstract 217
Achsenbezeichner 564
Addition 79
Ähnlichkeiten 88
aggregierende Funktionen (SQL) 454
Algebra, logische 81
ALL (SQL) 454
alternative Zweige 136
Anführungszeichen 85
Anhänge versenden 434
Apache
– installieren 30
– testen 35
ArGoSoft Mail Server 429
Array 182
– Assoziative 191
– erstellen 183
– Funktionen 198
– Werte 186
– Zeiger 188
array_walk 196
Arraydaten 193
ASC (SQL) 456
ASCII-Zeichensatz 91
Assoziativität 133
attributes (SimpleXML) 586
Attributknoten 563
Ausdrücke 78
Ausgaben 55
– formatieren 59
AUTO_INCREMENT (SQL) 451
AVG (SQL) 455
B
Backslash 84
Bad Request 42
Base64 428
basename 254
Benennungsregeln 65
Benutzerverwaltung (mit SQLite) 501
BETWEEN (SQL) 448
Bilder 49
– Funktionen 385
– Zeugung 381
BinHex 428
Boolesches 81
break 137, 141
Browserdaten erkennen 374
C
case 137
catch 178
childNodes 579
children (SimpleXML) 587
chunk_split 94
class 207
643

Stichwortverzeichnis
clone 218
Coding Standards 65
continue 141
Cookies 349
– Beschränkungen 352
– Personalisierung 352
copy 335
count 184
COUNT (SQL) 454
CREATE TABLE (SQL) 449
current 188
current (Iterator) 265, 265
D
D. Richard Hipp 498
date 111
Dateien hochladen 334
Dateisystem 244
Dateizugriff 246
Datenspeichermethoden 358
Datentypen 74, 83
Datentypen (SQL) 449
Datum 110
default 138
DEFAULT (SQL) 451
define 76
defined 77
Dekrement 79
DELETE (SQL) 453
DESC (SQL) 456
Destruktoren 210
dir 260
DirectoryIterator 266
DISTINCT (SQL) 454
Division 79
DNS 70
do 148
DOM 576
– domAttr (Klasse) 624
– Funktionen 576
– Konstanten 625
Domain Name System siehe DNS
DomAttr 624
DomDocument 579
– getAttributeNode 624
644
– getElementsById 623
– getElementsByTagName 623
DomXPath 566
DROP (SQL) 453
Dropdown-Listen 295
DTD 553
dynamisch Bilder erzeugen 379
dynamischer Werbebanner 386
E
each 195
echo 55
Eigenschaftenaufruf 229
Elementknoten 563
else 136
Elternknoten 563
E-Mail 426
– versenden 430
empty 287
Entitäten 93
Ersetzen 87
Exception 224
exklusives Oder 83
Extensible Markup Language siehe XML
F
Factory-Klassen 235
Farbrad 146
fclose 251
Fehler (PHP) 42
– Behandlung 173
– Codes 177
– Klassen erstellen 224
– Nummer 176
– Text 176
fgets 251
file_get_contents 420
Filter 422, 440
final 216
fnmatch 260
fopen 251
for 142
foreach 194
Formatieren 119
– Zahlen 119

Formatregel 60
Formulare 52
– bauen 302
fscanf 120
func_get_arc 156
func_get_args 156
func_num_args 156
function 150
Funktionen 150
– Referenzen 159
– Rekursive 164
– Variable 166
Funktionsdefinition 150
G
GD2 379
Geschichte 22
GET 341
get_included_files 172
get_meta_tags 419
get_required_files 172
getElementsByTagName 579
getMessage 225
gleich 82
glob 257
global 162
globale Variablen 162
Grafikbibliothek 379
Grafiken 379
Größe (Datentyp) 83
größer als 82
Große Textmengen 57
GROUP BY (SQL) 454
Gruppierungen 98
Gruppierungen (SQL) 455
Gutmans, Andi 22
H
Handle 244
Hashes 186
HAVING (SQL) 454
header 380
heredoc 57
Herkunft erkennen 282
Hinweistexte platzieren 303
hochladen 334
HTML 46
– Formularelemente 278
– Mails 434
htmlentities 93
HTTP 71
HTTP_REFERER 282
httpd.conf 40
I
iconv-Modul 340
idate 116
if 132
imagecreate 381
imagecreatefromgif 382
imagecreatefromjpeg 382
imagecreatefrompng 382
imagegif 382
imagettfbbox 382
imagettftext 383
IMAP4 427
implements 221
IN (SQL) 448
include 169
include_once 169
Inkrement 79
Inner Join 458
INSERT INTO (SQL) 451
instanceof 236
Interfaces 221
is_a 237
is_resource 251
ISO-8859-1 91
J
JavaScript 47, 303
– lokale Zeit 117
JOIN (SQL) 459
K
key 188
Kindknoten 563
Klasse 207
kleiner als 82
Stichwortverzeichnis
645

Stichwortverzeichnis
Kombinationsoperatoren 81
Kommentare 62
Konfigurationsschritte 38
Konstanten 76
Konstruktoren 210
Kontext 440
Kontrollkästchen 287
Krause, Jörg 17
L
Laufzeitfehler 175
LC_TIME 116
LEFT JOIN (SQL) 459
libxml2 575
LIKE (SQL) 448
links-assoziativ 134
list 195
Literale 74
loadHtmlFile 579
localeconv 378
Lokalisierung 376
M
Mail 426
MAX (SQL) 455
MAX_FILE_SIZE 337
MD5 347
Mehrfachauswahl 297, 322
Mehrfachverzweigungen 137
mehrseitige Formulare 325
mehrsprachige Webseiten 374
Message Digest Version 5 347
MIME 428
MIN (SQL) 455
mktime 111
Modularisierung 168
Module einbinden 168
Modulus 79
Moniker 416
move_uploaded_files 335
MSI Installer 30
multipart/form-data 334
Multiplikation 79
Multipurpose Internet Mail Extensions
siehe MIME
646
MySQL
– Aggregat-Funktionen 467
– Beispielprojekt 510
– Control Center 513
– Datentypen 462
– Datumsformatierungen 475
– Datumsfunktionen 473
– Dialekt 461
– Funktionen 464
– Kontrollflussfunktionen 466
– Mathematische Funktionen 465
– Systemfunktionen 468
– Verschlüsselungsfunktionen 469
– Zahlenformatierungen 473
– Zeichenkettenfunktionen 470
– Zeitfunktionen 473
MySQLi 477
– Einfache Abfragen 485
– Komplexe Abfragen 487
– Referenz 491
– Testen 478
– Verknüpfungen abfragen 489
N
Namenskonventionen 68
new 208, 471, 471
next 188
next (Iterator) 265
Nicht 82
nl2br 94, 285
nodeType 580
Normalisierungen 457
NOT NULL (SQL) 451
NULL (SQL) 451
number_format 119
O
Objekt erzeugen 208
Objektorientierte Programmierung 204
oder 82
Operatoren 78
Optionsfelder 288
ORDER BY (SQL) 454, 456

P
Paradigmen 205
Parameter 153
– Anzahl, beliebige 155
– optionale 154
– Übergabe 159
parent 211
parse_url 343
PEAR 65
PECL-Module 29
Personal Home Page (Tools)/Forms
Interpreter 22
PHP
– Blöcke 27
– einbetten 53
– Skripte ausführen 41
PHP5 23
– installieren 37
– konfigurieren 37
PHP Hypertext Preprocessor 22
php.ini 38
PHP_OS 116
PHP_SELF 254
PHP4 23
phpTemple 516, 575
Platzhalter 96
POP3 427
preg_match 100
preg_match_all 100
preg_replace 100
preg_replace_callback 100
prev 188
Primärschlüssel 460
PRIMARY KEY (SQL) 451
print 58
print_r 196
printf 60, 120
– Formatstruktur 121
Prinzip des Seitenabrufs 70
private 215
professionelle Programmierung 62, 373
protected 216
Protokolldatei 255
public 215
PUT 334
Q
Query Builder 446
Quoted Printable 428
R
Rangfolge 133
Rasmus Lerdorf 22
RDF 569
Rechnen 79
rechts-assoziativ 135
Reflection::export 395
Reflection-API 395
ReflectionClass 399
ReflectionExtension 405
ReflectionFunction 397
Reflection-Informationen 395
Reflection-Klassen 397
ReflectionMethod 402
ReflectionProperty 403
Regex-Maschinen 103
registerXPathNamespace 592
reguläre Ausdrücke 95
rekursive Dateiliste 263
rekursive Funktionen 164
REQUEST_METHOD 281
require 169
require_once 169
reset 188
Ressource 244
rewind (Iterator) 265
RIGHT JOIN (SQL) 459
Root-Server 70
RSS 568
Rückgabewerte 151
S
Schema 553
Schleifen 141
Schnittstellen 221
Seitenmanagement 277
SELECT (SQL) 446
serialize 356
Stichwortverzeichnis
647

Stichwortverzeichnis
Servervariablen 365
Serverzeit 110
Sessions
– Cookies 350
– Verwaltung 358
set_error_handler 175
setcookie 352
setlocale 115, 376
setrawcookie 352
Sicherheitsprobleme 346
SimpleXML 581
– Referenz 620
simplexml_import_dom 587
simplexml_load_file 585, 620
simplexml_load_string 620
Singleton 213
Smarty 516
SMTP 427
SOAP 593, 595
– Body 595
– Envelope 595
– Header 595
– Projekt 608
Socket-Verbindung 441
Sonderzeichen 84f.
sort 191
Sortieren (SQL) 456
Sortierfunktion 191
SPAM-Versender 429
Sprache 374
sprintf 120
SQL 445
– Aggregate Funktionen 467
SQL92 461
SQLite 498
– Beispiel 500
– Referenz 506
sqlite_close 505
sqlite_error_string 504
sqlite_fetch_array 504
sqlite_last_error 504
sqlite_num_rows 504
sqlite_query 504
sscanf 120
648
Standard-Wrapper 247
static 213
statische Mitglieder 212
statische Variablen 160
Sticky Forms 301, 315
str_ireplace 89
str_replace 89
strcmp 89
stream_context_create 253
Streams 416
– Funktionen 425, 440
strftime 111
strip_tags 422
stripos 88
strlen 90
strnatcasecmp 88
strncasecmp 88
strpos 87
strrpos 88
Structured Query Language siehe SQL
Sub-Select 460
substr 92
Subtraktion 79
Suchen 87
Suchmuster 103
SUM (SQL) 455
Suraski, Zeev 22
switch 137
T
Tabellen 49, 445
Tabulator 85
Teilausdrücke 79
Teilzeichenketten 90
Template-System 516
Textfelder 285
Textknoten 563
throw 178
Timestamp 110
trigger_error 175
trinärer Operator 82
TRUNCATE (SQL) 453
try 178
Typ-Informationen 223

U
Umgebungsvariablen 365
und 82
ungleich 82
UNIQUE (SQL) 451
Unix-Timestamp 110
unserialize 357
unset 187
Unterabfragen 460
UPDATE (SQL) 452
url_decode 343
url_encode 343
UserLand 569
UTC 110
utf8_decode 580
UUEncode 427
V
valid (Iterator) 265
variable Funktionen 166
Variablen 74
– Erkennung 84
– globale 162
– statische 160
Vererbung 211
Vergleiche 81
verketten 80
Verknüpfungen (SQL) 457
Verzeichnisobjekt dir 260
Verzeichniszugriff 257
Verzweigungen 132
Vorauswahl 299
Vorbereitung 24
Vorzeichen 79
vprintf 120
vsprintf 120
W
Wagenrücklauf 85
WAMP 29
WebDAV 334
Webserver bauen 29
Webservices 593
– konsumieren 607
WHERE (SQL) 447
while 148
wordwrap 93
Wrapper 416
– eigene 425
Wrapper-Zugriff 246
WSDL 597
wsdl_cache_dir 608
wsdl_cache_enabled 608
wsdl_cache_ttl 608
Wurzelknoten 563
Stichwortverzeichnis
X
XML 550
– Definition 552
– Namensräume (SimpleXML) 588
– Path Language 1.0. 562
– Pointer Language 552
XPath 562
– Achsenbezeichner 564
– ancestor 564
– Ausdrücke 563
– Ausdrücke in PHP5 566
– child 564
– descendant 564
– following 565
– parent 564
– preceding 565
– self 564
xpath (SimpleXML) 588
XPath-Knoten 563
XQuery 553
xsl:apply-template 556
xsl:call-template 559
xsl:copy-of 559
xsl:for-each 558
xsl:if 557
xsl:include 560
xsl:number 559
xsl:output 560
xsl:sort 558
xsl:template 555
xsl:text 555
xsl:value-of 556
649

Stichwortverzeichnis
XSLT 553
– Basisregeln 555
– Funktionen 560
Z
Zeichen 90
Zeichencodes 91
Zeichenfolgen verketten 80
Zeichenketten 83
– erkennen 85
– Funktionen 86
650
– Operationen 86
Zeichenklassen 96
Zeilenvorschub 85
Zeit 110
Zend-Engine 23
Zielgruppe 16
Zugriffskontrolle 215
Zugriffsmethoden 227