5. De functies en procedures

5.1. De vooraf gedefinieerde functies van VBScript

De rijkdom van een taal is grotendeels af te leiden uit de functiebibliotheek; deze functies kunnen in objecten worden ingekapseld onder de naam methoden. In dit opzicht kan men stellen dat VBScript vrij beperkt is.

De volgende tabel geeft een overzicht van de functies van VBScript buiten objecten om. We zullen hier niet in detail op ingaan. Hun naam geeft doorgaans al een indicatie van hun functie. De lezer kan de documentatie raadplegen voor meer informatie over een bepaalde functie.

Abs	Array	Asc	Atn
CBool	CByte	CCur	CDate
CDbl	Chr	CInt	CLng
Omzettingen	Cos	CreateObject	CSng
Datum	DateAdd	DateDiff	DatePart
DateSerial	DateValue	Dag	Afgeleide wiskunde
Eval	Exp	Filter	FormatCurrency
FormatDateTime	FormatNumber	FormatPercent	GetLocale
GetObject	GetRef	Hex	Uur
InputBox	InStr	InStrRev	Int, Fixs
IsArray	IsDate	IsEmpty	IsNull
IsNumeric	IsObject	Join	LBound
LCase	Links	Len	LoadPicture
Log	LTrim; RTrim; en Trims	Wiskunde	Mid
Minute	Maand	MonthName	MsgBox
Nu	okt	Vervangen	RGB
Rechts	Rnd	Rond	ScriptEngine
ScriptEngineBuildVersion	ScriptEngineMajorVersion	ScriptEngineMinorVersion	Tweede
SetLocale	Sgn	Sin	Spatie
Split	Sqr	StrComp	String
Tan	Tijd	Timer	TimeSerial
TimeValue	TypeName	UBound	UCase
VarType	Weekdag	WeekdayName	Jaar

5.2. Modulaire programmering

Het beschrijven van de geprogrammeerde oplossing voor een probleem houdt in dat men de reeks elementaire handelingen beschrijft die door de computer kunnen worden uitgevoerd en waarmee het probleem kan worden opgelost. Afhankelijk van de programmeertaal zijn deze elementaire handelingen meer of minder geavanceerd. Voorbeelden hiervan zijn:

• gegevens van het toetsenbord of de schijf inlezen
• gegevens weergeven op het scherm, afdrukken, opslaan op schijf, enz.
• uitdrukkingen berekenen
• door een bestand navigeren
• ...

Het beschrijven van een complex probleem kan duizenden van deze elementaire instructies of zelfs meer vereisen. Het is dan voor de menselijke geest erg moeilijk om een totaalbeeld van een programma te krijgen. Gezien deze moeilijkheid om het probleem in zijn geheel te begrijpen, wordt het daarom opgesplitst in deelproblemen die eenvoudiger op te lossen zijn. Laten we het volgende probleem eens bekijken: een lijst met numerieke waarden die via het toetsenbord zijn ingevoerd, sorteren en de gesorteerde lijst op het scherm weergeven.

In eerste instantie kan de oplossing als volgt worden beschreven:

  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

We hebben het probleem opgesplitst in drie deelproblemen, die eenvoudiger op te lossen zijn. De algoritmische notatie is vaak formeler dan de vorige en het algoritme ziet er dan als volgt uit:

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

waarbij T een array vertegenwoordigt. De bewerkingen

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

zijn niet-elementaire bewerkingen die op hun beurt moeten worden beschreven door elementaire bewerkingen. Dit gebeurt in zogenaamde modules. De gegevens T worden een parameter van de module genoemd. Dit is informatie die het aanroepende programma doorgeeft aan de aangeroepen module (invoerparameter) of ontvangt van de aangeroepen module (uitvoerparameter). De parameters van een module zijn dus de gegevens die worden uitgewisseld tussen het aanroepende programma en de aangeroepen module.

module lire_tableau(T)
module trier_tableau(T)
module écrire_tableau(T)

