5. Funktionen und Prozeduren

5.1. Vordefinierte Funktionen von VBScript

Die Vielseitigkeit einer Sprache hängt weitgehend von ihrer Funktionsbibliothek ab, da diese Funktionen unter dem Namen von Methoden in Objekten gekapselt werden können. In dieser Hinsicht kann VBScript als eher begrenzt angesehen werden.

Die folgende Tabelle listet VBScript-Funktionen außerhalb von Objekten auf. Wir werden nicht näher auf sie eingehen. Ihre Namen geben im Allgemeinen ihren Zweck an. Leser sollten die Dokumentation konsultieren, um Details zu einer bestimmten Funktion zu erhalten.

Abs	Array	Asc	Atn
CBool	CByte	CCur	CDate
CDbl	Chr	CInt	CLng
Konvertierungen	Cos	CreateObject	CSng
Date	DateAdd	DateDiff	DatePart
Datumsserie	Datumswert	Tag	Abgeleitete mathematische Funktionen
Eval	Exp	Filter	Währung Format
FormatDateTime	Zahlenformat	Prozentformat	GetLocale
GetObject	GetRef	Hex	Stunde
Eingabefeld	InStr	InStrRev	Int, Fixs
IsArray	IsDate	IsEmpty	IstNull
IstZahl	IstObjekt	Join	LBound
LCase	Links	Len	Bild laden
Log	LTrim; RTrim; und Trims	Mathematik	Mitte
Minute	Monat	Monatsname	MsgBox
Jetzt	Okt	Ersetzen	RGB
Rechts	Rnd	Rund	ScriptEngine
ScriptEngineBuildVersion	ScriptEngineMajorVersion	ScriptEngineMinorVersion	Sekunde
SetLocale	Sgn	Sünde	Leerzeichen
Teilen	Quadrat	StrComp	String
Tan	Zeit	Timer	TimeSerial
Zeitwert	Typname	UBound	UCase
VarType	Wochentag	Wochentagsname	Jahr

5.2. Modulare Programmierung

Die programmierte Lösung eines Problems zu beschreiben bedeutet, die Abfolge von Grundoperationen zu beschreiben, die vom Computer ausgeführt werden können und zur Lösung des Problems führen. Je nach Programmiersprache variiert die Komplexität dieser Grundoperationen. Beispiele hierfür sind:

• Daten von der Tastatur oder einer Festplatte lesen
• Schreiben von Daten auf den Bildschirm, einen Drucker, eine Festplatte usw.
• Berechnung von Ausdrücken
• Navigieren durch eine Datei
• ...

Die Beschreibung eines komplexen Problems kann mehrere tausend dieser grundlegenden Anweisungen oder mehr erfordern. Daher ist es für den menschlichen Verstand sehr schwierig, den Gesamtüberblick über ein Programm zu behalten. Angesichts dieser Schwierigkeit, das Problem als Ganzes zu erfassen, zerlegen wir es in Teilprobleme, die leichter zu lösen sind. Betrachten Sie das folgende Problem: Sortieren Sie eine Liste von Zahlenwerten, die über die Tastatur eingegeben wurden, und zeigen Sie die sortierte Liste auf dem Bildschirm an.

Wir können die Lösung zunächst in folgender Form 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

Wir haben das Problem in drei Teilprobleme zerlegt, die leichter zu lösen sind. Die algorithmische Notation ist oft formalisierter als die vorherige, und der Algorithmus würde wie folgt geschrieben werden:

   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 wiederum durch elementare Operationen beschrieben werden müssen. Dies geschieht in sogenannten Modulen. Die Daten T werden als Modulparameter 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 somit die Informationen, die zwischen dem aufrufenden Programm und dem aufgerufenen Modul ausgetauscht werden.

Modul read_array(T)
Modul sort_array(T)
Modul read_array(T)

