¡Descarga Estructuras de Control en Visual Basic: Secuencial, Decisión y Repetición y más Diapositivas en PDF de Programación Informática solo en Docsity!
ESTRUCTURAS DE SECUENCIA, DECISIÓN, REPTICION EN
PROGRAMACIÓN
Un programador se enfrenta al desarrollo de un programa con recursos y experiencia. Vamos a tratar de abordar los distintos recursos disponibles en base a una terminología. En el diseño de un algoritmo no es en absoluto trascendente saber si lo que necesitamos es una estructura o una herramienta, pero sí será decisivo que conozcamos el recurso necesario, llámese como se llame. Llamaremos estructura a una instrucción o conjunto de instrucciones que controlan el flujo del programa para que éste sea secuencial, alternativo o repetitivo. De ahí la denominación de estructura secuencial , estructura de decisión , estructura de repetición , que gráficamente podemos asociar a: Esquema o estructura Esquema o estructura Esquema o estructura Secuencial de decisión de repetición (bucle) La potencia de los ordenadores se apoya, como es evidente, en la velocidad , pero también y de forma decisiva en las capacidades para decidir y repetir. En general, a una estructura de repetición se le conoce por “ bucle ” y así se puede decir “estamos en el bucle 7” ó “estamos en la iteración 7” en alusión a que se trata de la séptima repetición de un proceso.
Introducción a las Estructuras de Control
Las estructuras de control le permiten controlar el flujo de ejecución del programa en una rutina o función. Mediante ellas podemos controlar, mediante una condición, que se ejecute una determinada línea o bloque de líneas de código que no se ejecuten. Si no se controla mediante instrucciones de control de flujo, la lógica del programa fluirá por las instrucciones de izquierda a derecha y de arriba a abajo. Aunque se pueden escribir algunos programas sencillos con un flujo unidireccional y aunque se puede controlar parte del flujo mediante operadores para regular la precedencia de las operaciones, la mayor parte del poder y utilidad de un lenguaje de programación deriva de su capacidad de cambiar el orden de las instrucciones mediante estructuras y bucles.
- A) Estructuras de decisión Introducción a las estructuras de decisión utilizadas para bifurcar.
- B) Estructuras de bucle o repetición Introducción a las estructuras de bucle utilizadas para repetir procesos.
- C) Trabajar con estructuras de control (anidadas) Conceptos básicos del trabajo con estructuras de control en el código. ✓ Estructuras de control anidadas
A) Estructuras de Decisión
If ... Then (Si … Entonces)
Use la estructura If ... Then para ejecutar una o más instrucciones basadas en una condición. Puede utilizar la sintaxis de una línea o un bloque de varias líneas : Sintaxis en una sola línea: Flujograma: If Condición Then Instrucción 1 Sintaxis en bloque de varias líneas: If Condición Then Instrucción 1 Instrucción 2 . . Instrucción n End If Condición normalmente es una comparación (una pregunta serrada, no ambigua) la cual puede ser verdadera o falsa, pero puede ser cualquier expresión que dé como resultado un valor numérico. Visual Basic interpreta este valor como True o False ; un valor numérico cero es False y se considera True cualquier valor numérico distinto de cero. Si Condición es True (V) , Visual Basic ejecuta todas las Instrucciones que siguen a la palabra clave Then. Puede utilizar sintaxis de una línea o de varias líneas para ejecutar una sentencia basada en una condición, los siguientes dos ejemplos son equivalentes: If cualquierFecha < Now Then cualquierFecha = Now Observe que el formato de una única línea de If...Then no utiliza la instrucción End If. If cualquierFecha < Now Then cualquierFecha = Now End If Si se desea ejecutar más de una línea de código cuando condición sea True, debe utilizar la sintaxis de bloque de varias líneas If...Then...End If.
----------------------------------------------o0o----------------------------------------------
If...Then...Else (Si … Entonces … Si No)
Las construcciones If ... Then ... Else permiten probar una o más condiciones y ejecutar una o más instrucciones en función de cada condición. Sintaxis en una sola línea: If [Condición] Then Instrucción 1 Else Instrucción A Sintaxis en bloque: Flujograma: If [Condición] Then Instrucción 1 Instrucción 2 · · · Instrucción n Else Instrucción A Instrucción B · · · Instrucción Z End If La sintaxis a emplear con Visual Basic, con la sustitución del Si por If , del Entonces por Then , del SiNo por Else y del Finsi por End If. Puede probar las condiciones y tomar medidas de las maneras siguientes:
- Ejecutar una o más instrucciones si una condición es True.
- Ejecutar una o más instrucciones si una condición es False.
- Ejecutar algunas instrucciones si una condición es True y otras si es False.
- Probar una condición adicional si una condición anterior es False. Puede utilizar una versión de una línea si tiene simplemente una comprobación y una instrucción para ejecutar. Si tiene un conjunto más complejo de condiciones y acciones, puede utilizar la versión de varias líneas. También es posible encadenar varias acciones derivadas de un Then o de un Else en una sola línea. Sin embargo, recomendamos usar la opción de sintaxis en una sola línea exclusivamente para desarrollos sencillos como puede ser una instrucción en caso de
-------------------------------------------o0o---------------------------------- Observe que siempre puede agregar más cláusulas ElseIf a la estructura If...Then. Sin embargo, esta sintaxis puede resultar tediosa de escribir cuando cada ElseIf compara la misma expresión con un valor distinto. Para estas situaciones, puede utilizar la estructura de decisión Select Case. -------------------------------------------o0o----------------------------------
Select Case
Visual Basic proporciona la estructura Select Case como alternativa a If...Then...Else para ejecutar selectivamente un bloque de sentencias entre varios bloques. La sentencia Select Case ofrece posibilidades similares a la instrucción If...Then...Else, pero hace que el código sea más legible cuando hay varias opciones. La estructura Select Case se suele utilizar para evitar el uso de muchas cláusulas If y de esta manera no tener que anidarlas.
La claúsula Select evalúa una condición y las cláusulas case contienen valores , si el valor que contiene la cláusula case es igual a la condición que se evaluó, ejecutará las instrucciones en dicha cláusula. La estructura Select Case funciona con una única expresión de prueba que se evalúa una vez solamente, al principio de la estructura. Sintaxis: Select Case variable_control Case Valor Sentencia o grupo de sentencias Case Valor Sentencia o grupo de sentencias Case Valor Sentencia o grupo de sentencias End Select Visual Basic compara el resultado de esta expresión con los valores de cada Case de la estructura. Si hay una coincidencia, ejecuta el bloque de sentencias asociado a ese Case: Cada lista_expresiones es una lista de uno a más valores. Si hay más de un valor en una lista, se separan los valores con comas. Cada bloque de sentencias contiene cero o más instrucciones. Si más de un Case coincide con la expresión de prueba, sólo se ejecutará el bloque de instrucciones asociado con la primera coincidencia.
Variable ó Expresión Case 1 Case 2 Case 3 Case Else
ESTRUCTURAS DE REPETICIÓN (BUCLES) Las estructuras de repetición o bucles permiten que en nuestros programas se realice un proceso n veces. En concreto veremos las instrucciones Desde … Siguiente ( For … Next ) con su cláusula Paso (Step), la instrucción Desde Cada … Siguiente ( For Each… Next ) Hacer Mientras … Repetir ( Do While … Loop ) Hacer … Repetir Mientras ( Do … Loop While ). Muchas veces podremos optar indistintamente por usar una instrucción u otra. En otros casos, es recomendable concretarse por una de ellas por hacer el programa más legible o sencillo que usando otras opciones.
For...Next.
Desde … Siguiente (For … Next) con su cláusula Paso (Step), la instrucción Los bucles Do funcionan bien cuando no se sabe cuántas veces se necesitará ejecutar las sentencias del bucle. Sin embargo, cuando se sabe que se va a ejecutar las sentencias un número determinado de veces, es mejor elegir el bucle For...Next. A diferencia del bucle Do, el bucle For utiliza una variable llamada contador que incrementa o reduce su valor en cada repetición del bucle. La sintaxis es la siguiente: 1 50 3
For contador = iniciar To finalizar [ Step incremento]
Instrucciones
Next [ contador ]
Los argumentos contador, iniciar, finalizar e incremento son todos numéricos. Nota:
For Each...Next
El bucle For Each...Next es similar al bucle For...Next, pero repite un grupo de sentencia por cada elemento de una colección de objetos o de una matriz en vez de repetir las sentencias un número especificado de veces. Esto resulta especialmente útil si no se sabe cuántos elementos hay en la colección. He aquí la sintaxis del bucle For Each...Next: For Each elemento In grupo Sentencias Next elemento Tenga en cuenta las restricciones siguientes cuando utilice For Each...Next:
- Para las colecciones, elemento sólo puede ser una variable Variant, una variable Object genérica o un objeto mostrado en el Examinador de objetos.
- Para las matrices, elemento sólo puede ser una variable Variant.
- No puede utilizar For Each...Next con una matriz de tipos definidos por el usuario porque un Variant no puede contener un tipo definido por el usuario. ------------------------------------o0o------------------------------------
Do...Loop
Utilice el bucle Do para ejecutar un bloque de sentencias un número indefinido de veces. Hay algunas variantes en la sentencia Do...Loop, pero cada una evalúa una condición numérica para determinar si continúa la ejecución. Como ocurre con If...Then, la condición debe ser un valor o una expresión que dé como resultado False (cero) o True (distinto de cero).
- Do...Loop o Do While……Loop ▪ While … Wend o Do…….. Loop While o Do Until…….Loop o Do……. Loop Until
DO WHILE ... LOOP (Hacer Mientras)
Do While...Loop, las instrucciones se ejecutan siempre y cuando Condición sea Verdadera ( True): Do While Condición Instrucciones Loop Cuando Visual Basic ejecuta este bucle Do, primero evalúa Condición. Si condición es False (cero), se salta todas las sentencias. Si es True (distinto de cero) Visual Basic ejecuta las sentencias, vuelve a la instrucción Do While y prueba la condición de nuevo. Por tanto, el bucle se puede ejecutar cualquier número de veces, siempre y cuando condición sea distinta de cero o True. Nunca se ejecutan las sentencias si condición es False inicialmente. La sintaxis que hemos de seguir es la siguiente: Do While [ condición ] Instrucción 1 Instrucción 2 . . . Instrucción n Loop Las instrucciones tipo Do While son anidables dentro de sí mismas o dentro de otras estructuras. Es importante verificar que los bucles diseñados con esta instrucción dispongan de una condición de salida válida. Ejemplo: k = 0 Do while k < 5. Dentro del bucle tendremos que incrementar el valor de k, k = k +1. Loop Condición (^) Instrucciones V F Condición al comienzo
Do While i < 3 sería equivalente a Do Until i >= 3, y Loop Until i >= 3 sería equivalente a Loop While i < 3. Dado que podemos valernos de equivalencias, puede evitar confundirnos el usar preferentemente un mismo tipo de expresión, sabiendo que disponemos de otra equivalente. Un Loop (bucle) repite la ejecución de un conjunto de sentencias mientras una condición dada sea cierta, o hasta que una condición dada sea cierta. La condición puede ser verificada antes o después de ejecutarse el conjunto de sentencias. Sus posibles formas son las siguientes: Formato 1: Do[{While/Until} condicion] [ sentencias] [ Exit Do ] [ sentencias] Loop Formato 2: Do [ sentencias] [ Exit Do ] [ sentencias] Loop [{While/Until} condicion] La sentencia opcional Exit Do permite salir de un bucle Do ... Loop antes de que finalice éste.
DO UNTIL … LOOP (Hacer Hasta)
La sintaxis que hemos de seguir es la siguiente: Do Until [ condición ] Instrucción 1 Instrucción 2 . . . Instrucción n Loop Condición (^) Instrucciones F V V Condición al comienzo
--------------------------------------o0o--------------------------------------
DO … LOOP UNTIL (HACER … REPETIR HASTA)
La sintaxis a utilizar es: Do Instrucción 1 Instrucción 2 . . . Instrucción n Loop Until [ condición ] -------------------------------------------------o0o---------------------------------------------- Condición Instrucciones F V v Condición al final
Puede anidar las estructuras de control en Visual Basic en tantos niveles como desee. Es una práctica común crear estructuras de decisión anidadas y estructuras de bucle más legibles sangrando el cuerpo de la estructura de decisión o de bucle. Por ejemplo, este procedimiento imprime todos los nombres de fuentes comunes de la impresora y de la pantalla: Private Sub Form_Click() Dim SFont, PFont For Each SFont In Screen.Fonts() For Each PFont In Printer.Fonts() If SFont = PFont Then Print SFont End If Next PFont Next SFont End Sub Observe que el primer Next cierra el bucle For interior y que el último For cierra el bucle For exterior. Del mismo modo, en instrucciones If anidadas, las instrucciones End If se aplican automáticamente a la anterior instrucción If más cercana. Las estructuras Do...Loop anidadas funcionan de una forma parecida; la instrucción Loop más interior coincide con la instrucción Do más interior.
Salir de una estructura de control
La instrucción Exit le permite salir directamente de un bucle For , un bucle Do , un procedimiento Sub o un procedimiento Function. La sintaxis de la instrucción Exit es sencilla: Exit For puede aparecer tantas veces como sea necesario dentro de un bucle For y Exit Do puede aparecer tantas veces como sea necesario dentro de un bucle Do : For contador = iniciar To finalizar [ Step incremento] [bloque de instrucciones] [ Exit For ] [bloque de instrucciones] Next [contador[, contador] [,...]] Do [{ While | Until } condición] [bloque de instrucciones] [ Exit Do ] [bloque de instrucciones] Loop La instrucción Exit Do funciona con todas las variantes de la sintaxis del bucle Do. Exit For y Exit Do son muy útiles ya que, algunas veces, resulta apropiado salir inmediatamente de un bucle sin realizar más iteraciones o instrucciones dentro del bucle. Por ejemplo, en el ejemplo anterior que imprimía las fuentes comunes de la impresora y de la pantalla, el código sigue comparando las fuentes de impresora contra una fuente de pantalla aunque se haya encontrado una coincidencia con una fuente de
impresora anterior. Una versión más eficiente de la función saldría del bucle tan pronto como se encontrara una coincidencia: Private Sub Form_Click() Dim SFont, PFont For Each SFont In Screen.Fonts() For Each PFont In Printer.Fonts() If SFont = PFont Then Print Sfont Exit For ' Sale del bucle interior. End If Next PFont Next SFont End Sub Como muestra este ejemplo, la instrucción Exit aparece varias veces dentro de una instrucción If o una instrucción Select Case anidada en el bucle. Cuando utilice la instrucción Exit para salir de un bucle, el valor de la variable contador difiere, dependiendo de cómo haya salido del bucle:
- Cuando termina un bucle, la variable contador contiene el valor del límite superior más el paso.
- Cuando sale de un bucle prematuramente, la variable contador conserva su valor según las reglas usuales del alcance.
- Cuando sale antes del final de una colección, la variable contador contiene Nothing si se trata de un tipo de dato Object y Empty si es un tipo de dato Variant.
Salir de un procedimiento Sub o Function
También puede salir de un procedimiento desde una estructura de control. La sintaxis de Exit Sub y Exit Function es similar a la de Exit For y Exit Do de la sección anterior, "Salir de una estructura de control". Exit Sub puede aparecer tantas veces como sea necesario, en cualquier parte del cuerpo de un procedimiento Sub. Exit Function puede aparecer tantas veces como se necesite, en cualquier parte del cuerpo de un procedimiento Function. Exit Sub y Exit Function son muy útiles cuando el procedimiento ha realizado todo lo que tenía que hacer y se quiere volver inmediatamente. Por ejemplo, si desea modificar el ejemplo anterior para que imprima sólo la primera fuente común de impresora y de pantalla que encuentre, podría usar Exit Sub : Private Sub Form_Click() Dim SFont, PFont For Each SFont In Screen.Fonts() For Each PFont In Printer.Fonts() If SFont = PFont Then Print Sfont Exit Sub ' Sale del procedimiento. End If Next PFont Next SFont
