Das Benutzen von VBScript-Datenstrukturen
Die Datenstruktur-Manipulations-Strings
Multidimensionale Datenstrukturen
Operatoren, Kontrollstrukturen und sich wiederholende Strukturen
Die Konvertierung und Überprüfung von Daten in VBScript
Die Datenkonvertierungs-Funktionen
Funktionen zur Datenüberprüfung
Zeit- und String-Manipulations-Funktionen
Die Konvertierung von Datums- und Zeit-Informationen in ein allgemeingültiges Format
String-Manipulations-Funktionen
Die Benutzung der mathematischen Funktionen
A
Nahezu alle ASP-Applikationen in diesem Buch sind in VBScript geschrieben. Dies ist auch der Grund dafür, daß Ihnen dieses Kapitel eine Einführung in diese Thematik bietet. Sie werden in VBScript eingeführt, um Ihnen die breite Palette vonVBScript aufzuzeigen.
Vor langer Zeit (ungefähr 18 Monate, was im Computerzeitalter sehr lang ist) dachten Menschen über die Entwicklung dynamischer Web-Inhalte nach. Damals, und auch heute noch, benutzte man CGI-Applikationen, um derartige Web-Applikationen zu erstellen. Doch viele Menschen waren mit den Ergebnissen eher unzufrieden. Programmiersprachen wie etwa C oder C++ kompilierten die CGI-Applikation und transferierten diese anschließend in ein entsprechendes CGI-Verzeichnis des Web-Servers, der den Code auf Bugs hin untersuchte. Jede noch so kleine Änderung im CGI-Script machte eine Re-Kompilierung notwendig. Um dieses aufwendige Verfahren zu beseitigen entwickelte man Web-Script-Sprachen wie beispielsweise JavaScript und VBScript, welche die Entwicklung von Client-seitigen und Server-seitigen CGI-Applikationen wesentlich vereinfachten.
Warum VBScript?
VBScript bietet Ihnen folgende Vorteile:
Da VBScript von Microsoft unterstützt wird, wird es in naher Zukunft eine umfassende Integration zwischen VBScript und dem Internet Explorer, Windows NT/95, Microsoft Office und der Microsoft-BackOffice-Familie geben.
VBScript ist ein Bestandteil von Visual Basic und ist dementsprechend aufwärtskompatibel zu Visual Basic for Applications (VBA). VBA wird mit Microsofts Office-Applikationen ausgeliefert, die es Entwicklern vereinfachen, Custom-Lösungen im Bereich Office zu entwickeln. Die Möglichkeit der Scriptverarbeitung, Automatisierung von Prozessen sowie die Anpassung an Web-Browser und Web-Server ist ein wichtiger Bestandteil VBScripts. Sollten Sie mit Visual Basic vertraut sein, so wird Ihnen VBScript keinerlei Mühen bereiten. Selbst wenn Sie sich nicht auskennen, ist VBScript sehr einfach zu bedienen.
URL Besuchen Sie die URL http://www.microsoft.com/VBScript, um weiterführende Informationen über VBScript zu erhalten. |
JavaScript führt wie auch VBScript zum selben Ziel. Sollten Sie mit keiner der beiden Sprachen vertraut sein, so starten Sie am besten VBScript. Wie bereits erwähnt, ist VBScript einfach zu erlernen, so daß Sie innerhalb kürzester Zeit Applikationen entwickeln können.
Sollten Sie mit Visual Basic oder VBA vertraut sein, so werden Sie ebenfalls einen leichten Einstieg in VBScript finden. Mit einigen kleinen Unterschieden gleichen sich VBScript und Visual Basic bzw. VBA.
Verfügen Sie bereits über Wissen im Bereich JavaScript, so wird es Ihnen VBScript noch einfacher machen, sich in Visual Basic und VBA einzuarbeiten. Visual Basic 5.0 kann benutzt werden, um ActiveX-Controls zu erstellen.
Wie arbeitet VBScript?
VBScript-Programme werden innerhalb der <SCRIPT LANGUAGE=VBS> und </SCRIPT>-HTML-Tags definiert. Browser, die VBScript unterstützen, lesen die VBScript-Applikation innerhalb der Tags aus und führen anschließend eine Fehlerüberprüfung durch. VBScript arbeitet nach dem Schema aus Abbildung A.1.
Abbildung A.1: |
Wenn ein Web-Browser, der VBScript unterstützt, das Tag <SCRIPT LANGUAGE=VBC> erkennt, so wird der Text zwischen den Tags als eine VBScript-Applikation angesehen und einer Fehlerkorrektur unterzogen. Werden keinerlei Syntax-Fehler festgestellt, wird die Applikation auf dem Web-Browser ausgeführt. Sollten jedoch Fehler festgestellt werden, erschient das Fenster aus Abbildung A.2.
Abbildung A.2: |
Technologically Challenged Web-Browser
Um VBScript-Code zu verstecken, können Sie diesen zwischen zwei HTML-Kommentar-Tags einfügen (Listing A.1).
Listing A.1: Verstecken VBScript-Code
<SCRIPT LANGUAGE=VBS>
<!-- To hide VBScript code from technologically challenged
Web browsers
...VBScript code...
!-->
</SCRIPT>
Hello World! in VBScript
Das Erstellen der schon bekannten Hello World!-Applikation in VBScript ist sehr einfach. Für diese Zwecke werden wir eine Web-Seite, wie in Abbildung A.3 zu sehen, erstellen. Diese Web-Seite wird drei Web-Seiten enthalten. Die erste zeigt eine Message-Box mit einer Grußbotschaft an, die zweite gibt die aktuelle Zeit aus und die dritte Schaltfläche zeigt das aktuelle Datum an.
Die Hello World!-Dialog-Box
Die Hello World!-Dialog-Box aus Abbildung A.4 wird jedesmal dann angezeigt, wenn ein Anwender auf Please click here for message box-Schaltfläche betätigt (Abbildung A.3). Wenn Sie einen Blick auf die HTML-Seite der VBScript-Applikation werfen (Zeilen 22 und 23 des Listings A.5), daß die Command-Schaltfläche, die in Verbindung mit der Hello World!-Dialog-Box steht, einen Namen hat. Wie aus Zeile 1 des Listings A.2 ersichtlich, steht das OnClick-Ereignis der BtnHello-Schaltfläche mit der Subroutine BtnHello_OnClick in Verbindung. Jedesmal, wenn ein Anwender auf die Schaltfläche Please click here for message box klickt, ruft der Web-Browser die Subroutine BtnHello_OnClick mit dem darin enthaltenen VBScript-Code auf.
Die BtnHello_OnClick-Subroutine ist sehr einfach. Die ersten drei Zeilen erstellen einen String, der in der Dialog-Box aus Abbildung A.4 angezeigt wird. Der String-Operator (&) benutzt Zeile 4, um zwei Strings zusammenzufügen, und übergibt das Ergebnis an eine Variable. Das Resultat zeigt die Message-Box aus Abbildung A.4 an.
|
Zeilennummern sind kein Bestandteil des VBScript-Codes und dienen nur der besseren Orientierung. |
Abbildung A.3: |
Abbildung A.4: |
Listing A.2: Die BtnHello_OnClick-Subroutine
1: Sub BtnHello_OnClick
2: titleString = "ActiveX Developer's Guide"
3: helloString = "Hello world! Welcome to the fun filled "
4: helloString = helloString & "world of VBScript programming!"
5: MsgBox helloString, 0, titleString
6: End Sub
Die Subroutine BtnTime_OnClick ist der BtnHello_OnClick sehr ähnlich. Der Unterschied ist lediglich der, daß diese Subroutine weniger zwei Strings sondern vielmehr einen String mit dem Resultat einer Funktion verkettet. Die Funktion time gibt die aktuelle Uhrzeit aus. Die Zeile 3 des Listings A.3 gibt die aktuelle Uhrzeit in einer Dialog-Box aus (Abbildung A.5). Die Subroutine BtnTime_OnClick steht in Verbindung mit dem OnClick-Ereignis der BtnTime-Schaltfläche.
Listing A.3: Die BtnTime_OnClick-Subroutine
1: Sub BtnTime_OnClick
2: timeString = "So, you want to know the time? The time is " & time
3: MsgBox timeString , 0, "Time Dialog Box"
4: End Sub
Abbildung A.5: |
Die Date-Dialog-Box zeigt das aktuelle Datum an (Abbildung A.6). Wie Sie in Zeile 2 des Listings A.4 sehen können, wird das Resultat der Funktion (date) als Argument einer anderen Funktion benutzt (DateValue).
Abbildung A.6: |
Listing A.4: Die BtnDate_OnClick-Subroutine
1: Sub BtnDate_OnClick
2: dateString = "Today's date is " & DateValue(date)
3: MsgBox dateString , 0, "Date Dialog Box"
4: End Sub
Der gesamte Source-Code der Hello World!-Applikation ist in Listing A.5 vereint.
Listing A.5: Der komplette Source-Code der Hello World!-Applikation.
1: <!--
2: © 1996 Sanjaya Hettihewa
3: http://www.NetInnovation.com/sanjaya
4: !-->
5:
6: <HTML>
7: <HEAD>
8: <TITLE>VBScript Tutorial: Hello World!</TITLE>
9: </HEAD>
10:
11: <BODY BGCOLOR="#333333" TEXT="#0000FF"
12: LINK="#B864FF" VLINK="#670000" ALINK="#FF0000">
13:
14: <IMG SRC="vbscript.jpg"><P>
15:
16: <B><FONT FACE="Comic Sans MS" SIZE=6 COLOR=RED>
17: VBScript Tutorial: <FONT></B>
18: <I><FONT FACE="Comic Sans MS" SIZE=5 COLOR=BLUE>
19: "Hello World!" </I><P><FONT>
20:
21: <form>
22: <INPUT TYPE=BUTTON VALUE="Please click here for message box"
23: NAME="BtnHello">
24: <INPUT TYPE=BUTTON VALUE="What time is it?"
25: NAME="BtnTime">
26: <INPUT TYPE=BUTTON VALUE="What date is it?"
27: NAME="BtnDate">
28: </form>
29:
30: <SCRIPT LANGUAGE="VBScript">
31: <!-- To hide VBScript code from technologically challenged browsers
32:
33: Sub BtnHello_OnClick
34: titleString = "ActiveX Developer's Guide"
35: helloString = "Hello world! Welcome to the fun filled "
36: helloString = helloString & "world of VBScript programming!"
37: MsgBox helloString, 0, titleString
38: End Sub
39:
40: Sub BtnTime_OnClick
41: timeString = "So, you want to know the time? The time is " & time
42: MsgBox timeString , 0, "Time Dialog Box"
43: End Sub
44:
45: Sub BtnDate_OnClick
46: dateString = "Today's date is " & DateValue(date)
47: MsgBox dateString , 0, "Date Dialog Box"
48: End Sub
49: !-->
50: </SCRIPT>
51:
52: </BODY>
53:
54: </HTML>
Die Grundlagen von VBScript
VBScript wird von Entwicklern benutzt, um Web-Seiten Scripts, Automatismen und eine reichliche Portion von Interaktivität zu verpassen. In diesem Kapitel erfahren Sie die Grundlagen der VBScript-Web-Applikationsentwicklung.
Die Client-seitige VBScript-Engine ist Bestandteil des Internet Explorers. Sollten Sie den Internet Explorer 3.0 nicht auf Ihrem System installiert haben, so müssen Sie dies im Vorfeld der VBScript-Entwicklung durchführen. Auch wenn Sie den Internet Explorer 3.0 installiert haben sollten, so besuchen Sie doch Microsofts Web-Site, um stets über Updates und neue Versionen auf dem laufenden zu sein.
URL Mehr Informationen über den Microsoft Internet Explorer erhalten Sie unter der URL http://www.microsoft.com/ie/deafult.asp. |
Die Abbildung A.7 zeigt die grafische Ausgabe einer Client-seitigen VBScript-Applikation, die durch einen Web-Browser ausgeführt wird. Wenn ein Web-Browser, der VBScript unterstützt, eine Web-Seite mit VBScript lädt, führt dieser den Code aus, sobald ein entsprechendes Objekt eine VBScript-Subroutine aufruft.
Die Struktur einer VBScript-Applikation
Bevor Sie mit der Entwicklung einer VBScript-Applikation beginnen, ist es wichtig, deren Struktur zu kennen. Eine typische VBScript-Applikation besteht aus folgenden Punkten:
Sub name of subroutine
...VBScript statements...
End Sub
Abbildung A.7: |
VBScript-Subroutinen befinden sich innerhalb des <SCRIPT LANGUAGE="VBScript">- und </SCRIPT>-Tags. Verschiedene Ereignisse sind mit diversen Objekten in Verbindung, die wiederum VBScript-Subroutinen aufrufen, um die unterschiedlichsten Aufgaben zu erledigen.
Listing A.6: Eine typische VBScript-Applikation
1: <HTML>
2: <HEAD>
3: <TITLE>VBScript Tutorial: Hello World!</TITLE>
4: </HEAD>
5:
6: <BODY BGCOLOR="#333333" TEXT="#0000FF"
7: LINK="#B864FF" VLINK="#670000" ALINK="#FF0000">
8:
9: <B><FONT FACE="Comic Sans MS" SIZE=6 COLOR=RED>
10: VBScript Tutorial: <FONT></B>
11: <I><FONT FACE="Comic Sans MS" SIZE=5 COLOR=BLUE>
12: "Hello World!" </I><P><FONT>
13:
14: <FORM>
15: <INPUT TYPE=BUTTON VALUE="Please click here for message box"
16: NAME="BtnHello">
17: <INPUT TYPE=BUTTON VALUE="What time is it?"
18: NAME="BtnTime">
19: <INPUT TYPE=BUTTON VALUE="What date is it?"
20: NAME="BtnDate">
21: </FORM>
22:
23: <SCRIPT LANGUAGE=VBS>
24: <!-- To hide VBScript code from technologically challenged browsers
25: Sub BtnHello_OnClick
26: titleString = "Windows NT Internet & Intranet Development"
27: helloString = "Hello world! Welcome to the fun filled "
28: helloString = helloString & "world of VBScript programming!"
29: MsgBox helloString, 0, titleString
30: End Sub
31:
32: Sub BtnTime_OnClick
33: timeString = "So, you want to know the time? The time is " & time
34: MsgBox timeString , 0, "Time Dialog Box"
35: End Sub
36:
37: Sub BtnDate_OnClick
38: dateString = "Today's date is " & DateValue(date)
39: MsgBox dateString , 0, "Date Dialog Box"
40: End Sub
41: -->
42: </SCRIPT>
43:
44: </BODY>
45: </HTML>
Die Rolle von VBScript bei der Web-Seiten-Entwicklung
Interaktive Web-Seiten benötigen die Ausführung von CGI-Applikationen auf dem entsprechenden Server und deren Ausgabe auf dem Client-seitigen Web-Browser. Obwohl diese Art für die meisten Applikationen ausreichend ist, treten im Bereich von verfügbaren Netzwerk- und Systemressourcen erhebliche Defizite auf. VBScript gestattet die Erstellung von interaktiven Web-Seiten mit diversen Multimedia-Features und spart dabei System- und Netzwerkressourcen.
Automation von ActiveX-Controls
ActiveX-Controls sind mächtige Komponenten, die Sie benutzen können, um komplexe Web-Applikationen zu erstellen. ActiveX-Controls sind in der Lage, bestimmte Aufgaben auszuführen. Das Microsoft-Forms-2.0-ComboBox-ActiveX-Control ist beispielsweise in der Lage, eine Liste mit Punkten anzuzeigen, wo hingegen das Microsoft-Forms-2.0-Imgage-ActiveX-Control eine Grafik anzuzeigen in der Lage ist. Obwohl die zwei Steuerungen sehr spezielle Aufgaben haben, ist VBScript in der Lage, beide Steuerungen zu kombinieren, um eine Applikation zu entwickeln. So kann beispielsweise eine VBScript-Subroutine einem Anwender erlauben, daß dieser eine Grafik, die ein Microsoft-Forms-2.0-Image-ActiveX-Control definiert, auswählt und an eine andere Steuerung übergibt.
VBScript ist sehr gut zur Entwicklung dynamischer Web-Applikationen geeignet, die sofort auf User-Eingaben reagieren müssen. Die »Mr. Potato Head«-Applikation, die wir noch näher kennenlernen werden, ist das Beispiel einer Web-Applikation, die besser mittels einer Client-seitigen Script-Sprache implementiert wird als mit einer Server-seitigen CGI-Applikation.
Die Applikation aus Listing A.8 ist die CGI-Version des Programmes. Nachdem der Anwender verschiedene physikalische Attribute des Kopfes von Mr. Potato Head ausgewählt habt, werden diese zum Web-Server übermittelt. Eine CGI-Applikation erstellt ein Grafik des Kopfes auf Basis der Eingaben, die ein Anwender definiert hat (Abbildung A.9). Die Potato-Head-Applikation verschlingt viele Netzwerkressourcen, da sämtliche Daten zum Server gesandt werden müssen und zwar jedesmal, wenn der Anwender ein neues Attribut auswählt. Die CGI-Applikation ist weiterhin sehr Prozessor-intensiv, da der Server bei jeder Änderung des Anwenders einen CGI-Request verarbeiten muß, um den Kopf neu zu erstellen.
Abbildung A.8: |
Abbildung A.9: |
URL Statten Sie doch der Web-Site http://winnie.acsu.buffalo.ed/cgi-bin/potatoe-cgi einen Besuch ab. Dort läuft die CGI-Version der Applikation. |
Die ActiveX-Version von Mr. Potato Head (Abbildung A.10) überwindet die Einschränkungen der CGI-Version. Wie Sie sehen können, ist die ActiveX-Version wesentlich interaktiver und einfacher zu benutzen, da sie es dem Anwender gestattet, die physikalischen Attribute der Applikation on-the-fly zu ändern, ohne den Server bemühen zu müssen. Deshalb belegt die ActiveX-Applikation wesentlich weniger System- und Netzwerkressourcen.
URL Experimentieren Sie doch mal mit der ActiveX-Version von Mr. Potato Head unter http://www.microsoft.com/ie/most/howto/layout/eggplant/begin.htm. |
Abbildung A.10: |
Eine Fehlerkontrolle ist ein wichtiger Aspekt im Bereich der Web-Applikations-Entwicklung. Löcher in der Fehlerbehandlung können Ihre Applikation sehr schnell »alt aussehen lassen«. Die Aufzählung zeigt Ihnen, wozu Sie VBScript im Bereich der Fehlerkontrolle einsetzen können.
Manipulation von Browser-Objekten
VBScript-Applikationen sind in der Lage, Web-Browser-Objekte, wie beispielsweise die Hintergrundfarbe der aktuellen Web-Seite, zu modifizieren. Dieses Feature ist sehr hilfreich, wenn Sie komplexe Web-Applikationen erstellen möchten. So könnte beispielsweise eine VBScript-Subroutine einer Multiframe-Web-Applikation den Inhalt verschiedener Fenster verändern, sobald ein Anwender eine bestimmte Schaltfläche betätigt.
Wenn Sie Applikationen in VBScript entwickeln, so sollten Sie Source-Code erstellen, der einfach zu lesen und zu verstehen ist. Umfangreiche, schlecht gegliederte Source-Codes machen eine Fehlersuche sehr aufwendig oder nahezu unmöglich. Die folgenden Tips helfen Ihnen bei der Erstellung leicht zu verstehender VBScript-Applikationen.
Eingerückter Source-Code
Da Einrücken nicht die Ausführung des Codes beeinflußt, sollten Sie diese Möglichkeit nutzen, um Ihren Code zu gliedern. Sie sollten die Strukturen wie in Listing A.7 gliedern.
Listing A.7: Eingerückte Statements machen das Lesen von VBScript wesentlich
einfacher
Sub BtnEvaluate_OnClick
If (OperatorBox.Value = "?") Then
MsgBoxString = "A valid operator is required to carry out "
MsgBoxString = MsgBoxString & "an evaluation."
MsgBoxString = MsgBoxString & chr(10)
MsgBoxString = MsgBoxString & "Valid operators are: +, -, *"
MsgBox MsgBoxString , 48 , "Invalid operator!"
Else
If (OperatorBox.Value = "+") Then
answer = CDbl(Operand1Box.Value) + CDbl(Operand2Box.Value)
ElseIf (OperatorBox.Value = "-") Then
answer = CDbl(Operand1Box.Value) - CDbl(Operand2Box.Value)
ElseIf (OperatorBox.Value = "*") Then
answer = CDbl(Operand1Box.Value) * CDbl(Operand2Box.Value)
End If
MsgBox answer , 64 , "Results of calculation"
Operand1Box.Value = answer
Operand2Box.Value = 0
END If
End Sub
Sub AddDigit ( digit )
REM Just in case there are any preceeding zeros or spaces
Operand1Box.Value = CDbl (Operand1Box.Value)
If (OperatorBox.Value = "?") Then
If (Len (Operand1Box.Value) < 14) Then
Operand1Box.Value = Operand1Box.Value & digit
Operand1Box.Value = CDbl (Operand1Box.Value)
Else
TooManyDigits
END If
Else
If (Len (Operand2Box.Value) < 14) Then
Operand2Box.Value = Operand2Box.Value & digit
Operand2Box.Value = CDbl (Operand2Box.Value)
Else
TooManyDigits
END If
END If
End Sub
Benutzen Sie Code-Fortführungszeichen
Diese Zeichen werden benutzt, um lange VBScript-Statements aufzutrennen. Sollte ein derartiges Statement länger als 80 Zeichen sein, so sollten Sie Code-Fortführungszeichen benutzen, um das Statement in zwei oder mehr Zeilen aufzuteilen (Listing A.8). Bei dem entsprechenden Zeichen handelt es sich um einen sogenannten Unterstrich (_) und dieser bezeichnet den Punkt, ab dem ein Statement unterbrochen werden soll (Zeilen 3-5 des Listings A.8).
Listing A.8: VBScript-Code mit dem Code-Fortführungszeichen
1: Sub OperatorBox_OnChange
2:
3: If (NOT((OperatorBox.Value = "+" ) OR _
4: (OperatorBox.Value = "-" ) OR _
5: (OperatorBox.Value = "*" ) OR _
6: (OperatorBox.Value = "?" ))) Then
7: MsgString = "Do not type invalid characters "
8: MsgString = MsgString & "into the operator text box! "
9: MsgString = MsgString & chr(10)
10: MsgString = MsgString & "The operator text box will now be
reset."
11: MsgString = MsgString & chr(10) & chr(10)
12: MsgString = MsgString & "Valid input: +, -, *"
13: MsgBox MsgString , 48 , "Invalid input detected!"
14: OperatorBox.Value = "?"
15: END If
16:
17: End Sub
Kommentieren Sie Ihren Source-Code
Das Kommentieren von Source-Code spart Ihnen Stunden oder sogar Tage an Entwicklungszeit und ermöglicht es Ihnen (zu einem späteren Zeitpunkt) oder einem Mitarbeiter, den Code zu verstehen. Um einen Kommentar in VBScript-Applikationen einzufügen, müssen Sie folgende Syntax verwenden, die sich auf Apostrophe (´) oder den Befehl REM bezieht:
´ This is a comment
oder
Rem This is a comment
|
Sollten Sie an einer komplexen Applikation arbeiten, so benutzen Sie VBScript-Kommentare, um Ihren Code zu dokumentieren. Obwohl Sie vielleicht zum gegenwärtigen Zeitpunkt wissen, wie Ihre Applikation funktioniert, kann dies Monate später ganz anders ausschauen. |
Das Benutzen von VBScript-Datenstrukturen
Nahezu alle VBScript-Applikationen benutzen Strukturen. Datenstrukturen sind Blöcke Ihrer VBScript-Applikation, welche alle Informationen einer VBScript-Applikation beherbergen, die notwendig sind. Im Gegensatz zu anderen Programmiersprachen speichert VBScript alle Daten in einen Datentyp mit der Bezeichnung Variant. Eine Variable des Typs Variant ist in der Lage, die unterschiedlichsten Informationen zu speichern, wie etwa Strings (Hello!), Zahlen (123), boolesche Variablen (TRUE) usw. Der Vorteil dieses Variablen-Typs liegt darin begründet, daß Sie nicht länger unterschiedliche Variablen-Typen im Kopf haben müssen. VBScript benutzt Variablen und analysiert deren Wert und überprüft, ob genügend Speicherplatz für diese Variable zur Verfügung steht.
|
Wenn Sie komplexe Applikationen mit Dutzenden von Variablen verwenden, so kann es vorkommen, daß Sie nicht mehr auseinanderhalten können, welchem Zweck bestimmte Variablen dienten. Geben Sie aus diesem Grund Ihren Variablen beschreibende Namen. |
Um die verschiedenen Arten von Daten abzuspeichern, besteht der Variant-Datentyp aus verschiedenen Daten-Subtypen. Eine Beschreibung jedes Sub-Typen ersehen Sie aus Tabelle A.1.
Tabelle A.1: Die Subtypen Variants
Sub-Type |
Beschreibung |
Bereich |
Boolean |
Ein boolescher Wert |
TRUE oder FALSE |
Byte |
Ein Byte-Wert |
Integer-Wert zwischen 0 und 255 |
Date |
Ein Datum |
Ein Datum zwischen 1.Januar 100 und 31.Dezember 9999 |
Double |
Double-Precision-floating-Point-Zahl |
eine Zahl zwischen -1.79769313486232E308 und -4.94065645841247E-423 für negative Zahlen und Zahlen zwischen 4.94065645841247E-423 und 1.79769313486232E308 für positive Werte |
Empty |
ein nicht initialisierter Wert |
0 für numerische Variablen und "" (Empty-String) für String-Variablen |
Error |
Errorcode |
N/A |
Integer |
Integer-Wert |
ein Integer-Wert zwischen -32,768 und 32.767 |
Long |
große Integer-Werte |
ein Integer-Wert zwischen -2,147483,648 und 2,147483,648 |
Null |
Empty-Variable, enthält keinen Wert |
N/A |
Object |
OLE-Automation-Objekt |
N/A |
Single |
Single-Precision-Floating-Point-Zahl |
Eine Nummer zwischen -3.402823E38 und |
String |
ein String mit Zeichen |
bis zu 2 Millionen lange Zeichen |
Time |
die Zeit |
eine Zeit zwischen dem 1. Januar 100 und dem 31.Dezember 9999 |
VBScript-Datenstrukturen
VBScript-Datenstrukturen gliedern sich in zwei Kategorien:
Abbildung A.11: |
Der einfachste nichtskalare Datentyp ist ein eindimensionales Array, das nur einen Indexwert besitzt. Multidimensionale Datenstrukturen besitzen dagegen zwei oder mehr Datenindizes. Stellen Sie sich eine multidimensionale Datenstruktur als eine Art Tabelle vor, die aus zwei Dimensionen besteht - Zeilen und Spalten (Abbildung A.12). Der Name einer Variable nützt Ihnen an dieser Stelle gar nichts. Sie benötigen außerdem noch den Zeilen- und Spaltenwert dieser Variablen.
Abbildung A.12: |
Ein multidimensionales VBScript-Datenarray kann zusätzliche Dimensionen aufweisen, um darin Daten zu speichern. Die Abbildung A.13 zeigt ein dreidimensionales Array mit Zeilen, Spalten und einem Höhenwert.
Abbildung A.13: |
Prinzipiell sollten Sie nicht mehr als drei Dimensionen definieren. Mehr Dimensionen verlangen mehr Arbeitsspeicher und machen eine Programmierung wesentlich schwerer.
Die Datenstruktur-Manipulations-Strings
VBScript verfügt über verschiedene Funktionen, um Datenstrukturen zu manipulieren. Bevor wir uns mit den Möglichkeiten der Erstellung und Manipulation von Datenstrukturen beschäftigen, wollen wir einen Blick auf die entsprechenden Funktionen VBScripts werfen. Benutzen Sie die folgenden Funktionen, um Datenstrukturen zu definieren und zu managen.
Das Dim-Statement wird benutzt, um Variablen, wie beispielsweise Arrays, zu deklarieren und diesen Speicherplatz zuzuweisen. Sollten Sie numerische Variablen mit DIM deklarieren, so werden diese mit dem Wert 0 initialisiert. Andernfalls werden diese einem String zugewiesen. Das Dim-Statement kann benutzt werden, um unterschiedliche Typen von Variablen zu deklarieren.
In manchen Fällen ist es nicht immer sicher, wie groß ein bestimmtes Array sein soll. VBScript gestattet deshalb die Erstellung dynamischer Arrays. Dynamische Arrays können erweitert oder verkleinert werden, wie es Ihre Anforderungen notwendig machen. Dynamische Arrays basieren auf folgender Syntax:
Dim NameOfArray(10)
Zusätzlicher Speicherplatz für Elemente innerhalb eines dynamischen Arrays können Sie durch folgende Syntax definieren:
ReDim NameOfArray(10)
Bestehende Elemente eines Arrays können Sie schützen, indem Sie Preserve zwischen dem ReDim-Statement und dem Array-Namen eingeben:
ReDim Preserve NameOfArray(20)
|
Wurde der Datentyp eines dynamischen Arrays mittels des As-Statements definiert, kann der Datentyp nicht verändert werden, indem Sie das Statement ReDim einsetzen. Wird also ein dynamisches Array verkleinert, so gehen alle Daten verloren. |
Indem Sie eine Variable mittels Private deklarieren, können Sie den Bereich der Variablen im Script begrenzen.
Dieses Statement kann die Wirkungsweise Ihrer Variable auf andere Scripts ausweiten.
Das IsArray-Statement gibt ein TRUE zurück, wenn es sich bei der Datenstruktur um ein Array, und FALSE, wenn es sich um etwas anderes handelt.
Das Erase-Statement wird benutzt, um den Speicher eines dynamischen Arrays zu leeren und die Elemente eines statischen Arrays neu zu initialisieren. Handelt es sich um ein dynamisches Array, so wird der gesamte Speicher freigegeben. Dynamische Arrays müssen vor einer neuen Benutzung erst einmal durch ReDim neu initialisiert werden. Sollte es sich um ein statisches Array handeln, werden alle Elemente mit 0 initialisiert, solange es sich bei den Elementen um numerische Werte handelt. Die Syntax lautet wie folgt:
Erase NameOfArray
LBound wird benutzt, um den minimalen Index eines Arrays festzustellen. Wurde beispielsweise ArrayVariable (ein dreidimensionales Arrays) durch die Statements Dim ArrayVariable(5 To 100, 10 To 200, 20 To 300) definiert, so wird der Wert 5 ausgegeben. LBound(ArrayVariable,2) gibt 10 und LBound(ArrayVariable,3) 20 aus.
UBound stellt den maximalen Index eines Arrays fest. ArrayVariable, das mit dem Statement Dim ArrayVariable(100,200,300) definiert wurde, gibt für UBound(ArrayVariable,1) den Wert 300, UBound(ArrayVariable,2) den Wert 200 und für UBound(ArrayVariable,3) den Wert 200 aus.
Nahezu alle Subtypen Variants sind Scalar-Datenstrukturen. Eine Scalar-Datenstruktur wird mittels Dim und dem Namen der Variablen deklariert. Ein Variablenname kann Buchstaben, Zahlen und Underscore-Zeichen (_) enthalten. Dabei gibt es folgende Ausnahmen:
|
Vergeben Sie Variablen beschreibende Namen. RowCount ist viel aussagekräftiger als beispielsweise x2. |
Listing A.9 zeigt ein kleines Beispiel einer Scalar-Struktur auf, die von einer VBScript-Applikation genutzt werden kann. Die Zeile 3 des Listings A.9 deklariert eine Datenstruktur mit der Bezeichnung ThisIsAScalarVariable. Zeile 5 weist dieser den Wert 5 zu und Zeile 6 fügt 5 hinzu. Die Zeile 7 gibt das Resultat in einer Message-Box aus.
Listing A.9: Deklarieren und benutzen Sie eine VBScript-Datenstruktur
1: <SCRIPT LANGUAGE="VBScript">
2:
3: Dim ThisIsAScalarVariable
4:
5: ThisIsAScalarVariable = 5
6: ThisIsAScalarVariable = ThisIsAScalarVariable + 5
7: Msgbox "The value of ThisIsAScalarVariable is " & _
8: ThisIsAScalarVariable
9:
10: </SCRIPT>
Abbildung A.14: |
Multidimensionale Datenstrukturen
Multidimensionale Datenstrukturen werden benutzt, um verschiedene Datenwerte in einer einzigen Variablen abzuspeichern. Dank eines Index kann der Anwender auf verschiedene Datenfelder dieser Datenstruktur zugreifen.
|
Eine multidimensionale Datenstruktur in VBScript kann bis zu 60 Dimensionen enthalten. Sie sollten sich in aller Regel jedoch nur auf 3 bis 4 beschränken, da ansonsten die Komplexität Ihres Source-Codes enorm zunimmt und enorme System-Ressourcen verschlungen werden. |
Die Typen von multidimensionalen Datenstrukturen
Es gibt zwei Arten von Arrays - statische und dynamische. Beide gleichen sich, wenn es darum geht Daten zu speichern oder auf diese zuzugreifen. Im Gegensatz zu dynamischen Arrays, die aus dem Programm heraus verändert werden können, kann man die Größe eines statischen Arrays nicht mehr ändern, sobald das Programm gestartet wurde. Benutzen Sie statische Arrays, wenn Sie sich über die Größe des Arrays im Klaren sind. Dynamische Arrays finden vor allem dann Anwendung, wenn der Anwender die Größe eines Arrays noch nicht absehen kann.
|
In VBScript beginnt der Index einer multidimensionalen Datenstruktur mit 0. Dadurch enthält ein durch Dim Array(20) definiertes Array 21 Datenfelder. |
Statische Arrays werden durch das Dim-Statement definiert. Das Listing A.10 demonstriert, wie ein eindimensionales Array sechs Elemente enthalten kann.
|
Das folgende Beispiel bezieht sich auf eindimensionale als auch auf multidimensionale Arrays. Der einzige Unterschied liegt darin, daß multidimensionale Arrays mehrere Indizes enthalten, die voneinander getrennt sind. Im Falle eines zweidimensionalen Arrays ist der erste Eintrag ein Zeilenindex und der zweite ein Spaltenindex. ArrayVariable(2,3) bezieht sich auf die gespeicherten Daten in der zweiten Zeile und die dritte Spalte der ArrayVariable-Datenstruktur. |
Listing A.10: Deklarieren Sie ein Array
.
<SCRIPT LANGUAGE="VBScript">
<!--
Dim VariableName(5)
-->
</SCRIPT>
Die Werte werden VariableName zugewiesen, indem der Index des Datenfelds benutzt wird. Das Listing A.11 demonstriert, wie Sie den Wert eines jeden Daten-Array-Index den Datenfeldern aus Listing A.10 zuweisen können. Beispielsweise kann das erste Datenfeld den Wert 2 erhalten, das zweite 4 usw.
Listing A.11: Weisen Sie Werte einem Array zu
.
<SCRIPT LANGUAGE="VBScript">
<!--
VariableName(0) = 0
VariableName(1) = 2
VariableName(2) = 4
VariableName(3) = 6
VariableName(4) = 8
-->
</SCRIPT>
Sie können auf die Werte eines Arrays zugreifen, indem Sie den Array-Index nach dem Namen des Arrays einfügen. Das Listing A.12 demonstriert, wie die Werte des Arrays aus Listing A.10 dargestellt werden, deren Index 4 ist.
Listing A.12: Das Auslesen der Daten aus einem Array
.
<SCRIPT LANGUAGE="VBScript">
<!--
Msgbox "Value of element = " & VariableName(4)
-->
</SCRIPT>
Dynamische Arrays werden in ähnlicher Weise deklariert wie statische Arrays. Der einzige Unterschied liegt darin, daß keinerlei Array-Größe definiert wird. Dim und ReDim werden benutzt, um dynamische Arrays zu deklarieren (Listing A.13).
Listing A.13: Die Deklaration eines dynamische Arrays
.
<SCRIPT LANGUAGE="VBScript">
<!--
ReDim ArrayName()
Dim SecondArrayName()
-->
</SCRIPT>
ReDim modifiziert die Größe eines dynamischen Arrays. Das Listing A.14 demonstriert, wie Sie die Größe (15 Speicherstellen) der Variablen ArrayName, aus Listing A.13, setzen können.
Listing A.14: Die Neudefinition eines dynamischen Arrays
.
<SCRIPT LANGUAGE="VBScript">
<!--
ReDim ArrayName(15)
-->
</SCRIPT>
ReDim modifiziert die Größe eines dynamischen Arrays neu. Das Listing A.15 zeigt, wie das ReDim-Statement eingesetzt wird, um die Größe der Variablen ArrayName zu verändern, so daß sie dann den Wert 25 statt 15 (s. Listing A.14) erhält. Preserve wird benutzt, um die Daten während einer Neudefinition des Arrays beizubehalten.
|
Sämtliche Daten gehen verloren, wenn Sie die Größe eines Arrays verkleinern, selbst bei Verwendung von Preserve. |
Listing A.15: Die Neudefinition eines dynamischen Arrays unter Verwendung von Preserve
.
<SCRIPT LANGUAGE="VBScript">
<!--
ReDim Preserve ArrayName(25)
-->
</SCRIPT>
Es istvon großer Bedeutung, daß Sie das Konzept des Variablenbereichs verstehen. Falls Sie diesen Aspekt nicht beachten, kann es vorkommen, daß Ihre Applikation nicht ohne Fehler ablaufen wird.
Variablenbereiche definieren, welche Subroutinen einer Applikation Zugriff auf Daten innerhalb einer Variablen haben sollen. Wenn Sie VBScript-Applikationen entwickeln so sollten Sie sich nicht nur auf globale Variablen verlassen. Alle Subroutinen einer Applikation haben Zugriff auf globale Variablen, die durch die ASP-Applikation definiert wurden. Eine lokale Variable ist nur innerhalb der Subroutine verfügbar, innerhalb der diese definiert wurde. Die Benutzung lokaler Variablen erhöht die Portierbarkeit von Subroutinen. Basiert eine Subroutine auf globalen Variablen, so ist diese Subroutine nicht sehr portierbar.
Obwohl dies auf den ersten Blick vielleicht ein wenig verwirrend erscheint, ist das Prinzip des Variablenbereichs sehr einfach zu verstehen. Wird eine Variable innerhalb einer Subroutine deklariert, so ist diese auch nur innerhalb dieser Subroutine verfügbar. Im Falle der Gleichbennenung einer lokalen und globalen Variablen kann eine Applikation auf keine der beiden zugreifen.
Listing A.16: Die Eingabe von Werten zu jedem Zeitpunkt der Programmausführung
Value of variable A in subroutine A = ____
Value of variable B in subroutine A = ____
Value of variable A in subroutine B = ____
Value of variable B in subroutine B = ____
Value of variable A outside subroutine A and B = ____
Value of variable B outside subroutine A and B = ____
Abbildung A.15: |
Listing A.17: Arbeiten Sie mit dem Bereich der Datenstruktur
1: <HTML>
2: <HEAD>
3:
4: <TITLE>Working With The Scope Of Data Structures</TITLE>
5: </HEAD>
6: <BODY BGCOLOR=FFFFFF>
7:
8: <SCRIPT LANGUAGE="VBScript">
9: <!--
10:
11: Dim A
12: Dim B
13:
14: Sub SubroutineA ()
15:
16: Dim A
17: Dim B
18:
19: A = 20
20: B = 30
21:
22: document.write "Value of variable A in subroutine A = " _
23: & A & "<BR>"
24: document.write "Value of variable B in subroutine A = " _
25: & B & "<BR>"
26:
27: End Sub
28:
29: Sub SubroutineB ()
30:
31: Dim A
32:
33: A = 35
34:
35: document.write "Value of variable A in subroutine B = " _
36: & A & "<BR>"
37: document.write "Value of variable B in subroutine B = " _
38: & B & "<BR>"
39:
40: End Sub
41:
42: A = 5
43: B = 10
44:
45: Call SubroutineA
46: Call SubroutineB
47:
48: document.write "Value of variable A outside subroutine _
49: & A and B = " & A & "<BR>"
50: document.write "Value of variable B outside subroutine _
51: & A and B = " & B & "<BR>"
52:
53: -->
54: </SCRIPT>
55:
56: </BODY>
57: </HTML>
Abbildung A.16: |
Wie die Variable-Scope-Applikation arbeitet
A und B sind globale Variablen der VBScript-Applikation. Die Werte 5 und 10 werden diesen Variablen zu Beginn zugewiesen. Danach deklariert die Subroutine SubRoutineA die Variablen A und B als lokale Variablen. Die Zeilen 22 und 24 des Listings A.17 geben die Werte 20 und 30 aus, da diese Werte den lokalen Variablen A und B in den Zeilen 19 und 20 zugewiesen wurden. Die Situation ist die gleiche im Falle von SubroutineB, die ihre eigene Variable A deklariert.
Listing A.18: Die Ausgabe der Applikation in Listing A.17
Value of variable A in subroutine A = 20
Value of variable B in subroutine A = 30
Value of variable A in subroutine B = 35
Value of variable B in subroutine B = 10
Value of variable A outside subroutine A and B = 5
Value of variable B outside subroutine A and B = 10
Operatoren, Kontrollstrukturen und sich wiederholende Strukturen
Operatoren, Kontrollstrukturen und sich wiederholende Strukturen erlauben es VBScript-Entwicklern, intelligente und interaktive Web-Applikationen zu erstellen. Folgende Aspekte beinhaltet diese Sektion:
Operatoren weisen das Resultat einer Kalkulation einer Variablen zu oder leiten ein Ergebnis zu einer weiteren Berechnung weiter. VBScript unterstützt verschiedene Operatoren für String-, boolesche- und Zahlen-Manipulations-Operationen.
Syntax: operand1 + operand2
Die Additions-Operation wird benutzt, um zwei Operanden zu addieren. Sind beide Operanden numerisch, ist das Ergebnis ebenfalls numerisch. Handelt es sich jedoch dabei um Strings, führt VBScript eine Verkettung beider Strings durch.
|
Um Zweideutigkeiten zu vermeiden, sollten Sie bei Strings das kaufmännische UND (&) anstelle des Pluszeichens verwenden. |
Syntax: operand1 - operand2
Syntax: -operandToNegate
Wenn Sie diese Operation verwenden, werden beide Operanden einer Subtraktion unterzogen. Benutzen Sie ein Minuszeichen vor dem Operanden, so wird dieser negiert.
Syntax: operand1 * operand2
Diese Operation multipliziert beide Operanden miteinander.
Syntax: operand1 ^ operand2
Diese Operation potenziert beide Operanden.
Syntax: operand1 / operand2
Die Gleitkommadivision teilt den operand1 durch den operand2. Beide Operanden müssen numerisch sein. Verwechseln Sie nicht diese Operation mit der Integer-Division, bei dem das Resultat von 23/4 gleich 5 ist und nicht wie bei der Gleitkommadivision 5.75.
|
Passen Sie auf, daß Sie keine Division mit 0 im Rahmen einer Floating-Pointing-Division durchführen, wenn der operand2 nicht 0 ist. |
Syntax: operand1 \ operand2
Diese Art der Division ergibt einen ganzzahligen Wert als Ergebnis. Dazu ein paar kleine Beispiele:
(23 \ 4) = 5
(4 \ 23) = 0
(4 \ 2) = 2
(5 \ 2) = 2
Syntax: operand1 & operand2
Diese Operation verknüpft zwei Strings miteinander. So ergibt beispielsweise ,,Windows NT" & ,,is fun" das Ergebnis ,,Windows NT is fun".
Syntax: operand1 MOD operand2
Diese Operation ähnelt der Integer-Division mit der Ausnahme, daß an dieser Stelle der Rest der Division ausgegeben wird. Dazu folgende Beispiele:
(23 MOD 4) = 3
(4 MOD 23) = 4
(4 MOD 2) = 0
(5 MOD 2) = 1
VBScript unterstützt eine Vielzahl boolescher Operationen. Abbildung A.17 zeigt Ihnen einige dieser Operationen.
Abbildung A.17: |
Syntax: <operand1> AND <operand2>
Die Operation ergibt ein TRUE, wenn beide Operanden TRUE sind. Falls dies nicht der Fall ist, wird ein FALSE ausgegeben.
Syntax: <operand1> OR <operand2>
Die Operation ergibt ein TRUE, wenn einer der beiden Operanden TRUE ist. Falls dies nicht der Fall ist, wird ein FALSE ausgegeben.
Syntax: NOT <operand>
Dank dieser Operation kann ein Operand negiert werden.
Syntax: <operand1> XOR <operand2>
Die XOR-Operation ist ähnlich der OR-Operation, mit der Ausnahme, daß diese Operation ein TRUE ergibt, wenn einer der beiden Operanden TRUE ist.
Syntax: <operand1> Eqv <operand2>
Diese Operation stellt fest, ob operand1 gleich operand2 ist. Ist einer der beiden Operanden NULL, so ist das Resultat NULL. Folgend die logische Verknüpfungstabelle:
TRUE Eqv TRUE = TRUE
FALSE Eqv TRUE = FALSE
TRUE Eqv FALSE = FALSE
FALSE Eqv FALSE = TRUE
Die Object-Reference-Operation
Syntax: <operand1> IS <operand2>
Diese Operation wird dazu verwendet, zwei Objekte-Variablen zu vergleichen. Wenn sich <operand1> auf das gleiche Objekt wie <operand2> bezieht, wird ein TRUE ausgegeben, andernfalls FALSE.
VBScript unterstützt verschiedene vergleichende Operationen, die dazu benutzt werden, um Strings und Zahlen miteinander zu vergleichen.
Syntax: <operand1> = <operand2>
Diese Operation ergibt ein TRUE, wenn beide Operatoren gleich sind. Ist einer der beiden NULL, so wird auch NULL ausgegeben.
syntax: <operand1> <> <operand2>
Diese Operation ergibt ein TRUE, wenn beide Operatoren ungleich sind. Ist einer der beiden NULL, so wird auch NULL ausgegeben.
Syntax: <operand1> < <operand2>
Diese Operation ergibt ein TRUE, wenn <operand1> kleiner als <operand2> ist. Ist einer der beiden Operanden NULL, so wird auch NULL ausgegeben.
Die Kleiner-als-oder-gleich-Operation
Syntax: <operand1> <= <operand2>
Diese Operation ergibt ein TRUE, wenn <operand1> kleiner als oder gleich <operand2> ist. Ist einer der beiden Operanden NULL, so wird auch NULL ausgegeben.
Syntax: <operand1> > <operand2>
Diese Operation ergibt ein TRUE, wenn <operand1> größer als <operand2> ist. Ist einer der beiden Operanden NULL, so wird auch NULL ausgegeben.
Die Größer-als-oder-gleich-Operation
Syntax: <operand1> >= <operand2>
Diese Operation ergibt ein TRUE, wenn <operand1> größer als oder gleich <operand2> ist. Ist einer der beiden Operanden NULL, so wird auch NULL ausgegeben.
Kontrollstrukturen sind ein wichtiger Bestandteil jeder Programmiersprache. Sie hauchen einer Programmiersprache Leben ein, indem es Programmierern erlaubt wird, »bedingte Anweisungen« zu erstellen. Eine Kontrollstruktur transferiert den Programmfluß zu einer Serie von VBScript-Statements oder zu einer VBScript-Subroutine. Die nächsten Sektionen zeigen, wie Sie VBScript-Kontrollstrukturen in VBScript-Programmen nutzen können.
Call
Call wird benutzt, um Programmsteuerungen an andere VBScript-Subroutinen zu übergeben. Call setzt an dieser Stelle auf Parameter, die innerhalb von Klammern definiert werden. Die Wiedergabewerte von Funktionen werden ignoriert, wenn diese über Call aufgerufen werden.
|
Call wird an dieser Stelle empfohlen, da es Bestandteil von VBScript ist. Call ist generell überflüssig, da man Call weglassen kann, wenn Subroutinen aufgerufen werden. |
Das Listing A.19 ist ein Beispiel dafür, wie Programm-Steuerungen zu anderen VBScript-Subroutinen mittels des Call-Statements transferiert werden können. Die Subroutine ThisSubroutineWillBeCalledWithCall in den Zeilen 7-9 wird mit dem Statement Call aus Zeile 20 aufgerufen. Die Message-Box aus Abbildung A.18 wird angezeigt, wenn die Applikation aus Listing A.19 angezeigt wird.
Listing A.19: Die Übergabe der Programm-Steuerung mit dem Call-Statement
1: <HTML>
2:
3: <HEAD>
4:
5: <SCRIPT LANGUAGE="VBScript">
6: <!--
7: Sub ThisSubroutineWillBeCalledWithCall
8: MsgBox "Inside subroutine ThisSubroutineWillBeCalledWithCall"
9: end sub
10: -->
11: </SCRIPT>
12:
13: <TITLE>Transferring Program Control Using Call</TITLE>
14: </HEAD>
15:
16: <BODY BGCOLOR="FFFFFF">
17:
18: <SCRIPT LANGUAGE="VBScript">
19: <!--
20: Call ThisSubroutineWillBeCalledWithCall
21: -->
22: </SCRIPT>
23:
24: </BODY>
25: </HTML>
Abbildung A.18: |
Die Select...Case-Kontrollstruktur benutzt man, um verschiedene VBScript-Statements auszuführen. Die Syntax lautet wie folgt:
Select Case <ExpressionToTest>
Case <ResultOfExpression>
...VBScript statement(s)...
Case Else
...VBScript statement(s)...
End Select
Das Listing A.20 zeigt, wie die Select...Case-Kontrollstruktur benutzt wird, um die Programmsteuerung auf Grund eines bestimmten Wertes zu einem VBScript-Statement zu transferieren. Wenn ein Anwender eine Farbe über eine Drop-Down-Liste auswählt (Abbildung A.19), so ändert die Select...Case-Kontrollstruktur in den Zeilen 27-41 des Listings A.20 die Hintergrundfarbe der Web-Seite (Abbildung A.20).
Abbildung A.19: |
Listing A.20: Verwendung der Select...Case Kontrollstruktur
1: <HTML>
2: <HEAD>
3:
4: <SCRIPT LANGUAGE="VBScript">
5: <!--
6: Sub window_onLoad()
7: BackgroundColorSelector.AddItem ("Red")
8: BackgroundColorSelector.AddItem ("Blue")
9: BackgroundColorSelector.AddItem ("Yellow")
10: BackgroundColorSelector.AddItem ("Black")
11: BackgroundColorSelector.AddItem ("White")
12: end sub
13: -->
14: </SCRIPT>
15:
16: <TITLE>Transferring Program Control Using SELECT / CASE</TITLE>
17: </HEAD>
18: <BODY BGCOLOR="FFFFFF">
19: <B>
20: Please use the pull down menu to select the background
21: color of this Web page.
22: </B>
23:
24: <SCRIPT LANGUAGE="VBScript">
25: <!--
26: Sub BackgroundColorSelector_Change()
27: Select Case BackgroundColorSelector.Value
28: Case "Red"
29: Document.bgColor = "Red"
30: Case "Blue"
31: Document.bgColor = "Blue"
32: Case "Yellow"
33: Document.bgColor = "Yellow"
34: Case "Black"
35: Document.bgColor = "Black"
36: Case "White"
37: Document.bgColor = "White"
38: Case Else
39: MsgBox "Please select a a valid color!" &
40: document.ColorSelectorForm.BackgroundColorSelector.text
41: End Select
42: end sub
43: -->
44: </SCRIPT>
45:
46: <OBJECT ID="BackgroundColorSelector" WIDTH=269 HEIGHT=21
47: CLASSID="CLSID:8BD21D30-EC42-11CE-9E0D-00AA006002F3">
48: <PARAM NAME="VariousPropertyBits" VALUE="746604571">
49: <PARAM NAME="BackColor" VALUE="14417394">
50: <PARAM NAME="DisplayStyle" VALUE="3">
51: <PARAM NAME="Size" VALUE="7112;556">
52: <PARAM NAME="MatchEntry" VALUE="1">
53: <PARAM NAME="ShowDropButtonWhen" VALUE="2">
54: <PARAM NAME="FontCharSet" VALUE="0">
55: <PARAM NAME="FontPitchAndFamily" VALUE="2">
56: </OBJECT>
57:
58: </BODY>
59: </HTML>
Abbildung A.20: |
|
Es ist gute Programmierpraxis, ein Case Else-Statement in ein Select...Case-Statement einzufügen. Versuchen Sie, alle Eventualitäten zu durchdenken, und strukturieren Sie Ihre Select...Case-Statements so, daß diese in der Lage sind, jede Situation zu bewältigen. |
|
Eine Select...Case-Struktur kann innerhalb einer anderen Select...Case-Struktur plaziert werden. Beachten Sie jedoch, daß Sie ein End Select-Statement entsprechend setzen. |
Dieses Statement wird benutzt, um VBScript-Statements auf Basis einer booleschen Aussage auszuführen. Die Syntax lautet wie folgt:
If <BooleanExpression> Then
...VBScript statement...
END If
Wie aus der letzten Sektion ersichtlich, ist eine If...Then-Kontrollstruktur in der Lage, VBScript-Statements auf Basis des Wertes einer booleschen Aussage auszuführen.
Dieses Statement führt VBScript-Statements auf Basis einer booleschen Aussage aus. Die Syntax lautet wie folgt:
If <Booleanxpression> Then
...VBScript statement...
Else If <Booleanxpression> Then
...VBScript statement...
Else
...VBScript statement...
END If
Sie werden sich sicherlich fragen, wann Sie If...Then...Else oder Select...Case einsetzen sollen. Benutzen Sie Select...Case, wenn einige VBScript-Statements auf Basis des Wertes einer einzelnen Aussage ausgeführt werden sollen. If...Then...Else sollte verwendet werden, wenn die Ausführung auf verschiedenen booleschen Aussagen aufbaut.
Wenn Sie Applikationen entwickeln, kann es manchmal notwendig sein, eine Reihe von Aufgaben mehrmals auszuführen. VBScript verfügt über verschiedene sich wiederholende Strukturen, die benutzt werden können, um eine Reihe von Aktionen durchzuführen. Es gibt zwei Arten von sich wiederholenden (iterativen) Strukturen - solche, die sich wiederholen, bis eine spezielle Bedingung eintritt, und solche, die eine festgelegte Anzahl von Wiederholungen durchlaufen.
|
Seien Sie vorsichtig, wenn Sie sich wiederholende Strukturen benutzen, die bis zu einem bestimmten Ereignis agieren. Schnell können Sie sich eine Endlosschleife programmieren, aus der Sie nicht wieder herauskommen. |
Diese Schleife ist in der Lage, eine bestimmte Anzahl von VBScript-Statements zu wiederholen. Die Syntax lautet wie folgt:
For <LoopCount> = <BeginLoop> To <EndLoop> Step <StepCount>
...VBScript statements...
Next
Diese Definition kann benutzt werden, um eine Serie von VBScript-Statements eine bestimmte Anzahl lang zu wiederholen, indem Sie die Platzhalter durch folgende Aussagen ersetzen:
|
Das Exit For-Statement kann benutzt werden, um eine For-Schleife zu verlassen. |
Die Applikation aus Listing A.21 demonstriert, wie eine For...Next-Schleife benutzt wird, um eine Serie von VBScript-Statements auszuführen. In diesem Fall gibt eine Schleife alle geraden Zahlen zwischen 0 und 20 aus (Abbildung A.21). Die For...Next-Schleife der Zeilen 14-20 des Listings A.21 befindet sich innerhalb der For...Next-Schleife in den Zeilen 16-18.
Listing A.21: Eine For...Next-Struktur führt eine Reihe von VBScript-Statements aus
1: <HTML>
2: <HEAD>
3: <TITLE>Using the FOR / NEXT control structure</TITLE>
4: </HEAD>
5: <BODY BGCOLOR="FFFFFF">
6: <H3>
7: Printing even numbers from 0 to 20 using the FOR / NEXT
8: control structure and printing a histograph of the numbers
9: using asterisks.
10: </H3>
11: <SCRIPT LANGUAGE="VBScript">
12: <!--
13:
14: For LoopCountVariable = 0 To 20 Step 2
15: document.write (LoopCountVariable-1)
16: For AsterisksCountVariable = 0 To LoopCountVariable
17: document.write "*"
18: Next
19: document.write "<BR>"
20: Next
21: -->
22: </SCRIPT>
23:
24: </BODY>
25: </HTML>
Abbildung A.21: |
Diese Kontrollstruktur ist sehr hilfreich, um VBScript-Statements für jedes Objekt einer Collection oder jedes Element eines Arrays auszuführen. Die Syntax lautet wie folgt:
For Each <LoopIndex> In <ArrayOrCollection>
...VBScript statements...
Next <LoopIndex>
Der Platzhalter der For Each...Next-Kontrollstruktur besitzt folgende Parameter:
Mit Hilfe des Statements Exit For können Sie diese Schleife verlassen. Sie können <LoopIndex> im Next <LoopIndex> weglassen, was aber nicht unbedingt empfehlenswert ist, da es in diesem Fall zu erheblichen Schwierigkeiten kommen kann.
Diese Schleife findet Anwendung, um eine Reihe von VBScript-Statements auszuführen, während ein bestimmter boolescher Ausdruck wahr ist (TRUE). Die Syntax lautet wie folgt:
While <Booleanxpression>
...VBScript statements...
Wend
Das Listing A.22 demonstriert die Anwendung einer While...Wend-Struktur, um eine Serie von VBScript-Statements auszuführen. Die Abbildung A.22 zeigt die Ausgabe der VBScript-Applikation des Listings A.22.
Listing A.22: Eine While...Wend Kontrollstruktur wird verwendet, um eine Serie von VBScript-Aussagen zu wiederholen
1: <HTML>
2: <HEAD>
3: <TITLE>Using the While/Wend control structure</TITLE>
4: </HEAD>
5: <BODY BGCOLOR="FFFFFF">
6: <H3>
7: Printing even numbers from 0 to 20 using the While/Wend control
structure
8: and printing a histograph of the numbers using asterisks.</H3>
9: <SCRIPT LANGUAGE="VBScript">
10: <!--
11:
12: Dim LoopCountVariable, AsterisksCountVariable
13:
14: LoopCountVariable = 0
15: While LoopCountVariable <= 20
16: If ( LoopCountVariable MOD 2 = 0 ) Then
17: document.write LoopCountVariable
18: AsterisksCountVariable = 0
19: While AsterisksCountVariable < LoopCountVariable
20: document.write "*"
21: AsterisksCountVariable = AsterisksCountVariable + 1
22: Wend
23: document.write "<BR>"
24: End If
25: LoopCountVariable = LoopCountVariable + 1
26: Wend
27:
28: -->
29: </SCRIPT>
30:
31: </BODY>
32: </HTML>
Abbildung A.22: |
Diese Kontrollstruktur führt eine bestimmte Serie von VBScript-Statements aus, bis ein Boolescher Ausdruck wahr (TRUE) wird. Wie aus dem folgenden Beispiel ersichtlich, kann die spezielle Boolesche Kondition entweder an das Ende oder den Anfang der Kontrollstruktur plaziert werden.
Do <condition> <Booleanxpression>
...VBScript statements...
Loop
In diesem Beispiel befindet sich der Boolesche Ausdruck am Ende der Kontrollstruktur.
Do
...VBScript statements...
Loop <condition> <Booleanxpression>
Das letzte Beispiel führt die VBScript-Statements bis <Booleanxpression> wahr wird. In diesem Beispiel kann <condition> durch While oder Until ersetzt werden. Wie der Name schon sagt wird die Schleife solange ausgeführt, bis <Booleanxpression> nicht mehr wahr (TRUE) ist.
Listing A.23: Eine Do/While...Until/Loop-Schleife führt eine Reihe von VBScript-Statements aus
1: <HTML>
2: <HEAD>
3: <TITLE>Using the Do/While/Until/Loop control structure</TITLE>
4: </HEAD>
5: <BODY BGCOLOR="FFFFFF">
6: <H3>
7: Printing even numbers from 0 to 20 using the Do/While/Until/Loop
8: control structure and printing a histograph of the numbers
9: using asterisks.
10: </H3>
11: <SCRIPT LANGUAGE="VBScript">
12: <!--
13:
14: Dim LoopCountVariable, AsterisksCountVariable
15:
16: LoopCountVariable = 0
17:
18: Do
19: If ( LoopCountVariable MOD 2 = 0 ) Then
20: document.write LoopCountVariable
21: AsterisksCountVariable = 0
22: Do While AsterisksCountVariable < LoopCountVariable
23: document.write "*"
24: AsterisksCountVariable = AsterisksCountVariable + 1
25: Loop
26: document.write "<BR>"
27: End If
28: LoopCountVariable = LoopCountVariable + 1
29: Loop While LoopCountVariable <= 20
30: .
31: -->
32: </SCRIPT>
33:
34: </BODY>
35: </HTML>
Abbildung A.23: |
Das Exit-Statement wird benutzt, um eine Kontrollstruktur zu verlassen.
Die Konvertierung und Überprüfung von Daten in VBScript
Datenkonvertierung und die Überprüfung von Daten sind wichtige Aspekte der Applikations-Entwicklung. Datenkonvertierung und Überprüfung können in VBScript benutzt werden, um robuste Applikationen zu entwickeln und Fehleingaben eines Anwenders auszuschließen. Gibt ein Anwender beispielsweise anstelle einer Nummer einen String ein, so kann VBScript die Eingaben überprüfen und den Anwender auf Fehleingaben hinweisen.
|
Die Konvertierung von Zeit, Strings und mathematischen Ausdrücken wird in dieser Sektion nicht behandelt. Sie erfahren alles dafür Notwendige in einer späteren Sektion. |
Die Datenkonvertierungs-Funktionen
VBScript beinhaltet eine Reihe von Funktionen, die benutzt werden können, um Daten eines Subtypes einer Variante in eine andere zu konvertieren. Datenkonvertierungs-Funktionen sind nur verfügbar, wenn ein Austausch mit anderen Applikationen oder ActiveX-Komponenten stattfindet. So könnte beispielsweise eine ActiveX-Control die Eingabe einer hexadezimalen Zahl notwendig machen. In diesem Fall kann die Hex()-Funktion benutzt werden, um eine Konvertierung einer dezimalen Zahl durchzuführen.
Int() und Fix() konvertieren numerische Ausdrücke in Integer-Werte. Der einzige Unterschied zwischen beiden Funktionen liegt darin, daß Int() eine negative gebrochene Zahl in einen kleineren Integer-Wert und Fix() eine negative gebrochene Zahl in einen größeren Interger-Wert konvertiert. Das folgende Beispiel zeigt, wie Int() und Fix() mit gebrochenen Zahlen umgehen.
Int(11.75) = 11
Fix(11.75) = 11
Int(12.45) = 12
Fix(12.45) = 12
Int(-17.75) = -18
Fix(-17.75) = -17
Int(-7.25) = -8
Fix(-7.25) = -7
Hex() gibt einen hexadezimalen Wert eines numerischen Ausdrucks aus. Hex(10) würde beispielsweise den Wert A ausgeben.
Oct() gibt den oktalen Wert eines numerischen Ausdrucks aus. Oct(10) würde etwa den Wert 12 ausgeben.
CBool() gibt den Booleschen Wert eines Ausdrucks einer Funktion wieder. CBool(A=B) ergibt ein TRUE, wenn A und B den gleichen Wert enthalten.
CByte() konvertiert ein Zahl, die an eine Funktion übergeben wurde, in eine Zahl des Typs byte und gibt diesen Wert aus. Wird CByte() beispielsweise mit der Zahl 123.678 aufgerufen, wird der Wert 123 zurückgegeben.
CDbl() konvertiert einen Ausdruck, der an eine Funktion übergeben wurde, in einen Variant des Subtyps double.
Chr() gibt das ASCII-Zeichen eines bestimmten ASCII-Codes aus. So wäre beispielsweise Chr(65) der Buchstabe A.
CInt() konvertiert einen Ausdruck in den Subtyp Integer. So wäre beispielsweise CInt(1234.567) 1235.
CLng() gibt den Subtyp long nach der Übergabe des Ausdrucks an eine Funktion aus. CLng(12345.67) würde beispielsweise den Wert 12346 ausgeben.
CSng() konvertiert eine numerische Aussage in den Subtyp Single. CSng(12.123456) würde beispielsweise den Wert 12.12346 zurückgeben.
Cstr() konvertiert einen Ausdruck in einen String und gibt diesen zurück. CStr(123.456) würde den Wert ,,123.456" zurückgeben.
Val() wird verwendet, um die Nummer innerhalb eines Strings festzustellen. So würde etwa Val(,,1234 567 in an string") den Wert 1234567 ausgeben.
Funktionen zur Datenüberprüfung
Datenüberprüfungs-Funktionen werden benutzt, um festzustellen, welcher Daten-Typ in einem Objekt bzw. in einer Aussage gespeichert ist. So ist beispielsweise IsDate() in der Lage, das vom Anwender eingegebene Datum zu überprüfen. IsDate() erbringt ein TRUE, wenn die Aussage in ein gültiges Datum konvertiert werden kann, oder ein FALSE, wenn dies nicht möglich ist.
IsArray() ergibt ein TRUE, wenn es sich bei der Variablen um ein Array handelt, und ein FALSE, wenn dies nicht der Fall ist.
IsDate() ergibt ein TRUE, wenn die Aussage in ein gültiges Datum konvertiert werden kann, und ein FALSE, wenn dies nicht der Fall ist.
IsEmpty() ergibt ein TRUE, wenn die Variable erfolgreich initialisiert wurde.
IsError() ergibt ein TRUE, wenn es sich bei der Aussage um einen Fehlercode handelt. Ist dies nicht so, erhält der Anwender ein FALSE.
IsNull() ergibt ein TRUE, wenn die Aussage NULL ist, und FALSE, wenn dies nicht so ist.
IsNumeric() gibt ein TRUE zurück, wenn die Aussage ein numerischer Wert ist.
IsObject() ergibt ein TRUE, wenn sich die Aussage auf ein OLE-Automations-Objekt bezieht - FALSE, falls nicht.
Der Typ einer Variablen kann mittels dieser Funktion festgestellt werden. Handelt es sich beispielsweise bei IntVariable um eine Integer-Variable, so gibt IntVar(IntVariable) den Wert 2 aus. Die Tabelle A.2 gibt die entsprechenden Zahlencodes wieder.
Tabelle A.2: Die verschiedenen Variablen-Typ-Codes
Rückgabewert |
Variablentyp |
0 |
Empty |
1 |
Null |
2 |
Integer |
3 |
langer Integer-Wert |
4 |
Single-Precision Floating-Point-Zahl |
5 |
Double-Precision Floating-Point-Zahl |
6 |
Currency |
7 |
Datum |
8 |
String |
9 |
OLE Automatisierungs-Objekt |
10 |
Fehler |
11 |
Boolescher Wert |
12 |
Variant |
13 |
Nicht-OLE-Automatisierungs-Objekt |
8192 |
Array |
Sie sollten stets eine Datenüberprüfung vornehmen, wenn Sie es Anwendern gestatten, Daten in ein Formular einzugeben. Fehler während einer User-Eingabe könnten ansonsten zu Runtime-Fehlern führen und ihre Applikation sogar zum Absturz bringen. Ein typischer Algorithmus besteht aus einer Dateneingangskontrolle, einer Datenüberprüfung, einer Schleife und diversen Funktionen, die Sie aus Abbildung A.24 ersehen können.
Eine einfache Applikation zur Datenüberprüfung
Die Applikation aus Listing A.24 zeigt die Implementierung einer einfachen Datenüberprüfung auf Basis VBScripts. Die Applikation beginnt erst dann zu starten, wenn der Anwender die Ziffer 5 eingegeben hat und zu einem anderen Bereich Ihres Web-Servers wechseln möchte.
Abbildung A.24: |
Listing A.24: Eine einfache Applikation zur Datenüberprüfung
1: <!--
2: © 1996 Sanjaya Hettihewa (http://www.NetInnovation.com/)
3: All Rights Reserved.
4: !-->
5: <HTML>
6: <HEAD>
7: <SCRIPT LANGUAGE="VBScript">
8: <!--
9: Sub ValidateData()
10: If ( IsNumeric (DataEntryForm.Input.Value) ) Then
11: If ( DataEntryForm.Input.Value=5 ) Then
12: Call ThankUser
13: Else
14: MsgBox "Please enter the number five!" & chr(10) & _
15: "The number you entered (" & DataEntryForm.Input.Value _
16: & ") is not the number 5."
17: End If
18: Else
19: MsgBox "Please enter the number five!" & chr(10) & _
20: "Your input (" & DataEntryForm.Input.Value _
21: & ") is not a valid numeric expression."
22: End If
23: End sub
24:
25: Sub ThankUser
26: document.open
27: document.write "<BODY BGCOLOR=FFFFFF>"
28: document.write "<H1>"
29: document.write "Thank you for entering the number 5!"
30: document.write "</H1>"
31: document.write "<H2>"
32: document.write "<Have a nice day!>"
33: document.write "</H2>"
34: document.close
35: End Sub
36: -->
37: </SCRIPT>
38: <TITLE>Simple Data Validation</TITLE>
39: </HEAD>
40: <BODY BGCOLOR="#F7FFF4">
41: <FORM NAME="DataEntryForm">
42: <p>Please enter the number 5
43: <INPUT LANGUAGE="VBScript"
44: TYPE=text ONCHANGE="call ValidateData()"
45: SIZE=20 NAME="Input"></p>
46: </FORM>
47: </BODY>
48: </HTML>
Die Ausgabe des Listings A.24 ist in Abbildung A.25 zu sehen. Sobald ein Anwender etwas eingibt und zu einer anderen Seite wechseln möchte, wird das Call ValiddateData()-Statement der Zeile 44 des Listings A.24 aufgerufen. Diese Subroutine überprüft zuerst, ob der eingegebene Wert auch numerischer Natur ist.
Abbildung A.25: |
Hat der Anwender einen nicht-numerischen Eintrag vorgenommen, erscheint die Dialog-Box aus Abbildung A.26, welche den Anwender nochmals zur Eingabe auffordert.
Abbildung A.26: |
Hat der Anwender eine Zahl eingegeben, die nicht der Ziffer 5 entspricht, wird die Dialog-Box aus Abbildung A.27 angezeigt. Der Anwender wird aufgefordert, die Nummer 5 einzugeben.
Abbildung A.27: |
|
Es ist immer gut, anzuzeigen, was der Anwender eingegeben hat, falls die Eingabe ungültig war. |
Sobald der Anwender die Zahl 5 eingibt, wird die Subroutine ThankUser aus den Zeilen 25-35 aufgerufen. Die Ausgabe von ThankUser ersehen Sie aus der Abbildung A.28.
Abbildung A.28: |
Die Überprüfung von Daten in einem HTML-Formular
HTML-Formulare sind prinzipiell dafür gedacht, um User-Eingaben zu empfangen. Sobald der Inhalt eines HTML-Formulars an den Server zur Weiterverarbeitung übergeben wurde, startet dort eine entsprechende CGI-Applikation. Unter Umständen kann es dann dazu kommen, daß unnötig Bandbreite verschwendet wird, da sich zum Schluß herausstellt, daß der Anwender fehlerhafte Eingaben getätigt hat. Die Gästebuch-Applikation aus Listing A.25 (siehe Abbildung A.29) demonstriert, wie VBScript die Daten auf Ihre Gültigkeit hin überprüft, bevor diese an die CGI-Applikation weitergeleitet werden.
Die meisten HTML-Formulare enthalten den folgenden HTML-Code:
<input type="submit" value="Submit Comments">
Dieser Code instruiert den Web-Browser, eine HTTP-Verbindung aufzubauen und die Daten aus dem HTML-Formular zu übergeben. Obwohl die Möglichkeit gut funktioniert, gestattet der Code nicht den Einsatz einer Client-seitigen VBScript-Applikation zur Datenüberprüfung. Dieses Problem löst die folgende Codezeile:
<input type="button" name="SubmitData" value="Submit Comments">
Vergleichen Sie doch mal die beiden Zeilen. Sie werden feststellen, daß sich beide Zeilen nur in der Art unterscheiden, wie die Daten übermittelt werden und einen zusätzlichen Befehl vorfinden name="SubmitData". Dieses Feld weist der Schaltfläche den Namen SubmitData zu, der die Funktion der Datenübermittlung hat. Wenn die Schaltfläche betätigt wird, transportiert der Web-Browser nicht etwa die Daten zur CGI-Applikation. In unserem Falle überprüft erst einmal eine VBScript-Subroutine die entsprechenden Daten auf Gültigkeit und überträgt diese erst im Anschluß daran mittels der Submit-Methode zur CGI-Applikation (Zeilen 54 und 57 des Listings A.25).
Listing A.25: Die Überprüfung der Daten eines HTML-Formulars
1: <!--
2: © 1996 Sanjaya Hettihewa (http://www.NetInnovation.com/)
3: All Rights Reserved.
4: !-->
5: <HTML>
6: <HEAD>
7:
8: <SCRIPT LANGUAGE="VBScript">
9: <!--
10:
11: Sub SubmitData_OnClick()
12:
13: ` The following VBScript statements verify HTML form data.
14:
15: If (GuestBookForm.FirstName.Value = "") Then
16: MsgBox "Invalid Input Detected." & Chr(10) & _
17: "Required data entry field not filled in." & Chr(10) & _
18: "Please fill in the First Name data entry field and " & _
19: "try again.", 4112, "Invalid Input Detected"
20: Else If (GuestBookForm.LastName.Value = "") Then
21: MsgBox "Invalid Input Detected." & Chr(10) & _
22: "Required data entry field not filled in." & Chr(10) & _
23: "Please fill in the Last Name data entry field and " & _
24: "try again.", 4112, "Invalid Input Detected"
25: Else If (GuestBookForm.EMailAddress.Value = "") Then
26: MsgBox "Invalid Input Detected." & Chr(10) & _
27: "Required data entry field not filled in." & Chr(10) & _
28: "Please fill in the E-Mail Address data entry field and " & _
29: "try again.", 4112, "Invalid Input Detected"
30: Else If (GuestBookForm.Country.Value = "") Then
31: MsgBox "Invalid Input Detected." & Chr(10) & _
32: "Required data entry field not filled in." & Chr(10) & _
33: "Please fill in the Country data entry field and " & _
34: "try again.", 4112, "Invalid Input Detected"
35: Else If (GuestBookForm.City.Value = "") Then
36: MsgBox "Invalid Input Detected." & Chr(10) & _
37: "Required data entry field not filled in." & Chr(10) & _
38: "Please fill in the City data entry field and " & _
39: "try again.", 4112, "Invalid Input Detected"
40: Else If (GuestBookForm.Comments.Value = "") Then
41: MsgBox "Invalid Input Detected." & Chr(10) & _
42: "Required data entry field not filled in." & Chr(10) & _
43: "Please fill in the Comments data entry field and " & _
44: "try again.", 4112, "Invalid Input Detected"
45: Else If (GuestBookForm.Birthdate.Value <> "") Then
46: If (IsDate (GuestBookForm.Birthdate.Value) = FALSE) Then
47: MsgBox "Invalid Input Detected." & Chr(10) & _
48: "I'm sorry but the birthday you entered is " & Chr(10) & _
49: "not a valid earth day. Please enter a valid " & Chr(10) & _
50: "birthday and try again." & Chr(10) & Chr(10) & _
51: "Ps: Please e-mail Webmaster if you are not from earth." _
52: , 4112, "Invalid Input Detected"
53: Else
54: GuestBookForm.Submit ` Submit HTML form data to the server.
55: End If
56: Else
57: GuestBookForm.Submit ` Submit HTML form data to the server.
58: End If
59: End If
60: End If
61: End If
62: End If
63: End If
64: End If
65: End sub
66: -->
67: </SCRIPT>
68: <TITLE>Submit Guest Book Entry</TITLE>
69: </HEAD>
70:
71: <BODY BGCOLOR="#F7FFF4">
72: <CENTER><TABLE BORDER=3 BGCOLOR=FFFFCC>
73: <TR><TD>
74: <FONT SIZE=+2>Thank you for signing the guest book!</FONT>
75: </TD></TR></TABLE></CENTER>
76: <p>Thanks for taking the time to sign the NetInnovation guest
77: book. As soon as you fill in the following form and press the
78: submit button, your guest book entry will be added to the
79: NetInnovation.Com guest book.</p>
80: <P><B>Please note that data entry fields with a white backgound
81: are optional.</B></P>
82:
83: <form name="GuestBookForm"
84: action="http://www.NetInnovation.com/cgi-bin/
GuestBookSubmit.IDC"
85: method="POST">
86:
87: <TABLE BGCOLOR=FFFFCC>
88: <TR>
89: <TD>First Name Please: </TD><TD><INPUT NAME="FirstName"
90: TYPE="TEXT" COLS=50 SIZE="43" ALIGN=left></TD>
91: </TR>
92: <TR>
93: <TD>Last Name Please: </TD><TD><INPUT NAME="LastName"
94: TYPE="TEXT" COLS=50 SIZE="43" ALIGN=left></TD>
95: </TR>
96: <TR>
97: <TD>E-mail Address Please: </TD><TD><INPUT NAME="EMailAddress"
98: TYPE="TEXT" COLS=50 SIZE="43" ALIGN=left></TD>
99: </TR>
100: <TR BGCOLOR=FFFFFF>
101: <TD>Your Birthdate Please: </TD><TD>
102: <INPUT NAME="Birthdate" TYPE="TEXT" COLS=10 SIZE="10"
103: ALIGN=left> (Example: 02/29/1976)</TD></TR>
104: <TR>
105: <TD>Country </TD><TD><INPUT NAME="Country" TYPE="TEXT"
106: COLS=50 SIZE="43" ALIGN=left></TD>
107: </TR>
108: <TR>
109: <TD>City / State / Province </TD><TD>
110: <INPUT NAME="City" TYPE="TEXT" COLS=50 SIZE="43" ALIGN=left></TD>
111: </TR>
112: </TABLE>
113:
114: <TABLE BGCOLOR=FFFFCC>
115: Please type your comments below. (Feel free to use HTML!)<BR>
116: <TEXTAREA NAME="Comments" WRAP=VIRTUAL ROWS=5 COLS=82
117: SIZE="82" ALIGN=left></TEXTAREA><BR>
118: </TABLE>
119:
120: <TABLE BGCOLOR=000000>
121: <input type="button" name="SubmitData" value="Submit Comments">
122: <input type="reset" value="Clear Form">
123: </TABLE>
124:
125: </form>
126: <HR>
127:
128: <strong>In case you are curious, after you press the submit
button,
129: your guest book entry is inserted to a Microsoft Access
130: database.</strong>
131:
132: <HR>
133: <h5>Copyright © 1995 Sanjaya Hettihewa.
134: All rights reserved.<br>
135: Revised: February 10, 1997.</h5>
136:
137: </body>
138: </html>
Abbildung A.29: |
Die Applikation aus Listing A.25 besteht aus einer Reihe von If...Then...Else-Statements, welche die Anwendereingabe überprüfen. Die Abbildung A.30 zeigt eine Fehlermeldung, wenn ein Anwender versucht, ein leeres Formular zu versenden.
Abbildung A.30: |
Die If...Then...Else-Statements in den Zeilen 15-64 des Listings A.25 überprüfen alle Datenfelder, ob diese auch ausgefüllt sind. Falls dies nicht der Fall ist, wird der Anwender auf einen fehlenden Eintrag hingewiesen (Abbildung A.31).
Die Zeilen 45-55 des Listings überprüft den Geburtstag des Anwenders. Wurde ein ungültiges Datum eingegeben, erscheint die Nachricht aus Abbildung A.32. Sobald das Gästebuch-Formular korrekt ausgefüllt ist (Abbildung A.33), überträgt es die VBScript-Applikation zum Web-Server. Aus Abbildung A.34 ersehen Sie die Resultate des Gästebuch-Eintrags.
Abbildung A.31: |
Abbildung A.32: |
Abbildung A.33: |
Abbildung A.34: |
|
Die Gästebuch-Applikation in dieser Sektion arbeitet mit dem Internet-Database-Connector. |
Zeit- und String-Manipulations-Funktionen
VBScript Zeit- und Strings-Manipulations-Funktionen sind sehr hilfreich bei der Entwicklung von Web-Applikationen.
Web-Applikationen können einen raffinierten Touch erhalten, wenn Sie die Zeit-Manipulations-Funktionen nutzen. Sie haben dank dieser Funktionen beispielsweise die Möglichkeit, den Anwender mit der tageszeitabhängigen Botschaft zu begrüßen. Die folgende Liste zeigt Ihnen einige Möglichkeiten der entsprechenden Funktion auf:
Das Überprüfen von User-Eingaben
VBScript ist in der Lage, die Daten des Anwenders zu überprüfen. Der VBScript-Code aus Listing A.26 zeigt eine Dialog-Box an (Abbildung A.35), wenn ungültige Daten an die Variable UserInput übergeben wurden. Sie können diese Variable durch den Namen eines HTML-Formular-Elementes ersetzen, wie beispielsweise NameOfForm.NameOfFormDataEntryField.Value, um die Daten des HTML-Formulars zu überprüfen. Die VBScript-Subroutine aus Listing A.26 benutzt IsDate(), um die Daten zu überprüfen.
Listing A.26: Diese Routine sucht nach fehlerhaften Eingaben
1: If (IsDate (UserInput) = FALSE) Then
2: MsgBox "Invalid Input Detected." & Chr(10) & _
3: "I'm sorry but the date you entered is " & Chr(10) & _
4: "not a valid day. Please enter a valid " & Chr(10) _
5: & "date and try again." _
6: , 4112, "Invalid Input Detected"
7: End If
Abbildung A.35: |
Berechnungen mit Datum und Uhrzeit
VBScripts Zeit- und Datums-Manipulations-Funktionen können zu verschiedenen Berechnungen herangezogen werden. Beispielsweise gibt die Funktion DateSerial(), die mit den Argumenten DateSerial(1996,4-2,1+28) aufgerufen wurde, das exakte Datum der letzten zwei Monate und 28 Tage nach dem 1.4.1996 aus.
Die Anzeige von Zeit-sensitiven Nachrichten auf Basis der Tageszeit
Derartige Nachrichten können auf einem Web-Browser angezeigt werden, in Abhängigkeit davon, zu welcher Zeit ein Anwender den entsprechenden Web-Server besucht (Listing A.27). Die Hour()- und Time()-Funktionen in der Zeile 24 des Listings A.27 stellen die Stunde des Tages fest. Die Ausgabe der Applikation aus Listing A.27 ersehen Sie aus Abbildung A.36.
Listing A.27: Die zeitabhängige Hello World!-Applikation
1: <!--
2: © 1996 Sanjaya Hettihewa (http://www.NetInnovation.com/)
3: All Rights Reserved.
4: Permission is hereby given to modify and distribute this code as
you wish
5: provided that this block of text remains unchanged.
6: !-->
7:
8: <HTML>
9:
10: <HEAD>
11: <TITLE>Hello World! (time sensitive version)</TITLE>
12: </HEAD>
13:
14: <BODY BGCOLOR=FFFFCC>
15:
16: <H1>Hello World! (time sensitive version)</H1>
17:
18: <TABLE BORDER=4 BGCOLOR="000000">
19: <TR><TD>
20: <FONT COLOR="FFFFFF">
21: <SCRIPT LANGUAGE="VBScript">
22: <!--
23:
24: CurrentHour = Hour(Time)
25:
26: document.Write "<H3>Current time: " & Time & "<BR>"
27: document.Write "Current date: " & Date & "</H3>"
28:
29: If (CurrentHour < 6 ) Then
30: document.Write _
31: "<H2>Hi! What are you doing up in the wee hours of the
morning?</H2>"
32: Else If (CurrentHour < 12 ) Then
33: document.Write _
34: "<H2>Hi! Good morning!</H2>"
35: Else If (CurrentHour < 14) Then
36: document.Write _
37: "<H2>Hi! Good afternoon!</H2>"
38: Else
39: document.Write _
40: "<H2>Hi! Good evening!</H2>"
41: End If
42: End If
43: End If
44:
45: -->
46: </SCRIPT>
47: </FONT>
48: </TD></TR>
49: </TABLE>
50:
51: </BODY>
52: </HTML>
Abbildung A.36: |
Die Konvertierung von Datums- und Zeit-Informationen in ein allgemeingültiges Format
Wenn Sie eine Datenbank-Applikation einsetzen, so möchten Sie vielleicht alle Einträge im Format 01/01/1996 anstelle des Formats 1.Januar 1996 oder 1. Jan. 1996 einsetzen. Die VBScript-Zeit-Manipulations-Funktionen sind in der Lage, derartige Konvertierungen durchzuführen.
Die Syntax der Zeit-Manipulations-Funktionen
Wurde ein Datum an eine Funktion übergeben, so wird es in Date konvertiert und ausgegeben. Bevor das Datum an die CDate()-Funktion übergeben werden kann, können Sie mittels IsDate() den entsprechenden Daten-Typ feststellen.
Date() gibt die Zeit der Systemuhr aus.
DateSerial() ist in der Lage, Berechnungen auf Basis von Tagen auszuführen. Indem Sie numerische Werte verwenden, können Sie vom aktuellen Datum vorwärts oder rückwärts zählen. Die Syntax lautet wie folgt:
DateSerial(<Year>, <Month>, <Day>)
Ist beispielsweise das aktuelle Datum 4/1/1996, so gibt DateSerial(1996,4-2,1+28) den Wert 2/29/1996 aus.
DateValue() konvertiert einen Ausdruck, der an eine Funktion übergeben wurde, in den Subtyp Date. Beispielsweise ergibt DateValue(,,February 29, 1976") den Wert 2/29/19976. Wird das Jahr weggelassen, so erhält die Funktion die Information von der Systemzeit.
Die Day()-Funktion ergibt einen Wert zwischen 1 und 31 und kann benutzt werden, um den Tag eines Datums herauszufinden. Day(,,4/1/1996") ergibt beispielsweise den Wert 1.
Hour() gibt die Anzahl der Stunden eines Ausdrucks aus. So ergibt beispielsweise Hour(,,12:35:34") den Wert 12.
IsDate() ergibt ein TRUE, wenn ein Ausdruck in ein gültiges Datum konvertiert werden kann - FALSE, wenn nicht.
|
Wenn Sie Datumseingaben eines Anwenders akzeptieren, so sollten Sie diese Daten immer mittels IsDate()überprüfen. |
Minute() ergibt die Anzahl der Minuten innerhalb eines Ausdrucks. So ergibt beispielsweise Minute(,,23:50:45") den Wert 50.
Month() gibt den Monat zurück, wenn diese Funktion aufgerufen wurde. So ergibt beispielsweise Month(,,4/1/1996") den Wert 4.
Now() gibt das aktuelle Datum und die Uhrzeit der Systemuhr aus. Der Wiedergabewert besteht aus dem Datum und der Uhrzeit. Now gibt beispielsweise den String 4/1/1996 23:00:31 aus.
Second() ergibt die Anzahl der Sekunden innerhalb eines Ausdrucks. So ergibt beispielsweise Second(,,18:23:57") den Wert 57.
Diese Funktion gibt die aktuelle Systemzeit aus. Wenn Sie diese Funktion zu einem bestimmten Zeitpunkt aufrufen, bekommen Sie den Wert 01:23:48 zurück.
Auf Basis dieser Funktion können Sie Berechnungen mit den Zeit-Ausdrücken durchführen. Ist die aktuelle Zeit beispielsweise 12:30, so ist TimeSerial() in der Lage, die Zeit vor 25 Minuten herauszufinden - TimeSerial(12,30-25,0) wird die Zeit 12:05:00 ausgeben.
TimeValue() gibt einen Ausdruck einer Funktion wieder, der in Date() konvertiert wurde. Beispielsweise ergibt TimeValue(,,2:35:17pm") den Wert 14:35:17.
Diese Funktion erbringt eine Zahl zwischen 1 und 7 (siehe Tabelle A.3).
Tabelle A.3: Die Tagescodes
Tagescode |
Tag |
1 |
Sonntag |
2 |
Montag |
3 |
Dienstag |
4 |
Mittwoch |
5 |
Donnerstag |
6 |
Freitag |
7 |
Samstag |
So würde beispielsweise Weekday(,,April 2, 1996") den Wert 3 ergeben - Dienstag.
Diese Funktion ergibt das Jahr eines Ausdrucks. So erbringt beispielsweise Year(,,February 29, 1976") den Wert 1976.
String-Manipulations-Funktionen
Diese Funktionen werden benutzt, um Daten, die vom Anwender eingegeben wurden, zu verarbeiten. Die folgenden VBScript-Funktionen können benutzt werden, um Strings zu manipulieren.
LSet wird benutzt, um eine Variable eines anwenderdefinierten Typs zu einer anderen Vaeiablen entsprechenden Typs zu kopieren. Wenn Sie eine Variable über diesen Befehl kopieren, ist diese links ausgerichtet. Die Syntax lautet wie folgt:
LSet Variable = ValueOfVariable
Ist die Länge von Variable länger als ValueofVariable, nachdem ValueOfVariable zu Variable kopiert wurde, so werden die entsprechenden Stellen mit Leerzeichen gefüllt. Ist der gegensätzliche Fall akut, werden die entsprechenden Ausdrücke gekürzt, bis Sie passen. Ist beispielsweise Variable in der Lage, nur vier Zeichen zu beherbergen, und ValueOfVariable enthält den Ausdruck »ABCDEFG«, so steht nach dem Kopiervorgang lediglich die Zeichenkette »ABCD« zur Verfügung.
Mid() ist in der Lage, ein oder auch mehrere Zeichen eines Strings durch Zeichen eines anderen Strings zu ersetzen. Die Syntax lautet wie folgt:
Mid(<Variable>, <Begin>, <NumCharactersToReplace>) = <Replacement>
Die Platzhalter haben folgende Funktion:
Dieses Kommando ähnelt in starkem Maße dem Kommando LSet. Der einzige Unterschied liegt lediglich in der Tatsache, daß dieses Kommando rechts-orientiert ist. Die Syntax lautet wie folgt:
RSet <Variable> = <StringToCopy>
CStr konvertiert einen Ausdruck in einen String. So ergibt beispielsweise CStr(1234,456) den Wert ,,123.456".
Diese Funktion findet einen String innerhalb eines anderen. Die Syntax lautet wie folgt:
InStr(<BeginPosition>, <String1>, <String2>, <ComparisonType>)
Die Placeholder haben folgende Bedeutung:
Die Instr()-Funktion kann benutzt werden, um eine E-Mail-Adresse herauszufinden, die von einem Anwender eingegeben wurde. VBScript selbst ist nicht in der Lage, mit einem Remote-Mail-Server Kontakt aufzunehmen. Die E-Mail-Adresse kann jedoch mittels der VBScript-String-Manipulations-Funktionen herausgefunden werden. Die Applikation aus Listing A.28 demonstriert, wie die Instr()-Funktion benutzt wird, um eine E-Mail-Adresse auf Grundlage der Syntax text@text.tex zu überprüfen. Wurde eine ungültige E-Mail-Adresse eingegeben, erscheint die Dialog-Box aus Abbildung A.37. Die Dialog-Box aus Abbildung A.38 erscheint, wenn die E-Mail-Adresse korrekt ist.
Listing A.28: Die Überprüfung einer E-Mail-Adresse
1: <!--
2: © 1996 Sanjaya Hettihewa (http://www.NetInnovation.com/)
3: All Rights Reserved.
4: Permission is hereby given to modify and distribute this code as
5: you wish provided that this block of text remains unchanged.
6: !-->
7: <HTML>
8: <HEAD>
9: <TITLE>Validating An E-Mail Address</TITLE>
10: </HEAD>
11: <BODY BGCOLOR=FFFFCC>
12: <H1>Validating An E-Mail Address</H1>
13: <TABLE BORDER=4 BGCOLOR="000000">
14: <TR><TD>
15: <FONT COLOR="FFFFFF">
16: <form name="EMailAddressEntryForm">
17: <p><H3>Please enter an e-mail address to validate</H3>
18: <input type="text" size="40" name="EMailAddress">
19: <input type="button" name="Validate" value="Validate E-Mail
Address"></p>
20: </form>
21: </FONT>
22: </TD></TR>
23: </TABLE>
24: <SCRIPT LANGUAGE="VBScript">
25: <!--
26: Sub Validate_OnClick
27: EMailAdress = EMailAddressEntryForm.EMailAddress.Value
28: AtSignPosition = InStr (EMailAdress,"@")
29: If (AtSignPosition > 0) Then
30: PeriodPosition = InStr (AtSignPosition,EMailAdress,".")
31: Else
32: PeriodPosition = 0
33: End If
34: AddressLength = Len(EMailAdress)
35: If (AtSignPosition = 0) Then
36: MsgBox "Invalid e-mail address entered!"
37: Else If (PeriodPosition = 0) Then
38: MsgBox "Invalid e-mail address entered!"
39: Else If (AddressLength=PeriodPosition) Then
40: MsgBox "Invalid e-mail address entered!"
41: Else
42: MsgBox "Valid e-mail address entered!"
43: End If
44: End If
45: End If
46: End Sub
47: -->
48: </SCRIPT>
49: </BODY>
50: </HTML>
Abbildung A.37: |
Abbildung A.38: |
|
Die Applikation aus Listing A.28 gibt Ihnen einen guten Einblick in die Funktionsweise der Instr()-Funktion, welche die User-Eingaben überprüft. |
Diese Funktion konvertiert einen String-Ausdruck in Kleinbuchstaben.
Left() ergibt eine gewisse Anzahl von Zeichen ab der linken Position eines Strings. Left(,,Windows NT", 7) ergibt beispielsweise den Wert ,,Windows".
Diese Funktion gibt die Länge eines Strings aus.
Diese Funktionen beseitigen Leerzeichen eines Strings und geben den Wert anschließend wieder aus. LTrim eliminiert vorangestellte Leerzeichen. RTrim eliminiert nachfolgende Leerzeichen und Trim beseitigt beide Arten von Leerzeichen.
Diese Funktion ergibt eine gewisse Anzahl von Zeichen eines Strings. Mid(,,Windows NT", 0, 7) ergibt den Wert ,,Windows".
Right() ergibt eine gewisse Anzahl von Zeichen ab der rechten Position eines Strings. Right(,,Windows NT", 2) ergibt beispielsweise den Wert ,,NT".
Diese Funktion konvertiert einen numerischen Wert in einen String.
Diese Funktion vergleicht zwei Strings. Die Syntax lautet wie folgt:
StrComp(String1, String2, ComparisonMethod)
Nachdem beide Strings einem Vergleich unterzogen wurden, wird der Wert 0 ausgegeben, wenn beide Strings identisch sind. Ist der erste String kleiner als der zweite, wird -1 ausgegeben, im genau umgekehrten Fall gibt die Funktion den Wert 1 aus. Erhalten Sie eine 0, so fand ein binärer Vergleich statt.
Diese Funktion wird benutzt, um ein Zeichen eine bestimmte Anzahl von Malen zu wiederholen. String(5,"*") gibt fünf mal das Stern-Zeichen aus.
Diese Funktion konvertiert Strings in Großbuchstaben und gibt diese anschließend wieder aus. So ergibt UCase(,,Windows NT") beispielsweise den Wert ,,WINDOWS NT" aus.
Die Val()-Funktion sucht nach Zahlen innerhalb eines Strings. Val(,,1234567 in a string") ergibt beispielsweise den Wert 1234567.
Mathematische Funktionen sind in der Lage, komplexe mathematische Operationen durchzuführen. Diese Sektion führt Sie in die Thematik der mathematischen Operationen VBScripts ein. Die meisten mathematischen Funktionen führen trigonometrische Berechnungen durch. Am Ende dieser Sektion sehen Sie eine VBScript-Applikation, die sämtliche mathematischen Funktionen benutzt.
|
Gradangaben können in Radianten konvertiert werden, indem Sie durch 180 teilen und die Gradzahl dann mit dem Ergebnis multiplizieren. |
Diese Funktion gibt den Arctangens-Wert einer Funktion aus.
Diese Funktion gibt den Cosinus-Wert eines Winkels aus.
Diese Funktion gibt den Sinus-Wert eines Winkels aus.
Diese Funktion berechnet den Tangens eines Winkels. Tan(0) ergibt beispielsweise den Wert 0.
Diese Funktion gibt den Exponenten eines bestimmten Wertes aus. So ergibt beispielsweise Exp(1) den Wert 2.71828182845905.
Log() ergibt den natürlichen Logarithmus eines nicht-negativen Ausdrucks.
Diese Funktion gibt den Quadratwert eines nicht-negativen Ausdrucks wieder.
Die Funktion startet den Zufallsgenerator und erbringt zufällige Zahlen - mit oder ohne ein numerisches Argument. Wird diese Funktion ohne ein Argument aufgerufen, wird die interne Systemuhr benutzt, um den Zufallsgenerator zu steuern.
Rnd() ergibt eine zufällige Zahl zwischen 0 und 1. Stellen Sie sicher, daß Sie den Zufallsgenerator gestartet haben, bevor Sie diese Funktion starten.
Die Benutzung der mathematischen Funktionen
Mathematische Funktionen der Sektionen finden jetzt im Listing A.29 Anwendung. Experimentieren Sie doch mit der Applikation aus Abbildung A.39, um mit den mathematischen Funktionen vertrauter zu werden. Geben Sie einen Wert in die Text-Box ein und klicken Sie anschließend auf die Schaltfläche Evaluate, um das Ergebnis aus Abbildung A.40 zu erhalten.
Listing A.29: Benutzen Sie die mathematischen Funktionen VBScripts
1: <HTML>
2: <HEAD>
3: <TITLE>Using VBScript Mathematical Functions</TITLE>
4: </HEAD>
5: <BODY BGCOLOR="FFFFFF">
6: <form name="SimpleCalculator">
7: <H3>
8: Atn(<input type="text" size="5" name="AtnInput" value="1">)
9: <input type="button" name="AtnEvaluate" value="Evaluate!"><P>
10: Cos(<input type="text" size="5" name="CosInput" value="1">)
11: <input type="button" name="CosEvaluate" value="Evaluate!"><P>
12: Sin(<input type="text" size="5" name="SinInput" value="1">)
13: <input type="button" name="SinEvaluate" value="Evaluate!"><P>
14: Tan(<input type="text" size="5" name="TanInput" value="1">)
15: <input type="button" name="TanEvaluate" value="Evaluate!"><P>
16: Exp(<input type="text" size="5" name="ExpInput" value="1">)
17: <input type="button" name="ExpEvaluate" value="Evaluate!"><P>
18: Log(<input type="text" size="5" name="LogInput" value="1">)
19: <input type="button" name="LogEvaluate" value="Evaluate!"><P>
20: Sqr(<input type="text" size="5" name="SqrInput" value="1">)
21: <input type="button" name="SqrEvaluate" value="Evaluate!"><P>
22: </H3>
23: </form>
24: <SCRIPT LANGUAGE="VBScript">
25: <!--
26: Sub AtnEvaluate_OnClick
27: MsgBoxString = "Atn(" & SimpleCalculator.AtnInput.Value & _
28: ") = " & Atn(SimpleCalculator.AtnInput.Value)
29: MsgBox MsgBoxString , 64 , "Result of Calculation"
30: End Sub
31: Sub CosEvaluate_OnClick
32: MsgBoxString = "Cos(" & SimpleCalculator.CosInput.Value & _
33: ") = " & Cos(SimpleCalculator.CosInput.Value)
34: MsgBox MsgBoxString , 64 , "Result of Calculation"
35: End Sub
36: Sub SinEvaluate_OnClick
37: MsgBoxString = "Sin(" & SimpleCalculator.SinInput.Value & _
38: ") = " & Sin(SimpleCalculator.SinInput.Value)
39: MsgBox MsgBoxString , 64 , "Result of Calculation"
40: End Sub
41: Sub TanEvaluate_OnClick
42: MsgBoxString = "Tan(" & SimpleCalculator.TanInput.Value & _
43: ") = " & Tan(SimpleCalculator.TanInput.Value)
44: MsgBox MsgBoxString , 64 , "Result of Calculation"
45: End Sub
46: Sub ExpEvaluate_OnClick
47: MsgBoxString = "Exp(" & SimpleCalculator.ExpInput.Value & _
48: ") = " & Exp(SimpleCalculator.ExpInput.Value)
49: MsgBox MsgBoxString , 64 , "Result of Calculation"
50: End Sub
51: Sub LogEvaluate_OnClick
52: MsgBoxString = "Log(" & SimpleCalculator.LogInput.Value & _
53: ") = " & Log(SimpleCalculator.LogInput.Value)
54: MsgBox MsgBoxString , 64 , "Result of Calculation"
55: End Sub
56: Sub SqrEvaluate_OnClick
57: MsgBoxString = "Sqr(" & SimpleCalculator.SqrInput.Value & _
58: ") = " & Sqr(SimpleCalculator.SqrInput.Value)
59: MsgBox MsgBoxString , 64 , "Result of Calculation"
60: End Sub
61: -->
62: </SCRIPT>
63: </BODY>
64: </HTML>
Abbildung A.39: |
Abbildung A.40: |
Ein Imprint des Markt&Technik Buch- und Software-Verlag GmbH.
