5. Funktionen und Prozeduren

5.1. Die vordefinierten Funktionen von VBScript

Die Vielseitigkeit einer Sprache hängt weitgehend von ihrer Funktionsbibliothek ab, wobei diese Funktionen in Objekten unter dem Namen „Methoden“ gekapselt sein können. In dieser Hinsicht kann man VBScript als eher dürftig bezeichnen.

Die folgende Tabelle listet die Funktionen von VBScript außerhalb von Objekten auf. Wir werden nicht näher darauf eingehen. Ihr Name gibt in der Regel Aufschluss über ihre Funktion. Der Leser sollte die Dokumentation konsultieren, um Einzelheiten zu einer bestimmten Funktion zu erfahren.

Abs	Array	Asc	Atn
CBool	CByte	CCur	CDate
CDbl	Chr	CInt	CLng
Umrechnungen	Cos	CreateObject	CSng
Datum	DateAdd	DateDiff	DatePart
DateSerial	DateValue	Tag	Abgeleitete Mathematik
Bewertung	Exp	Filter	FormatCurrency
FormatDateTime	FormatNumber	FormatPercent	GetLocale
GetObject	GetRef	Hex	Stunde
InputBox	InStr	InStrRev	Int, Fixs
IsArray	IsDate	IsEmpty	IsNull
IsNumeric	IsObject	Join	LBound
LCase	Links	Len	LoadPicture
Log	LTrim; RTrim; und Trims	Mathematik	Mitte
Minute	Monat	MonthName	MsgBox
Jetzt	Okt	Ersetzen	RGB
Rechts	Rnd	Rund	ScriptEngine
ScriptEngineBuildVersion	ScriptEngineMajorVersion	ScriptEngineMinorVersion	Zweiter
SetLocale	Unterschrift	Sin	Leerzeichen
Split	Sqr	StrComp	String
Tan	Zeit	Timer	TimeSerial
TimeValue	TypeName	UBound	UCase
VarType	Wochentag	WeekdayName	Jahr

5.2. Modulare Programmierung

Die programmierte Lösung eines Problems zu beschreiben bedeutet, die Abfolge elementarer Aktionen zu beschreiben, die vom Computer ausgeführt werden können und das Problem lösen. Je nach Programmiersprache sind diese elementaren Operationen mehr oder weniger komplex. Dazu gehören beispielsweise:

• das Einlesen von Daten von der Tastatur oder von der Festplatte
• Daten auf dem Bildschirm, auf einem Drucker, auf der Festplatte usw. ausgeben
• Ausdrücke berechnen
• sich in einer Datei bewegen
• ...

Die Beschreibung eines komplexen Problems kann mehrere Tausend dieser elementaren Anweisungen und mehr erfordern. Für den menschlichen Verstand ist es dann sehr schwierig, sich einen Gesamtüberblick über ein Programm zu verschaffen. Angesichts dieser Schwierigkeit, das Problem in seiner Gesamtheit zu erfassen, zerlegt man es daher in Teilprobleme, die einfacher zu lösen sind. Betrachten wir das folgende Problem: Eine Liste von numerischen Werten, die über die Tastatur eingegeben wurden, sortieren und die sortierte Liste auf dem Bildschirm anzeigen.

Zunächst lässt sich die Lösung wie folgt beschreiben:

  début
        lire les valeurs et les mettre dans un tableau T
        trier le tableau T
        écrire les valeurs triées du tableau T à l'écran
  fin

Das Problem wurde in drei Teilprobleme zerlegt, die einfacher zu lösen sind. Die algorithmische Darstellung ist oft formalisierter als die vorherige, und der Algorithmus lässt sich eher wie folgt schreiben:

   début
         lire_tableau(T)
         trier_tableau(T)
         écrire_tableau(T)
   fin

wobei T ein Array darstellt. Die Operationen

    . lire_tableau(T)
    . trier_tableau(T)
    . écrire_tableau(T)

sind nicht-elementare Operationen, die ihrerseits durch elementare Operationen beschrieben werden müssen. Dies geschieht in sogenannten Modulen. Die Daten T werden als Parameter des Moduls bezeichnet. Es handelt sich dabei um Informationen, die das aufrufende Programm an das aufgerufene Modul übergibt (Eingabeparameter) oder vom aufgerufenen Modul erhält (Ausgabeparameter). Die Parameter eines Moduls sind also die Informationen, die zwischen dem aufrufenden Programm und dem aufgerufenen Modul ausgetauscht werden.

Modul lire_tableau(T)
Modul trier_tableau(T)
Modul écrire_tableau(T)

Das Modul lire_tableau(T) könnte wie folgt beschrieben werden:

début
    écrire "Tapez la suite de valeurs à trier sous la forme val1 val2 ... : "
    lire valeurs
    construire tableau T à partir de la chaîne valeurs
fin

Hier haben wir das Modul lire_tableau ausführlich beschrieben. Tatsächlich lassen sich die drei erforderlichen Aktionen unmittelbar in VBScript umsetzen. Für die letzte Aktion ist die Verwendung der Funktion „Split“ erforderlich. Würde VBScript diese Funktion nicht bieten, müsste Aktion 3 ihrerseits in elementare Aktionen zerlegt werden, für die es eine direkte Entsprechung in VBScript gibt.

Das Modul écrire_tableau(T) könnte wie folgt beschrieben werden:

début
    construire chaîne texte "valeur1,valeur2,...." à partir du tableau T
    écrire texte
fin

Das Modul écrire_tableau(T) könnte wie folgt beschrieben werden (unter der Annahme, dass die Indizes der Elemente von T bei 0 beginnen):

début
      N<-- indice dernier élément du tableau T
      pour IFIN variant de N à 1
      faire
           //: Der Index IMAX des größten Elements von T wird ermittelt
           // IFIN ist der Index des letzten Elements von T

          chercher_max(T, IFIN, IMAX) 

           // Das größte Element von T wird mit dem letzten Element von T vertauscht

          échanger (T, IMAX, IFIN)

      finfaire
FIN

Hier verwendet der Algorithmus erneut nicht-elementare Aktionen:

 . chercher_max(T, IFIN, IMAX)
 . échanger(T, IMAX, IFIN)

chercher_max(T, IFIN, IMAX) gibt den Index IMAX des größten Elements des Arrays T zurück, dessen Index des letzten Elements IFIN ist.

tauschen(T, IMAX, IFIN) tauscht zwei Elemente des Arrays T aus, nämlich diejenigen mit den Indizes IMAX und IFIN.

Daher müssen die neuen nicht-elementaren Operationen beschrieben werden.

Modul chercher_max(A, IFIN, IMAX)	début IMAX<--0 pour i variant de 1 à IFIN faire si T[i]>T[IMAX] alors début IMAX<--i fin finfaire fin
Modul „Austauschen“ (T IMAX, IFIN)	début temp<----T[IMAX] T[IMAX]<---T[IFIN] T[IFIN]<---temp fin

Das ursprüngliche Problem wurde mithilfe elementarer VBScript-Operationen vollständig beschrieben und kann nun in diese Sprache übersetzt werden. Es ist zu beachten, dass sich die elementaren Operationen von Sprache zu Sprache unterscheiden können und dass daher bei der Analyse eines Problems zu einem bestimmten Zeitpunkt die verwendete Programmiersprache berücksichtigt werden muss. Ein Objekt, das in einer Sprache existiert, existiert möglicherweise in einer anderen nicht und verändert somit den verwendeten Algorithmus. Wenn eine Sprache also über eine Sortierfunktion verfügt, wäre es hier unsinnig, diese nicht zu nutzen.

Das hier angewandte Prinzip ist das sogenannte Top-Down-Verfahren. Stellt man das Grundgerüst der Lösung dar, ergibt sich Folgendes:

Wir haben eine Baumstruktur.

5.3. Die VBScript-Funktionen und -Prozeduren

Sobald die modulare Analyse abgeschlossen ist, kann der Programmierer die Module seines Algorithmus in VBScript-Funktionen wie fonctions oder procédures umsetzen. Sowohl fonctions als auch procédures akzeptieren Eingabe- und Ausgabeparameter, doch fonction liefert ein Ergebnis, das die Verwendung in Ausdrücken ermöglicht, während procédure kein solches Ergebnis liefert.

5.3.1. Deklaration von VBScript-Funktionen und -Prozeduren

Die Deklaration einer VBScript-Prozedur lautet wie folgt

sub nomProcédure([Byref/Byval] param1, [Byref/Byval] param2, ...)
    instructions
end sub

und die einer Funktion

function nomFonction([Byref/Byval] param1, [Byref/Byval] param2, ...)
    instructions
end sub

Um ihr Ergebnis auszugeben, muss die Funktion eine Anweisung enthalten, mit der das Ergebnis einer Variablen zugewiesen wird, die den Namen der Funktion trägt:

Funktionsname = Ergebnis

Die Ausführung einer Funktion oder Prozedur wird auf zwei Arten beendet:

1. beim Erreichen der Anweisung zum Ende der Funktion (end function) oder der Prozedur (end sub)
2. beim Erreichen der Anweisung zum Verlassen der Funktion (exit function) oder der Prozedur (exit sub)

Bei einer Funktion ist zu beachten, dass das Ergebnis einer Variablen mit dem Namen der Funktion zugewiesen worden sein muss, bevor diese mit einem „end function“ oder „exit function“ beendet wird.

5.3.2. Möglichkeiten der Parameterübergabe bei einer Funktion oder Prozedur

Bei der Deklaration der Ein- und Ausgabeparameter einer Funktion oder Prozedur wird die Art (byRef, byVal) der Parameterübergabe vom aufrufenden Programm an das aufgerufene Programm festgelegt:

sub nomProcédure([Byref/Byval] param1, [Byref/Byval] param2, ...)

function nomFonction([Byref/Byval] param1, [Byref/Byval] param2, ...)

Wenn der Übertragungsmodus byRef oder byVal nicht angegeben ist, wird der Modus byRef verwendet.

Effektive Parameter, formale Parameter

Angenommen, eine VBScript-Funktion ist wie folgt definiert:

function nomFonction([Byref/Byval] paramForm1, [Byref/Byval] paramForm2, ...)
...
end function

Die in der Definition der Funktion oder Prozedur verwendeten Parameter parmamFormi werden als formale Parameter bezeichnet. Die vorstehende Funktion kann vom Hauptprogramm oder einem anderen Modul aus mit einer Anweisung wie der folgenden aufgerufen werden:

résultat=nomFonction(paramEff1, paramEff2, ...)

Die Parameter parmamEffi, die beim Aufruf der Funktion oder Prozedur verwendet werden, werden als effektive Parameter bezeichnet. Wenn die Ausführung der Funktion nomFonction beginnt, erhalten die formalen Parameter die Werte der entsprechenden effektiven Parameter. Die Schlüsselwörter byRef und byVal legen den Übertragungsmodus dieser Werte fest.

Wertübertragungsmodus (byVal)

Wenn ein formaler Parameter diesen Übertragungsmodus angibt, handelt es sich bei dem formalen und dem effektiven Parameter um zwei verschiedene Variablen. Der Wert des effektiven Parameters wird vor der Ausführung der Funktion oder Prozedur in den formalen Parameter kopiert. Wenn diese während ihrer Ausführung den Wert des formalen Parameters ändert, hat dies keinerlei Auswirkungen auf den Wert des entsprechenden effektiven Parameters. Diese Übertragungsart eignet sich gut für Eingabeparameter der Funktion oder Prozedur.

Übertragungsmodus per Referenz (byRef)

Diese Übertragungsart ist die Standardart, wenn keine Parameterübertragungsart angegeben ist. Wenn ein formaler Parameter diese Übertragungsart angibt, sind der formale Parameter und der entsprechende effektive Parameter ein und dieselbe Variable. Wenn die Funktion also den formalen Parameter ändert, wird auch der effektive Parameter geändert. Diese Übertragungsart eignet sich gut für:

• für Ausgabeparameter, da deren Wert an das aufrufende Programm übergeben werden muss
• für Eingabeparameter, deren Kopieren aufwendig ist, wie z. B. Arrays

Das folgende Programm zeigt Beispiele für die Parameterübergabe:

Programm

Sub proc1(byval i, ByRef j, k)
  ' i wird als Wert übergeben (byval) – der tatsächliche Parameter und der formale Parameter sind dann unterschiedlich
  ' j wird als Wert übergeben (byref) – der tatsächliche Parameter und der formale Parameter sind dann identisch
  ' Die Übergabemethode für k ist nicht angegeben. Standardmäßig erfolgt die Übergabe per Referenz
  i=i+1
  j=j+1
  k=k+1
  affiche "dans proc1",i,j,k
End Sub

 Sub affiche(byval msg, ByVal i, ByVal j, ByVal k)
  ' zeigt die Werte von i, j und k an
  wscript.echo msg & " i=" & i & " j=" & j & " k=" & k
End Sub


' ------------- Aufrufe von Funktionen und Prozeduren

' Initialisierung von i und j
  i=4:j=5 : k=6

' Überprüfung
  affiche "dans programme principal, avant l'appel à proc1 :",i,j,k

' Aufruf der Prozedur proc1
  proc1 i,j,k

' Überprüfung
  affiche "dans programme principal, après l'appel à proc1 :",i,j,k

' Ende
  wscript.quit 0

Ergebnisse

dans programme principal, avant l'appel à proc1 : i=4 j=5 k=6
dans proc1 i=5 j=6 k=7
dans programme principal, après l'appel à proc1 : i=4 j=6 k=7

Anmerkungen

• In einem VBScript-Skript gibt es keinen festgelegten Platz für Funktionen und Prozeduren. Sie können an beliebiger Stelle im Quelltext stehen. In der Regel werden sie entweder am Anfang oder am Ende zusammengefasst, und man achtet darauf, dass das Hauptprogramm einen zusammenhängenden Block bildet.

5.3.3. Syntax für den Aufruf von Funktionen und Prozeduren

Angenommen, eine Prozedur p akzeptiert formale Parameter pf1, pf2, ...

• Der Aufruf der Prozedur p erfolgt in der Form

p pe1, pe2, ...

ohne Klammern um die Parameter

• Wenn die Prozedur p keine Parameter akzeptiert, kann man wahlweise den Aufruf p oder p() sowie die Deklaration sub p oder sub p() verwenden

Sei f eine Funktion, die formale Parameter pf1, pf2, ... akzeptiert

• Der Aufruf der Funktion f erfolgt in der Form

résultat=f(pe1, pe2, ...)

Die Klammern um die Parameter sind obligatorisch. Wenn die Funktion f keine Parameter akzeptiert, kann man wahlweise den Aufruf f oder f() sowie die Deklaration function f oder function f() verwenden.

• Das Ergebnis der Funktion f kann vom aufrufenden Programm ignoriert werden. Die Funktion f wird dann als Prozedur betrachtet und folgt den Regeln für den Aufruf von Prozeduren. Man schreibt dann f pe1, pe2, ... (ohne Klammern), um die Funktion f aufzurufen.

Handelt es sich bei der Funktion oder Prozedur um eine Objektmethode, scheinen die Regeln etwas anders und uneinheitlich zu sein.

• So kann man beispielsweise MyFile.WriteLine „Dies ist ein Test.“ oder MyFile.WriteLine(„Dies ist ein Test.“) schreiben
• Aber während man wscript.echo 4 schreiben kann, kann man nicht wscript.echo(4) schreiben.

Es gelten folgende Regeln:

• Keine Klammern um die Parameter einer Prozedur oder einer als Prozedur verwendeten Funktion
• Klammern um die Parameter einer Funktion

5.3.4. Einige Beispiele für Funktionen

