vorheriges KapitelInhaltsverzeichnisStichwortverzeichnisFeedbacknächstes Kapitel


Tag 18


Active Server Pages

Heute wollen wir Sie in die serverseitige Programmierung à la Microsoft einführen. ASP steht für »Active Server Pages«, also aktive Server-Seiten, und der Name ist Programm. Bei den Webservern von Microsoft ist die ASP-Unterstützung im Lieferumfang mit dabei, und sofern Sie Microsoft Windows 95, 98, Me, 2000 oder NT einsetzen, können Sie loslegen. Die zugehörige Software finden Sie - sofern nicht eh bereits installiert - auf Ihrer Betriebssystem-CD oder können Sie im Internet herunterladen. Im Anhang finden Sie eine etwas ausführlichere Installationsanleitung. Stellen Sie sicher, dass Ihr lokaler Webserver auf die Unterstützung von ASP eingerichtet ist, damit Sie die heutigen Beispiele auch nachvollziehen sowie eigene Erfahrungen mit ASP sammeln können.

Beachten Sie bitte auch, dass Sie heute nur eine Einführung in ASP erhalten, Sie aber in der begrenzten Zeit keinen vollständigen Kurs erhalten können. Für weitergehende Informationen sowie eine deutlich ausführlichere Abhandlung empfehlen wir Ihnen aus dem Verlagsprogramm den Titel »Jetzt lerne ich Active Server Pages Programmierung«.

Die Themen heute:

18.1 Wie funktioniert eigentlich ASP?

Im Einleitungsabschnitt haben Sie es bereits gelesen: ASP muss bei Ihnen funktionsfähig installiert sein. Machen Sie nun Folgendes: Öffnen Sie mit Start/Suchen/Dateien/ Ordner den Dialog zum Durchsuchen Ihrer Festplatte nach Dateien, und suchen Sie dort nach »asp.dll«. Nach einiger Zeit sollten Sie fündig werden; die entsprechende Datei liegt in der Regel im Verzeichnis \Windows\System\inetsrv bzw. \Windows\System32\inetsrv.

Abbildung 18.1:  Die Datei wurde gefunden

Diese Datei, weniger als 400 KB groß, soll alles sein, was sich hinter ASP verbirgt? Nun ja, ein Fünkchen Wahrheit steckt da schon dahinter. Versetzen Sie sich in der Lage eines Webservers.

Wenn wir heute von einem Webserver reden, meinen wir damit einen Webserver mit ASP- Unterstützung, also in der Regel einen Internet Information Server (IIS) oder einen Personal Web Server (PWS), jeweils von Microsoft. Von diesem Server also wird eine ASP- Seite angefordert. Der Webserver weiß nun, dass er die Datei asp.dll zu Rate ziehen muss, denn diese interpretiert die ASP-Seite und führt den auf dieser Seite aufgeführten Code aus. Die Rückgabe der DLL ist dann (im Regelfall) HTML-Code, denn der Browser kann nur diesen interpretieren, mit ASP-Kommandos kommt er nicht klar.

Achten Sie also bei Ihren Tests unbedingt darauf, dass Sie den Server die ASP-Seiten ausführen lassen. Rufen Sie Ihre Beispielskripte via http://servername/skriptname.asp auf, und nicht über das Dateisystem, beispielsweise c:\inetpub\wwwroot\skriptname.asp. In Abbildung 18.2 sehen Sie, wozu das führen kann: Der Netscape Communicator öffnet einen Dialog zum Abspeichern der Datei, der Internet Explorer bietet dasselbe an, oder öffnet die Datei in einem Editor wie etwa Microsoft Frontpage.

Abbildung 18.2:  Netscape Navigator will die ASP-Datei speichern

Sie müssen die Suche natürlich auf dem Rechner ausführen, auf dem der ASP-fähige Webserver läuft!

Der Begriff »ASP« geisterte in den letzten Wochen und Monaten mehrmals durch die Medien und Sie sind vielleicht auch selbst ein paar Mal darauf gestoßen.

Mit Active Server Pages hatten die entsprechenden Artikel jedoch nur in den seltensten Fällen zu tun. Meistens ging es um Application Service Providing, wobei es sich - stark vereinfacht - um das Anbieten von Softwareapplikationen übers Internet handelt. Sie können also bei einem Application Service Provider (das - wie Application Service Providing auch - gerne mit ASP abgekürzt wird) die Nutzung einer speziell zugeschnittenen Textverarbeitung einkaufen, und dann im Minutentakt tippen. Da liegen Parallelen zu Abgabeterminen von Büchern sehr nahe...

Bevor es nun los geht, sollten Sie ein letztes Mal Ihre ASP-Installation auf Funktionstüchtigkeit überprüfen. Speichern Sie folgenden Code als ASP-Datei ab (oder nehmen Sie die Version auf der CD), und rufen Sie diese Datei dann im Browser auf:

Listing 18.1: willkommen.asp

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>ASP-Test</title>
</head>
<body bgcolor="white">
<%
Response.Write "<h1>"
Response.Write "Willkommen bei ASP!"
Response.Write "</h1>"
%>
</body>
</html>

Wenn Sie alles richtig gemacht haben, sollte das Ergebnis so aussehen wie in Abbildung 18.3. Falls nicht, lesen Sie noch einmal die Hinweise in diesem Kapitel sowie die Installationshinweise im Anhang!

Abbildung 18.3:  ASP ist korrekt eingerichtet worden!

18.2 Spracheinführung

Auf den nun folgenden Seiten erhalten Sie eine Schnelleinführung in ASP. Die verschiedenen Konzepte kennen Sie bereits aus der zweiten Woche, in der Sie JavaScript genauestens kennen gelernt haben. Sehen Sie uns also nach, wenn wir uns hier und da etwas kurz fassen, denn zum einen wollen wir Ihre (und unsere) Zeit nicht mit Redundanzen und Wiederholungen verschwenden, und zum anderen wollen wir schnellstmöglich zu den Anwendungsmöglichkeiten von ASP vordringen, denn das ist deutlich interessanter als die trockene Theorie.

Zunächst aber noch ein Wort zur Programmiersprache. ASP selbst ist keine Programmiersprache, sondern eine Technologie bzw. ein Grundgerüst, die/das es ermöglicht, auf Microsoft-Servern serverseitig zu programmieren. Sie haben in Bezug auf die verwendete Programmiersprache eine Reihe von Wahlmöglichkeiten, und wir haben uns hier für Visual Basic Script (kurz: VBScript) entschieden. Warum? Hier sind ein paar der Gründe:

Hauptkonkurrenz zu VBScript ist JScript. JScript ist das Microsoft-Pendant zu JavaScript. Wenn Sie also im Internet Explorer JavaScript-Programme ausführen, dann werden die dort von der JScript-Engine interpretiert. Sie werden jetzt vielleicht die nicht ganz unberechtigte Frage stellen, wieso wir dann an dieser Stelle nicht JScript verwenden, wenn Sie (der Leser) nach der Lektüre der Tage 8 bis 13 bereits JavaScript-Profis sind? Nun, drei der Gründe finden Sie oben aufgeführt, und es gibt noch einen dritten Grund: JScript ist zwar ziemlich kompatibel zu JavaScript, aber eben nicht ganz. Vor allem bei der serverseitigen Programmierung stößt man hier recht schnell auf Hindernisse.

Sprung ins kalte Wasser

Werfen Sie noch einmal einen Blick auf oben bereits aufgeführten Programmcode:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>ASP-Test</title>
</head>
<body bgcolor="white">
<%
Response.Write "<h1>"
Response.Write "Willkommen bei ASP!"
Response.Write "</h1>"
%>
</body>
</html>

Sie sehen zunächst einmal eine Reihe von HTML-Code. Etwa in der Mitte finden Sie ein paar Ihnen bis dato eher unbekannte Anweisungen. Sie werden durch <% und %> begrenzt. Daraus können Sie eine erste Schlussfolgerung ableiten: ASP-Kommandos werden durch <% und %> begrenzt.

Wenn wir im Folgenden von ASP-Code und ASP-Kommandos reden meinen wir streng genommen VBScript-Code/-Kommandos, der/die auf einer ASP-Seite integriert ist/sind.

Werfen Sie als Nächstes einen Blick auf die drei Zeilen eigentlichen ASP-Code: Sie haben alle den folgenden Aufbau:

Response.Write "irgendein Text"

Es sollte klar sein, was hier passiert: Der hinter Response.Write angegebene Text wird ausgegeben und an den Browser geschickt. Und in der Tat, wenn Sie sich in Ihrem Webbrowser den Quelltext der aktuellen Seite anzeigen lassen (Internet Explorer: Ansicht/Quelltext anzeigen, Netscape Navigator: View/Page Source oder Ansicht/Seitenquelltext), sehen Sie Folgendes:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>ASP-Test</title>
</head>
<body bgcolor="white">
<h1>Willkommen bei ASP!</h1>
</body>
</html>

Die drei Texte (oder, um bei Programmiersprachentermini zu bleiben, Strings/ Zeichenketten) wurden also tatsächlich wie gewünscht ausgegeben.

Was das mit Response.Write genau auf sich hat, werden wir an späterer Stelle genauer erläutern. Zunächst nur so viel: ASP bietet eine Reihe von so genannten Objekten an, welche erweiterte Funktionalitäten bieten. Das Response-Objekt ist eines dieser Objekte, und es hat eine Methode namens Write, welche Texte an den Browser ausgibt. Eine Methode ist in etwa so etwas wie eine Funktion, ein Konzept, das Sie bereits in den JavaScript-Kapiteln kennen gelernt haben.

»Aber bei JavaScript werden Funktionsparameter doch geklammert?!« - Sie haben recht, das ist in der Tat ein Unterschied. Aber zur Beruhigung: Sofern Sie nur einen Parameter übergeben, können Sie auch Klammern verwenden; Response.Write "irgendein Text" funktioniert also auch.

Variablen

Wie in jeder anderen Programmiersprache auch, dreht sich bei ASP vieles, wenn nicht sogar fast alles, um Variablen. Variablen können dazu verwendet werden, Daten zwischenzuspeichern, Daten miteinander zu verbinden, und vieles mehr.

Zuweisungen

Eine Zuweisung an eine Variable geht in VBScript wie folgt vonstatten:

<%
Option Explicit
Dim ping
ping = "pong"
%>

Mittels Dim ping wird eine Variable namens ping definiert, und dieser dann eine Zeile weiter die Zeichenkette "pong" als Wert zugewiesen. Doch wozu dient das Option Explicit?

Um dies herauszufinden, betrachten Sie einmal das folgende Skript, welches nur leicht abgeändert worden ist:

<%
Option Explicit
' Dim ping
ping = "pong"
%>

