3. Grundlagen der VBScript-Programmierung
Nachdem wir die möglichen Ausführungskontexte für ein VBScript-Skript beschrieben haben, werden wir nun die Sprache selbst behandeln. Von hier an gehen wir von folgenden Voraussetzungen aus:
- Der Skriptcontainer ist WSH
- das Skript befindet sich in einer Datei mit der Erweiterung .vbs
Um ein Konzept vorzustellen, gehen wir im Allgemeinen wie folgt vor:
- Wir stellen das Konzept bei Bedarf vor
- Wir stellen ein anschauliches Programm zusammen mit seinen Ergebnissen vor
- Wir kommentieren die Ergebnisse und das Programm, falls erforderlich
Bei VBScript-Containern wird im Skripttext nicht zwischen Groß- und Kleinschreibung unterschieden. Daher können Sie entweder „wscript.echo „hello““ oder „WSCRIPT.ECHO „hello““ schreiben.
Die unten vorgestellten Programme geben viele Informationen auf dem Bildschirm aus, daher werden wir uns noch einmal die Ausgabemethoden des wscript-Objekts ansehen.
3.1. Anzeigen von Informationen
Wir haben bereits die echo-Methode des wscript-Objekts verwendet, aber es gibt noch weitere Methoden zum Schreiben auf den Bildschirm, wie im folgenden Skript gezeigt:
Programm | Ergebnisse |
 |
Die folgenden Punkte sind zu beachten:
- Jeder Text, der auf ein Apostroph folgt, wird als Skriptkommentar behandelt und von WSH nicht interpretiert (Zeile 1).
- Die Methode „echo“ gibt ihre Argumente aus und springt zur nächsten Zeile, ebenso wie die Methode „writeLine“ (Zeilen 2 und 6)
- Die Methode „write“ gibt ihre Argumente aus und springt nicht in die nächste Zeile (Zeile 3).
- Ein Zeilenendezeichen wird durch die Folge der beiden ASCII-Zeichen 13 und 10 dargestellt. Daher wird Zeile 4 durch den Ausdruck chr(13) & chr(10) dargestellt, wobei chr(i) das ASCII-Zeichen i und & der Zeichenfolgenverknüpfungsoperator ist. Somit ergibt „chat“ & „eau“ die Zeichenfolge „chateau“.
- Das Zeilenendezeichen lässt sich einfacher durch die Konstante vbCRLF darstellen (Zeile 5)
3.2. : Anweisungen in einem VBScript-Skript schreiben
Standardmäßig wird eine Anweisung pro Zeile geschrieben. Es können jedoch mehrere Anweisungen in einer einzigen Zeile geschrieben werden, indem man sie durch das Zeichen: trennt, wie in inst1:inst2:inst3. Wenn eine Zeile zu lang ist, kann sie in Teile aufgeteilt werden. In diesem Fall müssen die verschiedenen Teile der Anweisung durch die beiden Zeichen (Leerzeichen)_ abgeschlossen werden. Schauen wir uns das vorherige Beispiel noch einmal an, indem wir die Anweisungen anders umschreiben:
Programm | Ergebnisse |
 |
3.3. Schreiben mit der Funktion msgBox
Während wir in diesem Dokument das wscript-Objekt fast ausschließlich zur Anzeige von Text auf dem Bildschirm verwenden, gibt es eine komplexere Funktion zur Anzeige von Informationen in einem Fenster. Dies ist die msgbox-Funktion, die im Allgemeinen mit drei Parametern verwendet wird:
msgbox Nachricht, Symbole+Schaltflächen, Titel
- message ist der Text der anzuzeigenden Meldung
- icons+buttons (optional) ist eigentlich eine Zahl, die den Typ des Symbols und die Schaltflächen angibt, die im Meldungsfenster platziert werden sollen. Diese Zahl ist meist die Summe zweier Zahlen: Die erste bestimmt das Symbol, die zweite die Schaltflächen
- title ist der Text, der in der Titelleiste des Meldungsfensters angezeigt werden soll
Die Werte zur Festlegung des Symbols und der Schaltflächen im Anzeigefenster lauten wie folgt:
Konstante | Wert | Beschreibung |
vbOKOnly | 0 | Zeigt nur die Schaltfläche „OK“ an. |
vbOKCancel | 1 | Zeigt die Schaltflächen „OK“ und „Abbrechen“ an. |
vbAbortRetryIgnore | 2 | Zeigt die Schaltflächen „Abbrechen“, „Wiederholen“ und „Ignorieren“ an. |
vbYesNoCancel | 3 | Zeigt die Schaltflächen „Ja“, „Nein“ und „Abbrechen“ an. |
vbYesNo | 4 | Zeigt die Schaltflächen „Ja“ und „Nein“ an. |
vbRetryCancel | 5 | Zeigt die Schaltflächen „Erneut versuchen“ und „Abbrechen“ an. |
vbCritical | 16 | Zeigt das Symbol für kritische Meldungen an. |
vbQuestion | 32 | Zeigt das Symbol für eine Warnanfrage an. |
vbExclamation | 48 | Zeigt das Symbol für eine Warnmeldung an. |
vbInformation | 64 | Zeigt das Symbol für eine Informationsmeldung an. |
vbDefaultButton1 | 0 | Die erste Schaltfläche ist die Standardschaltfläche. |
vbDefaultButton2 | 256 | Die zweite Schaltfläche ist die Standardschaltfläche. |
vbDefaultButton3 | 512 | Die dritte Schaltfläche ist die Standardschaltfläche. |
vbDefaultButton4 | 768 | Die vierte Schaltfläche ist die Standardschaltfläche. |
vbApplicationModal | 0 | Modale Anwendung; der Benutzer muss auf die Meldung reagieren, bevor er die Arbeit in der aktuellen Anwendung fortsetzen kann. |
vbSystemModal | 4096 | Systemmodal; alle Anwendungen werden angehalten, bis der Benutzer auf die Meldung reagiert. |
Hier sind einige Beispiele:
Programm | ||||||||||||||||||||||||
 | ||||||||||||||||||||||||
