PHP is about as exciting as your toothbrush. You use it every day, it does the job, it is a simple tool, so what? Who would want to read about toothbrushes? – Rasmus Lerdorf
17 Webserveranwendungen
Das Grundprinzip von Webserveranwendungen ist immer dasselbe: Wenn ein Benutzer eine bestimmte URL anfordert, die auf einen Teil einer solchen Anwendung verweist, liefert der Webserver nicht einfach ein fertiges Dokument aus. Stattdessen startet er irgendeine Art von Programm, das aus einer Vorlage und variablen Daten on-the-fly eine Webseite erstellt, und liefert diese dynamisch erzeugte Seite an den Browser des Besuchers aus.
Bei dem Programm, das der Webserver aufruft, kann es sich je nach verwendeter Server-Lösung um ein externes Programm handeln, das separat gestartet wird, oder aber um ein Modul des Webservers selbst. Letzteres ist erheblich effizienter – der Webserver kann die Anfrage selbst bearbeiten und muss kein separates Programm starten. Bedenken Sie, dass bei einem externen Programm für jeden Aufruf ein neuer Prozess gestartet wird, was bei vielen zeitgleichen Benutzern zu erheblichen Engpässen führen kann.
In diesem Kapitel wird zuerst die beliebte Webserver-Programmiersprache PHP vorgestellt. Da größere Webanwendungen so gut wie immer auf einer Datenbank basieren, wird zusätzlich die Zusammenarbeit mit dem Datenbankserver MySQL beschrieben. Im zweiten Abschnitt erhalten Sie eine kompakte Praxiseinführung in das moderne Web-Framework Ruby on Rails. Zum Schluss wird dann ein Schnellüberblick über einige weitere Technologien für serverseitige Webanwendungen geliefert, einschließlich integrierter Lösungen wie etwa Content-Management-Systemen.
17.1 PHP 
Die Sprache PHP ist eines der beliebtesten Werkzeuge zur Erstellung dynamischer Webinhalte für kleine und mittlere Websites. Der Name dieser 1995 von Rasmus Lerdorf unter der ursprünglichen Bezeichnung Personal Homepage Tools entwickelten Server-Skriptsprache steht inzwischen für das rekursive Akronym PHP:Hypertext Preprocessor.
Die Sprache ist für viele verschiedene Plattformen wie Windows und etliche UNIX-Varianten verfügbar. Besonders verbreitet ist die Kombination aus dem Betriebssystem Linux, dem Webserver Apache, der freien Datenbank MySQL und der Programmiersprache PHP (manchmal auch Perl oder Python) – kurz einem LAMP-System. Unter dem Betriebssystem Windows wird dieselbe Softwarekombination WAMP genannt. Wie Sie PHP in Ihrem Apache-Webserver installieren, wird in Kapitel 12, Server für Webanwendungen, beschrieben.
17.1.1 Sprachgrundlagen 
Der PHP-Interpreter akzeptiert gewöhnliche HTML-Dateien, in denen speziell markierte PHP-Abschnitte verarbeitet und durch ihre Ausgabe ersetzt werden. Sie müssen also kein HTML ausgeben, sondern können PHP-Anweisungen an die passende Stelle des HTML-Dokuments schreiben. Da dies bei umfangreicheren PHP-Anwendungen unübersichtlich werden kann, sollten Sie in diesem Fall aber Gebrauch von den weiter unten vorgestellten Include-Dateien machen.
Der PHP-Code wird in einen Bereich hineingeschrieben, der folgendermaßen gekennzeichnet wird:
<?php // PHP-Anweisungen ?>
Ein solcher Bereich kann an einer beliebigen Stelle im HTML-Dokument stehen, sogar innerhalb von HTML-Tags oder ihren Attributwerten. Außerdem können sich HTML- und PHP-Blöcke an einer beliebigen Stelle und selbst innerhalb derselben Zeile abwechseln. Konstrukte wie das folgende sind ohne Weiteres möglich und können sehr praktisch sein:
<?php if ($punkte > 100) { ?> <h2>Herzlichen Glückwunsch!</h2> <?php } else { ?> <h2>Sie sollten noch üben!</h2> <?php } ?>
Dieses Beispiel gibt die Überschrift »Herzlichen Glückwunsch!« aus, falls die Variable $punkte einen höheren Wert als 100 hat, ansonsten den Text »Sie sollten noch üben!«. Die folgende Schreibweise ist synonym, aber unhandlicher:
<?php if ($punkte > 100) { echo "<h2>Herzlichen Glückwunsch!</h2>"; } else { echo "<h2>Sie sollten noch üben!</h2>"; } ?>
Der Sprachkern von PHP wurde stark von Programmiersprachen wie C und Perl inspiriert. PHP ist ursprünglich eine prozedurale Sprache, wurde aber in neueren Versionen um objektorientierte Merkmale erweitert.
Wie die meisten anderen Skriptsprachen ist PHP nicht typisiert, eine Variable kann also nacheinander Werte beliebiger Datentypen annehmen. Grundlegende Kontrollstrukturen wie Fallunterscheidungen und Schleifen funktionieren genau wie in C und in allen davon abgeleiteten Sprachen.
Variablenbezeichner beginnen grundsätzlich mit einem $-Zeichen. Anders als in Perl gibt es keine besonderen Zeichen, die Arrays oder Hashes kennzeichnen. Hinter dem $ können Buchstaben, Ziffern und Unterstriche folgen; das erste Zeichen darf allerdings keine Ziffer sein. Es wird zwischen Groß- und Kleinschreibung unterschieden.
Funktions- und Klassennamen kommen dagegen ohne Dollar-Zeichen aus, abgesehen davon werden Groß- und Kleinschreibung weder bei selbst definierten noch bei eingebauten Funktions- und Klassennamen unterschieden. Allerdings wäre es sehr schlechter Programmierstil, dies auszunutzen. Üblicherweise sollten Sie Funktionsbezeichner mit kleinem und Klassennamen mit großem Anfangsbuchstaben schreiben.
Variablendefinition und -verwendung
Eine Variable wird in PHP durch die erste Wertzuweisung (Initialisierung) erzeugt. Wertzuweisungen sehen genauso aus wie in den meisten anderen Programmiersprachen:
$test = 9; $text = "hallo";
In dem Moment, in dem einer Variablen zum ersten Mal ein Wert zugewiesen wird, existiert sie. Eine Deklaration im eigentlichen Sinn gibt es nicht.
Variablen haben in PHP auch keinen festgelegten Datentyp. Sie können einer Variablen nacheinander verschiedene Arten von Werten zuweisen, zum Beispiel:
$a = 5; // Ganzzahl $a = 3.78; // Fließkommazahl $a = "hi"; // String
Mitunter werden die Werte von Variablen in einem neuen Zusammenhang automatisch anders interpretiert. Hier sehen Sie zwei Beispiele:
$b = "67"; // String, wegen Anführungszeichen $c = $b + 9; // Ergebnis: 76 $a = 22; // Ganzzahl $b = $a . "33"; // "2233"
Operatoren
Genau wie in Perl ist der Verkettungsoperator für Strings der Punkt (.) und nicht das in Java und JavaScript verwendete Pluszeichen, das häufig wegen der Verwechslung mit der numerischen Addition Ärger bereitet. Die meisten anderen Operatoren entsprechen ebenfalls ihrer Verwendung in Perl. Der einzige wichtige Unterschied zu Perl besteht darin, dass Strings in PHP mit den normalen Vergleichsoperatoren wie ==, != oder <= verglichen werden und nicht mit speziellen Operatoren. Genaueres über die Perl-Operatoren finden Sie in Kapitel 8, Grundlagen der Programmierung.
Variablen gelten in PHP ab dem Zeitpunkt ihrer Wertzuweisung im gesamten Dokument. Es gibt keine untergeordneten Gültigkeitsbereiche innerhalb von Blöcken wie Fallunterscheidungen oder Schleifen. Die Ausnahme bilden Variablen, die innerhalb der weiter unten behandelten Funktionen definiert werden. Sie sind lokal und gelten nur innerhalb der jeweiligen Funktion.
Arrays
Wie in den meisten anderen Programmiersprachen gibt es auch in PHP die Möglichkeit, Arrays zu bilden. Ein Array ist eine Variable, die eine Liste von Werten enthält, auf die über einen Index zugegriffen werden kann. PHP unterscheidet nicht grundsätzlich zwischen einem gewöhnlichen Array mit numerischen Indizes und einem Hash, bei dem die Indizes Strings sind. In jedem Array können beide Indexarten gleichzeitig existieren.
Um ein klassisches Array mit numerischen Indizes zu erzeugen, genügt es, einem einzelnen Element dieses Arrays einen Wert zuzuweisen:
$monate[0] = "Januar";
Mithilfe der eingebauten Funktion array() können Sie auch gleich ein numerisches Arrays mit mehreren Elementen erzeugen:
$jahreszeiten = array ("Fruehling", "Sommer", "Herbst", "Winter");
Besonders interessant ist im Übrigen die Tatsache, dass Sie leere eckige Klammern statt eines konkreten Indexes verwenden können, um ein Element am Ende des Arrays anzufügen:
$wochentage[] = "Sonntag"; $wochentage[] = "Montag"; // und so weiter
Über die Funktion array_push($array, $wert1, $wert2, ...) können Sie aber auch eine Liste mehrerer Elemente am Ende des Arrays einfügen. Umgekehrt liefert die Funktion array_pop($array) das letzte Element des Arrays zurück und entfernt es aus dem Array.
Hash- Funktio- nalität
Um einen Hash oder assoziatives Array zu erzeugen, können Sie ebenfalls mit der Zuweisung des Wertes für ein einzelnes Element beginnen:
$monate['jan'] = "Januar";
Möchten Sie die Werte mehrerer Elemente gleichzeitig zuweisen, so funktioniert dies mithilfe der folgenden Form der Funktion array():
$wochentage = ('So' => "Sonntag", 'Mo' => "Montag", 'Di' => "Dienstag", 'Mi' => "Mittwoch", 'Do' => "Donnerstag", 'Fr' => "Freitag", 'Sa' => "Samstag");
Die Verwendung einfacher Anführungszeichen für die Indizes und doppelter für die Werte ist nicht vorgeschrieben, aber eine gängige Konvention. Wie in Perl werden innerhalb doppelter Anführungszeichen Variablen und alle üblichen Esacpe-Sequenzen ausgewertet, innerhalb von einfachen aber nicht (lediglich \' für ein einzelnes Anführungszeichen als solches und \\ für einen Backslash werden erkannt):
$geld = 100;
echo ("Ich habe $geld \$."); // Ausgabe: Ich habe 100 $. echo ('Ich habe auch $geld $.'); // Ausgabe: Ich habe auch $geld $.
Die Funktion sizeof($array) liefert die Anzahl der Elemente im Array zurück. Auf diese Weise können Sie alle Elemente eines numerischen Arrays in einer Schleife ausgeben, zum Beispiel folgendermaßen:
$zimmer = array("Wohnzimmer", "Schlafzimmer", "Kinderzimmer", "Arbeitszimmer"); $zahl = sizeof($zimmer); for ($i = 0; $i < $zahl; $i++) { echo($zimmer [$i]."<br />"); }
Das kleine Beispiel gibt untereinander die Bezeichnungen der vier Zimmer aus. Bei Hashes sollten Sie dagegen eine andere Methode verwenden, die Elemente aufzuzählen: Die Funktion each($array) gibt bei jedem Aufruf das nächste Schlüssel-Wert-Paar zurück. Dieses Paar können Sie mithilfe von list() einer Liste aus zwei Variablen zuweisen. Das Ganze funktioniert so:
$rechner = array ('cpu' => "Intel Core 2 Duo", 'ram' => "2048 MB DDR2 RAM", 'hdd' => "Maxtor 500 GB", 'dvd' => "16xDVD / 52xCD"); reset ($rechner); // Sicherheitshalber auf Anfang while (list ($key, $val) = each ($rechner)) { echo ("$key: <b>$val</b><br />"); }
Noch klarer und einfacher sind foreach-Schleifen, die für die beiden Arrays wie folgt aussehen:
foreach ($zimmer as $z) { echo($z); } foreach ($rechner as $key => $val) { echo ("$key: <b>$val</b><br />"); }
Strings zerlegen
Interessant ist auch noch die Funktion explode(). Sie funktioniert nach folgendem Schema:
$array = explode ($muster, $string);
Die Funktion zerlegt den String $string an den Stellen, an denen $muster vorkommt, in die einzelnen Elemente des Arrays $array. Zum Beispiel:
$string = "a,b,c,d"; $array = explode (",", $string); /* $array[0] ist "a" $array[1] ist "b" $array[2] ist "c" $array[3] ist "d" */
Wenn Sie statt eines einfachen Strings einen regulären Ausdruck als Trennzeichen angeben möchten, müssen Sie die Anweisung split() statt explode() verwenden.
Die umgekehrte Aufgabe erledigt die Funktion implode(), die die Elemente eines Arrays – getrennt durch das angegebene Muster – zu einem String zusammenfasst:
$string = implode ($muster, $array);
Hier sehen Sie ein Beispiel:
$array = array ("So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"); $string = implode (", ", $array); // $string ist "So, Mo, Di, Mi, Do, Fr, Sa";
Mehrdimensionale Arrays
Auch mehrdimensionale Arrays sind kein Problem. Das folgende Beispiel definiert die Variable $jahr als Aufzählung der Jahreszeiten mit ihren Monaten:
$jahr = array ( 'fruehling' => array("März", "April", "Mai"), 'sommer' => array("Juni", "Juli", "August"), 'herbst' => array("September", "Oktober", "November"), 'winter' => array("Dezember", "Januar", "Februar") );
Wenn Sie nun beispielsweise auf den zweiten Monat im Sommer zugreifen möchten, können Sie die Schreibweise $jahr['sommer'][1] verwenden – die Rückgabe lautet natürlich »Juli«.
Perl-kompatible reguläre Ausdrücke
Beinahe der gesamte in Kapitel 9, Konzepte der Programmierung, beschriebene Perl-Komfort für reguläre Ausdrücke steht erfreulicherweise auch in PHP zur Verfügung. Die Syntax der regulären Ausdrücke selbst ist praktisch identisch, allerdings unterscheidet sich ihre Handhabung ein wenig, da PHP mit konventionellen Funktionen statt mit seltsamen Sonderzeichen operiert.
Matching
Die Funktion preg_match($regexp, $string) überprüft, ob der reguläre Ausdruck $regexp auf den String $string passt. Das folgende Beispiel gibt eine Meldung aus, falls $eingabe nicht komplett aus Ziffern besteht:
if (preg_match ("/\D/", $eingabe)) { echo ("Dies ist keine Zahl!"); }
Innerhalb der String-Anführungszeichen steht der reguläre Ausdruck zwischen zwei // (Slashes). Hinter dem schließenden Slash können – wie in Perl – Modifikatoren stehen. Der wichtigste ist i, um Unterschiede zwischen Groß- und Kleinschreibung zu ignorieren. Das folgende Beispiel sucht nach PHP in beliebiger Schreibweise:
if (preg_match ("/php/i", $eingabe)) { echo ("PHP gefunden!"); } else { echo ("PHP nicht vorhanden!"); }
Ersetzen
preg_replace ($regexp, $ersatz, $string[, $limit]) ersetzt den regulären Ausdruck $regexp in $string durch den Ersatztext $ersatz. Normalerweise wird jedes Vorkommen von $regexp ersetzt; der optionale Parameter $limit gibt die maximale Anzahl von Ersetzungen an. Die folgende Anweisung ersetzt in $eingabe jedes Vorkommen von »Perl« in beliebiger Schreibweise durch »PHP«:
$eingabe = preg_replace ("/perl/i", "PHP", $eingabe);
Mithilfe von $n (mit n-Werten zwischen 0 und 99) können Sie sich im Ersatztext auf geklammerte Ausdrücke aus dem regulären Ausdruck beziehen. Das folgende Beispiel fügt an den korrekten Stellen einer alten, zehnstelligen ISBN die Bindestriche ein:
$isbn = preg_replace ("/(\d)(\d{5})(\d{3})(\d)/", "$1-$2-$3-$4", $isbn);
Aus 3836210150 (der unformatierten ISBN des vorliegenden Buches) würde so beispielsweise 3–83621-015-0.
In PHP-Versionen vor 4.0 musste der Bezug auf geklammerte Ausdrücke durch \\n statt $n dargestellt werden. Diese Option wird zwar nach wie vor unterstützt, aber nicht mehr empfohlen.
Kommentare
PHP unterstützt drei Arten von Kommentaren, um es Programmierern leicht zu machen, die verschiedene Sprachen beherrschen. Als Erstes wird der einzeilige Kommentar im C++-Stil unterstützt:
// einzeiliger Kommentar
Dabei wird der Rest der Zeile ignoriert. Auch der mehrzeilige Kommentar im C-Stil ist erlaubt:
/* mehr- zeiliger Kommentar */
Hier werden alle betroffenen Zeilen ignoriert. Schließlich ist auch noch der einzeilige Kommentar im Stil von Perl und der UNIX-Shell-Sprachen zulässig:
# einzeiliger Kommentar
Funktionen
Eine PHP-Funktion ist ein benannter Codeblock, der mit seinem Namen aufgerufen wird. Ständig wiederkehrende Anweisungsfolgen in Funktionen zu verpacken, schafft Übersicht und schont Ressourcen, da eine Funktion innerhalb eines Skripts nur einmal kompiliert wird. Sie sollten Funktionen in einem PHP-Block zu Beginn Ihres Dokuments unterbringen oder sie in einer externen Include-Datei (wird weiter unten beschrieben) speichern. Die allgemeine Syntax ist einfach:
function funktionsname() { // Anweisungen ... }
Nach Ausführung der letzten Anweisung wird die Kontrolle an die aufrufende Stelle zurückgegeben. Wie bereits erwähnt, können Funktionen lokale Variablen enthalten: Jede Variable, die in einer Funktion verwendet wird, ist lokal – sogar dann, wenn im globalen Code eine gleichnamige Variable existiert. Betrachten Sie etwa den Wert der beiden Variablen namens $a im folgenden Beispiel:
function a_aendern() { $a = 9; // lokales $a hat den Wert 9. } $a = 7; // globales $a hat den Wert 7. a_aendern(); // $a hat hier wieder den Wert 7.
Zugriff auf globale Variablen
Möchten Sie innerhalb einer Funktion auf eine globale Variable zugreifen, so müssen Sie am Anfang der Funktion ausdrücklich das Schlüsselwort global verwenden. Hier sehen Sie das Beispiel von oben noch einmal, allerdings wird innerhalb der Funktion auf die globale Variable $a zugegriffen:
function a_aendern() { global $a; $a = 9; // globales $a hat nun den Wert 9. } $a = 7; // globales $a hat den Wert 7. a_aendern(); // $a hat jetzt den Wert 9.
Eine Funktion kann Parameter entgegennehmen. Zu diesem Zweck müssen Sie bei der Definition die Namen der gewünschten Parametervariablen in den Klammern des Funktionskopfes angeben:
function top_cell ($inhalt) { echo ("<td valign=\"top\">$inhalt</td>"); }
Diese Funktion gibt den übergebenen Wert, der in der Parametervariablen $inhalt gespeichert wird, als Tabellenzelle mit der häufig verwendeten vertikalen Ausrichtung oben aus. Parametervariablen haben innerhalb der Funktion dieselbe Bedeutung wie lokale Variablen – der Standardfall beim Funktionsaufruf ist in PHP der Call by Value, das heißt die Übergabe eines Wertes ohne Rückbezug auf die aufrufende Stelle. Betrachten Sie dazu das folgende Beispiel:
function halbieren ($wert) { $wert /= 2; } $zahl = 9; // $zahl hat den Wert 9. halbieren ($zahl); // $zahl hat weiterhin den Wert 9.
Sie können Parametern Standardwerte zuweisen, um sie optional zu machen. Beim Aufruf können sie dann von rechts an weggelassen werden. Hier eine Variante der Tabellenzellen-Ausgabe, bei der Sie sich die vertikale Ausrichtung aussuchen können; "top" ist Standard:
function table_cell ($inhalt, $valign = "top") { echo ("<td valign=\"$valign\">$inhalt</td>"); }
Eine oben ausgerichtete Zelle können Sie dabei ohne Angabe des zweiten Arguments erzeugen:
table_cell ("Oben ausgerichtet");
Es schadet aber auch nichts, den Wert "top" dennoch anzugeben:
table_cell ("Explizit oben ausgerichtet", "top");
Referenzübergabe
Falls Sie stattdessen einen Call by Reference benötigen, das heißt, den Wert der Variablen verändern möchten, mit der die Funktion aufgerufen wird, müssen Sie der entsprechenden Parametervariablen bei der Funktionsdefinition ein &-Zeichen voranstellen. Wenn Sie die Funktion halbieren() folgendermaßen umschreiben, wird $zahl also tatsächlich halbiert:
function halbieren (&$wert) { $wert /= 2; } $zahl = 10; // $zahl hat den Wert 10. halbieren ($zahl); // $zahl hat nun selbst den Wert 5.
Beachten Sie bei einem Call by Reference, dass Sie der Funktion eine Variable übergeben müssen. Ein konstanter Wert ist nicht gestattet und erzeugt eine Fehlermeldung.
Wertrückgabe
Eine Funktion kann auch einen Wert zurückgeben, sodass Sie das Ergebnis an der aufrufenden Stelle in einem Ausdruck einsetzen können. Dafür ist die Anweisung return zuständig. Sie verlässt die Funktion sofort und gibt den entsprechenden Wert zurück. Hier ein Beispiel:
function verdoppeln ($wert) { return $wert * 2; }
Wenn Sie diese Funktion aufrufen, wird der Wert des übergebenen Arguments verdoppelt. Der fertig berechnete Ausdruck wird anschließend zurückgegeben. Sie können einen Aufruf dieser Funktion in einem beliebigen Ausdruck verwenden. Bevor dieser Ausdruck ausgewertet wird, erfolgt die Ausführung der Funktion, und es wird mit dem zurückgegebenen Wert weitergerechnet. Beispiel:
echo (verdoppeln ($zahl));
Diese Anweisung gibt den doppelten Wert der Variablen $zahl aus.
Die folgende Funktion zieht die n-te Wurzel aus einer Zahl. Wird der zweite Parameter weggelassen, wählt sie die Quadratwurzel (zweite Wurzel) als Standard:
function wurzel($zahl, $n = 2) { return pow($zahl, 1 / $n); }
Probieren Sie die Funktion aus, indem Sie zum Beispiel die zweite und die dritte Wurzel aus 64 ziehen:
w2 = wurzel(64); // ergibt 8 w3 = wurzel(64, 3); // ergibt 4
Beachten Sie, dass eine Funktion mehrere return-Anweisungen enthalten kann, die von Fallentscheidungen abhängen. Sie benötigen noch nicht einmal else-Blöcke für solche if-Anweisungen, weil return die Ausführung der Funktion unmittelbar beendet. Die folgende Funktion macht sich das zunutze, um einen übergebenen Ausdruck daraufhin zu überprüfen, ob er ein Integer zwischen 1 und 4 ist:
function antworttest($antwort) { if (!is_int ($antwort)) { return false; } if ($antwort < 1 || $antwort > 4) { return false; } // An dieser Stelle kann $antwort nur OK sein. return true; }
In dem Beispiel wird als Erstes überprüft, ob $antwort überhaupt ein Integer ist – falls nicht, wird sofort false zurückgegeben. Anschließend wird geprüft, ob $antwort außerhalb des zulässigen Bereichs liegt – in diesem Fall erfolgt ebenfalls die Rückgabe von false. Wenn keine der beiden if-Abfragen zutrifft, wird automatisch false zurückgegeben.
Datentypen testen
Die verwendete eingebaute Funktion is_int() liefert übrigens true zurück, wenn es sich bei dem übergebenen Wert um einen Integer handelt, andernfalls false. In PHP stehen eine Reihe solcher Funktionen zur Verfügung, um die Datentypen von Ausdrücken zu testen, beispielsweise is_string(), is_float(), is_array() oder is_null(), die das übergebene Argument daraufhin überprüfen, ob es ein String, eine Fließkommazahl, ein Array beziehungsweise leer ist.
Eine ähnliche Aufgabe erfüllen die Funktion isset() beziehungsweise isunset(), die überprüfen, ob eine Variable überhaupt jemals definiert wurde. Mithilfe der Anweisung unset() können Sie PHP sogar anweisen, eine Variable vollständig zu vergessen.
17.1.2 Klassen und Objekte
Auch wenn PHP ursprünglich als prozedurale Skriptsprache entwickelt wurde, unterstützt sie seit der Version 4 eine einfache Art der Objektorientierung, die in PHP 5 nochmals erweitert wurde. Sie können Klassen mit Eigenschaften, Methoden und Konstruktoren definieren und voneinander ableiten. Wenn Sie mit diesen Grundbegriffen der Objektorientierung nichts anfangen können, lesen Sie bitte die Abschnitte Java und/oder Ruby in Kapitel 8, Grundlagen der Programmierung.
Das folgende Beispiel definiert eine Klasse namens Table, die verschiedene Methoden zur Ausgabe von HTML-Tabellenelementen enthält, definiert ein Objekt dieser Klasse und ruft die entsprechenden Methoden auf:
class Table { function tab_start($border = 0) { echo "<table border=\"$border\">\n"; } function tab_end() { echo "</table>\n"; } function tr_start() { echo "<tr>\n"; } function tr_end() { echo "</tr>\n"; } function td($content, $align = "left", $valign = "top") { echo ("<td align=\"$align\" valign=\"$valign\">$content</td>\n"); } } $tab = new Table(); $tab->tab_start (2); $tab->tr_start(); $tab->td ("Linke Zelle"); $tab->td ("Rechte Zelle"); $tab->tr_end(); $tab->tab_end();
Klassen definieren
Wie Sie im Beispiel sehen, wird eine Klasse mit dem Schlüsselwort class deklariert. Die Methoden sind einfache Funktionen, die in den Block der Klasse hineinverschachtelt werden. Ein Objekt einer Klasse wird über den Operator new erzeugt und ruft, falls vorhanden, den Konstruktor der Klasse auf (siehe unten). Der Zugriff auf Methoden und Eigenschaften eines Objekts erfolgt mithilfe des Operators ->.
Das Beispiel erzeugt die folgende HTML-Ausgabe:
<table border="2"> <tr> <td align="left" valign="top">Linke Zelle</td> <td align="left" valign="top">Rechte Zelle</td> </tr> </table>
Als Eigenschaften einer Klasse gelten automatisch alle Variablen, die in der Klasse, aber nicht innerhalb einer Methode definiert werden. Aus einer Methode heraus wird das Schlüsselwort $this verwendet, um auf Eigenschaften zuzugreifen. Das folgende Beispiel zeigt den Umgang mit einer Eigenschaft:
class Test { var $wert = 0; function setWert($wert) { $this->wert = $wert; } function getWert() { return $this->wert; } } $obj = new Test(); $obj->setWert(2); echo($obj->getWert());
Zunächst wird die Variable $wert deklariert und mit dem Wert 0 initialisiert. Die Methode setWert() ändert sie auf einen von außen angegebenen Wert. getWert() gibt den Inhalt von $wert dagegen zurück. Beachten Sie, dass der Variablenname hinter $this und dem Zugriffsoperator -> nicht mit einem weiteren Dollarzeichen versehen wird.
Falls Sie einen expliziten Konstruktor definieren möchten: Es handelt sich um eine Funktion mit dem speziellen Namen __construct() – mit zwei Unterstrichen. [In PHP 4 wurde dagegen eine Funktion mit dem Namen der Klasse verwendet. Wenn Sie Anwendungen schreiben möchten, die abwärtskompatibel zu Version 4 sind, können Sie zusätzlich eine solche Funktion schreiben, die __construct() explizit aufruft. ] Innerhalb des Konstruktors werden typischerweise Initialisierungsarbeiten vorgenommen, die zu Beginn des Lebenszyklus eines Objekts notwendig sind. Insbesondere können die übergebenen Parameter als Anfangswerte für die Attribute des Objekts gesetzt werden. Die folgende verbesserte Fassung der Klasse Table definiert die wichtigsten Tabellen- und Zelleneigenschaften durch einen Konstruktoraufruf und stellt Methoden bereit, um die Zelleneinstellungen nachträglich zu ändern:
class Table { // Eigenschaften deklarieren (optional): var $bgcolor, $border, $align, $valign; // Konstruktor: function __construct($bg = "#FFFFFF", $b = 0, $a = "center", $va = "left") { $this->bgcolor = $bg; $this->border = $b; $this->align = $a; $this->valign = $va; } function tab_start() { echo "<table border=\"{$this->border}\" bgcolor=\"{$this->bgcolor}\">\n"; } function tab_end() { echo "</table>\n"; } function tr_start() { echo "<tr>\n"; } function tr_end() { echo "</tr>\n"; } function td($content) { echo "<td align=\"{$this->align}\" valign=\"{$this->valign}\">$content</td>\n"; } function setAlign($a) { $this->align = $a; } function setVAlign($va) { $this->valign = $va; } } $tab = new Table("#CCCCCC", 2); $tab->tab_start(); $tab->tr_start(); $tab->td("Normale<br/>Zelle"); $tab->setVAlign("bottom"); $tab->td("Inhalt unten"); $tab->tr_end(); $tab->tab_end();
Die HTML-Ausgabe dieses Beispiels sieht so aus:
<table border="2" bgcolor="#CCCCCC"> <tr> <td align="left" valign="top">Normale<br />Zelle</td> <td align="left" valign="bottom">Inhalt unten</td> </tr> </table>
Innerhalb von doppelten Anführungszeichen können Sie bei der Funktion echo() einen Ausdruck in geschweifte Klammern setzen, damit er ausgewertet und ausgegeben wird. Ein komplexer Ausdruck wie $this->valign könnte ohne dieses Hilfsmittel nicht innerhalb eines Ausgabestrings verwendet werden.
Vererbung
Die Vererbung funktioniert in PHP, ähnlich wie in Java, mithilfe des Schlüsselworts extends. Das folgende Beispiel leitet von der Klasse Table die Klasse FixedTable ab, deren Breite und Höhe zusätzlich angegeben werden können:
class FixedTable extends Table { // Neue Eigenschaften deklarieren: var $width, $height; // Konstruktor: function __construct($w, $h, $bg = "#FFFFFF", $b = 0, $a = "left", $va = "top") { $this->width = $w; $this->height = $h; // Konstruktor der Elternklasse aufrufen parent::__construct($bg, $b, $a, $va); } // Überschriebene Methode: function tab_start() { $t = "<table border=\"{$this->border}\" bgcolor=\"{$this->bgcolor}\" width=\"{$this->width}\" height=\"{$this->height}\""; echo $t; } } $ftab = new FixedTable("100%", "100%", "#FFFF00", 2); $ftab->tab_start(); $ftab->tr_start(); $ftab->td("Hallo"); $ftab->td("Welt!"); $ftab->tr_end(); $ftab->tab_end();
Beachten Sie, dass der Konstruktor einer abgeleiteten Klasse nicht automatisch den Kostruktor der Elternklasse aufruft. Im obigen Beispiel wird er explizit als parent::__construct() aufgerufen, um die Eigenschaften zu setzen, die bereits in der übergeordneten Klasse existieren.
Include-Dateien
Damit die Objektorientierung ihren Hauptnutzen entfalten kann, nämlich den der einfachen Wiederverwendbarkeit von Code, sollten Sie die Klassendefinitionen in externe Dateien schreiben, die Sie zur Laufzeit importieren können. Eine externe Datei besitzt meist die doppelte Dateiendung .inc.php (obwohl dies für ihr Funktionieren keine Rolle spielt) und wird mithilfe der Anweisung include() importiert. Auch in einer solchen Include-Datei muss PHP-Code innerhalb eines Blocks der Form <?php ... ?> stehen, um ausgeführt zu werden, andernfalls wird der Inhalt als HTML-Code interpretiert. Die include()-Anweisung selbst funktioniert folgendermaßen:
include ("extern.inc.php");
Falls sich die Datei in einem anderen Verzeichnis befindet als das PHP-Skript, muss nach der üblichen URL-Logik der Pfad angegeben werden.
17.1.3 Webspezifische Funktionen
Die Hauptaufgabe von PHP ist das Erstellen dynamischer Webanwendungen. Zu diesem Zweck werden eine Reihe spezieller Funktionen und Fähigkeiten angeboten. Dazu gehören das Auslesen von Formulardaten, das Erzeugen und Lesen von Cookies oder auch das Session-Tracking. Letzteres steuert eine Funktionalität bei, die HTTP von Hause aus nicht besitzt: Es ermöglicht das Verfolgen der Aktivitäten eines Benutzers über mehrere besuchte Seiten hinweg. Dies ist wichtig für Warenkorbsysteme oder andere Anwendungen, bei denen eine Reihe aufeinander folgender Aktivitäten registriert werden muss.
Formulardaten auslesen
HTML-Formulare wurden im vorigen Kapitel vorgestellt. In PHP stehen empfangene Formulardaten je nach Methode in einem der beiden Arrays $_GET oder $_POST zur Verfügung. Ein name=wert-Paar aus dem Formular wird dabei als $_GET['name'] beziehungsweise $_POST['name'] angesprochen.
Betrachten Sie als Beispiel das folgende kurze Formular:
<form action="auswert.php" method="get"> Name: <input type="text" name="user" /><br /> E-Mail: <input type="text" name="mail" /><br /> <input type="submit" value="Abschicken" /> </form>
Klickt ein Benutzer den Button Abschicken an, wird das PHP-Skript auswert.php aufgerufen. Da die HTTP-Methode GET ausgewählt wurde, befinden sich die Formulardaten in dem Array $_GET. Der folgende Codeblock liest sie und gibt sie anschließend aus:
$user = $_GET['user']; $mail = $_GET['mail']; echo ("Hallo $user.<br />"); echo ("Bestätigung geht an $mail.");
Hilfsfunktion cgi_param()
Sicherer ist es, wenn Sie zuerst überprüfen, ob die gewünschten Formularfelder überhaupt Daten enthalten. Da leere Felder in älteren PHP-Versionen einfach als leere Strings erscheinen, in neueren aber als undefiniert gelten – die Funktion isset() liefert false –, sollten Sie beides prüfen. Aus alldem ergibt sich folgende praktische Funktion, die Sie am besten in jedes PHP-Skript einbauen oder per include() laden sollten:
function cgi_param ($feld, $default = "") { // Variable zunächst auf Default-Wert setzen $var = $default; if (isset($_GET['$feld'] && $_GET['$feld'] != "") { $var = $_GET['$feld']; } elseif (isset($_POST['$feld'] && $_POST['$feld'] != "") { $var = $_POST['$feld']; } // Ermittelten Wert zurückgeben return $var; }
Die Funktion erwartet als Parameter den Namen des auszulesenden Feldes sowie optional einen Default-Wert, der geliefert wird, falls das Feld nicht verfügbar oder leer ist. Die beiden Felder aus dem obigen Formularbeispiel lassen sich mithilfe dieser Funktion folgendermaßen lesen:
// User auslesen, Standardwert "Anonymous" $user = cgi_param ("user", "Anonymous"); // E-Mail auslesen, Standardwert "" (automatisch) tipp_li$mail = cgi_param ("mail");
Schreiben Sie diese Funktion einfach in einen PHP-Block am Beginn jeder Datei, die Formulardaten auslesen muss, oder speichern Sie sie in einer Include-Datei.
Datei-Uploads
Bereits im vorigen Kapitel haben Sie das spezielle HTML-Formularfeld kennengelernt, das Benutzern den Versand einer lokalen Datei mit dem Formular ermöglicht. Es handelt sich um ein <input>-Element mit dem Attribut type="file". Damit der Upload funktionieren kann, muss das Formular mit der HTTP-Methode POST und der speziellen MIME-Codierung multipart/form-data versandt werden. PHP verarbeitet optional ein zusätzliches Formularfeld mit der Bezeichnung MAX_FILE_SIZE, das die maximal zulässige Dateigröße in Byte enthält und meist als Hidden-Formularfeld gesetzt wird. Sollte der angegebene Wert größer sein als die php.ini-Einstellung upload_max_filesize (siehe oben), wird er ignoriert.
Das folgende Beispiel definiert ein Formular für den Versand einer GIF-Bilddatei (dies wird erst auf dem Server geklärt!) von maximal 400 Kilobyte Größe:
<form action="bildupload.php" method="post" enctype="multipart/form-data"> <input type="hidden" name="MAX_FILE_SIZE" value="409600" /> Bitte eine GIF-Bilddatei wählen:<br /> <input type="file" name="bild" /> <br /> <input type="submit" value="Abschicken" /> </form>
Die Datei lässt sich in PHP über das globale Array $_FILES auslesen; der Index ist der Feldname. Das entsprechende Array-Element ist wiederum ein Array mit folgenden Elementen:
- tmp_name: der temporäre Dateiname, unter dem der Server die hochgeladene Datei gespeichert hat,
- type: der MIME-Type der Datei (aus der Dateiendung oder aus dem Content-Type-Header des Formularabschnitts ermittelt),
- size: Größe der Datei oder 0 bei einem Fehler,
- name: ursprünglicher Pfad und Dateiname der Datei auf dem Client-Rechner,
- error: Fehlercode bei einem Upload-Fehler. Seit PHP 4.3.0 sind die angegebenen symbolischen Konstanten definiert, in früheren Versionen nur die in Klammern angebenen numerischen Werte:
 |
UPLOAD_ERR_OK (0): kein Fehler, |
| |
UPLOAD_ERR_INI_SIZE (1): Datei ist größer als die in php.ini angegebene Höchstgrenze upload_max_filesize, |
| |
UPLOAD_ERR_FORM_SIZE (2): Datei ist größer als die mit dem Formular übertragene Höchstgrenze MAX_FILE_SIZE, |
| |
UPLOAD_ERR_PARTIAL (3): Die Datei wurde nur zum Teil hochgeladen, |
| |
UPLOAD_ERR_NO_FILE (4): Es wurde gar keine Datei hochgeladen. |
Das folgende PHP-Fragment kopiert die hochgeladene Datei unter dem Namen bild.gif in das Verzeichnis des Skripts selbst, falls es sich um eine Bilddatei vom Typ GIF handelt:
if (is_uploaded_file($_FILES['bild']['tmp_name'])) { if ($_FILES['bild']['type'] == 'image/gif') { move_uploaded_file ($_FILES['bild']['tmp_name'], "bild.gif"); } else { echo ("Falscher Dateityp!<br />"); } } else { echo ("Upload-Fehler (Datei zu groß)?<br />"); }
Sessions
Eines der interessantesten Web-Features von PHP ist das Session-Tracking. HTTP ist ein zustandsloses Protokoll, das heißt, jede Client-Anfrage steht für sich allein. Für größere Webanwendungen, die sich über viele Seiten erstrecken, wird deshalb ein Verfahren zur Datenweitergabe an nachfolgende Anfragen benötigt. PHP stellt sehr praktische Funktionen zur Verwaltung von Session-Daten bereit.
Beachten Sie, dass Sie Session-Befehle in einen PHP-Block zu Beginn Ihres Skripts setzen müssen: Session-Daten werden als Cookies übertragen, wenn der Client dies zulässt, ansonsten über eine Session-ID im Query-String. Beides erfordert, dass das eigentliche geparste Dokument noch nicht begonnen hat, sodass mit dem ersten Zeichen Ihres Skripts die Sequenz <?php einsetzen muss.
Jedes Skript, das auf Session-Daten zugreifen soll, muss zunächst folgende Anweisung enthalten:
session_start();
Anschließend können Sie das spezielle Array $_SESSION mit Name-Wert-Paaren bestücken oder Werte von einer zuvor besuchten Seite daraus lesen. Aus dem soeben erwähnten Grund muss das Lesen vor dem Schreibzugriff erfolgen:
// Stückzahl auslesen $stueckzahl = $_SESSION ['stueck']; // GET-Formularfeld zahlungsart auslesen $zahlungsart = $_GET ['zahlungsart']; // Zur zukünftigen Verwendung in Session speichern* $_SESSION ['zahlungsart'] = $zahlungsart;
Cookies
Für die meisten Anwendungen ist die Verwendung von Session-Daten gegenüber Cookies vorzuziehen. Der einzige Nachteil von Sessions besteht darin, dass die Daten beim nächsten Besuch eines Benutzers nicht mehr zur Verfügung stehen. Dies lässt sich oft durch die Speicherung der Daten in einer Datenbank und eine persönliche Anmeldung beheben.
Dennoch gibt es Fälle, in denen Cookies praktischer sind. Es kann für einen Besucher unter Umständen nützlich sein, Einstellungen, die er auf einer Seite vorgenommen hat, beim nächsten Besuch wieder vorzufinden. Sie sollten allerdings niemals eine Webanwendung programmieren, die von Cookies abhängt: Aufgrund des Missbrauchs, der häufig zu Werbe- und Usertracking-Zwecken mit Cookies getrieben wird, schalten viele Benutzer sie generell ab.
In PHP wird ein Cookie mithilfe der folgenden Funktion gesetzt:
setcookie ($name, $wert[, $verfallsdatum[, $pfad [, $domain[, $secure]]]])
Hier eine Übersicht über die Parameter:
- $name. Der Name des Cookies, über den es später wieder abgefragt werden kann.
- $wert. Der Wert, den Sie für den entsprechenden Namen festlegen möchten.
- $verfallsdatum. Der Verfallszeitpunkt für das Cookie in Sekunden seit EPOCH. Sie können einfach time() + $sekundenzahl verwenden, da die Funktion time() den aktuellen Zeitpunkt in diesem Format liefert. Lassen Sie diesen Wert weg, so erzeugen Sie automatisch ein Session-Cookie, das nur während der aktuellen Client-Sitzung gilt.
- $pfad. Der URL-Pfad, unter dem das Cookie zur Verfügung steht.
- $domain. Die Domain, unter der das Cookie gültig ist.
- $secure. Wenn Sie diesen Wert auf 1 setzen, wird das Cookie nur über eine gesicherte HTTPS-Verbindung übertragen.
Wie bereits erwähnt, werden Cookies als HTTP-Header gesetzt. Deshalb muss dieser Befehl – genau wie die Session-Anweisungen – vor jeglichem HTML-Code in der PHP-Datei stehen. Die folgende Anweisung setzt ein sieben Tage gültiges Cookie namens lastvisit, dessen Wert die aktuelle Uhrzeit ist:
setcookie ("lastvisit", time(), time() + 7 * 24 * 60 * 60);
Die Cookies, die der Client bei der Anfrage mitgeschickt hat, können Sie aus dem globalen Array $_COOKIE lesen. Dieses Beispiel liest das Cookie lastvisit und speichert seinen Wert in einer gleichnamigen Variablen:
$lastvisit = $_COOKIE['lastvisit'];
Diese Variable lässt sich im weiteren Verlauf des Skripts etwa so verwenden:
$lastvisitformat = date ("d.m.Y, H:i", $lastvisit); echo ("Ihr letzter Besuch: $lastvisitformat <br />");
Die Funktion date ($format, $sek_seit_epoch) erzeugt formatierte Datumsangaben. Im Formatstring können unter anderem folgende Komponenten vorkommen:
- j ist der Tag im Monat.
- d steht ebenfalls für den Tag, gibt ihn allerdings zweistellig an (aus 9 wird etwa 09).
- w gibt den Wochentag als Zahlenwert an, wobei 0 für Sonntag steht, 1 für Montag, bis 6 für Samstag.
- n ist der numerisch angegebene Monat.
- m ist noch einmal die Nummer des Monats, aber zweistellig.
- y gibt das zweistellige Jahr an.
- Y bedeutet ebenfalls das Jahr, allerdings vierstellig.
- G ist die Stunde im 24-Stunden-Format.
- H ist ebenfalls die Stunde im 24-Stunden-Format, jedoch mit erzwungener Zweistelligkeit.
- i gibt die Minuten zweistellig an.
- s steht für die zweistelligen Sekunden.
17.1.4 Zugriff auf MySQL-Datenbanken
Es gibt drei verschiedene PHP-Schnittstellen für den Zugriff auf MySQL-Datenbanken: die klassische mysql-Schnittstelle, die neuere Entwicklung mysqli und die Abstraktionsschicht PHP Data Objects (PDO). mysqli und PDO existieren nur in PHP 5 und arbeiten nur mit MySQL ab Version 4.1 zusammen. Diese Einführung beschränkt sich auf die Gegenüberstellung von mysql und mysqli.
Eine Testdatenbank
Die nachfolgenden einfachen MySQL-Beispiele beziehen sich alle auf eine kleine Datenbank namens programmiersprachen, in der eine einzige Tabelle mit dem Namen sprachen enthalten ist. Die Felder dieser Datenbanktabelle sehen Sie in Tabelle 17.1.
Damit die Beispiele nicht allzu umfangreich werden, ist die Tabelle sehr einfach gehalten.
| Feldbezeichnung | Datentyp |
|
id |
int, auto_increment, Primärschlüssel |
|
name |
varchar(30) |
|
architektur |
enum('imperativ', 'oop', 'sonstige') |
|
implementierung |
enum('Compiler', 'Interpreter', 'VM', 'Mischform') |
|
systeme |
set('Unix', 'Windows', 'sonstige') |
|
kurzinfo |
varchar(255) |
|
jahr |
year |
Sie können diese Tabelle mit phpMyAdmin oder einem anderen grafischen Datenbankverwaltungstool anlegen. Alternativ können Sie die mysql-Konsole öffnen (siehe Kapitel 11, Datenbanken) und nacheinander folgende SQL-Befehle eintippen (die Ausgabe des Clients wurde hier weggelassen):
mysql> create database programmiersprachen; mysql> use programmiersprachen mysql> create table sprachen ( -> id int auto_increment, -> name varchar(30), -> architektur enum('imperativ', 'oop', -> 'sonstige'), -> implementierung enum('Compiler', 'Interpreter', -> 'VM', 'Mischform'), -> systeme set('Unix', 'Windows', 'sonstige'), -> kurzinfo varchar(255), -> jahr year, -> primary key(id), -> index(name) -> );
create database und create table sind SQL-Standardbefehle zum Erzeugen einer neuen Datenbank beziehungsweise Tabelle; use <Datenbank> ist dagegen ein interner Befehl des MySQL-Clients, der zur Auswahl der gewünschten Datenbank verwendet wird.
Als Nächstes benötigt die Datenbank einige Beispielinhalte. Sie können entweder die Werte aus Tabelle 17.2 übernehmen oder Ihre eigenen benutzen.
| Name | Arch. | Impl. | Systeme | Kurzinfo | jahr |
|
C |
imperativ |
Compiler |
UNIX, Windows |
Älteste weit verbreitete Sprache; Syntax in vielen Sprachen verbreitet |
1970 |
|
C++ |
oop |
Compiler |
UNIX, Windows |
Weiterentwicklung von C mit OOP-Fähigkeiten |
1983 |
|
Java |
oop |
VM |
UNIX, Windows |
OOP-Sprache mit Multi-Plattform-VM |
1995 |
|
C# |
oop |
Mischform |
Windows |
Sprache für die CLR des .NET-Frameworks |
2000 |
|
Perl |
imperativ |
Interpreter |
UNIX, Windows |
Beliebte Skriptsprache für Admin- und Textbearbeitungsaufgaben; neuere Versionen bieten (umständliche) OOP. |
1987 |
|
Ruby |
oop |
Interpreter |
UNIX, Windows |
Skriptsprache mit fast allen Perl-Features sowie sauberer, moderner OOP-Implementierung |
1993 |
Verwenden Sie am besten einen grafischen Client, um die Beispielwerte einzugeben. Manuelle INSERT-Abfragen gemäß der Anleitung in Kapitel 11, Datenbanken, sind ebenfalls möglich, aber recht aufwendig und fehlerträchtig. Alternativ können Sie auch die Datei mksprachen.sql aus der Listing-Sammlung zu diesem Kapitel (http://buecher.lingoworld.de/fachinfo/listings/kap17.html) ausführen. Dies funktioniert im MySQL-Kommandozeilen-Client beispielsweise folgendermaßen:
mysql> source mksprachen.sql
Die mysql-Schnittstelle
Hier wird zunächst einmal die Vorgehensweise für die klassische Schnittstelle vorgestellt; weiter unten lernen Sie dieselben Anweisungen für mysqli kennen.
Als Erstes müssen Sie eine Verbindung zum MySQL-Server herstellen. Dies funktioniert mithilfe der klassischen Schnittstelle schematisch so:
$connID = mysql_connect ($host[, $user[, $passwort]]);
Angenommen, der Datenbank-Server läuft auf demselben Host wie der Webserver, der Benutzername ist dbuser und das Passwort geheim. Dann wird der Befehl folgendermaßen aufgerufen:
$connID = mysql_connect ("localhost", "dbuser", "geheim");
Sie sollten es bei einem Produktivsystem dringend vermeiden, anonyme Zugriffe auf den Datenbank-Server zuzulassen. Es sollte also keine Webanwendung geben, bei der ein Zugriff auf MySQL ohne Benutzername und Passwort möglich ist.
Die Verbindungskennung $connID ist übrigens im Erfolgsfall ein positiver Integer, andernfalls erhält die Variable den Wert 0. Deshalb könnte die konkrete Verwendung folgendermaßen aussehen:
$connID = mysql_connect ("localhost", "dbuser", "geheim"); if ($connID) { // Datenbankverarbeitung ... } else { echo("Fehler: Kein Datenbankzugrif möglich! <br />"); }
Als Nächstes müssen Sie die Datenbank auswählen, auf die zugegriffen wird. Dies geschieht mit dem Befehl mysql_select_db(). Der erste Parameter ist der Name der gewünschten Datenbank. Optional können Sie die Verbindungskennung angeben – dies ist aber nur erforderlich, falls mehrere Datenbankverbindungen bestehen. Beispiel:
mysql_select_db ("programmiersprachen"); // Falls mehrere Datenbankverbindungen geöffnet sind: mysql_select_db ("programmiersprachen", $connID);
Nun können Sie der Datenbank SQL-Abfragen senden. Dies geschieht mithilfe der Funktion mysql_query ($abfrage[, $connID]). Die Verbindungskennung braucht auch hier wieder nur angegeben zu werden, falls Sie mehrere Datenbankverbindungen gleichzeitig verwenden. Der Rückgabewert ist eine Ergebnis-Kennung, deren Inhalt Sie mit weiteren Funktionen auslesen können, oder false, wenn die Abfrage fehlschlägt. Im letzteren Fall liefert die Funktion mysql_error() eine Fehlerbeschreibung.
Hier ein Beispiel für eine Auswahlabfrage: Sie wählt alle Programmiersprachen aus, deren Name mit »C« beginnt:
$result = mysql_query("SELECT name, architektur, implementierung, systeme, kurzinfo, jahr FROM sprachen WHERE name LIKE 'C%'");
Die einzelnen Zeilen des Ergebnisses lassen sich mithilfe von mysql_fetch_row($result) oder mysql_fetch_array($result) auslesen. Trotz der unterschiedlichen Bezeichnungen liefern beide ein Array. Der Unterschied ist, dass die Indizes bei mysql_fetch_row() numerisch und bei mysql_fetch_array() die eigentlichen Feldnamen sind. Sie können beide Funktionen in einer while()-Schleife aufrufen, weil sie false zurückgeben, falls kein weiterer Datensatz mehr vorhanden ist. Hier ein Beispiel für mysql_fetch_row():
echo("<table border=\"2\">"); echo("<tr><th>Sprache</th>"); echo("<th>Architektur</th>"); echo("<th>Implementierung</th>"); echo("<th>Systeme</th>"); echo("<th>Kurzinfo</th>"); echo("<th>Erscheinungsjahr</th></tr>"); while ($record = mysql_fetch_row ($result)) { $name = $record[0]; $arch = $record[1]; $impl = $record[2]; $syst = $record[3]; $info = $record[4]; $jahr = $record[5]; echo("<tr><td>$name</td>"); echo("<td>$arch</td>"); echo("<td>$impl</td>"); echo("<td>$syst</td>"); echo("<td>$info</td>"); echo("<td>$jahr</td></tr>"); } echo("</table>");
Eine kürzere Fassung lässt sich mithilfe der Funktion list() erreichen, die die Elemente eines Arrays einer Liste von Einzelvariablen zuweisen kann:
while (list($name, $arch, $impl, $syst, $info, $jahr) = mysql_fetch_row($result)) { echo("<tr><td>$name</td>"); echo("<td>$arch</td>"); echo("<td>$impl</td>"); echo("<td>$syst</td>"); echo("<td>$info</td>"); echo("<td>$jahr</td></tr>"); }
Mit mysql_fetch_array() sieht der relevante Ausschnitt der while()-Schleife dagegen so aus:
while ($record = mysql_fetch_array ($result)) { $name = $record['name']; $arch = $record['architektur']; $impl = $record['implementierung']; $syst = $record['systeme']; $info = $record['kurzinfo']; $jahr = $record['jahr']; // ... wie gehabt ... }
Bei den unterschiedlichen Arten von Änderungsabfragen (UPDATE, INSERT, DELETE und REPLACE) gibt es natürlich kein Ergebnis in Form zurückgegebener Datensätze. Stattdessen können Sie über die Funktion mysql_affected_rows() erfahren, wie viele Datensätze geändert (beziehungsweise hinzugefügt oder gelöscht) wurden. Beispiel:
// Neue Sprache hinzufügen $name = "Python"; $arch = "oop"; $impl = "Interpreter"; $syst = "Unix,Windows"; $info = "Objektorientierte Skriptsprache"; $jahr = 1990; $result = mysql_query ("INSERT INTO sprachen (name, architektur, implementierung, systeme, kurzinfo, jahr) VALUES (NULL, '$name', '$arch', '$impl', '$syst', '$info', '$jahr')"); // Hat es funktioniert? if (mysql_affected_rows() == 1) { echo ("Sprache erfolgreich hinzugefügt. <br />"); } else { echo ("Sprache konnte nicht eingefügt werden. <br />"); }
Wenn Sie eine Abfrage durchführen, die besonders viele Datensätze liefert, sollten Sie anschließend den Speicher leeren, den das Ergebnis belegt hat:
mysql_free_result ($result);
Zum Schluss sollten Sie die Datenbankverbindung ordnungsgemäß schließen:
mysql_close ($connID); // $connID entfällt, wenn eindeutig
Die mysqli-Schnittstelle
Die neuere Datenbankschnittstelle mysqli kann sowohl prozedural als auch objektorientiert verwendet werden. Wenn Sie die prozedurale Schreibweise verwenden, unterscheiden sich ihre Funktionen nicht sehr stark von der gerade vorgestellten klassischen Schnittstelle mysql. Der objektorientierte Zugriff ist zu bevorzugen. Hier wird für jede Verbindung ein eigenes mysqli-Objekt erzeugt, dessen Methoden und Eigenschaften Sie für die Datenbankoperationen einsetzen können.
Hier sehen Sie das gesamte Beispiel: Auslesen aller mit »C« beginnenden Sprachen und Hinzufügen einer neuen – in objektorientierter mysqli-Syntax. Die ausführlichen Kommentare erläutern die Unterschiede:
// Datenbankverbindung herstellen, // Standarddatenbank wählen // (nun in einem Schritt) $conn = new mysqli ("localhost", "dbuser", "geheim", "programmiersprachen"); // Abfragen sind Instanzmethoden // des mysqli-Objekts $result = $conn->query("SELECT name, architektur, implementierung, systeme, kurzinfo, jahr FROM sprachen WHERE name LIKE 'C%'"); echo("<table border=\"2\">"); echo("<tr><th>Sprache</th>"); echo("<th>Architektur</th>"); echo("<th>Implementierung</th>"); echo("<th>Systeme</th>"); echo("<th>Kurzinfo</th>"); echo("<th>Erscheinungsjahr</th></tr>"); // Das Auslesen der Datensätze ist // eine Instanzmethode des Result-Objekts while (list($name, $arch, $impl, $syst, $info, $jahr) = $result->fetch_row()) { echo("<tr><td>$name</td>"); echo("<td>$arch</td>"); echo("<td>$impl</td>"); echo("<td>$syst</td>"); echo("<td>$info</td>"); echo("<td>$jahr</td></tr>"); } echo("</table>"); // Neuen Datensatz einfügen $name = "PHP"; $arch = "oop"; $impl = "Interpreter"; $syst = "Unix,Windows"; $info = "Objektorientierte Web-Skriptsprache"; $jahr = 1995; mysql_query ("INSERT INTO sprachen (name, architektur, implementierung, systeme, kurzinfo, jahr) VALUES (NULL, '$name', '$arch', '$impl', '$syst', '$info', '$jahr')"); // Hat es funktioniert? // (affected_rows ist nun eine Eigenschaft // des mysqli-Objekts) if (mysql_affected_rows() == 1) { echo ("Sprache erfolgreich hinzugefügt. <br />"); } else { echo ("Sprache konnte nicht eingefügt werden. <br />"); } // Verbindung schließen $conn->close();