Das Modul read_array(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

Damit haben wir das Modul „read_array“ ausreichend beschrieben. Tatsächlich lassen sich die drei erforderlichen Schritte direkt in VBScript umsetzen. Für den letzten Schritt ist die Verwendung der Funktion „Split“ erforderlich. Hätte VBScript diese Funktion nicht, müsste Schritt 3 wiederum in einzelne Schritte zerlegt werden, die eine direkte Entsprechung in VBScript haben.

Das Modul „write_array(T)“ könnte wie folgt beschrieben werden:

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

Das Modul write_array(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
          //on recherche l'indice IMAX du plus gd élément de T
          // IFIN est l'indice du dernier élément de T

          chercher_max(T, IFIN, IMAX) 

          // on échange l'élément le plus grand de T avec le dernier élément de T

          échanger (T, IMAX, IFIN)

      finfaire
FIN

Auch hier verwendet der Algorithmus wieder nicht-elementare Aktionen:

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

find_max(T, IFIN, IMAX) gibt den Index IMAX des größten Elements im Array T zurück, dessen letztes Element den Index IFIN hat.

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

Wir müssen daher die neuen nicht-elementaren Operationen beschreiben.

Modul find_max(A, IFIN, IMAX)	begin IMAX<--0 für i von 1 bis IFIN dann wenn T[i] > T[IMAX], dann start IMAX<--i Ende finfaire Ende
Austauschmodul(T IMAX, IFIN)	start temp<----T[IMAX] T[IMAX]<---T[IFIN] T[IFIN]<---temp Ende

Das ursprüngliche Problem wurde unter Verwendung grundlegender VBScript-Operationen vollständig beschrieben und kann daher nun in diese Sprache übersetzt werden. Beachten Sie, dass sich grundlegende Operationen von Sprache zu Sprache unterscheiden können und daher bei der Analyse eines Problems irgendwann die verwendete Programmiersprache berücksichtigt werden muss. Ein Objekt, das in einer Sprache existiert, existiert möglicherweise in einer anderen nicht, wodurch sich der verwendete Algorithmus ändert. Wenn eine Sprache also über eine Sortierfunktion verfügt, wäre es absurd, diese hier nicht zu verwenden.

Das hier angewandte Prinzip ist als Top-Down-Analyse bekannt. Wenn wir den Rahmen der Lösung skizzieren, ergibt sich Folgendes:

Wir haben eine Baumstruktur.

5.3. VBScript-Funktionen und -Prozeduren

Sobald die modulare Analyse durchgeführt wurde, kann der Programmierer die Module seines Algorithmus in VBScript-Funktionen oder -Prozeduren umsetzen. Sowohl Funktionen als auch Prozeduren akzeptieren Eingabe-/Ausgabeparameter, aber eine Funktion gibt ein Ergebnis zurück, das es ermöglicht, sie in Ausdrücken zu verwenden, während dies bei einer Prozedur nicht der Fall ist.

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 zurückzugeben, muss die Funktion eine Zuweisungsanweisung enthalten, die das Ergebnis einer Variablen mit dem gleichen Namen wie die Funktion zuweist:

Funktionsname=Ergebnis

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

1. beim Auftreffen auf die Anweisung „end function“ oder „end sub“
2. beim Auftreten der Anweisung „exit function“ oder „exit sub“

Beachten Sie bei einer Funktion, dass das Ergebnis einer Variablen mit dem Namen der Funktion zugewiesen worden sein muss, bevor die Funktion mit einer „end function“- oder „exit function“-Anweisung endet.

5.3.2. Parameterübergabemodi für eine Funktion oder Prozedur

In der Deklaration der Ein- und Ausgabeparameter einer Funktion oder Prozedur wird der Modus (byRef, byVal) der Parameterübergabe vom aufrufenden Programm an das aufgerufene Programm angegeben:

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

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

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

Tatsächliche Parameter, formale Parameter

Betrachten wir eine VBScript-Funktion, die wie folgt definiert ist

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

Die in der Definition der Funktion oder Prozedur verwendeten Parameter paramForm1 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 paramEffi, die beim Aufruf der Funktion oder Prozedur verwendet werden, werden als tatsächliche Parameter bezeichnet. Wenn die Ausführung der Funktion functionName beginnt, erhalten die formalen Parameter die Werte der entsprechenden tatsächlichen Parameter. Die Schlüsselwörter byRef und byVal legen die Art der Übergabe dieser Werte fest.

Wertübergabe (byVal)

Wenn ein formaler Parameter diesen Übergabemodus angibt, sind der formale Parameter und der tatsächliche Parameter zwei verschiedene Variablen. Der Wert des tatsächlichen Parameters wird vor der Ausführung der Funktion oder Prozedur in den formalen Parameter kopiert. Wenn die Funktion oder Prozedur den Wert des formalen Parameters während der Ausführung ändert, hat dies keinen Einfluss auf den Wert des entsprechenden tatsächlichen Parameters. Diese Übergabemethode eignet sich gut für die Eingabeparameter einer Funktion oder Prozedur.

Referenzübergabe (byRef)

Dieser Übergabemodus ist der Standard, wenn kein Parameterübergabemodus angegeben wird. Wenn ein formaler Parameter diesen Übergabemodus angibt, sind der formale Parameter und der entsprechende tatsächliche Parameter ein und dieselbe Variable. Wenn die Funktion also den formalen Parameter ändert, wird auch der tatsächliche Parameter geändert. Dieser Übergabemodus eignet sich gut für:

• Ausgabeparameter, da deren Werte an das aufrufende Programm zurückgegeben werden müssen
• 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 is passed by value (byval) - the effective parameter and the formal parameter are then different
  ' j is passed by value (byref) - the effective parameter and the formal parameter are then identical
  ' the k passage mode is not specified. The default is by reference
  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)
  ' displays the values of i and j and k
  wscript.echo msg & " i=" & i & " j=" & j & " k=" & k
End Sub
 
 
' ------------- calls to functions and procedures
 
' init i and j
  i=4:j=5 : k=6
 
' check
  affiche "dans programme principal, avant l'appel à proc1 :",i,j,k

' call proc1 procedure
  proc1 i,j,k
 
' check
  affiche "dans programme principal, après l'appel à proc1 :",i,j,k
 
' end
  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

Kommentare

• In einem VBScript-Skript gibt es keinen bestimmten Ort für Funktionen und Prozeduren. Sie können an beliebiger Stelle im Quellcode stehen. Im Allgemeinen werden sie entweder am Anfang oder am Ende gruppiert, und das Hauptprogramm ist als durchgehender Block strukturiert.

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

Sei p eine Prozedur, die formale Parameter pf1, pf2, ... akzeptiert

• Der Aufruf der Prozedur p hat die Form

p pe1, pe2, ...

ohne Klammern um die Parameter

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

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

• Die Funktion f wird in der Form

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

Klammern um die Parameter sind obligatorisch. Wenn die Funktion f keine Parameter benötigt, kann man entweder den Aufruf f oder f() und 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. Wir schreiben dann f pe1, pe2, ... (ohne Klammern), um die Funktion f aufzurufen.

Wenn die Funktion oder Prozedur eine Objektmethode ist, scheinen die Regeln etwas anders und inkonsistent zu sein.

• So können wir MyFile.WriteLine „Dies ist ein Test.“ oder MyFile.WriteLine(„Dies ist ein Test.“) schreiben
• , aber während wir wscript.echo 4 schreiben können, können wir wscript.echo(4) nicht schreiben.

Wir halten uns an die folgenden Regeln:

• keine Klammern um die Parameter einer Prozedur oder Funktion, die als Prozedur verwendet wird
• Klammern um die Parameter einer Funktion

5.3.4. Einige Beispiele für Funktionen

Nachfolgend finden Sie einige Beispiele für Funktionsdefinitionen und deren Verwendung:

Programm

 Function plusgrandque(byval i, ByVal j)
  ' returns boolean true if i>j, boolean false otherwise
 
  ' data verification
  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)
  ' makes an array of n elements
  tableau=array()
  ' check validity of parameter 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
  ' we return the result
  rendUnTableau=tableau
End Function
 
 Function argumentsVariables(byref arguments)
  ' arguments is an array of numbers whose sum is returned
  somme=0
  For i=0 To ubound(arguments)
    somme=somme+arguments(i)
  Next
  argumentsVariables=somme
End Function
 
  ' two parameter-free functions declared in 2 different ways
  Function sansParametres1
    sansParametres=4
  End Function
 
  Function sansParametres2()
    sansParametres=4
  End Function
 

' ------------- calls to functions and procedures
 
' calls function 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")
 
' calls to the rendUnTableau function
  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
 
' calls to the argumentsVariables function
  wscript.echo "somme=" & argumentsVariables(array(-1,2,7,8))
  wscript.echo "somme=" & argumentsVariables(array(-1,10,12))
 
' function calls without parameters
  res=sansParametres1
  res=sansParametres1()
  sansParametres1
  sansParametres1()
 
  res=sansParametres2
  res=sansParametres2()
  sansParametres2
  sansParametres2()
 
' end
  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

Kommentare

• Die Funktion `rendUnTableau` zeigt, dass eine Funktion mehrere Ergebnisse statt nur eines zurückgeben kann. Dazu müssen sie lediglich in eine Array-Variant abgelegt und diese Variant als Ergebnis zurückgegeben werden.
• Umgekehrt zeigt die Funktion `argumentsVariables`, dass man eine Funktion schreiben kann, die eine variable Anzahl von Argumenten akzeptiert. Auch hier muss man sie einfach in eine Array-Varianten ablegen und diese Variante zu einem Funktionsparameter machen.

5.3.5. Ausgabeparameter oder Funktionsergebnis

Angenommen, die Analyse einer Anwendung hat ergeben, dass ein Modul M mit Eingabeparametern Ei und Ausgabeparametern Sj benötigt wird. Zur Erinnerung: Eingabeparameter sind Informationen, die das aufrufende Programm dem aufgerufenen Programm zur Verfügung stellt, und umgekehrt sind Ausgabeparameter Informationen, die das aufgerufene Programm dem aufrufenden Programm zur Verfügung stellt. In VBScript gibt es mehrere Lösungen für Ausgabeparameter:

• Wenn es nur einen Ausgabeparameter gibt, kann dieser zum Ergebnis einer Funktion gemacht werden. Es gibt dann keinen Ausgabeparameter mehr, sondern lediglich ein Funktionsergebnis.
• Gibt es n Ausgabeparameter, kann einer davon als Funktionsergebnis dienen, während die verbleibenden n-1 als Ausgabeparameter fungieren. Alternativ kann man anstelle einer Funktion eine Prozedur mit n Ausgabeparametern verwenden. Man kann auch eine Funktion verwenden, die ein Array zurückgibt, das die n Werte enthält, die an das aufrufende Programm zurückgegeben werden sollen. Man beachte, dass das aufgerufene Programm seine Ergebnisse per Wert an das aufrufende Programm zurückgibt. Dieses Kopieren wird vermieden, wenn Ausgabeparameter per Referenz übergeben werden. Die letztgenannte Lösung spart daher Zeit.

5.4. Das VBScript-Programm zum Sortieren von Werten

Wir haben unsere Erörterung der modularen Programmierung mit einer algorithmischen Untersuchung der Sortierung von über die Tastatur eingegebenen numerischen Werten begonnen. Hier ist die VBScript-Implementierung, die verwendet werden könnte:

Programm

' main program
Option Explicit

Dim T        ' the table of values to be sorted

' reading values
T=lire_tableau

' value sorting
trier_tableau T

' display of sorted values
ecrire_tableau T

' end
wscript.quit 0

' ---------- functions & procedures

' -------- lire_tableau
Function lire_tableau
    ' values are requested
    wscript.stdout.write "Tapez les valeurs à trier sous la forme val1 val2  ... valn : "
    ' we read them
    Dim valeurs
    valeurs=wscript.stdin.readLine
    ' we put them in a table
    lire_tableau=split(valeurs," ")
End Function

' -------- ecrire_tableau
Sub ecrire_tableau(byref T)
    ' displays the contents of table T
    wscript.echo join(T," ")
End Sub

' -------- trier_tableau
Sub trier_tableau (byref T)
    ' sorts array T in ascending order

    ' find the imax index of the T[0..ifin] array
    ' to exchange T[imax] with the last element of array T[0..ifin]
    ' then start again with an array with 1 fewer element

    Dim ifin, imax, temp
    For ifin=ubound(T) To 1 Step -1
        ' find the imax index of the T[0..ifin] array
        imax=chercher_max(T,ifin)
        ' we exchange the max with the last element of array T[0..ifin]
        temp=T(ifin):T(ifin)=T(imax):T(imax)=temp
    Next
End Sub

' -------- chercher_max
Function chercher_max(byRef T, ByVal ifin)
    ' find the imax index of the T[0..ifin] array
    Dim i, imax
    imax=0
    For i=1 To ifin
        If cdbl(T(i))>cdbl(T(imax)) Then imax=i
    Next

    ' We return the result
    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

Kommentare:

• Das im ursprünglichen Algorithmus identifizierte Swap-Modul wurde hier nicht als VBScript-Modul implementiert, da es als zu einfach angesehen wurde, um ein separates Modul zu rechtfertigen.

5.5. Das TAX-Programm in modularer Form

Wir greifen das Steuerberechnungsprogramm wieder auf, diesmal in modularer Form geschrieben

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

' mandatory variable declaration
Option Explicit
Dim erreur

' retrieve arguments and check their validity
Dim marie, enfants, salaire
erreur=getArguments(marie,enfants,salaire)
' mistake?
If erreur(0)<>0 Then wscript.echo erreur(1) : wscript.quit erreur(0)

' retrieve the data needed to calculate taxes
Dim limites, coeffR, coeffN
getData limites,coeffR,coeffN

' the result is displayed
wscript.echo "impôt=" & calculerImpot(marie,enfants,salaire,limites,coeffR,coeffN)

' leave without error
wscript.quit 0

' ------------ functions and procedures

' ----------- getArguments
Function getArguments(byref marie, ByRef enfants, ByRef salaire)
    ' must retrieve three values passed as arguments to the main program
    ' an argument is passed to the program without spaces in front and behind it
    ' use regular expressions to check data validity

    ' returns an error array variant with 2 values
    ' error(0): error code, 0 if no error
    ' error(1): error message if error otherwise empty string

    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)"

    ' we check that there are 3 arguments
    Dim nbArguments
    nbArguments=wscript.arguments.count
    If nbArguments<>3 Then
        ' error msg
        getArguments= array(1,syntaxe & vbCRLF & vbCRLF & "erreur : nombre d'arguments incorrect")
        ' end
        Exit Function
    End If

    Dim modele, correspondances
    Set modele=new regexp

    ' marital status must be among the characters oOnN
    modele.pattern="^[oOnN]$"
    Set correspondances=modele.execute(wscript.arguments(0))
    If correspondances.count=0 Then
        ' error msg
        getArguments=array(2,syntaxe & vbCRLF & vbCRLF & "erreur : argument marie incorrect")
        ' we leave
        Exit Function
    End If
    ' the value
    If lcase(wscript.arguments(0)) = "o"Then
        marie=true
    Else
        marie=false
    End If

    ' children must be an integer >=0
    modele.pattern="^\d{1,2}$"
    Set correspondances=modele.execute(wscript.arguments(1))
    If correspondances.count=0 Then
        ' error
        getArguments= array(3,syntaxe & vbCRLF & vbCRLF & "erreur : argument enfants incorrect")
        ' we leave
        Exit Function
    End If
    ' the value
    enfants=cint(wscript.arguments(1))

    ' salary must be an integer >=0
    modele.pattern="^\d{1,9}$"
    Set correspondances=modele.execute(wscript.arguments(2))
    If correspondances.count=0 Then
        ' error
        getArguments= array(4,syntaxe & vbCRLF & vbCRLF & "erreur : argument salaire incorrect")
        ' we leave
        Exit Function
    End If
    ' the value
    salaire=clng(wscript.arguments(2))

    ' finished without error
    getArguments=array(0,"")
End Function

' ----------- getData
Sub getData(byref limites, ByRef coeffR, ByRef coeffN)
    ' we define the data needed to calculate the tax in 3 tables
    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)

    ' 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
    calculerImpot=int(revenu*coeffr(i)-nbParts*coeffn(i))
End Function

Kommentare

• Die Funktion „getArguments“ ruft die Daten des Steuerzahlers ab (Ehepartner, Kinder, Gehalt). Diese werden hier als Argumente an das VBScript-Programm übergeben. Sollte sich dies ändern – beispielsweise wenn diese Argumente aus einer grafischen Benutzeroberfläche stammen –, müsste nur die Prozedur „getArguments“ neu geschrieben werden, nicht die anderen.
• Die Funktion „getArguments“ kann Fehler in den Argumenten erkennen. In diesem Fall hätte man sich entscheiden können, die Ausführung des Programms innerhalb der Funktion „getArguments“ mit einer „wscript.quit“-Anweisung zu beenden. Dies sollte niemals innerhalb einer Funktion oder Prozedur geschehen. Wenn eine Funktion oder Prozedur einen Fehler erkennt, muss sie dies auf irgendeine Weise dem aufrufenden Programm signalisieren. Es ist Sache des aufrufenden Programms, zu entscheiden, ob die Ausführung beendet wird oder nicht, nicht die der Prozedur. In unserem Beispiel könnte das aufrufende Programm beschließen, den Benutzer aufzufordern, die fehlerhaften Daten über die Tastatur erneut einzugeben, anstatt die Ausführung zu beenden.
• Hier gibt die Funktion „getArguments“ ein Array-Variant zurück, bei dem das erste Element ein Fehlercode ist (0, wenn kein Fehler vorliegt) und das zweite eine Fehlermeldung, falls ein Fehler aufgetreten ist. Durch Überprüfung des zurückgegebenen Ergebnisses kann das aufrufende Programm feststellen, ob ein Fehler aufgetreten ist oder nicht.
• Die Prozedur `getData` ruft die zur Berechnung der Steuer benötigten Daten ab. Hier werden diese Daten direkt innerhalb der Prozedur `getData` definiert. Würden diese Daten aus einer anderen Quelle stammen – beispielsweise einer Datei oder einer Datenbank –, müsste nur die Prozedur `getData` umgeschrieben werden, nicht die anderen.
• Die Funktion `calculerImpot` berechnet die Steuer, sobald alle Daten vorliegen, unabhängig davon, wie diese beschafft wurden.
• Beachten Sie daher, dass modulare Programmierung die (Wieder-)Verwendung bestimmter Module in unterschiedlichen Kontexten ermöglicht. Dieses Konzept wurde in den letzten zwanzig Jahren im Rahmen des Objektkonzepts intensiv weiterentwickelt.