Ergebnisse | ||||||||||||||||||||||||
| ||||||||||||||||||||||||
In manchen Fällen wird ein Informationsfenster angezeigt, das gleichzeitig als Eingabefenster dient. Wenn beispielsweise eine Frage gestellt wird, möchten wir wissen, ob der Benutzer auf die Schaltfläche „Ja“ oder „Nein“ geklickt hat. Die Funktion msgBox gibt ein Ergebnis zurück, das wir im vorherigen Programm nicht verwendet haben. Dieses Ergebnis ist eine Ganzzahl, die die Schaltfläche angibt, auf die der Benutzer geklickt hat, um das Anzeigefenster zu schließen:
Konstante | Wert | Ausgewählte Schaltfläche |
vbOK | 1 | OK |
vbCancel | 2 | Abbrechen |
vbAbort | 3 | Abbrechen |
vbRetry | 4 | Wiederholen |
vbIgnore | 5 | Ignorieren |
vbYes | 6 | Ja |
vbNein | 7 | Nein |
Das folgende Programm zeigt, wie man das Ergebnis der Funktion „msgBox“ verwendet. Es wird viermal ein Fenster mit den Schaltflächen „Ja“, „Nein“ und „Abbrechen“ angezeigt. Sie reagieren wie folgt:
- Klicken Sie auf „Ja“
- Klicken Sie auf „Nein“
- Klicken Sie auf „Abbrechen“
- Schließen Sie das Fenster, ohne eine Schaltfläche zu verwenden. Das Programm zeigt, dass dies der Verwendung der Schaltfläche „Abbrechen“ entspricht.
Programm | ||||
 | ||||
