Programar con Visual BASIC (III)

Continuamos aprendiendo a programar con Visual BASIC Studio. En esta tercera entrega dejaremos por un momento los controles de lado, para concentrarnos en las sentencias destinadas a controlar el flujo del programa.

Sentencias para el control del programa

Este grupo de instrucciones puede modificar el orden en que se ejecutan las demás sentencias que componen nuestro programa. Básicamente, existen dos grupos de instrucciones que pueden llevar a cabo estas tareas: las que determinan la ejecución de un trozo de código tomando una decisión, y las que permiten repetir un grupo de sentencias un número determinado de veces. Comenzaremos analizando las del primer grupo.

Sentencias de decisión

Una instrucción de este tipo representa una división en el flujo normal del programa. A partir del punto del código en que escribimos una instrucción de este tipo se produce una “división” en dos o más alternativas. Del resultado de la evaluación de una condición (que forma parte de la sentencia de decisión) dependerá cuál de las alternativas es la que finalmente se ejecuta.

Dentro de este grupo veremos las sentencias If, Choose y Select Case. Comencemos.

If…Then

Existen varias maneras de utilizar esta sentencia. Su forma más simple ocupa solo una línea de código, y tiene la forma siguiente:

If condición then sentencia

A menudo los programadores se refieren a este formato como “If de una línea”, y se emplea generalmente para asignar un valor a alguna variable cuando se da una condición determinada. Veamos un ejemplo.

Supongamos que si la edad de una persona es mayor a 18 años, debemos guardar en la variable “sujeto_estado” el valor “adulto”. La edad de la persona está almacenada en la variable “sujeto_edad”. La sentencia If que realiza esta comprobación y (eventual) asignación es la siguiente:

If sujeto_edad > 18 then sujeto_estado = “adulto”

La sentencia en cuestión, en caso de que la condición sea verdadera (es decir, que la edad del sujeto sea mayor a 18 años), ejecuta la asignación que se encuentra a la derecha del “then”, haciendo que sujeto_estado contenga la cadena “adulto”. Y luego continuará con la sentencia siguiente.

En caso de que “sujeto_edad” sea igual o menor a 18, el programa continuará con la sentencia siguiente a la del ejemplo sin realizar ninguna asignación.

Hay una variación posible al “If de una línea”, y consiste en el agregado de la cláusula “else”. Dicha sentencia tiene la siguiente forma:

If condición then sentencia1 else sentencia2

Este tipo de construcción es muy útil cuando, en función del resultado que arroje la evaluación de la condición, deban ejecutarse uno u otro (pero no ambos) grupo de instrucciones.

Nuevamente, un ejemplo nos aclarará mejor la cuestión. Supongamos que queremos asignar a la variable sujeto_estado el valor “adulto” o “niño” dependiendo de si es mayor o no de 18 años. Nuestro “If de una línea” quedará como sigue:

If sujeto_edad > 18 then sujeto_estado = “adulto” else sujeto_estado = “niño”

Al ejecutar esa línea, Visual BASIC decidirá si la condición es o no verdadera, y en función del resultado ejecutará la asignación que se encuentra a la derecha del “then” o la que está después del “else”. Independientemente de cuál sea el resultado, el programa (luego de realizar la asignación correspondiente) seguirá con la línea siguiente a la del “if…”.

Por supuesto, nada de esto sirve cuando necesitamos, luego de evaluar una condición, ejecutar un grupo de instrucciones y no solamente una. En esos casos, si el número de instrucciones es pequeño, podemos optar por separarlas por dos puntos:

If condición then sentencia1 : sentencia2 : sentencia3 : ….

En caso de que la condición sea verdadera, se ejecutarán todas las sentencias que están luego del “then”, en riguroso orden de izquierda a derecha. El mismo truco puede emplearse para colocar varias sentencias después del “else”.

Pero aún así, hay casos en que esto no basta. Veamos qué podemos hacer.

La versión larga del If…

Por ejemplo, no podemos poner otra sentencia “If…” a continuación del “then” o “else”. Para estos casos tenemos la “versión larga” del “If…”, que ocupa todas las líneas que haga falta, y que, en la práctica, es la que más utilizaremos. El formato de esta alternativa es la siguiente:

If condición then sentencia1 sentencia2 sentencia3 ….
End If