Die Zeile Dim Ping beginnt jetzt mit einem Apostroph/Hochkomma (auf der Tastatur: (Umschalt)+(#)). Hierdurch wird ein einzeiliger Kommentar eingeleitet, vergleichbar mit // in JavaScript-Code. Hierdurch wird der Befehl Dim ping also vor dem ASP- Interpreter versteckt, und damit die Variable ping nicht mehr explizit deklariert. Wenn Sie dieses Codestück in Ihrem Browser laden, erscheint eine (serverseitig generierte) Fehlermeldung (siehe Abbildung 18.4).

Anstelle eines Apostrophen können Sie einen Kommentar auch mit Rem einleiten (kurz für Remark, engl. Anmerkung).

Abbildung 18.4:  Die Variable wurde nicht definiert

Die Variable wurde also nicht deklariert. Sie erinnern sich nun vielleicht an die Argumentation von zuvor, dass wir VBScript gegenüber JScript unter anderem wegen der Einsteigerfreundlichkeit den Vorzug gegeben haben. Bei JScript jedoch kann eine Variable gut und gerne mit var variablenname deklariert werden, muss aber nicht. Nun, die gute Nachricht ist: Bei VBScript ist das nicht großartig anders. Auch hier können Sie Variablen ohne explizite Deklaration verwenden, Sie benötigen also überhaupt kein Dim.

Deklarieren oder nicht?

Im Gegensatz zu JavaScript bietet VBScript auch noch einen Modus an, der den Programmierer dazu zwingt, Variablen zu deklarieren. Dieser Modus wird mit Option Explicit aktiviert. Wenn Sie diese Anweisung einsetzen, müssen Sie auf dieser Seite alle verwendeten Variablen mittels Dim deklarieren, bevor Sie sie verwenden können.

Option Explicit muss die allererste Anweisung in der ASP-Seite sein, muss also insbesondere vor allen anderen Kommandos sowie vor jedweder HTML-Ausgabe kommen!

Warum das von Vorteil sein kann, sehen Sie an folgendem Beispiel. Dieses Beispiel stammt - auch wenn man das kaum glauben mag - aus der Praxis. Natürlich ist es stark vereinfacht, aber wie oft konnten wir auf die Fragen eines Kollegen, der den Fehler in seinem ASP-Code nicht finden konnte, antworten mit: Du hast Dich bei dem Variablennamen vertippt. Untenstehender Code ist also falsch - und wird Option Explicit nicht verwendet, ist die Fehlersuche (vor allem bei längeren Listings) sehr, sehr mühsam.

Listing 18.2: optionexplicit.asp

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Option Explicit</title>
</head>
<body bgcolor="white">
<%
Dim beispielsbegruessung
beispielsbegruessung = "Guten Tag!"
Response.Write "<h1>"
Response.Write bespielsbegruessung
Response.Write "</h1>"
%>
</body>
</html>

Der Browser gibt nichts aus, wovon Sie sich selbst überzeugen können, wenn Sie das Listing in Ihren Browser laden. Wenn Sie aber Option Explicit verwenden (als erste Anweisung, versteht sich, also noch vor <!DOCTYPE und <html>), wird der Fehler offensichtlich (siehe Abbildung 18.5).

Abbildung 18.5:  Ein Tippfehler im Variablennamen führt zur Fehlermeldung

Ausgabe

Wie Sie Variablen ausgeben können, haben Sie in obigem Beispiel bereits gesehen: Sie verwenden einfach Response.Write und übergeben als Parameter (mit oder ohne Klammern, das ist in diesem Fall wie gesagt Ihnen überlassen) den Variablennamen. Hier ein Beispiel mit mehreren Variablen:

Listing 18.3: begruessung.asp

<%
Option Explicit

Dim begruessung, thema
Dim tag

begruessung = "Guten Tag!"
tag = 18
thema = "ASP"
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Variablen</title>
</head>
<body bgcolor="white">
<h1>
<%
Response.Write begruessung
%>
</h1>
Herzlich willkommen an Tag
<%
Response.Write tag
%>;
das heutige Thema lautet:
<%
Response.Write thema
%>.
</body>
</html>

Abbildung 18.6:  Der Inhalt der Variablen wird ausgegeben

Ihnen sollten an obigem Code auch noch zwei Dinge auffallen:

Der Code wird nun doch schon etwas lang, obiger Code etwa umfasst circa eine Druckseite. Für die spartanischen Informationen, die auf der resultierenden Seite angezeigt werden, ist das schon ein wenig zu viel des Guten. Es gibt jedoch zwei Möglichkeiten, den Code etwas zu straffen:

Obiger Code lässt sich also etwas kürzer fassen:

Listing 18.4: begruessung_kurz.asp

<%
Option Explicit

Dim begruessung, thema
Dim tag

begruessung = "Guten Tag!"
tag = 18
thema = "ASP"
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Variablen</title>
</head>
<body bgcolor="white">
<h1><% =begruessung %></h1>
Herzlich willkommen an Tag <% =tag%>;
das heutige Thema lautet: <% =thema %>.
</body>
</html>

Es gibt auch noch eine weitere Abkürzung, die jedoch in der Regel auf Kosten der Übersichtlichkeit geht. Sie können mehrere Anweisungen in eine Zeile schreiben, wenn Sie diese Anweisungen durch einen Doppelpunkt voneinander trennen. Die Variablenzuweisungen in obigem Listing könnten Sie also auch wie folgt etwas kürzer fassen:

<%
begruessung = "Guten Tag!" : tag = 18 : thema = "ASP"
%>

Auf der anderen Seite ist es ebenfalls möglich, eine relativ lange Anweisung in mehrere Zeilen aufzuspalten. Betrachten Sie einmal folgendes Beispiel. Es kommt im Satz zu einem erzwungenen Zeilenumbruch, weil die Anweisung (aufgrund der überdimensionalen Zeichenkette) länger als eine Zeile ist:

<%
Response.Write "Kant sagte einst: Schön ist dasjenige, was ohne Interesse gefällt"
%>

Aus Autorensicht ist so ein Umbruch natürlich etwas sehr unerwünschtes. Erkennt ein Leser beispielsweise nicht, dass der Umbruch aus rein satztechnischen Gründen geschehen ist (auch ein vom Setzer eingefügtes Symbol, dass es sich hier um einen solchen Umbruch handelt hilft hier oft nicht viel), kann es sein, dass bei ihm der Code nicht funktioniert. Aus diesem Grund behelfen auch wir uns des öfteren mit der Möglichkeit, längere Codezeilen aufzuteilen. Wie das geht? Mit dem Unterstrich _ (Tastatur: (Umschalt)+(-)) kann man lange Zeilen auftrennen - aber nur zwischen einzelnen Teilen eines Kommandos, nicht beispielsweise innerhalb von Zeichenketten.

<%
Response.Write _
"Kant sagte einst: Schön ist dasjenige, was ohne Interesse gefällt"
%>

Dadurch gewinnt der Autor so viel an Platz, dass er die nachfolgende(n) Zeile(n) oft sogar noch ein wenig einrücken kann, aus rein ästhetischen Gründen.

Variablentypen und Namensgebung

Es gibt in ASP eine Reihe von Variablentypen, die gebräuchlichsten sind jedoch die Folgenden:

Weitere Variablentypen stellen wir an den entsprechenden Stellen am heutigen Tag noch vor.

Sie können die unterschiedlichen Variablentypen auch ineinander umwandeln, also beispielsweise aus einer numerischen Variablen eine Stringvariable machen. Der Typ einer Variablen kann sich innerhalb eines ASP-Skripts jederzeit ändern.

Beachten Sie in obiger Auflistung die Namensgebung der Variablen. Sie sind hier natürlich freigestellt (wie üblich müssen Variablennamen eindeutig sein, sollten am besten ausschließlich aus Buchstaben bestehen, und insbesondere kein Minus-Zeichen enthalten), aber auch hier haben sich einige Regeln eingebürgert. Vor dem eigentlichen Variablennamen (der mit einem Großbuchstaben beginnen sollte) wird ein kurzes Präfix gestellt, das den Typ der Variablen angibt. Beispielsweise lautet eine Empfehlung, dass die Namen von Stringvariablen mit str beginnen, Boolean-Variablen mit b, und so weiter. Auch wenn das insbesondere für den deutschen Leser etwas ungewohnt aussieht - englische Präfixe, gefolgt von einem unter Umständen deutschen Variablennamen - so hält es doch den Code nachvollziehbar, insbesondere wenn einmal jemand anderes Ihren Code überarbeiten muss.

Wir werden uns in diesem Buch deswegen an diese Empfehlungen (um nicht zu sagen: an diese Quasi-Standards) halten, Sie sind aber natürlich in der Wahl Ihrer Variablennamen sowie der Namenskonventionen für Variablen frei. Sie sollten sich aber unbedingt dazu durchringen, eine Namenskonvention einzurichten und dann auch einzuhalten, um eine gewisse Form der Einheitlichkeit in Ihrem Code zu erhalten. Außerdem sind damit Stolperfallen der Art »steht in der Variablen jahr die Jahreszahl als Integer (2001) oder als zweistelliger String (»01«)?« quasi ausgeschlossen.

Arrays

Selbstverständlich bietet Ihnen VBScript auch die Möglichkeit, mehrere Werte unter dem Oberbegriff einer einzelnen Variablen zu speichern: Die Rede ist natürlich von Arrays. Zum Einstieg aber gleich eine Warnung, die uns so ernst ist, dass wir sie in einen eigenen Absatz packen:

Verwenden Sie Arrays mit VBScript so selten wie möglich!

Wir meinen das auch ernst. Die Array-Behandlung von VBScript ist im Vergleich zu fast allen anderen Programmiersprachen indiskutabel. Sie sollten also Arrays tunlichst vermeiden, aber wie Sie sehen werden, benötigen Sie Arrays auch äußerst selten.

Ein Array deklarieren Sie wie jede andere Variable auch, also mit Dim. Sie müssen aber hinter dem Variablennamen in Klammern den Index des letzten Elements im Array angeben. Die Zählung der Elemente beginnt bei 0, mit Dim arystrName(41) erstellen Sie also ein Array mit maximal 42 Elementen. Hier ein kleines Beispiel:

Listing 18.5: kontinente1.asp

<%
Option Explicit

Dim arystrKontinente(5)
arystrKontinente(0) = "Amerika"
arystrKontinente(1) = "Afrika"
arystrKontinente(2) = "Asien"
arystrKontinente(3) = "Europa"
arystrKontinente(4) = "Antarktis"
arystrKontinente(5) = "Australien"
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Array</title>
</head>
<body bgcolor="white">
<table border="2" cellpadding="5">
<tr><td><% =aryStrKontinente(0) %></td></tr>
<tr><td><% =aryStrKontinente(1) %></td></tr>
<tr><td><% =aryStrKontinente(2) %></td></tr>
<tr><td><% =aryStrKontinente(3) %></td></tr>
<tr><td><% =aryStrKontinente(4) %></td></tr>
<tr><td><% =aryStrKontinente(5) %></td></tr>
</table>
</body>
</html>

Abbildung 18.7:  Die sechs Kontinente

Auch hier wieder eine Empfehlung für die Namensgebung: Dass es sich bei einer Variablen um ein Array handelt, können Sie durch das Präfix ary kennzeichnen. Nun gibt es aber Arrays, die Zeichenketten enthalten, Arrays, die nur numerische Werte beinhalten, und so weiter. Sie sollten also ein zweites Präfix nehmen, das den Datentyp der Arrayelemente angibt. Im obigen Beispiel haben wir das gemacht: Das Array enthält nur Zeichenketten, und hat deswegen das Präfix arystr.

Arrays können verschiedene Datentypen enthalten, das ist dem VBScript-Interpreter völlig egal. Verwenden Sie dann bei der Namensgebung nur das Präfix ary.

Wenn Sie anfangs noch nicht festlegen können (oder wollen), wie viele Elemente ein Array letztendlich enthält, können Sie auch ein dynamisches Array anlegen. Geben Sie dazu einfach bei der Deklaration keinen maximalen Index an:

<%
Dim arystrKontinente()
%>

Sie können nun mittels der Anweisung ReDim die Anzahl der Elemente in dem Array im Nachhinein festlegen:

<%
Dim arystrKontinente()
ReDim arystrKontinente(6)
arystrKontinente(0) = "Amerika"
arystrKontinente(1) = "Afrika"
arystrKontinente(2) = "Asien"
arystrKontinente(3) = "Europa"
arystrKontinente(4) = "Antarktis"
arystrKontinente(5) = "Australien"
arystrKontinente(6) = "Bayern"
%>

Nun stellen Sie Ihren Fehler fest und können - durch erneuten Aufruf von ReDim die Anzahl der Elemente im Array korrigieren (in diesem Fall nach unten). Hierbei gehen alle Elemente, die einen höheren Index haben als der neue Maximalindex, verloren. Wenn Sie so wollen: Bayern ist also kein eigener Kontinent mehr1.

<%
Dim arystrKontinente()
ReDim arystrKontinente(6)
arystrKontinente(0) = "Amerika"
arystrKontinente(1) = "Afrika"
arystrKontinente(2) = "Asien"
arystrKontinente(3) = "Europa"
arystrKontinente(4) = "Antarktis"
arystrKontinente(5) = "Australien"
arystrKontinente(6) = "Bayern"
ReDim arystrKontinente(5)
%>

Auch, wenn Sie später noch einmal mittels ReDim das Array größer machen, erhalten Sie den Wert »Bayern« nicht mehr zurück, der ist unwiderruflich verloren.

In Bezug auf Arrays noch eine letzte Funktion: Mittels UBound erhalten Sie den größtmöglichen Index des Arrays:

<%
Dim arystrKontinente()
ReDim arystrKontinente(6)
Response.Write "<p>Maximaler Index: "
Response.Write UBound(arystrKontinente) 'Ausgabe: 6
Response.Write "<br />"
ReDim arystrKontinente(5)
Response.Write "Neuer maximaler Index: "
Response.Write UBound(arystrKontinente) 'Ausgabe: 5
Response.Write "</p>"
%>

Zu guter Letzt noch ein kleiner Tipp: Sie können mit der Funktion Array() ein Array auch bequemer vorfüllen; übergeben Sie einfach die Arraywerte als Parameter:

<%
Dim arystrKontinente
arystrKontinente = Array("Amerika", "Afrika", "Asien", "Europa", _
"Antarktis", "Australien")
%>

Operationen und Operatoren

Auch diese Thematik ist eigentlich ein alter Hut und Ihnen aus dem JavaScript-Teil bereits bestens bekannt. Aus diesem Grund ersparen wir Ihnen an dieser Stelle alle weiteren langen Vorreden und steigen direkt in die Materie ein. Auch in VBScript unterscheidet man zwischen arithmetischen Operatoren, Vergleichsoperatoren, logischen Operatoren sowie Zeichenkettenoperatoren und -operationen.

Arithmetische Operatoren

Die meisten arithmetischen Operatoren sind wohl noch aus der Schule bekannt - und da Sie ja inzwischen schon ein JavaScript-Halbgott sind, kennen Sie den größten Teil davon eh schon. In Tabelle 18.1 finden Sie eine Übersicht, sowie das jeweils entsprechende JavaScript-Äquivalent.

Operator

Beschreibung

Beispiel

JavaScript-Äquivalent

+

Addition

11 + 4 (= 15)

+

-

Subtraktion

11 - 4 (= 7)

-

*

Multiplikation

11 * 4 (=44)

*

/

Division

11 / 4 (=2.75)

/

Mod

Rest bei Division

11 Mod 4 (=3)

%

^

Exponentialrechnung

11 ^ 4 (= 14641)

pow()

\

Ganzzahlige Division

11 \ 4 (= 2)

(nicht vorhanden)

Tabelle 18.1: Die arithmetischen Operatoren von VBScript

An dieser Stelle ist es höchste Zeit, den Zuweisungsoperator = noch einmal offiziell einzuführen (auch wenn wir ihn zuvor schon mehrmals untergeschoben haben). Das ganze läuft hier exakt wie in JavaScript: Rechts vom Gleichheitszeichen steht ein Ausdruck, und der Wert dieses Ausdrucks wird der Variablen links vom Gleichheitszeichen zugewiesen:

<%
Option Explicit

Dim intTageProJahr, intAnzahlWochen, intTageProWoche
intAnzahlWochen = 52
intTageProWoche = 7
intTageProJahr = intAnzahlWochen * intTageProWoche + 1
' intTageProJahr hat jetzt den Wert 365

Response.Write "Ein (nicht Schalt-)Jahr hat "
Response.Write intTageProJahr
Response.Write " Tage"
%>

Vergleichsoperatoren

Unter einem Vergleichsoperator versteht man genau das, was der Name schon verspricht - zwei »Dinge« (Variablen, Werte, Ausdrücke) werden miteinander verglichen. Das Ergebnis einer Vergleichsoperation ist ein boolescher Wert, also entweder True oder False. Sie benötigen Vergleichsoperationen für die diversen Kontrollstrukturen von VBScript, welche Sie in Kürze kennen lernen werden. Zunächst sollten Sie aber die Vergleichsoperationen kennen lernen, und auch dieses Mal ziehen wir wieder den Vergleich zu JavaScript:

Operator

Beschreibung

Beispiel

JavaScript-Äquivalent

>

größer als

2 > 1 (= True)

>

<

kleiner als

2 < 1 (= False)

<

>=

größer oder gleich als

2 >= 1 (= True)

>=

<=

kleiner oder gleich als

2 <= 1 (= False)

<=

=

gleich

2 = 1 (= False)

==

<>

ungleich

2 <> 1 (= True)

!=

Tabelle 18.2: Die Vergleichsoperatoren von VBScript

Logische Operatoren

Arithmetische Operatoren werden auf Integer- und Double-Werte angewandt, Vergleichsoperatoren ebenso (und unter bestimmten Umständen auch auf Strings). Boolesche Werte mit Termen wie »größer« und »kleiner« fassen zu wollen, ist schon etwas unintuitiv. Für diese Zwecke gibt es aber vier logische Operatoren, die Sie Tabelle 18.3 entnehmen können.

Operator

Bedeutung

Beispiel

JavaScript-Äquivalent

And

(logisches) Und

True And False (= False)

&&

Or

(logisches) Oder

True Or False (= True)

||

Not

Nicht (Negation)

Not True (= False)

!

Xor

Entweder oder

True Xor False (= True)

(nicht vorhanden)

Tabelle 18.3: Die logischen Operatoren von VBScript

Zeichenkettenoperatoren und -operationen

Die wohl naheliegendste Operation, die man mit zwei Zeichenketten anstellen kann, ist die Konkatenation, das Aneinanderhängen von zwei oder mehr Zeichenketten. Erinnern Sie sich noch an die etwas mühseligen Ausgaben von Zeichenketten in den vorangegangenen Beispielen? Dort sah das immer ungefähr folgendermaßen aus:

<%
Dim begruessung
begruessung = "Guten Tag!"
Response.Write "<h1>"
Response.Write begruessung
Response.Write "</h1>"
%>

Recht viel Platz für wenig Ausgabe, finden Sie nicht? Folgendes sieht da schon etwas besser (und kürzer) aus:

<%
Dim begruessung
begruessung = "Guten Tag!"
Response.Write "<h1>" & begruessung & "</h1>"
%>

Die meisten der bisherigen Operatoren bestanden aus einem oder zwei (Sonder-)Zeichen (zum Beispiel +, -, >=, <=), oder aus einem mehr oder minder kurzen Begriff (And, Or, ...). Alle weiteren Stringoperationen passen nicht genau in dieses Schema, denn es handelt sich hierbei um Funktionen, die aber mit Strings arbeiten.

Das Funktionen-Konzept kennen Sie ebenfalls bereits aus der JavaScript-Woche. Eine Funktion ist ein eigenständiges Funktionsstück, dem Sie in den meisten Fällen einen oder mehrere Parameter übergeben. Die Funktion hat dann (ebenfalls nur in den meisten Fällen) einen Rückgabewert, den Sie für die Programmierung benötigen.

In Tabelle 18.4 finden Sie nun eine Reihe von String-Operationen, mit denen Sie beispielsweise Teilbereiche aus einem String heraustrennen können.

Die Funktionen haben alle eins gemeinsam: Sie ändern den übergebenen String in keinster Weise, Sie müssen also immer den Rückgabewert verwenden!

Funktion

Beschreibung

Parameter

Beispiel

Len(s)

Ermittelt die Länge eines Strings

s - der betrachtete String

Len(»M+T«) (= 3)

InStr(s1, s2)

Ermittelt die erste Position eines Teilstrings in einem längeren String. Der Rückgabewert 0 bedeutet, dass der Teilstring nicht im längeren String enthalten war.

s1 - der zu durchsuchende String

s2 - der zu suchende String

InStr(»abcbcd«, »bc«) (= 2)

InStrRev(s1, s2)

Ermittelt die letzte Position eines Teilstrings in einem längeren String. Der Rückgabewert 0 bedeutet, dass der Teilstring nicht im längeren String enthalten war.

s1 - der zu durchsuchende String

s2 - der zu suchende String

InStr(»abcbcd«, »bc«) (= 4)

Left(s, i)

Liefert die ersten Zeichen eines Strings zurück.

s - der betrachtete String

i - Anzahl der zu ermittelnden Zeichen

Left(»Markt+Technik«, 5) (= »Markt«)

Mid(s, a, b)

Liefert ein Teilstring aus einem String zurück.

s - der betrachtete String

a - Startposition des Teilstrings

b - Anzahl der zu ermittelnden Zeichen

Mid(»Markt+Technik«, 5, 3) (= »t+T«)

Right(s, i)

Liefert die letzten Zeichen eines Strings zurück.

s - der betrachtete String

i - Anzahl der zu ermittelnden Zeichen

Right(»Markt+Technik«, 7) (= »Technik«)

Replace(s, s1, s2)

Ersetzt in einem String einen Teilstring durch einen anderen und liefert den ersetzten String zurück.

s - der betrachtete String

s1 - der zu ersetzende Teilstring

s2 - der Teilstring, durch den ersetzt werden soll

Replace(»Markt & Technik«, » & », » + ») (= »Markt + Technik«)

Tabelle 18.4: Die in VBScript eingebauten Zeichenkettenfunktionen

Fallunterscheidungen

Programmierung ist nie linear. Je nach den äußeren Umständen (Benutzereingaben, dem aktuellen Datum, dem verwendeten Browser des Benutzers) muss ein serverseitiges Skript andere Aktionen ausführen.

If-Anweisung

Haupt-Sprachkonstrukt von VBScript ist die If-Anweisung, die Sie - zumindest in ähnlicher Form schon von JavaScript her kennen. Sie haben an dieser Stelle aber zwei Hauptunterschiede, die beide (vor allem für den Einstieg) vorteilhaft sind:

Um das ganze einmal anhand eines kleinen Beispiels darstellen zu können, hier ein kleiner Blick in die Zukunft: Mit Weekday(Now) können Sie den aktuellen Wochentag ermitteln. Dabei gibt die Funktion einen Rückgabewert zwischen 1 und 7 zurück, die die in Tabelle 18.2 ersichtliche Bedeutung haben:

Rückgabewert

Wochentag

1

Sonntag

2

Montag

3

Dienstag

4

Mittwoch

5

Donnerstag

6

Freitag

7

Samstag

Tabelle 18.5: Die Rückgabewerte von Weekday

Jetzt können Sie beispielsweise eine Warnmeldung ausgeben, wenn der Benutzer Ihr ASP- Skript an einem Sonntag aufruft:

<%
Option Explicit
Dim intTag
intTag = Weekday(Now)
If intTag = 1 Then
Response.Write "Am Sonntag wird nicht gearbeitet!"
End If
%>

Sie sehen hier schon den groben Aufbau einer If-Anweisung:

<%
If Bedingung Then
Befehlsblock
End If
%>

Es gibt auch eine Kurzfassung, die sich aber nur dann lohnt, wenn der Befehlsblock einzeilig ist (oder durch : einzeilig gemacht werden kann):

<%
If Bedingung Then Befehlsblock
%>

Sie können in diesem Fall also das End If weglassen - aber hüten Sie sich davor, denn dadurch wird der Code nur unwesentlich kürzer, aber wesentlich inkonsistenter!

Else-Anweisung

Obiges Codebeispiel gibt nur sonntags etwas aus, an allen anderen Tagen bleibt die Seite leer. Höchste Zeit, dies zu beheben:

<%
Option Explicit
Dim intTag
intTag = Weekday(Now)
If intTag = 1 Then
Response.Write "Am Sonntag wird nicht gearbeitet!"
Else
Response.Write "Guten Tag, frisch ans Werk!"
End If
%>

Aus obigem Listing ist die Syntax der Else-Anweisung leicht ersichtlich:

<%
If Bedingung Then
Befehlsblock
Else
Befehlsblock
End If
%>

Auch hier kann wieder das End If weggelassen werden, wenn alles in einer Zeile steht, aber wie wir bereits oben bemerkt haben, sollten Sie nicht an der falschen Stelle an Arbeit sparen.

Streng genommen sollte man ja auch samstags nicht arbeiten. Ein erster Ansatz hierfür sieht so aus:

<%
Option Explicit
Dim intTag
intTag = Weekday(Now)
If intTag = 1 Then
Response.Write "Am Sonntag wird nicht gearbeitet!"
Else
If intTag = 7 Then
Response.Write "Am Samstag wird nicht gearbeitet"
Else
Response.Write "Guten Tag, frisch ans Werk!"
End If
End If
%>

Sie sehen hier durch die Einrückung, welches End If zu welchem If gehört. Unsere Empfehlung lautet also: Sparen Sie nicht an Einrückungen, mindestens zwei Leerzeichen pro neuer untergeordneter Ebene. Sie erkennen dann immer auf den ersten Blick, welcher Befehlsblock zu welcher Anweisung gehört!

Wenn Sie nun an jedem Wochentag eine entsprechende Meldung ausgeben wollen, dann könnten Sie beispielsweise wie folgt vorgehen:

<%
Option Explicit
Dim intTag
intTag = Weekday(Now)
If intTag = 1 Then
Response.Write "Am Sonntag wird nicht gearbeitet!"
Else
If intTag = 2 Then
Response.Write "Montag Morgen, da macht das Arbeiten Spaß"
Else
If intTag = 3 Then
Response.Write "Dienstags ist die Montagsmüdigkeit überwunden"
Else
If intTag = 4 Then
Response.Write "Am Mittwoch ist die halbe Woche schon rum"
Else
If intTag = 5 Then
Response.Write "Fast geschafft, heute ist Donnerstag"
Else
If intTag = 6 Then
Response.Write "Endlich Freitag, endlich Wochenende"
Else
Response.Write "Samstag ist Einkaufstag, nicht Arbeitstag"
End If
End If
End If
End If
End If
End If
%>

Das Listing erfüllt seinen Zweck, wovon Sie sich leicht überzeugen können - aber es ist auch ziemlich lang. Und schlimmer noch: Man tut sich irgendwann mit den Einrückungen schwer, auch bei der größten Bildschirmauflösung.

ElseIf-Anweisung

Sanfte Linderung verspricht hier die Anweisung ElseIf, welche eine Kombination aus Else und If ist, aber kein zusätzliches End If benötigt:

<%
If Bedingung Then
Befehlsblock
ElseIf Bedingung Then
Befehlsblock
ElseIf Bedingung Then
Befehlsblock
...
Else
Befehlsblock
End If
%>

Das letzte Else sowie der dazugehörige letzte Befehlsblock sind beide optional.

Obiges Beispiel kann also wie folgt umgeschrieben werden:

<%
Option Explicit
Dim intTag
intTag = Weekday(Now)
If intTag = 1 Then
Response.Write "Am Sonntag wird nicht gearbeitet!"
ElseIf intTag = 2 Then
Response.Write "Montag Morgen, da macht das Arbeiten Spaß"
ElseIf intTag = 3 Then
Response.Write "Dienstags ist die Montagsmüdigkeit überwunden"
ElseIf intTag = 4 Then
Response.Write "Am Mittwoch ist die halbe Woche schon rum"
ElseIf intTag = 5 Then
Response.Write "Fast geschafft, heute ist Donnerstag"
ElseIf intTag = 6 Then
Response.Write "Endlich Freitag, endlich Wochenende"
Else
Response.Write "Samstag ist Einkaufstag, nicht Arbeitstag"
End If
%>

Select Case

Schon besser, aber immer noch ein wenig zu viel Tipparbeit, zumindest nach unserem Geschmack. Aber einen Pfeil haben wir noch im Köcher: Select Case. Diese Anweisung entspricht dem switch-Kommando von JavaScript, und die Syntax lautet wie folgt:

<%
Select Case Ausdruck
Case Werteliste
Befehlsblock
Case Werteliste
Befehlsblock
...
Case Else
Befehlsblock
End Select
%>

Das Case Else sowie der darauf folgende, dazugehörige Befehlsblock sind optional. Eine Werteliste kann aus einem einzelnen Wert bestehen, oder aus mehreren, durch Kommata voneinander getrennten Werten.

Im folgenden Code finden Sie alle Elemente von Select Case einmal im Einsatz, wieder am Beispiel der Wochentagsausgabe.

<%
Option Explicit
Dim intTag
intTag = Weekday(Now)
Select Case intTag
Case 1, 7
Response.Write "Am Wochenende wird nicht gearbeitet!"
Case 4, 5, 6
Response.Write "Die Woche ist schon fast herum"
Case Else
Response.Write "So früh in der Woche, und schon surfen?!"
End Select
%>

Abbildung 18.8:  Die Ausgabe samstags und sonntags

Schleifen

Die wiederholte Ausführung von Anweisungen ist ebenfalls eine häufige Anforderung an ASP-Skripte. Zu den Anwendungsmöglichkeiten gehören:

For-Schleife

Mit einer For-Schleife, der wohl einfachsten Schleifenvariante, wird eine Anweisung (oder ein Anweisungsblock) mehrfach ausgeführt. Um wieder die JavaScript-Analogie zu bemühen: auch hier gibt es eine For-Schleife, die Syntax ist bei VBScript aber etwas anders. Nachfolgend ein paar Beispiele:

Listing 18.6: mehrgehalt.asp

<%
Option Explicit
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Ich will mehr Gehalt</title>
</head>
<body bgcolor="white">
<p>
<%
Dim i
For i = 1 To 10
Response.Write "Ich will mehr Gehalt <br />"
Next
%>
</p>
</body>
</html>

Abbildung 18.9:  Gehaltsverhandlungen mit ASP

Dieses Beispiel war noch recht einfach - zehnmal derselbe Text. Die Zählvariable (hier haben wir i gewählt) kann aber auch in den Befehlsblock eingebaut werden. Hier ein etwas komplexeres Beispiel: Eine Zeichenkette wird in seine einzelnen Zeichen zerlegt. Dazu muss die Zählvariable von 0 bis zur Länge der Zeichenkette laufen. Wie Sie aus Tabelle 18.4 ersehen können, lautet die entsprechende Zeichenkettenfunktion Len. Das entsprechende Zeichen erhalten Sie - auch aus Tabelle 18.4 ersichtlich - mit Mid. Achten Sie darauf, wie wir in der Ausgabe auf die Zählvariable zugreifen:

<%
Option Explicit
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Pappenheimer</title>
</head>
<body bgcolor="white">
<p>
<%
Dim i, strText
strText = "Pappenheimer"
For i = 1 To Len(strText)
Response.Write "Das " & i & ". Zeichen ist: "
Response.Write Mid(strText, i, 1)
%>
<br />
<%
Next
%>
</p>
</body>
</html>

Sie sehen an obigem Code, wie es möglich ist, auch innerhalb einer Schleife den ASP-Code kurz zu unterbrechen und HTML-Code einzufügen.

Abbildung 18.10:  Die einzelnen Zeichen des Wortes »Pappenheimer«

Die Syntax der For-Schleife hat noch eine Erweiterung:

<%
For i = Start To Ende Step Weite
Befehlsblock
Next
%>

Die Schrittweite (Weite) gibt an, um wie viel die Zählvariable pro Durchlauf erhöht wird. Der Standardwert ist 1, und da dieser fast immer verwendet wird, kann man Step Weite weglassen und die Zählvariable wird automatisch um 1 erhöht. Hin und wieder ist das Ganze aber recht nützlich, beispielsweise bei diesem (zugegebenermaßen arg konstruierten) Beispiel: Alle ungerade Zahlen von 1 bis 10 sollen ausgegeben werden:

Listing 18.7: ungerade.asp

<%
Option Explicit
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Ungerade Zahlen</title>
</head>
<body bgcolor="white">
<p>
<%
Dim i
For i = 1 To 10 Step 2
Response.Write i & " "
Next
%>
</p>
</body>
</html>

Sie können eine For-Schleife durch die Anweisung Exit For vorzeitig verlassen.

For-Schleifen sind übrigens auch im Zusammenhang mit Arrays nützlich:

Listing 18.8: kontinente2.asp

<%
Option Explicit

Dim arystrKontinente(5), i
arystrKontinente(0) = "Amerika"
arystrKontinente(1) = "Afrika"
arystrKontinente(2) = "Asien"
arystrKontinente(3) = "Europa"
arystrKontinente(4) = "Antarktis"
arystrKontinente(5) = "Australien"
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Arrays und For </title>
</head>
<body bgcolor="white">
<table border="2" cellpadding="5">
<%
For i = 0 To UBound(arystrKontinente)
%>
<tr><td><% =arystrKontinente(i) %></td></tr>
<%
Next
%>
</table>
</body>
</html>

Abbildung 18.11:  Die sechs Kontinente, mit einer For-Schleife ausgegeben

Do-Loop-Schleife

Mittels Do-Loop werden Befehlsblöcke mehrfach ausgeführt, und zwar solange eine Bedingung erfüllt ist, oder bis eine Bedingung erfüllt ist. Die erste Variante (ausführen, solange eine Bedingung erfüllt ist) sieht folgendermaßen aus:

<%
Do While Bedingung
Befehlsblock
Loop
%>

Die Alternative (Ausführen, bis eine Bedingung erfüllt ist):

<%
Do Until Bedingung
Befehlsblock
Loop
%>

Sie können - mit ein wenig Aufwand - eine For-Schleife mit Do-Loop emulieren. Werfen Sie zunächst einen Blick auf das folgende Codestück, mit einer For-Schleife:

<%
For i = 1 To 10
Response.Write i & " "
Next
%>

Das gleiche nun mit Do While-Loop:

<%
i = 0
Do While i < 10
i = i + 1
Response.Write i & " "
Loop
%>

Die Bedingung wird also immer am Anfang des Befehlsblocks geprüft!

Und noch einmal, diesmal mit Do Until-Loop:

<%
i = 0
Do Until i = 10
i = i + 1
Response.Write i & " "
Loop
%>

Auch hier wird wieder die Bedingung am Anfang des Befehlsblocks geprüft.

Wenn Sie eine Do-Schleife vorzeitig verlassen möchten, erreichen Sie dies mit dem Befehl Exit Do. Hier noch einmal das Beispiel von zuvor, diesmal mit Exit Do. Beachten Sie, dass die Bedingung immer erfüllt ist, und die Schleife - ohne Exit Do - endlos weiter laufen würde.

<%
i = 0
Do While i >= 0
i = i + 1
Response.Write i & " "
If i = 10 Then
Exit Do
End If
Loop
%>

While-Wend-Schleife

Bei While-Wend handelt es sich um eine beinahe exakte Kopie von Do While-Loop. »Beinahe« deshalb, weil eine While-Schleife nicht (wie etwa Do While-Loop) vorzeitig verlassen werden kann. Ansonsten nichts Neues:

<%
i = 0
While i < 10
i = i + 1
Response.Write i & " "
Wend
%>

For-Each-Schleife

Die For-Each-Schleife dient dazu eine Kollektion zu durchlaufen. Eine Kollektion ist eine Ansammlung von Daten, und in drei Tagen (wenn wir uns den Datenbanken zuwenden) werden Sie Kollektionen genauer kennen lernen. Eine Form von Kollektionen kennen Sie bereits, und zwar Arrays.

Die Syntax von For-Each ist die folgende

<%
For Each Wert In Kollektion
Befehlsblock
Next
%>

So können Sie also - ohne sich mühsam um die Anzahl der Elemente in einem Array kümmern zu müssen - alle Elemente im Array bequem ausgeben. Alles was Sie dazu brauchen, finden Sie hier:

<%
Option Explicit

Dim arystrKontinente(5), strKontinent
arystrKontinente(0) = "Amerika"
arystrKontinente(1) = "Afrika"
arystrKontinente(2) = "Asien"
arystrKontinente(3) = "Europa"
arystrKontinente(4) = "Antarktis"
arystrKontinente(5) = "Australien"
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Arrays und For Each</title>
</head>
<body bgcolor="white">
<table border="2" cellpadding="5">
<%
For Each strKontinent in arystrKontinente
%>
<tr><td><% =strKontinent %></td></tr>
<%
Next
%>
</table>
</body>
</html>

Abbildung 18.12:  Wieder die sechs Kontinente, diesmal mit For-Each ausgegeben

Somit haben Sie eine erste Schnelleinführung in VBScript erhalten. Ein Blick nach draußen beschert uns aber einsetzende Dämmerung, der Tag neigt sich aber langsam aber sicher dem Ende zu. Höchste Zeit, dass wir uns nun ein paar nützlichen Anwendungen zuwenden!

18.3 Datumswerte

Einer der ersten Gehversuche, sobald man über den Tellerrand von HTML schaut, besteht darin, das aktuelle Tagesdatum zu bestimmen - und auszugeben. Es ist einfach eine nette Sache, wenn man auf seiner Website das aktuelle Datum anzeigen kann, was unter anderem den netten Nebeneffekt hat, dass die Website subliminal frisch und aktuell wirkt - sie trägt ja schließlich das Tagesdatum!

Man kann natürlich das aktuelle Tagesdatum auch mit JavaScript anzeigen lassen. Dies hat aber einen kleinen Nachteil: Da JavaScript eine clientseitige Programmiersprache ist, also im Client, dem Browser, ausgeführt wird, wird auch das Datum des Clients angezeigt. Und wenn dies falsch eingestellt ist, wird auch ein falsches Datum verwendet. Bei serverseitigen Programmiersprachen wie eben ASP ist dies anders: Hier wird stets das Datum des Servers verwendet, und wenn Sie auf diesem stets die aktuelle Uhrzeit einstellen, zeigen auch Ihre Seiten immer die korrekte Zeit.

Für Datumswerte gibt es ein eigenes Datumsobjekt. Objekt deswegen, weil wir nur eine Variable benötigen, aber mittels diverser Funktionen aus dieser Variablen vielfältige Informationen ziehen können, beispielsweise den aktuellen Monat, die Uhrzeit oder sogar den Wochentag.

Erinnern Sie sich? Wir haben heute schon einmal mit dem Wochentag gearbeitet, und zwar im Abschnitt 18.2.4!

Ein Hinweis zur Nomenklatur: Datumsvariablen werden meist mit objDate oder objDatum oder so ähnlich bezeichnet. Das Präfix obj weist darauf hin, dass es sich um ein Objekt handelt, und der Variablenname danach sollte zumindest entfernt etwas mit dem Namensraum »Datum« zu tun haben.

Es gibt zwei Möglichkeiten, das aktuelle Tagesdatum zu erhalten: Mit Date und mit Now. Probieren wir einfach einmal beides aus:

Listing 18.9: tagesdatum.asp

<%
Option Explicit
Dim objDate, objNow
objDate = Date
objNow = Now
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Tagesdatum</title>
</head>
<body bgcolor="white">
<h2>Date: <% =objDate %></h2>
<h2>Now: <% =objNow %></h2>
</body>
</html>

Abbildung 18.13:  Der Unterschied zwischen Date und Now

Es ist offensichtlich, was hier passiert: Date liefert das aktuelle Tagesdatum zurück, Now darüber hinaus auch noch die Uhrzeit.

Ihnen stehen nun eine Reihe von Funktionen zur Verfügung, mit denen Sie auf die einzelnen Eigenschaften des Datumsobjekts zugreifen können. In Tabelle 18.6 finden Sie eine alphabetische Übersicht.

Datumsfunktion

Beschreibung

Rückgabewert am 24.12.2001, 23:45:56 Uhr

Day()

Tag

24

Hour()

Stunde

23

Minute()

Minute

45

Month()

Monat

12

Second()

Sekunde

56

Weekday()

Wochentag (1=Sonntag, 7=Samstag)

2

Year()

Jahr

2001

Tabelle 18.6: Die Datumsfunktionen von VBScript

Sie können nun mit ein wenig Aufwand das aktuelle Tagesdatum ausgeben. Im folgenden Listing haben wir das einmal durchgeführt. Achten Sie darauf, dass wir die deutschen Monats- und Tagesnamen in Arrays speichern und dann ausgeben. Zwar stellt VBScript auch hierfür etwas zur Verfügung, aber nicht immer die deutschen Namen!

Listing 18.10: tagesdatum_deutsch.asp

<%
Option Explicit
Dim arystrMonatsnamen, arystrTagesnamen, objDate
arystrMonatsnamen = Array("", "Januar", "Februar", "M&auml;rz", _
"April", "Mai", "Juni", "Juli", "August", "September", "Oktober", _
"November", "Dezember")
arystrTagesnamen = Array("", "Sonntag", "Montag", "Dienstag", _
"Mittwoch", "Donnerstag", "Freitag", "Samstag")
objDate = Now
Dim strDatum
strDatum = arystrTagesnamen(Weekday(objDate))
strDatum = strDatum & ", der "
strDatum = strDatum & Day(objDate) & ". "
strDatum = strDatum & arystrMonatsnamen(Month(objDate)) & " "
strDatum = strDatum & Year(objDate) & ", "
strDatum = strDatum & Hour(objDate) & ":"
strDatum = strDatum & Minute(objDate) & ":"
strDatum = strDatum & Second(objDate) & " Uhr."
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Tagesdatum</title>
</head>
<body bgcolor="white">
<p>Guten Tag! Heute ist <% =strDatum %></p>
</body>
</html>

Abbildung 18.14:  Datum mit ASP und VBScript

Das jeweils erste Element jedes Arrays war ein Leerstring (»«). Der Grund: Dieses Element hat den Index 0, und es gibt weder Wochentag noch Monat 0!

18.4 Auf Formulare zugreifen

Die wohl einfachste Möglichkeit, mit dem Besucher seiner Webseiten in Kontakt zu treten und Interaktion zu betreiben, liegt in der Verwendung von Formularen. In der ersten Woche haben Sie ja unter anderem eine ausführliche Einführung in die Thematik erhalten, und auch in der zweiten Woche sind Sie immer wieder auf Formularelemente gestoßen, und wie Sie mit JavaScript darauf zugreifen können. Aus diesem Grund werden wir den HTML-Anteil der folgenden Seiten relativ gering halten, damit wir uns nicht allzu oft wiederholen.

Allgemeines

Zunächst einmal müssen Sie sich ja bei einem Formular entscheiden, ob Sie die Daten mittels POST oder mittels GET verschicken. Zur Erinnerung: Bei Versand mittels POST werden die Formulardaten als Teil des HTTP-Headers verschickt; wenn Sie GET einsetzen, werden die Daten an die URL der Seite angehängt.

Die Länge eines URL ist von Webserver zu Webserver unterschiedlich, liegt aber in der Praxis irgendwo zwischen 500 und 2000 Zeichen. Sie sollten also umfangreiche Formulare immer via POST versenden, und nicht via GET. Ganz generell ist POST vorzuziehen.

Zunächst zur grauen Theorie: Wenn Sie Daten via POST verschicken, können Sie mittels Request.Form darauf zugreifen. Bei GET verwenden Sie Request.QueryString.

Im folgenden Listing finden Sie das einmal umgesetzt. Sie finden dort zwei Formulare, eines verschickt die Daten mittels POST, das andere die Daten mittels GET. Das action- Attribut des Formulars ist nicht gesetzt, das heißt, die Formulardaten werden an die aktuelle Seite verschickt. Die Werte von Request.Form und Request.QueryString werden ausgegeben, und je nachdem, welches der beiden Formulare Sie verschicken, enthält einer der beiden Ausdrücke einen Wert.

Listing 18.11: post_get.asp

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Formulare</title>
</head>
<body bgcolor="white">
<h2>Request.Form: <% =Request.Form %></h2>
<h2>Request.QueryString: <% =Request.QueryString %></h2>
<h3>Formular (POST)</h3>
<p>
<form method="post">
<input type="text" name="vorname1" size="20" />Vorname<br />
<input type="text" name="nachname1" size="20" />Nachname<br />
<input type="text" name="email1" size="20" />E-Mail<br />
<input type="submit" name="submit1" value="Abschicken" />
</form>
</p>
<h3>Formular (GET)</h3>
<p>
<form method="get">
<input type="text" name="vorname2" size="20" />Vorname<br />
<input type="text" name="nachname2" size="20" />Nachname<br />
<input type="text" name="email2" size="20" />E-Mail<br />
<input type="submit" name="submit2" value="Abschicken" />
</form>
</p>
</body>
</html>

Abbildung 18.15:  Alle Formularwerte stehen in Request.Form

Sie sehen also: Die einzelnen name-Attribute werden durch ein Gleichheitszeichen mit den jeweiligen value-Attributen (bzw. den Eingaben in die Formularfelder) gefüllt, und die einzelnen Formularfelder durch kaufmännische Unds (&) aneinandergehängt. Sie können nun mit String-Operationen versuchen, auf die einzelnen Werte Zugriff zu erhalten, aber ASP nimmt Ihnen hier einen Großteil der Arbeit ab: Mit Request.Form("name-Attribut") bzw. Request.Form("name-Attribut") erhalten Sie das dazugehörige value-Attribut! Im obigen Beispiel (mitsamt Abbildung 18.15) hätte also Request.Form("vorname1") den Wert »Erik«.

Um das einmal auszutesten, hier noch ein kleiner Hinweis: Bei Request.Form bzw. Request.QueryString handelt es sich um eine sogenannte Kollektion. Erinnern Sie sich an den Begriff? Wir haben ihn im Zusammenhang mit den For-Each-Schleifen eingeführt. Sie können sich also mit einer For-Each-Schleife alle Elemente in der Kollektion anzeigen lassen! Das folgende Listing realisiert exakt dies; aus Platzgründen verwenden wir diesmal nur ein Formular mit POST (bei GET geht es ganz analog):

Listing 18.12: foreach.asp

<%
Option Explicit
Dim strName
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Formulare</title>
</head>
<body bgcolor="white">
<h3>Formularwerte</h3>
<p>
<%
For Each strName in Request.Form
Response.Write "<strong>" & strName & "</strong>: "
Response.Write Request.Form(strName) & "<br />"
Next
%>
</p>
<h3>Formular (POST)</h3>
<p>
<form method="post">
<input type="text" name="vorname" size="20" />Vorname<br />
<input type="text" name="nachname" size="20" />Nachname<br />
<input type="text" name="email" size="20" />E-Mail<br />
<input type="submit" name="submit" value="Abschicken" />
</form>
</p>
</body>
</html>

Abbildung 18.16:  Die Formularangaben werden einzeln mit For-Each ausgegeben

Ein Tipp für ganz Schreibfaule: Sie können auch direkt über Request("name-Attribut") auf die einzelnen value-Attribute zugreifen. Wenn Sie nämlich nur Request angeben, wird zunächst Request.Form durchsucht, und dann Request.QueryString. In diesem Fall ist es also völlig egal, ob das Formular mittels POST oder mittels GET verschickt worden ist. Ob das dann aber noch sauberer Programmierstil ist, sei einmal dahingestellt.

Unterschiede bei den einzelnen Formularfeldern

Oben aufgeführte Regel gilt tatsächlich in den meisten Fällen: Geben Sie das name-Attribut an, und Sie erhalten das dazugehörige value-Attribut. Bei einigen der Formularelemente gibt es jedoch kleine, aber feine Unterschiede. Werfen wir also einen genaueren Blick auf die verschiedenen Möglichkeiten, die einem HTML und ASP bieten.

Textfelder / Passwortfelder

Alles, was durch die HTML-Konstrukte <input type="text">, <input type="password"> und <textarea> angegeben wird, folgt von ASP-Seiten aus einer Regel: Request.Form("name-Attribut") bzw. Request.QueryString("name-Attribut") liefert das dazugehörige value-Attribut zurück. Ein möglicher Code zur Ausgabe kann dann folgendermaßen aussehen:

Sie haben als E-Mail-Adresse 
<% =Request("email") %>
angegeben!

Auswahllisten

Noch einmal zur Erinnerung: Eine Auswahlliste ist wie folgt aufgebaut:

<select name="Name">
<option value="Wert1">Beschriftung 1</option>
<option value="Wert2">Beschriftung 2</option>
<!-- ... -->
</select>

Wenn Sie obigen HTML-Code als Teil eines Formulars an ein ASP-Skript verschicken, erhalten Sie dort dann mittels Request("Name") das value-Attribut der ausgewählten Option. Etwas anderes ist es jedoch, wenn Sie <select multiple> verwenden. Dann stehen in Request("Name") die value-Attribute aller ausgewählten Elemente, durch Kommata voneinander getrennt. Auch hier können Sie beispielsweise mit InStr und Konsorten die einzelnen Werte herausbekommen, aber der alte For-Each-Trick funktioniert ebenfalls tadellos: Setzen Sie diese Schleife ein, und Sie erhalten alle einzelnen Werte. Folgender Beispielcode funktioniert prinzipiell sowohl bei <select> als auch bei <select multiple>:

<p>Sie haben folgende Werte ausgew&auml;hlt:</p>
<p>
<%
Dim strWert
For Each strWert in Request("Name")
Response.Write strWert & "<br />"
Next
%>
</p>

Checkboxen

Auch, wenn Checkboxen in der Regel in Rudeln auftreten (will sagen: eine Checkbox kommt selten allein), so werden dennoch Checkboxen jeweils einzeln und unabhängig voneinander behandelt. Aus diesem Grund ist der Zugriff auch hier recht einfach. Ist die Checkbox angekreuzt, so enthält Request("name-Attribut") das value-Attribut der Checkbox, ansonsten ist Request("name-Attribut") leer.

Wenn Sie kein value-Attribut angeben, übergeben die meisten Browser als value-Attribut den String »on«. Schlussfolgerung: Geben Sie möglichst immer ein value-Attribut an!

Der folgende Code zeigt exemplarisch, wie Sie feststellen können, ob eine Checkbox angekreuzt ist oder nicht:

<%
If Request.Form("Name")<>"" Then
Response.Write "Checkbox angekreuzt!"
Else
Response.Write "Checkbox nicht angekreuzt!"
End If
%>

Radiobuttons

Im Gegensatz zu Checkboxen werden Radiobuttons gruppenweise verwaltet: Von allen Radiobuttons innerhalb einer Gruppe darf immer nur höchstens einer ausgewählt werden. Damit ist ziemlich klar, was Request("name-Attribut") zurückliefert: Das value-Attribut des ausgewählten Radio-Buttons:

Sie haben den Radiobutton <% =Request("Name") %> ausgew&auml;hlt!

Datei-Uploads

Die Möglichkeit, Dateien auf den Server zu überspielen, ist eine gute Sache - aber nicht, wenn Sie ASP einsetzen. Mit den Standardmitteln von ASP ist es sehr schwierig, auf die übermittelten Dateien zuzugreifen. Am einfachsten ist es hier, Sie verwenden ein zusätzliches Programm, oder Sie schwenken zu PHP über. Aus diesem Grund behandeln wir dieses Thema heute nicht, aber morgen, wenn Sie die Open-Source-Konkurrenz zu ASP kennen lernen, erfahren Sie mehr darüber.

Versende-Schaltflächen

Mit <input type="submit"> wird ein Formular verschickt. Und auch hier können Sie mit Request("name-Attribut") auf das dazugehörige value-Attribut (was in diesem Falle gleich der Beschrifung der Schaltfläche ist) zugreifen. Auf den ersten Blick ist das nicht sinnvoll, aber auf den zweiten Blick ist das sehr nützlich. Stellen Sie sich vor, Sie verschicken ein Formular auf dieselbe ASP-Seite, und wollen dieses Formular dann verarbeiten. Dazu müssen Sie zunächst feststellen, ob das Formular verschickt worden ist (dann müssen die Daten verarbeitet werden), oder ob diese Seite direkt aufgerufen worden ist (dann muss das Formular angezeigt werden). Hier ein exemplarischer Code für diese Aufgabe:

<%
If Request.Form("Versendebutton") = "Abschicken" Then
' Formulardaten verarbeiten
Else
' Formular anzeigen
End If
%>

Praxisbeispiele

Sie wissen nun bereits schon fast alles, was man zum Umgang mit Formularen können muss. Wir wollen Sie aber nicht aus diesem Abschnitt entlassen, ohne vorher zwei Praxisbeispiele angeboten zu haben. Viel Spaß beim Ausprobieren und Erweitern!

Anzeige der Daten

Im ersten Beispiel werden alle angegebenen Daten ausgegeben. Wir greifen dazu auf jedes Formularfeld einzeln zu, und bedienen uns nicht der (faulen) For-Each-Schleife. In der Praxis könnte man dieses Beispiel etwa dahingehend erweitern, dass die Daten parallel dazu noch in eine Datenbank geschrieben werden (in drei Tagen mehr dazu!). Von der Programmierung her bringt der Code wenig Neues, so dass wir ihn hier ohne weitere Umstände direkt wiedergeben:

Listing 18.13: daten_anzeigen.asp

<%
Option Explicit
Dim strAnrede, strOS, i
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Formulare</title>
</head>
<body bgcolor="white">
<%
If Request.Form("submit")="Abschicken" Then
%>
<h3>Formularwerte</h3>
<p>
<%
Select Case Request.Form("Geschlecht")
Case "m"
strAnrede = "Herr"
Case "f"
strAnrede = "Frau"
Case Else
strAnrede = "Herr/Frau"
End Select

Response.Write "Hallo " & strAnrede & " "
Response.Write Request.Form("Vorname") & " "
Response.Write Request.Form("Nachname") & "!<br />"
%>
Sie setzen die folgenden Betriebssysteme ein:
<%
If Request.Form("Windows")<>"" Then
Response.Write "Windows "
End If
If Request.Form("Linux")<>"" Then
Response.Write "Linux "
End If
%>
<br />Sch&ouml;n, dass Ihnen Tag <% =Request.Form("Tag") %>
so gut gef&auml;llt.
</p>
<%
Else
%>
<h3>Formular (POST)</h3>
<p>
<form method="post">
<input type="text" name="Vorname" size="20" />Vorname<br />
<input type="text" name="Nachname" size="20" />Nachname<br />
<input type="radio" name="Geschlecht" value="m">m&auml;nnlich
<input type="radio" name="Geschlecht" value="f">weiblich<br />
Ich nutze
<input type="checkbox" name="Windows" value="ja">Windows
<input type="checkbox" name="Linux" value="ja">Linux<br />
<select name="Tag" size="1">
<%
For i=1 To 21
%>
<option value="<% =i %>"><% =i %></option>
<%
Next
%>
</select>Dieser Tag gef&auml;llt mir am Besten<br />
<input type="submit" name="submit" value="Abschicken" />
</form>
</p>
<%
End If
%>
</body>
</html>

Ein kleiner Kniff verdient noch der Erwähnung. Für die Auswahlliste mit den 21 Tagen wäre normalerweise recht viel HTML-Code nötig gewesen. Mit einer kleinen For-Schleife geht das jedoch in wenigen Zeilen.

Abbildung 18.17:  Das Formular ...

Abbildung 18.18:  ... und die dazugehörige Ausgabe

Vollständigkeitsüberprüfung

Websurfer füllen ungern Formulare aus, denn das dauert Zeit, und man muss doch immer mal wieder einige persönliche Daten preisgeben. Wir möchten uns nicht in die Diskussion um den Datenschutz einmischen, aber es ist klar, dass auf der anderen Seite der Betreiber einer Website Interesse daran hat, dass das Formular auch vollständig ausgefüllt wird. Mit JavaScript kann man ein Formular auf Vollständigkeit überprüfen, aber JavaScript lässt sich ausschalten. Sie sollten deswegen auch auf der Serverseite eine Vollständigkeitsüberprüfung vornehmen. Im folgenden Listing wird das so realisiert: Nach dem Abschicken des Formulars wird überprüft, ob alle Formularfelder ausgefüllt worden sind. Falls ja, wird ein Dankestext angezeigt, falls nein, wird das Formular nochmals ausgegeben.

Listing 18.14: vollstaendig.asp

<%
Option Explicit
Dim bVollstaendig, i
bVollstaendig = False
If Request.Form("submit")="Abschicken" Then
bVollstaendig = True

If Request.Form("Geschlecht") = "" Then
bVollstaendig = False
End If
If Request.Form("Vorname") = "" Then
bVollstaendig = False
End If
If Request.Form("Nachname") = "" Then
bVollstaendig = False
End If
If Request.Form("Windows") = "" And Request.Form("Linux") = "" Then
bVollstaendig = False
End If
End If
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Formulare</title>
</head>
<body bgcolor="white">
<h3>Formularversand</h3>
<p>
<%

If bVollstaendig Then
Response.Write "Danke f&uuml;r Ihre Angaben!"
Else
%>
<form method="post">
<input type="text" name="Vorname" size="20" />Vorname<br />
<input type="text" name="Nachname" size="20" />Nachname<br />
<input type="radio" name="Geschlecht" value="m">m&auml;nnlich
<input type="radio" name="Geschlecht" value="f">weiblich<br />
Ich nutze
<input type="checkbox" name="Windows" value="ja">Windows
<input type="checkbox" name="Linux" value="ja">Linux<br />
<select name="Tag" size="1">
<%
For i=1 To 21
%>
<option value="<% =i %>"><% =i %></option>
<%
Next
%>
</select>Dieser Tag gef&auml;llt mir am Besten<br />
<input type="submit" name="submit" value="Abschicken" />
</form>
</p>
<%
End If
%>
</p>
</body>
</html>

In der booleschen Variablen bVollstaendig steht, ob das Formular vollständig ausgefüllt worden ist. Standardwert ist False, das heißt das Formular muss (ggf. erneut) angezeigt werden. Beim Formularversand wird der Wert der Variablen auf True gesetzt und dann die Felder einzeln auf Vollständigkeit überprüft. Wurde ein Feld nicht ausgefüllt, wird die Variable wieder auf False zurückgesetzt. Im <body>-Abschnitt dann wird der Wert der Variablen überprüft: Bei False wird das Formular angezeigt, bei True ein Dankestext.

Eine weitere Möglichkeit besteht darin, den Benutzer auf eine Dankesseite weiterzuleiten, wenn das Formular korrekt ausgefüllt worden ist. Dazu dient die Anweisung Response.Redirect. Als Parameter wird dazu die URL übergeben, auf die weitergeleitet werden soll.

Diese Anweisung muss vor dem ersten HTML-Code ausgeführt werden. Oder, mit anderen Worten: Sobald Sie HTML-Ausgaben haben, können Sie Response.Redirect nicht mehr einsetzen.

Im obigen Beispiel lässt sich die Weiterleitung schnell einbauen. Aus Platzgründen wiederholen wir hier nicht das komplette, doch ziemlich lange Listing, sondern nur das Codestück vor <!DOCTYPE:

Listing 18.15: weiterleitung.asp (Ausschnitt)

<%
Option Explicit
Dim bVollstaendig, i
bVollstaendig = False
If Request.Form("submit")="Abschicken" Then
bVollstaendig = True

If Request.Form("Geschlecht") = "" Then
bVollstaendig = False
End If
If Request.Form("Vorname") = "" Then
bVollstaendig = False
End If
If Request.Form("Nachname") = "" Then
bVollstaendig = False
End If
If Request.Form("Windows") = "" And Request.Form("Linux") = "" Then
bVollstaendig = False
End If
End If

If bVollstaendig = True Then
Response.Redirect "danke.asp"
End If
%>

Auf der Seite danke.asp (im selben Verzeichnis wie das Formular selbst) steht dann ein geeigneter Dankestext.

18.5 Mit Dateien arbeiten

Das Thema Dateihandling ist auch in ASP vorgesehen worden. Auch hier gibt es mannigfaltige Einsatzmöglichkeiten, wir beschränken uns aber hier aus Platz- und Zeitgründen (die Sonne dürfte nun auch bei Ihnen schon fast untergegangen sein) auf das Schreiben in eine Datei. Um dies zu bewerkstelligen, müssen Sie den folgenden Code verwenden:

<%
Dim objFSO, objFile
Set objFSO = Server.CreateObject("Scripting.FileSystemObject")
Set objFile = objFSO.OpenTextFile("formular.txt", 8, True)
%>

Damit öffnen Sie eine Verbindung zur Datei formular.txt. Der Wert 8 bedeutet, dass an diese Datei Daten angehängt werden (zum Überschreiben müssten Sie hier eine 2 angeben). Nun können Sie mit objFile.Write "Text" einen Text in die Datei schreiben; objFile.WriteLine "Text" schreibt außer dem String auch noch einen Zeilensprung in die Datei.

Am Ende der Schreiboperationen können Sie die Datei wieder schließen, und im System belegte Ressourcen wieder freigeben. Das geht folgendermaßen:

<%
objFile.Close 'Schließt Datei
Set objFile = Nothing 'Löscht Objekt aus dem Speicher
Set objFSO = Nothing 'Löscht Objekt aus dem Speicher
%>

Das war auch schon alles - zumindest alles, was fürs Schreiben in eine Datei interessant ist. Viele Hoster bieten keinen Datenbankzugriff in Ihren Paketen an, Schreibzugriffe sind aber oftmals möglich. Aus diesem Grund kann es sich lohnen, Formulareingaben in einer Textdatei zu speichern. Im folgenden Beispiel wollen wir dies einmal mit dem altbekannten Formular durchführen. Die Formularangaben werden in eine Textdatei geschrieben, und dabei durch Tabulatorzeichen voneinander getrennt. Dies hat den Vorteil, dass die Textdatei später einmal leicht in eine Tabellenkalkulation wie beispielsweise Excel oder auch in eine Datenbank importiert werden kann.

Es fehlt Ihnen nur noch ein Detail, um das durchführen zu können. Wie erzeugen Sie ein Tabulatorsymbol? Die Antwort: Mit vbTab.

Im Folgenden nun schon das Listing, das die Daten in die Textdatei schreibt. Die Vollständigkeitsüberprüfung haben wir hier aus Gründen der Einfachheit weggelassen, Sie können sie aber wie oben gezeigt implementieren.

Listing 18.16: dateizugriff.asp

<%
Option Explicit
Dim i
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Formulare</title>
</head>
<body bgcolor="white">
<%
If Request.Form("submit")="Abschicken" Then
Dim objFSO, objFile
Set objFSO = Server.CreateObject("Scripting.FileSystemObject")
Set objFile = objFSO.OpenTextFile("formular.txt", 8, True)
objFile.Write Request.Form("Vorname") & vbTab
objFile.Write Request.Form("Nachname") & vbTab
objFile.Write Request.Form("Geschlecht") & vbTab
objFile.Write Request.Form("Windows") & vbTab
objFile.Write Request.Form("Linux") & vbTab
objFile.WriteLine Request.Form("Tag")
objFile.Close
Set objFile = Nothing
Set objFSO = Nothing
Response.Write "<p>Vielen Dank f&uuml;r Ihre Angaben!</p>"
Else
%>
<h3>Formular (POST)</h3>
<p>
<form method="post">
<input type="text" name="Vorname" size="20" />Vorname<br />
<input type="text" name="Nachname" size="20" />Nachname<br />
<input type="radio" name="Geschlecht" value="m">m&auml;nnlich
<input type="radio" name="Geschlecht" value="f">weiblich<br />
Ich nutze
<input type="checkbox" name="Windows" value="ja">Windows
<input type="checkbox" name="Linux" value="ja">Linux<br />
<select name="Tag" size="1">
<%
For i=1 To 21
%>
<option value="<% =i %>"><% =i %></option>
<%
Next
%>
</select>Dieser Tag gef&auml;llt mir am Besten<br />
<input type="submit" name="submit" value="Abschicken" />
</form>
</p>
<%
End If
%>
</body>
</html>

Der Speicherort der Datei formular.txt ist je nach System unterschiedlich, meistens befindet sich die Datei im Hauptverzeichnis der Festplatte C:. Sie können jedoch einen absoluten Pfad zur Datei angeben und diese somit an einem beliebigen Ort ablegen. Achten Sie aber unbedingt darauf, dass die Datei nicht via HTTP (also über Eingabe einer URL) heruntergeladen werden kann, das ist ein großes Sicherheitsloch (jeder könnte dann mit ein bisschen Raten auf die Datei zugreifen und dann alle Formulareinträge lesen).

Abbildung 18.19:  Die Datei formular.txt im Editor

18.6 Cookies

HTTP, das HyperText Transfer Protocol, das für den Datenfluss im World Wide Web zuständig ist, arbeitet nach folgendem Prinzip: Verbindung aufbauen - Daten schicken - Verbindung schließen. Wenn Sie also eine halbe Stunde lang auf der Website des Markt+Technik Verlags (www.mut.de) herumsurfen, dann wird eine Vielzahl von Verbindungen zum Webserver geöffnet und auch wieder geschlossen. Der Webserver jedoch weiß eigentlich nicht, dass das genau eine Person war, die permanent Daten von ihm angefordert hat. Aus diesem Grund hat Netscape, die Firma, die auch den gleichnamigen Browser entwickelt hat, das Konzept der Cookies ersonnen. Cookies sind kleine Textinformationen, die auf der Festplatte des Browsers abgelegt werden und bei jeder neuen Anforderung an den Webserver wieder mitgeschickt werden.

Wir wollen uns auch hier aus den Diskussionen über Sinn und Unsinn von Cookies heraushalten, aber wir vertreten die Meinung, dass Cookies (richtig eingesetzt) nicht schädlich sind, und dass es bei manchen Applikationen zu Cookies auch keine wirklichen Alternativen gibt - insbesondere in Verbindung mit ASP.

Was sind Cookies?

Um das Konzept der Cookies noch einmal zu verdeutlichen: Stellen Sie sich vor, Ihr Name ist in einem Cookie gespeichert. Bei jeder Anfrage an den Webserver wird diese Information mitgeschickt. Auf der Serverseite kann nun beispielsweise ein ASP-Skript diesen Namen auslesen und auf jeder Seite ausgeben, Sie haben also eine einfache Form der Personalisierung.

Bei der Verwendung von Cookies gibt es aber eine Reihe von Einschränkungen:

Die offizielle Cookie-Spezifikation finden Sie im Internet unter http://www.netscape.com/ newsref/std/cookie_spec.html. Die dortigen Angaben haben jedoch Empfehlungscharakter, und es liegt in den Händen der Browserhersteller, wie sie die dortigen Vorgaben umsetzen. Aus diesem Grund haben wir die Formulierungen oben, insbesondere in Bezug auf die Obergrenzen, absichtlich unscharf gelassen.

Cookies mit ASP

Wie Sie gesehen haben, können Sie auch mit JavaScript Cookies setzen. Dies ist aber nur eine Art Entgegenkommen der Browserhersteller, denn normalerweise gelten die folgenden Maxime:

Sie müssen also unterscheiden, ob Sie Cookies setzen oder lesen möchten.

Cookies setzen

Wie bereits erwähnt, werden Cookies vom Server als Teil der HTTP-Header- Informationen gesetzt. Von ASP-Seiten aus steht Ihnen hierzu die Kollektion Response.Cookies zur Verfügung. Sie können folgendermaßen ein Cookie setzen:

<%
Response.Cookies("Name") = "Erik"
%>

Dieser Code muss vor jeder HTML-Ausgabe stehen, damit der ASP-Interpreter die Cookie-Informationen in den HTTP-Header schreiben kann!

Hier ein etwas längeres Beispiel: Der Benutzer gibt seine Lieblingsfarbe in ein Texteingabefeld ein; sie wird dann als Cookie gespeichert:

Listing 18.17: cookie_schreiben1.asp

<%
If Request.Form("submit") = "Abschicken" Then
Response.Cookies("Farbe") = Request.Form("Farbe")
End If
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Cookies</title>
</head>
<body bgcolor="white">
<h2>Cookies</h2>
<%
If Request.Form("submit") = "Abschicken" Then
%>
Sie haben <% =Request.Form("Farbe") %>
als Ihre Lieblingsfarbe angegeben!
<%
Else
%>
<form method="post">
<input type="text" name="Farbe" size="20" /> Lieblingsfarbe<br />
<input type="submit" name="submit" value="Abschicken">
</form>
<%
End If
%>
</body>
</html>

Abbildung 18.20:  Der Browser will einen Cookie setzen

Cookies dauerhaft speichern

Wenn Sie, wie zuvor beschrieben, einen Cookie setzen, dann wird der wieder automatisch gelöscht, wenn Sie den Browser beenden. Man spricht in diesem Zusammenhang auch von temporären Cookies. Interessant sind jedoch oft nur Cookies, die auch beim nächsten Browserstart noch zur Verfügung stehen. Man nennt diese Cookies auch permanent. Unendlich lang gültige Cookies gibt es nicht - und aufgrund der Mengenbeschränkung von 300 Stück ist das auch schwer zu realisieren. Aber Sie können Cookies ein Ablaufdatum mit auf den Weg geben, und diese werden dann so lange im Datenspeicher des Browsers gehalten.

Um das mit ASP zu realisieren, müssen Sie die Eigenschaft Expires des entsprechenden Cookies auf den gewünschten Datumswert setzen:

<%
Response.Cookies("Name") = "Erik"
Response.Cookies("Erik").Expires = "24.12.2001 23:45:56"
%>

Es stellt sich nun die Frage, wie lange dieser Cookie überhaupt gültig sein soll. Manche Leute empfehlen, das Ablaufdatum sehr weit in die Ferne zu setzen, beispielsweise ins Jahr 2037; das ist jedoch relativ unfreundlich denjenigen Leuten gegenüber, die nur durch Zufall auf die Seite gestoßen sind und sicher nicht wieder so bald dorthin zurückkehren werden. Aus diesem Grund empfehlen wiederum andere Leute, das Ablaufdatum recht bald zu setzen, also beispielsweise zwei Monate nach Erstellung der Webseiten. Auch dieses Vorgehen bringt Nachteile mit sich, denn wenn Sie solch ein Datum in Ihren Code schreiben, müssen Sie diesen Code regelmäßig auf neue Datumswerte aktualisieren.

Das wohl beste Vorgehen vereint die beiden oben genannten Möglichkeiten. Das Ablaufdatum wird zwar recht bald gesetzt - beispielsweise zwei Monate in der Zukunft - aber es wird auf zwei Monate nach dem aktuellen Datum gesetzt. Wenn der Benutzer die Seiten erneut besucht, bekommt er einen neuen Cookie, der dann wiederum zwei Monate lang gültig ist und den alten Cookie überschreibt.

Die Umsetzung dieses Plans in ASP ist einfacher als Sie denken:

<%
Response.Cookies("Name") = "Erik"
Response.Cookies("Erik").Expires = Date + 60
%>

Der Ausdruck Date + 60 liefert ein Datum, das 60 Tage nach dem aktuellen Datum liegt (wenn Sie Wert auf Sekundengenauigkeit legen, können Sie auch Now + 60 verwenden). So haben Sie mit sehr wenig Aufwand ein stets akkurates Ablaufdatum. Mit diesem neuen Wissen lässt sich das Beispiel von zuvor mit der Lieblingsfarbe erweitern:

Listing 18.18: cookie_schreiben2.asp

<%
If Request.Form("submit") = "Abschicken" Then
Response.Cookies("Farbe") = Request.Form("Farbe")
Response.Cookies("Farbe").Expires = Date + 60
End If
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Cookies</title>
</head>
<body bgcolor="white">
<h2>Cookies</h2>
<%
If Request.Form("submit") = "Abschicken" Then
%>
Sie haben <% =Request.Form("Farbe") %>
als Ihre Lieblingsfarbe angegeben!
<%
Else
%>
<form method="post">
<input type="text" name="Farbe" size="20" /> Lieblingsfarbe<br />
<input type="submit" name="submit" value="Abschicken">
</form>
<%
End If
%>
</body>
</html>

Abbildung 18.21:  Die Lieblingsfarbe wird drei Monate lang gespeichert

Cookies löschen

Um ein Cookie zu löschen, brauchen Sie auch keinen großen Aufwand zu treiben. Sie könnten natürlich den Wert des Cookies auf einen leeren String setzen, aber dann bleibt der Cookie (wenn auch ohne Wert) weiterhin im System des Surfers bestehen und belegt dort Speicher. Besser ist es, das Ablaufdatum des Cookies auf einen Wert in der Vergangenheit zu setzen; der Browser entfernt dann den Cookie automatisch:

<%
Response.Cookies("Erik").Expires = Now - 1
%>

Im Browser sehen Sie dann - sofern Sie Warnmeldungen beim Eintreffen von Cookies aktiviert haben - etwas Merkwürdiges (siehe ): Obwohl Sie als Ablaufdatum den gestrigen Tag angegeben haben, schlägt der Browser als Ablaufdatum den 1. Januar 1970, 1 Uhr und 1 Sekunde vor.

Abbildung 18.22:  Das Ablaufdatum beim Löschen eines Cookies

Das hat historische Gründe: Unter Unix/Linux wird die aktuelle Zeit als Anzahl der seit dem 1. Januar 1970 verstrichenen Millisekunden angegeben (auch Epoche genannt). Das vom Browser vorgeschlagene Ablaufdatum ist also eines der frühestmöglichen Datumswerte im System, auch wenn Sie ein anderes - in der Vergangenheit liegendes - Datum angegeben haben. Gelöscht wird das Cookie aber allemal.

Cookies auslesen

Nachdem wir uns so lange über das Setzen von Cookies ausgelassen haben, werfen wir nun endlich einen Blick auf die andere Seite: Nämlich das Auslesen von Cookies. Wie bereits erwähnt: Wenn Sie serverseitig ein Cookie auslesen wollen, müssen Sie die HTTP- Anforderung des Clients untersuchen. Dazu ist unter ASP das Request-Objekt zuständig, welches Sie beispielsweise schon von den Formularen her kennen. Alle Cookies stehen in der Kollektion Request.Cookies, und Sie können beispielsweise so auf ein Cookie zugreifen:

<%
Response.Write "Wert im Cookie 'Name': " & Request.Cookies("Name")
%>

Auch hier gibt es wieder eine kleine Abkürzung: Mit Request("Name") geht es auch! Zunächst wird untersucht, ob Request.Form("Name") existiert, dann ob es Request. QueryString("Name") gibt, und dann, ob Request.Cookies("Name") etwas liefert.

Wenn Sie mit Formularen arbeiten, sollten Sie also die Abkürzung eher selten einsetzen, nicht dass Sie dann irgendwann mit einem gleichnamigen Cookie Probleme haben.

Praxisbeispiel

Zu Cookies gibt es mehrere Einsatzbeispiele. Beispielsweise kann in einem Cookie der aktuelle Warenkorb bei einer Shoppinglösung gespeichert werden, oder in einem geschützten Bereich der Login-Name des Benutzers. Ebenso kann gezählt werden, wie oft der Benutzer schon auf der aktuellen Seite war, und ob er ein bestimmtes JavaScript- Popup-Fenster schon gesehen hat. Wir wollen hier aber eine andere Anwendungsmöglichkeit zeigen, und zwar, wie Sie mit Cookies recht schnell eine personalisierte Website erstellen können. Im einfachsten Beispiel kommen wir auf den vorherigen Code mit der Lieblingsfarbe zurück. Der dort eingegebene Wert wird als Hintergrundfarbe auf jeder Seite verwendet. Wie das Cookie gespeichert wird, haben Sie bereits vorher gesehen; jetzt werfen wir einen Blick auf die Ausgabeseite. Der Wert im Cookie wird einfach als bgcolor-Attribut des <body>-Tags eingesetzt.

Ein paar Sicherheitsvorkehrungen haben wir eingebaut. Ist das Cookie nicht gesetzt (oder leer), wird als Hintergrundfarbe Weiß eingesetzt. Ebenso werden öffnende und schließende spitze Klammern herausgefiltert, denn die haben ja in HTML eine besondere Bedeutung (und so könnte ein böswilliger Surfer über den Umweg mit der Hintergrundfarbe beispielsweise JavaScript-Code in die Seiten einbauen).

Listing 18.19: lieblingsfarbe.asp

<%
Option Explicit
Dim strFarbe
strFarbe = Request.Cookies("Farbe")
strFarbe = Replace(strFarbe, "<", "")
strFarbe = Replace(strFarbe, ">", "")
If strFarbe = "" Then
strFarbe = "white"
End If
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN
http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Personalisierung</title>
</head>
<body bgcolor="<% =strFarbe %>">
<h2>Willkommen auf Ihrer personalisierten Seite!</h2>
<p>Ihre Lieblingsfarbe ist: <% =strFarbe %>.</p>
</body>
</html>

Abbildung 18.23:  Die Lieblingsfarbe wird als Hintergrundfarbe verwendet

Ihren eigenen Ideen sind somit kaum mehr Grenzen gesetzt. Wenn Sie sich weiter in ASP einarbeiten wollen, am Anfang dieses Tages finden Sie einen Literaturhinweis. Auf alle Fälle sollten Sie sich noch die VBScript-Dokumentation von Microsoft herunterladen, denn diese enthält eine komplette Befehlsübersicht und ist somit eine unverzichtbare Hilfe für den ASP-Programmierer. Sie finden die Dokumentation momentan unter der URL http://msdn.microsoft.com/scripting/vbscript/download/vbsdoc.exe.

Und noch ein Hinweis: Sollte Ihnen dieser Tag recht lange vorgekommen sein - keine Bange, morgen geht es etwas ruhiger zu, auch wenn wir ein komplett neues Thema betrachten: PHP, die Open Source-Konkurrenz zu ASP!

18.7 Fragen und Antworten

Frage:
Wie bekomme ich in ASP heraus, von welcher Seite der Benutzer herkam? Welche IP- Adresse er hat?

Antwort:
All dies (und noch viel mehr) steht in der Kollektion Request.ServerVariables. Sie können diese mit For-Each durchschreiten und sich die interessanten Werte ausgeben lassen. Um die Frage zu beantworten: Verwenden Sie Request.ServerVariables("HTTP_REFERER") bzw. Request.ServerVariables("REMOTE_ADDR").

Frage:
Wie kann ich einen numerischen Wert in einen Integerwert umwandeln und umgekehrt?

Antwort:
ASP bietet dazu Funktionen an, die Sie in der Dokumentation finden (unter »C«). Besonders einfach - wenn auch etwas unsauber - geht es folgendermaßen: Integers werden zu Strings, wenn Sie die Integervariable mit »« konkatenieren. Strings werden zu Integer-Werten (oder auch zu Floats), wenn Sie sie mit 1 multiplizieren.

Frage:
Kann ich mit ASP ein wenig HTML-Code ausgeben, und dann nach ein paar Sekunden den Benutzer auf eine andere Seite weiterleiten?

Antwort:
Nein, das geht nur mit clientseitigen Mitteln. In den vorhergehenden beiden Wochen haben Sie dazu Mittel und Wege kennen gelernt, sowohl mit HTML als auch mit JavaScript.

Frage:
Kann ich mit ASP die Bildschirmauflösung des Benutzers herausbekommen?

Antwort:
Nein! ASP ist eine serverseitige Technologie, und damit können Sie solche clientseitigen Informationen nicht erhalten. Verwenden Sie auch hier JavaScript.

Frage:
Ich will eine Datei im aktuellen Verzeichnis erstellen. Wie gehe ich vor, wenn ich nicht den absoluten Pfad auf der Festplatte eingeben will (denn dann kann ich recht schlecht mit der Anwendung auf einen anderen Server umziehen)?

Antwort:
Durch Server.MapPath("datei.txt") bekommen Sie den absoluten Pfad der Datei datei.txt im aktuellen (virtuellen) Verzeichnis heraus.

Frage:
Immer, wenn ich eine Datei erstellen will, erhalte ich als Meldung »Permission denied« oder »Zugriff verweigert«. Was kann ich tun?

Antwort:
Sie haben offensichtlich keine Schreibrechte in das aktuelle Verzeichnis oder die aktuelle Datei. Bei Dateien überprüfen Sie bitte, ob der Schreibschutz aktiviert ist; andernfalls bitten Sie Ihren Administrator (oder Provider) um Hilfe. Viele Provider ermöglichen nur auf Nachfrage Schreibrechte in bestimmte Verzeichnisse.

18.8 Workshop

Der Workshop enthält Quizfragen, die Ihnen helfen sollen, Ihr Wissen zu festigen, und Übungen, die Sie anregen sollen, das eben Gelernte umzusetzen und eigene Erfahrungen zu sammeln. Versuchen Sie, das Quiz und die Übungen zu beantworten und zu verstehen, bevor Sie zur Lektion des nächsten Tages übergehen.

Quiz

  1. Ist ASP eine Programmiersprache?
  2. Wozu dient Option Explicit?
  3. Ist das Gleichheitszeichen im VBScript ein Vergleichs- oder ein Zuweisungsoperator?
  4. Was ist der Hauptunterschied zwischen If-Then und Select Case?
  5. Mit welchen Schleifen können Sie besonders bequem auf alle Arrayelemente zugreifen?
  6. Was passiert, wenn Sie das action-Attribut eines Formulars leer lassen?
  7. Wie greifen Sie auf alle ausgewählten Elemente einer Auswahlliste zu, die mit <select multiple> erstellt worden ist?
  8. Wozu ist der zweite Parameter von OpenTextFile gut?
  9. Was ist der Hauptunterschied beim Lesen und beim Setzen von Cookies?

Übungen

  1. Begrüßen Sie auf einer ASP-Seite Ihre Besucher je nach Tageszeit (»Guten Morgen« etc.)!
  2. Erweitern Sie die Vollständigkeitsüberprüfung des Formulars aus diesem Kapitel! Momentan ist es so, dass bei nicht vollständiger Ausfüllung das Formular erneut angezeigt wird, aber komplett leer. Sorgen Sie dafür, dass bereits eingegebene Werte stehen bleiben.
  3. Fassen Sie die Listings zum Thema Personalisierung zusammen: Auf einer ASP-Seite erscheint entweder die angegebene Hintergrundfarbe, oder der Benutzer wird zu ihrer Eingabe aufgefordert.



vorheriges KapitelInhaltsverzeichnisStichwortverzeichnisFeedbackKapitelanfangnächstes Kapitel


1

© Markt+Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH