Computer

Elektronik

Uni

Fun

Links

Impressum
Kontakt

PHP-Tutorial

Dieses PHP-Tutorial ist für meine Schwester Astrid, damit sie auch den PHP Hypertext Preprocessor beherrscht (um Rekursion zu verstehen, muss man Rekursion verstehen). Als Referenzquelle ist Dokumentation auf php.net zu verwenden.

Erste Schritte mit PHP

PHP ist eine Skript-Sprache. Das heißt, zur richtigen Zeit kommt ein Programm daher und führt genau das aus, was man ihm über PHP-Code anweist und verschwindet dann wieder. Alles, was nicht PHP-Code ist, bleibt unverändert! Dieser "richtige Zeitpunkt" ist (in Verbindung mit Webseiten) genau dann, wenn ein Client (wie beispielsweise du daheim vor dem PC) eine Seite anfordert. Der Webserver erkennt dann anhand der Dateiendung, dass er vorher dieses Programm (im folgenden "Interpreter") über die Datei drüberlaufen lassen muss. Je nach Webserver sind für PHP zulässige Dateiendungen .php, .phtml oder .php3. In letzter Zeit hat sich die Verwendung von .php mehr oder weniger durchgesetzt.

Kleine Generalvoraussetzung für dieses Tutorial: Ich gehe davon aus, dass HTML und CSS vertraut sind und auf dem zu verwendenden Server PHP installiert ist! HTML-Spezifika wie DOCTYPE und META-Tags lasse ich ganz bewusst weg (etwaiger HTML-Code ist minimalistisch), um nicht von PHP abzulenken.

Um nicht länger um den heißen Brei herumzureden, hier ein einfaches Beispiel, eingebettet in das erste Beispiel aus dem HTML-Tutorial:

   <html>
   <head>
   <title>Ein Titel</title>
   </head>
   <body>
   <?php 
     echo "Hallo Welt!";
   ?>
   </body>
   </html>

Was ist alles aus dem einfachen Beispiel zu erkennen: PHP-Code wird in <?php und ?> eingefasst. Alternativ sind auch <? und ?> als Einfassungen möglich, aber nicht zu empfehlen, da dies abhängig von der Serverkonfiguration nicht immer funktioniert. Die Anweisung echo gibt das dahinter in Anführungszeichen stehende aus, in unserem Fall also Hallo Welt. Anweisungen in PHP werden wie auch in vielen anderen Programmiersprachen mit einem Semikolon abgeschlossen. Dieses einfache Beispiel zeigt auch, wie PHP in Webseiten arbeitet: Stellen, wo ursprünglich PHP-Code gestanden ist, werden durch anderen Text ersetzt, im Regelfall also Text bzw. HTML-Tags.

PHP kennt natürlich auch Variablen, Kontrollstrukturen und vieles mehr, schließlich ist es eine vollwertige Programmiersprache. Eine ausführliche Beschreibung der Syntax ist unter Kontrollstrukturen in PHP zu finden, die wichtigsten habe ich nocheinmal zu sammengefasst: (Kommentare stehen wie in CSS zwischen /* und */)

   <?php
   /* Variablen verwenden */
   $variable1 = "Tutorial";
   $variable2 = 42;
   $variable3 = TRUE;
   $variable4 = 123.45;

   /* if-Abfrage */
   if ($variable2 == 41){
      $variable4 = $variable2;
      $variable1 = "Aisha";
   } else if ($variable2 != 42){
      $variable1 = "Hundefutter";
   } else {
      $variable3 = FALSE;
   }
      
   /* for-Schleife */
   for ($i = 0; $i < 10; $i++){
      echo $variable1;
   }
   
   /* while-Schleife */
   while ($variable2 < 100){
      $variable2 = $variable2 + 1;
      echo $variable2;
   }
   
   ?>

Variablen werden mit vorangestelltem Dollar-Zeichen deklariert. Beginnen muss eine Variable mit einem Buchstaben oder einem Underscore (_), danach sind auch Ziffern erlaubt. PHP erlaubt es, Variablen einfach so zu verwenden, wie man sie benötigt. Man sollte jedoch alle Variablen vor ihrer Verwendung initialisieren, also mit einem Wert belegen! PHP entscheidet dadurch selbst, was für ein Typ die Variable ist. Ob das ein Fluch oder ein Segen ist, muss jeder für sich selbst herausfinden... Zur if-Abfrage ist eigentlich nicht viel zu sagen, in runder Klammer steht die zu prüfende Bedingung, im nachfolgenden Block der Code, der auszuführen ist, wenn die Bedingung wahr ist. Ist die Bedingung nicht war, werden auch noch die else-Blöcke überprüft, diese sind aber optional und können auch weggelassen werden.

Die Schleifen sind wie folgt aufgebaut: Bei der for-Schleife besteht die runde Klammer aus drei Teilen: Der erste Teil ist eine Initialisierung, die auch leer bleiben kann. Der zweite Teil ist die Bedingung, die vor jedem Schleifendurchlauf auf Wahrheit überprüft wird und der dritte Teil wird ausgeführt, nachdem die Schleife durchlaufen wird. Getrennt werden die drei Teile durch Semikolons. Der nachfolgende Block wird bei jedem Schleifendurchlauf abgearbeitet. Im obigen Beispiel wird also $i=0 initialisiert, vor jedem Durchlauf auf $i < 10 getestet und nach jedem Durchlauf wird $i um eins erhöht. while-Schleifen sind hinsichtlich Syntax einfacher, weil in runden Klammern nur die Bedingung steht. Dafür ist aber auch die Gefahr größer, aus Versehen eine Endlosschleife zu produzieren. Schleifen können auch mit "break;" "von Hand" beendet werden, während "continue;" nur den aktuellen Schleifendurchlauf beendet.