Ergebnisse | ||||
|
3.4. In VBScript verwendbare Datentypen
VBScript erkennt nur einen Datentyp: den Variant. Der Wert eines Variants kann eine Zahl (4, 10,2), eine Zeichenfolge („hello“), ein Boolescher Wert (true/false), ein Datum (#01/01/2002#), die Adresse eines Objekts oder eine Sammlung all dieser Datentypen sein, die in einer als Array bezeichneten Struktur angeordnet sind.
Betrachten wir das folgende Programm und seine Ergebnisse:
Programm | Ergebnisse |
 |
Kommentare:
- In einer Reihe von Programmiersprachen (C, C++, Pascal, Java, C# usw.) muss eine Variable vor ihrer Verwendung deklariert werden. Bei dieser Deklaration werden der Name der Variablen und der Datentyp, den sie aufnehmen kann (Ganzzahl, Gleitkomma, Zeichenkette, Datum, Boolescher Wert usw.), angegeben. Die Deklaration von Variablen ermöglicht verschiedene Dinge:
- den für die Variable benötigten Speicherplatz zu bestimmen, da verschiedene Datentypen unterschiedliche Speicherplatzmengen erfordern
- die Konsistenz des Programms zu überprüfen. Wenn beispielsweise i eine Ganzzahl und c eine Zeichenkette ist, ergibt die Multiplikation von i mit c keinen Sinn. Wenn die Typen der Variablen i und c vom Programmierer deklariert wurden, kann das Programm, das für die Analyse des Codes vor der Ausführung zuständig ist, eine solche Inkonsistenz kennzeichnen.
Wie die meisten Skriptsprachen mit einem einzigen Datentyp (Perl, Python, JavaScript usw.) erlaubt VBScript die Verwendung von Variablen ohne Deklaration. Genau das wurde im obigen Beispiel getan.
- Beachten Sie die Syntax der verschiedenen Datentypen
- 10,2 in Zeile 10 (Dezimalpunkt, kein Komma). Beachten Sie, dass 10,2 auf dem Bildschirm angezeigt wird.
- 1,4e-2 in Zeile 13 (wissenschaftliche Notation). Die Zahl 0,014 wird
- [#01/10/2002#] (Zeile 26), um das Datum 10. Januar 2002 darzustellen. VBScript verwendet daher das Format #mm/tt/jjjj#, um das Datum tt des Monats mm des Jahres jjjj darzustellen
- die Booleschen Werte true und false in den Zeilen 31 und 34. Diese beiden Werte werden jeweils durch die Ganzzahlen -1 und 0 dargestellt, wie in der Ausgabe der Zeilen 32 und 35 zu sehen ist. Wenn ein Boolescher Wert mit einer Zeichenkette verkettet wird, werden diese Werte zu den Zeichenketten „True“ bzw. „False“, wie in den Zeilen 33 und 36 gezeigt. Beachten Sie, dass der Verkettungsoperator & nicht nur zum Verketten von Zeichenketten verwendet werden kann.
- Da einer Variablen v kein Typ zugewiesen ist, kann sie im Laufe der Zeit nacheinander Werte unterschiedlicher Typen enthalten.
3.5. L : Untertypen des Variant-Typs
Hier ist, was die offizielle Dokumentation über die verschiedenen Datentypen sagt, die ein Variant enthalten kann:
Über die einfache Unterscheidung zwischen Zahlen und Zeichenfolgen hinaus kann ein Variant zwischen verschiedenen Arten numerischer Informationen unterscheiden. Beispielsweise stellen manche numerischen Informationen ein Datum oder eine Uhrzeit dar. Wenn diese Informationen zusammen mit anderen Datums- oder Zeitangaben verwendet werden, wird das Ergebnis stets als Datum oder Uhrzeit ausgedrückt. Es gibt auch andere Arten numerischer Informationen, die von booleschen Werten bis hin zu großen Gleitkommazahlen reichen. Diese verschiedenen Kategorien von Informationen, die in einem Variant enthalten sein können, sind Untertypen. In den meisten Fällen fügen Sie Ihre Daten einfach in ein Variant ein, und es verhält sich entsprechend diesen Daten auf die am besten geeignete Weise.
Die folgende Tabelle listet die verschiedenen Untertypen auf, die in einem Variant enthalten sein können.
Untertyp | Beschreibung |
Leer | Die Variante ist nicht initialisiert. Ihr Wert ist Null für numerische Variablen und eine leere Zeichenkette („“) für Zeichenfolgenvariablen. |
Null | Die Variant enthält absichtlich falsche Daten. |
Booles | |
Byte | Enthält eine Ganzzahl von 0 bis 255. |
Ganzzahl | Enthält eine Ganzzahl von -32.768 bis 32.767. |
Währung | -922.337.203.685.477,5808 bis 922.337.203.685.477,5807. |
Long | Enthält eine Ganzzahl von -2.147.483.648 bis 2.147.483.647. |
Single | Enthält eine Gleitkommazahl mit einfacher Genauigkeit im Bereich von -3,402823E38 bis -1,401298E-45 für negative Werte; von 1,401298E-45 bis 3,402823E38 für positive Werte. |
Double | Enthält eine Gleitkommazahl mit doppelter Genauigkeit im Bereich von -1,79769313486232E308 bis -4,94065645841247E-324 für negative Werte; von 4,94065645841247E-324 bis 1,79769313486232E308 für positive Werte. |
Datum (Uhrzeit) | Enthält eine Zahl, die ein Datum zwischen dem 1. Januar 100 und dem 31. Dezember 9999 darstellt. |
Zeichenkette | Enthält eine Zeichenfolge variabler Länge, die auf etwa 2 Milliarden Zeichen begrenzt ist. |
Objekt | Enthält ein Objekt. |
Fehler | Enthält eine Fehlernummer. |
3.6. C- : Den genauen Typ der in einer Variablen enthaltenen Daten ermitteln
Eine Variable vom Typ variant kann Daten verschiedener Typen enthalten. Manchmal müssen wir die genaue Beschaffenheit dieser Daten kennen. Wenn wir in einem Programm product = number1 \* number2 schreiben, gehen wir davon aus, dass number1 und number2 beide numerische Werte sind. Manchmal sind wir uns jedoch nicht sicher, da diese Werte aus einer Tastatureingabe, einer Datei oder einer anderen externen Quelle stammen können. Wir müssen dann die Art der in number1 und number2 gespeicherten Daten überprüfen. Mit der Funktion typename(var) können wir den in der Variablen var enthaltenen Datentyp ermitteln. Hier sind einige Beispiele:
Programm | Ergebnisse |
 |
Eine weitere mögliche Funktion ist vartype(var), die eine Zahl zurückgibt, die den Typ der in der Variablen var enthaltenen Daten angibt:
Konstante | Wert | Beschreibung |
vbEmpty | 0 | Leer (nicht initialisiert) |
vbNull | 1 | Null (keine gültigen Daten) |
vbInteger | 2 | Ganzzahl |
vbLong | 3 | Ganze Zahl (Long) |
vbSingle | 4 | Gleitkommazahl mit einfacher Genauigkeit |
vbDouble | 5 | Gleitkommazahl mit doppelter Genauigkeit |
vbCurrency | 6 | Währung |
vbDate | 7 | Datum |
vbString | 8 | Zeichenfolge |
vbObject | 9 | Automatisierungsobjekt |
vbError | 10 | Fehler |
vbBoolean | 11 | Boolesche Variable |
vbVariant | 12 | Variant (wird nur bei Variant-Arrays verwendet) |
vbDataObject | 13 | Nicht-Automation-Objekt |
vbByte | 17 | Byte |
vbArray | 8192 | Array |
Hinweis: Diese Konstanten sind in VBScript definiert. Daher können die Namen an beliebiger Stelle in Ihrem Code anstelle der tatsächlichen Werte verwendet werden.
Die obigen Informationen stammen aus der VBScript-Dokumentation. Diese sind manchmal fehlerhaft, wahrscheinlich aufgrund von Kopier- und Einfügevorgängen aus der VB-Dokumentation. Die VBScript-Funktion „vartype“ erfüllt nur einen Teil der oben beschriebenen Aufgaben.
Das vorherige Programm, umgeschrieben für „vartype“, liefert die folgenden Ergebnisse:
Programm | Ergebnisse |
 |
3.7. D Deklaration der vom Skript verwendeten Variablen
Wir haben erwähnt, dass es nicht zwingend erforderlich ist, die vom Skript verwendeten Variablen zu deklarieren. In diesem Fall, wenn wir schreiben:
1) somme=4
...
2) somme=smme+10
Wenn in Zeile 2 ein Tippfehler vorliegt – beispielsweise „smme“ statt „somme“ –, meldet VBScript keinen Fehler. Es geht davon aus, dass „smme“ eine neue Variable ist. Es legt diese an und verwendet sie im Kontext von Zeile 2, indem es sie auf 0 initialisiert.
Solche Fehler können sehr schwer zu finden sein. Daher ist es ratsam, die Variablendeklaration mithilfe der Anweisung option explicit am Anfang des Skripts zu erzwingen. Dann muss jede Variable vor ihrer ersten Verwendung mit einer dim-Anweisung deklariert werden:
option explicit
...
dim somme
1) somme=4
...
2) somme=smme+10
In diesem Beispiel weist VBScript darauf hin, dass in 2) eine nicht deklarierte Variable „smme“ vorhanden ist, wie im folgenden Beispiel gezeigt:
Programm | Ergebnisse |
 |
Zwar sind die Variablen in den kurzen Beispielen dieses Dokuments meist nicht deklariert, doch sobald wir unsere ersten aussagekräftigen Skripte schreiben, müssen wir sie deklarieren. Die Anweisung „Option Explicit“ wird dann systematisch verwendet.
3.8. Konvertierungsfunktionen
VBScript konvertiert Variant-Daten je nach Kontext in Zeichenfolgen, Zahlen, Boolesche Werte usw. Meistens funktioniert dies gut, doch manchmal führt es zu unerwarteten Ergebnissen, wie wir später sehen werden. Daher möchten Sie möglicherweise den Datentyp des Variants „erzwingen“. VBScript verfügt über Konvertierungsfunktionen, die einen Ausdruck in verschiedene Datentypen umwandeln. Hier sind einige davon:
Cint (Ausdruck) | konvertiert Ausdruck in eine kurze Ganzzahl |
Clng (Ausdruck) | konvertiert Ausdruck in eine lange Ganzzahl |
Cdbl (Ausdruck) | konvertiert Ausdruck in einen Double |
Csng (Ausdruck) | konvertiert Ausdruck in eine Gleitkommazahl mit einfacher Genauigkeit (single) |
Ccur (Ausdruck) | konvertiert Ausdruck in eine Währung |
Hier sind einige Beispiele:
3.9. Über die Tastatur eingegebene Daten
Das wscript-Objekt ermöglicht es einem Skript, über die Tastatur eingegebene Daten abzurufen. Die Methode wscript.stdin.readLine liest eine Textzeile ein, die über die Tastatur eingegeben und durch Drücken der „Enter“-Taste bestätigt wurde. Diese eingelesene Zeile kann einer Variablen zugewiesen werden.
Programm | Ergebnisse |
 | |
Kommentare:
- In der Ergebnisspalte und in der Zeile [Geben Sie Ihren Namen ein: st] ist „st“ der vom Benutzer eingegebene Text.
Wenn der über die Tastatur eingegebene Text eine Zahl darstellt, wird er dennoch in erster Linie als Zeichenfolge behandelt, wie im folgenden Beispiel gezeigt:
Programm | Ergebnisse |
 |
Wenn diese Zahl in einer arithmetischen Operation verwendet wird, wandelt VBScript die Zeichenfolge automatisch in eine Zahl um, jedoch nicht immer. Sehen wir uns das folgende Beispiel an:
Programm | Ergebnisse |
 |
In den Ergebnissen sehen wir, dass Zeile 8 des Skripts nicht wie erwartet ausgeführt wurde, da der Operator + in VBScript (leider) zwei Bedeutungen hat: die Addition zweier Zahlen oder die Verkettung zweier Zeichenfolgen (die beiden Zeichenfolgen werden miteinander verbunden). Wir haben zuvor gesehen, dass über die Tastatur eingegebene Zahlen als Zeichenfolgen gelesen wurden und dass VBScript sie bei Bedarf in Zahlen umwandelte. Dies funktionierte korrekt für die Operationen -, *, /, die nur Zahlen beinhalten können, nicht jedoch für den Operator +, der auch Zeichenfolgen beinhalten kann. Hier ging das Skript davon aus, dass wir Zeichenfolgen verketten wollten.
Eine einfache Lösung für dieses Problem besteht darin, die Zeichenfolgen sofort nach dem Einlesen in Zahlen umzuwandeln, wie in der folgenden Verbesserung des vorherigen Programms gezeigt wird:
Programm | Ergebnisse |
 |
3.10. S Eingabe von Daten mit der Funktion inputBox
Möglicherweise möchten Sie Daten über eine grafische Oberfläche statt über die Tastatur eingeben. Verwenden Sie in diesem Fall die Funktion inputBox. Diese Funktion akzeptiert viele Parameter, aber üblicherweise werden nur die ersten beiden verwendet:
response = inputBox(message, title)
- message: die Frage, die Sie dem Benutzer stellen
- title (optional): der Titel, den Sie dem Eingabefenster geben
- response: der vom Benutzer eingegebene Text. Wenn der Benutzer das Fenster geschlossen hat, ohne zu antworten, ist response eine leere Zeichenkette.
Hier ist ein Beispiel, in dem wir nach dem Namen und dem Alter einer Person fragen. Für den Namen geben wir Informationen ein und klicken auf „OK“. Für das Alter geben wir ebenfalls Informationen ein, klicken aber auf „Abbrechen“.
Programm | ||||
 | ||||
Ergebnisse | ||||
|
3.11. U n strukturierte Objekte
Mit VBScript lassen sich Objekte mit Methoden und Eigenschaften erstellen. Der Einfachheit halber stellen wir hier ein Objekt mit Eigenschaften, aber ohne Methoden vor. Nehmen wir eine Person als Beispiel. Sie hat viele Eigenschaften, die sie charakterisieren: Größe, Gewicht, Hautfarbe, Augenfarbe, Haarfarbe usw. Wir konzentrieren uns hier auf nur zwei: ihren Namen und ihr Alter. Bevor Sie Objekte verwenden können, müssen Sie die Vorlage erstellen, mit der Sie diese erstellen können. In VBScript geschieht dies mithilfe einer Klasse. Die Klasse „Person“ könnte wie folgt definiert werden:
class personne
Dim nom,age
End class
Es ist die Anweisung [Dim name, age], die die beiden Eigenschaften der Klasse Person definiert. Um Kopien (sogenannte Instanzen) der Klasse Person zu erstellen, schreiben wir:
Warum nicht schreiben
Da eine Variable kein Objekt enthalten kann. Sie kann nur die Adresse des Objekts enthalten. Wenn Sie „set person1 = new person“ schreiben, geschieht Folgendes:
- Ein Person-Objekt wird erstellt. Das bedeutet, dass ihm Speicher zugewiesen wird.
- Die Adresse dieses Person-Objekts wird der Variablen person1 zugewiesen
Wir haben dann die folgende Speicheranordnung für die Variablen person1 und person2:
 |
Bildlich gesprochen könnte man sagen, dass person1 ein Personenobjekt ist. Wir können diese bildliche Darstellung akzeptieren, wenn wir bedenken, dass person1 tatsächlich die Adresse eines Personenobjekts ist und nicht das Personenobjekt selbst.
Wir haben gesagt, dass ein Person-Objekt zwei Eigenschaften hat: name und age. Wie greifen wir auf diese Eigenschaften zu? Mit der Notation object.property, wie zuvor erläutert. Somit
bezieht sich person1.name auf den Namen von Person 1 und person1.age auf deren Alter. Hier ist ein kurzes Programm zur Veranschaulichung:
Programm | Ergebnisse |
 |
Das vorherige Programm könnte wie folgt geändert werden:
Programm | Ergebnisse |
 |
Hier haben wir die Struktur with ... end with verwendet, die es uns ermöglicht, Objektnamen in Ausdrücken „herauszulösen“. Die Struktur with p1 ... end with* in den Zeilen 9–12 und 15–18 ermöglicht es uns, die Syntax .name anstelle von p1.name* und .age* anstelle von p1.age* zu verwenden. Dies vereinfacht das Schreiben von Anweisungen, in denen derselbe Objektname wiederholt verwendet wird.
3.12. Zuweisen eines Werts zu einer Variablen
Es gibt zwei Anweisungen zum Zuweisen eines Werts an eine Variable:
- variable=ausdruck
- set variable=Ausdruck
Form 2 ist für Ausdrücke reserviert, deren Ergebnis eine Objektreferenz ist. Für alle anderen Arten von Ausdrücken ist Form 1 geeignet. Der Unterschied zwischen den beiden Formen ist wie folgt:
- In der Anweisung variable=Ausdruck erhält die Variable einen Wert. Sind v1 und v2 zwei Variablen, wird durch die Schreibweise v1=v2 der Wert von v1 der Variablen v2 zugewiesen. Dies führt zur Duplizierung eines Werts an zwei verschiedenen Stellen. Wird der Wert von v2 anschließend geändert, bleibt der Wert von v1 unverändert.
 |
