Die Syntax von ASP-Applikationen
Hello World! als Active Server Pages
Das Kombinieren verschiedener Script-Sprachen
Schleifen für sich wiederholende Aufgaben
Das Benutzen von »Conditional Statements« zur Ablaufsteuerung
Die Benutzung von Server-Side Includes
Die Entwicklung von wiederverwendbaren Subroutinen
Die Entwicklung von ASP-Seiten mit Client-seitigen Scripts
Hello World! mit Active Server Pages - die personalisierte Version
2
Grundlagen der ASP-Applikations-Entwicklung
In diesem Kapitel erlernen Sie die Grundlagen der ASP-Applikations-Programmierung. Arbeiten Sie dieses Kapitel sorgfältig durch, da hier das Fundament für alle weiteren Kapitel gelegt wird. Die Grundlagen der ASP-Applikations-Programmierung sind sehr einfach zu verstehen und bauen auf simplen HTML-Tags, die eine typische Web-Seite in eine ASP-Applikation konvertieren. Um ASP-Applikationen zu entwickeln, sollten Sie des weiteren mit Script-Sprachen, wie beispielsweise VBScript, JScript oder Perl, vertraut sein. Sämtliche Beispiele in diesem Buch basieren auf VBScript, das in seinen Grundlagen noch einmal im Anhang Erklärung findet.
Die Syntax von ASP-Applikationen
Bevor Sie damit beginnen, ASP-Applikationen zu entwickeln, ist es wichtig zu verstehen, wie deren Syntax lautet. Eine ASP-Applikation ist nichts anderes als eine Web-Seite mit zusätzlichen Script-Befehlen, die auf dem entsprechenden Web-Server ausgeführt werden. ASP-Applikationen bestehen aus folgenden Elementen:
Die einzigen Unterschiede zwischen einer typischen Web-Seite und einer ASP-Applikation ist das Vorhandensein eines ASP-Script-Delimiters. Das Listing 2.1 zeigt eine typische ASP-Applikation mit verschiedenen Script-Delimitern. Die Bildschirmausgabe der ASP-Applikation aus Listing 2.1 sehen Sie in Abbildung 2.1.
Listing 2.1: Die Komponenten einer typischen ASP-Applikation
1: <%@ LANGUAGE="VBSCRIPT" %>
2:
3: <SCRIPT RUNAT=SERVER LANGUAGE=VBSCRIPT>
4:
5: Sub SayHello ()
6:
7: Response.Write("<H1>Hello! Today's date is " & Date & " </H1>")
8:
9: End Sub
10:
11: </SCRIPT>
12:
13: <HTML>
14: <HEAD>
15: <META NAME="GENERATOR" Content="Microsoft Visual InterDev 1.0">
16: <META HTTP-EQUIV="Content-Type" content="text/html;
charset=iso-8859-1">
17: <TITLE>Syntax of ASP Applications</TITLE>
18: </HEAD>
19: <BODY bgcolor="#DBFFBF" link="#0000FF" vlink="#800080">
20:
21: <!-- Insert HTML here -->
22:
23: <%= "<H2>This line of text is displayed as output </H2>" %>
24:
25: <%
26:
27: Call SayHello ()
28: Response.Write ("<HR>")
29:
30: %>
31:
32: </BODY>
33: </HTML>
Abbildung 2.1: |
Die Script-Sprache, die von der ASP-Applikation benutzt wird, ist durch das Statement <%@ LANGUAGE="VBSCRIPT" %> näher spezifiziert. Dieses Statement wurde zum Anfang der ASP-Applikation plaziert, wie aus Zeile 1 des Programm-Codes zu ersehen ist. Sämtliche ASP-Subroutinen sind zwischen den Delimitern <SCRIPT RUNAT=SERVER LANGUAGE=VBSCRIPT> und </SCRIPT> eingebettet. Das Argument LANGUAGE spezifiziert die Script-Sprache der Subroutine näher. Schauen Sie sich doch mal die Zeilen 3 bis 11 an, dort finden Sie ein Beispiel für eine ASP-Subroutine.
|
Das Schlüsselwort LANGUAGE wird von verschiedenen Script-Sprachen wie JScript unterstützt. |
|
Das Statement RUNAT=SERVER wird dazu benötigt, dem Web-Server mitzuteilen, daß das Script auf dem jeweiligen Web-Server auszuführen ist. Anderenfalls werden die Kommandos in den HTML-Code integriert und zum Client versandt. |
Sie haben die Möglichkeit, Ausdrücke auf einfache Art und Weise mittels der Delimiter <%= und %> auszugeben. Der entsprechende Text muß sich zwischen den Begrenzern befinden. Um beispielsweise den Text This line of text is displayed as output auf einer Web-Seite auszugeben, müssen Sie dieses Text-String folgendermaßen bearbeiten: <%= "<H2>This line of text is displayed as output </H2>" %> (siehe Zeile 23). Weiterhin haben Sie die Möglichkeit, dasselbe Ergebnis mittels des Statements Response.Write zu erzielen. Dieses Statement findet dann Anwendung, wenn Sie die Ausgabe eines Wertes in der Mitte einer Subroutine benötigen.
Was Sie tun sollen |
Was nicht | |
Verwenden Sie Response.Write, um den Wert einer Aussage innerhalb eines ASP-Script-Blocks auszugeben (ein Script-Block befindet sich innerhalb der Delimiter <% und %>). |
||
Sogenannte Inline-ASP-Statements werden zwischen den Delimitern <% und %> plaziert, wie aus den Zeilen 25-30 des Programm-Codes zu ersehen ist. Der einzige Unterschied an dieser Stelle zu beispielsweise Inline-Images ist der, daß lediglich das ASP-Statement ausgegeben wird.
Hello World! als Active Server Pages
Es ist sehr einfach, diese klassische Applikation mittels ASP zu erstellen. Die Hello-World-Applikation aus Listing 2.2 sieht auf den ersten Blick wie eine ganz normale Web-Seite aus - bis auf die ASP-Statements! Im Gegensatz zu einer ganz normalen Web-Seite beinhaltet der Source-Code aus Listing 2.2 ASP-Script-Delimiters, deren verschiedene Statements auf dem Web-Server ausgeführt werden, bevor diese auf die Reise zum Anwender gehen. Der Befehl in Zeile 13 des Listings 2.2, <%= "Hello World!<BR> The time now is " & time & " on " & date %>, gibt den String Hello World! mit der aktuellen Zeit und dem Datum auf dem Bildschirm des Anwenders aus. Bitte beachten Sie an dieser Stelle, wie der VBScript-Operator (&) dazu benutzt wird, um zwei Strings miteinander zu verbinden, welche die Funktionen time und date ausgeben. Die Resultate von Listing 2.2 sehen Sie in Abbildung 2.2.
Listing 2.2: Die ASP-Version der klassischen Hallo-World!-Applikation
1: <%@ LANGUAGE="VBSCRIPT" %>
2:
3: <HTML>
4: <HEAD>
5: <META NAME="GENERATOR" Content="Microsoft Visual InterDev 1.0">
6: <META HTTP-EQUIV="Content-Type" content="text/html;
charset=iso-8859-1">
7: <TITLE>Hello World, Active Server Pages!</TITLE>
8: </HEAD>
9: <BODY bgcolor="#DBFFBF" link="#0000FF" vlink="#800080">
10:
11: <FONT SIZE=6 FACE="Comic Sans MS">
12:
13: <%= "Hello World!<BR> The time now is " & time & " on " & date %>
14:
15: </FONT>
16:
17: </BODY>
18: </HTML>
Abbildung 2.2: |
Hello World! in VBScript
ASP-Applikationen sind in der Lage, verschiedene VBScript-Kommandos zu benutzen. Die Applikation aus Listing 2.3 illustriert auf anschauliche Art und Weise die Benutzung von VBScript, um eine Subroutine innerhalb einer ASP-Applikation zu definieren. Die Zeilen 3-12 des Listings 2.3 beinhaltet eine VBScript-Subroutine, die das aktuelle Datum ausgibt. Im Anschluß daran führt die Programmzeile 22 die Subroutine fort. In Abbildung 2.3 sehen Sie die Ausgabe des Listings innerhalb eines Web-Browsers. Wie Sie sehen, können Sie auf sehr einfachem Wege VBScript dazu benutzen, um ASP-Applikationen zu entwickeln.
Listing 2.3: Die VBScript-Version unserer Hello-World!-Applikation
1: <%@ LANGUAGE="VBSCRIPT" %>
2:
3: <SCRIPT RUNAT=SERVER LANGUAGE=VBSCRIPT>
4:
5: Sub UserDefinedVBScriptFunction ()
6:
7: Response.Write("<H2>UserDefinedVBScriptFunction has been
called.<BR>")
8: Response.Write("Today's date is " & Date )
9:
10: End Sub
11:
12: </SCRIPT>
13:
14: <HTML>
15: <HEAD>
16: <META NAME="GENERATOR" Content="Microsoft Visual InterDev 1.0">
17: <META HTTP-EQUIV="Content-Type" content="text/html;
charset=iso-8859-1">
18: <TITLE>Hello World, VBScript!</TITLE>
19: </HEAD>
20: <BODY bgcolor="#DBFFBF" link="#0000FF" vlink="#800080">
21:
22: <% Call UserDefinedVBScriptFunction %>
23:
24: </BODY>
25: </HTML>
Abbildung 2.3: |
Hello World! in JScript
ASP-Applikationen können JScript benutzen, um verschiedene Kommandos auszuführen. Die Applikation in Listing 2.4 zeigt die Implementierung von JScript, um Subroutinen innerhalb von ASP-Applikationen zu definieren. Die Zeilen 3 bis 13 definieren eine JScript-Subroutine, welche die aktuelle Uhrzeit ausgibt. Die entsprechende Subroutine wird im Anschluß daran in Zeile 23 ausgeführt. Die Ausgaben des Listings 2.4 können Sie aus Abbildung 2.4 ersehen.
Listing 2.4: Die JScript-Version der Hello-World-Applikation
1: <%@ LANGUAGE="VBSCRIPT" %>
2:
3: <SCRIPT RUNAT=SERVER LANGUAGE=JSCRIPT>
4:
5: function UserDefinedJScriptFunction ()
6: {
7: var DateObject = new Date()
8: Response.Write("<H2>UserDefinedJScriptFunction has been
called.<BR>")
9: Response.Write("The current time is " + DateObject.getHours()
+ " : " +
10: DateObject.getMinutes() + " : " +
DateObject.getSeconds())
11: }
12:
13: </SCRIPT>
14:
15: <HTML>
16: <HEAD>
17: <META NAME="GENERATOR" Content="Microsoft Visual InterDev 1.0">
18: <META HTTP-EQUIV="Content-Type" content="text/html;
charset=iso-8859-1">
19: <TITLE>Document Title</TITLE>
20: </HEAD>
21: <BODY bgcolor="#DBFFBF" link="#0000FF" vlink="#800080">
22:
23: <% Call UserDefinedJScriptFunction %>
24:
25: </BODY>
26: </HTML>
Abbildung 2.4: |
Das Kombinieren verschiedener Script-Sprachen
Es ist möglich, verschiedene Script-Sprachen innerhalb einer ASP-Applikation zu kombinieren. Listing 2.5 demonstriert dies auf anschauliche Weise. Sie sollten jedoch darauf achten, jeweils nur eine Script-Sprache innerhalb einer Subroutine zu benutzen, die klare Ein- und Ausgaben definiert. Die Zeilen 3 bis 12 definieren eine VBScript-Subroutine, denen eine JScript-Subroutine in den Zeilen 15 bis 25 folgt. Beide Subroutinen werden in den Zeilen 36 und 39 aufgerufen. Das Ergebnis des Listings 2.5 sehen Sie in Abbildung 2.5.
Was Sie tun sollen |
Was nicht | |
Entscheiden Sie sich für eine Script-Sprache. Mixen Sie Script-Sprachen nur dann miteinander, wenn Sie dafür wirklich sehr gute Gründe haben. |
||
Listing 2.5: Verschiedene Script-Sprachen innerhalb einer Applikation
1: <%@ LANGUAGE="VBSCRIPT" %>
2:
3: <SCRIPT RUNAT=SERVER LANGUAGE=VBSCRIPT>
4:
5: Sub UserDefinedVBScriptFunction ()
6:
7: Response.Write("<H2>UserDefinedVBScriptFunction has been
called.<BR>")
8: Response.Write("Today's date is " & Date )
9:
10: End Sub
11:
12: </SCRIPT>
13:
14:
15: <SCRIPT RUNAT=SERVER LANGUAGE=JSCRIPT>
16:
17: function UserDefinedJScriptFunction ()
18: {
19: var DateObject = new Date()
20: Response.Write("<H2>UserDefinedJScriptFunction has been
called.<BR>")
21: Response.Write("Today's time is " + DateObject.getHours()
+ " : " +
22: DateObject.getMinutes() + " : " +
DateObject.getSeconds())
23: }
24:
25: </SCRIPT>
26:
27: <HTML>
28: <HEAD>
29: <META NAME="GENERATOR" Content="Microsoft Visual InterDev 1.0">
30: <META HTTP-EQUIV="Content-Type" content="text/html;
charset=iso-8859-1">
31: <TITLE>Mixing Scripting Languages</TITLE>
32: </HEAD>
33: <BODY bgcolor="#DBFFBF" link="#0000FF" vlink="#800080">
34:
35: <H1>About to call VBScript subroutine</H1>
36: <% Call UserDefinedVBScriptFunction %>
37:
38: <H1>About to call JScript subroutine</H1>
39: <% Call UserDefinedJScriptFunction %>
40:
41: </BODY>
42: </HTML>
Abbildung 2.5: |
Schleifen für sich wiederholende Aufgaben
Schleifen, auch Loops genannt, benutzt man im allgemeinen dazu, um gewisse Aufgaben immer wieder auszuführen. Die Applikation aus Listing 2.6 demonstriert die Funktionsweise einer Schleife innerhalb einer ASP-Applikation - im vorliegendem Beispiel zum »Aufpeppen« der Hello-World!-Applikation. Die Schleife zwischen den Zeilen 15 bis 26 zeigt den String Hello World! an, aber jeweils immer nur einen Buchstaben zu einer bestimmten Zeit. Im Anschluß daran folgt dem Buchstaben ein immer länger werdender Balken (Farbe schwarz). Das Ergebnis des Scripts können Sie in Abbildung 2.6 sehen.
|
Sie haben die Möglichkeit, auch mehrere Schleifen ineinander zu verschachteln, um mehrere Aktionen zur gleichen Zeit durchzuführen. |
Listing 2.6: Schleifen erledigen verschiedene Aufgaben zur gleichen Zeit
1: <%@ LANGUAGE="VBSCRIPT" %>
2:
3: <HTML>
4: <HEAD>
5: <META NAME="GENERATOR" Content="Microsoft Visual InterDev 1.0">
6: <META HTTP-EQUIV="Content-Type" content="text/html;
charset=iso-8859-1">
7: <TITLE>Hello World!</TITLE>
8: </HEAD>
9: <BODY bgcolor="#DBFFBF" link="#0000FF" vlink="#800080">
10:
11: <FONT SIZE=3 FACE="ARIAL">
12:
13: <%
14: Greeting = "HELLO WORLD!"
15: For RowCount = 1 to Len(Greeting)
16: %>
17:
18: <TABLE>
19: <TR>
20: <TD BGCOLOR=000000 WIDTH=<%= (RowCount^2)+(RowCount*15)%>>+</TD>
21: <TD><%= Left(Greeting,1) %></TD></TR>
22: </TABLE>
23:
24: <%
25: Greeting = Right(Greeting, Len(Greeting)-1)
26: Next
27: %>
28:
29: </FONT>
30:
31: <HR>
32:
33: <B>The time now is <%= Time %> on <%= Date %>.</B>
34:
35: </BODY>
36: </HTML>
Abbildung 2.6: |
Das Benutzen von »Conditional Statements« zur Ablaufsteuerung
Bedingungen werden dazu benutzt, um den Fluß einer ASP-Applikation zu kontrollieren. Die Applikation aus Listing 2.7 benutzt ein If...Then...Else, um eine Grußbotschaft in Abhängigkeit von der Uhrzeit auszugeben (siehe Abbildung 2.7).
Listing 2.7: Conditional Statements dienen der Ablaufsteuerung
1: <%@ LANGUAGE="VBSCRIPT" %>
2: <HTML>
3: <HEAD>
4: <META NAME="GENERATOR" Content="Microsoft Visual InterDev 1.0">
5: <META HTTP-EQUIV="Content-Type" content="text/html;
charset=iso-8859-1">
6: <TITLE>Conditional Statements</TITLE>
7: </HEAD>
8: <body bgcolor="#DBFFBF" link="#0000FF" vlink="#800080">
9: <H1> Hi! </H1>
10: <FONT Face="Comic Sans MS" Size=6>
11: <%
12: If (Hour(Time) < 12) Then
13: Response.Write "Good morning!"
14: ElseIf (Hour(Time) < 3) Then
15: Response.Write "Good afternoon!"
16: Else
17: Response.Write "Good evening!"
18: End If
19: %>
20: </FONT>
21: <HR>
22: The current time is <%= Time %>.
23: </BODY>
24: </HTML>
Abbildung 2.7: |
Die Benutzung von Server-Side Includes
»Server-Side Includes« (SSI) können in Verbindung mit Active Server Pages verwendet werden. Sollten Sie nicht mit C/C++ vertraut sein, so stellt SSI eine gute Möglichkeit dar, um ASP-Subroutinen in andere Dateien einzubinden. So ist es etwa vorstellbar, eine separate Datei zu generieren, die Ihre ASP-Subroutinen enthält. Dank SSI haben Sie die Möglichkeit, diese Datei in andere ASP-Applikationen zu integrieren. Eine Subroutine innerhalb einer SSI-Datei könnte einen bestimmten Verkaufspreis einer Ware aus einem bestimmten Formular ermitteln. Zu einem späteren Zeitpunkt, wenn sich beispielsweise der Preis geändert hat, muß lediglich eine Datei aktualisiert werden. Andere ASP-Applikationen, die ebenfalls das SSI-File benutzen, benutzen automatisch das neue Formular mit den korrigierten Preisen. Es gibt insgesamt zwei Wege, um SSI-Dateien in ASP-Applikationen zu integrieren - virtuelle und relative Pfadangaben.
|
Sie können ASP-Statements nicht dazu benutzen, um eine neue Datei zu generieren, da ASP-Statements erst nach externen Dateien ausgeführt werden. |
Sie können Dateien implementieren, die relativ zum Hauptverzeichnis des Web-Servers liegen, indem Sie das folgende Statement beutzen: <!--#INCLUDE VIRTUAL="/VIRTUAL/Path/Of/File.inc"-->. Virtuelle Pfadangaben finden meist in Subroutinen vieler Applikationen Anwendung.
Folgendes Statement ist für eine relative Pfadangabe notwendig: <!--#INCLUDE FILE="RELATIVE/PATH/Of/File.inc"--> Derlei Pfadnamen werden vor allem dann verwendet, wenn es darum geht, gleichartige Subroutinen in eine Applikation zu implementieren.
Was Sie tun sollen |
Was nicht | |
Vergeben Sie die Datei-Extension ».inc« nur dann, wenn Sie mehrere Subroutinen verwenden, die in einer ASP-Applikation weiterhin Anwendung finden sollen. |
||
Die Entwicklung von wiederverwendbaren Subroutinen
Sollten Sie ASP-Subroutinen entwickeln, so versuchen Sie stets, einmal entwickelten Programm-Code immer wieder zu verwenden. Subroutinen machen die Programm-Entwicklung wesentlich effektiver und Ihre Applikationen effizienter.
Die Entwicklung von ASP-Seiten mit Client-seitigen Scripts
Es ist möglich, ASP-Applikationen unter Zuhilfenahme von Client-seitigen Scripts zu entwickeln. Indem Sie dies tun, nutzen Sie die Vorteile und umfangreichen Features des »Active Desktop«. Die Implementierung des Client-seitigen Script-Codes ist denkbar einfach, da dieser ganz einfach in die ASP-Applikation eingefügt wird. Der ASP-Interpreter ignoriert den Client-seitigen Code innerhalb einer ASP-Applikation und führt diesen nicht auf dem Server aus.
Hello World! mit Active Server Pages - die personalisierte Version
Es ist sehr einfach, eine interaktive Version der Hello-World!-Applikation zu entwickeln. Sobald Sie die Applikation aus Listing 2.8 eingegeben und gestartet haben, erscheint die aus Abbildung 2.8 ersichtliche Bildschirmausgabe. Diese neue Version erlaubt nun die Eingabe eines Namens.
Listing 2.8: Das altbekannte Script in einer personalisierten Version
1: <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
2: <html>
3:
4: <head>
5: <meta http-equiv="Content-Type"
6: content="text/html; charset=iso-8859-1">
7: <meta name="Template"
8: content="C:\PROGRA~1\MICROS~2\Office\html.dot">
9: <meta name="GENERATOR" content="Microsoft FrontPage 2.0">
10: <title>Hello World, Active Server Pages!
(Interactive Version)</title>
11: </head>
12:
13: <body bgcolor="#DBFFBF" link="#0000FF" vlink="#800080">
14:
15: <% IF (Request.QueryString("NameOfUser") = "") THEN %>
16:
17: <p>
18: <img src="/Graphics/Lines/Colorful_SquiggleD8.gif" width="424"
19: height="18">
20: </p>
21:
22: <table border="0" cellpadding="7" cellspacing="0" width="492">
23: <tr>
24: <td valign="top" bgcolor="#333333">Welcome to the
25: exciting and dynamic world of Web application development
26: with Active Server Pages! Please enter your name and
27: press the button!</td>
28: </tr>
29: </table>
30:
31: <p> </p>
32:
33: <form action="/ASP/HelloWorldInteractive.asp">
34: <p>Please enter your name here and press the button <input
35: type="text" size="20" maxlength="30" name="NameOfUser"
36: width="24"> <input type="submit"
37: value="Please press this button after typing your name."> </p>
38: </form>
39:
40: <% ELSE %>
41:
42: <p><font color="#000000" size="5">
43: <strong>Hello World!</strong>
44: </font></p>
45:
46: <p><font color="#FF0000" size="5" face="Arial">
47: <em><%= Request.QueryString("NameOfUser") %>,</em></font>
48: <font color="#0000FF" size="4" face="Comic Sans MS">
49: welcome to the fun and exciting world of ASP application
development!
50: </font></p>
51:
52: <form action="/ASP/HelloWorldInteractive.asp">
53: <p><input type="submit"
54: value="Please click here to start over again."> </p>
55: </form>
56:
57: <% END IF %>
58:
59: </body>
60: </html>
Abbildung 2.8: |
Nachdem der Anwender seinen Namen eingegeben hat, begrüßt die Applikation den User mit seinem Namen (siehe Abbildung 2.9). In Zeile 15 wird die Variable NameOfUser dazu benutzt, um festzustellen, ob der Anwender überhaupt einen Namen eingegeben hat. Ist dies nicht der Fall, fragt die Applikation erneut nach einem Namen. Anwendung findet an dieser Stelle die Methode Request.QueryString.
Abbildung 2.9: |
Zusammenfassung
Active Server Pages können benutzt werden, um auf einfache Art und Weise Web-Applikationen zu entwickeln und diese im Internet zu veröffentlichen. Die Grundlagen der Entwicklung von ASP-Applikationen sind sehr einfach zu erlernen. ASP-Applikationen unterscheiden sich von typischen Web-Seiten durch spezielle Script-Delimiter, die dazu benutzt werden, um ASP-Code vom Rest einer Web-Seite sauber zu trennen. Nützliche ASP-Subroutinen können in eine SSI-Datei integriert werden, die dann wiederum von anderen ASP-Applikationen aufgerufen werden können.
Was kommt als nächstes?
Die Applikation aus Listing 2.8 zeigt nur eine oberflächliche Übersicht über die Leistungsfähigkeit interaktiver ASP-Applikationen. Im nächsten Kapitel lernen Sie mehr über Interaktionen mit den Anwendern, die Ihre Web-Site besuchen.
Fragen und Antworten
Frage:
Ist es möglich, unterschiedliche Script-Sprachen innerhalb einer ASP-Applikation zu mischen?
Antwort:
Ja, es ist möglich. Seien Sie jedoch vorsichtig damit, und tun Sie dies nur, wenn es absolut notwendig ist.
Frage:
Wie stellt der IIS fest, ob die aktuelle Web-Seite eine ASP-Applikation ist?
Antwort:
Der IIS tut dies, indem er die Datei-Extension (Erweiterung) der Web-Seite überprüft. Ist diese .asp, so handelt es sich um eine ASP-Applikation.
Frage:
Genügt es, um eine eine ASP-Applikation im Internet zu veröffentlichen, diese unter .asp abzuspeichern?
Antwort:
Nicht ganz. Sie müssen ebenfalls gewährleisten, daß das Verzeichnis, in dem sich die Datei befindet, ebenfalls ausführbar ist. Folgende Schritte sind notwendig:
Frage:
Welches ist der einfachste Weg, den Wert der Variablen InteresRate in der Mitte einer Tabellen-Zelle anzuzeigen?
Antwort:
A <TD> <%= InteresRate %> </TD>
Frage:
Ich benötige eine Subroutine, die mir die Versicherungsprämie eines Autos kalkuliert, sobald einige Informationen in Form von Argumenten in eine Funktion übergeben wurden. Diese Routine soll von verschiedenen anderen ASP-Applikationen aufgerufen werden. Sollte ich diese Subroutine als eine virtuelle oder relative SSI-Datei implementieren?
Antwort:
Sie sollten eine virtuelle SSI-Datei benutzen, so daß andere Applikationen auf einfache Art und Weise auf die Subroutinen zugreifen können.
Aufgaben
1. Modifizieren Sie die Applikation aus Listing 2.7 so, daß der Anwender mit einer von zehn Nachrichten, basierend auf der Anzahl der verstrichenen Sekunden seit der letzten Minute, begrüßt wird.
2. Konvertieren Sie den ASP-Code aus Aufgabe 1 in eine ASP-Subroutine, und implementieren Sie diese in eine SSI-Datei.
3. Entwickeln Sie eine neue ASP-Applikation, die eine Subroutine in der aus Beispiel 2 entwickelten SSI-Datei aufruft.
Ein Imprint des Markt&Technik Buch- und Software-Verlag GmbH.
