Académique Documents
Professionnel Documents
Culture Documents
Por: Ariel Palazzesi @ viernes, 09 de mayo de 2008 Nota vista 5687 veces
Si alguna vez has sentido deseos de crear tus propios programas, estas de parabienes: en
NeoTeo te enseñaremos, paso a paso, como crear programas utilizando una de las
herramientas mas sencillas y potentes que puedes conseguir: Visual Basic. ¿Comenzamos?
A pesar de lo ampliamente difundido que se encuentra Visual Basic en todas sus versiones,
hasta no hace mucho había que gastar un buen montón de dinero para hacerse con una
copia de esta magnifica herramienta. Sin embargo, Microsoft ha decidido distribuir
versiones gratuitas de algunos de sus lenguajes de programación más populares. Se trata de
copias totalmente operativas, aunque con algunas limitaciones.
Visual Basic 2005 Express es la versión gratis que utilizaremos en este tutorial. Para
acceder a ella, lo primero que debes hacer es descargar e instalar el paquete
correspondiente. Se trata de una descarga de aproximadamente 380MB, que puedes
conseguir en el sitio oficial que Microsoft ha puesto en línea para este producto.
Veamos como instalarlo. Por supuesto, haremos clic sobre “versión final en español”, lo
que hará que nuestro navegador nos pregunte si deseamos guardar o ejecutar el programa al
que lleva dicho link. Seleccionaremos “ejecutar”, y esperaremos unos segundos. Primero
aparecerá un cuadro como el de la figura 1, indicándonos que esperemos, y luego algo
parecido a lo siguiente:
Figura 2 Figura 3
Figura 4: ¿Que vamos a descargar?
Este es un buen momento para ordenar un poco la habitación, o para salir a por un poco de
aire. Dependiendo de la velocidad de nuestra conexión, el proceso puede demorar entre 40
minutos y un par de horas. No es mala idea cerrar las demás aplicaciones que estén
haciendo uso de Internet, para acelerar un poco esta etapa.
Tarde o temprano el proceso finaliza, y nos invita a reiniciar el ordenador. Una vez hecho
esto, el programa esta listo para ser usado. Y eso es lo que haremos.
IDE son las iniciales, en ingles, de Integrated Development Environment, algo asi como
entorno de desarrollo integrado. Se trata de un programa que nos pone a disposición las
herramientas que necesitamos para programar en un (o en varios) lenguajes de
programación. En el caso del Visual Basic 2005 Express, lo primero que vemos es la
imagen de la figura 7, de donde podemos elegir si vamos a encarar un proyecto nuevo o
editar uno existente.
Aquí debemos hacer una aclaración. Debe haber pocos programas que brinden la
posibilidad de personalización de sus barras de herramientas como este IDE. Seria muy
conveniente que no cambies de lugar las barras, cuadros o botones por ahora, para que la
disposición se parezca lo más posible a las capturas de pantalla que ofrecemos como
muestra. Eso hará más fácil de seguir las explicaciones.
Hemos marcado la barra que contiene las opciones del menú principal con un “1” (en rojo,
no puedes no verlo). Desde allí es posible acceder a casi todas las opciones del Visual
Basic 2005 Express, que iremos viendo a medida que resulten necesarias.
Un “2” señala la fila de iconos que representan las tareas que utilizaremos con mayor
frecuencia. Si alguna vez utilizaste alguno de los integrantes del paquete Microsoft Office,
ya sabes como se utilizan estos iconos.
En “3” tenemos el “Explorador de soluciones”, que es básicamente una lista de cada parte
que compone nuestro proyecto, y que proporciona una forma rápida de llegar a cada uno de
ellos.
La zona marcada con un “4” muestra (y nos permite modificar) las propiedades del objeto o
control que hayamos seleccionado en ese momento. Será una de las zonas que mas
emplearemos del IDE.
En “5” vemos el “formulario” que contendrá los elementos que conforman nuestra
aplicación. En el momento que el programa que estamos creando este listo, será la ventana
que lo contenga. Allí depositaremos los botones, menues, etiquetas, y todo lo que necesite
nuestra aplicación para llevar a cabo su tarea.
Por ultimo, “6” muestra el “Cuadro de herramientas”. Este menú, que se divide en varias
zonas, será el que proporcione todos los controles que necesitamos para completar nuestra
aplicación. La forma de colocar alguno de ellos sobre el “formulario” es tan sencilla como
“arrastrarlo” sobre este. La figura 11 muestra como hemos colocado un botón.
Lo hemos marcado con un círculo rojo, y también hemos puesto otro para que veas de qué
forma se modifico el contenido de la zona “4”, para reflejar la lista de las propiedades que
este botón tiene.
La figura 12 muestra el mismo formulario, al que hemos agregado una serie de controles
diferentes.
Figura 10: Nuestro primer control. Figura 11: Agregamos más items al
formulario.
Puedes comenzar con la instalación del paquete, y explorar las herramientas de las que
dispone el IDE.
Tienes 30 días para registrar (gratuitamente) tu paquete en el sitio Web de Microsoft. Una
vez hecho esto, tendrás acceso a una serie de tutoriales y publicaciones que harán más fácil
tu aprendizaje. Nosotros seguiremos explicando como hacer uso de Visual Basic 2005
Express en la próxima entrega de este tutorial.
Ventana con las propiedades de Form1.
Asumimos que el lector tiene a disposición la ayuda que brinda MSDN Library,
que se instala junto a Visual Studio Express, para consultar los detalles de
cada propiedad. Solo explicaremos las que vayan siendo necesarias para
entender los ejemplos que vayamos planteando.
La forma de escribir el código es muy fácil: basta con hacer un clic en la solapa
que lleva el nombre del formulario (en este caso “Form1.vb”). El IDE
automáticamente escribe por nosotros los encabezados de los procedimientos,
por lo que solo escribimos nuestro código.
Otra propiedad que posiblemente quieras cambiar es “Icon”. Si haces clic sobre
ella, se abrirá un cuadro de dialogo que te permite elegir el archivo “.ICO” que
desees sea el icono que se muestre en la esquina superior de la ventana:
Me.Size.Width = 480
Una de las primeras impresiones que se tiene al entrar al IDE de Visual Studio Express
2005 es que hay controles que no utilizaremos nunca. Sin embargo, con el tiempo vamos
viendo que todos son útiles en algún momento, y afortunadamente Microsoft los ha puesto
a disposición.
Los controles simplemente se arrastran con el ratón desde la paleta que está a la izquierda
de la pantalla hasta el formulario. Vamos a probar como hacerlo. Intenta arrastrar 3 botones
(Button), una etiqueta (Label), 3 casillas (CheckBoxes) y un cuadro de texto (TextBox). No
importa demasiado (por ahora) su posición sobre el formulario, aunque si pones un poco de
cuidad, podrás colocarlos tal como se ven en la imagen:
Una vez hecho esto, vamos a cambiarles a todos estos controles el texto que muestran. Los
vamos seleccionando de a uno, utilizando el ratón, y modificamos en la ventana
“propiedades” el valor de la propiedad “Text”. Toma tu tiempo, y haz que tus controles
queden tal como se ve aquí:
Vamos a ver como hacer para que los controles que hemos agregado ejecuten alguna tarea
cuando el usuario interactúa con ellos. La forma de hacer esto es, simplemente, escribir el
código necesario en el evento deseado. Como siempre, un ejemplo puede resultar mucho
más simple de entender. Hagamos que cuando presionamos el tercer botón (el que tiene el
texto “Salir”) el programa termine. En BASIC, la instrucción que finaliza la ejecución de
un programa es “End”. Para escribir esta instrucción en el evento “Click” del Button3
simplemente le damos doble clic, y el IDE nos posicionará en el lugar correcto. Una vez
editado, este debería ser el aspecto del código:
La flecha indica el lugar donde debemos escribir “End”. Como ves, el entorno del Visual
Basic ha escrito el encabezado del procedimiento por si solo. Una vez hecho esto, veremos
que si corremos el programa, al hacer “clic” sobre el botón “Salir”, el programa termina.
Los demás, al no tener código asociado, no efectúan ninguna tarea.
Tenemos dos botones mas para “programar”. Aprovechemos para ver como las acciones
que se llevan a cabo sobre un control pueden influir en otro. Vamos a darle doble clic al
botón “Escribir” para acceder a su evento “clic”, y escribir allí el código necesario para que
el TextBox1 (el pequeño cuadro de texto de la parte superior del formulario) muestre el
texto “Hola mundo!” cuando lo presionamos. El código debería quedar así:
Volvemos a agregar código.
Si ejecutamos el programa, veremos que el cuadro de texto aparece vacio. Al hacer clic
sobre “Escribir”, su contenido cambia a “Hola mundo!”. Lo que hemos hecho ha sido
modificar el evento “click” del Button1 para que modifique la propiedad “Text” del control
TextBox1. Resulta bastante más difícil describir el proceso que llevarlo a cabo.
El contenido del TextBox1 puede ser modificado utilizando el ratón y el teclado, editando o
copiando su contenido. Pero también podríamos modificarlo mediante código.
¡Listo! Ahora podemos escribir con un botón, borrar con el otro, y salir con el tercero. Y lo
mejor de todo es que hemos escrito muy poco código para lograrlo.
CheckBoxes
Con todo lo visto hasta aquí, no debería resultarnos muy difícil hacer que, si el usuario
marca alguno de las casillas del formulario, se modifique el contenido del cuadro de texto.
En realidad, el procedimiento es el mismo que hemos empleado para modificar el
comportamiento de los primeros dos botones: le damos doble clic al CheckBox que
queremos editar, y escribimos el codigo necesario. Por ejemplo, en la figura siguiente
vemos como hacer para que el al marcar el CheckBox1 el TextBox1 muestre la palabra
“Rojo”:
Ya puedes modificar por ti mismo los otros tres para que escriban “Verde”, “Amarillo” y
“Azul”. También puedes comprobar que el botón “Borrar” sigue borrando el contenido del
TextBox1, y que el botón “Escribir” escribe “Hola mundo!” independientemente del
contenido del cuadro de texto.
Por supuesto, el programa tiene un defecto: El TextBox1 escribe lo que le pedimos al hacer
clic, independientemente de que estemos marcando o desmarcando el CheckBox
correspondiente. Por supuesto, no es un problema de Visual Basic (que hace exactamente lo
que le hemos indicado), sino de nuestro código, que no tiene en cuenta esta situación.
Por hoy hemos terminado. Seria interesante que, mientras preparamos la próxima entrega,
realices muchas pruebas con los controles que hemos visto, y si te surgen inquietudes, las
plantees como comentarios en este articulo. Prometemos responder a todas las consultas.
Este grupo de instrucciones pueden 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 mas alternativas. Del resultado de la evaluación de una condición (que
forma parte de la sentencia de decisión) dependerá cual de las alternativas es la que
finalmente se ejecuta.
Dentro de este grupo veremos las sentencias If, Choose y Select Case. Comencemos.
Enlaces
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:
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.
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:
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 si es mayor o no
de 18 años. Nuestro “If de una línea” quedará como sigue:
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:
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 que podemos hacer.
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 practica, 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 linea
para separar las sentencias unas de otras, pero se agrega la clausula “End If” al final para
que el compilador sepa donde termina el bloque de instrucciones correspondientes al “If…”
y donde comienzan las que pertenecen al resto del programa. Si realizamos el ejemplo
anterior con este formato, nos quedaría:
Ahora ya sabes por que, cada vez que pueden, los programadores eligen el “If de una
línea”. Pero donde realmente se luce es en los casos que el código a ejecutar es mas
extenso, ya que no solo permite un numero (teóricamente) infinito de sentencias de todo
tipo en su interior, si no 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.
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:
IIF
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 que la variable sujeto_estado
adquiere el valor “adulto” o “niño” dependiendo si es mayor o no de 18 años, “traducido” a
este nuevo formato:
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 IFF. También puede formar parte de otras sentencias,
como el FOR…NEXT. Aún a riesgo de adelantarnos, veamos como podríamos hacer un
bucle que cuente hasta 20 o hasta 50 dependiendo del valor de una variable:
For i = 1 to IFF(variable = 1, 20, 50)
….
….
….
Next i
If variable = 1 then
For i = 1 to 20
….
….
….
Next i
Else
For i = 1 to 50
….
….
….
Next i
End If
O asi:
Como puede verse, la forma mas corta de todas es la que emplea el IFF.
Conclusión
Hemos aprendido como 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 cual es
la más conveniente en cada ocasión. En breve veremos cómo se emplean las restantes.
Con esto terminamos este capítulo de nuestro pequeño curso de programación. La semana
próxima comenzaremos con las sentencias capaces de hacer que una porción de nuestro
código se repita la cantidad de veces que necesitemos. Mientras tanto, intenta aplicar lo
aprendido para fijar los conceptos. ¡Hasta la próxima!
Choose()
Esta función recibe una lista de parámetros, de los cuales el primero se utiliza como índice
para determinar cual de los demás se devuelve al ser evaluada. Esto puede parecer difícil de
entender, pero en realidad, como demostraremos con los ejemplos, es muy simple. El
formato de Choose() es el siguiente:
Al ejecutarse esta sentencia, “Variable1” tomará alguno de los valores de la serie “Valor1” a
“ValorN”. El contenido de la variable “indice” será el que determine cual resulta elegido: si
“indice” es igual a 1, Choose() hará que “Variable1” tome el valor de “Valor1”; si “indice”
es igual a 2 tomará el de “Valor2”; y así sucesivamente.
Si hubiésemos querido hacer lo mismo utilizando “If…Then”, el programa sería mucho mas
extenso (y quizás más confuso):
If color = 1 Then
variable1 = "rojo"
Else
If color = 2 Then
variable1 = "verde"
Else
'asumo que si color no es 1 ni 2, es 3.
variable1 = "azul"
End If
End If
Esta instrucción es ideal para utilizar en aquellas situaciones en que debemos elegir una
alternativa de entre muchas. Si bien Choose() hace mas o menos esto mismo (“If…Then”
también), por lo general “Select Case” resulta más fácil de leer. Particularmente, yo
prefiero utilizar “Choose()” cuando quiero que el código (fuente) sea compacto, y “Select
Case” cuando hay muchas alternativas, pero cada programador elije la forma que cree más
conveniente.
Su formato es el siguiente:
La <expresión a evaluar> puede ser algo tan simple como una variable, o una expresión
más compleja que Visual Basic resolverá antes de elegir que grupo de instrucciones
ejecutar. Las <lista de expresiones> que siguen a cada sentencia “Case” se evalúan, y de
ser verdaderas (solo debería serlo una de ellas) se ejecutan las sentencias que estén a
continuación.
En caso de que ninguna de las <lista de expresiones> sea verdadera, se ejecutan las
instrucciones que están a continuación del “Case Else”. Esta sección no es obligatoria. Si
no existe “Case Else” y ninguna de las <lista de expresiones> es verdadera, el programa no
ejecutará nada de lo que hay dentro de la estructura.
Veamos cómo podríamos resolver el ejemplo de los colores visto antes, usando Select Case:
Respecto de las expresiones que pueden utilizarse a continuación de las cláusulas “Case”,
no tiene por que ser necesariamente un numero. Supongamos que queremos que si “color”
vale 1,2 o 3, “Variable1” sea igual a “Correcto”. No necesitamos usar tres “Case”
diferentes, sino que podemos hacerlo en uno solo, separando los valores por comas.
Quedaría así:
En estos casos, donde queremos hacer lo mismo para un grupo de valores comprendidos en
un rango determinado, también podemos utilizar la cláusula “To”. El siguiente código hace
exactamente lo mismo que el visto recién:
Resulta evidente que su la lista de valores es larga, “To” simplifica mucho el código.
También podemos utilizar la cláusula “To”.
En todos los ejemplos vistos, hemos efectuado alguna acción cuando el valor de
<expresión a evaluar> es igual a un valor determinado. Pero puede darse el caso de que
necesitemos hacer algo cuando la <expresión a evaluar> sea mayor, menor o diferente a un
valor determinado. Para ello, debemos utilizar el operador “Is”. Literalmente, el
significado, en español, de este operador es “Es”. Su uso brinda una gran flexibilidad a la
<expresión a evaluar>. Veamos un ejemplo:
El código anterior guardará en “Variable1” el texto "Primera decena" solo cuando el valor
de “numero” sea menor a 11 (es decir, este comprendido entre 0 y 10).
Para terminar con “Select Case”, vamos a resolver un problema utilizando todo lo visto
hasta aquí.
Supongamos por un momento que en un variable tenemos la edad de una persona, y que
debemos, en función de su valor, determinar que en que tipo de establecimiento educativo
se encuentra cursando sus estudios (por supuesto, los valores y tipos de establecimientos
son completamente ficticios). Mira el código fuente siguiente e intenta comprender que
hace cada línea:
Seguramente podrás descubrir, leyendo el programa, cual es el valor de “Variable1” una vez
ejecutado el código anterior, verdad?
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:
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.
Supongamos que queremos sumar los números enteros de 1 a 10 (ambos inclusive). Usando
For-Next podríamos hacerlo así:
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.
Nuestro primer For-Next.
For i = 1 To 10
suma = suma + i
Next
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:
For i As Integer = 1 To 10
suma = suma + i
Next
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:
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:
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:
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.
Código y resultado de la ejecución.
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.
inicio = 85.7
final = 100.8
incremento = 0.1
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.
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:
inicio = 1
final = 1000
incremento = 1
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.
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.
En la quinta entrega de este pequeño tutorial, vimos que con FOR…NEXT podíamos
resolver aquellas situaciones en las que un grupo de instrucciones debían repetirse un
número determinado de veces. Pero existen otras situaciones, y aparecen con mucha
frecuencia, en las que no se conoce de antemano el número de iteraciones que debería tener
nuestro bucle.
Do…Loop
El bucle DO...LOOP es muy versátil. Tanto, que puede reemplazar a FOR…NEXT en casi
todos los casos. Con él se pueden crear una gran variedad de bucles diferentes, dependiendo
si comprueban una condición antes de ejecutar el bucle una vez; después de la primera
ejecución; mientras que se cumple la condición o hasta que la mencionada condición se
cumpla. La sintaxis básica de esta estructura es la siguiente:
Do
Instrucciones…
[Exit Do]
Instrucciones…
Loop
Esta es la forma más simple de escribir este tipo de bucle. Las instrucciones comprendidas
entre el Do y el Loop se ejecutaran indefinidamente. Resulta muy apropiado para aquellos
casos en que nuestro programa se encuentra esperando que ocurra alguna situación
determinada, a la vez que repite un grupo de instrucciones.
La opción “Exit Do” permite abandonar el bucle cuando lo deseemos. En general, una
sentencia “If…Then” comprueba el valor de alguna expresión, y cuando dicha expresión es
verdadera, se ejecuta el “Exit Do”. El siguiente ejemplo ilustra este caso:
Do
edad = edad - 1
If edad = 0 Then
Exit Do
End If
Loop
Como puede verse, el bucle se repetirá mientras que el valor de “edad” sea diferente de
cero. Cuando esto ocurre, la condición que evalúa el “If…Then” será verdadera y el control
del programa saltará a la instrucción que haya a continuación del “Loop”.
La opción “Exit Do” permite abandonar el bucle cuando lo deseemos.
Por supuesto, no podemos utilizar “While” y “Until” a la vez. En esta forma del bucle, la
condición se evalúa al comienzo del mismo. En el caso de utilizar la opción “While”, el
bucle se repetirá mientras que la condición sea verdadera. Podemos escribir el ejemplo
anterior utilizando esta posibilidad:
Como puede verse, es mucho más simple utilizar “While” que “If…Then” y “Exit Do”.
Aclaramos que la condición evalúa que edad sea diferente de cero.
Do Until edad = 0
edad = edad - 1
Loop
En este caso, el bucle se repetirá hasta que edad sea igual a cero. En estos dos ultimo
ejemplos puede darse el caso de que, si edad es igual a cero cuando se llega a la instrucción
“Do”, las instrucciones existentes en el interior del bucle no se ejecuten nunca.
El bucle se repetirá hasta que edad sea igual a cero.
La tercera forma que puede adoptar el bucle que estamos analizando es la siguiente:
Do
Instrucciones…
[Exit Do]
Instrucciones…
Loop { While | Until } condición
Como puede verse, se ha delegado la capacidad de evaluar la condición al final del bucle.
Esto tiene la particularidad de permitir que el grupo de instrucciones existentes en el
interior del bucle se ejecuten al menos una vez, independientemente de que la condición a
evaluar sea o no verdadera.
Do
edad = edad - 1
Loop Until edad = 0
O asi:
Do
edad = edad - 1
Loop While edad <> 0
Se puede evaluar la condición al final del bucle.
En todos los casos puede utilizarse, entre las instrucciones que están dentro del bucle, la
sentencia “Continue Do”, que hace que el control del programa salte nuevamente al
“Do…”, repitiendo el ciclo actual.
Si comprendiste la forma en que funciona el bucle "Do… Loop" con la opción “While”, no
tendrás ninguna dificultad en aprender a usar “While…End”.
While condición
Instrucciones…
[Exit While]
Instrucciones…
[Continue While]
Instrucciones…
End While
Lo primero que notamos es que en este bucle también existe la posibilidad de abandonarlo
en cualquier momento, gracias a “Exit While”; y que, al igual que antes, la sentencia
“Continue While”
Este es el tipo de bucle que debemos usar si deseamos repetir un conjunto de instrucciones
un número indefinido de veces. Esto ocurrirá mientras la condición sea verdadera. Es
menos flexible que “Do...Loop”, pero a muchas personas les resulta más sencillo de utilizar.
No tendrás ninguna dificultad en aprender a usar “While…End”.
Para poder compararla con las otras opciones vistas, vamos a escribir el código de los
ejemplos anteriores utilizando “While…End”:
Como puede verse, resulta muy simple de usar. Para terminar, tengamos presente que si se
desea repetir las instrucciones un número fijo de veces, la instrucción “For...Next” siempre
es la mejor opción.
GoTo
Esta instrucción es la “oveja negra” de todos los dialectos BASIC, aunque también existe
en otros lenguajes de programación.
Su función consiste en transferir, sin condiciones, la ejecución del programa a otro punto
del mismo, identificado por una etiqueta (o número de línea) determinada. En realidad, en
la “prehistoria” de la programación, en la época en que los lenguajes de programación eran
muy primitivos, la mayoría de los bucles se construían con “GoTo”.
Instrucciones…
Goto etiqueta
Instrucciones…
Etiqueta:
Instrucciones…
Cuando el programa se encuentra con “GoTo etiqueta”, salta a la instrucción siguiente a
“Etiqueta:”. “Etiqueta:” puede estar antes o después del “GoTo”, lo que permite hacer
“saltos hacia atrás” o “saltos hacia adelante”. Tampoco hay límite entre la cantidad de
instrucciones que pueden escribirse entre el “GoTo” y la “etiqueta:”.
Esta “libertad” que otorga hace que muchos programadores, en general los principiantes,
hagan un uso abusivo del “GoTo”, y sus programas sean muy difíciles de comprender.
Además, es posible escribir cualquier programa sin necesidad de siquiera un solo “Go To”.
Para terminar este capitulo, realizaremos el ejemplo de antes, pero con “GoTo”:
repetir:
edad = edad - 1
If edad > 0 Then
GoTo repetir
End If
Como puede verse, y a pesar de su poca longitud, el código resulta algo mas confuso que
los otros ejemplos. En programas largos, de miles de instrucciones, con varios “GoTo”
saltando de un lado para otro, el seguimiento del programa puede convertirse en una
pesadilla, incluso para la misma persona que lo escribió.
Con esto, damos por finalizada esta entrega del tutorial de programación en Visual Basic.
Dentro de unos días publicaremos el capítulo siguiente.
Los controles, que pueden arrastrarse y soltarse sobre los formularios (Forms) de Visual
Basic, son componentes extremadamente importantes para la construcción de las
aplicaciones. Son, en resumen, los que permiten confeccionar la interfaz que el usuario
utilizara para controlar las funciones de nuestro programa.
Figura 1
Comenzaremos viendo como utilizar los “Controles comunes”. Es bastante difícil encontrar
alguna aplicación que no utilice alguno de estos controles como parte de su interfaz. El
primero de ellos, cuyo icono es una pequeña flecha, no es en realidad un control, sino la
herramienta que podemos usar para mover o seleccionar alguno de los controles que
tenemos en nuestro formulario.
Hecha esta aclaración, comencemos con el análisis. Lo primero que haremos será abrir el
Microsoft Visual Basic 2005 Express, seleccionemos “Aplicación para Windows”, y
asegurémonos que tenemos el “Form1” en la pantalla, en modo diseño. Deberíamos tener a
la vista algo más o menos así:
Figura 2
Figura 3
El primer control que usaremos será “Button”. Como habrás adivinado, se trata del clásico
botón presente en prácticamente la totalidad de las ventanas de cada programa. Este control
puede ejecutar una acción cuando el usuario hace clic sobre él.
Figura 5 Figura 6
Con esto tenemos el botón con el texto deseado escrito en él. Ahora, vemos como hacer
para que, cuando el usuario haga “clic” sobre el control, la aplicación termine. Para ello,
debemos escribir un trozo de código que se ejecute cuando esta acción tenga lugar. La
forma de hacerlo es muy sencilla: simplemente, damos un doble clic sobre el botón, y
Visual Basic pasará al Form.vb, tal como se ve en la figura:
Figura 7
El IDE de Visual Basic nos facilita mucho las cosas. Tanto, que como puede verse nos
lleva directamente al lugar exacto donde debemos escribir el código que se ejecutará, en
tiempo de ejecución, al pulsar el botón. Como queremos que la aplicación termine cuando
esto ocurra, simplemente escribimos “End”:
Figura 8
Una vez hecho esto, ya podemos probar nuestro programa para ver si funciona
correctamente. Para ello, basta con presionar “F5” o hacer clic sobre la flecha verde de la
barra de herramientas que tenemos en la parte superior del IDE, debajo del menú. El
programa arrancará, y se verá más o menos como sigue:
Figura 9
Obviamente, ya habrás hecho clic sobre el botón y comprobado cómo se cierra la ventana.
Por supuesto, podemos hacer cosas mucho más interesantes con este control.
Aprovecharemos, de paso, para aprender a utilizar la función MsgBox(), que permite
desplegar pequeñas ventanas con un mensaje (y algunos botones) en ella. Su sintaxis es la
siguiente:
Donde prompt, que obligatoriamente debe estar, es una cadena que representa el texto que
aparecerá en el cuadro de diálogo. La longitud máxima de prompt es de unos 1024
caracteres, variando con el ancho de los caracteres utilizados.
Title es otra cadena opcional, que se muestra en la barra de título del cuadro de diálogo. Si
se omite este parámetro, en la barra de título se verá el nombre de la aplicación.
genera un cuadro de diálogo con el texto "Aprendiendo Visual Basic", un solo botón con el
texto “Ok” y el titulo “NeoTeo”. Tal cual se ve en la imagen:
Figura 10
Ahora bien, seguramente te estás preguntando “¿Cómo hago yo para enterarme que poner
para crear cada combinación de botones?”. Y nosotros, rápidamente, te damos la
respuesta:
Tabla 1
Como puede verse, Visual Basic proporciona una palabra clave para que no tengamos que
recordar números extraños. El siguiente código
Tabla 2
Lo interesante de MsgBox() es que devuelve un código que nos indica que botón ha
pulsado el usuario. Esto significa que, si somos lo suficientemente hábiles a la hora de
escribir nuestros programas, podremos realizar diferentes acciones en respuesta a la
respuesta (¡ops!) del usuario.
El siguiente código muestra un aviso de alerta con los botones Anular, Reintentar y Omitir.
Luego, utilizando la instrucción If-Then, el programa analiza la respuesta del usuario y
muestra otro cuadro de diálogo que nos confirma cual fue el botón presionado:
Dim a As Integer
a = MsgBox("Error grave, se ha perdido la información", vbAbortRetryIgnore +
vbCritical, "Error grave")
If a = vbAbort Then
MsgBox("Presionaste Anular")
End If
If a = vbRetry Then
MsgBox("Presionaste Reintentar")
End If
If a = vbIgnore Then
MsgBox("Presionaste Omitir")
End If
Figura 12 Figura 13
Como puede verse, resulta muy simple utilizar los controles disponibles en Visual Basic.
Hoy no hemos visto más que una pequeñísima parte de las opciones de uno de sus
controles, pero afortunadamente, la mayor parte de las características y propiedades de un
control existen y se utilizan de la misma forma en casi todos los demás. Esto facilitará
mucho nuestro aprendizaje.