- In der Anweisung `set variable=expression` wird `variable` die Adresse eines Objekts zugewiesen. Wenn `v1` und `v2` zwei Variablen sind und `v2` die Adresse eines Objekts `obj2` ist, weist die Schreibweise `set v1=v2` `v2` den Wert von `v1` zu, d. h. die Adresse des Objekts `obj2`. Wenn das Skript anschließend v1 und v2 manipuliert, werden nicht die „Werte“ von v1 und v2 manipuliert, sondern die Objekte, auf die v1 und v2 „zeigen“ – in diesem Fall dasselbe Objekt. Wir sagen, dass v1 und v2 zwei Verweise auf dasselbe Objekt sind, und es macht keinen Unterschied, ob man es über v1 oder v2 manipuliert. Mit anderen Worten: Das Ändern des Objekts, auf das v2 verweist, ändert auch dasjenige, auf das v1 verweist.
 |
Hier ist ein Beispiel:
Programm | Ergebnisse |
 |
3.13. E- e zur Auswertung von Ausdrücken
Die wichtigsten Operatoren zur Auswertung von Ausdrücken sind folgende:
Art der Operatoren | Operatoren | Beispiel |
Arithmetik | +,-,*,/ | |
Vergleich | <, <= >, >= =,<> | a<>b ist wahr, wenn a nicht gleich b ist a=b ist wahr, wenn a gleich b ist a und b können beide Zahlen oder beide Zeichenfolgen sein. Im letzteren Fall gilt string1<string2, wenn string1 in alphabetischer Reihenfolge vor string2 steht. Beim Vergleich von Zeichenfolgen stehen Großbuchstaben in alphabetischer Reihenfolge vor Kleinbuchstaben. |
Logik | und, oder, nicht, XOR | Alle Operanden sind hier boolesch. bool1 oder bool2 ist wahr, wenn bool1 oder bool2 wahr ist bool1 und bool2 ist wahr, wenn sowohl bool1 als auch bool2 wahr sind not bool1 ist wahr, wenn bool1 falsch ist, und umgekehrt bool1 xor bool2 ist wahr, wenn nur einer der Booleschen Werte bool1 oder bool2 wahr ist |
Verkettung | &, + | Es wird nicht empfohlen, den Operator + zum Verketten zweier Zeichenfolgen zu verwenden, da dies mit der Addition zweier Zahlen verwechselt werden kann. Verwenden Sie daher ausschließlich den Operator &. |
3.14. C- : Steuerung der Programmausführung
3.14.1. E : Aktionen bedingt ausführen
Die VBScript-Anweisung, mit der Aktionen je nachdem ausgeführt werden, ob eine Bedingung wahr oder falsch ist, lautet wie folgt:
Der Ausdruck wird zuerst ausgewertet. Dieser Ausdruck muss einen booleschen Wert haben. Wenn er als wahr ausgewertet wird, werden die Aktionen im then-Block ausgeführt; andernfalls werden die Aktionen im else-Block ausgeführt, sofern vorhanden. |
Hier ist ein Programm, das verschiedene Varianten der if-then-else-Anweisung demonstriert:
Programm | Ergebnisse |
 |
Anmerkungen:
- In VBScript können Sie Anweisung1:Anweisung2:... : Anweisungn schreiben, anstatt eine Anweisung pro Zeile zu schreiben. Diese Funktion wird beispielsweise in Zeile 10 verwendet.
3.14.2. E- Wiederholte Ausführung von Aktionen
Schleife mit bekannter Anzahl von Iterationen |
Sie können eine for-Schleife jederzeit mit der Anweisung exit for verlassen. |
Schleife mit unbekannter Anzahl von Iterationen |
Sie können eine do-while-Schleife jederzeit mit der Anweisung exit do verlassen. |
Das folgende Programm veranschaulicht diese Punkte:
Programm |
 |
Ergebnisse |
|
Hinweis: Während der Entwicklungsphase eines Programms kommt es nicht selten vor, dass ein Programm in eine „Schleife“ gerät, d. h. niemals stoppt. Im Allgemeinen führt das Programm eine Schleife aus, deren Abbruchbedingung nicht überprüft werden kann, wie im folgenden Beispiel:
' infinite loop
i=0
Do While 1=1
i=i+1
wscript.echo i
Loop
' another of the same kind
i=0
Do While true
i=i+1
wscript.echo i
Loop
Wenn Sie das vorherige Programm ausführen, wird die erste Schleife niemals von selbst enden. Sie können sie zwangsweise beenden, indem Sie auf der Tastatur STRG-C drücken (halten Sie die STRG- und die C-Taste gleichzeitig gedrückt).
3.14.3. Beenden der Programmausführung
Die Anweisung ***wscript.quit n*** beendet das Programm, indem sie einen Fehlercode zurückgibt, der gleich n ist. Unter DOS kann dieser Fehlercode mit der Anweisung if ERRORLEVEL n überprüft werden, die den Wert „true“ ergibt, wenn der vom zuletzt ausgeführten Programm zurückgegebene Fehlercode >=n ist. Betrachten Sie das folgende Programm und seine Ergebnisse:
 |
