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 aspecto, se puede considerar que VBScript es bastante pobre.

La siguiente tabla define las funciones de VBScript fuera de los objetos. No las detallaremos. Su nombre suele ser indicativo de su función. El lector consultará la documentación para obtener detalles sobre una función concreta.

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
Eval	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 Trims	Matemáticas	Mid
Minuto	Mes	MonthName	MsgBox
Ahora	Oct	Reemplazar	RGB
Derecha	Rnd	Redondo	ScriptEngine
ScriptEngineBuildVersion	ScriptEngineMajorVersion	ScriptEngineMinorVersion	Segundo
SetLocale	Fdo	Sin	Espacio
División	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 es describir la secuencia de acciones elementales que puede ejecutar el ordenador y que son capaces de resolver el problema. Dependiendo del lenguaje, estas operaciones elementales son más o menos sofisticadas. Por ejemplo:

• leer un dato procedente del teclado o del disco
• escribir datos en la pantalla, en la impresora, en el 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 introducidos con el teclado y mostrar la lista ordenada en pantalla.

En un primer momento, podemos describir la solución de la siguiente 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

Hemos desglosado el problema en tres subproblemas, más fáciles de resolver. La escritura algorítmica suele ser más formalizada que la anterior y 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 denomina módulos. El dato T se denomina parámetro del módulo. Se trata de información que el programa llamante 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 llamante 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 directa 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 desglosarse a su vez en acciones elementales que tuvieran un equivalente directo 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 matriz T cuyo índice del último elemento es IFIN.

intercambiar(T, IMAX, IFIN) intercambia dos elementos de la matriz 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 diferir de un lenguaje a otro y que, por lo tanto, el análisis de un problema debe tener en cuenta en algún momento 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 tuviera una función de ordenación, sería absurdo no utilizarla en este caso.

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

Tenemos una estructura en á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 fonctions o procédures. Tanto fonctions como procédures admiten parámetros de entrada/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 VBScript

La declaración de un procedimiento 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 de asignación del resultado a una variable que lleve el nombre de la función:

nombreFunción=resultado

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

1. al llegar a la instrucción de fin de función (end function) o fin de procedimiento (end sub)
2. al encontrar la instrucción de salida de función (exit function) o de 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-salida de una función o procedimiento, se especifica el modo (byRef, byVal) de transmisión del parámetro del programa llamante 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

Supongamos una función 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 entonces dos variables diferentes. El valor del parámetro efectivo se copia en el parámetro formal antes de la ejecución de la función o el procedimiento. Si esta modifica el valor del parámetro formal durante su ejecución, ello no modifica 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 el procedimiento.

Modo de transmisión por referencia (byRef)

Este modo de transmisión es el modo predeterminado si no se indica 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. Así, 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); en este caso, el parámetro efectivo y el parámetro formal son idénticos
  ' el modo de paso de k no está especificado. 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 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 constituya un bloque continuo.

5.3.3. Sintaxis de llamada a funciones y procedimientos

Sea 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 alrededor de 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 resultado de la función f puede ser ignorado por el programa que la llama. La función f se considera entonces un procedimiento y sigue las reglas de llamada de los procedimientos. Se escribe entonces 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 algo diferentes y no homogéneas.

• 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 ceñiremos a las siguientes reglas:

• no se utilizarán 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 muestran algunos ejemplos de definiciones y usos de funciones:

Programa

 Function plusgrandque(byval i, ByVal j)
  ' devuelve el valor booleano verdadero si i>j, falso en caso contrario

  ' 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()
  ' verificación de 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 formas 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 muestra que una función puede devolver varios resultados y no solo uno. Basta con que los coloque en una variable de tipo matriz y devuelva dicha variable 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 variable de tipo matriz y convertir dicha variable 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 puesto de manifiesto 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 llamante proporciona al programa llamado y que, a la inversa, los parámetros de salida son información que el programa llamado proporciona al programa llamante. 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. Entonces 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 la función, mientras que los otros n-1 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 llamante. Recordemos que el programa llamado devuelve sus resultados al programa llamante 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 de ordenación de valores

Comenzamos el debate sobre la programación modular con el estudio algorítmico de una ordenación de valores numéricos introducidos mediante el teclado. He aquí la traducción VBScript que podría hacerse:

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 matriz
    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 ascendente

     ' se busca el índice imax de la tabla T[0..ifin]
     ' para intercambiar T[imax] con el último elemento de la matriz 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 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 ha convertido aquí en un módulo en VBScript porque se consideró demasiado simple para ser objeto de un módulo específico.

5.5. El programa IMPOTS en forma 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 llamarse con tres parámetros: casado, hijos, salario
' casado: carácter O si está casado, N si no lo está
' hijos: número de hijos
' salario: salario anual sin céntimos

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

' se recuperan los argumentos comprobando 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 recuperan los datos necesarios para el cálculo del 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 argumento al programa principal
     ' un argumento se transmite al programa sin espacios delante ni detrás
     ' se utilizarán expresiones regulares para verificar la validez de los datos

     ' devuelve una variable 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 un error; de lo contrario, 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 comprueba 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")
         ' salir
        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 ha completado 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 participaciones
    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 la base 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. En este caso, dicha información se pasa como argumentos al programa VBScript. Si esto cambiara, por ejemplo, si estos argumentos procedieran 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 en una función o procedimiento. Si una función o procedimiento detecta un error, debe notificárselo de alguna forma al programa que lo invoca. Es este último quien debe decidir si detiene la ejecución o no, no el procedimiento. En nuestro ejemplo, el programa que invoca podría decidir pedir al usuario que vuelva a introducir el dato erróneo mediante el teclado en lugar de detener la ejecución.
• Aquí, la función getArguments devuelve una variable de tipo matriz 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 comprobar el resultado obtenido, el programa que realiza la llamada puede saber 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 procedieran 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 señalar, por tanto, que una escritura modular permite la (re)utilización de ciertos módulos en diferentes contextos. Este concepto se ha desarrollado considerablemente en los últimos veinte años en el marco del concepto de objeto.