Im Folgenden finden Sie einige Beispiele für die Definition und Verwendung von Funktionen:

Programm

 Function plusgrandque(byval i, ByVal j)
  ' gibt „wahr“ zurück, wenn i > j, andernfalls „falsch“

  ' Datenüberprüfung
  If isnumeric(i) And isnumeric(j) Then
    If i>j Then
      plusgrandque=true
    Else
      plusgrandque=false
    End If
  Else
    wscript.echo "Arguments (" & i & "," & j & ") erronés"
    plusgrandque=false
  End If
  Exit Function
End Function

 Function rendUnTableau(byval n)
  ' gibt ein Array mit n Elementen zurück
  tableau=array()
  ' Überprüfung der Gültigkeit des Parameters n
  If isnumeric(n) And n>=1 Then
    ReDim Preserve tableau(n)
    For i= 0 To n-1
      tableau(i)=i
    Next
  Else
    wscript.echo "Argument [" & n & "] erroné"
  End If
  ' Das Ergebnis wird zurückgegeben
  rendUnTableau=tableau
End Function

 Function argumentsVariables(byref arguments)
  ' arguments ist ein Array von Zahlen, deren Summe zurückgegeben wird
  somme=0
  For i=0 To ubound(arguments)
    somme=somme+arguments(i)
  Next
  argumentsVariables=somme
End Function

  ' zwei Funktionen ohne Parameter, die auf zwei verschiedene Arten deklariert wurden
  Function sansParametres1
    sansParametres=4
  End Function

  Function sansParametres2()
    sansParametres=4
  End Function


' ------------- Aufrufe von Funktionen und Prozeduren

' Aufrufe der Funktion „plusgrandque“
  wscript.echo "plusgrandque(10,6)=" & plusgrandque(10,6)
  wscript.echo "plusgrandque(6,10)=" & plusgrandque(6,10)
  wscript.echo "plusgrandque(6,6)=" & plusgrandque(6,6)
  wscript.echo "plusgrandque(6,'a')=" & plusgrandque(6,"a")

' Aufrufe der Funktion rendUnTableau
  monTableau=rendUnTableau(10)
  For i=0 To ubound(monTableau)
    wscript.echo monTableau(i)
  Next
  monTableau=rendUnTableau(-6)
  For i=0 To ubound(monTableau)
    wscript.echo monTableau(i)
  Next

' Aufrufe der Funktion „argumentsVariables“
  wscript.echo "somme=" & argumentsVariables(array(-1,2,7,8))
  wscript.echo "somme=" & argumentsVariables(array(-1,10,12))

' Aufrufe von Funktionen ohne Parameter
  res=sansParametres1
  res=sansParametres1()
  sansParametres1
  sansParametres1()

  res=sansParametres2
  res=sansParametres2()
  sansParametres2
  sansParametres2()

' Ende
  wscript.quit 0

Ergebnisse

plusgrandque(10,6)=Vrai
plusgrandque(6,10)=Faux
plusgrandque(6,6)=Faux
Arguments (6,a) erronés
plusgrandque(6,'a')=Faux
0
1
2
3
4
5
6
7
8
9

Argument [-6] erroné
somme=16
somme=21
somme=10

Anmerkungen

• Die Funktion rendUnTableau zeigt, dass eine Funktion mehrere Ergebnisse und nicht nur ein einziges zurückgeben kann. Dazu muss sie diese lediglich in eine Array-Variable speichern und diese Variable als Ergebnis zurückgeben.
• Umgekehrt zeigt die Funktion argumentsVariables, dass man eine Funktion schreiben kann, die eine variable Anzahl von Argumenten akzeptiert. Auch hier reicht es aus, diese in eine Array-Variable zu packen und diese Variable als Parameter der Funktion zu verwenden.

5.3.5. Ausgabeparameter oder Ergebnis einer Funktion

Nehmen wir an, die Analyse einer Anwendung habe ergeben, dass ein Modul M mit Eingabeparametern Ei und Ausgabeparametern Sj erforderlich ist. Zur Erinnerung: Eingabeparameter sind Informationen, die das aufrufende Programm an das aufgerufene Programm übergibt, und umgekehrt sind Ausgabeparameter Informationen, die das aufgerufene Programm an das aufrufende Programm übergibt. In VBScript gibt es mehrere Lösungen für Ausgabeparameter:

• Gibt es nur einen einzigen Ausgabeparameter, kann man diesen zum Ergebnis einer Funktion machen. Es gibt dann keinen Ausgabeparameter mehr, sondern lediglich ein Funktionsergebnis.
• Gibt es n Ausgabeparameter, kann einer davon als Funktionsergebnis dienen, während die übrigen n-1 weiterhin Ausgabeparameter bleiben. Man kann auch keine Funktion, sondern eine Prozedur mit n Ausgabeparametern verwenden. Eine weitere Möglichkeit ist der Einsatz einer Funktion, die ein Array zurückgibt, in das die n Werte eingefügt wurden, die an das aufrufende Programm zurückgegeben werden sollen. Man beachte, dass das aufgerufene Programm seine Ergebnisse durch Wertkopie an das aufrufende Programm zurückgibt. Diese Wertkopie entfällt bei Ausgabeparametern, die per Referenz übergeben werden. Bei dieser letzten Lösung ergibt sich somit eine Zeitersparnis.

5.4. Das VBScript-Programm zum Sortieren von Werten

Wir hatten die Diskussion über modulare Programmierung mit der algorithmischen Untersuchung einer Sortierung von über die Tastatur eingegebenen numerischen Werten begonnen. Hier ist die Übersetzung VBScript, die daraus erstellt werden könnte:

Programm

' Hauptprogramm
Option Explicit

Dim T        ' le tableau de valeurs à trier

' Werte auslesen
T=lire_tableau

' Sortieren der Werte
trier_tableau T

' Anzeige der sortierten Werte
ecrire_tableau T

' Ende
wscript.quit 0

' ---------- Funktionen & Prozeduren

' -------- lire_tableau
Function lire_tableau
     ' die Werte werden abgefragt
    wscript.stdout.write "Tapez les valeurs à trier sous la forme val1 val2  ... valn : "
     ' sie werden gelesen
    Dim valeurs
    valeurs=wscript.stdin.readLine
     ' sie werden in ein Array gespeichert
    lire_tableau=split(valeurs," ")
End Function

' -------- ecrire_tableau
Sub ecrire_tableau(byref T)
     ' gibt den Inhalt des Arrays T aus
    wscript.echo join(T," ")
End Sub

' -------- trier_tableau
Sub trier_tableau (byref T)
     ' sortiert das Array T in aufsteigender Reihenfolge

     ' Es wird der Index imax des Arrays T gesucht[0..ifin]
     ' um T[imax] mit dem letzten Element des Arrays T[0..ifin] zu vertauschen
     ' Anschließend beginnt man erneut mit einem Array, das ein Element weniger enthält

    Dim ifin, imax, temp
    For ifin=ubound(T) To 1 Step -1
         ' man sucht den Index imax des Arrays T[0..ifin]
        imax=chercher_max(T,ifin)
         ' Man tauscht das maximale Element mit dem letzten Element des Arrays T[0..ifin] aus
        temp=T(ifin):T(ifin)=T(imax):T(imax)=temp
    Next
End Sub

' -------- chercher_max
Function chercher_max(byRef T, ByVal ifin)
     ' Wir suchen den Index imax des Arrays T[0..ifin]
    Dim i, imax
    imax=0
    For i=1 To ifin
        If cdbl(T(i))>cdbl(T(imax)) Then imax=i
    Next

     ' Das Ergebnis wird zurückgegeben
    chercher_max=imax
End Function

Ergebnisse

Tapez les valeurs à trier sous la forme val1 val2  ... valn : 10 9 8 7 6 1
1 6 7 8 9 10

Anmerkungen:

• Das Modul échanger, das im ursprünglichen Algorithmus identifiziert worden war, wurde hier nicht als VBScript-Modul umgesetzt, da es als zu einfach erachtet wurde, um Gegenstand eines eigenen Moduls zu sein.

5.5. Das Programm IMPOTS in modularer Form

Wir greifen das Programm zur Steuerberechnung wieder auf, das diesmal in modularer Form geschrieben wurde

Programm

' Berechnung der Steuer eines Steuerpflichtigen
' Das Programm muss mit drei Parametern aufgerufen werden: verheiratet, Kinder, Gehalt
' verheiratet: Zeichen O, wenn verheiratet, N, wenn unverheiratet
' Kinder: Anzahl der Kinder
' Gehalt: Jahresgehalt ohne Cent

' obligatorische Variablendeklaration
Option Explicit
Dim erreur

' Die Argumente werden abgerufen und auf ihre Gültigkeit überprüft
Dim marie, enfants, salaire
erreur=getArguments(marie,enfants,salaire)
' Fehler?
If erreur(0)<>0 Then wscript.echo erreur(1) : wscript.quit erreur(0)

' Die für die Steuerberechnung erforderlichen Daten werden abgerufen
Dim limites, coeffR, coeffN
getData limites,coeffR,coeffN

' Das Ergebnis wird angezeigt
wscript.echo "impôt=" & calculerImpot(marie,enfants,salaire,limites,coeffR,coeffN)

' Das Programm wird ohne Fehler beendet
wscript.quit 0

' ------------ Funktionen und Prozeduren

' ----------- getArguments
Function getArguments(byref marie, ByRef enfants, ByRef salaire)
     ' muss drei Werte abrufen, die als Argumente an das Hauptprogramm übergeben wurden
     ' Ein Argument wird ohne Leerzeichen davor und dahinter an das Programm übergeben
     ' Zur Überprüfung der Gültigkeit der Daten werden reguläre Ausdrücke verwendet

     ' gibt eine Fehler-Array-Variant mit zwei Werten zurück
     ' Fehler(0): Fehlercode, 0, wenn kein Fehler vorliegt
     ' Fehler(1): Fehlermeldung bei einem Fehler, andernfalls die leere Zeichenkette

    Dim syntaxe
    syntaxe= _
    "Syntaxe : pg marié enfants salaire" & vbCRLF & _
    "marié : caractère O si marié, N si non marié" & vbCRLF & _
    "enfants : nombre d'enfants (entier >=0)" & vbCRLF & _
    "salaire : salaire annuel sans les centimes (entier >=0)"

     ' Es wird überprüft, ob 3 Argumente vorhanden sind
    Dim nbArguments
    nbArguments=wscript.arguments.count
    If nbArguments<>3 Then
         ' Fehlermeldung
        getArguments= array(1,syntaxe & vbCRLF & vbCRLF & "erreur : nombre d'arguments incorrect")
         ' Ende
        Exit Function
    End If

    Dim modele, correspondances
    Set modele=new regexp

     ' Der Familienstand muss zu den zulässigen Zeichen gehören oOnN
    modele.pattern="^[oOnN]$"
    Set correspondances=modele.execute(wscript.arguments(0))
    If correspondances.count=0 Then
         ' Fehlermeldung
        getArguments=array(2,syntaxe & vbCRLF & vbCRLF & "erreur : argument marie incorrect")
         ' Beenden
        Exit Function
    End If
     ' Wert abrufen
    If lcase(wscript.arguments(0)) = "o"Then
        marie=true
    Else
        marie=false
    End If

     ' „Kinder“ muss eine ganze Zahl >= 0 sein
    modele.pattern="^\d{1,2}$"
    Set correspondances=modele.execute(wscript.arguments(1))
    If correspondances.count=0 Then
         ' Fehler
        getArguments= array(3,syntaxe & vbCRLF & vbCRLF & "erreur : argument enfants incorrect")
         ' Beenden
        Exit Function
    End If
     ' Wert wird abgerufen
    enfants=cint(wscript.arguments(1))

     ' „Gehalt“ muss eine ganze Zahl >= 0 sein
    modele.pattern="^\d{1,9}$"
    Set correspondances=modele.execute(wscript.arguments(2))
    If correspondances.count=0 Then
         ' Fehler
        getArguments= array(4,syntaxe & vbCRLF & vbCRLF & "erreur : argument salaire incorrect")
         ' Beenden
        Exit Function
    End If
     ' Wert wird abgerufen
    salaire=clng(wscript.arguments(2))

     ' Der Vorgang wurde ohne Fehler abgeschlossen
    getArguments=array(0,"")
