Programar con Visual BASIC (V)

En la quinta entrega de éste tutorial comenzaremos a analizar las diferentes instrucciones que Visual BASIC dispone para la construcción de bucles (o reiteraciones). Su comprensión nos ayudará a crear programas capaces de realizar tareas más complejas y útiles.

Es muy difícil encontrar un proceso de datos que requiera de algún tipo de repetición. Si solo tuviésemos que llevar a cabo una acción determinada en dos o tres oportunidades, podríamos limitarnos a repetir el código en cuestión la cantidad necesaria de veces. Esto funcionaria, a pesar de que a un programador “serio” le produciría dolor de estomago. Pero si necesitamos efectuar un proceso sobre, digamos, un millón de registros, la solución anterior, además de ser muy poco eficaz, es absolutamente impracticable.

Para resolver estas situaciones, los lenguajes de programación proporcionan una serie de instrucciones destinadas a la repetición de porciones de código. Si bien todas ellas hacen básicamente lo mismo, tienen sutiles diferencias que hacen, frente a un determinado problema, unas mas apropiadas que otras.

FOR-NEXT
Esta quizás sea la estructura de este tipo mas conocida. De hecho, se encuentra presente en los dialectos BASIC desde los orígenes de este lenguaje. Su formato es el siguiente:

For variable = valor_inicial To valor_final Step incremento   Instrucciones
Next variable

donde “variable” irá cambiando su valor a lo largo de la ejecución del bucle For-Next, comenzando con “valor_inicial” hasta “valor_final”, en incrementos de “incremento”. Por cada valor que asuma “variable”, la(s) instrucción(es) que se encuentran entre el For y el Next se ejecutarán una vez.

¿Confuso? Seguramente el ejemplo siguiente te aclarará las cosas.

Supongamos que queremos sumar los números enteros de 1 a 10 (ambos inclusive). Usando For-Next podríamos hacerlo así:

Dim i, suma As Integer
suma = 0
For i = 1 To 10 Step 1           suma = suma + i
Next i

En primer lugar, declaramos la variable “i”, que será la que controlara el bucle, y la variable “suma” (guardará el total de la suma) como enteras. Luego, hacemos que suma sea igual a cero. Esto no es indispensable, por que el compilador la inicializa por defecto con ese valor, pero es recomendable tener a la vista ese dato.

Luego, tenemos el bucle for-Next propiamente dicho. Vemos que “i” adoptará valores desde 1 hasta 10, incrementándose en 1 cada iteración.
La sentencia “suma = suma + i” se ejecutará 10 veces, sumando cada vez el valor de “i” en la variable suma. “i” tomará valores 1, 2, 3, 4, 5, 6, 7, 8, 9 y 10, mientras que “suma” será 1, 3, 6, 10, 15, 21, 28, 36, 45 y 55.

Colocar el nombre de la “variable” a continuación del Next es opcional. Pero a pesar de no ser obligatorio, es una buena práctica hacerlo, ya que en aquellos programas en que se emplean varios bucles, uno dentro de otro, ayuda a identificar a que For corresponde cada Next.

Cuando el incremento de la “variable” es 1, como en el ejemplo anterior, tampoco hace falta poner “Step 1”, ya que el compilador lo hace por defecto. Digamos que si queremos escribir lo menos posible, nuestro ejemplo podría quedar como sigue:

Dim i, suma As Integer      
For i = 1 To 10            suma = suma + iNext

En programas tan sencillos, podemos omitir todas estas cuestiones que son opcionales. Pero si nuestro programa es muy extenso, o si debe ser modificado o leído por otra persona, conviene incluir todo lo necesario para que su comprensión sea más fácil.

La declaración del tipo de la “variable” puede hacerse dentro del mismo “For”, lo que compacta un poco más el código:

Dim suma As Integer

For i As Integer = 1 To 10           suma = suma + i
Next

Personalmente, me gusta ésta forma de declarar la variable usada en el bucle.

También puede ser útil construir bucles que modifiquen el valor de la “variable” de forma decreciente. Esto es posible gracias a que el valor a continuación del Step puede ser negativo. Si se da esta condición, el valor de la “variable” se decrementa en cada iteración. Veamos un ejemplo:

Dim suma As Integer

For i As Integer = 100 To 0 Step -2           suma = suma + iNext

En este caso, el valor inicial de “i” será 100, ira descendiendo de a dos unidades en cada iteración, y la última se producirá cuando el valor de “i” sea igual a cero. La variable “suma” va incrementando su valor en cada pasada, y al finalizar contiene la suma de los números pares que se encuentran entre el 0 y el 100, ambos inclusive. Puedes comprobarlo, el resultado final de “suma” será 2550.

Por supuesto, en ese caso el “valor_inicial” debe ser mayor que el  “valor_final”, si no nuestro bucle no se ejecutará ni una vez. Esto plantea un tema interesante: puede darse el caso de que un bucle no se ejecute ninguna vez, ya que sus valores iniciales son tales que lo hacen imposible. La situación se produce cuando, al principio del bucle, Visual Basic evalúa los valores de “variable”, “valor_inicial”,“valor_final” e “incremento” y descubre que se ha alcanzado el máximo valor posible, saltando a la instrucción que sigue al Next.

Por ejemplo, el siguiente código no realiza ninguna suma, ya que el valor inicial es inferior al final, y el incremento es negativo:

Dim suma As Integer

For i As Integer = 1 To 10 Step -2           suma = suma + i
Next

Nada impide utilizar valores no enteros en cualquiera de los parámetros del For-Next. Supongamos que, siguiendo con las sumas, queremos sumar los valores comprendidos entre 0 y 10, de 0.1 en 0.1:

        Dim suma, i As Double
       For i = 0 To 10 Step 0.1           suma = suma + i       Next

(nótese el detalle de que hemos declarado las variables como “Double”).
El código anterior sumará 0.0, 0.1, 0.2, etc hasta 10.0 . El resultado, como se ve en la imagen siguiente es 505.

Por supuesto, todos los parámetros de un For-Next pueden ser variables. Esto le otorga una gran flexibilidad a nuestros programas, ya que permite construir bucles cuyo numero de ejecuciones dependa, por ejemplo, del numero de productos que contiene una base de datos, o de los días que tiene el mes en curso.

El ejemplo siguiente ilustra esta posibilidad:

        Dim suma, i, inicio, final, incremento As Double
       inicio = 85.7       final = 100.8       incremento = 0.1
       For i = inicio To final Step incremento           suma = suma + i       Next i

Por supuesto, como dijimos antes, si no se es cuidadoso se puede terminar con un bucle que no se ejecute ni una vez. Dato curioso: el resultado, que debería ser 14.174 tiene un pequeño error de redondeo.

Por ultimo, hay un par de instrucciones que pueden alterar el número de veces que se va a repetir el contenido de un bucle For-Next. Supongamos que queremos sumar los números enteros hasta que la suma sea superior a 1000. Salvo que seamos muy buenos con la matemática, no tenemos forma de conocer cual será el “valor_final” de nuestra cuenta.

Pero con “Exit For” podemos abortar el For-Next cuando queramos. Si Visual BASIC se encuentra con esta instrucción, inmediatamente pasa a la instrucción posterior al Next, sin importar que se haya alcanzado el “valor_final” elegido o no. Así es como se usa:
       Dim suma, i, inicio, final, incremento As Double
       inicio = 1       final = 1000       incremento = 1
       For i = inicio To final Step incremento           suma = suma + i           If suma >= 1000 Then               Exit For           End If       Next i

Usando el IF-THEN que vimos en una entrega anterior, preguntamos si la suma ya es igual o superior a 1000. En caso de que sea así, ejecutamos el Exit For para abandonar el bucle. En la imagen siguiente puede verse el resultado del programa, y también que “i” sólo ha necesitado incrementarse 35 veces.

For-Next tiene una variante que permite recorrer los ítems de una colección, mediante For-Each. Cuando hayamos visto que son y como se emplean las colecciones, volveremos sobre For-Next para explicar este ultimo aspecto.

Con esto terminamos la quinta entrega de nuestro tutorial. En la siguiente veremos los demás tipos de bucles que podemos emplear en nuestros programas Visual BASIC.