Unmittelbar nach dem Ausführen des Programms werden die folgenden drei DOS-Befehle ausgegeben:
Der DOS-Befehl 1 prüft, ob der vom Programm zurückgegebene Fehlercode >=5 ist. Ist dies der Fall, gibt er 5 aus (echo); andernfalls nichts.
Der DOS-Befehl 3 prüft, ob der vom Programm zurückgegebene Fehlercode >=4 ist. Ist dies der Fall, wird 4 ausgegeben; andernfalls nichts.
Der DOS-Befehl 5 prüft, ob der vom Programm zurückgegebene Fehlercode >=3 ist. Ist dies der Fall, gibt er 3 aus; andernfalls nichts.
Aus den angezeigten Ergebnissen lässt sich ableiten, dass der vom Programm zurückgegebene Fehlercode 4 war.
3.15. L- t Daten-Arrays in einer Variante
Ein Variant T kann eine Liste von Werten enthalten. Wir sagen dann, dass es sich um ein Array handelt. Ein Array T hat verschiedene Eigenschaften:
- Wir greifen auf das Element i des Arrays T mit der Syntax T(i) zu, wobei i eine ganze Zahl ist, die als Index bezeichnet wird und zwischen 0 und n-1 liegt, wenn T n Elemente hat.
- Der Index des letzten Elements des Arrays T kann mit dem Ausdruck ubound(T) ermittelt werden. Die Anzahl der Elemente im Array T ist dann ubound(T)+1. Diese Zahl wird oft als Größe des Arrays bezeichnet.
- Eine Variable T kann mit einem leeren Array unter Verwendung der Syntax T=array() oder mit einer Folge von Elementen unter Verwendung der Syntax T=array(element0, element1, ...., elementn) initialisiert werden
- Sie können einem bereits erstellten Array T Elemente hinzufügen. Verwenden Sie dazu die Anweisung redim preserve T(N), wobei N der neue Index des letzten Elements des Arrays T ist. Dieser Vorgang wird als Größenänderung (redim) bezeichnet. Das Schlüsselwort preserve gibt an, dass bei dieser Größenänderung der aktuelle Inhalt des Arrays erhalten bleiben muss. Fehlt dieses Schlüsselwort, wird T in der Größe angepasst und seine Elemente werden gelöscht.
- Ein Element T(i) des Arrays T ist vom Typ variant und kann daher jeden beliebigen Wert enthalten, einschließlich eines anderen Arrays. In diesem Fall bezieht sich die Notation T(i)(j) auf das j-te Element des Arrays T(i).
Diese verschiedenen Eigenschaften von Arrays werden durch das folgende Programm veranschaulicht:
Programm | Ergebnisse |
 |
Kommentare
- Hier haben wir eine Funktion namens „join“ verwendet, die weiter unten näher erläutert wird.
3.16. Deklaration von Array-Variablen
In VBScript gibt es eine weitere Möglichkeit, ein Array zu verwenden: durch die Verwendung einer Array-Variablen. Im Gegensatz zu skalaren Variablen muss eine solche Variable mit einer „dim“-Anweisung deklariert werden. Es sind verschiedene Deklarationen möglich:
- dim array(n) deklariert ein statisches Array mit n+1 Elementen, die von 0 bis n nummeriert sind. Die Größe dieses Array-Typs kann nicht geändert werden
- dim array() deklariert ein leeres dynamisches Array. Es muss zur Verwendung mit der redim-Anweisung in der Größe angepasst werden, genau wie bei einem Variant, das ein Array enthält
- dim array(n,m) deklariert ein zweidimensionales Array mit (n+1)*(m+1) Elementen. Das Element (i,j) des Arrays wird als array(i,j) bezeichnet. Beachten Sie den Unterschied zu einer Variablen, bei der dasselbe Element als array(i)(j) bezeichnet worden wäre.
Warum gibt es zwei Arten von Arrays, die sich letztlich sehr ähnlich sind? Die VBScript-Dokumentation geht darauf nicht ein und gibt keinen Hinweis darauf, ob eine davon effizienter ist als die andere. Im weiteren Verlauf werden wir in unseren Beispielen fast ausschließlich Arrays innerhalb von Varianten verwenden. Es ist jedoch erwähnenswert, dass VBScript von der Sprache Visual Basic abgeleitet ist, die selbst typisierte Daten enthält (Integer, Double, Boolean usw.). Wenn wir in diesem Fall beispielsweise ein Array mit reellen Zahlen verwenden müssen, ist die Array-Variable effizienter als die Variant-Variable. Wir würden dann etwas wie dim array(1000) as double deklarieren, um ein Array mit reellen Zahlen zu definieren, oder einfach dim array() as double, wenn das Array dynamisch ist.
Hier ist ein Beispiel, das die Verwendung von Array-Variablen veranschaulicht:
Programm | Ergebnisse |
 |