El funcionamiento es el mismo que cuando utilizamos los “:” en la versión de una sola línea para separar las sentencias unas de otras, pero se agrega la cláusula “End If” al final para que el compilador sepa dónde termina el bloque de instrucciones correspondientes al “If…” y dónde comienzan las que pertenecen al resto del programa. Si realizamos el ejemplo anterior con este formato, nos quedaría:

If sujeto_edad > 18 then sujeto_estado = “adulto”
End If

Ahora ya sabes por qué, cada vez que pueden, los programadores eligen el “If de una línea”. Pero donde realmente se luce es en los casos en que el código a ejecutar es más extenso, ya que no solo permite un número (teóricamente) infinito de sentencias de todo tipo en su interior, sino que es mucho más legible que el “If de una línea” con sentencias separadas por “:”. Y por supuesto, puede usarse con el “Else”:

If condición then Sentencia_v1 Sentencia_v2 Sentencia_v3 ….
Else Sentencia_f1 Sentencia_f2 Sentencia_f3 ….
End If

Pero lo más interesante es que pueden “anidarse” sentencias condicionales, unas dentro de otras. Eso permite la toma de decisiones realmente complejas. Y si somos ordenados (comentando e indentando el código a conciencia), el programa seguirá siendo legible a pesar de la longitud que pueda tener.

If anidados

Veamos un ejemplo. Supongamos que tenemos una variable, llamada “sujeto_sexo”, cuyo valor puede ser “H” o “M” (por “Hombre” o “Mujer”), y otra llamada “sujeto_edad” que contiene (¡como no!) la edad del sujeto. El siguiente código:

If sujeto_sexo = “H” then 'Si el sujeto es HOMBRE
    If sujeto_edad > 18 then 'Y tiene más de 18 años…
        sujeto = “Varón mayor de edad”
    Else            'Si no….
        Sujeto = “Varón menor de edad”
    End If
Else 'Si el sujeto es MUJER
    If sujeto_edad > 18 then 'Y tiene más de 18 años…
        sujeto = “Mujer mayor de edad”
    Else            'Si no….
        Sujeto = “Mujer menor de edad”
    End If
End If

coloca en la variable “sujeto” una descripción de la persona basada en los datos conocidos. Puede verse de qué forma se han “anidado” un If dentro de otro. La indentación del código permite identificar fácilmente cada parte del programa.

IIF

Para terminar con el capítulo dedicado a esta indispensable instrucción, aprenderemos a utilizar el “If…” como función. Efectivamente, es posible utilizar esta sentencia como si fuese una función. Luego de ser evaluada la condición, devuelve en la variable el valor que se encuentra después de la primera “,” (condición verdadera) o el que se encuentra después de la segunda (condición falsa). La forma es la siguiente:

Variable = IIF(condición, valor1, valor2)

Esta puede ser una herramienta interesante, y en muchos casos puede reemplazar al “If de una línea”. Veamos uno de los ejemplos anteriores, aquel en el que la variable sujeto_estado adquiere el valor “adulto” o “niño” dependiendo de si es mayor o no de 18 años, “traducido” a este nuevo formato:

sujeto_estado = IIF (sujeto_edad > 18, “adulto”, “niño”)

Como puede verse, una vez comprendida la sintaxis puede ser una buena forma de escribir un código claro.

Pero no terminan aquí las ventajas del IIF. También puede formar parte de otras sentencias, como el FOR…NEXT. Aún a riesgo de adelantarnos, veamos cómo podríamos hacer un bucle que cuente hasta 20 o hasta 50 dependiendo del valor de una variable:

For i = 1 to IIF(variable = 1, 20, 50)
….
….
….
Next i

Si “variable” es 1, el bucle se ejecutará 20 veces. Caso contrario, se ejecutará 50. El código equivalente, de no existir el IIF, podría escribirse así:

If variable = 1 then For i = 1 to 20 …. …. …. Next i
Else For i = 1 to 50 …. …. …. Next i
End If

O así:

If variable = 1 then limite = 20 else limite = 50
For i = 1 to limite
….
….
….
Next i

Como puede verse, la forma más corta de todas es la que emplea el IIF.

Conclusión

Hemos aprendido cómo hacer que nuestro programa pueda “tomar decisiones” utilizando algunas de las varias formas que posee la sentencia “if…then”. A medida que vayamos escribiendo nuestros propios programas seremos capaces de determinar rápidamente cuál es la más conveniente en cada ocasión. En breve veremos cómo se emplean las restantes.