5. Funções e procedimentos

5.1. As funções predefinidas do VBScript

A riqueza de uma linguagem deriva, em grande parte, de sua biblioteca de funções, as quais podem ser encapsuladas em objetos sob o nome de métodos. Nesse aspecto, pode-se considerar que o VBScript é bastante limitado.

A tabela a seguir define as funções do VBScript fora dos objetos. Não as detalharemos aqui. Seus nomes geralmente indicam sua finalidade. O leitor deve consultar a documentação para obter detalhes sobre uma função específica.

Abs	Array	Asc	Atn
CBool	CByte	CCur	CDate
CDbl	Chr	CInt	CLng
Conversões	Cos	CreateObject	CSng
Data	DateAdd	DateDiff	DatePart
DateSerial	DateValue	Dia	Matemática derivada
Avaliação	Exp	Filtro	FormatCurrency
FormatDateTime	FormatNumber	FormatPercent	GetLocale
GetObject	GetRef	Hex	Hora
InputBox	InStr	InStrRev	Int, Fixs
IsArray	IsDate	IsEmpty	IsNull
IsNumeric	IsObject	Anexar	LBound
LCase	Esquerda	Len	LoadPicture
Log	LTrim; RTrim; e acabamentos	Matemática	Meio
Minuto	Mês	MonthName	MsgBox
Agora	Out	Substituir	RGB
Direita	Rnd	Redondo	ScriptEngine
ScriptEngineBuildVersion	ScriptEngineMajorVersion	ScriptEngineMinorVersion	Segundo
SetLocale	Assinatura	Sin	Espaço
Split	Sqr	StrComp	String
Tan	Time	Temporizador	TimeSerial
TimeValue	TypeName	UBound	UCase
VarType	Dia da semana	WeekdayName	Ano

5.2. Programação modular

Descrever a solução programada de um problema significa descrever a sequência de ações elementares que podem ser executadas pelo computador e que são capazes de resolver o problema. Dependendo da linguagem de programação, essas operações elementares são mais ou menos sofisticadas. Entre elas, encontram-se, por exemplo:

ler um dado proveniente do teclado ou do disco
gravar um dado na tela, na impressora, no disco, etc.
calcular expressões
navegar por um arquivo
...

Descrever um problema complexo pode exigir vários milhares dessas instruções elementares e até mais. Nesse caso, fica muito difícil para a mente humana ter uma visão global de um programa. Diante dessa dificuldade de compreender o problema em sua totalidade, ele é então dividido em subproblemas mais simples de resolver. Consideremos o seguinte problema: classificar uma lista de valores numéricos digitados no teclado e exibir a lista classificada na tela.

Inicialmente, podemos descrever a solução da seguinte forma:

  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

Dividimos o problema em três subproblemas, mais simples de resolver. A notação algorítmica costuma ser mais formalizada do que a anterior, e o algoritmo será escrito da seguinte forma:

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

onde T representa uma matriz. As operações

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

são operações não elementares que, por sua vez, devem ser descritas por operações elementares. Isso é feito no que se denomina módulos. O dado T é chamado de parâmetro do módulo. Trata-se de uma informação que o programa chamador passa para o módulo chamado (parâmetro de entrada) ou recebe do módulo chamado (parâmetro de saída). Os parâmetros de um módulo são, portanto, as informações que são trocadas entre o programa chamador e o módulo chamado.

módulo lire_tableau(T)
módulo trier_tableau(T)
módulo écrire_tableau(T)

O módulo lire_tableau(T) poderia ser descrito da seguinte forma:


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

Aqui, descrevemos detalhadamente o módulo lire_tableau. De fato, as três ações necessárias têm uma tradução imediata para VBScript. A última exigirá o uso da função split. Se o VBScript não tivesse essa função, a ação 3 teria que ser, por sua vez, decomposta em ações elementares com um equivalente imediato no VBScript.

O módulo écrire_tableau(T) poderia ser descrito da seguinte forma:


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

O módulo écrire_tableau(T) poderia ser descrito da seguinte forma (supondo que os índices dos elementos de T comecem em 0):

début
      N<-- indice dernier élément du tableau T
      pour IFIN variant de N à 1
      faire
           //: procurando o índice IMAX do maior elemento de T
           // IFIN é o índice do último elemento de T

          chercher_max(T, IFIN, IMAX) 

           // trocamos o maior elemento de T pelo último elemento de T

          échanger (T, IMAX, IFIN)

      finfaire
FIN

Aqui, o algoritmo utiliza novamente ações não elementares:


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

chercher_max(T, IFIN, IMAX) retorna o índice IMAX do maior elemento da tabela T, cujo índice do último elemento é IFIN.

trocar(T, IMAX, IFIN) troca dois elementos da matriz T, aqueles com índices IMAX e IFIN.

Portanto, é necessário descrever as novas operações não elementares.

módulo 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`
módulo de troca (T IMAX, IFIN)	`début temp<----T[IMAX] T[IMAX]<---T[IFIN] T[IFIN]<---temp fin`

O problema inicial foi descrito completamente por meio de operações elementares do VBScript e, portanto, agora pode ser traduzido para essa linguagem. Observe-se que as ações elementares podem diferir de uma linguagem para outra e que, portanto, a análise de um problema deve, em determinado momento, levar em conta a linguagem de programação utilizada. Um objeto que existe em uma linguagem pode não existir em outra e, assim, alterar o algoritmo utilizado. Assim, se uma linguagem tivesse uma função de classificação, seria absurdo não utilizá-la neste caso.

O princípio aplicado aqui é o chamado de análise descendente. Se representarmos a estrutura básica da solução, temos o seguinte:

Temos uma estrutura em árvore.

5.3. As funções e procedimentos do VBScript

Uma vez realizada a análise modular, o programador pode traduzir os módulos de seu algoritmo para VBScript, como fonctions ou procédures. Tanto o fonctions quanto o procédures aceitam parâmetros de entrada/saída, mas o fonction retorna um resultado que permite seu uso em expressões, enquanto o procédure não retorna nenhum.

5.3.1. Declaração de funções e procedimentos em VBScript

A declaração de um procedimento VBScript é a seguinte

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

e a de uma função

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

Para retornar seu resultado, a função deve conter uma instrução de atribuição do resultado a uma variável com o nome da função:

nomeDaFunção = resultado

A execução de uma função ou procedimento é interrompida de duas maneiras:

ao encontrar a instrução de fim de função (end function) ou fim de procedimento (end sub)
ao encontrar a instrução de saída da função (exit function) ou do procedimento (exit sub)

No caso da função, lembre-se de que o resultado deve ter sido atribuído a uma variável com o nome da função antes que esta termine com um end function ou exit function.

5.3.2. Modos de passagem de parâmetros de uma função ou procedimento

Na declaração dos parâmetros de entrada e saída de uma função ou procedimento, especifica-se o modo (byRef, byVal) de transmissão do parâmetro do programa chamador para o programa chamado:

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

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

Quando o modo de transmissão byRef ou byVal não for especificado, será utilizado o modo byRef.

Parâmetros efetivos, parâmetros formais

Seja uma função VBScript definida por

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

Os parâmetros parmamFormi utilizados na definição da função ou do procedimento são chamados de parâmetros formais. A função anterior poderá ser utilizada a partir do programa principal ou de outro módulo por meio de uma instrução do tipo:

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

Os parâmetros parmamEffi utilizados na chamada à função ou ao procedimento são chamados de parâmetros efetivos. Quando a execução da função nomFonction começa, os parâmetros formais recebem os valores dos parâmetros efetivos correspondentes. As palavras-chave byRef e byVal definem o modo de transmissão desses valores.

Modo de transmissão por valor (byVal)

Quando um parâmetro formal especifica esse modo de transmissão, o parâmetro formal e o parâmetro efetivo são, então, duas variáveis diferentes. O valor do parâmetro efetivo é copiado para o parâmetro formal antes da execução da função ou do procedimento. Se esta modificar o valor do parâmetro formal durante sua execução, isso não altera de forma alguma o valor do parâmetro efetivo correspondente. Esse modo de transmissão é adequado para os parâmetros de entrada da função ou do procedimento.

Modo de transmissão por referência (byRef)

Esse modo de transmissão é o padrão caso nenhum modo de transmissão do parâmetro seja especificado. Quando um parâmetro formal especifica esse modo de transmissão, o parâmetro formal e o parâmetro efetivo correspondente são uma única e mesma variável. Assim, se a função alterar o parâmetro formal, o parâmetro efetivo também será alterado. Esse modo de transmissão é adequado para:

para parâmetros de saída, pois o valor deles deve ser transmitido ao programa chamador
aos parâmetros de entrada cuja cópia é trabalhosa, como tabelas

O programa a seguir mostra exemplos de passagem de parâmetros:

Programa


Sub proc1(byval i, ByRef j, k)
  ' i é passado por valor (byval) — o parâmetro efetivo e o parâmetro formal são, portanto, diferentes
  ' j é passado por valor (byref) — o parâmetro efetivo e o parâmetro formal são, portanto, idênticos
  ' o modo de passagem de k não está especificado. Por padrão, é por referência
  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)
  ' exibe os valores de i, j e k
  wscript.echo msg & " i=" & i & " j=" & j & " k=" & k
End Sub


' ------------- chamadas a funções e procedimentos

' inicializa i e j
  i=4:j=5 : k=6

' verificação
  affiche "dans programme principal, avant l'appel à proc1 :",i,j,k

' chamada ao procedimento proc1
  proc1 i,j,k

' verificação
  affiche "dans programme principal, après l'appel à proc1 :",i,j,k

' fim
  wscript.quit 0

Resultados

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

Comentários

Em um script VBScript, não há um local específico para funções e procedimentos. Eles podem estar em qualquer parte do texto-fonte. Geralmente, eles são agrupados no início ou no final, e procura-se fazer com que o programa principal constitua um bloco contínuo.

5.3.3. Sintaxe de chamada de funções e procedimentos

Seja um procedimento p que aceita parâmetros formais pf1, pf2, ...

a chamada ao procedimento p é feita da seguinte forma

p pe1, pe2, ...

sem parênteses em torno dos parâmetros

se o procedimento p não aceitar nenhum parâmetro, pode-se usar indistintamente a chamada p ou p() e a declaração sub p ou sub p()

Seja uma função f que admite parâmetros formais pf1, pf2, ...

a chamada à função f é feita na forma

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

Os parênteses em torno dos parâmetros são obrigatórios. Se a função f não aceitar nenhum parâmetro, pode-se usar indistintamente a chamada f ou f() e a declaração function f ou function f().

O resultado da função f pode ser ignorado pelo programa chamador. A função f é então considerada um procedimento e segue as regras de chamada de procedimentos. Escreve-se, então, f pe1, pe2, ... (sem parênteses) para chamar a função f.

Se a função ou procedimento for um método de objeto, parece que as regras sejam um pouco diferentes e não homogêneas.

Assim, pode-se escrever MyFile.WriteLine “Este é um teste.” ou MyFile.WriteLine(“Este é um teste.”)
mas, embora seja possível escrever wscript.echo 4, não é possível escrever wscript.echo(4).

Seguiremos as seguintes regras:

não usar parênteses em torno dos parâmetros de uma procedimento ou função utilizada como procedimento
parênteses em torno dos parâmetros de uma função

5.3.4. Alguns exemplos de funções

Veja abaixo alguns exemplos de definições e utilizações de funções:

Programa


 Function plusgrandque(byval i, ByVal j)
  ' retorna o valor booleano verdadeiro se i > j; caso contrário, retorna falso

  ' verificação dos dados
  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)
  ' retorna uma matriz com n elementos
  tableau=array()
  ' verificação da validade do parâmetro 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
  ' retorna o resultado
  rendUnTableau=tableau
End Function

 Function argumentsVariables(byref arguments)
  ' os argumentos são uma matriz de números cuja soma é retornada
  somme=0
  For i=0 To ubound(arguments)
    somme=somme+arguments(i)
  Next
  argumentsVariables=somme
End Function

  ' duas funções sem parâmetros declaradas de duas maneiras diferentes
  Function sansParametres1
    sansParametres=4
  End Function

  Function sansParametres2()
    sansParametres=4
  End Function

  
' ------------- chamadas a funções e procedimentos

' chamadas à função 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")

' chamadas à função 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

' chamadas à função argumentsVariables
  wscript.echo "somme=" & argumentsVariables(array(-1,2,7,8))
  wscript.echo "somme=" & argumentsVariables(array(-1,10,12))

' chamadas de funções sem parâmetros
  res=sansParametres1
  res=sansParametres1()
  sansParametres1
  sansParametres1()

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

' fim
  wscript.quit 0

Resultados

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

Comentários

A função rendUnTableau mostra que uma função pode retornar vários resultados, e não apenas um. Basta que ela os coloque em uma variante de tabela e retorne essa variante como resultado.
Por outro lado, a função argumentsVariables mostra que é possível escrever uma função que aceite um número variável de argumentos. Basta, nesse caso, colocá-los em uma variante de tabela e definir essa variante como um parâmetro da função.

5.3.5. Parâmetro de saída ou resultado de uma função

Suponhamos que a análise de uma aplicação tenha demonstrado a necessidade de um módulo M com parâmetros de entrada Ei e parâmetros de saída Sj. Vale lembrar que os parâmetros de entrada são informações que o programa chamador fornece ao programa chamado e que, inversamente, os parâmetros de saída são informações que o programa chamado fornece ao programa chamador. No VBScript, existem várias soluções para os parâmetros de saída:

se houver apenas um parâmetro de saída, ele pode ser definido como o resultado de uma função. Nesse caso, não há mais um parâmetro de saída, mas simplesmente um resultado de função.
se houver n parâmetros de saída, um deles pode servir como resultado de função, enquanto os n-1 restantes continuam sendo parâmetros de saída. Também é possível não usar uma função, mas sim um procedimento com n parâmetros de saída. Além disso, pode-se utilizar uma função que retorne uma matriz na qual foram colocados os n valores a serem devolvidos ao programa chamador. Lembre-se de que o programa chamado retorna seus resultados ao programa chamador por cópia de valores. Essa cópia é evitada no caso de parâmetros de saída passados por referência. Portanto, nessa última solução, há uma economia de tempo.

5.4. O programa VBScript para classificação de valores

Começamos a discussão sobre programação modular com o estudo algorítmico de uma ordenação de valores numéricos digitados no teclado. Aqui está a tradução VBScript que poderia ser feita:

Programa

' programa principal
Option Explicit

Dim T        ' le tableau de valeurs à trier

' leitura dos valores
T=lire_tableau

' classificação dos valores
trier_tableau T

' exibição dos valores classificados
ecrire_tableau T

' fim
wscript.quit 0

' ---------- funções e procedimentos

' -------- lire_tableau
Function lire_tableau
    ' solicita-se os valores
    wscript.stdout.write "Tapez les valeurs à trier sous la forme val1 val2  ... valn : "
    ' eles são lidos
    Dim valeurs
    valeurs=wscript.stdin.readLine
    ' coloca-se em uma tabela
    lire_tableau=split(valeurs," ")
End Function

' -------- ecrire_tableau
Sub ecrire_tableau(byref T)
    ' exibe o conteúdo da tabela T
    wscript.echo join(T," ")
End Sub

' -------- trier_tableau
Sub trier_tableau (byref T)
    ' ordena a tabela T em ordem crescente

    ' procura-se o índice imax da tabela T[0..ifin]
    ' para trocar T[imax] pelo último elemento da matriz T[0..ifin]
    ' em seguida, repetimos o processo com uma matriz com um elemento a menos

    Dim ifin, imax, temp
    For ifin=ubound(T) To 1 Step -1
        ' buscamos o índice imax da matriz T[0..ifin]
        imax=chercher_max(T,ifin)
        ' trocamos o valor máximo pelo último elemento da matriz 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)
    ' buscamos o índice imax da matriz T[0..ifin]
    Dim i, imax
    imax=0
    For i=1 To ifin
        If cdbl(T(i))>cdbl(T(imax)) Then imax=i
    Next

    ' Retorna-se o resultado
    chercher_max=imax    
End Function

Resultados

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

Comentários:

o módulo échanger, que havia sido identificado no algoritmo inicial, não foi implementado aqui como um módulo em VBScript, pois foi considerado simples demais para ser objeto de um módulo específico.

5.5. O programa IMPOTS na forma modular

Retomamos o programa de cálculo do imposto, desta vez escrito em formato modular

Programa

' cálculo do imposto de um contribuinte
' o programa deve ser chamado com três parâmetros: casado, filhos, salário
' casado: caractere O se casado, N se solteiro
' filhos: número de filhos
' salário: salário anual sem os centavos

' declaração obrigatória das variáveis
Option Explicit
Dim erreur

' os argumentos são recuperados mediante verificação de sua validade
Dim marie, enfants, salaire
erreur=getArguments(marie,enfants,salaire)
' erro?
If erreur(0)<>0 Then wscript.echo erreur(1) : wscript.quit erreur(0)

' recuperam-se os dados necessários para o cálculo do imposto
Dim limites, coeffR, coeffN
getData limites,coeffR,coeffN

' exibe-se o resultado
wscript.echo "impôt=" & calculerImpot(marie,enfants,salaire,limites,coeffR,coeffN)

' encerra sem erros
wscript.quit 0

' ------------ funções e procedimentos

' ----------- getArguments
Function getArguments(byref marie, ByRef enfants, ByRef salaire)
    ' deve recuperar três valores passados como argumentos para o programa principal
    ' um argumento é transmitido ao programa sem espaços antes e depois
    ' serão utilizadas expressões regulares para verificar a validade dos dados

    ' retorna uma variante de tabela de erros com 2 valores
    ' erro(0): código de erro, 0 se não houver erro
    ' erro(1): mensagem de erro se houver erro; caso contrário, a string vazia

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

    ' verifica-se se há 3 argumentos
    Dim nbArguments
    nbArguments=wscript.arguments.count
    If nbArguments<>3 Then
        ' mensagem de erro
        getArguments= array(1,syntaxe & vbCRLF & vbCRLF & "erreur : nombre d'arguments incorrect")
        ' fim
        Exit Function
    End If

    Dim modele, correspondances
    Set modele=new regexp

    ' o estado civil deve estar entre os caracteres oOnN
    modele.pattern="^[oOnN]$"
    Set correspondances=modele.execute(wscript.arguments(0))
    If correspondances.count=0 Then
        ' mensagem de erro
        getArguments=array(2,syntaxe & vbCRLF & vbCRLF & "erreur : argument marie incorrect")
        ' saindo
        Exit Function
    End If
    ' recuperando o valor
    If lcase(wscript.arguments(0)) = "o"Then
        marie=true
    Else
        marie=false
    End If

    ' filhos deve ser um número inteiro >=0
    modele.pattern="^\d{1,2}$"
    Set correspondances=modele.execute(wscript.arguments(1))
    If correspondances.count=0 Then
        ' erro
        getArguments= array(3,syntaxe & vbCRLF & vbCRLF & "erreur : argument enfants incorrect")
        ' saindo
        Exit Function
    End If
    ' recuperando o valor
    enfants=cint(wscript.arguments(1))

    ' o salário deve ser um número inteiro >=0
    modele.pattern="^\d{1,9}$"
    Set correspondances=modele.execute(wscript.arguments(2))
    If correspondances.count=0 Then
        ' erro
        getArguments= array(4,syntaxe & vbCRLF & vbCRLF & "erreur : argument salaire incorrect")
        ' saindo
        Exit Function
    End If
    ' recuperando o valor
    salaire=clng(wscript.arguments(2))

    ' concluído sem erros
    getArguments=array(0,"")
End Function

' ----------- getData
Sub getData(byref limites, ByRef coeffR, ByRef coeffN)  
    ' definimos os dados necessários para o cálculo do imposto em 3 tabelas
    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)

    ' calcula-se o número de cotas
    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

    ' calcula-se o quociente familiar e a renda tributável
    Dim revenu, qf
    revenu=0.72*salaire
    qf=revenu/nbParts

    ' calcula-se o imposto
    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

Comentários

A função getArguments permite recuperar as informações (cônjuge, filhos, salário) do contribuinte. Aqui, elas são passadas como argumentos para o programa VBScript. Se isso fosse mudar, por exemplo, se esses argumentos viessem de uma interface gráfica, apenas o procedimento getArguments precisaria ser reescrito, e não os demais.
A função getArguments pode detectar erros nos argumentos. Quando isso ocorre, poderia ter-se decidido interromper a execução do programa na função getArguments por meio de uma instrução wscript.quit. Isso nunca deve ser feito em uma função ou procedimento. Se uma função ou procedimento detectar um erro, ele deve comunicá-lo de alguma forma ao programa chamador. Cabe a ele decidir se interrompe ou não a execução, e não ao procedimento. Em nosso exemplo, o programa chamador poderia decidir solicitar novamente ao usuário que digite o dado incorreto no teclado, em vez de interromper a execução.
Aqui, a função getArguments retorna uma variante do tipo tabela, em que o primeiro elemento é um código de erro (0 se não houver erro) e o segundo, uma mensagem de erro, caso tenha ocorrido algum erro. Ao testar o resultado obtido, o programa chamador pode saber se houve ou não um erro.
O procedimento getData permite obter os dados necessários para o cálculo do imposto. Aqui, esses dados são definidos diretamente no procedimento getData. Caso esses dados venham de outra fonte, como um arquivo ou um banco de dados, por exemplo, apenas o procedimento getData precisaria ser reescrito, e não os demais.
A função calculerImpot permite calcular o imposto assim que todos os dados forem obtidos, independentemente da forma como foram obtidos.
Observe-se, portanto, que uma programação modular permite a (re)utilização de certos módulos em diferentes contextos. Esse conceito foi amplamente desenvolvido nos últimos vinte anos no âmbito da programação orientada a objetos.