3.17. L : die Funktionen „split“ und „join“
Mit den Funktionen split und join können Sie eine Zeichenkette in ein Array umwandeln und umgekehrt:
- Wenn T ein Array und car eine Zeichenkette ist, ist join(T,car) eine Zeichenkette, die durch Verknüpfung aller Elemente des Arrays T gebildet wird, wobei jedes Element durch die Zeichenkette car vom nächsten getrennt ist. Somit ergibt join(array(1,2,3),"abcd") die Zeichenkette "1abcd2abcd3"
- Wenn C eine Zeichenkette ist, die aus einer Folge von Feldern besteht, die durch die Zeichenkette car getrennt sind, gibt die Funktion split(C,car) ein Array zurück, dessen Elemente die einzelnen Teile der Zeichenkette C sind. Somit gibt split("1abcd2abcd3", "abcd") das Array (1,2,3) zurück
Hier ist ein Beispiel:
Programm | Ergebnisse |
| |
3.18. Wörterbücher
Wir können auf ein Element eines Arrays T zugreifen, wenn wir dessen Index i kennen. Der Zugriff erfolgt dann über die Notation T(i). Es gibt Arrays, auf deren Elemente nicht über einen Index, sondern über eine Zeichenkette zugegriffen wird. Ein typisches Beispiel für diese Art von Array ist ein Wörterbuch. Wenn wir die Bedeutung eines Wortes in „Larousse“ oder „Le petit Robert“ nachschlagen, greifen wir über das Wort darauf zu. Wir könnten dieses Wörterbuch als zweispaltiges Array darstellen:
Wort1 | Beschreibung1 |
Wort2 | Beschreibung2 |
Wort3 | Beschreibung3 |
.... |
Wir könnten dann beispielsweise Folgendes schreiben:
dictionary("Wort1") = "Beschreibung1"
dictionary("Wort2") = "Beschreibung2"
...
Dies ähnelt der Funktionsweise eines Arrays, mit dem Unterschied, dass die Array-Indizes keine Ganzzahlen, sondern Zeichenfolgen sind. Diese Art von Array wird als Dictionary (oder assoziatives Array, Hash-Tabelle) bezeichnet, und die Zeichenfolgenindizes werden als Dictionary-Schlüssel bezeichnet. Dictionaries werden in der Welt der Informatik extrem häufig verwendet. Wir alle haben eine Sozialversicherungskarte mit einer Nummer darauf. Diese Nummer identifiziert uns eindeutig und ermöglicht den Zugriff auf Informationen über uns. Im Modell dictionary("key")="information" wäre „key“ die Sozialversicherungsnummer und „information“ wären alle Informationen, die über uns in den Sozialversicherungssystemen gespeichert sind.
In Windows gibt es ein ActiveX-Objekt namens „Scripting.Dictionary“, mit dem Sie Wörterbücher erstellen und verwalten können. Ein ActiveX-Objekt ist eine Softwarekomponente, die eine Schnittstelle bereitstellt, die von Programmen in verschiedenen Sprachen genutzt werden kann, sofern diese dem ActiveX-Objektstandard entsprechen. Das Scripting.Dictionary-Objekt kann daher von Windows-Programmiersprachen wie JavaScript, Perl, Python, C, C++, VB, VBA und anderen verwendet werden – nicht nur von VBScript.
1 | Ein Scripting.Dictionary-Objekt wird mit der folgenden Anweisung erstellt set dico=wscript.CreateObject("Scripting.Dictionary") oder einfach set dico=CreateObject("Scripting.Dictionary") CreateObject ist eine Methode des WScript-Objekts, die zum Erstellen von Instanzen von ActiveX-Objekten verwendet wird. Version 2 zeigt, dass wscript ein implizites Objekt sein kann. Wenn eine Methode nicht zu einem Objekt „aufgelöst“ werden kann, versucht der WSH-Container, sie zum wscript-Objekt aufzulösen. |
2 | Sobald das Wörterbuch erstellt ist, können wir ihm mithilfe der add-Methode Elemente hinzufügen: dico.add „key“,value erstellt einen neuen Eintrag im Wörterbuch, der mit dem Schlüssel „key“ verknüpft ist. Der zugehörige Wert ist ein Variant, der beliebige Daten enthalten kann. |
3 | Um den mit einem bestimmten Schlüssel verknüpften Wert abzurufen, verwenden wir die Methode „item“ des Wörterbuchs: var = dic.item("key") oder set var = dic.item("key"), wenn der mit dem Schlüssel verknüpfte Wert ein Objekt ist. |
4 | Alle Schlüssel im Wörterbuch können mithilfe der Methode `keys` in einem variablen Array abgerufen werden: keys = dic.keys `keys` ist ein Array, dessen Elemente durchlaufen werden können. |
5 | Alle Werte im Wörterbuch können mithilfe der Methode `items` in ein Array-Variable abgerufen werden: values = dic.items `items` ist ein Array, dessen Elemente durchlaufen werden können. |
6 | Die Existenz eines Schlüssels kann mit der Methode `exists` überprüft werden: dico.exists("key") ist wahr, wenn der Schlüssel „key“ im Wörterbuch vorhanden ist |
7 | Sie können einen Eintrag aus dem Wörterbuch (Schlüssel+Wert) mit der Methode „remove“ entfernen: dico.remove("key") entfernt den Eintrag aus dem Wörterbuch, der mit dem Schlüssel „key“ verknüpft ist. dico.removeall entfernt alle Schlüssel, d. h., es leert das Wörterbuch. |
Das folgende Programm nutzt diese verschiedenen Optionen:
Programm
' creating and using a dictionary
Set dico=CreateObject("Scripting.Dictionary")
' dico filling
dico.add "clé1","valeur1"
dico.add "clé2","valeur2"
dico.add "clé3","valeur3"
' number of elements
wscript.echo "Le dictionnaire a " & dico.count & " éléments"
' kEY LIST
wscript.echo "liste des clés"
cles=dico.keys
For i=0 To ubound(cles)
wscript.echo cles(i)
Next
' list of values
wscript.echo "liste des valeurs"
valeurs=dico.items
For i=0 To ubound(valeurs)
wscript.echo valeurs(i)
Next
' list of keys and values
wscript.echo "liste des clés et valeurs"
cles=dico.keys
For i=0 To ubound(cles)
wscript.echo "dico(" & cles(i) & ")=" & dico.item(cles(i))
Next
' item search
' key1
If dico.exists("clé1") Then
wscript.echo "La clé clé1 existe dans le dictionnaire et la valeur associée est " & dico.item("clé1")
Else
wscript.echo "La clé clé1 n'existe pas dans le dictionnaire"
End If
' key4
If dico.exists("clé4") Then
wscript.echo "La clé clé4 existe dans le dictionnaire et la valeur associée est " & dico.item("clé4")
Else
wscript.echo "La clé clé4 n'existe pas dans le dictionnaire"
End If
' remove key 1
dico.remove("clé1")
' list of keys and values
wscript.echo "liste des clés et valeurs après suppression de clé1"
cles=dico.keys
For i=0 To ubound(cles)
wscript.echo "dico(" & cles(i) & ")=" & dico.item(cles(i))
Next
' we do away with everything
dico.removeall
' list of keys and values
wscript.echo "liste des clés et valeurs après suppression de tous les éléments"
cles=dico.keys
For i=0 To ubound(cles)
wscript.echo "dico(" & cles(i) & ")=" & dico.item(cles(i))
Next
' end
wscript.quit 0
Ergebnisse
Le dictionnaire a 3 éléments
liste des clés
clé1
clé2
clé3
liste des valeurs
valeur1
valeur2
valeur3
liste des clés et valeurs
dico(clé1)=valeur1
dico(clé2)=valeur2
dico(clé3)=valeur3
La clé clé1 existe dans le dictionnaire et la valeur associée est valeur1
La clé clé4 n'existe pas dans le dictionnaire
liste des clés et valeurs après suppression de clé1
dico(clé2)=valeur2
dico(clé3)=valeur3
liste des clés et valeurs après suppression de tous les éléments
3.19. Sortieren eines Arrays oder eines Dictionaries
Häufig möchte man ein Array oder ein Dictionary in aufsteigender oder absteigender Reihenfolge nach seinen Werten oder, im Falle eines Dictionaries, nach seinen Schlüsseln sortieren. Während die meisten Sprachen über Sortierfunktionen verfügen, scheint es in VBScript keine zu geben. Dies ist ein Manko.
3.20. Programmargumente
Es ist möglich, ein VBScript-Programm aufzurufen, indem man ihm Parameter übergibt, wie in:
Auf diese Weise kann der Benutzer Informationen an das Programm übergeben. Wie ruft das Programm diese Informationen ab? Sehen wir uns das folgende Programm an:
Programm | Ergebnisse |
 |
