Galileo Computing < openbook >
Galileo Computing - Professionelle Buecher. Auch fuer Einsteiger.
Galileo Computing - Professionelle Buecher. Auch fuer Einsteiger.


Kompendium der Informationstechnik
 von Sascha Kersken
EDV-Grundlagen, Programmierung, Mediengestaltung
Buch: Kompendium der Informationstechnik
gp Kapitel 18 Serverseitig dynamische Websites
  gp 18.1 Klassisches CGI
    gp 18.1.1 Das erste Beispiel
    gp 18.1.2 Manuelles Auslesen von Formulardaten
    gp 18.1.3 Mit dem Modul CGI.pm arbeiten
  gp 18.2 PHP
    gp 18.2.1 Die ersten PHP-Beispiele
    gp 18.2.2 PHP-Sprachgrundlagen
    gp 18.2.3 Webspezifische Funktionen
    gp 18.2.4 Gästebücher und Counter mit Textdateien
    gp 18.2.5 Zugriff auf MySQL-Datenbanken
  gp 18.3 Zusammenfassung

gp

Prüfungsfragen zu diesem Kapitel (extern)

Kapitel 18 Serverseitig dynamische Websites

Sonntags und nach 20.00 Uhr keine lauten Websites herunterladen
– »Internet-Knigge«; www.autsch.de

Als das Web erfunden wurde, waren Websites nichts weiter als eine Ansammlung statischer HTML-Dokumente. Irgendwann wurden die zu präsentierenden Datenmengen jedoch zu umfangreich, um »zu Fuß« entsprechende Dokumente zu schreiben. Dieses Kapitel stellt zwei verbreitete Verfahren zur serverseitigen Erzeugung von Webseiten aus dynamischen Inhalten vor: das klassische CGI-Scripting mit Perl und die beliebte Kombination aus der Skriptsprache PHP und der Datenbank MySQL.

Zwei weitere bekannte Technologien, nämlich Java Servlets/JSP und Microsoft ASP.Net werden im Rahmen der entsprechenden Frameworks J2EE beziehungsweise .Net in Kapitel 14, Netzwerkanwendungen, kurz angesprochen.

Prinzip der Serveranwendung

Das Grundprinzip von Webserver-Anwendungen ist immer dasselbe: Wenn ein Benutzer eine bestimmte URL anfordert, die auf eine solche 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.

Wenn Sie die Beispiele in diesem Kapitel ausprobieren möchten, benötigen Sie grundsätzlich Zugang zu einem Webserver. Sie können eine Webserver-Software wie Apache auf Ihrem eigenen Rechner installieren (siehe Kapitel 14, Netzwerkanwendung). Wenn Sie bereits eine öffentlich zugängliche Website betreiben, können Sie auch den Webserver Ihres Providers verwenden – allerdings stehen nicht in allen Tarifen aller Hosting-Dienste serverseitige Funktionen zur Verfügung. Dies müssen Sie übrigens auch prüfen, bevor Sie sich für einen bestimmten Provider beziehungsweise für eine bestimmte Server-Technologie entscheiden.


Galileo Computing

18.1 Klassisches CGI  downtop

Das Common Gateway Interface ist keine Sprache, sondern die Definition einer Schnittstelle zwischen dem Webserver und einem externen Programm. Ein Programm kann über diesen festgelegten Mechanismus mit dem Webserver kommunizieren und Daten austauschen:

gp  Die Standardausgabe des Programms, das heißt die Ausgabe, die normalerweise auf der Konsole ankommt, wird an den Webserver weitergegeben, der sie seinerseits über HTTP dem anfragenden Browser übergibt.
gp  Das CGI-Programm kann vom Webserver Formulardaten entgegennehmen. HTML-Formulare haben Sie in Kapitel 16, kennen gelernt; hier erfahren Sie, wie man sie weiterverarbeitet. Dem Programm sind sowohl per POST als auch über GET versandte Daten zugänglich, allerdings über verschiedene Verfahren.
gp  Es werden eine Reihe von speziellen Umgebungsvariablen definiert, die CGI-Programme auslesen können, um Informationen über den eigenen Webserver sowie über den Browser des entfernten Users zu erhalten.

Warum Perl?

Sie können CGI-Programme in jeder beliebigen Programmiersprache verfassen, die auf dem Serverrechner läuft und die die Standard-Ein- und Ausgabe auf der Konsole unterstützt. Zu den Sprachen, mit denen bereits CGIs programmiert wurden, gehören C und C++, Java, sämtliche UNIX-Shell-Skriptsprachen, TCL, Python, DOS-Batchdateien (!) und viele andere. Allerdings hat sich eine Sprache zum absoluten Liebling der CGI-Programmierer entwickelt: Perl. Dafür gibt es eine Reihe guter Gründe:

gp  Wie Sie bereits in Kapitel 5, Grundlagen der Programmierung, erfahren haben, verfügt Perl über eine Vielzahl cleverer Funktionen zur Textmanipulation und war darüber hinaus eine der ersten richtigen Programmiersprachen mit einer Engine für reguläre Ausdrücke.
gp  Die große Mehrheit der installierten Webserver läuft auf UNIX-Rechnern. Die meisten UNIX-Administratoren können in Perl programmieren.
gp  Im Vergleich zu kompilierten Sprachen wie C oder C++ ist das Sicherheitsrisiko bei einer Skriptsprache wie Perl weitaus geringer. Bedenken Sie bei CGI stets, dass hier ein anonymer, externer Benutzer (wenn auch indirekt) den Start eines lokalen Programms veranlassen kann.
gp  Die geringere Geschwindigkeit einer interpretierten Skriptsprache gegenüber einer kompilierten ist ebenfalls kein Hindernis für die Verwendung von Perl für CGI-Skripte: Die Netzwerkverbindung ist unter Garantie langsamer als der Perl-Interpreter.
gp  Außerdem hat Lincoln D. Stein das hervorragende Perl-Modul CGI.pm geschrieben, mit dessen Hilfe die Erstellung von CGI-Skripten besonders einfach und bequem funktioniert.

Um die folgenden Beispiele ausprobieren zu können, benötigen Sie einen Webserver und einen Perl-Interpreter. In Kapitel 14, Netzwerkanwendung, wird beschrieben, wie Sie den Webserver Apache installieren und für die Ausführung von CGI-Skripten konfigurieren können. Um CGI in einer öffentlichen Website einzusetzen, muss Ihnen der Provider, auf dessen Server die Site liegt, dieses Recht einräumen. Bei den größten deutschen Hostern, 1&1 und Strato, ist dies nur in den teureren Tarifen der Fall.


Galileo Computing

18.1.1 Das erste Beispiel  downtop

Das CGI-Skript in Listing 18.1 erzeugt ein HTML-Dokument, in dem einem User seine IP-Adresse, seine Browserversion und die Kennung des Webservers mitgeteilt wird:

Listing 18.1   Ein einfaches Perl-CGI-Skript

#!/usr/bin/perl –w use strict;
my $ip = $ENV{'REMOTE_ADDR'};
my $browser = $ENV{'HTTP_USER_AGENT'};
my $server = $ENV{'SERVER_NAME'};
print "Content-type: text/html\n\n";
print << "ENDE";
<html>
  <head>
    <title>Das erste CGI-Beispiel</title>
  </head>
  <body>
   <h1>Hallo, $ip!</h1>
    Hier spricht $server. Wie sch&ouml;n, dass du     $browser benutzt.
  </body>
</html>
ENDE

Denken Sie daran, dass Sie die Shebang-Angabe in der ersten Zeile anpassen müssen, wenn Sie das Skript auf einem Windows-Rechner verwenden (siehe Kapitel 5, Grundlagen der Programmierung). Bitte beachten Sie auch, dass die Markierung ENDE am Zeilenanfang einer eigenen Zeile stehen muss. Außerdem müssen Sie sie mit einem Zeilenumbruch abschließen – es handelt sich um ein HIER-Dokument, das ebenfalls in Kapitel 5 beschrieben wird. Speichern Sie die Datei in ein Verzeichnis Ihres Webservers, in dem die Ausführung von CGI-Skripten erlaubt ist (siehe Kapitel 14, Netzwerkanwendung) und öffnen Sie die entsprechende URL in Ihrem Browser.

Das Ergebnis sieht im Internet Explorer 6.0 beispielsweise so aus:

    Hallo, 127.0.0.1!
       
    Hier spricht 127.0.0.1. Wie schön, dass du Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1) benutzt.
       

Die merkwürdige Browserkennung »Mozilla/4.0« und so weiter wird im nächsten KapitelHHH erläutert. Dass Browser und Webserver beide die Adresse 127.0.0.1 melden, liegt daran, dass sie auf demselben Rechner arbeiten. Wenn Sie dieses Skript auf einem öffentlichen Webserver im Internet laufen lassen, wird er seinen Hostname statt einer IP-Adresse nennen, aber auf meinem lokalen Rechner läuft kein eigener Nameserver.

Die Ausgabe von Content-type: text/html, gefolgt von zwei Leerzeichen, ist der minimale HTTP-Header. Da die Endung der Datei nicht .htm(l) ist, benötigt der Browser umso dringender die Information, dass es sich bei den übermittelten Daten um ein HTML-Dokument handelt.

CGI-Umgebungsvariablen

Das Hash %ENV enthält sämtliche Umgebungsvariablen des Rechners, auf dem das CGI-Skript läuft. Neben den lokalen Umgebungsvariablen wie etwa PATH (siehe Kapitel 4, Betriebssysteme), die Sie in Perl als $ENV{'PATH'} ansprechen können, gibt es spezielle CGI-Umgebungsvariablen. Im Beispiel wurden die Variablen SERVER_NAME (der Hostname des Serverrechners), HTTP_USER_AGENT (die Browserkennung des anfragenden Clients) sowie REMOTE_ADDR (die IP-Adresse des anfragenden Hosts) verwendet. Tabelle 18.1 enthält eine Übersicht der wichtigsten CGI-Variablen.


Tabelle 18.1   Die wichtigsten CGI-Umgebungsvariablen

Variable Erläuterung
CONTENT_LENGTH Länge der übertragenen Anfragedaten
CONTENT_TYPE MIME-Type der Anfrage
DOCUMENT_ROOT Das Server-Basisverzeichnis
HTTP_ACCEPT Eine Liste der MIME-Types, die der Client annehmen möchte
HTTP_COOKIE Die Cookies, die mit der Anfrage übertragen wurden, weil sie für die angefragte Domain gespeichert sind
HTTP_REFERER Die URL des Dokuments, das per Hyperlink auf das aktuell angefragte Dokument verwiesen hat
QUERY_STRING Der Datenanhang der URL bei einer GET-Anfrage, hinter einem ?
REMOTE_ADDR Die IP-Adresse des anfragenden Clients
REMOTE_HOST Der Hostname des anfragenden Clients, falls er über DNS ermittelt werden kann
REQUEST_METHOD Die HTTP-Anfragemethode
SERVER_NAME Hostname oder IP-Adresse des Servers
SERVER_PORT Die TCP-Portnummer, an der der Server auf Anfragen lauscht
SERVER_PROTOCOL Name und Version des Anfrageprotokolls
SERVER_SOFTWARE Name und Version der Webserver-Software


Galileo Computing

18.1.2 Manuelles Auslesen von Formulardaten  downtop

Eine der häufigsten Aufgaben für CGI-Skripte ist das Auslesen von Formulardaten, die die Benutzer in ein HTML-Dokument eingeben. Die Formulardaten können mit Hilfe der HTTP-Methoden POST (als separater Datenstrom) oder GET (als Teil der URL) versandt werden – festgelegt im HTML-Tag <form>, siehe Kapitel 16, HTML und XHTML. Welche Methode verwendet wurde, steht in der Umgebungsvariablen REQUEST_METHOD. Wenn POST verwendet wurde, erhalten Sie die Daten über die Standardeingabe, deren Länge über CONTENT_LENGTH ermittelt werden kann. Bei GET befinden sie sich in der Umgebungsvariablen QUERY_STRING.

Sie können den Inhalt der Formulardaten unabhängig von der HTTP-Anfragemethode folgendermaßen in der Variablen $data speichern:

my $data;  # Variable für Formulardaten deklarieren
my $method = $ENV{'REQUEST_METHOD'};
if ($method eq 'POST') {
   read (STDIN, $data, $ENV{'CONTENT_LENGTH'};
) elsif ($method eq 'GET') {
   $data = $ENV{'QUERY_STRING'};
} else {
   die "Ungueltige Abfragemethode!\n";
}

Eigentlich ist es nicht hilfreich, ein CGI-Skript bei einem Fehler mit die() abzubrechen – schließlich ist keine Konsole vorhanden, um den Fehler anzuzeigen. Im nächsten Unterabschnitt wird eine elegantere Lösung vorgestellt.

Formulardaten decodieren

Ein weiteres Problem besteht darin, dass der Inhalt von $data URL-codiert ist. Betrachten Sie beispielsweise das folgende HTML-Formular:

<form action="/cgi-bin/formtest.pl" method="GET">
Ihr Name:
<input type="text" name="kunde" />
<br />
M&ouml;chten Sie weitere Infos?
<input type="radio" name="info" value="1" /> ja
<input type="radio" name="info" value="0" /> nein
</form>

Wenn Sie beispielsweise als Namen Peter Müller eingeben und die Frage nach weiteren Infos mit Ja beantworten, sehen die Formulardaten in der Variablen $data anschließend folgendermaßen aus:

kunde=Peter+M%FCller&info=1

Diese Daten müssen getrennt und decodiert werden. Der folgende Codeabschnitt teilt zunächst die Formulardaten an den &-Zeichen, mit denen die einzelnen Felder voneinander getrennt werden. Anschließend zerlegt er die Name=Wert-Paare am Gleichheitszeichen und ersetzt die codierten Sonderzeichen durch ihren eigentlichen Wert. Daraufhin packt er die Formulardaten in das Hash %vars, in dem die Feldnamen die Schlüssel und ihre Werte die Elementinhalte bilden:

my @fields = split (/&/, $data);
my %vars;  # Das Hash für die fertig zerlegten Daten
foreach $field (@fields) {
   my ($var, $val) = split (/=/, $field);
   $val =~ s/\+/ /g;  # '+' durch Leerzeichen ersetzen
   $val =~ s/%([\dA-Fa-f]{2})/pack ("C", hex ($1))/eg;
   $vars{$var} = $val;
}

Sie werden zugeben, dass dieser Code umständlich und schwerfällig aussieht. Zwar funktioniert er tatsächlich, aber genau solche Konstrukte sind ein guter Grund, das im nächsten Unterabschnitt vorgestellte Modul CGI.pm zu verwenden, das unter anderem das Lesen der Formulardaten automatisiert.

Sehen Sie sich trotzdem kurz den Code des Beispiels an. Wenn Sie die Programmierkapitel 5 und 6 gelesen haben, sollten Sie fast alle Zeilen verstehen. Die einzig schwierige Zeile ist diejenige, die die Sonderzeichencodierungen ersetzt:

$val =~ s/%([\dA-Fa-f]{2})/pack ("C", hex ($1))/eg;

Der reguläre Ausdruck %([\dA-Fa-f]{2}) sucht nach einem Prozentzeichen, gefolgt von zwei Hexadezimalziffern: \d ist die Kurzfassung für 0-9 (beliebige Ziffer), die Buchstaben A bis F sind die restlichen zulässigen Zeichen in Hexadezimalzahlen. Durch die Klammern merkt sich die RegExp-Engine die beiden Stellen in der automatischen Variablen $1, die für den ersten geklammerten Wert im regulären Ausdruck steht.

Die Funktion pack() wandelt anschließend den mittels hex() errechneten Dezimalwert in ein Zeichen (Formatangabe "C") mit dem entsprechenden ASCII- beziehungsweise ANSI-Code um. Der Modifikator g (global) sorgt dafür, dass die Ersetzung beliebig oft und nicht nur einmal pro Zeile durchgeführt wird, während e (expression) die Engine dazu bringt, den Ersetzungstext als auszuwertenden Ausdruck und nicht als String zu betrachten.


Galileo Computing

18.1.3 Mit dem Modul CGI.pm arbeiten  toptop

Wie Sie gerade gesehen haben, ist es relativ aufwändig, die Formulardaten manuell einzulesen. Es ist daher wünschenswert, diese häufig verwendete Funktionalität zu automatisieren. Am einfachsten und bequemsten erledigt das Modul CGI.pm von Lincoln D. Stein diese Aufgabe. Darüber hinaus vereinfacht es noch jede Menge weiterer Aufgaben der CGI-Programmierung.

CGI.pm einbinden

Das Modul gehört seit mehreren Versionen zum Lieferumfang aller Perl-Distributionen. Wenn Sie es in einem Skript verwenden möchten, müssen Sie es allerdings zunächst mittels use() einbinden:

use CGI;

Genau wie viele andere Perl-Module bietet auch CGI.pm zwei Zugriffsarten, eine prozedurale und eine objektorientierte. Das kurze Skript in Listing 18.2 verwendet das prozedurale Zugriffsverfahren, um einen Benutzer mit seinem Namen zu begrüßen, falls dieser in das Formularfeld user eingegeben wurde:

Listing 18.2   Ein prozedurales CGI.pm-Beispiel

#!/usr/bin/perl -w use strict;
use CGI qw/:standard/;
print header;
print start_html      ('Persönliche Begrüßung');
print h1 ('Ein Gru&szlig; von CGI.pm!');
if (param ('user')) {
   my $user = param ('user');
   print "Hallo, $user!<br />";
}
print << "ENDHT";
<form action=\"gruss.pl\" method=\"GET\">
Ihr Name, bitte:
<input type=\"text\" name=\"user\" />
</form>
ENDHT
print end_html;

Zunächst wird das Modul CGI.pm mit dem Tag :standard eingebettet, das die prozedurale Verwendungsweise ermöglicht. Die CGI-Funktion header erzeugt automatisch einen HTTP-Header, standardmäßig mit dem MIME-Type text/html. start_html() erstellt den gesamten Anfangsteil des HTML-Dokuments bis einschließlich <body>; ein als Argument übergebener String wird als Dokumenttitel verwendet. h1() erzeugt selbstverständlich eine entsprechende Überschrift.

Formulardaten lesen

Die CGI-Funktion param() gibt den Wert des genannten Formularfelds zurück. Bei HTML-Textfeldern handelt es sich dabei um den Eintrag, den der Benutzer vorgenommen hat; bei anderen Formularelementen werden die jeweiligen vordefinierten Werte zurückgegeben. Wenn ein Feld nicht ausgefüllt wurde oder gar nicht existiert, liefert die Funktion den Wert undefined. Im Beispiel wird die Funktion zunächst verwendet, um zu überprüfen, ob das Feld user ausgefüllt wurde. Ist dies der Fall, dann wird unter erneuter Verwendung von param() ein Gruß an den eingegebenen Namen ausgegeben.

Der Rest des Skripts verwendet ein HIER-Dokument, um das Formular mit dem Textfeld user und einem Absendeknopf auszugeben. Die CGI-Funktion end_html() liefert schließlich </body> und </html>, um das Dokument abzuschließen.

Mehrfachauswahlen

Übrigens gibt param() bei Checkboxgruppen oder bei <select>-Menüs mit dem Mehrfachauswahl-Attribut multiple="true" keinen einzelnen String zurück, sondern ein Array mit allen ausgewählten Optionen. Betrachten Sie zum Beispiel die folgende HTML-Checkboxgruppe:

W&auml;hlen Sie Ihre Servertechnologien:
<input type="checkbox" name="server" value="cgi" />CGI
<input type="checkbox" name="server" value="php" />PHP
<input type="checkbox" name="server" value="asp" />ASP
<input type="checkbox" name="server" value="jsp" />JSP

Mit den folgenden Perl-Anweisungen geben Sie alle angekreuzten Felder in einer Liste aus:

my @server = param('server');
print "Ihre gew&auml;hlten Servertechnologien:<ul>";
foreach $server(@server) {
   print "<li>$server</li>";
}
print "</ul>";

CGI.pm objektorientiert einsetzen

Wenn Sie das CGI-Modul ohne spezielles Tag importieren, können Sie nur den neueren objektorientierten Ansatz verwenden. Dieser erfordert zunächst, dass Sie ein CGI-Objekt erzeugen und die CGI-Funktionen anschließend als Methoden dieses Objekts aufrufen. Dadurch wird die CGI-Funktionalität im Skript deutlicher von anderen Perl-Anweisungen abgegrenzt.

Das Beispiel in Listing 18.3 implementiert mit Hilfe der objektorientierten Syntax ein kleines Gästebuch, das die Einträge in einer Textdatei speichert. Auf einer häufig besuchten Website können Sie es in dieser Form aber nicht verwenden, weil es nicht abfragt, ob die Textdatei gerade verwendet wird. Wenn nun zwei verschiedene Instanzen des Skripts gleichzeitig versuchen, in die Datei zu schreiben, könnte sie beschädigt werden.

Listing 18.3   Ein kleines CGI.pm-Gästebuch

#!/usr/bin/perl -w use strict;
use CGI;
use CGI::Carp qw(fatalsToBrowser);
my $query = CGI::new();
if ($query->param ('user') ||       $query->param ('entry')) {
   # Neuen Eintrag hinzufügen
   my $user = $query->param ('user');
   my $entry = $query->param ('entry');
   open (OUT, ">>data.txt") ||
        die "Kann Daten nicht schreiben: $!\n";
   print OUT "<i><b>$user</b> schreibt</i>:<br />\n";
   print OUT "$entry\n";
   print OUT "<hr />\n";
   close OUT;
}
# Formular für Neueintrag anzeigen
print $query->header;
print $query->start_html ('Gaestebuch');
print << "ENDHT";
<h1>G&auml;stebuch</h1>
<h2>Neueintrag</h2>
<form action=\"gast.pl\" method=\"POST\">
Ihr Name:
<input type=\"text\" name=\"user\" size=\"30\" />
<br />
Ihr Eintrag:
<textarea name=\"entry\" cols=\"40\" rows=\"6\" />
</textarea>
<br />
<input type=\"submit\" value=\"Eintragen\" />
</form>
<h2>Bisherige Eintr&auml;ge</h2>
ENDHT
# Ausgabe der bisherigen Einträge
if (open (IN, "<data.txt")) {
   while (<IN>) {
     print;
   }
   close IN;
} else {
   print "<i>Noch keine Eintr&auml;ge.</i>";
}
print $query->end_html;

CGI::Carp

Neben dem Modul CGI wird hier auch das Modul CGI::Carp eingebunden, das für aussagekräftigere Fehlermeldungen in CGI-Skripten sorgt – ebenso wie Carp die Fehlermeldungen in allgemeinen Perl-Skripten erweitert. Die Direktive fatalsToBrowser bedeutet, dass Fehler als HTML-Datei im Browser ausgegeben werden sollen. Dies ist für Debugging-Zwecke eine sehr praktische Angelegenheit, weil Sie nicht bei jedem Fehler die Log-Datei des Webservers lesen müssen. Vor der eigentlichen Veröffentlichung des Skripts sollten Sie die Zeile allerdings entfernen, weil eine solche Fehlermeldung für Anwender nicht geeignet ist.

Anschließend wird folgendermaßen ein neues CGI-Objekt namens $query erstellt:

my $query = CGI::new();

Falls Formulardaten übergeben wurden, werden diese als Nächstes in korrekter HTML-Formatierung an die Datei data.txt angehängt. Natürlich sorgt ein »echtes« Gästebuch dafür, dass der neueste Eintrag oben eingefügt wird. Dies kann beispielsweise mit Hilfe einzelner Textdateien pro Eintrag geschehen, am einfachsten aber durch die Verwendung einer Datenbank. Entsprechende Beispiele werden weiter unten im PHP-Abschnitt gezeigt.

Daraufhin wird das Formular angezeigt, um einen Eintrag einzugeben. Zu guter Letzt wird die Textdatei ausgelesen, falls vorhanden, und die bisherigen Einträge werden angezeigt. Wenn die Textdatei nicht existiert, wird stattdessen die Meldung »Noch keine Einträge« angezeigt.

Weitere CGI.pm-Optionen

Das CGI-Modul enthält noch eine Reihe weiterer Funktionen und Optionen. Unter anderem können Sie fast jedes HTML-Tag durch eine Methode erzeugen, die dessen Namen trägt. Auch die Angabe der HTML-Attribute funktioniert nach einem einfachen Schema. Das Skript in Listing 18.4 gibt zum Beispiel eine kleine HTML-Tabelle aus:

Listing 18.4   Ausgabe einer HTML-Tabelle mittels CGI.pm

#!/usr/bin/perl -w
use strict;
use CGI;
use CGI::Carp qw(fatalsToBrowser);
my $query = CGI::new();
print $query->header;
print $query->start_html('Automatisch erzeugte Tabelle');
print $query->h1({-align => 'center'}, 'HTML-Tabelle');
print    $query->table({-border => '2', -cellpadding => '4'},
   $query->Tr(
      $query->td('Dies'),
      $query->td('ist'),
   ), $query->Tr(
      $query->td('eine'),
      $query->td('Tabelle')));
print $query->end_html;

Der erzeugte HTML-Code sieht folgendermaßen aus:

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
<HTML><HEAD><TITLE>Automatisch erzeugte Tabelle</TITLE>
</HEAD><BODY><H1 ALIGN="center">HTML-Tabelle</H1>
<TABLE CELLPADDING="4" BORDER="2"><TR><TD>Dies</TD> 
<TD>ist</TD></TR> 
<TR><TD>eine</TD> 
<TD>Tabelle</TD></TR></TABLE></BODY></HTML>

Die hier von mir verwendete, mit Perl 5.6.1 gelieferte Version des CGI-Moduls erzeugt HTML-4.0-kompatiblen Code; neuere Versionen erzeugen dagegen standardmäßig XHTML-Code. Wie Sie sehen, werden keine Zeilenumbrüche zwischen den HTML-Tags erzeugt, was den Browsern aber egal ist. Wenn Sie schön formatierten HTML-Code benötigen, können Sie statt dem einfachen CGI.pm das spezielle Modul CGI::Pretty von Brian Paulsen verwenden.

HTML erzeugen

So gut wie alle HTML-Tags sind auf die gezeigte Art als Methoden eines CGI-Objekts verfügbar (oder als normale Funktionen, wenn Sie den prozeduralen Ansatz verwenden). Beachten Sie, dass einige Tag-Namen wie das oben verwendete Tr(), Select() oder Link() großgeschrieben werden müssen, um nicht mit den gleichnamigen eingebauten Perl-Funktionen durcheinander zu kommen.

Eine Methode, die HTML erzeugt, kann zwei verschiedene Arten von Argumenten besitzen: ein Hash mit einer Liste von Attributen sowie einen String mit verschachtelten Elementen – Letzterer kann auch durch den Aufruf weiterer CGI-Methoden gebildet werden.

Die HTML-Attribute werden als Hash angegeben, in dem die Schlüssel die Attributnamen mit vorangestelltem – (Minuszeichen) bilden. Die Werte sind Strings und entsprechen den Attributwerten.

  

Einstieg in PHP 5

Einstieg in Java

C von A bis Z

Einstieg in C++

Einstieg in Linux

Einstieg in XML

Apache 2




Copyright © Galileo Press GmbH 2004
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press GmbH, Gartenstraße 24, 53229 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de