Variablen können - wie bereits bei Schleifenbedingungen verwendet - verglichen werden. Ebenso sind einfache Operationen möglich, wie im Folgenden erklärt wird: (Kommentare bis zum Zeilenende werden mit einem // begonnen)

   /** Speziell für numerische Datentypen **/
   
   /* Vergleich auf Gleichheit von numerischen Werten */
   if ( $variable1 == $variable2 ){ ... }
   
   /* Kleiner als ... */
   if ( $variable1 < $variable2 ){ ... }

   /* Größer als ... */
   if ( $variable1 > $variable2 ){ ... }
   
   /* Ungleich */
   if ( $variable1 != $variable2 ){ ... }

   /* variable1 kleiner als variable2 und größer als variable3 */
   if ( $variable1 != $variable2 && $variable1 > $variable3 ){ ... }
   
   /* um eins erhöhen (Kurzform) */
   $variable++;
   
   /* eins abziehen (Kurzform) */
   $variable--;
   
   /** Speziell Zeichenketten **/
   /* Siehe insbesondere http://www.php.net/manual/de/ref.strings.php */
   
   /* Zeichenketten auf Gleichheit prüfen: */
   if ( strcmp($string1, $string2) ) { ... }
   
   /* Zeichenketten verbinden */
   $string12 = $string1 . $string2;
   
   /* Zeichenkette in HTML-kompatible Zeichen umkodieren: */
   $htmlstring = htmlentities($string);
   
   /* In Groß- bzw. Kleinbuchstaben: */
   $string1 = strtolower($string);      //in Kleinbuchstaben
   $string2 = strtoupper($string);      //in Großbuchstaben
   
   /* Zeichenkette in Zahl umwandeln */
   $num = intval($string);           //in Ganzzahl umwandeln
   $num = floatval($string);         //in Gleitkommazahl
   
   /* Zahl in Zeichenkette */
   $str = strval($zahl);
   
   /* Prüfen, ob variable bereits verwendet wurde */
   if ( isset($variable) ) { ... }
   
   /* Typprüfungen */
   if ( is_numeric($variable) ) { ... }   //numerischer Typ
   if ( is_string($variable) ) { ... }    //Zeichenkette
   if ( is_bool($variable) ) { ... }      //Boolean (TRUE/FALSE)
   if ( is_array($variable) ) { ... }     //Array

Zum Abschluss dieses Unterabschnitts noch ein kommentiertes Beispiel, um etwas Vertrautheit mit der Syntax zu schaffen:

 <html> 
 <head> 
   <title> Einfaches PHP-Beispiel </title> 
 </head> 
 <body> 
 
 <?php
 
    /* Initialisiere Zählvariable $cnt zu Null */
    $cnt = 0;
    
    /* Aktuelle Uhrzeit (Stunden, Minuten, Sekunden) speichern */
    $sekunden = intval(date('s'));
    $minuten = intval(date('i'));
    $stunden = intval(date('G'));
    
    /* Für jede Sekunde ein "s" ausgeben: */
    for ( $i=0;  $i <  $sekunden;  $i =  $i + 1){
       echo "s";
    }
    
    /* Sekunden als Zahl am Ende der Buchstabensuppe ausgeben: */
    echo $sekunden;

    /* Neue Zeile beginnen:
    (\n macht auch im Quellcode einen Zeilenumbruch)*/
    echo "<br>\n";
    
    /* Für jede Minute ein "m" ausgeben: */
    $i = 0;
    while ( $i <  $minuten){
       echo "m";
        $i++;          // äquivalent zu $i = $i + 1;
    }

    /* Minuten als Zahl am Ende der Buchstabensuppe ausgeben: */
    echo $minuten;

    /* Neue Zeile beginnen: */
    echo "<br>\n";
    
    /* Für jede Stunde ein "h" ausgeben: */
    $i = 0;
    $str = "";        //leere Zeichenkette
    while ($cnt == 0){
       /* An $str ein h anhängen: */
       $str = $str . "h";     
       if ($i == $stunden){
          break;      //Schleife verlassen
       }
       $i++;          // äquivalent zu $i = $i + 1;
    }
    /* Und ausgeben von $str nicht vergessen: */
    echo $str;
    
    /* Stunden als Zahl am Ende der Buchstabensuppe ausgeben: */
    echo $stunden;

 ?>
 
 </body> 
 </html>

Dieses Beispiel ist hier in Aktion zu sehen.

Etwas Dynamik ins Spiel bringen

Sofern kein Input von außen stattfindet, wird PHP-Code im Regelfall (solche Zeitspielereien wie im vorigen Beispiel ausgenommen) gleich ablaufen und man könnte daher gleich ein normales HTML-File schreiben. Interessant werden daher erst Benutzer-Eingaben als Input. Dieser Benutzer-Input passiert im Regelfall in der Form, dass Variablen "von außen" an das Skript übergeben werden, für Webseiten werden diese Variablen über GET- und POST-Methoden übertragen. Obwohl diese zwei Methoden den gleichen Endzweck haben, ist der Weg des Erreichens ein anderer.

GET-Methode

Diese Methode ist für jene Fälle vorgesehen, wo ein mehrmaliges Aufrufen der Seite mit denselben Variablen keine unerwünschten zusätzlichen Nebeneffekte hervorruft. Im Speziellen also wenn damit nur Content-Auswahl oder Datenbank-Abfragen (lesend!) betrieben werden. Die Variablen werden dabei direkt in der URL mitübertragen. Sollen an ein Skript example.php die Variablen $test1 und $test2 mit den Werten "Hallo" bzw. "Welt übergeben werden, so geschieht das über example.php?test1=Hallo&test2=Welt. Seit PHP 4.1.0 werden diese Variablen dann über das $_GET-Array abgerufen. Das folgende Skript gibt die übergebenen Variablen $test1 und $test2 einfach wieder aus.

 <?php
   if (isset($_GET["test1"])){
      $test1 = $_GET["test1"];
   } else {
      $test1 = "";
   }
   
   echo "Variable test1: " . $test1 . "<br>\n";
   
   if (isset($_GET["test2"])){
      $test2 = $_GET["test2"];
   } else {
      $test2 = "";
   }

   echo "Variable test2: " . $test2 . "\n";
 ?>

Dieses Beispielskript ist unter diesem Link zu finden.

Anstelle der komplizierten if-Konstrukte könnte man auch direkt echo $_GET["test1"]; anweisen, in größeren Skripten ist es allerdings geschickter, die übergebenen Variablen einmal bewusst einzubinden und so auch gleich einen Default-Wert festlegen, falls die Variable nicht übergeben wurde. Möchte man den Name der übergebenen Variable ändern, muss man dies dann auch nur an einer einzigen Stelle im Skript tun.

Sehr beliebt ist es, über die GET-Methode den Inhalt einer Seite zu selektieren. Dazu übergibt man beispielsweise eine Variable $inhalt mit einer Zahl und dann wird aus einer Datenbank oder einer Datei der hinter dieser Zahl stehende Inhalt angezeigt. Dies wird auch auf dieser Homepage so praktiziert und wird im Datenbanken-Teil noch detaillierter behandelt. Ein Nachteil dieser Methode ist allerdings, dass die URL nicht mehr vielsagend ist und man unter Umständen schlechtere Suchmaschinenrankings in Kauf nehmen muss.

POST-Methode

POST hat in diesem Fall nichts mit dem in Österreich mittlerweile privatisierten Brief- und Paketzustelldienstleister zu tun. Bei der POST-Methode werden die Daten im Hintergrund als eigene HTTP-Transaktion statt. Die Variablen erscheinen zwar nicht in der Adressleiste, werden aber dennoch unverschlüsselt übertragen, was insbesondere bei der Übertragung von Passwörtern zu beachten ist! Aus der Sicht des PHP-Skripts ändert sich nur das abzufragende Array: Anstelle von $_GET muss nun $_POST benutzt werden. Dieser Methode ist immer dann zu verwenden, wenn die GET-Methode nicht in Frage kommt, also insbesondere bei Skripten, die schreibend auf Datenbanken oder Dateien operieren.

Als einfaches Beispiel sollen die Formulardaten einer HTML-Seite über die POST-Methode an ein PHP-Skript übergeben werden. Die HTML-Datei ist dabei wie folgt:

 <html> 
 <head> 
   <title> PHP-Beispiel für POST-Variablen</title> 
 </head> 
 <body> 
    <form action="php-example3.php" method="post">
    Hier bitte Namen eingeben: <input name="eingabe" type="text" size="20" maxlength="30">
    <input type="submit" value=" Absenden "> 
    </form> 
 </body> 
 </html>

Und die PHP-Datei (HTML-Gerüst weggelassen):

 <?php
   if (isset($_POST["eingabe"])){
      $eingabe = $_POST["eingabe"];
   } else {
      $eingabe = "";
   }
   
   echo "Die Eingabe lautete: " . $eingabe;
   
 ?>

Auch hier gibt es wieder einen Link zum Beispiel.

Ebenso kann man auch ganze Formulare übergeben, also mehrere Text-, Combo- und-so-weiter-Boxen, inklusive Werte von "versteckten" Text-Boxen, um den aktuellen Schritt parat zu haben, etc.

Sessions

Ein sehr häufiger Anwendungsbereich von serverseitigen Skriptsprachen sind Login-Bereiche und personalisierte Seitengestaltungen wie zum Beispiel Warenkörbe in Online-Shops. Dabei bekommen Clients eine eigene ID, die sogenannte Session-ID. Variablen, die angelegt werden, bleiben innerhalb der selben Session, also für denselben Client, gültig und können weiterverwendet werden. Wird bei User A also eine Variable $warenkorb auf 42 gesetzt, so kann in allen weiteren Skripten, die im Laufe der Zeit von User A aufgerufen werden, auf $warenkorb zugegriffen werden.

Am einfachsten verständlich wird das an einem Beispiel: In einem HTML-Formular wählen wir eine Hintergrundfarbe aus. Dieses HTML-Formular gibt die Auswahl an ein PHP-Skript weiter, das die Session startet und die Hintergrundfarbe setzt. Ein weiteres PHP-Skript liest nur die gesetzte Session-Variable aus und setzt die Hintergrundfarbe entsprechend, ohne GET- oder POST-Variablen übergeben zu bekommen. Hier die HTML-Datei:

 <html> 
 <head> 
   <title> PHP-Beispiel für Sessions</title> 
 </head> 
 <body> 
    <form action="php-example4a.php" method="post">
    Hier bitte Hintergrund auswählen: <br> 
    <input type="radio" name="hintergrund" value="red" checked="checked">Rot <br>
    <input type="radio" name="hintergrund" value="blue">Blau <br>
    <input type="radio" name="hintergrund" value="silver">Silber <br>
    <input type="submit" value=" Absenden "> 
    </form> 
 </body> 
 </html>

Und das zugehörige PHP-Skript php-example4a.php:

 <?php
   session_start();         //Session starten
   if (isset($_POST["hintergrund"])){
      $_SESSION['bg'] = $_POST["hintergrund"];
   }
 ?>
 <html> 
 <head> 
   <title> PHP-Beispiel für Sessions</title> 
 </head> 
   
 <?php 
   if (isset($_SESSION['bg'])){
     echo "<body style=\"background-color: " . $_SESSION['bg'] . "\";>";
     echo "Hintergrund gesetzt auf: " . $_SESSION['bg'];
   } else {
     echo "<body> Kein Hintergrund gesetzt!!";
   }   
 ?>
 <br> <a href="php-example4b.php">Weiter zu Skript ohne POST-Daten</a>
 </body> 
 </html>

Sowie das Session-gesteuerte PHP-Skript php-example4b.php:

 <?php
   /* Wird logout über GET-Variable übergeben,
   dann Session beenden, ansonsten starten bzw. wiederaufnehmen: */
   if (isset($_GET["logout"])){
      $_SESSION = array();
      if (isset($_COOKIE[session_name()])) {
         setcookie(session_name(), '', time()-42000, '/');
      }
      session_destroy();         
   } else {
      session_start();
   }
 ?>
 <html> 
 <head> 
   <title> PHP-Beispiel für Sessions</title> 
 </head> 
   
 <?php 
   if (isset($_SESSION['bg'])){
     echo "<body style=\"background-color: " . $_SESSION['bg'] . ";\">";
     echo "<a href=\"php-example4a.php\">Zurück zu vorigem PHP-Skript</a>";
     echo "<br>Hintergrund gesetzt auf: " . $_SESSION['bg'];
     echo "<br><a href=\"php-example4b.php?logout=1\">Session beenden</a>";
   } else {
     echo "<body> <a href=\"php-example4a.php\">Zurück zu vorigem PHP-Skript</a>";
     echo "<br> Kein Hintergrund gesetzt!!";
   }   
 ?>

 </body> 
 </html>

Hier gibt es die drei Dateien in Aktion

Zu diesem nichttrivialen Beispiel gibt es einiges zu erklären: Die Formulareingabe wird von php-example4.html an php-example4a.php gesendet und dort verarbeitet. Dort wird auch gleich eine Session gestartet mittels "session_start();". Dieses Kommando muss das ausgeführt werden, bevor noch Zeichen an den Client gesendet werden! Im Klartext heißt das, dass "<?php" die allerersten Zeichen der HTML-Datei sein müssen, es dürfen auch keine Leerzeichen davor stehen! Ist die Session gestartet, können beliebige Werte im assoziativen Array $_SESSION abgelegt werden wie eben beispielsweise $_SESSION['bg]. Alternativ hätte der Hintergrund auch unter $_SESSION['hintergrund'] oder einem anderen Schlüssel gespeichert werden können. Dieses assoziative Array steht allerdings jeweils erst nach einem session_start(); zur Verfügung.

Nach dem Starten der Session und dem Abspeichern des Hintergrundes unter dem Schlüssel 'bg' wird dann in beiden Skripten ein entsprechender HTML-Inhalt erzeugt, indem mit isset() überprüft wird, ob der entsprechende Schlüssel in $_SESSION existiert. Wird dem Skript php-example4b.php eine Variable logout übergeben, so wird die Session beendet, also speziell das $_SESSION-Array gelöscht, das Cookie mit der Session-ID beim Client gelöscht und alle registrierten Daten zerstört. Danach wird auch bei den beiden Skripten der Hintergrund nicht mehr eingefärbt, die Session ist also wirklich beendet.

Mit der oben gezeigten Technik lässt sich auch relativ leicht ein Login-Bereich realisieren: In einem Formular gibt man Login-Name und Passwort ein, schickt es an ein PHP-Skript, das Benutzernamen und Passwort prüft und setzt beispielsweise $_SESSION['loginsuccess'] auf true oder 1, wenn erfolgreich. In weiterer Folge brauchen dann Inhalte aus dem Login-Bereich nur noch prüfen, ob $_SESSION['loginsuccess'] gesetzt ist.

PHP und MySQL

Sehr populär ist die Verwendung von PHP mit einer MySQL-Datenbank. Durch die in PHP integrierten MySQL-Funktionen ist das ganze denkbar einfach, solange man stets PHP und SQL (Die Sprache zur Abfrage der Datenbank) auseinander hält.

Ein PHP-Skript mit MySQL besteht aus den folgenden Phasen:

  • Aufbauen einer Verbindung zum MySQL-Server
  • Die Datenbank auswählen
  • Absetzen der MySQL-Abfrage
  • Verarbeiten des Ergebnisses
  • Beenden der Verbindung

Diese Schritte wollen wir uns der Reihe nach einmal ansehen:

Verbindung aufbauen

Die folgende Code-Zeile baut eine Verbindung zum MySQL-Server auf:

 $link = mysql_connect("localhost", "testuser", "testpass");

$link ist eine Variable, die die Verbindung zum MySQL-Server gewissermaßen speichert, ähnlich einem File-Handle. Das erste Argument ist die Adresse des MySQL-Servers, in unserem Fall der lokale Rechner. Sollte der MySQL-Serverprozess auf einem anderen Rechner laufen, so kann die IP-Adresse oder der DNS-Name angegeben werden. Das zweite Argument ist der MySQL-Benutzername, das dritte Argument ist das Passwort.

Die Datenbank auswählen

Da pro User mehrere Datenbanken zur Verfügung stehen können, muss man zuerst die entsprechende Datenbank auswählen, was über

 mysql_select_db("myDataBase");

geschieht. Dabei wird die Datenbank "myDataBase" ausgewählt.

Absetzen der MySQL-Abfrage

Nach dem Aufbau der Verbindung können nun SQL-Abfragen stattfinden. Das Muster ist jeweils dasselbe:

$query = "SELECT * FROM `testtabelle` WHERE id=5 LIMIT 0,30 ASC";
$result = mysql_query($query);

Die Funktion mysql_query() hat als Übergabeparameter jene Zeichenkette, in welcher sich die SQL-Abfrage befindet und gibt das Ergebnis zurück, das wir in der Variable $result speichern. Ich möchte nicht weiter auf SQL eingehen, da das ein Tutorial für sich beanspruchen würde, jedoch möchte ich zumindest die obige SQL-Abfrage erläutern: "SELECT * FROM `testtabelle`" wählt aus der Tabelle 'testtabelle' alle Spalten aus, die die nachfolgenden Bedingungen erfüllen: "WHERE id=5 LIMIT 0,30" In der Spalte 'id' muss die Zahl fünf stehen. Als Ergebnis werden zwischen 0 und 30 Zeilen (=Einträge) zurückgegeben.

Verarbeiten des Ergebnisses

Das Ergebnis wird in der Regel Zeile für Zeile abgearbeitet, wobei "Zeile" einen Tabelleneintrag meint. Dazu werden die Spalten des Ergebnisses in einem Array abgespeichert, das danach entweder über den Spaltennamen oder über die Spaltennummer (beginnend bei 0) abgefragt werden kann.

      
 $num = mysql_num_rows($result); //Anzahl der Zeilen

 for ($i=0; $i < $num; $i++){

    //Zeile extrahieren:
    $row = mysql_fetch_array($result);

    //Ausgabe der Spalten "Name" und "Alter":
     echo $row['Name'];
     echo $row['Alter'];

    //Gibt die erste und zweite Spalte aus:
     echo $row[0];
     echo $row[1];
 }

Die Kommentare sollten eigentlich alles klar machen: Zuerst wird mittels mysql_num_rows() die Anzahl der Zeilen (aus der Abfrage in $result) zurückgeliefert. Danach werden diese Zeilen der Reihe nach abgearbeitet. mysql_fetch_array() gibt dabei die aktuelle Zeile als Array zurück, auf das wie erwähnt mittels Zahlen oder Schlüsselwörtern zugegriffen werden kann. Außerdem stellt diese Funktion den internen Pointer weiter, sodass beim neuerlichen Aufruf die darauf folgende Zeile zurückgegeben wird.

Beenden der Verbindung

Das Beenden der Verbindung erledigt ein simples

 mysql_close($link);

Dem einen oder anderen ist vielleicht aufgefallen, dass außer mysql_connect() und mysql_close() keine weitere mysql-Funktion die Variable $link verwendet hat. PHP wählt diese Verbindung automatisch aus, wenn keine explizit übergeben wird. Das heißt aber natürlich NICHT, dass ein Verbindungsaufbau bzw. ein Beenden der Verbindung weggelassen werden kann!

Ein abschließendes Beispiel

Um nun alles zusammenzufassen und in ein funktionierendes Skript zu gießen, werden wir eine Tabelle mit den Spalten "Datum", "Name", "Email" und "Eintrag" abfragen, wie es bei einem sehr rudimentären Gästebuch der Fall ist. Auf großen designerischen Schnick-Schnack habe ich verzichtet, um das Wesentliche zu verdeutlichen.

 <html>
 <head>
 <title>Very simple Guestbook</title>

 </head> 
 <body>
 <?php 
   $link = mysql_connect("localhost", "testuser", "testpass");
   mysql_select_db("myDataBase");
   
   $query = "SELECT * FROM `simple_guestbook` ORDER BY `Datum` DESC LIMIT 0,30";
   $result = mysql_query($query);
   
   $num = mysql_num_rows($result); //Anzahl der Zeilen
   
   for ($i=0; $i < $num; $i++){
   
       //Zeile extrahieren:
       $row = mysql_fetch_array($result);
      
       //Ausgabe der Spalten:
       echo "Eintrag am: " . $row['Datum'] . "<br>";
       echo "Name: " . $row['Name'] . "<br>";
       echo "Email: " . $row['Email'] . "<br>";
       echo "Eintrag: " . $row['Eintrag'] . "<br>";
       echo "<hr>"; 
   }
   
   mysql_close($link);
 ?>
 </body>
 </html>

Der Großteil wurde bereits besprochen. Die SQL-Abfrage fragt bis zu 30 Einträge der Tabelle 'simple_guestbook' ab, absteigend nach dem Datum angeordnet. Das Gegenstück, nämlich das Eintragen eines neuen Kommentars ins Gästebuch, kann mit dem Wissen über Formulare ebenfalls realisiert werden, es ist stattdessen halt der entsprechende SQL-Befehl "INSERT" zu verwenden.

Natürlich fehlt noch eine Fehlerbehandlung, im Fehlerfall liefern die mysql-Funktionen FALSE zurück, worauf jedesmal abgefragt werden müsste. Diese if-Abfragen seien aber dem Leser zur Übung vorbehalten.

Letztes Update dieser Seite am 7. 3. 2007