Kommentare
- WScript.Arguments ist die Sammlung der an das Skript übergebenen Argumente
- Eine C-Sammlung ist ein Objekt, das
- eine „count“-Eigenschaft, die die Anzahl der Elemente in der Sammlung angibt
- eine Methode C(i), die das i-te Element der Sammlung zurückgibt
3.21. Eine erste Anwendung: STEUERN
Wir schlagen vor, ein Programm zu schreiben, das die Steuer eines Steuerzahlers berechnet. Wir betrachten den vereinfachten Fall eines Steuerzahlers, der nur sein Gehalt angeben muss:
- Die Anzahl der Anteile für den Arbeitnehmer wird wie folgt berechnet: nbParts = nbEnfants / 2 + 1, wenn der Arbeitnehmer unverheiratet ist, oder nbEnfants / 2 + 2, wenn der Arbeitnehmer verheiratet ist, wobei nbEnfants die Anzahl der Kinder ist.
- Wir berechnen sein zu versteuerndes Einkommen R = 0,72 * S, wobei S sein Jahresgehalt ist
- Wir berechnen den Familienkoeffizienten Q = R / N
Wir berechnen ihre Steuer I auf der Grundlage der folgenden Daten
12620,0 | 0 | 0 |
13.190 | 0,05 | 631 |
15.640 | 0,1 | 1.290,5 |
24.740 | 0,15 | 2.072,5 |
31.810 | 0,2 | 3.309,5 |
39.970 | 0,25 | 4.900 |
48.360 | 0,3 | 6.898,5 |
55.790 | 0,35 | 9.316,5 |
92.970 | 0,4 | 12.106 |
127.860 | 0,45 | 16.754,5 |
151.250 | 0,50 | 23.147,5 |
172.040 | 0,55 | 30.710 |
195.000 | 0,60 | 39.312 |
0 | 0,65 | 49.062 |
Jede Zeile enthält 3 Felder. Um die Steuer I zu berechnen, suchen wir nach der ersten Zeile, in der QF <= Feld1 ist. Wenn beispielsweise QF = 30000 ist, finden wir die Zeile
Steuer I ist dann gleich 0,15*R – 2072,5*nbParts. Wenn QF so ist, dass die Bedingung QF<=field1 nie erfüllt ist, werden die Koeffizienten aus der letzten Zeile verwendet. Hier:
was die Steuer I = 0,65*R - 49062*nbParts ergibt.
Das Programm lautet wie folgt:
Programm
' calculating a taxpayer's tax liability
' the program must be called with three parameters: married children salary
' married: character Y if married, N if unmarried
' children: number of children
' salary: annual salary without cents
' no verification of data validity is performed, but we do
' check that there are three of them
' mandatory variable declaration
Option Explicit
' we check that there are 3 arguments
Dim nbArguments
nbArguments=wscript.arguments.count
If nbArguments<>3 Then
wscript.echo "Syntaxe : pg marié enfants salaire"
wscript.echo "marié : caractère O si marié, N si non marié"
wscript.echo "enfants : nombre d'enfants"
wscript.echo "salaire : salaire annuel sans les centimes"
' stop with error code 1
wscript.quit 1
End If
' retrieve arguments without checking their validity
Dim marie, enfants, salaire
If wscript.arguments(0) = "O" Or wscript.arguments(0)="o" Then
marie=true
Else
marie=false
End If
' children is an integer
enfants=cint(wscript.arguments(1))
' salary is a long integer
salaire=clng(wscript.arguments(2))
' we define the data needed to calculate the tax in 3 tables
Dim limites, coeffn, coeffr
limites=array(12620,13190,15640,24740,31810,39970,48360, _
55790,92970,127860,151250,172040,195000,0)
coeffr=array(0,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45, _
0.5,0.55,0.6,0.65)
coeffn=array(0,631,1290.5,2072.5,3309.5,4900,6898.5,9316.5, _
12106,16754.5,23147.5,30710,39312,49062)
' the number of shares is calculated
Dim nbParts
If marie=true Then
nbParts=(enfants/2)+2
Else
nbParts=(enfants/2)+1
End If
If enfants>=3 Then nbParts=nbParts+0.5
' we calculate the family quotient and taxable income
Dim revenu, qf
revenu=0.72*salaire
qf=revenu/nbParts
' tax calculation
Dim i, impot
i=0
Do While i<ubound(limites) And qf>limites(i)
i=i+1
Loop
impot=int(revenu*coeffr(i)-nbParts*coeffn(i))
' the result is displayed
wscript.echo "impôt=" & impot
' leave without error
wscript.quit 0
Ergebnisse
|
Anmerkungen:
- Das Programm nutzt die zuvor behandelten Themen (Variablendeklarationen, Argumente, Typkonvertierungen, Prüfungen, Schleifen, Array in einer Variablen)
- Es überprüft nicht die Gültigkeit der Daten, was in einem echten Programm ungewöhnlich wäre
- Nur die while-Schleife stellt eine Herausforderung dar. Es versucht, den Index i des Arrays „limits“ zu ermitteln, für den limits(i) > qf gilt, und zwar für i < ubound(limits) (d. h. hier i < 13), da das letzte Element des Arrays „limits“ nicht von Bedeutung ist. Es wurde ausschließlich hinzugefügt, damit die Prüfung [Do While i<ubound(limits) And qf>limits(i)] für i=13 durchgeführt werden kann. Der Test lautet dann 13<13 und qf>limits(13), und daher muss (in VBScript) limits(13) existieren. Beim Verlassen der while-Schleife wird der zuletzt berechnete Wert von i zur Berechnung der Steuer verwendet: [tax = Int(income * coeffr(i) - nbParts * coeffn(i))].