ESTRUCTURAS DE SELECCION
ESTRUCTURA IF THEN ELSE La estructura IF -THEN –ELSE - END IF, sirve para evaluar condiciones y si se cumple dicha(s) condiciones se ejecuta el código que se encuentra en medio del “THEN” y el “ELSE”. En caso de no cumplirse la condición se ejecuta el código que se encuentra entre el “ELSE” y el “END IF” En el siguiente programa se evalúa la variable “contador”, la cual fue inicializada en “4” y la evaluación consiste en preguntar si dicha variable toma un valor menor a 10, en caso de tomarlo se muestra un mensaje que dice “El contador es menor que 10” y en caso de no cumplirse la condición se muestra el mensaje "El contador es mayor o igual a 10". Observemos que este ejercicio muestra un solo mensaje y no los dos al tiempo, por cuanto la sentencia if then else end if se construye con el fin de ejecutar dos bloques de código excluyentes. En el caso del ejercicio que se muestra a continuación se muestra el primer mensaje. Veamos: '****************************************************************** 'Nombre: seleccion1.frm 'Descripcion: El siguiente programa muestra cómo utilizar la ' sentencia de selección IF THEN ELSE 'Tipo: El programa es básico de SENTENCIAS DE SELECCION '***************************************************************** Private Sub Form_Load() Sub Form_Load() Dim contador Dim contador As Integer contador = 4 If contador < 10 Then MsgBox "El contador es menor que 10" Else MsgBox "El contador es mayor o igual a 10" End If End Sub Ahora bien, con el fin de lograr que el amigo lector / estudiante comprenda claramente la estructura IF- THEN- ELSE –END IF, a continuación se muestra otro ejercicio que tiene dos estructuras de las mencionadas y cada una de ellas evalúa una variable. La primera evaluación se cumple, y la segunda evaluación no se cumple. Veamos pues el programa: '****************************************************************** 'Nombre: seleccion2.frm 'Descripcion: El siguiente programa muestra como utilizar la ' sentencia de selección IF THEN ELSE 'Tipo: El programa es básico de SENTENCIAS DE SELECCION '***************************************************************** Private Sub Form_Load() Dim contador1, contador2 As Integer
contador1 = 4 contador2 = 15 If contador1 < 10 Then MsgBox "El contador1 es menor que 10" Else MsgBox "El contador1 es mayor o igual a 10" End If If contador2 < 10 Then MsgBox "El contador2 es menor que 10" Else MsgBox "El contador2 es mayor o igual a 10" End If End Sub
ESTRUCTURA IF THEN ELSE ANIDADOS Es posible colocar una estructura IF-THEN-ELSE-END IF inmersa en otra estructura IF-THEN-ELSE-END IF, con lo cual se dice que la estructura se encuentra anidada. En el siguiente programa se muestra como implementar este tipo de estructuras en forma anidada. Veamos: '****************************************************************** 'Nombre: seleccion3.frm 'Descripcion: El siguiente programa muestra la utilizacion de ' la estructura IF THEN ELSE en forma anidada 'Tipo: El programa es básico de SENTENCIAS DE SELECCION '***************************************************************** Private Sub Form_Load() Dim contador1, contador2 As Integer contador1 = 4 contador2 = 15 If contador1 < 10 Then If contador2 < 10 Then MsgBox "Ambas variables son menores que 10" Else MsgBox "contador1 < 10 y contador2 >= 10" End If Else If contador2 < 10 Then MsgBox "Contador1 > =10 y contador2 < 10" Else MsgBox "Ambas variables son mayores que 10"
End If End If End Sub
ESTRUCTURA IF THEN ELSE EN UNA LINEA Cuando se desea implementar una estructura IF-THEN-ELSE y al evaluarse la expresión se necesitan ejecutar sentencias de solo una línea, es muy interesante saber que el IF-THEN-ELSE se puede colocar reducido para este caso, con el fin de lograr menos líneas de código. Tentamos en cuenta que si se desean escribir más de una línea para cada evaluación de condición no es posible implementar esta versión de una sola línea. Veamos pues el ejercicio: '****************************************************************** 'Nombre: seleccion4.frm 'Descripcion: El siguiente programa muestra la utilizacion de ' la estructura IF THEN ELSE en forma minima 'Tipo: El programa es básico de SENTENCIAS DE SELECCION '***************************************************************** Private Sub Form_Load() Dim contador1, contador2 As Integer C1 = 4 C2 = 15 If C1 < 10 Then If C2 < 10 Then MsgBox "C1 y C2 < 10" Else MsgBox "C1<10 y C2>=10" Else If C2 < 10 Then MsgBox "C1>=10 y C2<10" Else MsgBox "C1>=10 y C2>=10" End If End Sub Aclaremos que la versión mínima de la estructura IF-THEN-ELSE-END IF para una sola línea es: IF THEN ELSE Y el “END IF” no se coloca. No es necesario colocarlo, es más, incluso de llegarse a colocar generaría un error de sintaxis.
CLAUSULA ELSEIF En ocasiones, dada una estructura IF -THEN -ELSE- END IF, se realizan anidamientos de la siguiente manera: IF THEN ELSE IF THEN ELSE END IF END IF Y sucede que la anterior estructura puede ser escrita de la siguiente manera: IF THEN ELSEIF THEN ELSE END IF En donde si se fija el amigo lector / estudiante, se ha suprimido una cláusula END IF y esto se debe básicamente a que el if fue “pegado” al else y a pesar de seguir comportándose como IF THEN ELSE, no es posible finalizarlo en un END IF. Ahora bien,supongamos que unimos este último ELSE, con otro if, dando lugar a una estructura como la siguiente: IF THEN ELSEIF THEN ELSEIF THEN ELSE END IF Esta estructura sigue siendo correcta pero puede prestarse para confusiones. De todas formas hay cosas que cabe mencionar en esta estructura: No es posible agregar otro ELSE, pues el compilador no sabría con cual cerrarlo No es posible agregar otro END IF, pues tampoco se sabría con cual cerrarlo.
Para no ir más lejos, veamos el siguiente ejercicio que aclara esta estructura: '****************************************************************** 'Nombre: seleccion5.frm 'Descripcion: El siguiente programa muestra la utilizacion de ' la estructura IF THEN ELSE en forma minima 'Tipo: El programa es básico de SENTENCIAS DE SELECCION '***************************************************************** Private Sub Form_Load() Dim calificacion As Integer calificacion = 3 If calificacion > 4 Then MsgBox "Calificacion excelente" ElseIf calificacion > 3 Then MsgBox "Calificacion buena" ElseIf calificacion > 2 Then MsgBox "Calificacion aceptable" Else MsgBox "Calificacion mala" End If End Sub Para terminar con la explicación del anterior programa, a continuación se muestra una tabla en la que se muestra vara diversos valores de la variable “calificación”, los diversos mensajes que imprimiría el programa anterior. Valor de la calificación Calificación = 1 Calificación = 2 Calificación = 3 Calificación = 4 Calificación = 5
variable Resultado mostrado programa Calificación mala Calificación mala Calificación aceptable Calificación buena Calificación excelente
por
el
ESTRUCTURA SELECT CASE Esta estructura es utilizada frecuentemente para tomar decisiones con respecto a valores tomados por una variable. Veamos el siguiente ejercicio: '****************************************************************** 'Nombre: seleccion6.frm 'Descripcion: El siguiente programa muestra la utilizacion de ' la estructura SELECT CASE 'Tipo: El programa es básico de SENTENCIAS DE SELECCION '*****************************************************************
Private Sub Form_Load() Dim calificacion As Integer calificacion = 3 Select Case calificacion Case 1 MsgBox "Le fue muy mal" Case 2 MsgBox "le fue mal pero no tanto" Case 3 MsgBox "paso raspando" Case 4 MsgBox "le fue bien" Case 5 MsgBox "Le fue muy bien" Case Else MsgBox "No tiene nota valida" End Select End Sub Tengamos en cuenta que la instrucción SELECT CASE, no necesariamente funciona con valores fijos y únicos, sino que también puede ser utilizada para establecer rangos de valores, tal como se muestra en el siguiente ejercicio: '****************************************************************** 'Nombre: seleccion7.frm 'Descripcion: El siguiente programa muestra la utilización de ' la estructura SELECT CASE 'Tipo: El programa es básico de SENTENCIAS DE SELECCION '***************************************************************** Private Sub Form_Load() Dim calificacion As Double calificacion = 4.5 Select Case calificacion Case Is < 1 MsgBox "Le fue pesimamente" Case 1 To 1.99 MsgBox "le fue muy mal " Case 2 To 2.99 MsgBox "le fue mal" Case 3 To 3.99 MsgBox "es una nota aceptable" Case 4 To 4.5 MsgBox "Le fue bien" Case 4.5 To 5
MsgBox "Le fue excelentemente" Case Else MsgBox "No tiene nota valida" End Select End Sub Y con el ánimo del lograr la mejor comprensión de estos temas por parte del amigo estudiante / lector, a continuación se muestran los resultados que arrojaría el anterior programa si se hubieran dados los siguientes valores a la variable “calificacion”: Veamos: Valor de la calificación Calificación = 1 Calificación = 1.5 Calificación = 2 Calificación = 2.5 Calificación = 3 Calificación = 3.5 Calificación = 4 Calificación = 4.5 Calificación = 4.6 Calificación = 5
variable Resultado mostrado programa Le fue muy mal Le fue muy mal Le fue mal Le fue mal Es una nota aceptable Es una nota aceptable Le fue bien Le fue bien Le fue excelentemente Le fue excelentemente
por
el
Cabe mencionar que en la estructura SELECT CASE, solamente se ejecuta una condición como máximo y esa es la razón por la cual en nuestro ejercicio se ejecuta el caso: Case 4 To 4.5 Y el siguiente caso que también cumple la condición, ya no se ejecuta, es decir el siguiente código Case 4.5 To 5 A pesar de cumplir la condición no se ejecuta por haberse ejecutado ya un caso que cumple la condición.
MAS COSAS SOBRE SELECT CASE En algunos ejercicios pasados se mostraba el uso de “is” en el “case” e implícitamente se estaba queriendo decir que este se utiliza en los casos en los que la comparación sea de los siguientes tipos: <
<=
=
>
>=
Para lograr ejemplificar lo expuesto, a continuación se presenta un ejercicio en el que se utiliza la instrucción “is”, dentro de una función “case”. Veamos: '****************************************************************** 'Nombre: seleccion8.frm 'Descripcion: El siguiente programa muestra la utilizacion de ' la estructura SELECT CASE 'Tipo: El programa es básico de SENTENCIAS DE SELECCION '***************************************************************** Private Sub Form_Load() Dim nota As Double nota = 1 Select Case nota Case Is < 0 MsgBox "Nota por debajo de lo valido" Case 1, 3, 5 MsgBox "Nota valida e impar" Case Is = 0 MsgBox "La nota es cero" Case 2, 4 MsgBox "Nota valida y par" Case Is > 5 MsgBox "Nota por encima de lo valido" Case Else MsgBox "La nota no debe tener decimales" End Select End Sub A continuación se muestra una tabla en la que se pueden apreciar los mensajes que muestra el programa anterior, suponiendo que la variable “nota” toma diversos valores. Veamos: Asignación a variable nota -1 0 0.5 1
Mensaje producido por el programa Nota por debajo de lo valido La nota es cero La nota no debe tener decimales Nota valida e impar
2 3 4 5 6
Nota valida y par Nota valida e impar Nota valida y par Nota valida e impar Nota por encima de lo valido
Tengamos en cuenta que en el programa anterior se utilizo una sentencia como: Case 2,4 Para comparar con dos valores de una sola vez a la variable. Es decir que separando los valores por comas (,) es posible hacer varias comparaciones con valores constantes sin necesidad de tener que repetir otro “case” con cada número que se va a comparar.
ESTRUCTURAS DE ITERACIÓN
Las estructuras de iteración son estructuras que ejecutan una o más veces un conjunto de sentencias (o una sentencia) un número determinado de veces, hasta que se cumpla una condición, mientras se cumpla una condición o hasta que se den ciertas circunstancias que obliguen a no ejecutar por más tiempo dichas instrucciones. ´Recordemos que las estructuras de selección ejecutaban un bloque de instrucciones determinado una vez o nunca, dependiento del cumplimiento de una condición previamente establecida.
ESTRUCTURA FOR NEXT El siguiente programa se ejecuta tan pronto se carga un formulario, contiene una sentencia inmersa en la sección de “declaraciones”: Option Base 1 La cual se encarga de hacer que los vectores que se creen tengan un índice que comience con el valor uno. De otra parte, es importante notar que es necesario colocar la propiedad “AutoRedraw” a true con el fin de lograr que se pueda imprimir cosas directamente en el formulario, sin necesidad de tener que hacerlo mediante una caja de texto, un label, etc. El programa crea un vector con cuatro posiciones y cada una de ellas contiene un texto y al final por medio de la estructura for se ejecutan las instrucciones hasta antes de la palabra reservada “next” varias veces, en donde la primera vez, se ejecuta con el valor de 1 en la variable “contador”, la segunda vez con el valor de 2 en la variable “contador” y así sucesivamente se va ejecutando hasta que el valor de la variable “contador” sea igual a 4. Veamos el ejercicio: '****************************************************************** 'Nombre: for1.frm 'Descripcion: El siguiente programa muestra la utilizacion de ' la estructura FOR - NEXT 'Tipo: El programa es básico de ESTRUCTURAS DE ITERACION '***************************************************************** Option Base 1 Private Sub Form_Load() Dim contador As Integer Dim cadena(4) As String Form1.AutoRedraw = True cadena(1) = "uno" cadena(2) = "dos" cadena(3) = "tres" cadena(4) = "cuatro" For contador = 1 To 4 Print cadena(contador) Next
End Sub
ESTRUCTURA FOR -EACH –NEXT Y LAS COLECCIONES Como veíamos en el anterior ejercicio, la estructura for es bien interesante para muchas cosas y para el caso de recorrer un vector es de bastante ayuda. Suponga ahora que quiere eliminar un elemento del vector de string, tendríamos para este caso varias posibilidades y cuestiones al respecto, a saber: •
•
•
•
Reemplazar el string de la posición del vector de String a eliminar por una cadena vacia, es decir por ejemplo por la cadena “ “. Implementar el algoritmo de las listas para colocar cada objeto en un nodo y cada vez que se añada un elemento poner a apuntar el último nodo existente con el nuevo nodo recién creado Para el caso de querer eliminar un elemento de la lista, se podría eliminar el nodo pero antes haber guardado la dirección del nodo “anterior” y el nodo “siguiente” al nodo a borrar y una vez eliminado el mismo, poner a apuntar el nodo “anterior” al nodo “siguiente”. Bueno, pero no hemos mencionado todos los problemas que tendríamos al recorrer dicha lista, pues en este caso sería necesario cambiar la estructura for colocando después de la instrucción “To” ya no un “4”, sino una instrucción que calcule el total de los elementos existentes en la lista, de tal suerte que sin importar si se añaden o eliminan elementos, el ciclo, siempre esté imprimiendo la totalidad de elementos de la lista.
Pues bien, todos estos problemas son sencillamente solucionados por Visual Basic con la implementación de colecciones (que se escriben “Collection”). La forma de declarar un objeto de tipo Collection es la siguiente: Dim coleccion As New Collection En donde la variable “colección” es de tipo “Collection” y los elementos a dicha colección se pueden añadir de la siguiente manera: coleccion.Add "Uno" coleccion.Add "Dos" coleccion.Add "Tres" y para referirse al primer elemento insertado en dicha colección, se hace de la siguiente manera: coleccion.Item(1) y para eliminar un elemento de la colección se hace así:
coleccion.Remove (2) Bueno, pero con el fin de mostrarle a usted amigo lector / estudiante un programa completo que trabaje estos conceptos a continuación se muestra un programa que maneja las colecciones. Veamos: '****************************************************************** 'Nombre: coleccion1.frm 'Descripcion: El siguiente programa muestra la utilizacion de ' colecciones, la adición y eliminación de elementos a las mismas 'Tipo: El programa es de COLECCIONES '***************************************************************** Option Base 1 Private Sub Form_Load() Form1.AutoRedraw = True Dim coleccion As New Collection coleccion.Add "Uno" coleccion.Add "Dos" coleccion.Add "Tres" Print coleccion.Item(1) Print coleccion.Item(2) Print coleccion.Item(3) coleccion.Remove (2) Print coleccion.Item(1) Print coleccion.Item(2) 'Print coleccion.Item(3) Generaria error End Sub Bien y ahora usted se estará preguntando: ¿ No estamos hablando acaso de la estructura FOR- EACH – NEXT y qué relación hay con las colecciones?. Pues la respuesta es bien sencilla: “La estructura FOR- EACH – NEXT, se creó con el fin de poder mostrar los elementos de una colección, sin tener necesidad de saber de antemano el número de elementos de dicha colección”. En el siguiente programa de ejemplo, se muestra el uso de la estructura “FOR- EACH – NEXT” para mostrar elementos de las colecciones y además se muestra la forma de añadir un elemento al final o añadirlo antes de una posición especificada. Veamos:
'****************************************************************** 'Nombre: for2.frm 'Descripcion: El siguiente programa muestra la utilizacion de ' la estructura FOR – EACH – NEXT y de las colecciones 'Tipo: El programa es básico de ESTRUCTURAS DE ITERACIÓN y ' manejo del objeto COLLECTION '***************************************************************** Option Base 1 Private Sub Form_Load() Form1.AutoRedraw = True Dim coleccion As New Collection Dim refer_coleccion Dim contador As Integer For contador = 1 To 5 coleccion.Add CStr(contador * contador), CStr(contador) Next Print "Coleccion antes de borrar elementos" For Each refer_coleccion In coleccion Print refer_coleccion Next refer_coleccion coleccion.Remove (5) coleccion.Remove (2) Print "Coleccion despues de borrar elementos" For Each refer_coleccion In coleccion Print refer_coleccion Next refer_coleccion coleccion.Add "Textico2", "5", 3 Print "Coleccion despues de añadir un textico2" For Each refer_coleccion In coleccion Print refer_coleccion Next refer_coleccion End Sub El programa anterior, imprime los siguientes resultados: Colección antes de borrar colección después de borrar Colección después de añadir elementos elementos un textico2 1 4 9 16 25 1 9 16 1 9 textico2 16
En donde el formato para insertar en un objeto collection es: Objeto_colection.Add Item, key, before, after Y en donde Nombre del Argumento de la Significado de dicho argumento propiedad Add del objeto Collection Item el contenido de lo que se va a colocar en el elemento de la colección Key un identificador opcional para distinguir este elemento Before especifica la posición antes de la cual se va a colocar el elemento After especifica la posición después de la cual se va a colocar el elemento Nota: Los argumentos “Befores” y “After” son exluyentes, lo que quiere decir que si se especifica un valor para “Befores”, no de debe especificarse un valor para “After” y viceversa, si se especifica un valor para “After”, no debe especificarse un valor para “Befores”.
CICLO DO – UNTIL - LOOP El ciclo “DO-UNTIL-LOOP”, es utilizado con frecuencia cuando se necesita que se ejecuten ciertas instrucciones hasta que se cumpla una condición determinada, momento en el cual se sale del ciclo. Es preciso tener en cuenta que primero se evalúa la condición y si se llega a cumplir no se entra al ciclo. Veamos el siguiente ejercicio que describe el funcionamiento de esta clase de ciclos: '****************************************************************** 'Nombre: do1.frm 'Descripcion: El siguiente programa muestra como utilizar ' el ciclo DO - UNTIL - LOOP 'Tipo: El programa es de ESTRUCTURAS DE ITERACIÓN '***************************************************************** Option Explicit Dim Dado1, Dado2 As Integer Private Sub Command1_Click() Do Until Dado1 = 3 And Dado2 = 3 Dado1 = Int(6 * Rnd + 1) Dado2 = Int(6 * Rnd + 1) Print "Dado1: " & CStr(Dado1) & "Dado2: " & CStr(Dado2) Loop Print "FIN DEL CICLO"
End Sub Observemos en el programa anterior que una vez se ejecuta un ciclo de iteraciones hasta que se cumple por primera vez la condición, nunca más se vuelve a ejecutar el ciclo, debido a que al evaluar la condición, ésta se cumple y por tanto se sale del ciclo de iteración “DO – UNTIL –LOOP”. Para mayor comprensión del tema tratado, a continuación se muestra un posible resultado del programa anterior(se dice que es un posible resultado, debido a que se utiliza una función aleatoria que hace de los resultados del programa un conjunto distinto por cada vez que se ejecuta el mismo) Dado1: 4 Dado2: 1 Dado1: 5 Dado2: 4 Dado1: 3 Dado2: 2 Dado1: 4 Dado2: 3
Dado1: 6 Dado2: 6 Dado1: 2 Dado2: 1 Dado1: 2 Dado2: 4 Dado1: 3 Dado2: 4
Dado1: 4 Dado2: 5 Dado1: 4 Dado2: 3 Dado1: 3 Dado2: 6 Dado1: 3 Dado2: 3
FIN DEL CICLO “NUNCA MÁS SE VUELVE A EJECUTAR LAS SENTENCIAS” Por lo tanto, si el usuario vuelve a presionar el botón de comando, el programa sacará el siguiente resultado: FIN DEL CICLO Por cada vez que vuelva a presionar dicho botón (exceptuando como hemos dicho la primera vez que ejecuta el botón de comando). CICLO DO – LOOP - UNTIL Esta estructura de iteración es similar a la estructura “DO – UNTIL - LOOP”, con la diferencia que primero se ejecuta el bloque de instrucciones(o la instrucción) y posteriormente se evalúa la condición. En caso de cumplirse la condición se sale del ciclo. Para mayor comprensión, veamos pues el ejemplo: '****************************************************************** 'Nombre: do2.frm 'Descripcion: El siguiente programa muestra como utilizar ' el ciclo DO - UNTIL - LOOP 'Tipo: El programa es de ESTRUCTURAS DE ITERACIÓN '***************************************************************** Option Explicit Dim Dado1, Dado2 As Integer Private Sub Command1_Click() Do Dado1 = Int(6 * Rnd + 1)
Dado2 = Int(6 * Rnd + 1) Print "Dado1: " & CStr(Dado1) & "Dado2: " & CStr(Dado2) Loop Until Dado1 = 3 And Dado2 = 3 Print "FIN DEL CICLO" End Sub En este ejercicio a diferencia del anterior, siempre se va a ejecutar como mínimo una vez el bloque de sentencias y posteriormente se evalúa la condición. En caso de cumplirse se sale del ciclo, pero es importante recordar que por lo menos una sola vez se garantiza la ejecución del grupo de sentencias incluidas en esta estructura de iteración. A continuación se muestra un posible resultado de la ejecución del anterior programa. Veamos: Dado1: 1 Dado2: 4 Dado1: 4 Dado2: 5 Dado1: 2 Dado2: 3 Dado1: 4 Dado2: 3
Dado1: 4 Dado2: 6 Dado1: 1 Dado2: 1 Dado1: 3 Dado2: 5 Dado1: 3 Dado2: 5
Dado1: 4 Dado2: 5 Dado2: 4 Dado2: 2 Dado1: 5 Dado2: 6 Dado1: 3 Dado2: 3
FIN DEL CICLO Si el usuario vuelve a presionar el botón de comando, el programa ejecuta otra vez el ciclo y puede generar otro resultado como el siguiente: Dado1: 4 Dado2: 1 Dado1: 3 Dado2: 2 Dado1: 4 Dado2: 3
Dado1: 6 Dado2: 6 Dado1: 2 Dado2: 4 Dado1: 3 Dado2: 4
Dado1: 4 Dado2: 5 Dado1: 3 Dado2: 6 Dado1: 3 Dado2: 3
FIN DEL CICLO Y en general como se mencionado anteriormente, está garantizada la ejecución por lo menos una vez de las sentencias incluidas en la estructura de iteración.
USO DE EXIT DO Es interesante observar que no sólo es posible basarnos en una condición para salir de un ciclo de iteración como el DO – WHILE, sino que también podemos utilizar alguna condición de selección incorporada en el grupo de sentencias del ciclo, de tal suerte que cuando se cumpla, también se salga del ciclo de iteración. Veamos pues el ejercicio para comprender mejor este concepto:
'****************************************************************** 'Nombre: do3.frm 'Descripcion: El siguiente programa muestra como utilizar ' el ciclo DO - UNTIL - LOOP y la sentencia ' EXIT DO para abortar el ciclo de iteración 'Tipo: El programa es de ESTRUCTURAS DE ITERACIÓN '***************************************************************** Option Explicit Dim Dado1, Dado2 As Integer Private Sub Command1_Click() Do Dado1 = Int(6 * Rnd + 1) Dado2 = Int(6 * Rnd + 1) If Dado1 = 2 And Dado2 = 4 Then Print "Dado1= " & CStr(Dado1) & "Dado2= " & CStr(Dado2) Exit Do End If Print "Dado1: " & CStr(Dado1) & "Dado2: " & CStr(Dado2) Loop Until Dado1 = 2 And Dado2 = 4 Print "FIN DEL CICLO" End Sub A continuación se muestra un posible resultado del programa anterior: Dado1: 4 Dado2: 5 Dado1: 3 Dado2: 6 Dado1= 3 Dado2= 3 Observemos que una vez se cumpla dicha condición el programa ejecuta las sentencias incluidas en la estructura de selección “IF - THEN - END IF”, pero cuando se están ejecutando dichas sentencias incluidas en esta estructura el programa ejecuta la sentencia: EXIT DO La cual tiene por objetivo salir del ciclo “DO - LOOP” en forma inmediata, con lo cual ya no se ejecuta la siguiente sentencia que se encuentra después del “IF THEN - END IF” (es decir la sentencia: Print "Dado1: " & CStr(Dado1) & "Dado2: " & CStr(Dado2)). Ahora bien, la sentencia “EXIT DO”, no solamente sale del ciclo de iteración, sino que aparte de todo continúa la ejecución del programa a partir de la sentencia que se encuentre inmediatamente después de la palabra LOOP. Con lo anterior, podemos concluir que si el ciclo de iteración “DO - LOOP”, se encuentra anidado en otro ciclo “DO - LOOP” y el ciclo interno ejecuta la sentencia “EXIT DO”, se pasa el control del programa un nivel arriba del bucle interno y en
general la sentencia “EXIT DO” transfiere el control del programa un nivel arriba, cuando se trata de bucles anidados. Con todo lo anteriormente mencionado, es importante tener en cuenta que si a un ciclo de iteración tipo “DO – LOOP”, no se le coloca la instrucción “UNTIL”, pero se tiene en cuenta la instrucción “EXIT DO”, colocada de tal suerte que actúe abortando el ciclo en algún momento, es posible eliminar la sentencia “UNTIL”. Para comprender mejor lo anteriormente expuesto, veamos el siguiente programa que no es más que el programa que venimos trabajando en este apartado del ejercicio eliminándole la sentencia “UNTIL”: '****************************************************************** 'Nombre: do4.frm 'Descripcion: El siguiente programa muestra como utilizar ' el ciclo DO - LOOP sin UNTIL y con la sentencia ' EXIT DO para abortar el ciclo de iteración 'Tipo: El programa es de ESTRUCTURAS DE ITERACIÓN '***************************************************************** Option Explicit Dim Dado1, Dado2 As Integer Private Sub Command1_Click() Do Dado1 = Int(6 * Rnd + 1) Dado2 = Int(6 * Rnd + 1) If Dado1 = 2 And Dado2 = 4 Then Print "Dado1= " & CStr(Dado1) & "Dado2= " & CStr(Dado2) Exit Do End If Print "Dado1: " & CStr(Dado1) & "Dado2: " & CStr(Dado2) Loop ' Until Dado1 = 2 And Dado2 = 4 Print "FIN DEL CICLO" End Sub
USO DE DO - WHILE - LOOP En los casos anteriores, se usaba la palabra “UNTIL”, dentro de un ciclo “DO LOOP”, pero como veremos a continuación también es posible decirle a visual Basic que repita una serie de instrucciones mientras se presente una determinada condición. Veamos pues el ejercicio:
'****************************************************************** 'Nombre: do5.frm 'Descripcion: El siguiente programa muestra como utilizar ' el ciclo DO - WHILE - LOOP 'Tipo: El programa es de ESTRUCTURAS DE ITERACIÓN '***************************************************************** Dim variable As Integer Private Sub Form_Load() variable = 3 Do While variable < 10 Print "Variable = " & CStr(variable) variable = variable + 1 Loop End Sub Los resultados arrojados por este programa son: Variable = 3 Variable = 4 Variable = 5 Variable = 6 Variable = 7 Variable = 8 Variable = 9
USO DE DO - WHILE - LOOP También es posible al igual que con el ejercicio de “DO – UNTIL – LOOP”, colocar la palabra “WHILE” al final del ciclo, de tal manera que el ciclo primero ejecute el bloque de instrucciones y posteriormente evalúe la condición. Veamos: '****************************************************************** 'Nombre: do6.frm 'Descripcion: El siguiente programa muestra como utilizar ' el ciclo DO - LOOP - WHILE 'Tipo: El programa es de ESTRUCTURAS DE ITERACIÓN '***************************************************************** Dim variable As Integer Private Sub Form_Load() variable = 3 Do Print "Variable = " & CStr(variable) variable = variable + 1 Loop While variable < 10 End Sub
