5. Las funciones y procedimientos

5.1. Las funciones predefinidas de VBScript

La riqueza de un lenguaje se deriva en gran parte de su biblioteca de funciones, las cuales pueden encapsularse en objetos bajo el nombre de métodos. En este sentido, se puede considerar que VBScript es bastante limitado.

La siguiente tabla enumera las funciones de VBScript que no forman parte de objetos. No las detallaremos aquí. Por lo general, su nombre da una idea de su función. El lector puede consultar la documentación para obtener detalles sobre una función en particular.

Abs	Array	Asc	Atn
CBool	CByte	CCur	CDate
CDbl	Chr	CInt	CLng
Conversiones	Cos	CreateObject	CSng
Fecha	DateAdd	DateDiff	DatePart
DateSerial	DateValue	Día	Matemáticas derivadas
Evaluación	Exp	Filtro	FormatCurrency
FormatDateTime	FormatNumber	FormatPercent	GetLocale
GetObject	GetRef	Hex	Hora
InputBox	InStr	InStrRev	Int, Fijos
IsArray	IsDate	IsEmpty	IsNull
IsNumeric	IsObject	Unir	LBound
LCase	Izquierda	Len	LoadPicture
Log	LTrim; RTrim; y molduras	Matemáticas	Mid
Minuto	Mes	MonthName	MsgBox
Ahora	Oct	Reemplazar	RGB
Derecha	Rnd	Redondo	ScriptEngine
ScriptEngineBuildVersion	ScriptEngineMajorVersion	ScriptEngineMinorVersion	Segundo
SetLocale	Fdo.	Sin	Espacio
Split	Sqr	StrComp	String
Beige	Time	Temporizador	TimeSerial
TimeValue	TypeName	UBound	UCase
VarType	Día de la semana	WeekdayName	Año

5.2. Programación modular

Describir la solución programada de un problema significa describir la secuencia de acciones elementales que puede ejecutar la computadora y que son capaces de resolver el problema. Dependiendo del lenguaje, estas operaciones elementales son más o menos sofisticadas. Por ejemplo:

leer datos del teclado o del disco
escribir datos en la pantalla, en una impresora, en un disco, etc.
calcular expresiones
desplazarse por un archivo
...

Describir un problema complejo puede requerir varios miles de estas instrucciones elementales o incluso más. Por lo tanto, resulta muy difícil para la mente humana tener una visión global de un programa. Ante esta dificultad para comprender el problema en su totalidad, lo descomponemos en subproblemas más fáciles de resolver. Consideremos el siguiente problema: ordenar una lista de valores numéricos ingresados con el teclado y mostrar la lista ordenada en la pantalla.

En un primer momento, podemos describir la solución de la siguiente manera:

  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

Hemos dividido el problema en tres subproblemas, más fáciles de resolver. La notación algorítmica suele ser más formal que la anterior, por lo que el algoritmo se escribirá más bien así:

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

donde T representa una matriz. Las operaciones

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

son operaciones no elementales que, a su vez, deben describirse mediante operaciones elementales. Esto se lleva a cabo en lo que se conoce como módulos. El dato T se denomina parámetro del módulo. Se trata de información que el programa que realiza la llamada pasa al módulo llamado (parámetro de entrada) o recibe del módulo llamado (parámetro de salida). Los parámetros de un módulo son, por lo tanto, la información que se intercambia entre el programa que llama y el módulo llamado.

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

El módulo lire_tableau(T) podría describirse de la siguiente manera:


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

Aquí hemos descrito con suficiente detalle el módulo lire_tableau. De hecho, las tres acciones necesarias tienen una traducción inmediata a VBScript. La última requerirá el uso de la función split. Si VBScript no contara con esta función, la acción 3 debería descomponerse a su vez en acciones elementales que tuvieran un equivalente inmediato en VBScript.

El módulo écrire_tableau(T) podría describirse de la siguiente manera:


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

El módulo écrire_tableau(T) podría describirse de la siguiente manera (suponiendo que los índices de los elementos de T comienzan en 0):

début
      N<-- indice dernier élément du tableau T
      pour IFIN variant de N à 1
      faire
           //se busca el índice IMAX del elemento más grande de T
           // IFIN es el índice del último elemento de T

          chercher_max(T, IFIN, IMAX) 

           // se intercambia el elemento más grande de T con el último elemento de T

          échanger (T, IMAX, IFIN)

      finfaire
