T u t o r i a l
Einbetten von VBScript-Code in eine HTML-Seite
Variablen
Konstanten
Operatoren
Kontrollanweisungen
Schleifen
Prozeduren und Funktionen
Codeausführung bei Events
Die "Microsoft Visual Basic Scripting Edition" ist das jüngste Mitglied der Familie der Visual Basic Programmiersprachen. VBScript ermöglicht aktives Scripting in verschiedenen Umgebungen, wie beispielsweise "Web client scripting" im Microsoft Internet Explorer bzw. "Web server scripting" im Microsoft Internet Information Service.
Wenn man bereits Visual Basic programmiert hat bzw. kennt, so ist VBScript sehr leicht zu erlernen. Ist das jedoch nicht der Fall, so müßte das Erlernen von VBScript auch in sehr kurzer Zeit möglich sein.
VBScript wird von sogenannten "Scripting Engines" interpretiert. Diese sind in World Wide Web Browsern integriert. In VBScript gibt es zwar Objekte, aber Konzepte wie Vererbung, Polymorphismus und dynamische Bindung sind nicht realisiert.Microsoft bietet Binärimplementierungen von VBScript für das 32-Bit Windows API, das 16-Bit Windows API, sowie für den Macintosh an. Weiters ist VBScript auch in World Wide Web Browsern integriert.
Es sei noch erwähnt, daß VBScript als allgemeine Scripting-Sprache in verschiedenen anderen Applikationen, also nicht nur innerhalb von HTML-Seiten, verwendet werden kann.
VBScript-Code kann mittels des SCRIPT-Tags in eine HTML-Seite eingebettet werden, wobei der öffnende und der schließende SCRIPT-Tag den VBScript-Code umgeben.
Das "Language"-Attribut innerhalb des SCRIPT-Tags spezifiziert die Scripting-Sprache. Dieses Attribut wird in unserem Fall auf "VBScript" gesetzt. Die Scripting-Sprache muß unbedingt spezifiziert werden, da diverse Browser standardmäßig unterschiedliche Scripting-Sprachen verwenden können.
Es besteht die Möglichkeit, daß ein Browser den SCRIPT-Tag nicht interpretieren kann. Deshalb sollte der VBScript-Code immer innerhalb von HTML-Kommentaren (<!-- und -->) stehen, damit in einem solchen Fall der Code nicht am Bildschirm angezeigt wird.
Generell können SCRIPT-Blöcke überall in einer HTML-Seite deklariert werden, also sowohl innerhalb der BODY-Tags als auch innerhalb der HEAD-Tags. Es ist jedoch zu empfehlen, alle Funktionen und Prozeduren innerhalb der HEAD-Tags zu implementieren. Dies gewährleistet einerseits ein gewisses Maß an Übersichtlichkeit und andererseits wird dadurch garantiert, daß alle Funktionen und Prozeduren bereits gelesen und dekodiert worden sind, bevor sie innerhalb der BODY-Tags aufgerufen werden.
Das folgende Beispiel zeigt den Code einer einfachen HTML-Seite mit integriertem VBScript-Code:
<html>
<head>
<title>Beispiel</title>
<SCRIPT LANGUAGE="VBScript">
<!--
Dim a
a=InputBox("Geben Sie eine Zahl ein",1)
Sub Ausgabe(a)
MsgBox "Wert von a:"&a
End Sub
Ausgabe a
-->
</SCRIPT>
</head>
<body> Test </body>
</html>
Lädt man das vorhergehende Beispiel als HTML-Seite im Browser, so sieht man, daß zuerst ein Eingabefenster erscheint, wo man eine Zahl eingeben soll. Dann wird diese Zahl in einem Dialogfeld wieder ausgegeben. Erst dann, nach Abarbeitung des VBScript-Codes, erscheint das Wort "Test" auf dem Bildschirm.
Eine nennenswerte Ausnahme zu dieser Konvention ist die Verwendung von sogenanntem "Inline Scripting Code" innerhalb von Formularen, um auf Ereignisse von Objekten innerhalb des Formulars reagieren zu können. Diese Möglichkeit soll das folgende Beispiel erläutern:
<html>
<head> <title> Test Button Events </title> </head>
<body>
<form name="Form1">
<input type="Button" name="Button1" value="Click">
<SCRIPT FOR="Button1" EVENT="onClick" LANGUAGE="VBScript">
MsgBox "Button gedrückt!"
</SCRIPT>
</form>
</body>
</html>
In diesem Beispiel erscheint ein Dialogfenster mit dem Text "Button gedrückt!", sobald der Benutzer auf den Button drückt.
Meist wird VBScript-Code innerhalb von Prozeduren oder Funktionen geschrieben, die an im Code spezifizierten Stellen aufgerufen werden. Es können jedoch auch einzelne Anweisungen außerhalb von Prozeduren oder Funktionen (jedoch innerhalb von SCRIPT-Tags) geschrieben werden, die dann ausgeführt werden, wenn die HTML-Seite geladen wird. Diese Eigenschaft kann man beispielsweise zur Initialisierung von Variablen nützen.
VBScript hat prinzipiell nur einen Datentyp namens Variant. Folglich kann eine Variable vom Typ Variant sämtliche Arten von Daten enthalten. Da Variant der einzige Datentyp in VBScript ist, sind auch die Rückgabewerte von Funktionen immer vom Typ Variant.
Es gibt jedoch (intern) noch Subtypen von Variant. Welchen Subtyp nun tatsächlich eine Variable hat, ist vom Kontext des Variablengebrauchs abhängig. Im einfachsten Fall handelt es sich um numerische Typen oder den Typ String. Strings werden beispielsweise daran erkannt, daß die Zeichenketten in Hochkommas ("") eingeschlossen sind. Generell nimmt also eine Variable jenen Subtyp an, der am besten zu den Daten die sie speichert und zu ihrer Verwendung paßt.
Nun folgt eine Auflistung und Beschreibung der Subtypen in VBScript:
|
Subtyp
|
Beschreibung
|
| Empty | Der Variant ist nicht initialisiert. Der Wert ist 0 für numerische Variablen oder ein Leerstring für Stringvariablen. |
| Null | Der Variant enthält keine gültigen Daten. |
| Boolean | Enthält entweder True oder False. |
| Byte | Ganzzahliger Wertebereich von 0 bis 255. |
| Integer | Ganzzahliger Wertebereich von -32.768 bis 32.767. |
| Currency | Wertebereich von -922.337.203.685.477,5808 - 922.337.203.685.477,5807. |
| Long | Ganzzahliger Wertebereich von -2.147.483.648 - 2.147.483.647. |
| Single | Gleitkommazahlen mit einfacher Genauigkeit. Wertebereich von -3,402823E38 bis -1,401298E-45 für negative Werte und von 1,401298E-45 bis 3,402823E38 für positive Werte. |
| Double | Gleitkommazahlen mit doppelter Genauigkeit. Wertebereich von -1,79769313486232E308 bis -4,94065645841247E-324 für negative Werte und von 4,94065645841247E-324 bis 1,79769313486232E308 für positive Werte. |
| Date (Time) | Enthält eine Nummer, die ein Datum zwischen dem 1. Jänner 100 und dem 31. Dezember 9999 repräsentiert. |
| String | Enthält Zeichenketten bis zu einer Länge von 2 Milliarden Zeichen. |
| Object | Enthält ein Objekt. |
| Error | Enthält eine Fehlernummer. |
Tab. 1: Subtypen und deren Beschreibung
Abschließend sei noch erwähnt, daß VBScript auch Konvertierungsfunktionen zur Verfügung stellt. Mit deren Hilfe kann man Daten von einem Subtyp in einen anderen umwandeln. Weiters kann man die Funktion VarType verwenden, die den Subtyp einer Variable zurückliefert.
Variablen werden in VBScript durch das Dim, Public oder Private-Statement deklariert. Das Dim-Statement dient zum Anlegen von Scriptvariablen oder lokalen Variablen. Durch das Public- bzw. Private-Statement wird die Sichtbarkeit der Variablen bei Klassendefinitionen spezifiziert. Folglich sollte man weder das Public- noch das Private-Statement für Scriptvariablen bzw. lokalen Variablen verwenden.
Da es offiziell nur einen Datentyp gibt, erfolgt das Anlegen von Variablen mit:
Dim myVariable
Man kann jedoch der Variable keinen Wert bei ihrer Deklaration zuweisen. Zuweisungen erfolgen dann nach dem folgenden Prinzip:
myVariable = 10
Objektreferenzen werden mittels des Set-Statements zugewiesen:
Set myVariable = Document.LabelControls
Variablen sollten zur Gewährleistung der Übersichtlichkeit gleich am Anfang des Scripts bzw. gleich am Anfang der Prozedur oder Funktion deklariert werden. Variablen können jedoch auch implizit deklariert werden, indem man einfach ihren Namen innerhalb des Scripts verwendet. Dies kann jedoch bei Tippfehlern zu unerwarteten Ergebnissen führen. Um dies zu vermeiden, sollte als erste Anweisung im Script das Option Explicit-Statement verwendet werden. Dieses Statement erzwingt die explizite Deklaration aller Variablen.
Der Sichtbarkeitsbereich einer Variablen ist durch den Ort ihrer Deklaration definiert. Es gibt sogenannte Script-level Variablen, die als globale Variablen dienen und innerhalb des gesamten Scripts verwendet werden können. Script-level Variablen existieren während der gesamten Ausführung des Script.
Procedure-level Variablen werden innerhalb von Prozeduren bzw. Funktionen deklariert und können auch nur dort verwendet werden. Diese Variablen hören auf zu existieren sobald die Funktion bzw. Prozedur verlassen wird.
Arrayvariablen werden wie skalare Variablen deklariert, mit dem einzigen Unterschied, daß hinter dem Variablennamen die Elementanzahl in Klammern folgt:
Dim a(10)
In diesem Fall wird eine Arrayvariable mit dem Namen a angelegt, die 11 Elemente enthält. In VBScript hat das erste Element einer Arrayvariable den Index 0 und der Index des letzten Elements ist jener Wert, der bei der Variablendeklaration in den Klammern angegeben wird.
Elementzuweisungen erfolgen nach folgendem Prinzip:
a(5) = 10
In diesem Beispiel wird also dem sechsten Element der Variable a der Wert 10 zugewiesen.
In VBScript kann man auch mehrdimensionale Arrays deklarieren, wobei man bis zu 60 Dimensionen angeben kann. Die Deklaration von mehrdimensionalen Arrayvariablen erfolgt wie die Deklaration von einfachen Arrayvariablen, wobei jedoch innerhalb der Klammern die Größe der einzelnen Dimensionen durch Beistriche getrennt angegeben wird. Die Deklaration einer zweidimensionalen Arrayvariable mit 5 Zeilen und 10 Spalten sieht dann wie folgt aus:
Dim b(4, 9)
VBScript unterstützt auch dynamische Arrays. Das heißt, daß bei der Deklaration einer Arrayvariablen keine Dimension spezifiziert wird. Als einzige Kennzeichnung eines dynamischen Arrays erfolgt hinter dem Variablennamen ein Klammernpaar "()". Dynamische Arrayvariablen können entweder mittels des Dim- bzw. ReDim-Statements deklariert werden:
Dim a()
ReDim b()
Die Dimension(en) des Arrays werden dann irgendwo innerhalb des Scripts mittels des ReDim-Statements spezifiziert:
ReDim b(10)
Danach können die Elemente der Arrayvariablen belegt werden. Will man dann die Arrayvariable redimensionieren, so erfolgt das ebenfalls mit dem ReDim-Statement. Es sei jedoch erwähnt, daß dann zwar die Arrayvariable redimensioniert wird, der Inhalt der Elemente aber verloren geht. Um dies zu verhindern dient das Preserve Schlüsselwort:
ReDim Preserve b(15)
In diesem Beispiel wird die Anzahl der Elemente der Arrayvariablen b von 11 Elementen auf 16 Elemente erhöht, wobei der Inhalt der einzelnen Elemente erhalten bleibt. Selbstverständlich kann sowohl die Anzahl der Dimensionen also auch die Größe der einzelnen Dimensionen von Arrayvariablen auch verkleinert werden, wobei dann aber die "abgeschnittenen" Elemente verloren gehen.
Konstanten können mittels des Const-Statements deklariert werden:
Const MYSTRING = "Hallo" 'Stringkonstante
Const BIRTHDATE = #28-03-78# 'Datumskonstante
Im ersten Fall wird eine Stringkonstante für die Zeichenkette "Hallo" deklariert, im zweiten Fall eine Datumskonstante für das Datum 28. März 1978. Wie aus dem Beispiel ersichtlich ist, müssen in VBScript Datums- bzw. Zeitwerte innerhalb von #-Zeichen eingeschlossen sein. Kommentare werden in VBScript durch ein einfaches '-Zeichen spezifiziert und reichen dann bis zum Zeilenende.
In VBScript steht eine große Anzahl von Operatoren zur Verfügung, wie arithmetische Operatoren, Vergleichsoperatoren, Konkatenationsoperatoren und logische Operatoren.
Erscheinen mehrere Operatoren in einem Ausdruck, so werden diese nach einer fest definierten Reihenfolge ausgewertet. Um diese Reihenfolge zu beeinflussen, können geklammerte Ausdrücke verwendet werden, die dann zuerst aufgelöst werden. Innerhalb der Klammern wird jedoch wieder nach der zuvor erwähnten Reihenfolge ausgewertet.
Generell kann man sagen, daß arithmetische Operatoren zuerst evaluiert werden, gefolgt von Vergleichsoperatoren. Logische Operatoren werden erst zum Schluß ausgewertet. Vergleichsoperatoren sind von der Auswertungsreihenfolge als gleichwertig zu betrachten, das heißt, der Ausdruck wird einfach von links nach rechts ausgewertet. Bei arithmetischen bzw. logischen Operatoren soll die folgende Tabelle die Auflösungsreihenfolge veranschaulichen, wobei die Operatoren der ersten Zeile zuerst und jene der letzten Zeile zum Schluß ausgewertet werden.
| Arithmetische Op. |
|
Vergleichsop. |
|
Logische Op. |
|
| Beschreibung |
Symbol
|
Beschreibung |
Symbol
|
Beschreibung |
Symbol
|
| Potenz |
^
|
Gleichheit |
=
|
Logische Negation |
Not
|
| Negative Zahl |
-
|
Ungleichheit |
<>
|
Logisches Und |
And
|
| Multiplikation |
*
|
Kleiner |
<
|
Logisches Oder |
Or
|
| Division |
/
|
Größer |
>
|
Exklusives Oder |
Xor
|
| Ganzzahlige Division (vgl. div) |
\
|
Kleiner gleich |
<=
|
Logische Gleichheit |
Eqv
|
| Modulo |
Mod
|
Größer gleich |
>=
|
Implikation |
Imp
|
| Addition |
+
|
Objektgleichheit |
Is
|
|
|
| Subtraktion |
-
|
|
|
||
| String-Konkatenation |
&
|
|
|
Tab. 2: Operatoren
Falls eine Multiplikation und Division oder eine Addition und Subtraktion in einem Ausdruck gemeinsam vorkommen, so wird dies einfach von links nach rechts ausgewertet.
Der String-Konkatenationsoperator ist eigentlich kein arithmetischer Operator, er wird jedoch nach allen arithmetischen Operatoren und vor den Vergleichsoperatoren ausgewertet.
Der Objektgleichheitsoperator vergleicht ob zwei Objekte identisch sind, es wird also die Objektreferenzgleichheit und nicht die Gleichheit von Attributwerten geprüft.
Als Kontrollanweisungen dienen die If- bzw. die Select Case-Anweisung, welche im folgenden erklärt werden.
Die einfache If-Anweisung hat folgende Struktur: If Bedingung Then eine Anweisung falls Bedingung wahr ist.
Sind mehrere Anweisungen im Then-Block notwendig, so ist die If-Anweisung mit einem End If abzuschließen. Will man jedoch auch Code ausführen, wenn die Auswertung der Bedingung "False" liefert, so kann man einen Else-Block einfügen. Enthält dieser mehr als eine Anweisung, so ist das gesamte If-Konstrukt wieder mit einem End If abzuschließen.
Sollen weitere Abfragen erfolgen, falls die erste Bedingung nicht zutrifft, so kann man das mittels des ElseIf-Schlüsselwortes realisieren.
Das folgende Beispiel soll dies nun verdeutlichen:
Sub Test(value)
Dim a
If value = 0 Then
MsgBox value
ElseIf value = 1 Then
a=InputBox("Geben Sie eine Zahl für die Variable a ein",1)
MsgBox a
Else
a=InputBox("Geben Sie eine Zahl für die Variable a ein",1)
MsgBox a
MsgBox value
End If
End Sub
Die Select Case-Anweisung entspricht der "Switch"-Anweisung in Java. Die Select Case-Anweisung wertet eine Variable bzw. einen Wert (im Select-Statement) einmal aus und verzweigt dann in den entsprechenden Case-Block.
Die Struktur der Select Case-Anweisung sieht wie folgt aus:
Select Case Variable oder Wert
Case Möglichkeit 1
Anweisungen
Case Möglichkeit 2
Anweisungen
...
Case Else
Anweisungen
End Select
Ein konkretes Beispiel sieht dann so aus:
Sub Ausgabe(value)
Select Case value
Case 1
MsgBox "Wert: 1"
Case 2
MsgBox "Hallo"
Case Else
MsgBox "Wert von value: "&value
End Select
End Sub
VBScript unterstützt zwei Arten von Schleifen. Bei der ersten Art handelt es sich um Schleifen, die solange ausgeführt werden bis eine Bedingung falsch wird, wobei bei der zweiten Art die Schleifen solange ausgeführt werden bis eine Bedingung wahr wird.
Folgende Konstrukte für Schleifen werden unterstützt:
Diese Konstrukte werden nun genauer erklärt:
Eine Do ... Loop-Schleife wird, wie zuvor erwähnt, solange ausgeführt wie eine Bedingung wahr ist bzw. bis eine Bedingung wahr wird. Somit ist die Anzahl der Schleifendurchläufe vor der Ausführung der Schleife nicht bekannt. Diese beiden Möglichkeiten werden nun erläutert:
Ausführung solange eine Bedingung wahr ist
Mit dem While-Schlüsselwort spezifiziert man, daß die Schleife solange ausgeführt wird, wie die Auswertung der Schleifenbedingung "True" ergibt. Das While-Schlüsselwort kann am Anfang der Schleife stehen, sodaß die Schleife unter Umständen niemals betreten wird, sowie auch an deren Ende, was zumindest eine einmalige Ausführung der Schleife veranlaßt. Zwei Beispiele sollen das nun verdeutlichen:
Dim index
index = 0
Do While index < 2
MsgBox index
index = index + 1
Loop
In diesem Fall wird die Schleife genau 2 mal ausgeführt. Würde vor Beginn der Schleife der Variablen index nicht der Wert 0 sondern der Wert 2 zugewiesen werden, so würde die Schleife niemals betreten.
Dim index
index = 3
Do
MsgBox index
index = index + 1
Loop While index < 2
In diesem Fall wird die Schleife einmal ausgeführt, da die Schleifenbedingung erst am Schleifenende abgefragt wird.
Ausführung bis eine Bedingung wahr wird
Mit Hilfe des Until-Schlüsselwortes spezifiziert man, daß eine Schleife solange ausgeführt wird, bis die Auswertung der Schleifenbedingung "True" ergibt. Das Until-Schlüsselwort kann ebenfalls wieder am Anfang der Schleife bzw. am Ende der Schleife stehen. Es folgen zwei weitere Beispiele:
Dim index
index = 0
Do Until index = 2
MsgBox index
index = index + 1
Loop
In diesem Fall wird die Schleife ebenfalls 2 mal ausgeführt.
Dim index
index = 3
Do
MsgBox index
index = index + 1
Loop Until index = 4
In diesem Beispiel wird die Schleife einmal ausgeführt, da bei der Überprüfung der Schleifenbedingung die Variable index bereits den Wert 4 hat.
Aussprung aus dem Schleifeninneren
Mittels der Anweisung Exit Do kann aus dem Schleifeninneren eine Schleife verlassen werden. Das folgende Beispiel soll dies demonstrieren:
Dim index
index = 3
Do
MsgBox index
If index = 3 Then Exit Do
index = index + 1
Loop Until index = 4
Hier wird die Schleife nach dem Anzeigen des Dialogfensters schon beim ersten Schleifendurchlauf verlassen.
Die While ... Wend-Schleife gehört nur der Vollständigkeit halber zu den VBScript-Sprachkonstrukten. Es gibt aber keinen Unterschied zu einer Do ... Loop-Schleife mit Schleifenbedingung am Schleifenanfang bei gleichzeitiger Verwendung des While-Schlüsselwortes.
Die For ... Next-Schleife ist eine einfache Zählschleife, wobei die Schleife einem spezifizierten Wert entsprechend oft durchlaufen wird.
Ein einfaches Beispiel soll die Verwendung dieses Schleifentyps zeigen:
Dim index
For index = 1 To 10
MsgBox index
Next
Diese Schleife wird dann genau 10 mal ausgeführt. In diesem Fall wird der Schleifenzähler automatisch nach jedem Schleifendurchlauf um 1 erhöht. Mit dem Step-Schlüsselwort kann man jedoch eine andere (ganzzahlige) Schrittweite definieren. Das folgende Beispiel, indem der Schleifenzähler jeweils um den Wert 2 erniedrigt wird, soll dies demonstrieren:
Dim index
For index = 10 To 0 Step -2
MsgBox index
Next
Innerhalb einer For ... Next- Schleife kann man die Schleife auch mittels der Exit For-Anweisung verlassen.
Die For Each ... Next-Schleife ist mit der For ... Next-Schleife vergleichbar. Der einzige Unterschied ist, daß diese Schleife keinen expliziten Schleifenzähler benutzt. Somit kann man als Programmierer auch nicht die Anzahl der Schleifendurchläufe festlegen. Stattdessen wird die Schleife für jedes Element einer Arrayvariablen bzw. für jedes Element in einer Collection einmal ausgeführt. Dies ist besonders hilfreich, wenn man beispielsweise die Anzahl der Elemente in einer Collection nicht kennt. Ein weiteres Beispiel zeigt die Verwendung dieses Schleifentyps:
Dim myVar(10)
...
For Each elem in myVar
MsgBox myVar(elem)
Next
In VBScript gibt es sowohl Prozeduren als auch Funktionen, wobei Prozeduren keinen Rückgabewert haben, Funktionen jedoch schon.
Prozeduren weisen in VBScript folgende Struktur auf:
Sub Prozedurname([Parameterliste])
Anweisungen
End Sub
Eine Prozedur muß immer mit dem Schlüsselwort Sub beginnen, danach folgt der Prozedurname. Nach dem Prozedurnamen kann innerhalb von runden Klammern eine durch Beistriche getrennte Parameterliste angegeben werden. Da es ja nur einen Datentyp gibt, werden nur die Parameternamen spezifiziert. Will man der Prozedur keine Parameter übergeben, so muß man ein leeres Paar von runden Klammern schreiben. In Bezug auf Parameterübergabe sei noch erwähnt, daß VBScript nur Call-by-Reference unterstützt.
Die folgenden Zeilen enthalten dann Anweisungen. Abgeschlossen wird eine Prozedur durch das Schlüsselwort End Sub.
Funktionen müssen folgende Struktur aufweisen:
Function Funktionsname([Parameterliste])
Anweisungen
Funktionsname = Rückgabewert
End Function
Die Struktur von Funktionen ist praktisch gleich wie jene von Prozeduren, es wird jedoch statt des Schlüsselwortes Sub das Schlüsselwort Function verwendet. Ebenso wird statt des Schlüsselwortes End Sub das Schlüsselwort End Function verwendet. Die Parameterübergabe erfolgt nach dem gleichen Prinzip wie bei Prozeduren.
Wie bereits zuvor erwähnt haben Funktionen einen Rückgabewert vom Typ Variant. Die Rückgabe eines Wertes wird durch folgende Anweisung veranlaßt: "Funktionsname = Rückgabewert". Diese Anweisung kann auch mehrmals im Funktionscode vorkommen, was bedeutet, daß man auch mehrere Austrittspunkte definieren kann.
Eine Möglichkeit für Prozeduraufrufe ist die Verwendung der Call-Anweisung. In diesem Fall schreibt man im Code einfach "Call Prozedurname (Parameter)", wobei auch bei keiner Parameterübergabe runde Klammern notwendig sind.
Die zweite Möglichkeit ist die Angabe des Prozedurnamens, gefolgt von einer durch Beistriche getrennten Parameterliste (falls Parameter übergeben werden). Klammern sind in diesem Fall nicht erlaubt.
Funktionen werden in VBScript durch Angabe des Funktionsnamens, gefolgt von einer Parameterliste in runden Klammern, aufgerufen. Werden keine Parameter übergeben, so muß trotzdem ein leeres Klammernpaar angegeben werden. Wird der Rückgabewert einer Funktion einer Variablen zugewiesen, so muß der Funktionsaufruf immer auf der rechten Seite der Zuweisung stehen.
Das folgende Beispiel soll die Deklaration und Verwendung von Prozeduren und Funktionen verdeutlichen:
Sub ConvertTemp(t)
MsgBox "Die Temperatur beträgt "&Celsius(t)&" Grad Celsius"
End Sub
Function Celsius(f)
Celsius=(f-32)*5/9
End Function
Dim temp
temp = InputBox ("Geben Sie die Temperatur in Fahrenheit ein",1)
Call ConvertTemp(temp)
'bzw. ConvertTemp temp
VBScript stellt drei Möglichkeiten zur Ausführung von VBScript-Code als Reaktion auf Events, wie z. B. dem Drücken eines Buttons in einem HTML-Formular, zur Verfügung. Eine Möglichkeit wurde bereits im Kapitel Einbetten von VBScript-Code in eine HTML-Seite vorgestellt.
Nun folgt eine weitere Möglichkeit, die am besten anhand eines Beispiels demonstriert wird:
<html>
<head> <title> Test Button Event </title>
<SCRIPT LANGUAGE="VBScript">
<!--
Sub Button1_OnClick
MsgBox "Button gedrückt"
End Sub
-->
</SCRIPT>
</head>
<body>
<form> <input type="Button" name="Button1" value="Drücken">
</form>
</body>
</html>
Wenn nun der Internet Explorer diese Seite lädt, werden die SCRIPT-Tags automatisch erkannt und der dazugehörige Code gespeichert. Wird nun der Button gedrückt, so stellt der Internet Explorer die Verbindung zwischen dem Button und dem VBScript-Code her und führt die Prozedur aus. Die Prozedur "Button1_OnClick" ist in diesem Fall eine Eventprozedur. Ihr Name besteht aus zwei Teilen: der erste Teil ist der Name des Objektes, auf dessen Events die Prozedur hören soll, und der zweite Teil spezifiziert den Typ des Events, auf das die Prozedur reagieren soll. Diese beiden Teilnamen müssen durch einen Underscore ("_") getrennt sein.
Die dritte und letzte Möglichkeit kommt ohne die Verwendung von Prozeduren aus, liefert jedoch dieselben Resultate. Ein weiteres Beispiel soll dies zeigen:
<html>
<head> <title> Test Button Event </title> </head>
<body>
<form> <input type="Button" name="Button1" value="Drücken"
OnClick='MsgBox "Button gedrückt!"'> </form>
</body>
</html>
Die Funktionalität von diesem und dem vorhergehenden Beispiel ist identisch.
In diesem Fall ist jedoch zu beachten, daß das Verhalten beim Drücken
des Buttons sofort mittels "OnClick='Anweisungen'" spezifiziert
werden muß. Die Anweisung(en) müssen unter einfachen Hochkommas (')
stehen. Will man mehrere Anweisungen ausführen, so müssen diese durch
einen Doppelpunkt voneinander getrennt sein.
von Christoph Oster