Programmieren lernen in PHP 5 3446227377, 9783446227378 [PDF]
PHP wird mit der Version 5 erwachsen und wer bisher noch nie eigenen Programmcode für Webapplikationen geschrieben hat,
137 59 7MB
German Pages 399 Year 2004
Papiere empfehlen
![Programmieren lernen in PHP 5
3446227377, 9783446227378 [PDF]](https://vdoc.tips/img/200x200/programmieren-lernen-in-php-5-3446227377-9783446227378.jpg)
- Author / Uploaded
- Jörg Krause
Datei wird geladen, bitte warten...
Zitiervorschau
Jörg Krause Programmieren lernen in
PHP 5
v
Bleiben Sie einfach auf dem Laufenden: www.hanser.de/newsletter Sofort anmelden und Monat für Monat die neuesten Infos und Updates erhalten.
Jörg Krause Programmieren lernen in
PHP 5
Der Autor: Jörg Krause, Berlin
www.hanser.de
Alle in diesem Buch enthaltenen Informationen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autor und Verlag übernehmen infolgedessen keine Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen – oder Teilen davon – entsteht, auch nicht für die Verletzung von Patentrechten, die daraus resultieren können. Ebenso wenig übernehmen Autor und Verlag die Gewähr dafür, dass die beschriebenen Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt also auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.
Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.
Dieses Werk ist urheberrechtlich geschützt. Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren), auch nicht für Zwecke der Unterrichtsgestaltung, reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden. © 2004 Carl Hanser Verlag München Wien Gesamtlektorat: Fernando Schneider Copy-editing: Haide Fiebeler-Krause, Berlin Herstellung: Monika Kraus Datenbelichtung, Druck und Bindung: Kösel, Kempten Printed in Germany ISBN 3-446-22737-7
Schnellübersicht
5
Schnellübersicht Die folgende Übersicht hilft Ihnen, die für Sie relevanten Kapitel schnell zu finden. Sie finden passend dazu auch eine Griffleiste am rechten Rand.
Schnellübersicht ..................................................................................................5 Vorwort.................................................................................................................7 Inhaltsverzeichnis ...............................................................................................9 1 Vor dem Start .............................................................................................17 2 Dynamik in der Webseite.........................................................................25 3 Variablen und Konstanten .......................................................................45 4 Rechnen und Verarbeiten.........................................................................55 5 Komplexe Datenstrukturen: Arrays ........................................................83 6 Das Steuerrad für PHP: Kontrollstrukturen...........................................99 7 Sammeltransporte: Objekte....................................................................137 8 Daten bewegen: Dateisystem und FTP.................................................161 9 Daten aus dem Browser: Formulare und Links ...................................195 10 Big Brother: Sessions und Cookies ......................................................223 11 Datenbanken: So werden Daten gespeichert .......................................249 12 Symbiose: PHP und JavaScript ..............................................................297 13 1000 kleine Helfer: Die PHP-Funktionen .............................................313 14 Fehlersuche und Konfiguration.............................................................347 A Listings......................................................................................................367 B Quickreferenz MySQL 4.........................................................................373 C Empfehlungen..........................................................................................387 D Index..........................................................................................................391 E An den Autor............................................................................................399
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
Vorwort
7
Vorwort Mit der Version 5 erreicht PHP ein Entwicklungsstadium, das die Webskriptsprache fest in der Welt der Webprogrammierung etabliert. Vor allem der Wegbereiter der Webprogrammierung – Perl – dürfte es in Zukunft noch schwerer haben, seine Anhänger zu begeistern. Die einfache Formel lautet: Wenn kleine und mittlere Webprojekte privat oder kommerziell und meist im Hosting beim Provider betrieben werden, ist PHP die allererste Wahl. Die gute Nachricht für den Rest der Welt – also J2EE und ASP.NET – ist, dass bei PHP5 alles so bleibt wie es war. Viele neue Funktionen, die unübersichtlichen Bibliotheken und ein chaotisches Benennungssystem belassen die Sprache PHP5 konsequent in der Ecke der Bastler und Semiprofis. Wer sich da einbildet, das ganz große Ding mit PHP5 schreiben zu können, fischt leider am falschen Ufer. Die gute Nachricht für die Fans – und solche die es werden wollen – ist die Tatsache, dass man immer noch einfach so drauflos programmieren kann. Neue OOP-Techniken stellen Entwicklern gute Ergänzungen bereit, und eine Vereinheitlichung der XML-Bibliotheken schafft Sicherheit in der Projektplanung. Es hat lange, sehr lange gedauert, bis sich die Community zu einer neuen Version durchringen konnte. Es kann als Sieg der Einfachheit gefeiert werden, dass Applikationsserver, Framework und echtes OOP dabei durchgefallen sind. Denn mit diesen Funktionen wäre PHP5 vergleichbar geworden mit anderen, inzwischen nicht minder etablierten Sprachen. Auf diesem Niveau käme dann PHP nicht wirklich gut weg. Andererseits gibt es eben einen gigantischen Markt an Homepagebastlern und kleinen, kommerziellen Anwendern, die von PHP erheblich profitieren. Denen nützen Applikationsserver, Framework und echtes OOP nicht wirklich; der Preis – Inkompatibilität, Lernkurve, Ressourcenhunger – wäre zu hoch. Die Community hat richtig entschieden – alles bleibt wie es war. PHP5 verfügt über die neue Zend Engine 2.0, den von Zend entwickelten Sprachkern. Das ist der Teil, den niemand sofort bemerkt. Die Änderungen, die den Versionssprung von 4 auf 5 rechtfertigen, fanden also vor allem im Verborgenen statt. Nicht zuletzt deshalb bietet dieses Buch gegenüber dem Vorgängertitel neben dem Neuen auch viel Bewährtes an. Jörg Krause Berlin, im März 2004
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
Inhaltsverzeichnis _____________________________________________________
9
Inhaltsverzeichnis Schnellübersicht......................................................................................5 Vorwort.....................................................................................................7 Inhaltsverzeichnis...................................................................................9 1
Vor dem Start................................................................................ 17
1.1
Wer sind Sie? .......................................................................................... 19
1.2
Hinweise zum Buch ............................................................................... 19
1.2.1
Schreibweisen im Buch............................................................................................... 20
1.2.2
Wichtige Symbole ....................................................................................................... 20
1.2.3
Was nicht aufgeführt wurde ...................................................................................... 20
1.2.4
Navigationshilfen........................................................................................................ 21
1.3
Installation .............................................................................................. 21
1.3.1
LAMP........................................................................................................................... 21
1.3.2
WAMP ......................................................................................................................... 22
1.3.3
WPMP.......................................................................................................................... 22
1.3.4
WIMP........................................................................................................................... 22
1.3.5
Andere Server.............................................................................................................. 22
1.4
Softwarequellen...................................................................................... 23
1.5
Hilfe im Web........................................................................................... 23
1.6
Website zum Buch.................................................................................. 24
1.7
Welche PHP-Version? ............................................................................ 24
2
Dynamik in der Webseite........................................................... 25
2.1
HTML ist langweilig .............................................................................. 27
2.1.1
Mysterium CGI ........................................................................................................... 27
2.1.2
Was Webserver noch können..................................................................................... 28
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
10 _____________________________________________________ Inhaltsverzeichnis 2.1.3
2.2
Hochgesteckte Erwartungen ...................................................................................... 28
Werden Sie ein guter Programmierer!..................................................29
2.2.1
Ein wenig Theorie ....................................................................................................... 29
2.2.2
Mit Paradigmen vom Problem zur Lösung .............................................................. 30
2.2.3
Programmieren mit Stil .............................................................................................. 31
2.3
PHP ist einfach........................................................................................32
2.3.1
Sofort etwas ausprobieren .......................................................................................... 32
2.3.2
Wo wird programmiert?............................................................................................. 33
2.3.3
Wo wird PHP abgearbeitet? ....................................................................................... 33
2.3.4
PHP und HTML .......................................................................................................... 34
2.4 2.4.1
Erstellen und Testen...............................................................................38 Sind Sie startklar?........................................................................................................ 38
3
Variablen und Konstanten ......................................................... 45
3.1
Variablen erzeugen und erkennen........................................................47
3.2
Datentypen..............................................................................................48
3.2.1
3.3 3.3.1
3.4
Datentypen darstellen und erzwingen ...................................................................... 49
Variablen genauer betrachtet.................................................................51 Verweise....................................................................................................................... 52
Konstanten ..............................................................................................52
3.4.1
Definition von Konstanten ......................................................................................... 53
3.4.2
Vordefinierte Konstanten ........................................................................................... 54
4
Rechnen und Verarbeiten........................................................... 55
4.1
Zeichenketten..........................................................................................57
4.1.1
Zeichenkettenfunktionen ............................................................................................ 57
4.1.2
Basiswissen für Zeichenketten ................................................................................... 58
4.1.3
Zeichenketten in der Praxis ........................................................................................ 63
4.1.4
HTML problemlos verwenden................................................................................... 68
4.2
Praktische Mathematik ..........................................................................71
4.2.1
Operatoren................................................................................................................... 71
4.2.2
Mathematische Funktionen ........................................................................................ 76
4.2.3
Funktionen beliebiger Genauigkeit............................................................................ 80
Inhaltsverzeichnis _____________________________________________________ 11
5
Komplexe Datenstrukturen: Arrays .......................................... 83
5.1
Wie Arrays funktionieren...................................................................... 85
5.1.1
Eindimensionale Arrays ............................................................................................. 85
5.1.2
Sprechende Indizes: Assoziative Arrays ................................................................... 88
5.1.3
Mehrdimensionale Arrays.......................................................................................... 90
5.1.4
Mehrdimensionale Arrays verarbeiten...................................................................... 91
5.2
Die Arrayfunktionen.............................................................................. 93
5.3
Zugriff auf Array-Elemente................................................................... 94
5.3.1
Arrays durchlaufen..................................................................................................... 95
5.3.2
Mit Arrays spielen ...................................................................................................... 95
5.3.3
Interessante Arrayeffekte ........................................................................................... 96
6
Das Steuerrad für PHP: Kontrollstrukturen ............................ 99
6.1
Übersicht ............................................................................................... 101
6.1.1
Strukturiertes Programmieren ................................................................................. 101
6.1.2
Blöcke......................................................................................................................... 103
6.2
Verzweigungen .................................................................................... 104
6.2.1
Bedingungen ............................................................................................................. 104
6.2.2
Bedingungen mit if auswerten................................................................................. 106
6.2.3
Mehrfachauswertungen mit switch......................................................................... 108
6.3
Schleifen ................................................................................................ 110
6.3.1
Standardschleifen mit while..................................................................................... 110
6.3.2
Die »Mindest-Schleife« mit do ... while................................................................... 112
6.3.3
Abzählbare Schleifen: for(;;)..................................................................................... 114
6.3.4
Felder bestellen: foreach ........................................................................................... 116
6.4
Ordnung ins Chaos: Funktionen ........................................................ 118
6.4.1
Die Welt erschaffen: Funktionsdefinition................................................................ 118
6.4.2
Kleine Welten: Variablen in Funktionen ................................................................. 119
6.5
Fehler einfangen: try@catch ................................................................ 131
6.5.1
Bei Fehler: Abbiegen ................................................................................................. 132
6.5.2
Einfache Fehlerbehandlungen.................................................................................. 133
6.5.3
Fehlerunterdrückung mit @ ..................................................................................... 133
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
12 _____________________________________________________ Inhaltsverzeichnis
7
Sammeltransporte: Objekte...................................................... 137
7.1
Einführung in die Welt der Objekte....................................................139
7.1.1
Das Konzept .............................................................................................................. 139
7.1.2
Das erste Objekt......................................................................................................... 140
7.2
Erweiterte Techniken für Objekte .......................................................143
7.2.1
Direkter Zugriff auf Klassen..................................................................................... 143
7.2.2
Konstruktoren und Destruktoren ............................................................................ 144
7.2.3
Vererbung und Schnittstellen................................................................................... 146
7.3
Spezielle Funktionen ............................................................................148
7.3.1
Methoden aufrufen ................................................................................................... 148
7.3.2
Eigenschaften von Klassen ermitteln ....................................................................... 149
7.4 7.4.1
7.5
Klassenpraxis ........................................................................................150 Herausforderung: Grafik selbstgebaut .................................................................... 150
Eingebaut: Die Fehlerklassen ..............................................................155
7.5.1
Die Klasse Exception................................................................................................. 155
7.5.2
Praktischer Einsatz der Fehlerbehandlung.............................................................. 157
8
Daten bewegen: Dateisystem und FTP................................... 161
8.1
Dateisystem...........................................................................................163
8.1.2
Zugriff auf Dateien.................................................................................................... 164
8.1.3
Mit Dateien arbeiten.................................................................................................. 179
8.2
Umgang mit Verzeichnissen ...............................................................181
8.2.1
Basisfunktionen ......................................................................................................... 181
8.2.2
Im Verzeichnissystem bewegen ............................................................................... 181
8.3
Verbindungen zu Servern....................................................................183
8.3.1
HTTP-Verbindungen ................................................................................................ 183
8.3.2
FTP-Verbindungen mit Dateifunktionen................................................................. 186
8.4
FTP-Funktionen....................................................................................187
8.4.1
Verbindung zu FTP-Servern..................................................................................... 187
8.4.2
Navigation im Verzeichnisbaum ............................................................................. 190
9
Daten aus dem Browser: Formulare und Links..................... 195
9.1
Daten aus einem Formular ermitteln..................................................197
Inhaltsverzeichnis _____________________________________________________ 13 9.1.1
Formulare in HTML erstellen .................................................................................. 197
9.1.2
Formularelemente analysieren................................................................................. 202
9.1.3
Dateiupload............................................................................................................... 207
9.2
Daten per URL weiterreichen.............................................................. 213
9.2.1
Wie werden Daten weitergereicht?.......................................................................... 213
9.2.2
Probleme mit der Datenübertragung ...................................................................... 215
9.3
Daten über den Server ermitteln......................................................... 219
9.3.1
Servervariablen ermitteln ......................................................................................... 219
9.3.2
Übersicht Servervariablen ........................................................................................ 220
10
Big Brother: Sessions und Cookies ........................................ 223
10.1 Wozu dienen Sessions?........................................................................ 225 10.2 Sessionmanagement............................................................................. 226 10.2.1
Wie Sessions funktionieren ...................................................................................... 226
10.2.2
Ausblick..................................................................................................................... 239
10.3 Cookies.................................................................................................. 241 10.3.1
Einführung in Cookies.............................................................................................. 241
10.3.2
Cookies mit PHP verarbeiten................................................................................... 244
11
Datenbanken: So werden Daten gespeichert ........................ 249
11.1 Vorbemerkungen ................................................................................. 251 11.2 Ganz universell: SQL ........................................................................... 251 11.2.1
Grundsätzliche Konzepte ......................................................................................... 251
11.2.2
Vorbereitungen ......................................................................................................... 257
11.3 Mit MySQL arbeiten............................................................................. 259 11.3.1
Datenbanken und Tabellen erzeugen ...................................................................... 259
11.3.2
Mit Datenbanken arbeiten ........................................................................................ 261
11.3.3
Weitere Tabellenfunktionen ..................................................................................... 268
11.3.4
Die MySQL-Funktionen ........................................................................................... 269
11.3.5
PHP-Funktionen für MySQL ................................................................................... 269
11.4 MySQL ganz praktisch ........................................................................ 271 11.4.1
Vorbereiten des Projekts........................................................................................... 271
11.4.2
Aufbau der Skripte ................................................................................................... 272
11.4.3
Die Skripte im Detail................................................................................................. 272
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
14 _____________________________________________________ Inhaltsverzeichnis 11.4.4
Diskussion der Idee................................................................................................... 283
11.5 SQLite kurz vorgestellt ........................................................................284 11.5.1
Der SQLite SQL-Dialekt............................................................................................ 284
11.5.2
Die SQLite-Funktionen ............................................................................................. 288
11.6 SQLite ganz praktisch ..........................................................................290 11.6.1
Das Projekt vorbereiten............................................................................................. 290
11.6.2
Der Quellcode............................................................................................................ 291
11.6.3
Diskussion ................................................................................................................. 296
12
Symbiose: PHP und JavaScript................................................ 297
12.1 Warum JavaScript?...............................................................................299 12.1.1
Prinzipielle Fragen zu JavaScript............................................................................. 299
12.1.2
JavaScript erkennen .................................................................................................. 300
12.2 Umgang mit Formularen.....................................................................302 12.2.1
Projekt: Eine Abstimmungssite ................................................................................ 302
12.3 Gutes Zusammenspiel: Der Chat........................................................306 12.3.1
Vorbereitung: Die Datenbank................................................................................... 306
12.3.2
Mehr Leistung durch JavaScript .............................................................................. 311
13
1000 kleine Helfer: Die PHP-Funktionen............................... 313
13.1 Übersicht ...............................................................................................315 13.2 Hilfsdesigner: Bildfunktionen mit GD2..............................................315 13.2.1
Bilddaten dynamisch erzeugen ................................................................................ 315
13.2.2
Bilder dynamisch erzeugen ...................................................................................... 316
13.2.3
Umgang mit Fehlern ................................................................................................. 320
13.2.4
Weitere Bildfunktionen............................................................................................. 321
13.3 Suchexperten: Reguläre Ausdrücke ...................................................323 13.3.1
Kennen Sie Perl?........................................................................................................ 323
13.3.2
Überall reguläre Ausdrücke..................................................................................... 323
13.3.3
Erstellen einfacher Muster ........................................................................................ 328
13.3.4
Vom Einfachen zum Komplexen ............................................................................. 329
13.3.5
Suchen und Ersetzen................................................................................................. 332
13.3.6
Alle Metazeichen auf einen Blick ............................................................................. 333
13.3.7
Funktionen für reguläre Ausdrücke ........................................................................ 335
Inhaltsverzeichnis _____________________________________________________ 15
13.4 Zeitwächter: Datumsfunktionen......................................................... 336 13.4.1
Probleme mit Datumswerten ................................................................................... 336
13.4.2
Datumsfunktionen .................................................................................................... 337
14
Fehlersuche und Konfiguration............................................... 347
14.1 Die Informationszentrale..................................................................... 349 14.2 Konfiguration mit »php.ini«................................................................ 350 14.3 Tipps zur Fehlersuche.......................................................................... 361 14.4 Typische Fehler .................................................................................... 361 14.4.1
Verwendung von printf und print........................................................................... 361
14.4.2
Missbrauch des Variablenersatzes ........................................................................... 362
14.4.3
Umgang mit Variablen ............................................................................................. 362
14.4.4
Paradigmen und deren Gültigkeit ........................................................................... 363
14.4.5
Missverstandene Kontrollstrukturen....................................................................... 363
14.4.6
Fehler beim Umgang mit Datenbanken .................................................................. 363
A
Listings ........................................................................................ 367
B
Quickreferenz MySQL 4 ........................................................... 373
B.1
Datentypen ........................................................................................... 373
B.2
Mathematische Funktionen................................................................. 374
B.3
Logische Funktionen............................................................................ 375
B.4
Funktionen für spaltenweise Berechnungen ..................................... 376
B.5
Funktionen für Systeminformationen ................................................ 376
B.6
Zeichenkettenfunktionen..................................................................... 377
B.7
Zahlenformatierungen......................................................................... 378
B.8
Datums- und Zeitfunktionen .............................................................. 378
B.9
Datumsformatierungen ....................................................................... 380
B.10 MySQL-Anweisungen ......................................................................... 381
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
16 _____________________________________________________ Inhaltsverzeichnis
C
Empfehlungen............................................................................ 387
C.1
Themen..................................................................................................387
C.2
Fachbücher ............................................................................................387
C.3
Programmiersysteme ...........................................................................388
D
Index ............................................................................................ 391
E
An den Autor.............................................................................. 399
1.1 Wer sind Sie?______________________________________________________ 17
1 Vor dem Start Bevor Sie anfangen, die ersten Schritte als PHPEntwickler zu gehen, sollten Sie dieses Kapitel lesen. Es wird Ihnen helfen, das Buch sehr effektiv zu verwenden.
1
Vor dem Start
1.1 Wer sind Sie?______________________________________________________ 19
1.1
Wer sind Sie?
Wenn Sie dieses Buch gerade durchblättern – im Buchladen oder bereits Ein Wort zur zu Hause vor dem Computer – werden Sie sich vielleicht fragen: »Ist das Zielgruppe das richtige Buch für mich?« Ein paar Vermutungen, wer Sie sein könnten, habe ich als Grundlage beim Schreiben angestellt: • Sie sind Webentwickler und haben bisher Webseiten in HTML, JavaScript und Flash erstellt. • Sie haben eine kleine Webagentur oder arbeiten bei einer solchen. • Sie machen eine Umschulung zum Webprogrammierer oder planen diese. • Sie haben sich schon immer für das Internet interessiert, sich bisher aber nie getraut, selbst etwas zu programmieren. Vielleicht suchen Sie nur einfach nach Wegen, Ihre Webseiten cooler und interessanter zu machen. Sie haben gehört, das PHP eine spannende, umfangreiche und leicht zu erlernende Sprache ist. Außerdem können Sie bereits mit Windows umgehen und wissen, wie man Dateien anlegt, bearbeitet und speichert. PHP ist eine Skriptsprache, die für die Erstellung dynamischer Webseiten eingesetzt wird. Dieses Buch behandelt nur diesen Anwendungsfall. Darin eingeschlossen ist der Zugriff auf Datenbanken, Dateien und auf die Eingaben, die Benutzer über den Browser absenden. Das Buch zwingt Ihnen keinen speziellen Lernstil auf und verzichtet Für jeden Lernstil deshalb auf eine straffe Kapitelfolge, schulmeisterliche Fragen am geeignet Kapitelende und ein Zeitregime. Lesen Sie es von Anfang bis Ende oder überspringen Sie Abschnitte, wenn der Stoff Ihnen bekannt oder uninteressant erscheint. Die einzige sinnvolle Lernmethode lautet »üben, üben, üben«.
Was Sie mitbringen sollten Dieses Buch setzt keine umfassenden Programmierkenntnisse voraus. Allerdings sollten Sie prinzipiell mit der Erstellung von statischen Webseiten – also mit HTML – vertraut sein. Ebenso wird vorausgesetzt, dass das eingesetzte Betriebssystem beherrscht wird. Wenn Sie schon erfolgreich Seiten auf einen Webserver beim Provider überspielt und zum Laufen gebracht haben, sind alle wichtigen Voraussetzungen erfüllt.
1.2
Hinweise zum Buch
In diesem Abschnitt finden Sie allgemeine Hinweise zum Buch und zur Schreibweise.
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
20
______________________________________________________ 1 Vor dem Start
1.2.1 Schreibweise von reservierten Namen
Schreibweisen im Buch
Dieses Buch stützt sich auf die übliche Schreibweise bei der Syntaxangabe. Da PHP überwiegend aus Funktionen besteht, wird die Funktionsschreibweise primär zu finden sein. Der folgende Ausdruck beschreibt das Syntaxdiagramm einer Funktion:
int function(string param1, 0|1 [, int param2]) Diese Schreibweise tritt auch im Fließtext auf und ist folgendermaßen zu interpretieren. Der Funktionsname ist fett hervorgehoben. Wenn die Klammern zwingend erforderlich sind, gehören sie zum Funktionskopf und sind ebenso hervorgehoben. Vor der Funktion steht der Datentyp (int), den die Funktion zurückgibt. Im Beispiel gibt die Funktion also ganzzahlige Werte zurück. Parameter sind alternativ aber nicht optional, wenn sie durch | getrennt sind. Parameter in []-Klammern sind optional. Der Aufruf der Funktion könnte im Skript so aussehen:
$intvar = function("test", 1, 45); Soweit es sich vermeiden ließ, wurde auf reine Syntaxdiagramme verzichtet. Dafür gibt es eine umfassende Referenz. Selbst gewählte Namen
Selbst gewählte Namen, beispielsweise für Variablen, werden kursiv gesetzt: $time, myfunction.
Skripte und Dateien
An einige Stellen wird auf Skripte oder Dateien verwiesen. Diese stehen dann in Kapitälchen: PHP.INI.
1.2.2
Wichtige Symbole
Im Buch wird an vielen Stellen mit Symbolen gearbeitet, um die Orientierung zu erleichtern. Erklärungen mit diesem Symbol beziehen sich auf das jeweils davor stehende Listing. Alle Skripte werden ausführlich diskutiert, damit Sie die Funktion sofort nachvollziehen können. Dieses Symbol weist auf Warnungen und Hinweise hin, die im Zusammenhang mit dem betrachteten Stoff stehen. Oft sind auch typische Fehlermeldungen damit gekennzeichnet.
Der Infokasten Im Infokasten finden Sie Erklärungen zu wichtigen Begriffen, Hintergrundinformationen und Grundlagen.
1.2.3
Was nicht aufgeführt wurde
Dieses Buch soll schnell und kompakt in die Welt der Programmierung von Webseiten einführen. Breiten Raum nimmt deshalb die Erläuterung grundlegender Methoden und Techniken ein. PHP5 besticht den professionellen Programmierer dagegen durch eine Vielfalt von Funktionen, die oft elegante Lösungen ermöglichen. Darauf wird nicht in aller Breite
1.3 Installation ________________________________________________________ 21 eingegangen. Einige Kapitel enthalten jedoch Übersichten der verfügbaren Funktionen. In der Referenz zu diesem Buch können Sie sich über die genaue Verwendung aller Funktionen informieren.
1.2.4
Navigationshilfen
Im Buch finden Sie zwei Navigationshilfen für ein schnelles Auffinden So arbeiten Sie der passenden Lösung Ihres Problems. Beachten Sie allerdings, dass mit dem Anhang dieses kleine Buch keinen Anspruch auf Vollständigkeit erhebt oder als Lösungsbuch konzipiert wurde, sondern in die grundlegenden Programmiertechniken einführen soll. • Anhang A Listings (ab Seite 367) Hier finden Sie die Listings auf einen Blick. Alle Skripte können Sie sofort zur Ausführung bringen. Wer nichts abschreiben will, findet auf der Webseite zum Buch alle Skripte zum herunterladen und zum ausprobieren. • Anhang D Index (ab Seite 391) Der Index umfasst neben den normalen Stichworten auch alle Vorkommen von PHP-Funktionen. Die relevante Stelle ist, wenn vorhanden, fett gekennzeichnet. Alle anderen Vorkommen deuten meist auf die Verwendung in anderen Skripten hin. Außerdem wird intensiv mit Verweisen gearbeitet, die durch ein Symbol gekennzeichnet sind. Folgen Sie den Verweisen, um schneller an alle relevanten Informationen zu gelangen. Ein chronologisches Durcharbeiten ist dagegen nicht immer die beste Wahl.
1.3
Verweis...
Installation
Vor den ersten Schritten mit PHP steht – wenn Sie nicht online arbeiten möchten oder wollen, die Installation. Da sich die Installation je nach Version etwas unterscheidet und darüber hinaus viele Varianten beim Betriebssystem existieren, würde eine Installationsbeschreibung, die alle Ansprüchen gerecht wird, das halbe Buch in Anspruch nehmen. Anstatt vieler Seiten finden Sie hier die besten deutschen Tutorials im Web, die die Installation genau beschreiben. Starten Sie dort, um Ihr Entwicklungssystem aufzubauen. Die Tutorials werden gelegentlich aktualisiert, sodass Sie mit der neuesten PHP-Version funktionieren. Dies kann ein Buch, dass über einen längeren Zeitraum angeboten wird, nicht leisten.
1.3.1
LAMP
LAMP steht für »Linux Apache MySQL PHP«. Jörg Baach hat auf seiner Für Suse-Linux Site eine Anleitung, die sich auf die SUSE-Distribution stützt:
www.baach.de/lamp-tutorial.html
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
22
______________________________________________________ 1 Vor dem Start
Für Debian-Linux
Inspiriert von diesem Tutorial gibt es eine modifizierte Ausgabe, die auf die Debian-Distribution ausgelegt ist:
www.linux-root.de/elug/lamp.html
1.3.2
WAMP
WAMP steht für »Windows Apache MySQL PHP«. Hier wird als Betriebssystem Windows eingesetzt – der Rest unterscheidet sich nicht von der Linuxvariante. Einfacher ist die Installation vor allem deshalb, weil meist fertige Binärdateien eingesetzt werden und die Kompilation wegfällt. Ein gutes Tutorial von Ron Grahnert finden Sie hier:
www.php-homepage.de/artikel/?nr=8
1.3.3
WPMP
Die Abkürzung WPMP steht für »Windows PWS MySQL PHP«. Eine Anleitung für den PWS finden Sie unter folgender Adresse:
www.webknecht.de/php/index.html Der PWS wird mit Windows 95/98 und der NT 4.0 Workstation geliefert. Windows 2000, XP Professional und Windows Server 2003 verwenden dagegen den IIS, siehe nächster Abschnitt.
1.3.4
WIMP
WIMP bezeichnet »Windows IIS MySQL PHP« und bezieht sich auf den IIS 4, 5 oder 6, also auf die Webserver von Windows Me, Windows 2000 Workstation, XP Professional und Windows 2000/2003 Server sowie Windows NT 4.0 Server mit Option Pack. Eine deutsche Anleitung finden Sie unter:
www.php.comzept.de/index.php4?TEMPLATE=support&tutorial=wimp
1.3.5
Andere Server
Generell ist auch das Manual zu PHP eine gute Anlaufstelle. Hier finden Sie neben den bereits gezeigten Webservern weitere Hinweise. Leider sind noch nicht alle Teile übersetzt. Den umfassenderen englischen Text finden Sie an folgender Stelle:
www.php.net/manual/en/installation.php Die (teilweise) deutsche Version finden Sie hier:
http://www.php.net/manual/de/installation.php
1.4 Softwarequellen ____________________________________________________ 23 Windows: IIS/PWS/OmniHTTPd Ältere Windows-Webserver und der OmniHTTPd werden auf der folgenden Seite beschrieben:
http://www.php.net/manual/de/install-windows95-nt.php Unix: Andere Unixe Neben Linux wird PHP oft auch auf Solaris oder anderen Unixen einge- Solaris setzt. Die folgende Adresse hilft Ihnen dabei, PHP korrekt zu installieren: BSD
http://www.php.net/manual/de/install-unix.php
1.4
Softwarequellen
Nachfolgend finden Sie eine Liste mit Adressen, unter denen Sie sich die neueste Software beschaffen können. • PHP-Quellen und Binärversionen für Windows
http://www.php.net • Apache Webserver
http://www.apache.org • MySQL
http://www.mysql.com PHP5 verfügt über die integrierte Datenbank SQLite, die für einfachste Projekte ausreichend ist. Für die ersten Schritte mit Datenbanken ist deshalb MySQL nicht mehr zwingend erforderlich.
1.5
Hilfe im Web
Hilfe im Web versprechen viele Webseiten. Die besten englischen und Englische und deutschen Seiten finden Sie hier: Deutsche • Die internationale PHP-Homepage (engl.)
www.php.net • Die Zend-Homepage (engl.)
www.zend.com • Das deutsche PHP-Center (dt.)
www.php-center.de • PHP-Homepage (dt.)
www.php-homepage.de
Websites
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
24
______________________________________________________ 1 Vor dem Start • Dynamic Webpages (dt.)
www.dynamic-webpages.de • PHP Builder (engl.)
www.phpbuilder.com • Das PHP-Archiv (dt.)
www.phparchiv.de
1.6 Die Website nur für Leser
Website zum Buch
Speziell für die Leser dieses Buches gibt es eine Website unter der folgenden Adresse (klicken Sie auf die Beschriftung neben dem Buchcover):
http://www.php.comzept.de Dort finden Sie unter anderem: • Forum zur Kontaktaufnahme mit anderen PHP-Anfängern • Alle Skripte zum Buch – als ZIP-Archiv zum Herunterladen • Aktualisierungen zu den im Buch verwendeten Skripten • Hinweise auf Neuerscheinungen, Projekte usw., die für PHPEntwickler interessant sind • Kontaktmöglichkeit zum Autor für Kritik, Hinweise usw. Was ich leider nicht leisten kann Für die praktische Programmierung gibt es viele Foren, Newsgroups und Mailinglisten und sehr viel weiterführende Literatur. Bitte haben Sie Verständnis dafür, dass ich Anfragen nach technischer Hilfe im Allgemeinen nicht beantworte. Anregungen werden jedoch auf jeden Fall gelesen und gehen in Aktualisierungen auf der Website und künftige Auflagen des Buches ein. Schreiben Sie per E-Mail an folgende Adresse:
[email protected]
1.7
Welche PHP-Version?
Dieses Buch behandelt PHP in der Version 5.0. Alle Skripte wurden mit dieser Version und den Standardeinstellungen getestet. Es mag sein, dass einige Skripte mit älteren Versionen funktionieren, diese sind jedoch nicht Gegenstand des Buches und wurden nicht getestet. Dieses Buch behandelt ausschließlich PHP5. Es wurde größtenteils mit der dritten Beta-Version geschrieben und mit dem ersten Release Candidate (RC1) überarbeitet. Es ist möglich, dass die finale Version oder künftige Ausgaben von PHP5 in Details ein davon abweichendes Verhalten aufweisen.
1.7 Welche PHP-Version? ______________________________________________ 25
2 Dynamik in der Webseite HTML ist die Sprache des Internet. Jede Website besteht aus mehr oder weniger gut geschriebenem HTML, kombiniert mit Bildern, Flash-Animationen und im Browser ablaufenden Skripten. All das zusammen sorgt zwar für bunte Seiten oder schrille Effekte, nicht jedoch für Interaktivität. Eine Reaktion des Servers auf Benutzereingaben wird nur erzielt, wenn die empfangenen Daten verarbeitet werden. Eine wichtige Sprache, mit der dies erfolgen kann, ist PHP – PHP Hypertext Preprocessor.
2
Dynamik in der Webseite
2.1 HTML ist langweilig_________________________________________________ 27
2.1
HTML ist langweilig
Bevor Sie beginnen, die ersten Skripte zu schreiben, denken Sie einen Wie Webserver Moment darüber nach, wie ein Webserver arbeitet. Wenn Sie den Brow- arbeiten ser öffnen, und eine Adresse eingeben, zerlegt der Browser diese zuerst in zwei Teile. Betrachten Sie folgende Adresse:
http://www.php.comzept.de/php-lernen/index.php Diese Angabe besteht zum einen aus dem Protokoll: http. Dies steht für Hypertext Transfer Protocol und definiert die »Sprache«, in der Webserver und Browser miteinander reden. Danach folgt die Adresse des Servers, bestehend aus seinem eigenen Namen »www.php« und der Domäne »comzept.de«. Dieser Name wird zuerst in eine IP-Nummer, die weltweit eindeutig ist, aufgelöst. Das passiert aber transparent im Hintergrund und wird normalerweise vom Benutzer nicht wahrgenommen. Der dritte Teil enthält nun Pfad- und Dateiangaben, hier »phplernen/index.php«. Diesen Teil sendet der Browser mit dem entsprechenden HTTP-Kommando GET an den Server. Der reagiert darauf entweder mit der Auslieferung der angeforderten Datei oder einer Fehlerinformation, wenn die Datei nicht gefunden wurde. So war das Web ursprünglich konzipiert worden. HTML-Seiten sollten nur durch Hyperlinks verbunden werden. Das genügte, um Informationen strukturiert darzustellen und Designern eine gewisse Freiheit bei der Darstellung zu erlauben.
2.1.1
Mysterium CGI
Das Ziel einer solchen Anforderung kann auch ein Skript auf dem Web- Was ist CGI? server sein. Der Webserver ruft dann das mit der Dateierweiterung verbundene Programm auf. Dessen Ausgabe wiederum wird an den Browser gesendet. Praktisch können Sie also mit einem Skript alles kontrollieren was zum Browser geht. Die Schnittstelle zwischen Webserver und solchen Programmen zur Ausführung von Skripten ist sehr alt, sehr gut dokumentiert, sehr bekannt und sehr langsam. Ihr Name ist CGI – Common Gateway Interface. CGI selbst macht nichts. Die erste Skriptsprache, die sich CGI bediente, war Perl. Perl ist sehr weit verbreitet und kann virtuos mit Zeichen umgehen. Leider ist Perl auch sehr schwer zu erlernen und für Anfänger nicht zu empfehlen. Mit CGI ist es möglich, die Anforderungen eines Browsers auf ein Skript CGI ermöglicht umzuleiten. Solche Anforderungen können neben der Adresse einer Interaktivität Datei auch die Inhalte eines Formulars sein. Damit besteht nun die Möglichkeit, den Inhalt eines Formulars, das der Benutzer ausgefüllt hat, zu verarbeiten und darauf gezielt zu reagieren. Diese Reaktion kann sehr vielfältig ausfallen. Sie können das CGI-Skript veranlassen, die Daten zu überprüfen und dem Benutzer eine Fehlermeldung zurückzusenden, wenn er etwas vergessen hat. Oder Sie legen die Daten in einer Textdatei
V V V V V V 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 A A B B C C D D E E
28
____________________________________________ 2 Dynamik in der Webseite ab, die Sie sich später anschauen. Wenn Sie schon etwas professioneller programmieren, werden Sie dagegen eine Datenbank verwenden.
Vor- und Nachteile von CGI
Über CGI wurden viele Dinge geschrieben. Ein wichtiger Kritikpunkt ist die Geschwindigkeit. CGI startet mit jeder Anforderung einen so genannten Prozess auf dem Server, also eine Instanz des Skript-Interpreters. Wenn gleichzeitig 50 Benutzer zugreifen, werden 50 Instanzen gestartet, jede mit einigen Megabyte Speicherverbrauch. Ganz realistisch muss man heute sagen, hat die Entwicklung der Hardwareressourcen diesen Nachteil fast beseitigt. 50 Megabyte Speicher sind sehr wenig und 50 gleichzeitige Besucher sind verdammt viel. PHP kann man deshalb gut – sowohl auf der Entwicklungsmaschine auch auf einem Server im Netzwerk, als CGI-Applikation laufen lassen. Damit ist auch klar, das CGI nicht gleich Perl ist, in diesem Buch ist CGI gleich PHP.
Wie es arbeitet
Ein anderer Nachteil ist die Arbeitsweise des Protokolls HTTP. Jede Anforderung des Browsers ist ein für sich abgeschlossener Prozess. Da CGI den Interpreter jedes mal startet und danach wieder aus dem Speicher entfernt, gehen auch alle Einstellungen verloren. Das »Wiedererkennen« des Benutzers auf der nächsten Seite stellt deshalb ein Problem dar. Dank PHP stehen dafür aber spezielle Funktionen zur Verfügung – die Sessionfunktionen. Darauf wird selbstverständlich detailliert eingegangen. Also ist auch dieser Nachteil nicht wirklich schlimm.
2.1.2 Schnittstellen der Webserver
Was Webserver noch können
Webserver bieten eigene Schnittstellen. Diese sind – im Gegensatz zu CGI – von Server zu Server verschieden. Glücklicherweise gibt es heute nicht mehr sehr viele konkurrierende Webserver. In der PHP-Welt, wo Produktionsserver überwiegend unter Linux laufen und für Entwicklungsumgebungen Windows verwendet wird, dominiert der Apache Webserver, gefolgt von dem Internet Information Server von Microsoft. Beide eignen sich für den Betrieb von PHP und für beide gibt es neben der CGIVersion auch eine spezielle Variante, die auf die jeweiligen proprietären Schnittstellen zugreift. Damit beschäftigt sich dieses Buch aber nicht, weil es nicht beim Programmieren hilft und meist keinen Unterschied macht, ob das Skript mit einer Webserverschnittstelle oder CGI läuft. Die zusätzlichen Möglichkeiten der Webserverschnittstellen mögen Profis zu schätzen wissen, die eigene Server betreiben und ihre Applikationen darauf optimieren. Wenn Sie mit Ihren Skripten zu irgendeinem Provider gehen, werden Sie jedoch oft auf Server mit CGI treffen und solche optimierten Skripten funktionieren dann nicht. Beschäftigen Sie sich damit erst, wenn Sie PHP richtig gut können und ein eigener Server zur Verfügung steht.
2.1.3 Was PHP alles kann
Hochgesteckte Erwartungen
PHP löst viele Probleme, die CGI-Programmierer mit Perl in den vergangenen Jahren hatten und immer noch haben. Viele Dinge sind »einfach da«. Es wird dennoch immer wieder in speziellen Kästen auf diese Hin-
2.2 Werden Sie ein guter Programmierer!_________________________________ 29 tergründe hingewiesen, weil Sie nur so lernen, was dahinter steckt. Wenn etwas nicht wie erwartet funktioniert oder Sie komplexere Probleme angehen, hilft dieses Wissen.
2.2
Werden Sie ein guter Programmierer!
Die Programmierung in PHP ist sehr einfach. Das verleitet zu einem wirren und unsauberen Stil bei der Notation der Befehle. Wenn Sie gute Software schreiben möchten, müssen Sie sich auch ein wenig mit dem Stil auseinandersetzen. Auch darauf wird in diesem Buch eingegangen.
2.2.1
Ein wenig Theorie
Manche Leute studieren ein paar Jahre Informatik, um Programmierer zu werden. Andere tun das nicht und werden auch Programmierer. Vielleicht fragen Sie sich auch: »Warum also Informatik lernen, wenn es auch ohne geht?« In der Praxis hat sich herausgestellt, dass viele Anfänger an bestimmten Problemen scheitern oder ungewöhnlich schlechte Lösungen finden, weil bestimmte Grundlagen fehlen. Dieses Buch kann und soll kein Studium der Informatik ersetzen. Es wäre naiv zu glauben, dass man nur anhand einer modellhaft gezeigten Programmiersprache wirklich programmieren lernen kann. In diesem Abschnitt werden dennoch einige Grundlagen gezeigt. Wenn Sie Quereinsteiger sind, opfern Sie ein paar Minuten, um den nachfolgenden Text zu lesen. Er hilft Ihnen, sich auch bei kleinen Projekten nicht völlig zu blamieren. Syntax und Semantik Im Zusammenhang mit der Beschreibung von Programmiersprachen ist immer von den Begriffen Syntax und manchmal auch Semantik die Rede. Die Syntax beschreibt die äußere Gestaltung des Vokabulars der Sprache. Syntax Dazu gehört der Aufbau der Befehle, Vorschriften über den Aufbau des Programms und auch die Verwendung von Parametern. Die Semantik klärt die Bedeutung der Anweisung. Programmierer und Semantik auch Computer erfahren, was mit dem Code zu tun ist, wenn er ausgeführt wird. Compiler und Interpreter Bei der Konstruktion von Programmen, die Software ausführen, haben sich zwei grundlegende Konzepte herausgebildet. Interpreter lesen ein Programm zeilenweise, analysieren die Zeichen und Interpreter übersetzen sie dann in die Maschinensprache des Computers. Dieser führt den Code dann aus. Compiler lesen das gesamte Programm und übersetzen es in Maschinen- Compiler code, den der Prozessor ausführen kann. Erst wenn dieser Prozess abgeschlossen ist, wird der fertige Code als ausführbare Datei abgelegt und kann nun beliebig oft gestartet werden.
V V V V V V 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 A A B B C C D D E E
30
____________________________________________ 2 Dynamik in der Webseite
PHP ist ein Interpreter
Interpreter sind einfacher zu bedienen und zu konstruieren, dafür jedoch langsamer, weil der Code gegebenenfalls mehrfach übersetzt wird. Compiler sind komplexer und aufwändiger, der erzeugte Code meist schneller. PHP ist als Interpreter implementiert.
2.2.2
Mit Paradigmen vom Problem zur Lösung
Wenn Sie eine bestimmte Aufgabenstellung mit Hilfe eines Programms lösen müssen, sollten Sie einen systematischen Weg kennen, der dies effektiv ermöglicht. Sich einfach an den Editor zu setzen und drauflos hacken, führt nur selten zum Erfolg. Auch wenn das Programm letztendlich funktioniert, ist die Qualität doch fraglich. Spätere Änderungen oder Erweiterungen werden möglicherweise erschwert oder ganz unmöglich. Programmierparadigmen Imperative Programmierung
Die Programmierung unterliegt einem bestimmten Paradigma, das von der gewählten Sprache und den dahinter liegenden Konzepten abhängt. PHP wird nach dem Prinzip der imperativen Programmierung verarbeitet (vom lat. »imperare«, befehlen). Programme bestehen also aus einer Folge von Befehlen, die bestimmte Aktionen auslösen. Diese Art von Sprachen basiert wesentlich auf dem Konzept der Variablen, bei denen Daten einem Speicherplatz zugeordnet werden, der unter einem gewählten Namen verfügbar ist. Die Programmiersprache kümmert sich dabei um den benötigten Platz für die Daten und die Verwaltung des Speichers.
Applikative und prädikative Programmierung
Nur der Ordnung halber sei an dieser Stelle auf zwei andere Konzepte verwiesen. Applikative Programmiersprachen sind so organisiert, dass das Programm durch die Anwendung von Funktionen besteht. Typischer Vertreter ist LISP. Prädikative Programmiersprachen verlangen die Formulierung von Beweisen (Prädikaten) als Handlungsanleitung für den Computer. Wichtigster Vertreter ist PROLOG.
Objektorientierte Programmierung
In den letzten Jahren hat sich die Programmierung mit Objekten weitreichend durchgesetzt. Fast alle Programmiersprachen bieten eine Unterstützung für dafür, auch PHP. Indes ist PHP keine objektorientierte Sprache, weil ihr grundlegende Eigenschaften dazu fehlen. Echte objektorientierte Sprachen betrachten alle Elemente – auch Variablen – als Objekte. Diese zeichnen sich durch das Vorhandensein von Eigenschaften und Methoden aus. Bekannte Vertreter sind Java und C# , in der Skriptwelt ist die konsequenteste Umsetzung Ruby.
Mischformen
Viele Sprachen kann man nicht sicher einem bestimmten Paradigma zuordnen. So ist C++ sicher eine objektorientierte Programmiersprache. Die Ableitung von der imperativen Programmiersprache C führte jedoch dazu, dass der Programmierer beide Konzepte verwenden und auch imperativ entwickeln kann.
2.2 Werden Sie ein guter Programmierer!_________________________________ 31
2.2.3
Programmieren mit Stil
Sicher hat jeder Programmierer seinen Stil und kennt viele mögliche Auch Programme Varianten für eine saubere Programmierung. Anfänger sollten sich je- haben Stil doch nicht von fremden stilistischen Formen leiten lassen, ohne den Sinn zu erkennen, der hinter der einen oder anderen Schreibweise steckt. Die besonderen Anforderungen des Webs sind auch nicht jedem Profi völlig vertraut. Die folgenden Tipps zeigen, worauf es ankommt. Eine auch optisch ansprechende Codierung wird erreicht, wenn Sie: • Code-Konventionen einhalten und • Formatierung und Strukturierung beachten.
Das doppelköpfige Wesen einer dynamischen Webseite Dynamische Webseiten bestehen aus zwei grundlegenden Teilen: Code und Design. Das Design einer Webseite wird mit HTML, Cascading Style Sheets und Bildern erstellt. Der Code dagegen wird mit PHP erstellt. Die konsequente Trennung erleichtert die Programmierung und Wartung.
Trennen Sie Code vom Design Die Trennung hilft, leicht beherrschbare Programmteile zu erhalten. Die Wiederverwendbarkeit des Codes wird gesteigert. Sie können mit Gestaltungswerkzeugen arbeiten, die eingeschlossene Codes nicht verstehen. In großen Teams können Sie das Design von Designern erledigen lassen und die reine Programmierarbeit Softwareentwicklern übergeben. Zur Wiederverwendbarkeit von Design und Code Wenn Sie etwas ändern möchten, müssen Sie es nur an einer Stelle tun. Konsistente Gestaltungsmerkmale und Bedienerführung erleichtern den Nutzern die Navigation. Behandeln Sie deshalb Design-Elemente und Code als Komponenten, die Sie immer wieder verwenden. Verwenden Sie keine komplexen URLs URLs mit vielen Parametern zeigen Hackern die innere Struktur Ihrer Applikation und legen Angriffspunkte offen. Nutzer werden vielleicht auch Ihre Seite – und damit den URL – als Lesezeichen ablegen. Wenn Sie die innere Struktur ändern, verlieren Sie Leser, die über die Lesezeichenverwaltung des Browsers auf Ihre Site zugreifen. Unterstützen Sie Proxies und Caches Nicht jeder Nutzer hat schnelle Festverbindungen. Wenn der Cache des Browsers unterstützt wird, verkürzen Sie aktiv die Ladezeiten. Nutzen Sie dynamische Seiten nur dort, wo es sinnvoll ist.
V V V V V V 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 A A B B C C D D E E
32
____________________________________________ 2 Dynamik in der Webseite
Ein paar wichtige Begriffe »Proxies« sind Computer, die innerhalb eines Netzwerks alle Anfragen aus dem Netzwerk abfangen und selbst an das äußere Netzwerk weiterleiten. Ankommende Daten werden vom Proxy empfangen und an das innere Netzwerk weitergeleitet. Dabei können vielfältige Speicher- und Filtermaßnahmen definiert werden, u.a. auch Firewall-Funktionen. Als »Cache« wird ein kleiner, aber sehr schneller Zwischenspeicher bezeichnet. Häufiger benötigte Daten werden vom Cache schneller geliefert als es der Standardspeicher des Systems ermöglicht.
2.3
PHP ist einfach
PHP ist eine Skriptsprache. Im Unterschied zu einer als Compiler implementierten Programmiersprache müssen die Codes nicht übersetzt werden. Sie schreiben Ihr Programm einfach auf, in einem normalen Editor, und führen es dann aus. Dies geschieht durch Aufruf des Programms im Browser. PHP selbst – konkret die ausführbaren Dateien – arbeitet mehr im Hintergrund. Eigentlich sollten Sie nie in die Verlegenheit kommen, am Prompt oder in einem Fenster außerhalb des Browsers PHP aufzurufen.
2.3.1 Skripte lokal ausführen
Sofort etwas ausprobieren
Wenn Sie gleich loslegen möchten, aber keine Lust haben die Skripte abzuschreiben, gehen Sie folgendermaßen vor. Sie installieren sich lokal PHP und laden die fertigen Skripte von der Website. Die ZIP-Datei mit allen Skripten können Sie unter dieser Adresse laden:
http://www.php.comzept.de/lernen/skripte5.zip Dies kostet weniger Online-Gebühren als bei der Ausführung auf einer Website. In Abschnitt 1.3 Installation ab Seite 21 finden Sie Adressen für Installationsanleitungen für alle wichtigen Betriebssysteme und Webserver. Diese Anleitungen sind aktueller und umfangreicher, als es die Darstellung in einem Buch erlauben würde. Spielt Windows eine Rolle? Windows versus Linux
Die meisten Webserver im Internet nutzen Linux und den Webserver Apache. Die meisten Programmieranfänger nutzen jedoch WindowsComputer, weil Sie dort mit Office-Paketen, Grafikprogrammen und Editoren vertraut sind. PHP läuft unter Linux und Windows gleichermaßen. Sie können also Ihre vertraute Umgebung unter Windows weiter verwenden und die fertigen Applikationen dann auf einem leistungsfähigen Unix-Server einem größeren Publikum vorstellen. Insofern spielt Windows schon eine Rolle. In diesem Buch wird auf Betriebssysteme
2.3 PHP ist einfach ____________________________________________________ 33 nicht weiter eingegangen, alle Skripte laufen unverändert auf allen Plattformen.
2.3.2
Wo wird programmiert?
PHP ist eine Skriptsprache, deren Elemente direkt in HTML-Seiten ein- Dateierweiterung gebaut werden. Durch Änderung der Dateierweiterung .PHP oder .PHP5 der HTML-Seite wird daraus eine PHP-Skriptdatei. Um PHP-Skripte ablaufen lassen zu können, muss ein entsprechend eingerichteter Server vorhanden sein. Schreiben können Sie PHP mit allen gängigen Editoren. Auch wenn Sie Editor an speziellen Features wie Syntaxhervorhebung oder automatische Vervollständigung interessiert sind, sieht das Angebot bereits recht gut aus. Empfehlenswert sind, wenn Sie ein paar Euro investieren möchten, phpED von Nusphere, Zend Studio und Maguma. Sie können PHP nicht nur über den Webserver ausführen. PHP ist jedoch PHP ausführen speziell für die Programmierung von Webseiten entworfen worden, andere Varianten werden deshalb hier nicht betrachtet. Beachten Sie, dass der Webserver nicht mit einem lokalen Pfad angesprochen werden kann. Sie müssen eine URL eingeben. Den lokalen Rechner erreichen Sie normalerweise als »localhost« oder über die IP-Nummer »127.0.0.1«. Dies sind reservierte Bezeichnungen, die anderswo keine Verwendung finden.
2.3.3
Wo wird PHP abgearbeitet?
PHP läuft auf dem Webserver, was am Anfang verwirrend ist, wenn der Webserver zugleich die Entwicklungsumgebung ist. Lesen Sie hier etwas über den Unterschied zwischen client- und serverseitiger Programmierung. PHP läuft nicht im Browser ab Schwierigkeiten bereitet am Anfang erfahrungsgemäß das Verständnis darüber, wo und wann der Code abläuft. PHP wird auf dem Server verarbeitet. Was immer der Benutzer im Browser anrichtet, Sie werden darauf erst reagieren können, wenn die Daten auf dem Server eintreffen. Dazu muss der Benutzer einen Hyperlink anklicken oder ein Formular absenden. Alle anderen Varianten nutzen clientseitige Techniken wie beispielsweise JavaScript, um diese Aktionen zu simulieren. Clientseitiges Scripting wird mit JavaScript oder – wenn Sie Flash-Fan Clientseitiges sind – mit ActionScript ausgeführt. Das funktioniert folgendermaßen: Scripting • Der Benutzer fordert eine Seite beim Webserver an • Der Webserver sendet diese Seite an den Browser • Der Browser erkennt im Code der Seite clientseitige Skripte und führt diese aus
V V V V V V 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 A A B B C C D D E E
34
____________________________________________ 2 Dynamik in der Webseite • Einige Befehle werden nicht sofort ausgeführt, sondern nur wenn bestimmte Ereignisse eintreten, beispielsweise das Anklicken einer Schaltfläche
Serverseitiges Scripting
Beim serverseitigen Scripting gibt es ein paar Unterschiede: • Der Server führt Skripte aus, bevor sie zum Browser gesendet werden • Clientseitiger Code kann im Browser eingesehen werden, serverseitiger dagegen nicht – ihre Skripte bleiben dem Benutzer garantiert verborgen • Clientseitiger Code muss vom Browser unterstützt werden, serverseitiger dagegen nur vom Server. Beim Browser kommt nur einfacher HTML-Code an. • Jede Seite wird neu zusammengestellt und an den Browser gesendet, auf dem Server bleibt keine Kopie zurück. Oft können Sie das eine oder andere Problem sowohl mit client- als auch serverseitigem Scripting lösen. Manchmal ist auch eine Kombination aus beidem sinnvoll oder ermöglicht raffinierte Lösungen für knifflige Probleme. Bedenken Sie, dass Sie bei jeder Aktion, die PHP ausführen soll, die Daten erst zum Server senden und dort bearbeiten müssen.
2.3.4
PHP und HTML
PHP wird im Gegensatz zu Perl nicht als eigenständiges CGI-Programm ausgeführt, sondern direkt im HTML-Code untergebracht. Dazu muss natürlich eine Möglichkeit geschaffen werden, wie der PHP-Prozessor die für ihn bestimmten Teile erkennt und interpretiert. Dateierweiterung So sehen die Dateien aus
Der erste Schritt besteht in der Benennung einer HTML-Seite mit einer anderen Dateierweiterung. Sie kennen bisher Erweiterungen wie *.HTM oder *.HTML. Jede HTML-Datei können Sie einfach mit der Erweiterung *.PHP5 (nur PHP5) oder *.PHP (empfohlen) versehen. Jetzt wird bei einem Aufruf dieser Datei der Webserver die Seite nicht sofort zum Browser senden, sondern zuerst an den PHP-Interpreter übergeben. Die Dateierweiterung PHP5 sollten Sie nur wählen, wenn auf dem betreffenden Serversystem gleichzeitig andere PHP-Versionen laufen. Dies kann in einer Umstellungsphase notwendig sein.
So arbeitet PHP
Der PHP-Interpreter arbeitet nun die Datei von oben nach unten ab. Reine HTML-Teile wird er unverändert wieder zurückgeben. Sie werden davon nichts bemerken, abgesehen von der höheren Belastung Ihres Servers und, bei langsamen Maschinen, einer verringerten Ausgabegeschwindigkeit. Finden sich in der Datei PHP-Anweisungen, werden diese ausgewertet und ausgeführt.
2.3 PHP ist einfach ____________________________________________________ 35 PHP einbinden Es gibt insgesamt vier Möglichkeiten, PHP in der Seite unterzubringen. Nur eine davon ist »zukunftskompatibel«. Dieser so genannte XML-Stil dient der Erkennung von PHP-Sequenzen und funktioniert auch, wenn mit XHTML gearbeitet wird:
XML-Stil
Wenn Sie zukunftsorientiert programmieren wollen, sollten Sie den . XHTML ist wichtig für besten Wahl künftige Projekte, weil es die Kompatibilität zu XML sichert und zu sauberem Code führt. Für die anderen drei Einbindungsmöglichkeiten, die PHP aus historischen Gründen kennt, gibt es keinen sinnvollen Einsatzzweck. Wie die Daten zum Browser gesendet werden Reines HTML – außerhalb der PHP-Tags – wird unverändert zum Brow- echo ser gesendet. Interessanter ist es jedoch oft, berechnete Daten zu übertragen. Dazu kennt PHP die Anweisung echo. Sie können hinter echo beliebig viele durch Kommata getrennte Argumente angeben, die zum Browser gesendet werden. Alternativ gibt es auch die Funktion print. Hier darf nur ein Argument print angegeben werden. Längere Ausgaben, die sich aus mehreren Teilen zusammensetzen, können mit dem Operator ».« (Punkt) verbunden werden. Es gibt sicher viele Situationen, wo es egal ist, ob echo oder print ver- Unterschiede wendet wird. Die variable Argumentliste von echo mag häufiger benötigt zwischen echo werden – auch wegen des einen Buchstaben kürzeren Namens ist echo und print vielleicht mehr im Einsatz. Es gibt aber Ausdrücke, in denen auch Ausgaben erfolgen und die Rückgabe eines Wertes erwartet wird. Werte können aber nur von Funktionen zurückgegeben – dann muss print verwendet werden. Einen Geschwindigkeitsunterschied gibt es übrigens nicht. Ausgaben sind Zeichenketten, sie werden deshalb explizit in Anführungszeichen gesetzt. Variablen – darauf wird in Kapitel 3 Variablen und Konstanten eingegangen – werden auch in Zeichenketten erkannt und durch ihren Wert ersetzt, wenn doppelte Anführungszeichen verwendet werden. Wollen Sie das nicht oder soll diese Funktion unterdrückt werden, können einfache Anführungszeichen verwendet werden. Beispiele finden Sie in nahezu jedem Skript in diesem Buch. Blättern Sie Wo sind die einfach mal durch und achten Sie auf die grau hinterlegten Listings und Beispiele? die Nutzung der Anweisung echo oder der Funktion print.
V V V V V V 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 A A B B C C D D E E
36
____________________________________________ 2 Dynamik in der Webseite Tipps zum Einbau von PHP in HTML
Übersichtliche Skripte schreiben
Am Anfang ist die Versuchung groß, unübersichtliche Skripte zu bauen. Denn Leerzeichen, Zeilenumbrüche und Tabulatoren spielen keine Rolle. Sie können eine HTML-Seite so schreiben:
... aber auch so:
... Je nach Umfang des in PHP geschriebenen Codes wird die eine oder andere Variante günstiger sein. Eine optisch eindeutige Trennung von HTML und PHP hat sich in der Praxis als sinnvoll erwiesen. Das Semikolon
Befehle werden in PHP generell mit einem Semikolon abgeschlossen. Nur wenn der Befehl allein zwischen steht, ist das optional. Sie sollten sich angewöhnen, das Semikolon immer zu setzen. HTML mit PHP erzeugen Als Vorgriff auf die Darstellung der Sprache sei die Standardmethode zur Ausgabe der Texte an den Browser gezeigt:
Das sieht, auch wenn es wenig mit PHP zu tun hat, zumindest übersichtlich aus. Alternativ: Heredoc
Alternativ können Codeblöcke auch in der so genannten Heredoc-Syntax ausgedrückt werden. Dabei steht nach dem Ausgabebefehl oder einer Funktion oder Variablen, der Zeichen zugewiesen werden können, ein Einleitungssymbol. Am Ende folgt dann ein Endesymbol. Beides können Sie selbst festlegen:
2.3 PHP ist einfach ____________________________________________________ 37 Heredocs – der Begriff stammt aus Perl, wo die Technik erstmals zum Achtung! Einsatz kam – sind etwas tückisch. So muss der Ende-Text (im Beispiel Fehlerquelle! die Zeichenfolge »SYMBOL«) exakt mit dem Anfang übereinstimmen. Allein ein Leerzeichen davor oder dahinter macht den Befehl zunichte und PHP reagiert mit merkwürdigen Fehlern. Eingleitet wird das Startsymbol immer mit den drei spitzen Klammern: Verarbeitung von Zeichenketten Die Sonderzeichen »\n« und »\t« entsprechen dem Zeilenumbruch und Bedeutung von dem Tabulator. Sie werden aber nur von PHP übersetzt, wenn Sie inner- \n und \t halb einer Zeichenkette auftreten, die mit doppelten Anführungszeichen »""« umschlossen ist. Dem Browser sind diese Zeichen egal – sie entsprechen denen mit einem Editor erzeugten und werden bei der Anzeige ignoriert. Zur Aufbereitung des Quellcodes sind sie aber ideal geeignet. Unix, Windows und Mac aus Sicht des Zeilenumbruchs Viele Editor-Programme bieten die Options, den Quelltext explizit als »Windows«- oder »Unix«-kompatibel zu sichern. Manche bieten noch eine Option für den Mac an. Das liegt daran, dass es für den Zeilenumbruch eine Geschichte gibt. Urspünglich waren Drucker das Ausgabemedium (in den 60er Jahren, bevor es Monitore gab). Da wurden zwei Steuerzeichen benötigt, um auf die nächste Zeile zu gelangen: Wagenrücklauf
V V V V V V 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 A A B B C C D D E E
38
____________________________________________ 2 Dynamik in der Webseite (\r, return) und Neue Zeile (\n, new line). Windows-System verlangen die Kombination \r\n auch für den Bildschirm, während sich Unix mit \n zufrieden gibt. Damit es nicht zu einfach wird, erwartet der Mac ein alleinstehendes \r. PHP5 erkennt alle Varianten und macht beim Lesen keinen Unterschied, also \r == \r\n == \n.
2.4
Erstellen und Testen
Das Schreiben von Skripten geht immer mit dem Testen einher. Sie werden immer wieder, auch als fortgeschrittener Programmierer, ein Stück Code schreiben, ausprobieren, wieder ändern, erneut testen usw. Im Gegensatz zu HTML toleriert PHP Fehler kaum und zwingt, um Fortschritte zu erzielen, zu einer fehlerfreien Umsetzung. Das gilt zumindest für die Syntax. Ob die Programmlogik, die Sie sich wünschen, auch umgesetzt wurde, können Sie natürlich nur selbst herausfinden. Bearbeiten von Skripten
Das Bearbeiten von Skripten läuft immer nach folgendem Schema: • Schreiben Sie den Code in einem Editor • Speichern Sie den Code in einem Verzeichnis des Webservers • Nun öffnen Sie den Browser und geben die Adresse des Skripts ein • Das Skript wird ausgeführt und PHP zeigt das Resultat oder Fehlermeldungen an • Jetzt wird das Skript geändert und erneut gespeichert • Im Browser drücken Sie auf Aktualisieren, um es erneut auszuführen Gewöhnen Sie sich an diesen Ablauf von bearbeiten, speichern und ausführen. Sie können das auf einem Computer machen und zwischen den Fenstern wechseln oder auch mit mehreren Computern arbeiten.
2.4.1 Das erste Skript
Sind Sie startklar?
Wenn Sie sich jetzt fit fühlen, das erste Skript auszuprobieren, dann ist dies eine gute Gelegenheit. Zuerst ein paar Annahmen: • Der Name des Webservers in diesem Buch lautet: »localhost«. Ersetzen Sie den Namen durch den Ihres Servers, wenn Sie nicht lokal arbeiten. »localhost« repräsentiert normalerweise das lokale System. • Das virtuelle Verzeichnis, in dem die Skripte liegen, hat den Namen »php4lernen«. Verwenden Sie diesen Namen, müssen Sie an den Pfadangaben in diesem Buch nichts ändern. Sie können aber auch jeden anderen Namen verwenden. Manchmal sind dann Änderungen an Skripten notwendig.
2.4 Erstellen und Testen ________________________________________________ 39 • Wenn als Webserver Apache verwendet wird, lautet der Pfad zum Stammverzeichnis »c:\htdocs« bzw. »/usr/local/htdocs«. Wenn Sie den IIS verwenden, lautet der entsprechende Pfad beispielsweise »c:\inetpub\wwwroot«. Der vollständige Pfad, wo die Skripte liegen lautet also:
c:\htdocs\php5lernen
Win / Apache
c:\inetpub\wwwroot\php5lernen
Win / IIS
/usr/local/htdocs/php5lernen
Linux / Apache
Vorausgesetzt, die Skripte liegen nun in dem beschriebenen Verzeichnis, rufen Sie diese im Browser folgendermaßen auf:
http://www/php-lernen/start.php Welchen Webserver Sie nun verwenden oder welches Betriebssystem, Jeder Webserver spielt jetzt keine Rolle mehr. ist geeignet Für die Skripte wird die Erweiterung PHP verwendet. In den Listingunterschriften steht jeweils der Skriptname in Klammern, beispielsweise (start). Auf der CD finden Sie dann »start.php«. Vor dem ersten Skript Bevor Sie die ersten Programme ausprobieren, muss Ihre Entwicklungsumgebung laufen. Erstellen Sie zum Test einfach eine Datei mit dem Namen test.php. Sie sollte exakt folgenden Inhalt haben:
phpinfo ist eine Funktion, die Informationen über die Installation von PHP5 ausgibt. Sie sollten dann das Skript im Browser aufrufen, beispielsweise über folgende Zeile: http://localhost/php5lernen/test.php Es wird eine sehr lange Seite ausgegeben, deren erster Teil etwa wie folgt aussieht:
V V V V V V 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 A A B B C C D D E E
40
____________________________________________ 2 Dynamik in der Webseite
Abbildung 2.1: PHP5 mit wichtigen Informationen
Das erste Skript Das erste Skript haben Sie sich vielleicht schon von der CD zum Buch geladen. Es ist hilfreich, dies beim ersten Mal nicht zu tun und statt dessen abzutippen. Sie lernen so schneller den üblichen Ablauf beim Programmieren. Im Gegensatz zum Test wird hier bereits ein kleines Programm zum Ablauf gebracht: Listing 2.1: Das erste Skript zum Ausprobieren (start)
PHP-Lernen
Sie müssen jetzt noch nicht verstehen, was all die Zeichen bedeuten. Wichtig ist, dass Ihr Browser Ihnen die in der folgenden Abbildung gezeigte Seite ausgibt.
2.4 Erstellen und Testen ________________________________________________ 41 Abbildung 2.2: Ergebnis des Skripts aus Listing 2.1
Es funktioniert nicht! Es gibt nun zwei Möglichkeiten: Es funktioniert oder auch nicht. Wenn Wenn es nicht Sie die Ausgabe sehen, wie in Abbildung 2.2 gezeigt, dann steht Ihrer funktioniert erfolgreichen Karriere als PHP-Programmierer nichts mehr im Wege. Es gibt aber mehrere Probleme, die auftreten können: • Sie sehen den Quelltext des Skripts
Quelltext
In diesem Fall versteht der Webserver die Dateierweiterung PHP nicht. Lesen Sie das für Ihr System passende Tutorial auf einer der Webseiten, die in Abschnitt 1.3 Installation ab Seite 21. • Sie sehen nichts
Gar nichts
Vermutlich ist im Skript ein Fehler, der die Ausführung verhindert. passiert Lassen Sie den PHP-Code weg, erzeugt dieses Skript nur eine leere HTML-Seite. Achten Sie auf den Titel in der Kopfzeile des Browsers; dort muss »PHP-Lernen« stehen:
• Eine Fehlermeldung erscheint
Fehlermeldungen
In der Meldung finden Sie einen Hinweis auf die Zeile, in der PHP den Fehler entdeckt hat. Manchmal irrt PHP sich an dieser Stelle auch. Angegeben wird außerdem der physische Pfad zur Datei. Die angegebene Zeile ist dennoch ein guter Punkt, um mit der Suche zu beginnen.
• Sie erhalten eine Fehlermeldung, die auf Segmentfehler, Schutzver- Schutzverletzung letzungen u.ä. hinweist Sie haben ein Modul unter Windows verwendet, dass nicht stabil funktioniert. Dies sollte in der finalen Version nicht mehr auftreten. Versuchen Sie, die neueste PHP5-Version von der PHP-Website zu beschaffen.
V V V V V V 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 A A B B C C D D E E
42
____________________________________________ 2 Dynamik in der Webseite Es funktioniert!
So geht es weiter
Herzlichen Glückwunsch! Sie haben die größte Hürde beim Einstieg in PHP genommen. Ihr Webserver läuft, Ihr Skript läuft, der Browser funktioniert – Sie müssen jetzt nur noch ein paar PHP-Funktionen lernen und schon kann es losgehen. Es gibt übrigens mittlerweile weit über 2 000 Funktionen in PHP. Die kennen zwar auch Profis nicht alle, aber Sie wissen nun: Egal was für Herausforderungen auf Sie zukommen, Sie haben die beste und leistungsfähigste Skriptsprache für kleine und mittlere Webserverprojekte in der Hand (bei großen Systemen sieht das anders aus). Schauen Sie sich noch einmal das kleine Skript an, dass als Testobjekt diente. Der PHP-Teil ist fett hervorgehoben:
PHP-Lernen
Bis zum ersten
?>
?>
?>
$z1 und $z2 sind Ganzzahlen, $z3 und $z4 dagegen Gleitkommazahlen. Abbildung 3.1: Ausgabe von Listing 3.1
Wenn Sie also eine Ganzzahl wie $z4 im letzten Beispiel haben, intern aber mit Gleitkommawerten rechnen, setzen Sie einfach ».0« dahinter, um eine der oben gezeigten Bedingungen zu erfüllen. Datentyp erzwingen
Listing 3.2: Zahlenformate ändern (var_zahlencast)
PHP erlaubt die Angabe eines speziellen Operators, der den internen Datentyp verändert. Dazu wird einfach der Name des Datentyps in runde Klammern gesetzt und dem Wert oder der Variablen vorangestellt.
Die Ausgabe zeigt, wie PHP intern den Datentyp ändert:
Abbildung 3.2: Ausgabe von Listing 3.2 Dieser Operator kann folgende Formen annehmen, wobei rechts jeweils eine alternative Schreibweise für die Zahlentypen steht: • (integer), (int) • (double), (float)
Alles hat einen Namen Diese Art von Operatoren werden auch »cast«-Operatoren genannt – vom englischen »cast«, was soviel wie Guss oder Abdruck bedeutet. Eine Funktion mit dem Namen »cast« gibt es dagegen in PHP5 nicht.
3.3 Variablen genauer betrachtet ________________________________________ 51 Zeichenketten Zeichenketten werden durch zwei Bedingungen erkannt: • PHP kann keine Zahl erkennen – dann wird immer eine Zeichenkette daraus
Mehrere Zeichen: Zeichenketten
• Die Zeichenfolge wird in Anführungszeichen gesetzt PHP erlaubt als Anführungszeichen für Zeichenketten einfache und doppelte. Doppelte haben eine besondere Bedeutung: sie lösen in der Zeichenkette enthaltene Variablen auf, ersetzen den Namen also durch den Wert. Der Umwandlungsoperator für Zeichenketten kann ebenso wie der für Zahlen angewendet werden und hat folgendes Aussehen: • (string) Logische Werte Logische Werte werden auch als Boolesch bezeichnet. Diese haben zwei mögliche Zustände: Wahr und Falsch. PHP stellt sie allerdings intern als Ganzzahlen dar und »simuliert« praktisch nach außen die Verwendung spezieller Boolescher Werte. Dabei entspricht 0 oder Nichts dem Wert Falsch, 1 oder jede andere Ganzzahl Wahr. Der Umwandlungsoperator für Boolesche Werte kann ebenso wie der für Zahlen angewendet werden und hat folgendes Aussehen:
• (boolean) Es gibt zwei Konstanten, die die Verwendung vereinfachen, weil sie eindeutig erkennbar sind: • TRUE
• FALSE Woher kommt der Ausdruck Boolesch? George Boole (1815 – 1864) wurde 1815 im englischen Lincolnshire geboren. In einigen Biografien wird er als Ire bezeichnet, was genau genommen nicht korrekt ist. Allerdings verbrachte er den größten Teil seines Lebens in Irland. Er war ein englischer Mathematiker und Logiker, der einige grundlegende Regeln der Logik formulierte.
3.3
Variablen genauer betrachtet
Variablen sind in PHP weitaus flexibler, als die ersten Ausführungen vermuten ließen. Dieser Abschnitt zeigt weitere Eigenschaften, die elegante Lösungen für Programmierprobleme erlauben. Für die ersten Schritte ist es jedoch nicht notwendig, diesen Abschnitt zu lesen.
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
52 _____________________________________________3 Variablen und Konstanten
3.3.1 Zwei Namen = Ein Wert
Listing 3.3: Einfache Zuweisungen (noreferences)
Verweise
Normalerweise werden Werte einer Variablen mit dem Zuweisungsoperator übertragen. Dabei werden, wenn man sich den Vorgang im Speicher vorstellt, tatsächlich Bytes von einer Speicherstelle zu einer anderen kopiert. Betrachten Sie den folgenden Code:
Es existieren nun zwei unabhängige Variablen, $zahl und $ziel, beide mit dem Wert 14. Änderungen an einer der Variablen wirken sich woanders nicht aus. Das Skript gibt die Zahl 14 aus. Verweise auf Variablen: Referenzen
Referenzen
Listing 3.4: Referenzen erzeugen (var_reference)
Mit Hilfe von Referenzen kann ein Verweis auf eine Variable erstellt werden. Dabei wird der Wert nicht kopiert, sondern bleibt nur an der ursprünglichen Stelle bestehen. Ändert sich später diese Quelle, wirkt sich das auf alle Referenzen aus. Der folgende Code zeigt dies:
Dieses Skript gibt die Zahl 15 aus. Die Änderung an $zahl wirkt sich direkt auf die Referenz $ziel aus. Sie können mit solchen Referenzen Skripte lesbarer gestalten und die Werteübergabe vereinfachen.
&
Referenzen entstehen, indem der Quellvariablen das Zeichen & vorangestellt wird.
3.4
Konstanten
Konstanten sind gegenüber Variablen deutlich einfacher zu verwenden. Sie können in Berechnungen ebenso eingesetzt werden, dürfen sich aber während der Abarbeitung eines Skripts nicht ändern. Eingesetzt werden Konstanten häufig, um bestimmte Werte zu setzen, die zur globalen Einstellung dienen. Wenn Sie beispielsweise an mehreren Stellen die Farbe eines Textes angeben und sich die Änderung vorbehalten, wäre der feste Einbau der Zeichenkette »red« nicht ratsam. Sie müssten bei Änderungen dann alle Vorkommen von »red« suchen und ersetzen. Das funktioniert unter Umständen nicht automatisch, wenn auch Variablen mit dem Namen $red vorkommen oder gar Wörter wie
3.4 Konstanten ________________________________________________________ 53 »reden«. Definieren Sie dann eine Konstante mit dem Namen FARBE, der Sie den Wert »red« zuweisen. Prinzipiell unterliegen Konstanten den gleichen Benennungsregeln wie Namen der Variablen. Der Name kann beliebig lang sein und besteht aus Buchstaben Konstanten und Zahlen und dem Unterstrich. Er darf jedoch nicht mit einer Zahl beginnen. Konstanten erhalten kein vorangestelltes $-Zeichen. Normalerweise werden Variablen in Zeichenketten, die von doppelten Anführungszeichen umschlossen sind, analysiert und durch den Wert ersetzt. Mit Konstanten funktioniert das nicht, da diese nicht erkannt werden können.
3.4.1
Definition von Konstanten
Um Konstanten zu definieren, wird eine spezielle Anweisung eingesetzt:
define("FARBE", 44); Daraus entsteht eine Konstante mit dem Namen FARBE, die den Wert 44 define enthält. Die Großschreibweise hat sich bewährt – Skripte werden besser lesbar, wenn bestimmte Eigenschaften von Elementen sofort erkennbar werden. Ein Zwang, die Benennung durchzuführen, gibt es natürlich nicht. Auch Konstanten haben einen Datentyp. Allerdings können Sie diesen Datentyp einer mit den bei Variablen zulässigen Operatoren nicht mehr ändern. Achten Konstanten Sie deshalb bei der Zuweisung auf die Mechanismen, die PHP selbst zur Feststellung des Typs verwendet: • Zeichenketten entstehen folgendermaßen: - PHP kann keine Zahl erkennen – dann wird immer eine Zeichen-
kette daraus - Die Zeichenfolge wird in Anführungszeichen gesetzt
• Gleitkommazahlen werden so erkannt: - Verwendung des Dezimalpunktes - Verwendung des Exponentialoperators »e« oder »E« - Verlassen des Wertebereiches der Ganzzahlen
• Ganzzahlen sind an diese Bedingungen gebunden: - Wertebereich wird eingehalten - Keine der Bedingungen für Gleitkommazahlen - Nur die Zahlzeichen und das Minuszeichen werden verwendet
Manchmal kann es notwendig sein, zu überprüfen, ob eine Konstante defined bereits definiert wurde. Dazu dient die Funktion defined. Noch eine constant weitere Funktion kann im Zusammenhang mit Konstanten sinnvoll sein. Manchmal verlangt es die Syntax an einer bestimmten Stelle, dass statt eines Literals (Konstantenname) eine Funktion aufgerufen werden muss. Dann nutzen Sie die Funktion constant zum Abruf der Konstanten:
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
54 _____________________________________________3 Variablen und Konstanten Abbildung 3.3: Umgang mit Konstanten (constant)
3.4.2
Vordefinierte Konstanten
PHP_VERSION PHP_OS
PHP kennt bereits einige vordefinierte Konstanten. PHP_VERSION enthält die Versionsnummer des PHP-Interpreters. Sie können damit Skripte schreiben, die sich an bestimmte Bedingungen der Versionen anpassen. PHP_OS berücksichtigt das Betriebssystem, was vor allem bei Operationen im Dateisystem von Bedeutung sein kann.
TRUE FALSE NULL
In den meisten Programmiersprachen kann der Zustand »Wahr« und »Falsch« durch eine Konstante repräsentiert werden. Aufgrund des schwachen Typkonzepts von PHP wird ersatzweise angenommen, Werte ungleich 0 oder »0« sind »Wahr«. Um trotzdem lesbare Skripte erzeugen zu können, werden die Konstanten TRUE und FALSE verwendet, die intern als 1 und 0 dargestellt werden. Auch die kleine Schreibweise true und false ist zulässig. Seit PHP4 gibt es die Konstante NULL (null), die einen nicht vorhandenen Wert darstellt – vor allem zum Vergleich mit anderen Werten, die auf den Zustand »nichts« untersucht werden sollen.
__FILE__ __LINE__
Für die Fehlersuche sind zwei Konstanten wichtig, die immer die aktuelle Datei (Skript) und die Zeilennummer enthalten, die gerade abgearbeitet wird. Haben Sie einen Fehler abgefangen, können Sie in einer Fehlerausgabe auf diese Konstanten verweisen und so die Quelle des Fehlers feststellen: • __FILE__ enthält den Dateinamen des Skripts. • __LINE__ die Zeilennummer. Beachten Sie, dass es sich um zwei Unterstriche vor und nach dem Namen handelt.
E_ERROR E_WARNING E_PARSE E_NOTICE
Bei der Entwicklung von fehlertoleranten Anwendungen sind möglicherweise noch zusätzliche Konstanten von Bedeutung. Die folgenden Konstanten steuern die Ausgabe der Fehlermeldungen zur Laufzeit des Skripts: • E_ERROR, E_WARNING, E_PARSE, E_NOTICE Die Konstanten werden zusammen mit der Funktion error_reporting eingesetzt. Mehr dazu finden Sie in Abschnitt 14.3 Tipps zur Fehlersuche ab Seite 361. Sowohl eigene als auch vordefinierte Konstanten get_defined_constants aus. Versuchen Sie mal folgendes Skript:
print_r(get_defined_constants());
gibt
3.4 Konstanten ________________________________________________________ 55
4 Rechnen und Verarbeiten Programmieren hat viel mit Berechnungen und Datenverarbeitung zu tun. PHP5 liefert das hierfür nötige Spektrum an Funktionen und Operatoren, nicht mehr, aber auch nicht weniger.
4
Rechnen und Verarbeiten
4.1 Zeichenketten______________________________________________________ 57
4.1
Zeichenketten
Als Zeichenketten werden zwei oder mehr zusammenhängende Zeichen bezeichnet. Im englischen werden sie »string« genannt, weshalb viele Funktionen, die sich darauf beziehen, mit »str« beginnen. Zeichenketten haben in PHP kein spezielles Endezeichen und können bis zu 2 GByte groß sein – auch wenn dies eine eher theoretische Annahme ist.
4.1.1
Zeichenkettenfunktionen
Viele Vorgänge, die mit PHP programmiert werden, drehen sich um die So verarbeiten Verarbeitung von Zeichenketten. Praktisch sind sehr viele Daten, die in Sie Zeichenketten Skripten manipuliert werden, Zeichenketten. Berechnet wird dagegen vergleichsweise wenig. Arbeiten mit HTML heißt Umgang mit Zeichen. Entsprechend üppig ist PHP mit Funktionen ausgestattet. Die Kunst besteht weniger im anwenden, sondern im auffinden der richtigen Funktion. Tabelle 4.1 zeigt hier eine durch Funktionsmerkmale bestimmte Einteilung. Funktionsübersicht Die Vielzahl von Zeichenkettenfunktionen macht eine ganzheitliche Darstellung zu einer fast unlösbaren Aufgabe. Wichtiger als die ausführliche Ausbreitung aller Funktionsmerkmale – Auswahl der merken kann sich kaum jemand alle Funktionen – ist die Auffindbarkeit passenden in der Referenz. Die folgende Tabelle hilft Ihnen bei der Auswahl der Funktion richtigen Gruppen von Zeichenkettenfunktionen anhand des Aufgabengebietes. Aufgabe
Funktion
Umwandeln, Modifizieren
addcslashes addslashes bin2hex chop convert_cyr_string ltrim rtrim stripcslashes stripslashes
str_repeat strtok strtolower strtoupper trim ucfirst ucwords wordwrap strpos
Verschlüsseln
crypt crc32 md5
md5_file sha1 sha1_file
Zeichenorientierte Verarbeitung
ord chr
Tabelle 4.1: Zeichenkettenfunktionen nach Aufgabengebieten
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
58
____________________________________________ 4 Rechnen und Verarbeiten Aufgabe
Funktion
Zählen, Auswerten, Lokalisierung
localeconv levenshtein count_chars metaphone setlocale similar_text soundex
strlen strpos stripos strrev strrpos substr_count nl_langinfo
Vergleichen, Suchen, Ersetzen
strcasecmp strchr strcmp strcspn strstr stristr strnatcmp strnatcasecmp strcoll strtok
strncmp strrchr strspn strcspn str_replace str_ireplace strtr substr substr_replace
HTML/Web/URL
htmlentities htmlspecialchars get_html_translation_table get_meta_tags quoted_printable_decode
parse_str quotemeta strip_tags nl2br
Zerlegen, Zusammenführen
chunk_split explode implode join
Ausgaben, Formatieren
number_format money_format printf sprintf vprintf
vsprintf fprintf echo print
Erkennen
sscanf
fscanf
4.1.2
Basiswissen für Zeichenketten
In diesem Abschnitt werden einige sehr häufig verwendete und sehr mächtige Funktionen vorgestellt. Lesen Sie anschließend auch den folgenden Abschnitt 4.1.3 Zeichenketten ab Seite 63, um etwas über trickreiche Konstruktionen zu erfahren. Besonderheiten einiger Funktionen Verhalten beim Suchen
Wenn Sie mit Zeichenketten arbeiten, sollten Sie einige Eigenschaften kennen. Zeichenketten besitzen einen Index, der die Elemente der Kette –
4.1 Zeichenketten______________________________________________________ 59 die Zeichen – adressiert. Das erste Zeichen der Zeichenkette hat den Index 0. Das ist wichtig, wenn Sie in Zeichenketten suchen. Wenn die Fundstelle nämlich das erste Zeichen ist, dann wird 0 zurückgegeben. 0 entspricht aber auch dem Booleschen Wert FALSE – und das ist eigentlich der Wert, der zurückgegeben wird, wenn nichts gefunden wurde. Der Ausweg aus dem Dilemma besteht in der Nutzung des Identitätsoperators ===. Hier wird neben dem Wert (0) auch der Datentyp überprüft. Der ist bei einem Rückgabewert 0 integer, bei einem Fehler jedoch boolean. Universelle Zeichenkettenformatierungen Es gibt zwei Funktionen, die die gleiche Art der Formatierung verwen- printf den: printf und sprintf. Erstere gibt die formatierte Zeichenkette sofort sprintf an den Browser aus, sprintf dagegen gibt sie als Zeichenkette zur weiteren Verarbeitung zurück. Eine interessante Anwendung finden Sie in Listing 6.27 auf Seite 129, wo Beispiel die Einrückungen bei der Ausgabe eines Verzeichnisbaumes mit printf erzeugt werden. Beide Funktionen sind in der Anwendung identisch, die folgende Beschreibung bezieht sich auf beide Funktionen. Angegeben werden müssen mindestens zwei Parameter. Der erste gibt eine Formatieranweisung an, der zweite (und alle folgenden) gibt einen Wert an, der in die Formatieranweisung eingesetzt wird. Hier ein Beispiel für sprintf:
Listing 4.1: Datumsformatierung mit sprintf (string_sprintf)
Im Skript werden drei Variablen Werte zugewiesen:
$year = 2004; $month = 5; $day = 26; Dann werden diesen Werte den Formatanweisungen in sprintf übergeben. Dabei ersetzt die Funktion »%04d« mit dem Inhalt von $year usw. Die Minuszeichen werden unverändert ausgegeben, denn sie stehen außerhalb der Formate.
$result = sprintf("%04d-%02d-%02d", $year, $month, $day); Am Ende wird die formatierte Zeichenkette ausgegeben:
echo $result; Sie erzeugt dabei folgende Ausgabe: Abbildung 4.1: Ausgabe mit sprintf Die Formatieranweisungen von printf, sprintf usw. Eine komplette Formatieranweisung besteht nach dem einleitenden %- Was heißt »%0d2«? Zeichen aus bis zu fünf Elementen mit folgender Bedeutung:
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
60
____________________________________________ 4 Rechnen und Verarbeiten 1.
Ein Füllzeichen Der Standardwert ist das Leerzeichen. Wenn Sie mehrere Stellen wünschen und der Zahlen- oder Zeichenkettenwert diese nicht erreicht, wird der Rest mit dem Füllzeichen aufgefüllt.
2.
Ausrichtung Standardmäßig werden alle Werte rechts ausgerichtet, die Füllzeichen also als führende Zeichen behandelt. Mit einem Minuszeichen wird diese Funktion umgedreht.
3.
Zeichenzahl Eine optionale Anzahl Zeichen, die für den Wert in der Ausgabe reserviert wird. Fehlende Zeichen werden mit Füllzeichen aufgefüllt.
4.
Dezimale Für Gleitkommazahlen kann die Anzahl der Dezimalstellen bestimmt werden. Auf andere Werte hat dies keinen Einfluss.
5.
Typ Der Typ gibt an, wie der Wert generell behandelt wird. Folgende Typen sind möglich: - % Gibt ein Prozentzeichen aus. - b Ganze Zahl in binärer Form. - c Ganze Zahl als Zeichen aus dem ASCII-Zeichensatz. - d Ganze Zahl als Dezimalzahl. - f Gleitkommazahl in Exponentialform. - o Ganze Zahl in oktaler Form. - s Zeichenkette. - x Ganze Zahl in hexadezimaler Form. Die hexadezimalen Ziffern
werden als Kleinbuchstaben »a« bis »f« dargestellt. - X Ganze Zahl in hexadezimaler Form. Die hexadezimalen Ziffern
werden als Großbuchstaben »A« bis »F« dargestellt. Diese Art der Formatangabe setzt voraus, dass die Parameter immer in der richtigen Reihenfolge stehen. Das kann sich jedoch ändern, was zu praktischen Problemen führt. Betrachten Sie folgende Formatanweisung: »%s erscheint in Version %s« Wenn der erste Parameter »PHP« enthält und der zweiten die Zahl »5«, ergibt sich ein sinnvoller Text. Werden die Texte in einem komplexen Programm von jemand anderem erstellt, schreibt dieser später vielleicht folgendes: »Version %s der Sprache %s« Ändert man nun die Parameter nicht, erscheint ein sinnloser Satz: »Version PHP der Sprache 5«
4.1 Zeichenketten______________________________________________________ 61 Alle printf-Formatanweisungen können deshalb modifiziert werden:
%X\$F
Nummerierte Formatanweisungen
Dabei definiert X die Nummer des Parameters, von 1 beginnend. F steht für die ursprüngliche Formatanweisung (ohne %-Zeichen). Der Text im letzten Beispiel würde also besser folgendermaßen geschrieben werden: »Version %1\s der Sprache %2\s« Der Texter muss nun nur wissen, welche Bedeutung %1 und %2 haben. Ändert er den Text, kann er die Zuordnung frei wählen und der Quellcode mit dem Parametern muss nicht parallel dazu geändert werden. Sie können in der Formatierungszeichenkette beliebige Kombinationen Währungen aus solchen Zeichen darstellen, beispielsweise für die Ausgabe von Währungen.
Gelegentlich wird zur Formatierung von Währungen auf die Funktion money_format verwiesen. Dies ist jedoch gefährlich, weil diese unter Windows nicht definiert ist. Damit ist die Plattformunabhängigkeit nicht gewährleistet. Dies hat sich mit PHP5 nicht verändert, leider. Vergessen Sie money_format einfach, die Funktion ist nutzlos.
Listing 4.2: Währungen ausgeben (money_format) Abbildung 4.2: Währungsausgabe
Alle Zeichen, die nicht zur Formatieranweisung gehören, werden unver- Führende Nullen ändert ausgegeben, wie im letzten Beispiel der Präfix &euro. Für die Ausgabe von führenden Nullen ist die Funktion ebenfalls geeignet:
Listing 4.3: Formatierung mit führenden Nullen Abbildung 4.3: Ganzzahlformate
Wenn Sie Prozent- oder Zahlwerte ausgeben müssen, eignet sich folgen- Prozent- oder de Schreibweise: Zahlwerte
Listing 4.4: Verschiedene Formen der printf-Funktion für Prozent- und Zahlenwerte (string_format)
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
62
____________________________________________ 4 Rechnen und Verarbeiten Die Zuordnung der Variablen zu den Formatanweisungen erfolgt in der Reihenfolge des Auftretens. Stimmen die Datentypen nicht überein, wird er implizit entsprechend dem Format geändert. printf rundet Zahlenwerte außerdem mathematisch korrekt, wenn es durch die Angabe der Anzahl der Nachkommastellen dazu gezwungen wird. Betrachten Sie als Beispiel die Ausgabe des Prozentwertes aus Listing 4.4 in Abbildung 4.4.
Abbildung 4.4: Ausgabe des Skripts aus Listing 4.4 ReferenzWegweiser
Auf der hier anhand sprintf und printf gezeigten Vorgehensweise bauen weitere Funktionen auf: • vprintf • vsprintf Diese Funktionen arbeiten wie printf bzw. sprintf, akzeptieren aber als Argument keine Variablenliste, sondern ein Array, dessen Elemente als Argumente dienen (mehr zu Arrays finden Sie in Abschnitt 5.1 Wie Arrays funktionieren ab Seite 85).
sscanf
Mit einem vergleichbaren Satz von Formatierungsanweisungen arbeitet auch die Funktion sscanf. Hier wird eine unformatierte Zeichenkette auf die Existenz bestimmter Formen hin untersucht und die gefundenen Werte werden in einem Array abgelegt. Diese Funktion eignet sich, um Felder aus HTML-Formularen auszuwerten oder auch zur Umwandlung von fremden Formaten. Das folgende Beispiel zeigt die Aufbereitung eines amerikanischen Datumsformates und die Ausgabe in der in Deutschland üblichen Form mit sscanf und printf.
Listing 4.5: Daten mit sscanf scannen (string_sscanf)
Das von sscanf erzeugte Array %d hat so viele Elemente, wie gültige Formatierungen entdeckt werden konnten. Dies muss nicht der Anzahl der Formatanweisungen entsprechen. Mehr Informationen über Arrays finden Sie in Kapitel 6 Komplexe Datenstrukturen: Arrays ab Seite 83.
Abbildung 4.5: sscanf zur Ausgabe number_format
Geht es bei der Ausgabe jedoch nur um Zahlen, werden Sie vielleicht mehr mit number_format anfangen können. Diese Funktion eignet sich vor allem, um das intern verwendete englische Zahlenformat in das in Deutschland übliche umzuwandeln.
4.1 Zeichenketten______________________________________________________ 63
Listing 4.6: Zahlen formatieren (number_format)
Auch diese Funktion ist in der Lage, korrekt zu runden, wenn es die Anzahl der Dezimalstellen erfordert. Übergeben werden neben der Zahl (erster Parameter) die Anzahl der Dezimalstellen (im Beispiel »2«), das als Komma verwendete Zeichen und optional ein Zeichen, das als Tausender-Trennzeichen dient. Abbildung 4.6: Formatierung von Zahlen Die Bedeutung der Parameter der Funktion number_format entnehmen Sie bitte der folgenden Tabelle: Parameter
Bedeutung
1
Wert, der formatiert werden soll
2
Anzahl der Dezimalstellen
3
Zeichen für die Dezimaltrennung (bei uns: Komma)
4
Zeichen für Gruppierung (bei uns: Punkt)
Die Angaben sind – bis auf den Wert – optional.
4.1.3
Zeichenketten in der Praxis
Zeichen treten vor allem bei der Ausgabe auf. Auch Zahlen sind, wenn Sie in HTML erscheinen, nur Zeichen, die ansprechend formatiert werden müssen. Solche Ausgaben sollen zuerst behandelt werden. Ausgaben formatieren Beim Formatieren denken viele Programmierer gleich an komplexe Zeichenkette Funktionen wie printf oder number_format. Oft geht es jedoch viel einfa- gruppieren cher. So können Telefonnummern leicht in Zweiergruppen mit zwischengesetzten Leerzeichen zerlegt werden:
Die Variable $tel enthält nach dem Ausführen des folgenden Codes die Zeichenkette »56 30 10 32«. Die Funktion chunk_split zerlegt die Zeichenkette in Gruppen, wobei die Anzahl der Zeichen pro Gruppe durch den zweiten Parameter bestimmt wird. Dann werden die Gruppen mit dem Trennzeichen (dritter Parameter) verbunden.
Listing 4.7: Zeichenkette in Zweiergruppen (chunk_split)
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
64
____________________________________________ 4 Rechnen und Verarbeiten
Abbildung 4.7: Ausgabe des Skripts aus Listing 4.7 Einen Index erstellen Bei der Ausgabe von längeren Listen ist es oft gewünscht, einen Index in der Kopfzeile zu haben, mit dem bestimmte Punkte direkt erreicht werden können. Dabei wird eine Abfrage aus einer Datenbank sortiert und als Liste ausgegeben. Die einzelnen Buchstaben sind per seiteninternem Link erreichbar, wie hier für den Buchstaben »Z« gezeigt:
Z Im Kopf der Seite steht dann ein Link, der etwa folgendermaßen aussieht:
Z Natürlich sollen nur die Links aktiv sein, die auch zu Inhalten führen. Die folgende Abbildung zu Listing 4.8 zeigt das Ergebnis des Skripts: Abbildung 4.8: Index in HTML In der Lösung werden die Funktionen strtoupper, strncasecmp und substr verwendet, um das gewünschte Ergebnis zu erzielen. Listing 4.8: Erzeugen eines Index (siteindex)
4.1 Zeichenketten______________________________________________________ 65 Das Skript startet mit der Definition eines Musterarrays. Mehr zu Arrays finden Sie in Abschnitt 5.1 Wie Arrays funktionieren ab Seite 85. Die Daten können natürlich ebenso einer Datenbankabfrage entstammen. Nehmen Sie das Array einstweilen als Liste mehrerer Variablen an:
$wordlist = array("Anton", "Berlin", "Cäsar", "Karl", "Ludwig", "Thodor", "Xara"); Dann wird das Array sortiert. Die Sortierrichtung bestimmt die Anzeigereihenfolge:
sort($wordlist); Zuerst wird das erste Element des Index ausgewählt:
$oldword = "A"; Dann werden alle übergebenen Wörter durchlaufen:
foreach($wordlist as $word) { Mehr zur Anweisung foreach finden Sie in bestellen: foreach ab Seite 116.
Abschnitt 6.3.4 Felder
Vom aktuellen Wort wird der erste Buchstabe selektiert:
$word = strtoupper(substr($word, 0, 1)); Jetzt wird verglichen, ob der aktuelle Anfangsbuchstabe unmittelbar dem letzten Buchstaben folgt, also beispielsweise das »F« hinter »E« steht oder hinter »B«. Falls eine Lücke entstanden ist, wird diese mit der Funktion fillin ausgefüllt:
$next = strncasecmp($word, $oldword, 1); if ($next > 0) fillin($oldword, --$next); Das gefundene Wort wird unterstrichen dargestellt (die inzwischen von fillin geschriebenen Buchstaben sind nicht unterstrichen). Dies deutet den Einbau eines Links an, Sie müssten hier die passenden -Tags einsetzen:
}
echo "$delimiter$word"; $oldword = $word;
Zum Schluss wird fillin nochmals aufgerufen, um die fehlenden Buchstaben bis »Z« zu ergänzen, falls nicht ohnehin Wörter mit dem Anfangsbuchstaben »Z« existieren.
fillin($oldword, strncasecmp("Z", $word, 1)); Das eigentliche Auffüllen übernimmt die selbst definierte Funktion fillin. Informationen über Funktionen, die Sie selbst definieren können, finden Sie im Abschnitt 6.4 Ordnung ins Chaos: Funktionen ab Seite 118. Zeichenkette ab einer Fundstelle zurückgeben Oft werden Zeichenketten nach einem bestimmten Zeichen durchsucht. Wenn der Rest der Zeichenkette von Belang ist, benötigen Sie dazu nur
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
66
____________________________________________ 4 Rechnen und Verarbeiten eine der beiden Funktionen stristr bzw. strstr. Komplexe Konstruktionen mit substr, regulären Ausdrücken und raffinierten Berechnungen sind überhaupt nicht nötig:
Listing 4.9: Teil einer Zeichenkette ab Fundort (string_stristr)
Das »i« im Funktionsnamen von stristr unterdrückt die Beachtung von Groß- und Kleinschreibung. Die beiden Funktionen durchsuchen eine Zeichenkette und geben den Rest einschließlich der Fundstelle zurück.
Abbildung 4.9: Ausgabe mit stristr Formatierungen von Zeichenketten Zur Formatierung gehört auch die Aufbereitung von Zahlen für Tabellen und Spaltensatz. Die Anzahl der Ziffern einer Zahl können Sie mit der Zeichenkettenfunktion strlen ermitteln, wenn die Zahl zuvor in eine Zeichenkette gewandelt wurde: Listing 4.10: »Breite« einer Zahl berechnen (string_strlen)
Das Skript basiert auf strlen. Damit die Funktion wie erwartet eine Zeichenkette erhält, wird der Datentyp der Zahl in der Variablen $z zuvor mit dem Cast-Operator (string) umgewandelt. Noch flexibler ist die Funktion str_pad. Abbildung 4.10 zeigt die Anwendung zur Ausgabe eines Rechnungsfußes, wie in der folgenden Abbildung zu sehen ist.
Abbildung 4.10: So sollte der Rechnungsfuß aussehen Beachten Sie bei diesem Beispiel, dass die Formatierung voraussetzt, dass mit Zeichen gleicher Breite gearbeitet wird. Sie müssen also entweder als Font Courier oder einen vergleichbaren einsetzen, oder mit dem HTMLTag arbeiten. Die foreach-Schleife, in der die Ausgabe erfolgt, kann man auch gut in eine kleine Funktion verpacken und überall einsetzen, wo derartige Ausgaben erfolgen. Mehr zur Anweisung foreach finden Sie in Abschnitt 6.3.4 Felder bestellen: foreach ab Seite 116.
4.1 Zeichenketten______________________________________________________ 67
Listing 4.11: Ausgabe eines formatierten Rechnungsfußes
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
Das Skript beginnt mit der Definition von Musterdaten. Diese können natürlich auch aus einer Datenbank stammen. Die Anzahl der Datensätze spielt keine Rolle, es werden alle Elemente nacheinander verarbeitet:
foreach($money as $type => $val) { Zuerst wird der Wert in $val selbst formatiert. Benötigt werden zwei Dezimalstellen und die in Deutschland übliche Schreibweise.
$val = number_format($val, 2, ",", "."); Dann wird der linke Teil des Rechnungsfußes erzeugt. Die Wörter werden auf 20 Zeichen gebracht, als Auffüllzeichen werden rechts Unterstriche angehängt:
echo str_pad($type, 20, "_", STR_PAD_RIGHT); Ebenso wird der Wert formatiert, hier werden die Auffüllzeichen links angefügt. Maximal 10 Zeichen entstehen so:
}
echo str_pad($val, 10, "_", STR_PAD_LEFT); echo "\n";
Insgesamt ist der Fuß 30 Zeichen breit. Mehr Informationen zu foreach finden Sie auch in Abschnitt 6.3.4 Felder bestellen: foreach ab Seite 116. Pfade berechnen Auch Operationen mit Pfaden profitieren von Zeichenkettenfunktionen. Das folgende Beispiel erzeugt einen Pfad in Abhängigkeit von der Position des Skripts im Verzeichnisbaum.
Hier wird intensiv auf Zeichenkettenfunktionen zurückgegriffen. substr_count zählt, wie viele Verzeichnistrennzeichen die Variable $_SERVER[‘PHP_SELF’] enthält. $_SERVER ist ein Array, das Informationen über Webserver und Browser enthält. PHP_SELF enthält immer den Namen des aktuellen Skripts. Dies ist eine sehr häufige Schreibweise in Skripten.
Servervariablen
Mehr Informationen zu Servervariablen finden Sie im Daten über den Server ermitteln ab Seite 219.
Abschnitt 9.3
str_repeat erzeugt dann den Pfad nach oben, bestehend aus »../«Zeichenfolgen, indem diese mehrfach wiederholt zurückgegeben werden. Dann wird mit substr und strrchr der Dateiname abgetrennt und die Konstruktion neu zusammengesetzt. Aus dem vollständigen Pfad wie der Folgende: "/usr/local/htdocs/skript.php" wird dann eine solche Konstruktion:
"../../../skript.php" Wird im Beispiel $fn ersetzt, kann man andere Skripte im aktuellen Verzeichnis direkt erreichen, ohne zu wissen, wo genau man sich befindet. Das ist vor allem für Funktionen wie file interessant, die absolute Pfadangaben verwenden.
4.1.4 Viele Zeichenkettenoperation haben mit HTML zu tun
Listing 4.13: HTML-Entities zurückwandeln (string_htmltable)
HTML problemlos verwenden
Die folgende Funktion dreht die Umwandlung von Sonderzeichen in HTML-Codes um. Angenommen Sie durchsuchen fremde Webseiten und möchten Umlaute der Form ö wieder als »ö« haben, eignet sich die folgende Funktion:
Die eigentliche Arbeit erledigt strtr. Diese Funktion ersetzt alle Zeichen einer Zeichenkette anhand einer Austauschtabelle, die als assoziatives Array vorliegt. Die Austauschtabelle entsteht, in dem die Ausgabe von get_html_translation_table mit array_flip umgedreht wird. Dabei werden Werte und Indizes vertauscht. Mehr zu assoziativen Arrays finden Sie in Abschnitt 5.1.2 Sprechende Indizes: Assoziative Arrays ab Seite 88. Die Umwandlungstabelle wird übrigens auch intern von zwei Funktionen genutzt, htmlspecialchars und htmlentities. Diese wandeln Sonderzeichen in die entsprechenden
4.1 Zeichenketten______________________________________________________ 69 HTML-Codes um. Das nächste Listing zeigt, wie eine Sonderzeichentabelle erzeugt wird.
Abbildung 4.11 zeigt die fertige Zeichentabelle im Browser. Das Skript durchläuft den Teil der ASCII-Tabelle mit den erweiterten Zeichen mit einer Schleife:
for($i=162; $i Die Berechnung basiert auf folgender Definition: Der Modulus ist 0, wenn Dividend und Divisor ohne Rest teilbar sind. Wenn Sie also jede zweite Reihe anders behandeln möchten, dividieren Sie den Zähler durch zwei, für jede dritte Reihe durch drei usw. Konkret ausgeführt wird diese Berechnung in der folgenden Zeile:
if ($i % 2 == 0) Die if-Anweisung, die hier benutzt wird, entscheidet ob ein nachfolgender Block (in geschweiften Klammern) ausgeführt werden soll. Abschnitt 6.2 Verzweigungen ab Seite 104. InMehr dazu finden Sie formationen zu Schleifen enthält Abschnitt 6.3.3 Abzählbare Schleifen: for(;;) ab Seite 114. Das Verfahren eignet sich auch hervorragend für die Begrenzung der Spaltenanzahl. In Listing 4.14 auf Seite 69 finden Sie die folgende Zeile:
if ($x++ % 8 == 7) Hier erfolgt die Trennung nach der achten Spalte. Der Vergleichswert ist 7, da wegen »0 % Wert == 0« die Bedingung bereits im ersten Durchlauf erfüllt ist. Dies würde zur Ausgabe einer neunten Spalte führen. Wenn Sie dies vermeiden möchten, beginnen Sie entweder mit 1 oder setzen den Endwert anders. Generell ist der Rest der Division die Anzahl der bereits absolvierten Schritte. Die folgenden Formeln helfen, das zu verstehen. Dabei ist x die Laufvariable, y der Trennwert, ab dem eine Aktion ausgelöst werden soll: • Berechnung des Schrittes innerhalb eines Zyklus, beginnt mit z = 0:
z = x % y
4.2 Praktische Mathematik ______________________________________________ 73 • Berechnung der Anzahl Schritte s bis zum Endes des Zyklus, beginnend mit s = y:
s = (y – (x % y)) Das Ergebnis des Skripts zeigt die folgende Abbildung: Abbildung 4.13: Ausgabe des Skripts aus Listing 4.16
Zuweisungsoperatoren Der einfachste Operator ist der Zuweisungsoperator, der beispielsweise Zuweisungen: für die Übertragung von Werten in eine Variable Verwendung findet. Sie = können die grundlegenden arithmetischen Operatoren mit diesem Operator verbinden:
$zahl = 45; // weist einer Variablen einen Wert zu $zahl = $andere_zahl; Das sieht sehr einfach aus. Sie können aber mit Hilfe von Klammern Zuweisungskomplexere Konstruktionen schaffen: operatoren: += -= /= Anschließend enthält die Variable $faktor den Wert 2, $zahl den Wert 8 %= .=
$zahl = ($faktor = 2) * 4; $z1 = $z2 = $z3 = $z4 = $z5 = 0;
und alle Variablen $zX enthalten alle den Wert 0. Die arithmetischen Operatoren können damit kombiniert werden:
$zahl $zahl $zahl $zahl $zahl
+= -= *= /= %=
$zahl2; $zahl2; $zahl2; $zahl2; $zahl2;
Auch der Zeichenkettenoperator ».« kann mit der Zuweisung kombiniert werden:
$zeichen .= "
";
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
74
____________________________________________ 4 Rechnen und Verarbeiten Bitoperatoren Wenn Variablen Werte enthalten, die sich in Byte- oder Bitform auffassen lassen, können Manipulationen mit Bitoperatoren sinnvoll sein. Denken Sie daran, dass ein spezieller binärer Datentyp nicht existiert. Die Anwendung auf normale Variablen führt manchmal zu unerklärlichen Effekten.
& | ~
Tabelle 4.2: Verhalten der Bitoperatoren
Der Operator & führt eine binäre UND-Verknüpfung durch, | steht für eine ODER-Verknüpfung, während ~ den Bitwert negiert. Die Operatoren entsprechen Boolescher Algebra. Das Verhalten kann der Auflistung in Tabelle 4.2 entnommen werden. Operand $x
Operand $y
$x & $y
$x | $y
~$x
~$y
0
0
0
0
1
1
0
1
0
1
1
0
1
0
0
1
0
1
1
1
1
1
0
0
Bedenken Sie, dass das Ergebnis alle Bitstellen beinhaltet, also nicht einer dezimalen 0 oder 1 entspricht. Tabelle 4.2 gibt jedoch zur Vereinfachung nur eine Bitstelle wieder. Bits verschieben
Zwei weitere Operatoren arbeiten auf Bit-Ebene: >> und werden Bits nach rechts verschoben, bei > 1; Dies ergibt 50, binär 110010. Was ist passiert? Eigentlich hätte die Rechtsverschiebung zu "0010" führen müssen. Tatsächlich hat PHP die Verschiebung korrekt ausgeführt – in beiden Fällen entspricht dies einer Division durch 2. Allerdings ist die Zeichenkette intern in eine Dezimalzahl gewandelt worden – in die 100. Versuchen Sie es besser folgendermaßen: Listing 4.17: Bitoperatoren anwenden (bitops)
Jetzt wird erwartungsgemäß "0010" zurückgegeben. Einmal bitweise nach rechts verschieben entspricht einer Division durch 2, entsprechend ist eine Linksverschiebung eine Multiplikation mit 2.
bindec decbin
Elegant ist natürlich auch die Verwendung entsprechender Umwandlungsfunktionen. Speziell für Binärzahlen gibt es bindec (Binärzahl in Dezimalzahl) und decbin (Dezimalzahl in Binärzahl). Die Darstellung der Binärform ist jedoch in PHP eine Zeichenkette – keine echte Binärzahl.
4.2 Praktische Mathematik ______________________________________________ 75 Logische Operatoren Logische Operatoren dienen der Konstruktion logischer Ausdrücke und werden vor allem zusammen mit if, while oder do verwendet. Wichtig ist bei diesen Operatoren die Assoziativität – also die Rangfolge. PHP nutzt diese Vorgaben, wenn die Reihenfolge der Abarbeitung nicht durch Klammern exakt vorgegeben ist. Sie kennen sicher die Regel »Punkt- vor Strichrechnung« aus der Schule. Die Assoziativität dehnt das Regelwerk auf alle in der Programmiersprache definierten Operatoren aus. Die folgende Tabelle zeigt die nötige Übersicht: Assoziativität
Operator
links
, or xor and
rechts
print
links
= += -= *= /= .= %= &= != = ^= ~=
links
? :
links
|| && | ^ &
Nicht assoziativ
== != === < >=
links
> + - . * / %
rechts
! ~ ++ -- @ (integer) (double) (string) (array) (object) (boolean)
rechts
[
Nicht assoziativ
new
Bei Operatoren wie or oder and kann diese Vorrangsteuerung ausgenutzt werden, um bestimmte Effekte zu erzielen. Im folgenden Beispiel werden die Funktionen f1() bis f4() nur solange ausgeführt, bis eine der Funktionen FALSE zurückgibt.
if (f1() and f2() and f3() and f4()) Der logische Ausdruck verknüpft die vier Rückgabewerte der Funktionen f1() bis f4() mit and. Damit der Ausdruck Wahr wird, müssen alle vier Werte Wahr sein. Ist auch nur einer der Werte Falsch, kann das Ergebnis nur noch FALSE sein. Hier arbeitet PHP sehr effizient – der Rest des Ausdrucks wird einfach nicht mehr bearbeitet, die Funktionen f3() und f4() werden also nicht aufgerufen, wenn f2() FALSE zurückgibt. Ob das im Sinne des Programmierers ist, hängt vom konkreten Fall ab. Auch mit dem or-Operator kann man sinnvoll diese Effekte ausnutzen. Wenn Sie damit rechnen, dass eine Funktion bei Fehlern FALSE zurückgibt, schreiben Sie Folgendes:
myfunction() or print "Fehler in 'myfunction()'"; Der Ausdruck ist durch ein logisches ODER verknüpft. Zuerst wird die linke Funktion ausgeführt. Gibt diese TRUE zurück, ist der gesamte Ausdruck – unabhängig von der rechte Hälfte, auch TRUE. Durch die Optimierung wird die weitere Verarbeitung abgebrochen und das Skript läuft
Tabelle 4.3: Assoziativität der Operatoren
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
76
____________________________________________ 4 Rechnen und Verarbeiten weiter. Gibt die Funktion myfunction() jedoch FALSE zurück, muss auch der rechte Teil ausgeführt werden. Der bringt zwar keine neuen Erkenntnisse, aber die Fehlerausgabe erscheint. Sehr oft ist hier auch die Anweisung die zu sehen, die das Skript an dieser Stelle abbricht.
Praktisch verwendbar
Diese Art der Programmierung ist weit verbreitet, kompakt und verhältnismäßig gut lesbar. Auch wenn es den Anschein eines Tricks hat – diese Technik ist sinnvoll und praktikabel. Welcher Teil zuerst ausgeführt wird, können Sie Tabelle 4.3 entnehmen. Abschnitt 6.4 Ordnung ins Chaos: Funktionen ab Seite 118 enthält Informationen über den Umgang mit eigenen Funktionsdefinitionen.
4.2.2
Mathematische Funktionen
Die folgende Tabelle zeigt alle Funktionen auf einen Blick. Die trigonometrischen Funktionen erwarten Argument im Bogenmaß (Radiant), mit deg2rad und rad2deg können solche Werte von und in Winkel umgerechnet werden. Tabelle 4.4: Mathematische Funktionen
min und max clever einsetzen
Beschreibung
Funktion
Trigonometrische Funktionen
acos($x) asin($x) atan($x) atan2($x) cos($x) sin($x) tan($x)
Logarithmusfunktionen
exp($x) log($x) log10($x)
Maximalwert der Argumentliste
max($x [, $x2 [, ...]])
Minimalwert der Argumentliste
min($x [, $x2 [, ...]])
Potenzfunktion, xy
pow($x, $y)
Quadratwurzel
sqrt($x)
Die Funktionen min und max mögen auf den ersten Blick trivial erscheinen, werden jedoch seltener eingesetzt als eigentlich möglich. Betrachten Sie den folgenden Ausdruck:
if ($a > 3) { $b = $a; } else { $b = 3; } Solche Gebilde sind sehr häufig anzutreffen. Besser könnte man hier folgendes schreiben:
$b = max($a, 3); Oft dürfen Werte nicht kleiner als 0 werden. Relativ elegant ist dagegen folgendes Konstruktion:
$a < 0 ? $a = 0 : $a;
4.2 Praktische Mathematik ______________________________________________ 77 Noch kürzer kann man dafür max einsetzen:
$a = max(0, $a); Umgekehrt gehen Sie vor, wenn ein Wert ein bestimmtes Limit nicht überschreiten soll. Praktisch ist dies bei der Analyse von Benutzereingaben. Das folgende Beispiel zwingt den Wert zwischen zwei festgelegten Grenzen, wobei kleinere Zahlen auf den kleinsten und größere auf den größten zulässigen Wert korrigiert werden:
$month = max(1, min($month, 12)); Nach der Ausführung ist $month auf jeden Fall zwischen 1 und 12. Durch Messung der Abarbeitungszeiten kann man feststellen, dass der AbarbeitungsFunktionsaufruf nach max oder min geringfügig schneller ist, als die ver- zeiten gleichbaren mehrzeiligen Konstruktionen aus if und else. Mehr Informationen zu diesen Anweisungen enthält Abschnitt 6.2 Verzweigungen ab Seite 104. Funktion
Beschreibung
abs(zahl)
Absoluter Betrag
floor(zahl)
Ganzzahliger Teil einer Zahl
ceil(zahl)
Nächsthöhere Ganzzahl
round(zahl [,dezimalstelle])
Rundung auf die durch dezimalstelle angegebene Stellenzahl
base_convert (nummer, quellbasis, zielbasis)
Wandelt von einem beliebigen Zahlensystem der Basis 2 bis 36 in ein anderes um
bindec(binaerwert)
Binär
decbin(dezimalwert) dechex(dezimalwert) decoct(dezimalwert) hexdec(hexwert) octdec(oktalwert) deg2rad(winkel) rad2deg(radiant)
Tabelle 4.5: Umwandlungsfunktionen
Dezimal Dezimal Binär Dezimal Hexadezimal Dezimal Oktal Hexadezimal Dezimal Oktal Dezimal Winkel Radiant Radiant Winkel
Wenn Sie Logarithmen mit einer beliebigen Basis berechnen müssen, verwenden Sie folgende Definition. Das erste Argument ist die zu berechnende Mantisse, das zweite die Basis des Logarithmus:
$mant = 3.14; $raise = 2; echo log($mant)/log($raise); Eine Besonderheit ist bei round zu beachten. Die Rundung erfolgt nicht in Probleme mit allen Fällen korrekt. Das liegt an der internen Darstellung der Zahlen. dem Runden: Einige einfache Werte, wie beispielsweise 11,5, sind nicht exakt im Binär- round format darstellbar. Statt dessen speichert der Computer 11,49999999999.
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
78
____________________________________________ 4 Rechnen und Verarbeiten Die Rundungsfunktion rundet dann auf 11 ab. Eine Alternative ist die Anwendung der Funktionen ceil und floor, wie das folgende Beispiel zeigt:
Listing 4.18: Bessere Rundungsfunktion (math_round)
Die Funktion ermittelt zuerst die Anzahl der Dezimalstellen – dies entspricht der Zehnerpotenz:
$r = pow(10, $d); Dann wird der Wert damit multipliziert – jetzt gibt es keine Nachkommstellen mehr.
$v *= $r; Jetzt wird der so ermittelte Wert mit seinem ganzzahligen Teil verglichen. Tritt ein Fehler auf, ist die Differenz größer als 0,5, wird der nächst höhere Ganzzahlwert mit ceil ermittelt, andernfalls bleibt die bestehende Ganzzahl erhalten. Mit der abschließenden Division durch die Anzahl der Dezimalstellen entstehen wieder die Nachkommstellen. Tipp!
Eine andere Anwendung von ceil ist die Ermittlung einer Anzahl Seiten bei der seitenweisen Ausgabe von Ergebnissen. Wenn Sie beispielsweise 22 Ergebnisse in Gruppen zu sieben ausgeben, benötigen Sie dafür vier Seiten. 22/7 liefert 3.142. Eine Rundung würde 3 zurückgeben, was falsch ist; ceil liefert dagegen die korrekte Zahl 4. Mathematische Konstanten In PHP5 gibt es eine ganze Palette häufiger benötigter Konstanten, die in der folgenden Tabelle zusammengefasst sind.
Tabelle 4.6: Mathematische Konstanten und deren Definition
Konstante
Exakter Wert
Definition
M_PI
3.14159265358979323846
Der Wert π (Pi)
M_E
2.7182818284590452354
e (Eulersche Zahl)
M_LOG2E
1.4426950408889634074
log2 e
M_LOG10E
0.43429448190325182765
log10 e
M_LN2
0.69314718055994530942
loge 2
M_LN10
2.30258509299404568402
loge 10
M_PI_2
1.57079632679489661923
π/2
4.2 Praktische Mathematik ______________________________________________ 79 Konstante
Exakter Wert
Definition
M_PI_4
0.78539816339744830962
π/4
M_1_PI
0.31830988618379067154
1/π
M_2_PI
0.63661977236758134308
2/π
M_2_SQRTPI
1.12837916709551257390
M_SQRT2
1.41421356237309504880
M_SQRT1_2
0.70710678118654752440
2
π 2 1 2
Die in der Dokumentation ausgewiesenen Konstanten M_EULER und M_LNPI, die mit PHP4.0.2 eingeführt wurden, waren bei der ersten Version PHP5.0.0 nicht verfügbar. In künftigen Versionen kann dies wieder geändert werden. Zufallszahlen Zufallszahlen werden häufig benötigt, um Vorgänge zu steuern oder beispielsweise Kennwörter zu erzeugen. Zufallsfolgen beruhen auf mathematischen Funktionen, die zwar einen chaotischen Verlauf haben, aber dennoch einer strengen Folge gehorchen, sie sind pseudozufällig. Echte Zufälligkeit wird erst erzeugt, wenn der Startwert variiert. Die folgende Tabelle zeigt Funktionen zum Abruf der Zufallswerte und zum Setzen des Startwertes. Funktion
Beschreibung
mt_srand()
Setzt den Startwert für den Zufallsgenerator.
mt_rand([min] [, max])
Gibt eine Zufallszahl zwischen 0 und 1 oder zwischen min und max zurück1.
mt_getrandmax()
Gibt die höchstmöglich Zahl an, die rand zurückgeben kann.
Tabelle 4.7: Funktionen, um Zufallszahlen zu erzeugen
Es existieren noch ältere Zufallszahlenfunktionen ohne den Präfix mt_. mt-Funktionen Die Funktionen mit dem Präfix mt_ sind neuer und sollten grundsätzlich bevorzugt werden. Die in den ursprünglichen PHP-Bibliotheken verwendeten Zufallsgeneratoren sind relativ unbekannt und langsam. Vor allem beim Einsatz in der Kryptografie ist die Charakteristik eines Zufallsgenerators wichtig. Die mt-Funktionen wurden von Mersenne Twister (mt) entwickelt und sind gut dokumentiert. Urspünglich muss bei allen Zufallsgeneratoren der Startwert explizit gesetzt werden, um nicht immer wieder dieselbe Folge von pseudozufäl-
1 Die eckigen Klammern gehören nicht zur Funktion, sondern deuten an, dass es sich hier um optionale Parameter handelt.
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
80
____________________________________________ 4 Rechnen und Verarbeiten ligen Zahlen zu produzieren. PHP5 kann dies allein, es nimmt den aktuellen Zeitstempel inklusive des Mikrosekundenanteils als Startwert. Nur wenn das nicht reicht ist der Einsatz von mt_srand erforderlich.
4.2.3
Funktionen beliebiger Genauigkeit
Die internen mathematischen Funktionen von PHP – und übrigens auch aller anderen Programmiersprachen – arbeiten mit binären Gleitkommazahlen. Es liegt in der Natur dieser Zahlen, dass sie bestimmte reelle Zahlen nicht abbilden können. Letztlich sind Sie auch bei der dezimalen Mathematik auf eine bestimmte Anzahl Dezimalstellen beschränkt. Die alternative Schreibweise, die eine beliebige Genauigkeit erlaubt, sind Brüche. In der Computerwelt stehen für die Ablage und Verarbeitung von Zahlen im Prozessor auch nur eine bestimmte Anzahl von Bits zur Verfügung. Zahlen, die nicht in diesen Zahlenraum passen, werden mit einem bestimmten Fehler weiterverarbeitet. In der Praxis macht sich das nur selten bemerkbar, weil die Genauigkeit relativ hoch ist. Reicht es jedoch nicht, müssen andere Maßnahmen her. Ein wichtiges Beispiel sind Währungen. Während die Anzahl der Nachkommastellen gering ist, sind die Ansprüche an korrekte Berechnungen oder Rundungen extrem hoch. PHP unterstützt Berechnungen dieser Art mit einem Satz von Funktionen, die mit einer beliebigen Genauigkeit rechnen können. Wann es sich bemerkbar macht Rundungsprobleme
Um die Problematik noch etwas transparenter werden zu lassen, soll ein Beispiel gezeigt werden. Ab einer bestimmten Anzahl Dezimalstellen wird die verfügbare Genauigkeit überschritten:
$z = 4.4999999999999999; echo round($z, 0); Dieses Skript gibt »5« aus, was offensichtlich falsch ist. Berechnungen mit beliebiger Genauigkeit Das verwendete Modul trägt den Namen »bc« und liefert einige elementare Funktionen. Am Beginn steht die Festlegung der Anzahl Dezimalstellen, mit denen gerechnet werden soll. Die Anwendung zeigt das folgende Skript: Listing 4.19: Funktionen mit beliebiger Genauigkeit (math_bctest)
4.2 Praktische Mathematik ______________________________________________ 81 Das Skript führt eine Division mit einer Genauigkeit von 20 Stellen aus. Durch die provozierte Wahl der Operanden kann man den Effekt gut beobachten: Abbildung 4.14: Ausgabe des Skripts aus Listing 4.19 Sicher sind solche Fälle eher extreme Zustände. Wenn Sie jedoch den Verdacht haben, dass die interne Berechnung nicht ausreichend genau ist, beschäftigen Sie sich mit den Funktionen beliebiger Genauigkeit.
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
4.2 Praktische Mathematik ______________________________________________ 83
5 Komplexe Datenstrukturen: Arrays Zwischen Daten, wie sie in Variablen gespeichert werden, bestehen oft komplexe Beziehungen. Manchmal wäre es einfach nur praktisch, zusammengehörende Informationen auch gemeinsam ablegen zu können. Zu diesem Zweck sind Datenfelder entworfen worden – so genannte Arrays.
5
Komplexe Datenstrukturen: Arrays
5.1 Wie Arrays funktionieren ____________________________________________ 85
5.1
Wie Arrays funktionieren
Der Umgang mit Arrays erscheint, betrachtet man sich einfache Beispiele, unproblematisch. Trotzdem bergen sie einige Tücken, nicht zuletzt wegen der flexiblen Unterstützung in PHP5, die zu unsauberer Programmierung verleitet. Arrays sind Sammlungen von Daten unter einem gemeinsamen Namen. Ein leeres Array kann man in PHP folgendermaßen erzeugen:
$meinarray = array(); array ist eine Anweisung, die das erledigt. Arrays entstehen aber auch implizit, wenn man nicht existenten Elementen Werte zuweist. Die folgende Grafik zeigt, wie ein Array im einfachsten Fall aufgebaut ist. Jedes Element besteht aus einem Index (linke Spalte) und einem Datenwert (rechte Spalte). Abbildung 5.1: Aufbau eines einfaches Arrays
5.1.1
Eindimensionale Arrays
Im einfachsten Fall werden eindimensionale Arrays verwendet. Diese bestehen aus einer beliebigen Anzahl Elementen, die über einen numerischen Index angesprochen werden können. Der Index wird in eckigen Klammern angegeben, der Zugriff auf Elemente erfolgt ebenso:
Diese Skript erzeugt ein Array $plz mit drei Elementen. Das zweite Element wird anschließend ausgegeben: 12683. Der Datentyp der einzelnen Elemente muss dabei nicht identisch sein. Sie müssen sich über die Verwendung auch vorher keine Gedanken machen – jedenfalls ist das aus Sicht von PHP nicht notwendig. Betrachtet man dagegen Aspekte sauberer Programmierung, ist eine allzu verworrene innere Struktur eines Arrays nicht zu empfehlen. Prinzipiell kann ein Array aber alles enthalten, was auch eine normale Variable enthalten darf – einschließlich weiterer Arrays.
Listing 5.1: Ein einfaches Array anlegen (array_onedim)
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
86 _____________________________________ 5 Komplexe Datenstrukturen: Arrays Variablenauflösung mit Arrays Komplizierte Konstruktionen mit Array-Indizes kann PHP5 nicht immer korrekt innerhalb der automatischen Variablenerkennung auflösen. Gewöhnen Sie sich deshalb am besten gleich die Schreibweise mit Variablenkennzeichnung an, bei der der Ausdruck in geschweifte Klammern gesetzt wird: "Meine Postleitzahl lautet: {$plz[1]}". Solange Sie numerische Indizes verwenden, gibt es keine Besonderheiten. Folgendes funktioniert also problemlos:
echo “$arr[3]“; Mit assoziativen Arrays sieht es anders aus. Falsch ist diese Schreibweise:
echo “$arr[’test’]”; PHP erkennt den Indexwert nicht. Um das Problem zu lösen, gibt es eine besondere Syntax, die eine weitere Klammerform verwendet, um dem Parser den zur Variablen gehörenden Umfang mitzuteilen:
echo “{$arr[’test’]}”; Die geschweiften Klammern selbst werden nicht ausgeben. Sie sind nur zur Unterstützung des Parsers gedacht.
Der Wertebereich für Indizes Wenn kein Index angegeben wird, nimmt PHP den nächsten freien Wert. Der Wertebereich, der dafür zur Verfügung steht, reicht von 0 bis 232-1, das sind alle positiven Ganzzahlen. Nullbasierte Arrays
Arrays sind standardmäßig nullbasiert, das erste Element hat also den Index 0.
Andere Werte für die Index
Andere Werte werden als Schlüssel eines assoziativen Arrays interpretiert, was im nächsten Absatz erläutert wird. Das folgende Beispiel ist dem in Listing 5.1 gezeigten völlig gleichgestellt:
Listing 5.2: Array ohne Indexangabe erzeugen (array_onedim2)
Wenn Sie zwischendurch einen Indexwert selbst festlegen, wird dieser als Ausgangspunkt für die automatische Vergabe benutzt:
Listing 5.3: Indexreihenfolge beeinflussen (array_onedim3)
5.1 Wie Arrays funktionieren ____________________________________________ 87 Das Array $plz besteht nun aus drei Elementen mit den Indizes 0, 4 und 5. Wenn ein Index gezielt gesetzt wird, zählt PHP intern ab diesem Wert weiter. Mit jeder Zuweisung wird der Index um 1 erhöht. Die Ausgabe des Skripts aus Listing 5.3 lautet: 12459. Es ist generell eine gute Idee, die Indizes selbst zu vergeben und damit festzusetzen, wenn darauf später direkt Bezug genommen wird. Die folgenden Grafik zeigt den inneren Aufbau eines Arrays ohne fortlaufenden Index. In der linken Spalte stehen die Indizes. Zu sehen ist, dass PHP weder die fehlenden Werte auffüllt noch die Reihenfolge verändert. Abbildung 5.2: Arrays ohne fortlaufenden Index
Arrays wieder ausgeben Der Zugriff auf Elemente erfolgt mit Hilfe der Notation [index] hinter dem Variablennamen. Für die Ausgabe ganzer Arrays dagegen bieten sich verschiedene Schleifenanweisungen an. Das Ausgaben von Arrays ist indes nicht so schwer. Es gibt in PHP eine Ganze Arrays sehr gute Unterstützung. Am häufigsten wird die Schleifenanweisung ausgeben foreach verwendet. Diese durchläuft immer alle Elemente eines Arrays und gibt die Element in einer Variablen zurück:
= 10999; = 12683; = 12459; ($plz as $p) echo "$p
";
Grundsätzliche Aussagen zu foreach finden Sie in Abschnitt 6.3.4 Felder bestellen: foreach ab Seite 116. Hier wird die Sprachanweisung schon ohne weitere Erläuterung benutzt, um die Ausgabe der Arrays einfacher gestalten zu können. Die Schleife durchläuft alle Elemente und gibt diese untereinander aus. Die Anzahl spielt keine Rolle. Nur wenn die Variable $plz kein Array ist, wird ein Fehler ausgegeben. Falls der Index nicht der natürlichen Zahlenfolge entspricht, wären natürlich auch diese Angaben interessant. Erweitern Sie dann foreach folgendermaßen:
Listing 5.4: Ausgabe eines kompletten Arrays (array_foreach)
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
88 _____________________________________ 5 Komplexe Datenstrukturen: Arrays Listing 5.5: Array mit Indizes ausgeben (array_foreachi)
= 10999; = 12683; = 12459; ($plz as $i => $p) echo "[$i] $p
";
Der Operator => ist Bestandteil der foreach-Anweisung. Er dient der Trennung von Schlüssel und Werten eines assoziativen oder der Indizes eines numerischen Arrays. Abbildung 5.3: Ausgabe des Skripts aus Listing 5.5 Mehrere Werte zuweisen Umgang mit array Am Anfang wurde bereits die Erzeugung eines leeren Feldes mit array
angesprochen. Das ist sicher nur selten wirklich notwendig. Häufiger wird array eingesetzt, um gleich mehrere Werte zuzuweisen: Listing 5.6: Werte mit array zuweisen (array_array)
Wenn Sie nun, wie in Listing 5.7 gezeigt, andere Indizes wünschen, werden diese mit dem =>-Operator zugewiesen. Das sieht dann folgendermaßen aus:
Listing 5.7: Eigene Indizes mit array angeben (array_arrayi)
Beide Skripte geben »12683« aus.
5.1.2
Sprechende Indizes: Assoziative Arrays
Assoziative Arrays verwenden keinen numerischen Index, sondern Schlüssel. Dies sind Zeichenketten, die ein Element benennen. Manchmal wird ein solches Array auch als Hash bezeichnet. Abbildung 5.4: Aufbau eines assoziativen Arrays
5.1 Wie Arrays funktionieren ____________________________________________ 89
Jedem das Seine: Hashes und Arrays In PHP wird der Begriff »Hash« nicht explizit definiert, in anderen Programmiersprachen ist dies jedoch durchaus üblich. In PHP spricht man von assoziativen Arrays. In VBScript oder Visual Basic dagegen werden solche Felder als »Dictionaries« bezeichnet. Wie auch die Benennung erfolgt, das Prinzip ist dasselbe. Leider ist die Begriffsbestimmung offensichtlich nicht einfach, denn assoziative Arrays werden häufig mit mehrdimensionalen verwechselt – leider auch in der Fachliteratur zu PHP. Um es ganz klar herauszustellen: Assoziative Arrays sind nicht mehrdi- Assoziativ und mensional. Sehr wohl kann man aber beide Konzepte kombinieren. Dazu Mehrdimensional später mehr. Wenn Sie mehr Daten in einem Array speichern möchten, sind assoziative Arrays hilfreich. Das folgende Skript zeigt, wie die Daten eines Buches abgelegt werden.
Listing 5.8: Assoziatives Array erzeugen und ausgeben (array_assoziativ)
Die Indizes sind hier Zeichenketten, die den Zweck des Feldes klar hervorheben. Wenn Sie solche Arrays in Skripten sehen, sind diese bedeutend leichter zu lesen und zu warten. Abbildung 5.5: Ausgabe des Skripts aus Listing 5.8 Ebenso wie bei den vorangegangenen Beispielen können Sie statt der Anweisung array auch die Klammerschreibweise verwenden:
Listing 5.9: Verwendung der Klammerschreibweise (array_asso2)
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
90 _____________________________________ 5 Komplexe Datenstrukturen: Arrays Das Skript entspricht im Prinzip dem vorhergehenden. Die Lesbarkeit ist etwas besser, dafür ist der Schreibaufwand höher. Ansonsten entspricht die Ausgabe den bereits gezeigten Varianten. In den meisten Fällen dürfte die Benutzung von array sinnvoller und kompakter sein. Typische Fehlerquellen Häufig finden man auch die folgenden Schreibweisen:
$buch[titel] = 'PHP 5. Grundlagen und Profiwissen'; $buch = array(titel => 'PHP 5. Grundlagen und Profiwissen'); Das funktioniert zwar meistens, ist aber nicht korrekt. Denn hier wird eine Eigenschaft von PHP ausgenutzt, die Gefahren in sich birgt. Wenn PHP einen Ausdruck nicht auflösen kann, wie beispielsweise »titel«, dann wird dieser intern in eine Zeichenkette umgewandelt. Deshalb ist dies der Schreibweise aus Listing 5.9 äquivalent. Wenn Sie jedoch einen Namen als Index verwenden, den PHP kennt, wird ein Laufzeitfehler erzeugt – das Skript funktioniert plötzlich nicht mehr: Laufzeitfehler
Parse error: parse error, expecting `'('' in ... Schreiben Sie Indizes immer in Anführungszeichen, auch wenn Sie sicher sind, dass es ohne ebenso funktionieren würde. Wenn PHP in späteren Versionen die vermeintlich freien Namen als reserviert einführt, laufen Ihre Skripte sonst nicht mehr.
5.1.3
Mehrdimensionale Arrays
Wenn Sie mit einer Tabellenkalkulation wie Excel arbeiten, kennen Sie schon die Struktur eines zweidimensionalen Arrays. Eine Dimension erstreckt sich über die Spalten, die andere über die Zeilen. Jede Zelle enthält aber mehrere Informationen: Formel, aktueller Wert, Name für Bezüge und Formatierung für die Darstellung. Das kann man mit einer dritten Dimension abbilden. Stellen Sie sich jetzt vor, Sie haben mehrere Arbeitsblätter, die alle dieselbe Struktur aufweisen – das wäre dann schon die vierte Dimension. Der Zugriff auf mehrere Dimensionen erfolgt mit Hilfe von mehreren eckigen Klammern: Text in Zelle 0,0; Blatt 0
$tabelle[0][0][0][0] = 'Text in Zelle 0,0' $tabelle[0][0][0][1] = 'text' $tabelle[0][0][0][2] = 'Text in Zelle 0,0'
Zahl in Zelle 1,3; Blatt 1
$tabelle[1][1][3][0] = '34.5896999' $tabelle[1][1][3][1] = 'Währung' $tabelle[1][1][3][2] = 'DM 34.59' Wenn Sie jetzt entsetzt auf das Klammergrab schauen, müssen Sie nicht in Panik verfallen. Mehr als zwei Dimensionen benötigen Sie nur sehr, sehr selten. Wenn Sie keine passable Lösung mit zwei Dimensionen finden, ist vermutlich etwas an Ihrem Datenmodell falsch oder unglücklich formuliert. Denken Sie auch daran, dass solche Gebilde gigantische Datenmengen aufnehmen können. Wenn Sie sich 1 024 Zellen in Spalten-
5.1 Wie Arrays funktionieren ____________________________________________ 91 und Zeilenrichtung vorstellen, die jeweils 4 Eigenschaften haben und sich auf 8 Blätter verteilen können, stehen 1 024 x 1 024 x 4 x 8 Elemente zur Verfügung. Das sind schon 33 554 432 Einträge. Bei 10 Byte pro Eintrag benötigt dieses Array über 300 MByte. Haben Sie wirklich so viele Daten? Der gezeigte Fall ist extrem konstruiert – Tabellenkalkulationen baut man zum einen nicht mit PHP und zum anderen nicht mit Arrays. Aber denken Sie über die Datenmenge und die Verteilung in einem Array nach und entscheiden Sie dann, ob wirklich eine weitere Dimension nötig ist.
5.1.4
Mehrdimensionale Arrays verarbeiten
Für die Verarbeitung können Sie die bereits gezeigten Techniken verwenden. Lediglich die Anzahl der Klammerpaare erhöht sich mit jeder Dimension.
Listing 5.10: Erzeugen und ausgeben eines zweidimensionalen Arrays (array_multidim)
Hier wird ein Array $buch mit zwei Dimensionen erzeugt. Es enthält in der ersten Dimension zwei Elemente, in der zweiten dagegen drei (insgesamt also sechs). Die äußere Schleife durchläuft mit der Laufvariablen $k die erste Dimension. Die innere Schleife wird insgesamt zwei Mal angestoßen und arbeitet die jeweils die drei Werte der zweiten Dimension ab. Als Laufvariable kommt hier $i zum Einsatz. Beide Laufvariablen dienen als Index für die Ausgabe der Elemente:
echo "{$buch[$k][$i]}
"; Beachten Sie hier die Klammerung der Variablen! Hilfreich ist hier, wie auch bei den einfachen Arrays, die Funktion count, count mit der die Anzahl der Elemente ermittelt werden kann. Prinzipiell spricht aber auch hier nichts dagegen, mit foreach anstatt mit for zu arbeiten. Das folgende Skript zeigt dies:
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
92 _____________________________________ 5 Komplexe Datenstrukturen: Arrays Listing 5.11: Ausgabe des zweidimensionalen Arrays mit foreach (array_multidim2)
Beide Skripte erzeugen eine identische Ausgabe, wobei letzteres kompakter wirkt, weil auf die Ermittlung der Arraygrenzen mit count verzichtet werden konnte. Allerdings erlaubt der Zugriff auf die Laufvariablen manchmal elegante Lösungen.
Abbildung 5.6: Ausgabe der Skripte aus Listing 5.10 und Listing 5.11
Die folgende Abbildung zeigt den Aufbau des zuletzt verwendeten zweidimensionalen Arrays. Abbildung 5.7: Aufbau eines zweidimensionalen Arrays
Mehrdimensionalität und Assoziativität Statt der gezeigten numerischen Indizes können natürlich wieder Zeichenketten eingesetzt werden – so entstehen mehrdimensionale, assoziative Arrays. Das ist einer der häufigeren Einsatzfälle, auch wenn es kompliziert klingt. Das letzte Beispiel zeigt eine solche Kombination aus einem numerischen Array (1. Dimension) und einem assoziativen Array (2. Dimension). Neben der Klammerschreibweise eignet sich hier wieder die Anweisung array zum Erzeugen der Daten.
5.2 Die Arrayfunktionen ________________________________________________ 93
Listing 5.12: Zweidimensionales Array mit assoziativen Indizes (array_2dim)
Das Skript verwendet in der ersten Dimension des Arrays die intern generierten automatischen Indizes. In der zweiten wird dagegen auf eigene Indizes zurückgegriffen. Bildlich ist dies ein eindimensionales, numerisch indiziertes Array, dessen Elemente assoziative Arrays sind. Abbildung 5.8: Ausgabe des Skripts aus Listing 5.12
In PHP5 sind assoziative und mehrdimensionale Arrays praktisch äquivalent.
5.2
Die Arrayfunktionen
Die Arrayfunktionen in PHP sind sehr üppig und für nahezu jedes Problem existiert eine elegante Lösung. Mit jeder Version, auch mit PHP5, fanden neue Funktionen den Weg in die Sprache. Die folgende Tabelle gibt einen Überblick, sortiert nach Aufgabengebieten. Aufgabenstellung
Funktionsname
Suchen, Sortieren
array_multisort arsort asort krsort ksort rsort
Tabelle 5.1: Array-Funktionen sort uasort uksort usort in_array
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
94 _____________________________________ 5 Komplexe Datenstrukturen: Arrays Aufgabenstellung
Funktionsname
Auswerten
array_count_values count sizeof
array_sum array_walk
Umwandeln, Teilen, Zerlegen, Zusammensetzen
array_flip array_fill array_filter array_keys array_merge array_merge_recursive array_change_key_case array_diff_assoc array_diff array_intersec_assoc array_intersec
array_values shuffle extract compact array_map array_combine array_udiff_assoc array_udiff_uassoc array_udiff
Verändern
array_pad array_pop array_push array_reverse array_chunk array_shift
array_slice array_splice array_unshift array_reduce array_unique
Elemente auslesen
current each list next pos
prev reset key end
Erzeugen von Werten
array array_rand range
Informationen zu den einzelnen Funktionen finden Sie in der Referenz. Zu fast allen Arrayfunktionen sind interessante Beispielskripte zu finden. Die wichtigsten Methoden der Zugriffe werden in den folgenden Abschnitten dieses Kapitels noch exemplarisch vorgestellt. Probieren Sie die Beispiele aus, um ein Gefühl für den Umgang mit Arrays zu bekommen.
5.3
Zugriff auf Array-Elemente
Wenn Sie mit Arrays programmieren, ist der Zugriff auf bestimmte Elemente von großer Bedeutung. Die bisherigen Beispiele zeigten immer die Ausgabe des gesamten Arrays mit for oder foreach. Für den Zugriff auf bestimmte Teile eines Arrays oder die fallweise Abarbeitung stehen in PHP sehr viele Funktionen zur Verfügung.
5.3 Zugriff auf Array-Elemente __________________________________________ 95
5.3.1
Arrays durchlaufen
Wenn ein Array mit foreach durchlaufen wird, kümmert sich die An- Gezielt Elemente weisung selbst um das Auffinden des nächsten Elements. Wollen Sie eine auswählen andere Reihenfolge, hilft foreach nicht weiter – Änderungen der Arbeitsweise sind nicht möglich. PHP kennt aber andere Funktionen, die flexibler arbeiten. Dazu verwaltet PHP einen internen Zeiger auf jedes Array, der jeweils current auf ein Element zeigt – das aktuelle Element. Der Zugriff auf dieses aktuelle Element erfolgt mit current. Bewegen können Sie den Zeiger vom ersten Element aus gesehen nach next vorn mit next. Zurück geht es mit prev. Beide Funktionen reagieren prev nicht, wenn die Grenzen des Array überschritten werden. Erst ein nachfolgender Zugriff mit current führt zu einem Laufzeitfehler – der Zugriff geht dann ins Leere. Um den Zeiger wieder an den Anfang zu setzen, verwenden Sie reset. reset Analog existiert auch eine Funktion end. end Abbildung 5.9: Arbeitsweise der Arrayfunktionen
Die Grafik zeigt, wie die Funktionen wirken. Ausgehend vom aktuellen Element mit dem Index 3 stehen die Funktionsnamen neben dem Element, auf das der Arrayzeiger nach seiner Ausführung zeigt.
5.3.2
Mit Arrays spielen
Wenn die Daten erst mal im Array sind, können Sie diese vielfältig ma- array_walk nipulieren. Eine erste Funktion, die PHP-Neulinge dabei entdecken ist array_walk. Diese Funktion durchläuft jedes Element eines Arrays und führt mit diesem eine benutzerdefinierte Funktion aus. Damit lassen sich natürlich alle Arrayprobleme lösen. Es ist jedoch ein typischer Designfeh-
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
96 _____________________________________ 5 Komplexe Datenstrukturen: Arrays ler von PHP-Skripten, bereits vorhandene Funktionen »neu zu erfinden«. Das wichtigste Element in der Hand des Entwicklers ist dann auch nicht das Regal voller Bücher, sondern eine gute Referenz. Eigenschaften ermitteln Wenn Sie dazu die Anzahl der Elemente bestimmen müssen, setzen Sie die Funktion count ein. Beim Umgang mit Arrays ist auch is_array von Bedeutung. Mit dieser Funktion kann überprüft werden, ob eine Variable ein Array ist. unset eignet sich, um gezielt ein Element eines Arrays zu entfernen. Alle Elemente dahinter rutschen eine Position nach unten, sodass count nun ein Element weniger zählt. Daten wieder herausgeben list each
Listing 5.13: Arrays konventionell auslesen (array_while)
Für die Ausgabe eines Array bietet PHP5 ein spezielles Sprachelement, das bereits an einigen Stellen im Buch verwendet wurde: foreach. Es geht aber auch anders. Möglicherweise verleiht Ihnen diese Methode eine größere Flexibilität. Verwendet wird ein while-Schleife:
"> Ihre Dateiauswahl:
Das Skript prüft zuerst, ob tatsächlich Dateien abgesendet wurde, das heißt, die Absende-Schaltfläche angeklickt wurde.
if (isset($_POST['upload'])) Dann werden Daten zur aktuellen Datei ausgegeben. Hier wird sowohl auf das Array $_FILES als auch auf die automatisch generierten Variablen zugegriffen. Das Array enthält in der ersten Dimension den Namen des File-Feldes aus dem Formular. Benennen Sie mehrere solcher Felder unterschiedlich, stehen diese dann hier unter den entsprechenden Namen bereit.
echo echo echo echo
'Informationen zur aktuellen Datei:
'; $_FILES['userfile']['name'] . '
'; $_FILES['userfile']['size'] . ' Byte
'; $_FILES['userfile']['type'] . '
';
Dann wird der Pfad berechnet, unter dem die Daten abgespeichert werden. Es wird hier angenommen, dass das Zielverzeichnis mit dem Namen upload eine Ebene unterhalb des Skripts liegt.
$path = dirname($_SERVER['SCRIPT_FILENAME']) . '/upload/'; Jetzt wird die Datei aus dem temporären Verzeichnis ins Ziel kopiert. Die Funktion move_uploaded_file sorgt dafür, das wirklich nur hochgeladene Dateien kopiert werden. Sie arbeitet ansonsten wie die Funktion copy. Die Einschränkung auf hochgeladene Dateien reduziert das Sicherheitsrisiko in schlampig programmierten Skripten. Denken Sie außerdem daran, dass der Webserver Schreibrechte in diesem Verzeichnis benötigt.
move_uploaded_file ($_FILES['userfile']['tmp_name'], "$path{$_FILES['userfile']['name']}"); Es folgt noch die Ausgabe aller bereits hochgeladenen Verzeichnisse mit Hilfe der in diesem Kapitel bereits vorgestellten Verzeichnis- und Datei-
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
212 __________________________ 9 Daten aus dem Browser: Formulare und Links funktionen. Der reguläre Ausdruck unterdrückt die Anzeige der virtuellen Verzeichnisse ».« und »..«.
$dp = opendir($path); Beim ersten Aufruf des Skripts erfolgt noch ein Test, ob das entsprechenden Verzeichnis »upload« vorhanden ist. Ist das nicht der Fall, wird das Verzeichnis automatisch erzeugt:
if ($dp === FALSE) { mkdir('upload'); $dp = opendir($path); } Dann geht es mit der Anzeige des Verzeichnisinhalts weiter:
echo ''; while ($file = readdir($dp)) { if (!preg_match('/^\.{1,2}/', $file)) { echo $file; echo ' (' . filesize("upload/$file") . ' Byte)'; echo '
'; } } MIME-Typen
Die MIME-Typen, die das Skript anzeigt, werden vom Webserver erzeugt. Wenn hier nicht der erwartete Typ erscheint oder die Angabe sogar leer bleibt, konsultieren Sie die Dokumentation ihres Webservers, wie MIME-Typen eingerichtet werden können. Jeder Webserver bietet entsprechende Einstellmöglichkeiten. Beim Provider sollten die gängigen Typen bereits vorhanden sein.
Abbildung 9.5: Erfolgreicher Upload
Besonderheiten des Dateihochladens Der Umgang mit dem Hochladen ist eigentlich sehr einfach. Beachten Sie einige Dinge, ist der umfangreiche Einsatz nicht schwer. • Umgang mit den temporären Dateien PHP legt die empfangenen Dateien im temporären Verzeichnis des Servers ab. Dort steht die Datei nur bis zum Ende des Skripts, dass die Anforderung empfangen hat – also die Formulardaten verarbei-
9.2 Daten per URL weiterreichen ________________________________________ 213 tet. Danach wird die temporäre Datei gelöscht, auch wenn diese noch nicht bearbeitet wurde. Es ist also unbedingt notwendig, vor allen anderen Aktionen den Kopiervorgang auszuführen und die Datei zu retten. • Zu große Dateien Sehr große Dateien werden erst übertragen und dann – nach der Analyse im temporären Verzeichnis, gelöscht. Wenn move_uploaded_file mit einem Fehler abbricht, dass die Dateigröße 0 Byte war, dann wurde in der Regel die maximale Dateigröße überschritten. Wenn Sie im Formular keine Angabe dazu machen, liegt dies möglicherweise an restriktivere Einstellungen des Providers.
9.2
Daten per URL weiterreichen
Neben POST wird auch die Methode GET zum Übertragen von Daten verwendet – durch Anhängen der Werte an den URL. Dieser Abschnitt beschreibt, wie Sie Skripte per Hyperlink »verbinden«.
9.2.1
Wie werden Daten weitergereicht?
Jeder Link, den ein Nutzer anklicken kann, eignet sich auch zur Weiterleitung von Daten. Es ist Sache des Skripts, dass aufgerufen wird, die Daten auszuwerten. Damit ist auch klar, dass die Übertragung von Daten an HTML-Seiten zwar theoretisch möglich, aber völlig sinnlos ist – HTML kann dies nicht auswerten. Dieser direkte Zugriff erfolgt mittels entsprechend gestalteter Links:
Sprung Drei spezielle Zeichen finden dabei Verwendung. Das Trennzeichen ? zwischen URL und Daten ist das Fragezeichen (?). Die Trennung der & einzelnen Variablen-/Wertepaare ist das Ampersand (&). Die Trennung = innerhalb der Paare erfolgt mittels Gleichheitszeichen (=). Beachten Sie, dass Browser nur ca. 2 000 Zeichen akzeptieren, einschließlich URL. Größere Datenmengen können nur mit Formularen übertragen werden. Eine Extrahierung der Daten ist ebenso wie bei den Formularen nicht $_GET notwendig. Alle Daten stehen wieder in einem speziellen Array zur Verfügung – passend zur gewählten Methode mit dem Namen $_GET. Eine typische Anwendung zeigen die folgenden beiden Skripte:
Willkommen im Buchladen
Der Unbesiegbare
Der Schnupfen
Listing 9.6: Übertragung von Daten per Hyperlink (getform)
V V V 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C D E
214 __________________________ 9 Daten aus dem Browser: Formulare und Links Sterntagebücher
Eden
Im Beispiel werden Artikeldaten in einer Variablen $artikel verpackt und mit dem Link an die aufgerufene Seite übergeben, das Skript getanswer.php, das in Listing 9.7 zu finden ist. Listing 9.7: Antwort zu Listing 9.6: Die Variable $artikel wird automatisch aus der URL extrahiert (getanswer)
Was haben Sie bestellt? Sie haben das Buch
von Stanislaw Lem bestellt. Vielen Dank! Das war sicher sehr einfach. Praktisch werden solche Weitergaben sehr häufig eingesetzt. Oft dienen Bilder als Schaltflächen und es ist dann einfacher, mit -Tags zu arbeiten anstatt mit Formularen.
Kritische Benennung der Variablen
Kritisch ist die Verwendung von beliebigen Namen, weil die Werte eventuell im Konflikt mit anderen stehen können. In der Konfiguration kann festgelegt werden, in welcher Reihenfolge PHP die Werte aus Formularen, URLs und Cookies übernimmt. Unabhängig davon ist es eine gute Idee, eindeutige Namen zu verwenden. Beispielsweise könnten Sie Linkvariablen immer mit dem Präfix »url_« belegen, Cookies dagegen mit »coo_«, Formulare mit »frm_«. Kodierung von Daten Solange Sie nur Artikelnummern übertragen, wird diese Form problemlos funktionieren. Betrachten Sie das folgende Beispiel aufmerksam:
Ihr Name? Wenn der Eintrag »Ihr Name?« beispielsweise aus einem Formular übernommen wurde, kann das Skript nicht richtig funktionieren. Leerzeichen sind an dieser Stelle nicht zulässig. Die Daten müssen also auf ein Format gebracht werden, in dem die Sonderzeichen (? & =) tatsächlich als Sonderzeichen erkannt werden.
9.2 Daten per URL weiterreichen ________________________________________ 215
Über die Codierung von Daten Ein URL darf nur aus Buchstaben, Zahlen und dem Minuszeichen bestehen. Alle anderen Zeichen haben eine spezielle Bedeutung. Da oft auch andere Daten übertragen werden sollen, müssen diese codiert werden. Vergessen Sie das, werden Daten verfälscht oder gelöscht – man spricht üblicherweise von »unvorhersagbaren« Ergebnissen. Mit urlencode ersetzen Sie diese Zeichen durch die Zeichenfolge %HH, wobei HH den Hexcode des betreffenden Zeichens im ASCII-Zeichensatz darstellt. urldecode wandelt eine so kodierte URL wieder zurück. Wenn Sie eine URL bilden, schreiben Sie deshalb besser folgenden Code:
$coded = urlencode($email); Dann setzen Sie den Wert in den Link ein:
echo ""; echo "Ihr Name?"; Wenn Sie für den Text der Variablen folgende Zeichen einsetzen,
$email = "Jörg's E-Mail?"; finden Sie im Quelltext diese Form:
J%F6rg%27s+E-Mail%3F Die ersetzten Zeichen wurden für den Satz hervorgehoben. Das Leerzeichen wird durch ein Pluszeichen ersetzt, das Pluszeichen durch den entsprechenden ASCII-Code. Hier folgt nun das Listing: