5. Funciones y procedimientos

5.1. Funciones predefinidas de vbscript

La riqueza de un lenguaje deriva en gran medida de su biblioteca de funciones, que pueden encapsularse en objetos conocidos como métodos. En este sentido, vbscript puede considerarse bastante pobre.

La siguiente tabla define las funciones no objeto de VBScript. No entraremos aquí en detalles. Su nombre es generalmente una indicación de su función. El lector debe consultar la documentación para conocer los detalles de una función en particular.

Abs	Array	Asc	En
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, Arreglos
IsArray	IsDate	IsEmpty	IsNull
IsNumeric	IsObject	Join	LBound
LCase	Izquierda	Len	LoadPicture
Registro	LTrim; RTrim; y Embellecedores	Matemáticas	Medio
Minuto	Mes	MonthName	MsgBox
Ahora	Octubre	Replace	RGB
Derecha	Rnd	Redondo	ScriptEngine
ScriptEngineBuildVersion	ScriptEngineMajorVersion	ScriptEngineMinorVersion	Segundo
SetLocale	Sgn	Sin	Espacio
Split	Sqr	StrComp	String
Tan	Tiempo	Temporizador	TimeSerial
TimeValue	TypeName	UBound	UCase
VarType	Entre semana	WeekdayName	Año

5.2. Programación modular

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

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

Describir un problema complejo puede requerir varios miles de estas instrucciones elementales y mucho más. Por lo tanto, es muy difícil para la mente humana tener una visión global de un programa. Dada esta dificultad para captar el problema en su conjunto, lo descomponemos en subproblemas más sencillos de resolver. Consideremos el siguiente problema: Ordenar una lista de valores numéricos escritos en el teclado y mostrar la lista ordenada en la pantalla.

Inicialmente, la solución puede describirse del siguiente modo:

  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

El problema se ha descompuesto en 3 subproblemas, más sencillos de resolver. La redacción algorítmica suele ser más formalizada que la anterior y el algoritmo se escribe como sigue:

   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 hace en lo que se conoce como módulos. Los datos T se denominan parámetros de módulo. Se trata de información que el programa llamante pasa al módulo llamado (parámetro de entrada) o recibe de éste (parámetro de salida). Los parámetros de un módulo son, por tanto, la información intercambiada entre el programa que llama y el módulo llamado.

módulo lire_tableau(T)
módulo trier_tableau(T)
módulo escribir_tabla(T)

El módulo lire_tableau(T) podría describirse del siguiente modo:

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 suficientemente la lire_tableau. Las tres acciones requeridas se traducen inmediatamente a vbscript. La última acción requiere el uso de la función split. Si vbscript no dispusiera de esta función, la acción 3 tendría que descomponerse en acciones elementales con un equivalente vbscript inmediato.

El módulo de escritura_tableau(T) podría describirse del siguiente modo:

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

El módulo de escritura_tableau(T) podría describirse del siguiente modo (se supone que los índices de los elementos de T empiezan en 0):

début
      N<-- indice dernier élément du tableau T
      pour IFIN variant de N à 1
      faire
          //on recherche l'indice IMAX du plus gd élément de T
          // IFIN est l'indice du dernier élément de T

          chercher_max(T, IFIN, IMAX) 

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

          échanger (T, IMAX, IFIN)

      finfaire
FIN

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 mayor de la matriz T cuyo último índice de elemento es IFIN.

exchange(T, IMAX, IFIN) intercambia 2 elementos de la tabla T , los de índice IMAX y IFIN.

Por 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 exchange(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 ahora puede traducirse a este lenguaje. Hay que tener en cuenta que las acciones elementales pueden diferir de un lenguaje a otro y que, por 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, lo que modifica el algoritmo utilizado. Por ejemplo, si un lenguaje dispone de una función de ordenación, sería absurdo no utilizarla.

El principio aplicado aquí es el de análisis descendente. Si representamos la columna vertebral de la solución, tenemos lo siguiente:

Tenemos una estructura de árbol.

5.3. Funciones y procedimientos vbscript

Una vez realizado el análisis modular, el programador puede traducir los módulos de su algoritmo en funciones o procedimientos vbscript. Visite funciones y procedimientos ambos admiten parámetros de entrada/salida, pero el función devuelve un resultado que puede utilizarse en expresiones, mientras que la función procedimiento no devuelve nada.

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 para asignar el resultado a una variable que lleve el nombre de la función:

nomFonction=résultat

Existen dos formas de detener la ejecución de una función o procedimiento:

al final de la instrucción de función (fin function) o fin de procedimiento (fin sub)
para cumplir la instrucción de salida de la función (exit function) o procedimiento (salir de sub)

Para la función, recuerde que el resultado debe haberse asignado a una variable que lleve el nombre de la función antes de que ésta termine con un fin function o exit function.

5.3.2. Cómo pasar los parámetros de una función o procedimiento

Al declarar los parámetros de entrada-salida de una función o procedimiento, se especifica el modo (byRef,byVal) para transmitir el 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 el modo de transmisión byRef o byVal no se especifica el modo byRef se utiliza.

Parámetros efectivos, parámetros formales

Sea 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 procedimiento se denominan parámetros formales. La función anterior puede utilizarse desde el programa principal o desde otro módulo utilizando una instrucción como :

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

Los parámetros parmamEffi utilizados en la llamada a la función o procedimiento se denominan parámetros efectivos. Cuando se ejecuta el nomFonction los parámetros formales reciben los valores de los parámetros efectivos correspondientes. Las palabras clave byRef y byVal establecen cómo deben transmitirse 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 la función o el procedimiento modifican el valor del parámetro formal durante la ejecución, esto no modifica el valor del parámetro efectivo correspondiente. Este modo de transmisión se adapta bien a los parámetros de entrada de la función o el procedimiento.

Modo de transmisión de referencia (byRef)

Este modo de transmisión es el modo por defecto si no se especifica ningún modo de transmisión de parámetros. Cuando un parámetro formal especifica este modo de transmisión, el parámetro formal y el parámetro efectivo correspondiente son la misma variable. Así, si la función modifica el parámetro formal, también se modifica el parámetro efectivo. Este método de transmisión es muy adecuado para :

parámetros de salida, ya que sus valores deben transmitirse al programa de llamada
a los parámetros de entrada cuya copia es costosa, como las tablas

El siguiente programa muestra ejemplos de cómo pasar parámetros:

Programa

Sub proc1(byval i, ByRef j, k)
  ' i se pasa por valor (byval) - el parámetro efectivo y el parámetro formal son entonces diferentes
  ' j se pasa por valor (byref) - el parámetro efectivo y el parámetro formal son entonces idénticos
  ' no se especifica la forma de pasar 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 y j y k
  wscript.echo msg & " i=" & i & " j=" & j & " k=" & k
End Sub


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

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

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

' llamar procedimiento proc1
  proc1 i,j,k

' consulte
  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 vbscript script, no hay un lugar especial para las funciones y procedimientos. Pueden estar en cualquier parte del texto fuente. En general, se agrupan al principio o al final, para que el programa principal forme un bloque continuo.

5.3.3. Sintaxis de llamada a funciones y procedimientos

Sea p un procedimiento con parámetros formales pf1, pf2, ...

se llama al procedimiento p de la forma

p pe1, pe2, ...

sin corchetes alrededor de los parámetros

si el procedimiento p no tiene parámetros, puede utilizar la llamada p o p() y la declaración sub p o sub p()

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

la función f se llama de la forma

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

los paréntesis alrededor de los parámetros son obligatorios. Si la función f no tiene parámetros, puede utilizar 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 llama. La función f se considera entonces un procedimiento y sigue las reglas de llamada a procedimientos. Escribimos f pe1, pe2, ... (sin paréntesis) para llamar a la función f.

Si la función o procedimiento es un método de objeto, parece que las normas son algo diferentes e incoherentes.

por lo que podemos escribir MyFile.WriteLine "Esto es una prueba." o MyFile.WriteLine("Esto es una prueba.")
pero si podemos escribir wscript.echo 4no podemos escribir wscript.echo(4).

Se aplican las siguientes normas:

sin 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 ofrecen algunos ejemplos de definiciones y usos de las funciones:

Programa

Function plusgrandque(byval i, ByVal j)
  ' devuelve boolean true si i>j, boolean false 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)
  ' forma una matriz de n elementos
  tableau=array()
  ' comprobar 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
  ' devolvemos el resultado
  rendUnTableau=tableau
End Function

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

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

  Function sansParametres2()
    sansParametres=4
  End Function


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

' llama a una función mayor
  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 sólo uno. Todo lo que tiene que hacer es colocarlos en una variante del array y devolver esta variante como resultado.
a la inversa, el argumentsVariables muestra que se puede escribir una función que tome un número variable de argumentos. Una vez más, todo lo que tienes que hacer es ponerlos en una matriz de variantes y hacer de esta variante 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 mostrado 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 da al programa llamado y que, a la inversa, los parámetros de salida son información que el programa llamado da al programa llamante. En vbscript hay varias soluciones para los parámetros de salida:

si sólo hay un parámetro de salida, puede ser el resultado de una función. En este caso, ya no hay un parámetro de salida, sino simplemente el resultado de una función.
si hay n parámetros de salida, uno de ellos se puede utilizar como resultado de una función, los otros n-1 parámetros de salida restantes. También se puede utilizar un procedimiento con n parámetros de salida en lugar de una función. También puede utilizar una función que devuelve una matriz en la que ha colocado los n valores que se devolverán al programa que llama. Recuerde que el programa llamado devuelve sus resultados al programa llamante copiando los valores. Esto se evita en el caso de parámetros de salida pasados por referencia. Por lo tanto, esta última solución ahorra tiempo.

5.4. El programa Vbscript para ordenar valores

Comenzamos nuestro debate sobre la programación modular con un estudio algorítmico de la ordenación de valores numéricos escritos con el teclado. He aquí la traducción VBScripto que podría hacerse de él:

Programa

' programa principal
Option Explicit

Dim T        ' la tabla de valores a ordenar

' valores de lectura
T=lire_tableau

' clasificación por valores
trier_tableau T

' visualización de valores ordenados
ecrire_tableau T

' fin
wscript.quit 0

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

' -------- lire_tableau
Function lire_tableau
    ' pedimos los valores
    wscript.stdout.write "Tapez les valeurs à trier sous la forme val1 val2  ... valn : "
    ' los leemos
    Dim valeurs
    valeurs=wscript.stdin.readLine
    ' ponerlos 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 ascendente

    ' encontrar el índice imax de la matriz T[0..ifin]
    ' para intercambiar T[imax] con el último elemento de la matriz T[0..ifin]
    ' a continuación, empezar de nuevo con una matriz con 1 elemento menos

    Dim ifin, imax, temp
    For ifin=ubound(T) To 1 Step -1
        ' encontrar el índice imax de la matriz T[0..ifin]
        imax=chercher_max(T,ifin)
        ' intercambiar 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)
    ' encontrar 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 intercambiar que se había identificado en el algoritmo inicial no ha sido objeto aquí de un módulo vbscript porque se consideró demasiado simple para ser objeto de un módulo específico.

5.5. El programa IMPOTS en forma modular

Tomemos de nuevo el programa de cálculo de impuestos, esta vez escrito en forma modular

Programa

' cálculo de la deuda tributaria del contribuyente
' el programa debe llamarse con tres parámetros: salario de los hijos casados
' casado: carácter Y si está casado, N si no lo está
' hijos: número de hijos
' salario: salario anual sin céntimos

' declaración obligatoria de variables
Option Explicit
Dim erreur

' recuperar los argumentos y comprobar 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)

' recuperamos los datos necesarios para calcular los impuestos
Dim limites, coeffR, coeffN
getData limites,coeffR,coeffN

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

' salimos sin error
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 pasa al programa sin espacios delante y detrás de él
    ' se utilizarán expresiones regulares para comprobar la validez de los datos

    ' devuelve una variante de 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, en caso 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)"

    ' comprobamos que hay 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 ser uno de 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")
        ' nos vamos
        Exit Function
    End If
    ' el valor
    If lcase(wscript.arguments(0)) = "o"Then
        marie=true
    Else
        marie=false
    End If

    ' children debe ser un 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")
        ' nos vamos
        Exit Function
    End If
    ' 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")
        ' nos vamos
        Exit Function
    End If
    ' el valor
    salaire=clng(wscript.arguments(2))

    ' terminado sin error
    getArguments=array(0,"")
End Function

' ----------- getData
Sub getData(byref limites, ByRef coeffR, ByRef coeffN)  
    ' definimos los datos necesarios para calcular el 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 acciones
    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

    ' calculamos la cuota 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 recuperar información (matrimonio, hijos, salario) del contribuyente. Aquí, se pasan como argumentos al programa vbscript. Si esto cambiara, por ejemplo, si estos argumentos procedieran de una interfaz gráfica, sólo el getArguments y no los demás.
la función getArguments puede detectar errores de argumento. Cuando esto ocurre, podríamos haber decidido detener la ejecución del programa en la función getArguments con un wscript.quit. Esto nunca debe hacerse en una función o procedimiento. Si una función o procedimiento detecta un error, debe señalarlo de alguna manera al programa que llama. Es el programa invocador el que debe decidir si detiene o no la ejecución, no el procedimiento. En nuestro ejemplo, el programa de llamada podría decidir pedir al usuario que vuelva a escribir los datos erróneos en el teclado en lugar de detener la ejecución.
aquí, el getArguments devuelve una matriz de variantes donde 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. Comprobando el resultado obtenido, el programa llamante puede determinar si se ha producido o no un error.
el procedimiento getData se utiliza para obtener los datos necesarios para calcular el impuesto. Aquí se definen directamente en el procedimiento getData. Si estos datos procedieran de otra fuente, un fichero o una base de datos por ejemplo, sólo habría que reescribir el procedimiento getData y no los demás.
la función calculerImpot permite calcular el impuesto una vez obtenidos todos los datos, sea cual sea la forma en que se hayan obtenido.
así pues, cabe señalar que la escritura modular permite (re)utilizar determinados módulos en contextos diferentes. En los últimos veinte años, este concepto se ha desarrollado mucho en el concepto de objeto.