De module lire_tableau(T) zou als volgt kunnen worden beschreven:

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 hebben we de module lire_tableau voldoende beschreven. De drie benodigde acties kunnen namelijk direct in VBScript worden omgezet. Voor de laatste actie is het gebruik van de functie split vereist. Als VBScript deze functie niet zou hebben, zou actie 3 op haar beurt moeten worden opgesplitst in elementaire acties die een direct equivalent in VBScript hebben.

De module écrire_tableau(T) zou als volgt kunnen worden beschreven:

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

De module écrire_tableau(T) zou als volgt kunnen worden beschreven (ervan uitgaande dat de indices van de elementen van T bij 0 beginnen):

début
      N<-- indice dernier élément du tableau T
      pour IFIN variant de N à 1
      faire
           //we zoeken de index IMAX van het grootste element van T
           // IFIN is de index van het laatste element van T

          chercher_max(T, IFIN, IMAX) 

           // het grootste element van T wordt verwisseld met het laatste element van T

          échanger (T, IMAX, IFIN)

      finfaire
FIN

Hier maakt het algoritme opnieuw gebruik van niet-elementaire acties:

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

chercher_max(T, IFIN, IMAX) is de index IMAX van het grootste element in de array T, waarvan de index van het laatste element IFIN is.

uitwisselen(T, IMAX, IFIN) wisselt twee elementen van de array T uit, namelijk die met index IMAX en IFIN.

De nieuwe niet-elementaire bewerkingen moeten dus worden beschreven.

module 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
module uitwisselen(T IMAX, IFIN)	début temp<----T[IMAX] T[IMAX]<---T[IFIN] T[IFIN]<---temp fin

Het oorspronkelijke probleem is volledig beschreven aan de hand van elementaire VBScript-bewerkingen en kan nu dus in deze taal worden vertaald. Opgemerkt moet worden dat elementaire bewerkingen van taal tot taal kunnen verschillen en dat bij de analyse van een probleem dus op een bepaald moment rekening moet worden gehouden met de gebruikte programmeertaal. Een object dat in de ene taal bestaat, hoeft in een andere taal niet te bestaan, wat dan weer gevolgen heeft voor het gebruikte algoritme. Als een taal bijvoorbeeld een sorteerfunctie heeft, zou het hier absurd zijn om daar geen gebruik van te maken.

Het principe dat hier wordt toegepast, is dat van de zogenaamde top-down-analyse. Als we de structuur van de oplossing weergeven, krijgen we het volgende:

We hebben een boomstructuur.

5.3. De VBScript-functies en -procedures

Zodra de modulaire analyse is uitgevoerd, kan de programmeur de modules van zijn algoritme vertalen naar VBScript-code zoals fonctions of procédures. Zowel fonctions als procédures accepteren invoer- en uitvoerparameters, maar fonction levert een resultaat op dat in uitdrukkingen kan worden gebruikt, terwijl procédure dat niet doet.

5.3.1. Declaratie van VBScript-functies en -procedures

De declaratie van een VBScript-procedure is als volgt

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

en die van een functie

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

Om het resultaat weer te geven, moet de functie een toewijzingsinstructie bevatten waarmee het resultaat wordt toegewezen aan een variabele met de naam van de functie:

functienaam=resultaat

De uitvoering van een functie of procedure wordt op twee manieren beëindigd:

1. bij het tegenkomen van de instructie voor het einde van de functie (end function) of het einde van de procedure (end sub)
2. bij het tegenkomen van de instructie voor het verlaten van de functie (exit function) of procedure (exit sub)

Voor de functie geldt dat het resultaat moet zijn toegewezen aan een variabele met de naam van de functie voordat deze wordt beëindigd met een end function of exit function.

5.3.2. Manieren om parameters door te geven aan een functie of procedure

Bij de declaratie van de invoer- en uitvoerparameters van een functie of procedure wordt de wijze (byRef, byVal) gespecificeerd waarop de parameter van het aanroepende programma naar het aangeroepen programma wordt doorgegeven:

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

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

Wanneer de overdrachtsmodus byRef of byVal niet is gespecificeerd, wordt de modus byRef gebruikt.

Effectieve parameters, formele parameters

Stel dat er een VBScript-functie is gedefinieerd door

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

De parameters parmamFormi die in de definitie van de functie of procedure worden gebruikt, worden formele parameters genoemd. De bovenstaande functie kan vanuit het hoofdprogramma of vanuit een andere module worden aangeroepen met een instructie zoals:

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

De parameters parmamEffi die bij het aanroepen van de functie of procedure worden gebruikt, worden effectieve parameters genoemd. Wanneer de uitvoering van de functie nomFonction begint, krijgen de formele parameters de waarden van de bijbehorende effectieve parameters. De sleutelwoorden byRef en byVal bepalen de wijze waarop deze waarden worden doorgegeven.

Overdracht per waarde (byVal)

Wanneer een formele parameter deze overdrachtswijze specificeert, zijn de formele parameter en de effectieve parameter twee verschillende variabelen. De waarde van de effectieve parameter wordt vóór de uitvoering van de functie of procedure naar de formele parameter gekopieerd. Als de functie of procedure tijdens de uitvoering de waarde van de formele parameter wijzigt, heeft dit geen invloed op de waarde van de bijbehorende effectieve parameter. Deze overdrachtswijze is zeer geschikt voor invoerparameters van de functie of procedure.

Overdrachtswijze via verwijzing (byRef)

Deze overdrachtswijze is de standaardwijze als er geen overdrachtswijze voor de parameter is opgegeven. Wanneer een formele parameter deze overdrachtswijze specificeert, zijn de formele parameter en de bijbehorende effectieve parameter één en dezelfde variabele. Als de functie dus de formele parameter wijzigt, wordt ook de effectieve parameter gewijzigd. Deze overdrachtswijze is zeer geschikt voor:

• uitvoerparameters, omdat de waarde daarvan moet worden doorgegeven aan het aanroepende programma
• voor invoerparameters die moeilijk te kopiëren zijn, zoals tabellen

Het volgende programma toont voorbeelden van parameterdoorgave:

Programma

Sub proc1(byval i, ByRef j, k) ' i wordt als waarde doorgegeven (byval) – de werkelijke parameter en de formele parameter zijn dan verschillend ' j wordt als waarde doorgegeven (byref) – de werkelijke parameter en de formele parameter zijn dan identiek ' de overdrachtswijze van k is niet gespecificeerd. Standaard is dit per verwijzing 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) ' geeft de waarden van i, j en k weer wscript.echo msg & " i=" & i & " j=" & j & " k=" & k End Sub ' ------------- aanroepen van functies en procedures ' i en j initialiseren i=4:j=5 : k=6 ' controle affiche "dans programme principal, avant l'appel à proc1 :",i,j,k ' procedure proc1 aanroepen proc1 i,j,k ' controle affiche "dans programme principal, après l'appel à proc1 :",i,j,k ' einde wscript.quit 0

Resultaten

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

Opmerkingen

• In een VBScript-script is er geen specifieke plaats voor functies en procedures. Ze kunnen overal in de brontekst staan. Over het algemeen worden ze aan het begin of aan het einde gegroepeerd en zorgt men ervoor dat het hoofdprogramma een aaneengesloten blok vormt.

5.3.3. Syntaxis voor het aanroepen van functies en procedures

Stel dat er een procedure p is die formele parameters pf1, pf2, ... accepteert

• dan gebeurt de aanroep van procedure p in de vorm

p pe1, pe2, ...

zonder haakjes rond de parameters

• als de procedure p geen parameters accepteert, kan men naar keuze de aanroep p of p() gebruiken en de declaratie sub p of sub p()

Stel dat een functie f de formele parameters pf1, pf2, ... accepteert

• de aanroep van de functie f gebeurt in de vorm

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

De haakjes rond de parameters zijn verplicht. Als de functie f geen parameters heeft, kan men naar keuze de aanroep f of f() gebruiken, evenals de declaratie function f of function f().

• Het resultaat van de functie f kan door het aanroepende programma worden genegeerd. De functie f wordt dan beschouwd als een procedure en volgt de regels voor het aanroepen van procedures. Men schrijft dan f pe1, pe2, ... (zonder haakjes) om de functie f aan te roepen.

Als de functie of procedure een objectmethode is, lijken de regels enigszins af te wijken en niet uniform te zijn.

• Zo kan men bijvoorbeeld MyFile.WriteLine "Dit is een test." of MyFile.WriteLine("Dit is een test.") schrijven
• maar hoewel men wscript.echo 4 kan schrijven, kan men niet wscript.echo(4) schrijven.

We houden ons aan de volgende regels:

• geen haakjes rond de parameters van een procedure of een functie die als procedure wordt gebruikt
• haakjes rond de parameters van een functie

5.3.4. Enkele voorbeelden van functies

Hieronder volgen enkele voorbeelden van definities en toepassingen van functies:

Programma

Function plusgrandque(byval i, ByVal j) ' stelt de booleaanse waarde in op waar als i>j, anders op onwaar ' gegevenscontrole 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) ' geeft een array met n elementen terug tableau=array() ' controleert of de parameter n geldig is 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 ' het resultaat wordt geretourneerd rendUnTableau=tableau End Function Function argumentsVariables(byref arguments) ' argumenten zijn een array van getallen waarvan de som wordt geretourneerd somme=0 For i=0 To ubound(arguments) somme=somme+arguments(i) Next argumentsVariables=somme End Function ' twee functies zonder parameters, op twee verschillende manieren gedeclareerd Function sansParametres1 sansParametres=4 End Function Function sansParametres2() sansParametres=4 End Function ' ------------- aanroepen van functies en procedures ' aanroepen van de functie 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") ' aanroepen van de functie 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 ' aanroepen van de functie argumentsVariables wscript.echo "somme=" & argumentsVariables(array(-1,2,7,8)) wscript.echo "somme=" & argumentsVariables(array(-1,10,12)) ' aanroepen van functies zonder parameters res=sansParametres1 res=sansParametres1() sansParametres1 sansParametres1() res=sansParametres2 res=sansParametres2() sansParametres2 sansParametres2() ' einde wscript.quit 0

Resultaten

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

Opmerkingen

• De functie rendUnTableau laat zien dat een functie meerdere resultaten kan retourneren in plaats van slechts één. Het volstaat om deze in een array-variant te plaatsen en deze variant als resultaat te retourneren.
• Omgekeerd laat de functie argumentsVariables zien dat men een functie kan schrijven die een variabel aantal argumenten accepteert. Ook hier volstaat het om deze in een array-variant te plaatsen en deze variant als parameter van de functie te gebruiken.

5.3.5. Uitvoerparameter of resultaat van een functie

Stel dat uit de analyse van een toepassing is gebleken dat er behoefte is aan een module M met invoerparameters Ei en uitvoerparameters Sj. Laten we niet vergeten dat invoerparameters informatie zijn die het aanroepende programma aan het aangeroepen programma doorgeeft, en dat omgekeerd uitvoerparameters informatie zijn die het aangeroepen programma aan het aanroepende programma doorgeeft. In VBScript zijn er verschillende oplossingen voor uitvoerparameters:

• als er slechts één uitgangsparameter is, kan deze als het resultaat van een functie worden gebruikt. Er is dan geen uitgangsparameter meer, maar gewoon een functie-resultaat.
• Als er n uitvoerparameters zijn, kan één daarvan dienen als functie-resultaat, terwijl de overige n-1 uitvoerparameters blijven. Men kan ook geen functie gebruiken, maar een procedure met n uitvoerparameters. Men kan tevens een functie gebruiken die een array retourneert waarin de n waarden zijn geplaatst die aan het aanroepende programma moeten worden teruggegeven. We herinneren eraan dat het aangeroepen programma zijn resultaten aan het aanroepende programma teruggeeft door waarden te kopiëren. Deze kopieerbewerking wordt vermeden in het geval van uitgangsparameters die bij verwijzing worden doorgegeven. Deze laatste oplossing levert dus een tijdwinst op.

5.4. Het VBScript-programma voor het sorteren van waarden

We zijn de bespreking van modulair programmeren begonnen met de algoritmische analyse van het sorteren van numerieke waarden die via het toetsenbord zijn ingevoerd. Hier volgt de vertaling VBScript die hiervan gemaakt zou kunnen worden:

Programma

' hoofdprogramma Option Explicit Dim T ' le tableau de valeurs à trier ' waarden uitlezen T=lire_tableau ' sorteren van waarden trier_tableau T ' weergave van de gesorteerde waarden ecrire_tableau T ' einde wscript.quit 0 ' ---------- functies & procedures ' -------- lire_tableau Function lire_tableau ' de waarden worden opgevraagd wscript.stdout.write "Tapez les valeurs à trier sous la forme val1 val2 ... valn : " ' de waarden worden ingelezen Dim valeurs valeurs=wscript.stdin.readLine ' ze worden in een array geplaatst lire_tableau=split(valeurs," ") End Function ' -------- ecrire_tableau Sub ecrire_tableau(byref T) ' geeft de inhoud van de tabel T weer wscript.echo join(T," ") End Sub ' -------- trier_tableau Sub trier_tableau (byref T) ' sorteert de tabel T in oplopende volgorde ' we zoeken de index imax van de tabel T[0..ifin] ' om T[imax] te verwisselen met het laatste element van de array T[0..ifin] ' daarna beginnen we opnieuw met een array die één element minder bevat Dim ifin, imax, temp For ifin=ubound(T) To 1 Step -1 ' we zoeken de index imax van de array T[0..ifin] imax=chercher_max(T,ifin) ' we wisselen het maximale element om met het laatste element van de 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) ' we zoeken de index imax van de array T[0..ifin] Dim i, imax imax=0 For i=1 To ifin If cdbl(T(i))>cdbl(T(imax)) Then imax=i Next ' Het resultaat wordt weergegeven chercher_max=imax End Function

Resultaten

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

Opmerkingen:

• de module échanger, die in het oorspronkelijke algoritme was geïdentificeerd, is hier niet als VBScript-module geïmplementeerd omdat deze te eenvoudig werd geacht om een aparte module te rechtvaardigen.

5.5. Het programma IMPOTS in modulaire vorm

We nemen het programma voor de belastingberekening opnieuw op, ditmaal geschreven in modulaire vorm

Programma

' berekening van de belasting van een belastingplichtige ' het programma moet worden aangeroepen met drie parameters: gehuwd, kinderen, salaris ' getrouwd: letter O indien getrouwd, N indien ongehuwd ' kinderen: aantal kinderen ' salaris: jaarsalaris zonder centimes ' verplichte declaratie van variabelen Option Explicit Dim erreur ' de argumenten worden opgehaald en op geldigheid gecontroleerd Dim marie, enfants, salaire erreur=getArguments(marie,enfants,salaire) ' fout? If erreur(0)<>0 Then wscript.echo erreur(1) : wscript.quit erreur(0) ' de gegevens die nodig zijn voor de berekening van de belasting worden opgehaald Dim limites, coeffR, coeffN getData limites,coeffR,coeffN ' het resultaat wordt weergegeven wscript.echo "impôt=" & calculerImpot(marie,enfants,salaire,limites,coeffR,coeffN) ' we sluiten af zonder fouten wscript.quit 0 ' ------------ functies en procedures ' ----------- getArguments Function getArguments(byref marie, ByRef enfants, ByRef salaire) ' moet drie waarden ophalen die als argument aan het hoofdprogramma zijn doorgegeven ' een argument wordt zonder spaties ervoor en erachter doorgegeven aan het programma ' er worden reguliere expressies gebruikt om de geldigheid van de gegevens te controleren ' retourneert een foutvariant-array met 2 waarden ' fout(0): foutcode, 0 als er geen fout is ' fout(1): foutmelding indien er een fout is, anders de lege tekenreeks 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)" ' er wordt gecontroleerd of er 3 argumenten zijn Dim nbArguments nbArguments=wscript.arguments.count If nbArguments<>3 Then ' foutmelding getArguments= array(1,syntaxe & vbCRLF & vbCRLF & "erreur : nombre d'arguments incorrect") ' einde Exit Function End If Dim modele, correspondances Set modele=new regexp ' de burgerlijke staat moet bestaan uit de tekens oOnN modele.pattern="^[oOnN]$" Set correspondances=modele.execute(wscript.arguments(0)) If correspondances.count=0 Then ' foutmelding getArguments=array(2,syntaxe & vbCRLF & vbCRLF & "erreur : argument marie incorrect") ' afsluiten Exit Function End If ' waarde ophalen If lcase(wscript.arguments(0)) = "o"Then marie=true Else marie=false End If ' 'kinderen' moet een geheel getal zijn >=0 modele.pattern="^\d{1,2}$" Set correspondances=modele.execute(wscript.arguments(1)) If correspondances.count=0 Then ' fout getArguments= array(3,syntaxe & vbCRLF & vbCRLF & "erreur : argument enfants incorrect") ' afsluiten Exit Function End If ' de waarde wordt opgehaald enfants=cint(wscript.arguments(1)) ' het salaris moet een geheel getal zijn >=0 modele.pattern="^\d{1,9}$" Set correspondances=modele.execute(wscript.arguments(2)) If correspondances.count=0 Then ' fout getArguments= array(4,syntaxe & vbCRLF & vbCRLF & "erreur : argument salaire incorrect") ' we stoppen Exit Function End If ' de waarde wordt opgehaald salaire=clng(wscript.arguments(2)) ' het is zonder fouten voltooid getArguments=array(0,"") End Function ' ----------- getData Sub getData(byref limites, ByRef coeffR, ByRef coeffN) ' we definiëren de gegevens die nodig zijn voor de berekening van de belasting in 3 tabellen 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 wordt het aantal aandelen berekend 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 ' hier wordt het gezinsquotiënt en het belastbaar inkomen berekend Dim revenu, qf revenu=0.72*salaire qf=revenu/nbParts ' de belasting wordt berekend 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

Opmerkingen

• Met de functie getArguments kan informatie (echtgenote, kinderen, salaris) van de belastingplichtige worden opgehaald. Hier worden deze gegevens als argumenten doorgegeven aan het VBScript-programma. Mocht dit veranderen, bijvoorbeeld als deze argumenten afkomstig zouden zijn van een grafische interface, dan hoeft alleen de procedure getArguments te worden herschreven en niet de andere.
• De functie getArguments kan fouten in de argumenten detecteren. Wanneer dit gebeurt, had men kunnen besluiten de uitvoering van het programma in de functie getArguments te stoppen met een instructie wscript.quit. Dit mag nooit in een functie of procedure worden gedaan. Als een functie of procedure een fout detecteert, moet deze dit op de een of andere manier melden aan het aanroepende programma. Het is aan het aanroepende programma om te beslissen of de uitvoering al dan niet wordt gestopt, niet aan de procedure. In ons voorbeeld zou het aanroepende programma kunnen besluiten om de gebruiker te vragen de foutieve gegevens opnieuw via het toetsenbord in te voeren, in plaats van de uitvoering te stoppen.
• Hier retourneert de functie getArguments een arrayvariant waarvan het eerste element een foutcode is (0 als er geen fout is) en het tweede element een foutmelding als er een fout is opgetreden. Door het verkregen resultaat te controleren, kan het aanroepende programma vaststellen of er al dan niet een fout is opgetreden.
• Met de procedure getData kunnen de gegevens worden verkregen die nodig zijn voor de berekening van de belasting. Hier worden deze gegevens rechtstreeks gedefinieerd in de procedure getData. Als deze gegevens uit een andere bron zouden moeten komen, bijvoorbeeld uit een bestand of een database, zou alleen de procedure getData herschreven moeten worden en niet de andere.
• Met de functie calculerImpot kan de belasting worden berekend zodra alle gegevens zijn verkregen, ongeacht de manier waarop deze zijn verkregen.
• Er zij dus opgemerkt dat een modulaire opzet het (her)gebruik van bepaalde modules in verschillende contexten mogelijk maakt. Dit concept is de afgelopen twintig jaar sterk verder ontwikkeld binnen het objectgeoriënteerde denken.