FIN

Aquí el algoritmo vuelve a utilizar acciones no elementales:


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

chercher_max(T, IFIN, IMAX) devuelve el índice IMAX del elemento más grande de la tabla T, cuyo índice del último elemento es IFIN.

intercambiar(T, IMAX, IFIN) intercambia dos elementos del array T, los de índice IMAX y IFIN.

Por lo tanto, es necesario describir las nuevas operaciones no elementales.

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

El problema inicial se ha descrito completamente mediante operaciones elementales de VBScript y, por lo tanto, ahora puede traducirse a este lenguaje. Cabe señalar que las acciones elementales pueden variar de un lenguaje a otro y que, por lo tanto, el análisis de un problema debe, en algún momento, tomar en cuenta el lenguaje de programación utilizado. Un objeto que existe en un lenguaje puede no existir en otro y, por lo tanto, modificar el algoritmo utilizado. Así, si un lenguaje contara con una función de ordenación, sería absurdo no utilizarla en este caso.

El principio que se aplica aquí es el denominado «análisis descendente». Si representamos la estructura básica de la solución, obtenemos lo siguiente:

Tenemos una estructura de árbol.

5.3. Las funciones y procedimientos de VBScript

Una vez realizado el análisis modular, el programador puede traducir los módulos de su algoritmo a VBScript, como fonctions o procédures. Tanto fonctions como procédures admiten parámetros de entrada y salida, pero fonction devuelve un resultado que permite su uso en expresiones, mientras que procédure no lo devuelve.

5.3.1. Declaración de funciones y procedimientos de VBScript

La declaración de un procedimiento de VBScript es la siguiente

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

y la de una función

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

Para devolver su resultado, la función debe incluir una instrucción que asigne el resultado a una variable con el nombre de la función:

nombreFunción=resultado

La ejecución de una función o procedimiento se detiene de dos maneras:

al llegar a la instrucción de fin de función (end function) o fin de procedimiento (end sub)
al encontrar la instrucción de salida de la función (exit function) o del procedimiento (exit sub)

En el caso de la función, hay que recordar que el resultado debe haberse asignado a una variable con el nombre de la función antes de que esta termine con un «end function» o «exit function».

5.3.2. Modos de paso de parámetros de una función o procedimiento

En la declaración de los parámetros de entrada y salida de una función o procedimiento, se especifica el modo (byRef, byVal) de transmisión del parámetro del programa que llama al programa llamado:

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

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

Cuando no se especifica el modo de transmisión byRef o byVal, se utiliza el modo byRef.

Parámetros efectivos, parámetros formales

Sea una función de VBScript definida por

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

Los parámetros parmamFormi utilizados en la definición de la función o del procedimiento se denominan parámetros formales. La función anterior se podrá utilizar desde el programa principal o desde otro módulo mediante una instrucción del tipo:

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

Los parámetros parmamEffi utilizados en la llamada a la función o al procedimiento se denominan parámetros efectivos. Cuando comienza la ejecución de la función nomFonction, los parámetros formales reciben los valores de los parámetros efectivos correspondientes. Las palabras clave byRef y byVal determinan el modo de transmisión de estos valores.

Modo de transmisión por valor (byVal)

Cuando un parámetro formal especifica este modo de transmisión, el parámetro formal y el parámetro efectivo son dos variables diferentes. El valor del parámetro efectivo se copia en el parámetro formal antes de que se ejecute la función o el procedimiento. Si este modifica el valor del parámetro formal durante su ejecución, ello no altera en absoluto el valor del parámetro efectivo correspondiente. Este modo de transmisión es adecuado para los parámetros de entrada de la función o del procedimiento.

Modo de transmisión por referencia (byRef)

Este modo de transmisión es el predeterminado si no se especifica ningún modo de transmisión del parámetro. Cuando un parámetro formal especifica este modo de transmisión, el parámetro formal y el parámetro efectivo correspondiente son una misma variable. Por lo tanto, si la función modifica el parámetro formal, el parámetro efectivo también se modifica. Este modo de transmisión es adecuado para:

los parámetros de salida, ya que su valor debe transmitirse al programa que realiza la llamada
a los parámetros de entrada que resultan costosos de copiar, como las tablas

El siguiente programa muestra ejemplos de paso de parámetros:

Programa


Sub proc1(byval i, ByRef j, k)
  ' i se pasa por valor (byval); por lo tanto, el parámetro efectivo y el parámetro formal son diferentes
  ' j se pasa por valor (byref); por lo tanto, el parámetro efectivo y el parámetro formal son idénticos
  ' no se especifica el modo de paso de k. Por defecto, es por referencia
  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)
  ' muestra los valores de i, j y k
  wscript.echo msg & " i=" & i & " j=" & j & " k=" & k
End Sub


' ------------- llamadas a funciones y procedimientos

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

' verificación
  affiche "dans programme principal, avant l'appel à proc1 :",i,j,k

' llamada al procedimiento proc1
  proc1 i,j,k

' verificación
  affiche "dans programme principal, après l'appel à proc1 :",i,j,k

' fin
  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

Comentarios

En un script de VBScript, no hay un lugar específico para las funciones y los procedimientos. Pueden aparecer en cualquier parte del texto fuente. Por lo general, se agrupan al principio o al final y se procura que el programa principal forme un bloque continuo.

5.3.3. Sintaxis para llamar a funciones y procedimientos

Supongamos un procedimiento p que admite los parámetros formales pf1, pf2, ...

la llamada al procedimiento p se realiza de la forma

p pe1, pe2, ...

sin paréntesis alrededor de los parámetros

si el procedimiento p no admite ningún parámetro, se puede utilizar indistintamente la llamada p o p() y la declaración sub p o sub p()

Sea una función f que admite parámetros formales pf1, pf2, ...

la llamada a la función f se realiza de la forma

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

Los paréntesis que rodean los parámetros son obligatorios. Si la función f no admite ningún parámetro, se puede utilizar indistintamente la llamada f o f() y la declaración function f o function f().

El programa que realiza la llamada puede ignorar el resultado de la función f. En ese caso, la función f se considera un procedimiento y sigue las reglas de llamada de los procedimientos. Entonces, se escribe f pe1, pe2, ... (sin paréntesis) para llamar a la función f.

Si la función o el procedimiento es un método de objeto, parece que las reglas son un poco diferentes y no son uniformes.

Así, se puede escribir MyFile.WriteLine «Esto es una prueba.» o MyFile.WriteLine(«Esto es una prueba.»)
pero si se puede escribir wscript.echo 4, no se puede escribir wscript.echo(4).

Nos regiremos por las siguientes reglas:

no se deben usar paréntesis alrededor de los parámetros de un procedimiento o de una función utilizada como procedimiento
paréntesis alrededor de los parámetros de una función

5.3.4. Algunos ejemplos de funciones

A continuación se presentan algunos ejemplos de definiciones y usos de funciones:

Programa


 Function plusgrandque(byval i, ByVal j)
  ' devuelve el valor booleano verdadero si i > j; de lo contrario, falso

  ' verificación de datos
  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)
  ' devuelve una matriz de n elementos
  tableau=array()
  ' verifica la validez del 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
  ' se devuelve el resultado
  rendUnTableau=tableau
End Function

 Function argumentsVariables(byref arguments)
  ' los argumentos son una matriz de números de la que se devuelve la suma
  somme=0
  For i=0 To ubound(arguments)
    somme=somme+arguments(i)
  Next
  argumentsVariables=somme
End Function

  ' dos funciones sin parámetros declaradas de dos maneras diferentes
  Function sansParametres1
    sansParametres=4
  End Function

  Function sansParametres2()
    sansParametres=4
  End Function

  
' ------------- llamadas a funciones y procedimientos

' llamadas a la función «mayorQue»
  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")

' llamadas a la función 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

' llamadas a la función argumentsVariables
  wscript.echo "somme=" & argumentsVariables(array(-1,2,7,8))
  wscript.echo "somme=" & argumentsVariables(array(-1,10,12))

' llamadas a funciones sin parámetros
  res=sansParametres1
  res=sansParametres1()
  sansParametres1
  sansParametres1()

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

' fin
  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

Comentarios

La función rendUnTableau demuestra que una función puede devolver varios resultados y no solo uno. Basta con que los coloque en un variante de tipo tabla y que devuelva esa variante como resultado.
Por el contrario, la función argumentsVariables muestra que se puede escribir una función que admita un número variable de argumentos. También en este caso basta con colocarlos en una variante de tipo matriz y convertir esa variante en un parámetro de la función.

5.3.5. Parámetro de salida o resultado de una función

Supongamos que el análisis de una aplicación ha revelado la necesidad de un módulo M con parámetros de entrada Ei y parámetros de salida Sj. Recordemos que los parámetros de entrada son información que el programa que llama proporciona al programa llamado y que, a la inversa, los parámetros de salida son información que el programa llamado proporciona al programa que llama. En VBScript existen varias soluciones para los parámetros de salida:

si solo hay un parámetro de salida, se puede convertir en el resultado de una función. En ese caso, ya no hay un parámetro de salida, sino simplemente un resultado de función.
Si hay n parámetros de salida, uno de ellos puede servir como resultado de una función, mientras que los n-1 restantes siguen siendo parámetros de salida. También se puede optar por no utilizar una función, sino un procedimiento con n parámetros de salida. Asimismo, se puede utilizar una función que devuelva una matriz en la que se hayan colocado los n valores que se deben devolver al programa que realiza la llamada. Cabe recordar que el programa llamado devuelve sus resultados al programa que lo llama mediante copia de valores. Esta copia se evita en el caso de los parámetros de salida pasados por referencia. Por lo tanto, en esta última solución se ahorra tiempo.

5.4. El programa VBScript para ordenar valores

Habíamos iniciado la discusión sobre la programación modular con el estudio algorítmico de una ordenación de valores numéricos ingresados desde el teclado. A continuación se presenta la traducción VBScript que podría realizarse:

Programa

' programa principal
Option Explicit

Dim T        ' le tableau de valeurs à trier

' lectura de valores
T=lire_tableau

' ordenación de valores
trier_tableau T

' visualización de los valores ordenados
ecrire_tableau T

' fin
wscript.quit 0

' ---------- funciones y procedimientos

' -------- lire_tableau
Function lire_tableau
    ' se solicitan los valores
    wscript.stdout.write "Tapez les valeurs à trier sous la forme val1 val2  ... valn : "
    ' se leen
    Dim valeurs
    valeurs=wscript.stdin.readLine
    ' se colocan en una tabla
    lire_tableau=split(valeurs," ")
End Function

' -------- ecrire_tableau
Sub ecrire_tableau(byref T)
    ' muestra el contenido de la tabla T
    wscript.echo join(T," ")
End Sub

' -------- trier_tableau
Sub trier_tableau (byref T)
    ' ordena la tabla T en orden creciente

    ' se busca el índice imax de la tabla T[0..ifin]
    ' para intercambiar T[imax] con el último elemento de la tabla T[0..ifin]
    ' luego se vuelve a empezar con una matriz que tiene un elemento menos

    Dim ifin, imax, temp
    For ifin=ubound(T) To 1 Step -1
        ' buscamos el índice imax de la matriz T[0..ifin]
        imax=chercher_max(T,ifin)
        ' intercambiamos el valor máximo con el último elemento de la 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 el índice imax de la 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

    ' Se devuelve el 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

Comentarios:

El módulo échanger, que se había identificado en el algoritmo inicial, no se convirtió aquí en un módulo de VBScript porque se consideró demasiado simple como para ser objeto de un módulo específico.

5.5. El programa IMPOTS en formato modular

Retomamos el programa de cálculo de impuestos, escrito esta vez en formato modular

Programa

' cálculo del impuesto de un contribuyente
' El programa debe ejecutarse con tres parámetros: casado, hijos, salario
' casado: letra O si está casado, N si no lo está
' hijos: número de hijos
' salario: salario anual sin centavos

' declaración obligatoria de las variables
Option Explicit
Dim erreur

' se recuperan los argumentos verificando su validez
Dim marie, enfants, salaire
erreur=getArguments(marie,enfants,salaire)
' ¿Error?
If erreur(0)<>0 Then wscript.echo erreur(1) : wscript.quit erreur(0)

' se obtienen los datos necesarios para calcular el impuesto
Dim limites, coeffR, coeffN
getData limites,coeffR,coeffN

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

' se sale sin errores
wscript.quit 0

' ------------ funciones y procedimientos

' ----------- getArguments
Function getArguments(byref marie, ByRef enfants, ByRef salaire)
    ' debe recuperar tres valores pasados como argumentos al programa principal
    ' un argumento se transmite al programa sin espacios ni al principio ni al final
    ' se utilizarán expresiones regulares para verificar la validez de los datos

    ' devuelve una variante de tipo matriz de error con 2 valores
    ' error(0): código de error, 0 si no hay error
    ' error(1): mensaje de error si hay error; de lo contrario, la cadena vacía

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

    ' se verifica que haya 3 argumentos
    Dim nbArguments
    nbArguments=wscript.arguments.count
    If nbArguments<>3 Then
        ' mensaje de error
        getArguments= array(1,syntaxe & vbCRLF & vbCRLF & "erreur : nombre d'arguments incorrect")
        ' fin
        Exit Function
    End If

    Dim modele, correspondances
    Set modele=new regexp

    ' el estado civil debe estar entre los caracteres oOnN
    modele.pattern="^[oOnN]$"
    Set correspondances=modele.execute(wscript.arguments(0))
    If correspondances.count=0 Then
        ' mensaje de error
        getArguments=array(2,syntaxe & vbCRLF & vbCRLF & "erreur : argument marie incorrect")
        ' salimos
        Exit Function
    End If
    ' se recupera el valor
    If lcase(wscript.arguments(0)) = "o"Then
        marie=true
    Else
        marie=false
    End If

    ' «hijos» debe ser un número entero >=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")
        ' saliendo
        Exit Function
    End If
    ' se recupera el valor
    enfants=cint(wscript.arguments(1))

    ' el salario debe ser un número entero >=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")
        ' salimos
        Exit Function
    End If
    ' se recupera el valor
    salaire=clng(wscript.arguments(2))

    ' Se completó sin errores
    getArguments=array(0,"")
End Function

' ----------- getData
Sub getData(byref limites, ByRef coeffR, ByRef coeffN)  
    ' se definen los datos necesarios para el cálculo del impuesto en 3 tablas
    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)

    ' se calcula el número de cuotas
    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

    ' se calcula el coeficiente familiar y el ingreso imponible
    Dim revenu, qf
    revenu=0.72*salaire
    qf=revenu/nbParts

    ' se calcula el impuesto
    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

Comentarios

La función getArguments permite recuperar la información (esposa, hijos, salario) del contribuyente. Aquí, esta información se pasa como argumentos al programa VBScript. Si esto cambiara, por ejemplo, si estos argumentos provinieran de una interfaz gráfica, solo habría que reescribir el procedimiento getArguments y no los demás.
La función getArguments puede detectar errores en los argumentos. Cuando esto ocurre, se podría haber decidido detener la ejecución del programa en la función getArguments mediante una instrucción wscript.quit. Esto nunca debe hacerse dentro de una función o procedimiento. Si una función o procedimiento detecta un error, debe notificárselo de alguna manera al programa que lo llama. Es este último quien debe decidir si detiene la ejecución o no, no el procedimiento. En nuestro ejemplo, el programa que llama podría decidir pedirle nuevamente al usuario que vuelva a ingresar el dato erróneo desde el teclado en lugar de detener la ejecución.
Aquí, la función getArguments devuelve una variante de tipo tabla en la que el primer elemento es un código de error (0 si no hay error) y el segundo, un mensaje de error si se ha producido un error. Al verificar el resultado obtenido, el programa que realiza la llamada puede determinar si se ha producido un error o no.
El procedimiento getData permite obtener los datos necesarios para el cálculo del impuesto. Aquí se definen directamente en el procedimiento getData. Si estos datos provinieran de otra fuente, como un archivo o una base de datos, por ejemplo, solo habría que reescribir el procedimiento getData y no los demás.
La función calculerImpot permite calcular el impuesto una vez que se han obtenido todos los datos, independientemente de la forma en que se hayan obtenido.
Cabe destacar, por lo tanto, que una programación modular permite la (re)utilización de ciertos módulos en diferentes contextos. Este concepto se ha desarrollado ampliamente en los últimos veinte años en el marco del concepto de objeto.