End Function

' ----------- getData
Sub getData(byref limites, ByRef coeffR, ByRef coeffN)
     ' Wir legen die für die Steuerberechnung erforderlichen Daten in drei Tabellen fest
    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)
End Sub

' ----------- calculerImpot
Function calculerImpot(byval marie,ByVal enfants,ByVal salaire, ByRef limites, ByRef coeffR, ByRef coeffN)

     ' Hier wird die Anzahl der Anteile berechnet
    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

     ' Es werden der Familienquotient und das zu versteuernde Einkommen berechnet
    Dim revenu, qf
    revenu=0.72*salaire
    qf=revenu/nbParts

     ' Berechnung der Steuer
    Dim i, impot
    i=0
    Do While i<ubound(limites) And qf>limites(i)
        i=i+1
    Loop
    calculerImpot=int(revenu*coeffr(i)-nbParts*coeffn(i))
End Function

Kommentare

• Mit der Funktion getArguments lassen sich die Daten (Ehepartner, Kinder, Gehalt) des Steuerpflichtigen abrufen. Hier werden sie als Argumente an das VBScript-Programm übergeben. Sollte sich dies ändern, beispielsweise wenn diese Argumente aus einer grafischen Benutzeroberfläche stammen würden, müsste nur die Prozedur getArguments neu geschrieben werden, nicht jedoch die anderen.
• Die Funktion getArguments kann Fehler bei den Argumenten erkennen. In diesem Fall hätte man beschließen können, die Ausführung des Programms in der Funktion getArguments mittels einer Anweisung wscript.quit zu beenden. Dies darf jedoch niemals in einer Funktion oder Prozedur erfolgen. Wenn eine Funktion oder Prozedur einen Fehler feststellt, muss sie diesen auf die eine oder andere Weise dem aufrufenden Programm melden. Die Entscheidung, ob die Ausführung abgebrochen wird oder nicht, liegt beim aufrufenden Programm, nicht bei der Prozedur. In unserem Beispiel könnte das aufrufende Programm beschließen, den Benutzer aufzufordern, die fehlerhafte Eingabe über die Tastatur erneut einzugeben, anstatt die Ausführung abzubrechen.
• Hier gibt die Funktion getArguments ein Array-Variant zurück, dessen erstes Element ein Fehlercode ist (0, wenn kein Fehler vorliegt) und dessen zweites Element eine Fehlermeldung ist, falls ein Fehler aufgetreten ist. Durch Überprüfen des erhaltenen Ergebnisses kann das aufrufende Programm feststellen, ob ein Fehler aufgetreten ist oder nicht.
• Die Prozedur getData ermöglicht es, die für die Steuerberechnung erforderlichen Daten abzurufen. Hier werden sie direkt in der Prozedur getData definiert. Sollten diese Daten aus einer anderen Quelle stammen, beispielsweise aus einer Datei oder einer Datenbank, müsste lediglich die Prozedur getData umgeschrieben werden, nicht jedoch die anderen.
• Die Funktion calculerImpot ermöglicht die Berechnung der Steuer, sobald alle Daten vorliegen, unabhängig davon, auf welche Weise sie beschafft wurden.
• Es ist daher zu beachten, dass eine modulare Programmierung die (Wieder-)Verwendung bestimmter Module in verschiedenen Kontexten ermöglicht. Dieses Konzept wurde in den letzten zwanzig Jahren im Rahmen der objektorientierten Programmierung stark weiterentwickelt.