GUIA N° 1 PROGRAMACION I

TEMA 1
 Introducción al Visual Basic.
 Manejo de los elementos básicos de un programa en Visual Basic.
 Constantes y Variables: Definición. Declaración.
 Declaraciones de entrada y salida: Input, Print, Let, Stop, Rem, End.

Hola Jovenes… aquí les dejo una guía donde se tocan todos los puntos que se
mencionan al principio…Pero como el título indica, esto será una cosa para introducir
al que quiere empezar a programar, incluso para el que viene de otro lenguaje,
aunque seguramente, sobre todo al principio, se encontrará con conceptos
demasiados básicos.
aquí iremos creando sobre la marcha, espero tus indicaciones sobre si voy demasiado
rápido o si realmente me estoy pasando en cuanto a 'simpleza'. De cualquier forma,
me gustaría oír tu comentario y tus impresiones, eso nos ayudara a mejorar.

Bueno, manos a la obra.

Lo advierto, a los que saben algo y a los que lo saben todo (o casi todo), lo que
viene a continuación es super básico. Y pensando también en los que por una razón
u otra no tienen unos conocimientos que a otros les parecerá absurdo, sé que aún hay
gente que no tienen ni remota idea de lo que es una expresión, una variable y ni que
decir tiene sobre las matrices, los números binarios o la notación hexadecimal...

¿Que es una variable?

En cualquier programa siempre necesitaremos hacer cálculos, usar información,
procesarla y mostrarla.
En la mayoría de los casos, necesitaremos un lugar temporal en el cual guardar parte
de esa información, incluso toda.
Todos los lenguajes, y el Basic no iba a ser menos, nos permiten guardar datos en la
memoria, para que cuando los necesitemos, podamos tomarlos, modificarlos y
volverlos a guardar para usarlos más tarde. Si no seguimos unas normas o usamos
unas reglas, de poco nos iba a servir el guardar esa información, si después no
podemos almacenarla en ningún sitio, pero ese será tema de otro capítulo... ahora
centrémonos en la memoria.
¿La memoria? Espero que este concepto lo tengas claro, pero si no es así, te
explico… La memoria es el lugar donde el ordenador almacena de forma temporal los
programas y parte de la información que necesita o utiliza. Así pues, los lenguajes de
programación usan también esa memoria para guardar información propia del
lenguaje y del programa que queramos realizar.
El programa una vez que se está ejecutando puede necesitar también guardar
información, aunque esta información sólo estará disponible mientras se esté
ejecutando. Esas posiciones o lugares de la memoria donde los programas pueden
almacenar información son las variables. El que se llamen de esta forma es porque
podemos hacer que el contenido de ese lugar de almacenamiento varíe, es como si
tuviésemos una serie de cajas y en ellas pudiésemos guardar cosas, con la salvedad
de que en cada caja sólo puede haber una cosa a la vez; aunque también veremos
cómo hacer que el contenido pueda variar y que varíe dependiendo de lo que contenía
antes...
Veamos un ejemplo:
Imagínate que quieres guardar tu nombre en una variable, para ello tendríamos que
'guardar' el nombre en la memoria, es decir asignar a una variable un valor. En este
caso nuestro nombre. Para ello el lenguaje de programación pone a nuestra
disposición unos lugares donde almacenar nuestro nombre, pero nos impone una serie
de reglas de conducta.
Si queremos guardar en una de nuestras cajas una hoja, por lo menos tendremos una
caja con el tamaño adecuado y que tenga una 'forma', para que el papel no vuele al
menor soplo de viento.
Esta es la regla básica para poder usar esos lugares de almacenamientos
(variables):
Llamar a esas posiciones de memoria con un nombre. Simple, ¿verdad?
En principio, es todo el requisito necesario: que le demos un nombre al sitio en el que
queremos guardar la información.
Por tanto, si queremos guardar un nombre, (el nuestro, por ejemplo), en la memoria,
podríamos llamarlo nombre.
Y ahora tendremos que seguir otra norma de conducta (o funcionamiento), que en
este caso el lenguaje Basic nos dicta:
Para guardar en una variable (posición de memoria) algo, debes hacerlo de la
siguiente manera:
---Pon el nombre con el que quieres llamar a esa parte de la memoria,
---a continuación pones el signo igual (=) y
---después lo que quieras guardar.
Por tanto para guardar Guillermo en la variables nombre, tendríamos que hacer (o
casi):
Nombre = Guillermo
Pero esto podía llevar a confusión, ya que el VB no nos dice nada sobre cómo
debemos llamar (o si lo prefieres, cómo hay que escribir) el nombre de una variable,
por tanto Guillermo también podría ser una variable,
Así pues, cuando queramos guardar en una variable una palabra, una frase, nombre o
cualquier tipo de información alfabética, tendremos que indicarlo poniendo dicha
información dentro de comillas dobles, el ejemplo quedaría así:
Nombre = "Guillermo"
Ahora no hay confusión posible, hemos seguido lo que el VB nos ha dicho: variable,
signo igual, valor a almacenar.
Si queremos guardar un número en una variable, la cosa es más simple:
Numero = 7

¿vamos bien claros hasta aquí?

Pero, ¿que ocurre si quisiéramos repetir 7 veces a Guillermo?

Podrías hacer esto, multiplicar a Guillermo por 7
Paliza = "Guillermo" * 7
Pero el Basic te diría que eso no está bien, no porque Guillermo no sea un paliza, sino
porque te diría que no coinciden los tipos (Type Mismatch)
¿Que son los tipos? Los distintos tipos de datos.
Los datos pueden ser, básicamente, de dos tipos:
Numéricos: sólo números y
Alfanuméricos: cualquier cosa, letras y/o números, pero es tratada como si fuesen
palabras, frases, etc.
Para el VB 7 y "7" son dos tipos de datos diferentes.
El primero es el número 7 y en el segundo caso, es el literal (o palabra) "7"
Así que cuando veas algo entrecomillado, piensa que no es un número, sino una
palabra (más vulgarmente llamada cadena de caracteres o string en inglés)
Hemos visto que no podemos multiplicar una palabra (cadena) por un número, pero
si podemos multiplicar una variable por un número (siempre que la variable sea
numérica, por supuesto)
Según esto, el VB debería permitir hacer esto:
Guillermo = 5
Paliza = Guillermo * 7
El VB tomaría el 5 y lo almacenaría en una variable numérica llamada Guillermo.
Después se encuentra con: Paliza = Guillermo * 7 y aquí lo que hace es evaluar la
expresión que está después del signo igual, lo calcula y el resultado lo guarda en la
variable que está a la izquierda del signo de asignación (=)
¿Expresión? Expresión es cualquier cosa que el VB tenga que 'desglosar' para poder
entenderla...
Por ejemplo cuando el VB se encuentra con 5 * 2 tiene que 'evaluar' lo que significa,
para poder hacer el cálculo, de esta forma sabrá que tenemos una operación en la
cual queremos multiplicar dos números, una vez que ha evaluado nuestra intención de
multiplicar esos dos números, efectuará el cálculo y almacenará el resultado en... si
no le decimos dónde, lo hará en una memoria que tiene para esas cosas, pero si no le
indicamos que debe hacer con ese resultado, nos dará un error...
Si le decimos simplemente: 5 * 2
El VB no sabrá que hacer con el resultado de esta 'expresión' (que por cierto es 10) y
nos Dara un error…
Así que lo más juicioso sería decirle, guárdalo en una variable, así que:
Resultado = 5 * 2 guardaría un 10 en la variable Resultado.
También podríamos decirle que nos mostrara el resultado, en lugar de guardarlo en
una variable, y aquí llega nuestra primera instrucción: Print. Con ella le decimos
al vB que lo imprima (o sea que los muestre, más adelante veremos dónde), según lo
dicho, haciendo esto:
Print 5 * 2, el vB diría que muy bien y mostraría un 10
Pero, volvamos al Paliza del Guillermo, es decir al ejemplo de Paliza = Guillermo
*7
Si quisiéramos mostrar el valor de Paliza, tendríamos que hacer algo como
esto: Print Paliza, y nos mostraría 35, ya que el valor de Paliza sería 35, porque el
contenido de Guillermo es 5 y 5 * 7 es 35 (y sin calculadora!!!)
Veamos si es cierto que Guillermo vale 5. Haciendo Print Guillermo, mostrará un 5.

Antes de seguir 'imaginando' las cosas, vamos a verla en funcionamiento. Es decir

vamos a probar que todo esto es cierto.
Carga el Visual Basic (si es que aún no lo has hecho).
Te creará un Form nuevo, que estará vacío.
Ciérralo y muestra la ventana de código.
Mostrará la parte de las declaraciones Generales del Formulario.
Si tiene escrito Option Explicit, (estará en la parte superior), bórralo, más adelante te
explicaré para que sirve.
Ahora sitúate en Form (selecciónalo de la lista desplegable que está a la izquierda), te
mostrará:

Private Sub Form_Load()

End Sub

Sitúate en medio, es decir, en una línea en blanco después del Private... y escribe el
ejemplo, quedaría así:
Private Sub Form_Load()
Show
Guillermo = 5
Paliza = Guillermo * 7
Print Paliza
End Sub

Pulsa F5, para ejecutar el programa, y verás que se escribe el 35.

Bien, ya tienes una forma de mostrar datos. Ahora veamos otros ejemplos, antes
debes parar el programa, para ello cierra el Form, pulsando en el botón que tiene una
X, o bien pulsa en el botón detener de la barra de herramientas del VB.
Sitúate de nuevo en el código del Form_Load, escribe después de la línea del Print, lo
siguiente:

Print Guillermo

Pulsa de nuevo F5 y verás que ahora además del 35, hay un 5 debajo. El valor de la
variable Guillermo.
Pero, ¿que ocurriría si cambiásemos el valor de Guillermo?
Añade estas líneas a continuación de la anteriores, para que quede de esta forma:

Private Sub Form_Load()

Show
Guillermo = 5
Paliza = Guillermo * 7
Print Paliza
Print Guillermo
Guillermo = 10
Print Guillermo
Print Paliza
End Sub

Después de pulsar F5, te mostrará los siguientes valores (cada número en una línea),
35, 5, 10, 35
¿Esperabas que el último fuese 70?
Fíjate que cuando asignamos a Paliza el contenido de Guillermo, éste era 5, por
tanto el Basic evaluó la expresión 5 * 7 y almacenó el resultado (el 35). Una vez
almacenado el resultado, el Basic se olvidó de dónde había sacado ese 5.
Si queremos que se 'actualice' el valor de Paliza, tendremos que indicárselo de nuevo
al Basic, para que vuelva a evaluar la expresión y hacer la correspondiente
asignación. Para ello, pon en medio de los dos últimos prints la siguiente asignación:
Paliza = Guillermo * 7
Esta vez, al ejecutar el programa, mostrará un 70, que será el nuevo contenido
de Paliza.

Ya para terminar, borra todo lo anterior y escribe: (por supuesto debes detener el
programa...)

Private Sub Form_Load()

Show
Nombre = "Guillermo"
Print Nombre
End Sub

Pulsa F5 y verás que se muestra el contenido de la variable Nombre, es decir

Guillermo.
Prueba ahora con esto otro (es un clásico):
Print "Hola Mundo"
Y para rematar, y de camino ver otra posibilidad del Print, escribe en lugar del Print
Nombre:
Print "Hola " ; Nombre
El punto y coma, se usa para indicarle al Basic que se deben mostrar las cosas una a
continuación de la otra.
Ahora te habrá mostrado: Hola Guillermo, fíjate que después de hola y antes de
cerrar las comillas hay un espacio.

Bien, Antes que nada una pequeña aclaración, para que los ejemplos que explique
antes deberan poner un Show en el form Load antes de los Prints, para que se
muestre algo... sino no se verá nada.

Una vez hecha esta pequeña aclaraciٔón, sobre el manejo de entrada de datos y una
forma un poco más práctica de mostrar los datos, empezaremos a vernos ya con lo
que es programar con Windows, es decir el manejo de eventos, o al menos el
movernos dentro de los eventos y saber "controlarlos" para las cosas que queramos
hacer.

Con el "basic clásico", no había problemas. Las cosas se producían de forma lineal, es
decir empezaban por el principio del programa y se iban ejecutando a medida que se
avanzaba por él. Salvo en las ocasiones en las que en un momento dado "saltábamos"
a otro sitio, pero era porque nosotros así lo habíamos programado. De una forma u
otra teníamos control total sobre lo que podía ocurrir. Pero en Windows (o los
entornos dominados por los eventos), la cosa no es tan sencilla.
Debemos controlar todas (o casi) las posibilidades que se pueden producir...

Antes vamos a dejar un par de cosillas claras. Según como tengas configurado el
entorno de desarrollo, habrás tenido problemas con los ejemplos anteriores. La razón
es que el Visual Basic nos permite controlar un poco mejor el tema de las variables
que queremos usar. Ese control lo da la instrucción: Option Explicit. Si ponemos
esto en la parte destinada a las declaraciones de cualquier módulo, nos obligará a
declarar las variables que vamos a usar en dicho módulo.
En el último ejemplo, teníamos una variable llamada Nombre, en la cual almacenamos
 un nombre, por tanto podríamos haberle avisado a Visual Basic que reservara espacio
para una variable, y para hacerlo usamos la instrucción DIM, con ésta le
indicamos que nos guarde un "espacio" de la memoria para nuestro uso:
Dim Nombre
También nos ofrece una variante con respecto al "basic clásico" y es, precisamente, el
tipo de datos variant. Con este tipo podemos asignar a una variable cualquier tipo
de dato. Desde un número hasta una cadena de caracteres, pasando por cualquier
tipo de objeto que Visual Basic pueda manejar (más o menos).

Los que hayan tenido experiencias anteriores, con Basic u otro lenguaje, sabrán que
cada variable debe ser del tipo de datos que queramos asignarle. En VB por supuesto
esto también es posible y recomendable.
Ya vimos que los tipos de datos podían ser numéricos o de caracteres. Pero dentro de
los numéricos, tenemos cuatro tipos básicos: enteros, enteros largos, simples y
dobles. Cada uno de ellos tienen unas capacidades determinadas, además de ocupar
más memoria o menos, (ahora lo veremos), lo más importante es que los números
enteros y entero largo sólo admiten números enteros (de ahí sus nombres), es decir
que no admiten decimales. Sin embargo los otros dos si admiten decimales.
Estas capacidades puedes encontrarlas en el manual del basic o en la ayuda, lo que a
mi me interesa que sepas es cómo poder indicarle al Visual Basic que reserve ese
espacio de memoria para un tipo determinado. Ya te he dicho que el espacio que
ocupa en memoria es diferente para cada uno de estos tipos, veamos en la siguiente
tabla cómo declararlos y cuanto ocupa:

Espacio Tipo de
Tipo Ejemplo
ocupado declaración
Entero 2 bytes Integer Dim Numero As Integer
Entero Largo 4 bytes Long Dim Numero As Long
Simple 4 bytes Single Dim Numero As Single
Doble 8 bytes Double Dim Numero As Double
En el caso de las variables que van a guardar nombres (cadenas de caracteres), se
deben declarar como String y el espacio que ocupa será 4 bytes más un byte por cada
caracter que tenga, en el caso de VB de 32 bits realmente ocupará 2 bytes por cada
caracter que tenga.
La longitud máxima de una variable del tipo String será de aproximadamente 32.000
caracteres y la forma de declararla será:
Dim Cadena As String
Una vez declarada podemos asignarle la cantidad de caracteres que queramos (sin
pasarnos) y cuantas veces queramos.
Hay que tener en cuenta que en cualquier variable sólo se queda el último valor
asignado. Ya lo vimos en la entrega anterior, pero vamos a refrescarlo un poco:

Dim Número As Integer

Número = 5
Print Número
Número = 12
Print Número
En este ejemplo, el último valor almacenado en Número es el 12. El 5 que tenía en un
principio se perdió.
Pero, ¿que tengo que hacer para sumarle una cantidad al valor almacenado en una
variable?
Es decir, ¿cómo incrementar el valor de una variable numérica?
La respuesta la tienes en cómo se manejan las expresiones y las asignaciones a las
variables. Como ya vimos anteriormente, al asignar a una variable una expresión,
primero se calcula la expresión y una vez obtenido el resultado, se asigna a la
variable.
¿Recuerdas lo que ocurría con la variable Paliza? Vamos a verlo de nuevo, pero
usando otros nombres menos "cachondos"

Dim N As Integer
Dim M As Integer
N = 10
M = N * 3
Print M

El resultado de este programa sería 30, que es lo que resulta de multiplicar 10 por 3.
Cuando se asigna a la variable M el valor de N (que es 10) multiplicado por 3, el VB
toma el contenido de N y lo multiplica por 3. Una vez que sabe la solución, asigna ese
valor, en este caso 30) a la variable que hay a la izquierda del signo igual.
Sabiendo esto, podríamos simplificar la cosa y hacer los siguiente:

N = N * 3
Print N

También obtendríamos 30. Ya que cuando el VB calcula la expresión de la derecha del

signo igual, N vale 10, una vez obtenido el resultado del cálculo lo asigna a la variable
de la izquierda del signo de asignación, sin importarle lo más mínimo de que variables
es y cómo en este caso hemos usado la misma, pues se queda el último valor,
perdiéndose el que originalmente estaba "guardado". Esto es útil cuando necesitamos
"contar" de forma secuencial, para así incrementar el valor de una variable.

Ya veremos alguna "utilidad" para estos casos. Ahora vamos a ver cómo podemos
manejar las cadenas de caracteres, es decir las variables de tipo String.
Con estas variables ocurre lo mismo que con las numéricas, pero la única operación
que podemos realizar es la suma.
Realmente una suma en una cadena de caracteres es "pegar" dos cadenas en una
sola.
Por ejemplo si hacemos esto: N = 3 + 2. El valor obtenido es 5 y eso es lo que se
guarda en N.
Sin embargo con los strings hacer esto: Cadena = "A" + "B", se guardará "AB", es
decir se unirán las dos cadenas en una sola. Para este tipo de operación se
recomienda usar mejor el signo &. Que entre otras cosas le indica al Visual Basic que
lo que pretendemos hacer es unir dos cadenas, no sumarlas.
Aunque "teóricamente" no se pueden sumar cadenas, sólo con-catenarlas, veremos
cómo podemos llegar a producir "problemillas" de entendimiento entre el VB y
nuestras "mentes poderosas".
Como te he comentado al principio el tipo de datos Variant acepta de todo, números,
nombres, etc.
Si no le indicamos de forma correcta al VB cual es nuestra intención, podemos
confundirle y hacer que el resultado de algo que nosotros dábamos "por hecho", al
final se convierte en un pequeño caos para nuestras pobres mentes.
Vamos a verlo con un par de ejemplos, en estos casos: (al no indicarle de que tipo
son las variables, el Basic entiende que nuestra intención es usar el tipo Variant)

Dim Num1
Dim Num2
Num1 = 5
Num2 = 3
Num1 = Num1 + Num2
Print Num1

¿Que imprimirá? Pruébalo y saldrás de duda. Bueno, imprimirá un 8.

Ahora veamos este otro ejemplo:

Dim Num1
Dim Num2
Num1 = "5"
Num2 = "3"
Num1 = Num1 + Num2
Print Num1

Fíjate que lo que varía es sólo las comillas. El resultado en este caso es 53, es decir
ha unido las dos cadenas.
Ahora quita las comillas del 5, para dejarlo así:

Dim Num1
Dim Num2
Num1 = 5
Num2 = "3"
Num1 = Num1 + Num2
Print Num1

Alehop! ¿Que ha pasado? Pues que ha impreso un 8, es decir ha "pasado" de que el

tres sea una cadena de caracteres y lo ha tomado por un número...
En esta ocasión, sólo vamos a cambiar la línea de la asignación para dejarla de esta
forma:

Num1 = Num1 & Num2

El resultado será 53. Porque le hemos indicado que una las dos cadenas, por tanto al
encontrase con esta "operación" ha considerado al número 5 como una cadena, en
lugar de un número.
Cambia ahora la asignación del Num2, para que sea: Num2 = 3
Vuelve a mostrar 53, el signo & tiene unos poderes enormes... y a pesar de ser dos
números la única operación que puede realizar es la concatenación de cadenas, por
tanto el tipo Variant se convierte por arte de magia en cadena.
Pero fíjate si es "fuerte" el poder de convicción que tiene este operador, que aunque
cambiemos el tipo de las variables, sigue "convenciendo" al basic que tipo de
operación debe hacer. Esto no debería ocurrir así, pero ocurre.

Dim Num1 As Integer

Dim Num2 As Integer
Num1 = 5
Num2 = 3
Num1 = Num1 & Num2
Print Num1

Sigue mostrando 53, aunque en este caso debería producir un error, ya que un
Integer no es una cadena.
Así que "cuidadín" con las operaciones que realizamos. Ya que si añades esta línea:

Print Num1 * 2

Verás que realmente Num1 tiene guardado un número y el resultado será: 106

¿A dónde nos lleva todo esto? A que debemos usar los signos (operadores) de forma
adecuada. Y si nuestra intención es sumar números, empleemos el signo +, en caso
de que queramos unir cadenas de caracteres, usaremos el &

Para rematar esta segunda entrega, vamos a usar un textbox para que se puedan
introducir datos y empecemos a manejar los eventos, mejor dicho empecemos a
"habituarnos" a los eventos.

Añade al form dos Label, un TextBox y un botón de comandos. El aspecto será algo
parecido al de la siguiente figura:
Añade el siguiente código y después ejecuta el programa, ya sabes F5. Escribe algo en
el cuadro de texto y pulsa en el botón.

Private Sub Form_Load()

Label2 = ""
Text1 = ""
End Sub

Private Sub Command1_Click()

Label2 = "Hola " & Text1
End Sub

Cuando pulsas F5, se produce el evento Form_Load, por tanto se asigna al Label2 y al
Text1 una cadena vacía, con lo cual borramos el contenido anterior, que es el que se
muestra en la Figura.
Hasta que no pulsemos el botón mostrar, no ocurrirá nada y el programa estará
esperando a que ocurra algo.
Una vez pulsado el botón, se produce el evento Click del Command1 y se hace lo que
se indica en su interior, que es tomar lo que hay en la caja de texto y unirla a la
palabra Hola, para asignarla al Label2.

Ahora, imagínate que quieres mostrar el nombre en mayúsculas. Lo único que

tendrías que hacer es lo siguiente:

Private Sub Command1_Click()

Label2 = "Hola " & UCase(Text1)
End Sub

Lo que se ha hecho es decirle al VB que convierta en mayúsculas lo que ya está en

Text1. Esa es la "utilidad" del UCase.
Pero y ¿si quisiéramos que conforme se va escribiendo se vayan convirtiendo los
caracteres a mayúsculas?
Aquí entrarían más instrucciones/funciones del Visual Basic, así cómo otro de los
eventos que pone a nuestra disposición, en este caso el evento que se produce cada
vez que se modifica el contenido del textbox: Change, escribe lo siguiente:

Private Sub Text1_Change()

Text1 = UCase(Text1)
End Sub

Pruébalo y verás lo que ocurre. Queda "guay" ¿verdad? Pero no es lo que nosotros
pretendíamos. Vamos a intentar remediarlo y de camino vemos nuevas
instrucciones/propiedades, en este caso del TextBox.
 Private Sub Text1_Change()
Text1 = UCase(Text1)
Text1.SelStart = Len(Text1)
End Sub

La línea que se ha añadido (realmente la habrás tecleado tú), lo que le indica al Visual
Basic es que haga lo siguiente:
Calcula la longitud del contenido del Text1, (Len cuenta los caracteres de una cadena
y lo devuelve como número), SelStart es una propiedad del TextBox que entre otras
cosas, le indica la posición en la que se insertará el siguiente caracter que se escriba o
bien nos puede indicar la posición actual del cursor. Por tanto obliga a poner el cursor,
(el palico ese que parpadea y que nos indica que podemos escribir), al final de la
última letra que contiene el Text1.
Ahora ya sabes que cada vez que "cambie" el Text1, se produce un evento Change.

Pero hay otra forma de hacer esto mismo y es controlando cada tecla que se pulsa.
Esto lo podemos "controlar" en el evento KeyPress, el cual se produce cada vez que se
pulsa una tecla. Borra el procedimiento anterior y escribe este otro:

Private Sub Text1_KeyPress(KeyAscii As Integer)

Dim s As String

s = UCase(Chr(KeyAscii))
KeyAscii = Asc(s)

End Sub

Ahora han entrado dos nuevas funciones en acción: Chr, la cual convierte un número
en una cadena... realmente convierte un código ASCII en la letra que representa
(busca en la ayuda ASCII y léete lo que dice en las opciones que te muestra). Por otra
parte Asc hace lo contrario, es decir convierte una letra en el código ASCII. Y lo que
nosotros hacemos es: convertir el código de la tecla pulsada, representado por la
variable KeyAscii, en una cadena, la pasamos a mayúsculas y después la volvemos a
asignar a la variable, para "engañar" al Visual Basic y así hacerle pensar que
realmente hemos tecleado una letra en mayúsculas.

TEMA 2
 Operadores lógicos, relacionales y lógicos
 Comparaciones simples, compuestas y bloques.
 Condicionales e incondicionales
 Iteraciones
 Locación línea-columna
Para introducir código en cualquiera de los eventos de los controles o del formulario,
lo único que tienes que hacer es seleccionar el control y el evento que queremos
codificar de las listas desplegables, en el módulo de código, pulsando en Código en la
ventana en la que se muestra los módulos y formularios que forma un proyecto. En la
lista de la izquierda seleccionamos el control y en el de la derecha nos mostrará todos
los eventos soportados por VB para ese control. Si sabemos el nombre del control y el
del evento, podemos teclearlo directamente o bien si copiamos código de otro sitio,
simplemente con pegarlo, se va a su sitio.
En el caso de querer añadir al código, una función o procedimiento se puede hacer de
varias formas, lo acabo de decir, pero lo repito un poco más claro:

1. Directa: Escribir el código directamente, con lo cual se creará un nuevo

"apartado" en la lista de las funciones/ procedimientos. En caso de que no sea

un evento soportado por los controles de nuestro formulario, se mostrará en la

lista de la izquierda, estando seleccionada en la derecha "General"

2. Copiar/Pegar: Pues eso, si copias una función/procedimiento y lo pegas en la

ventana de código...

3. Por menú de VB: Según las distintas versiones de VB, será un menú u otro,

deberás especificar el nombre del procedimiento o la función, marcando la

casilla correspondiente. En VB4/VB5 verás que aparte de los Procedimientos

(Sub) y las Funciones (Function) hay también Propiedades (Property), estas las

veremos en otra ocasión. También verás que puedes declararlas Públicas o

Privadas. Esto no es posible en VB3, al menos en los procedimientos y

funciones de los formularios.

En otra ocasión veremos todas estas cosas y con ejemplos, que es lo que "mola".
Bueno, toda esta "retahíla" venía a cuento de cómo introducir código en los eventos
de los controles o del formulario y cómo crear nuestras propias instrucciones (esto es
lo que más me gustó del QuickBasic 4.0, poder crear mis propias instrucciones (subs)
y funciones).

Ya es hora de coger el listado de la entrega anterior y "destriparlo". Vamos a ver cada

cosa por separado, que aunque parezca que es mucho código, realmente está
"repetido", o casi...

Option Explicit

Esto nos obliga a declarar todas las variables que usemos en el módulo, ponerlo es
una recomendación, incluso te la impondría como norma. Para que salga de forma
automática en cada nuevo módulo, selecciona del menú Tools/Advanced la opción
Declare variables required (o algo parecido, que viene a significar Requiere la
declaración de variables)
Siguiendo nuestro recorrido por el código, no encontramos con:

Private Sub Command1_Click()

Lo de Private significa que sólo se puede acceder a este procedimiento desde dentro
del módulo en el que está declarado. Es decir no se puede llamar desde otro form o
módulo BAS.
Sub indica que es un procedimiento, no una función, ni una propiedad. Los Subs
actúan como instrucciones propias del lenguaje. Las funciones también, pero
devuelven un valor, mientras que los subs no devuelven nada, lo que cogen se los
quedan ellos, aunque en su momento veremos que también nos pueden dar algo a
cambio.
Command1_Click, este es el nombre que habrá que usar para acceder a él desde
cualquier punto de éste módulo.
Los paréntesis sin nada dentro, indica que este procedimiento no recibe parámetros;
los parámetros lo veremos dentro de un "ratillo"
Toda esta línea es la descripción del procedimiento y cuando se le llame, bien desde
nuestro propio código, bien porque se pulse sobre el botón, se ejecutará todo lo que
esté dentro de él. El final del procedimiento está marcado por End Sub.

Las líneas con DIM indican que estamos declarando las variables y lo que se
especifica después del AS es el tipo de variable, los cinco primeros son de cada uno
de los tipos numéricos soportados (otro día veremos otro tipo cuasi-numérico), el
sexto es Variant, el multi-uso, el que vale para todo.

Veamos ahora que es lo que se hace con esta línea:

Dim timer1#, timer2 As Double
Aquí he declarado dos variables del tipo Double. Al separarlas con comas no hay que
repetir la palabra DIM, pero sí el tipo de cada variable. Ya vimos en la entrega
anterior que algunos tipos de variables se podían indicar mediante unos caracteres
especiales, (estos tipos son los heredados de versiones anteriores al Visual Basic 2, en
esa versión, se introdujo el tipo Variant), en este caso # es lo mismo que Double,
por tanto se podría haber hecho también de cualquiera de estas tres formas:
Dim timer1#, timer2#
Dim timer1 As Double, timer2#
Dim timer1 As Double, timer2 As Double

Ahora fíjate que esta otra no haría la misma tarea:

Dim timer1, timer2 As Double
Esto funcionaría con lenguajes como el C, (realmente el tipo se pone delante), pero en
Basic no declara las dos variables como Double. La segunda variable si es Double,
pero la primera es del tipo por defecto, en nuestro caso Variant.
Así que mucho ojito con las declaraciones de las variables. En algún sitio, no voy a
decir dónde, porque lo mismo fue un "lapsus" del autor, pero decía que de esta forma
declaraban tres variables de tipo Integer:
Dim i, j, k As Integer

Sigamos nuestra andadura, ahora veamos esta declaración/asignación:

Const minBucle = 1, maxBucle = 10
Aquí lo que se declaran son dos constantes, éstas a diferencia de las variables, no
pueden cambiar de valor, de ahí su nombre, por tanto permanecerán siempre con el
mismo valor. Cuando se declara una constante, no es necesario especificar el tipo, VB
se encarga de adivinarlo y usar el tipo adecuado, realmente lo que hace es sustituir
estas "palabras" por el valor que hay después del signo igual. En caso de hacer
esto: cNombre = "Una palabra". Visual Basic sabe que es una cadena de caracteres
y cada vez que se encuentre con cNombre lo sustituirá por "Una palabra".
Ahora viene la explicación del "por qué" usar constantes. Además de "esclarecer" los
listados, los hace más fáciles de comprender, también nos permite modificar un valor
en un sólo sitio, con lo que ganamos en "confianza", al asegurarnos de que no
omitiremos alguno de los sitios dónde tengamos o queramos cambiar el valor antiguo
por uno nuevo.
En nuestro ejemplo, minBucle y maxBucle se usan en seis partes diferentes del
procedimiento, si quisieras probar con otros valores, tendrías que cambiar en seis
sitios esos valores, pero al declararlos como constantes, sólo cambiando el valor
asignado, tenemos todo el trabajo hecho. Esto además de ser más fiable y legible, nos
puede ahorrar algún que otro quebradero de cabeza y si además le añadimos que no
ocupan espacio extra, salvo en la tabla de símbolos, una vez compilado el programa
sólo se "compilarán" las constantes usadas. Sin embargo con las variables no ocurre
esto, ya que aunque no se usen, ocupan memoria.

Un inciso, esto de explicar tan detalladamente los listados, no va a ser norma, ya que
al final todos nos aburriríamos, sólo lo haré cuando lo crea conveniente o bien si lo
solicitas, en este caso, no tendré más remedio que cumplir tus deseos...

Command1.Caption = "Calculando..."
Cambiamos el texto mostrado en el botón, para avisarnos de que está haciendo
algo...

timer1 = Timer
Asignamos el valor de la función Timer a la primera de las dos variables que usaremos
para calcular el tiempo empleado por cada uno de los bucles. Esta función devuelve el
número de segundos transcurridos desde la media noche.

For nInt = minBucle To maxBucle

Esto es un bucle, que se repetirá desde minBucle (1) hasta maxBucle (10) y la
variable nInt es la que llevará la cuenta o la que se usará para saber el valor actual
del bucle.

Deberíamos ver primero la declaración del procedimiento Contar, para entender lo

que hace la línea que viene después del For.

Private Sub Contar(valor As Integer, etiqueta As Control)

Declaramos un procedimiento privado llamado Contar (actúa como una instrucción
más del VB, ya que no representa a ningún control ni evento), entre los paréntesis
están declarados los dos parámetros que espera recibir en la llamada, el primero es
un número entero y el segundo (separado por una coma), un Control, que puede ser
cualquier control de VB.
El resto del procedimiento ahora no es demasiado significativo

Ahora veamos esta línea:

Contar CInt(nInt), Label1
Contar es el nombre del procedimiento y a continuación se deben indicar los
parámetros que espera recibir. En este caso no sería necesario CINT ya que lo que
hace esta función es convertir el número que se pone dentro de los paréntesis en un
número entero y como resulta que nInt es un número entero... pues ¡no hay nada
que convertir!
El segundo parámetro es el control Label1, ya sabes que tenemos 6 etiquetas en
nuestro programa desde Label1 a Label6
Cuando llegue estos datos al procedimiento Contar, valor tomará lo que valga nInt y
etiqueta se adueñará de Label1.

Next
Continúa repitiendo el bucle hasta que se alcance el valor máximo, realmente el Next
lo que hace es lo siguiente:
nInt = nInt + 1
¿Es nInt menor o igual que maxBucle? Si la respuesta es SI, sigue con lo que haya
después de la línea FOR, en caso negativo continúa con la línea siguiente al Next
(realmente en la siguiente instrucción después del Next, ya veremos esto en otra
ocasión)

timer2 = CDbl(Timer - timer1)

Asignamos a la segunda variable que usamos para el cálculo del tiempo la diferencia
entre el nuevo valor de los segundos transcurridos desde la media noche (Timer) y el
valor que tenía timer1, es decir cuantos segundos... antes de empezar el bucle.
El CDBL es una fución que devuelve un valor Doble. Es decir hace la resta y ese valor
resultante lo convierte en doble.

Label1 = "Duración con Integer: " & timer2

Esta asignación realmente es Label1.Caption, si se omite la propiedad, Visual Basic
usa la que tiene por defecto, que según los manuales, suele ser la propiedad que se
usa con más frecuencia. En este caso el Caption, es decir lo que se muestra en la
etiqueta.

DoEvents
Esta es una instrucción "controvertida" y a la que muchos programadores no les hace
demasiada gracia usar, no porque no tenga su utilidad, sino porque hay que saber
realmente lo que hace y tener cuidado cuando la usamos, ya que algunas veces puede
crear errores o confusión... realmente no es tan drástico, pero casi...
DoEvents, detiene la ejecución del programa y devuelve el control a Windows, para
que ejecute los mensajes que tiene pendientes en la cola de mensajes... ¿? no te
preocupes si no te enteras, es así y punto. ¿por qué la uso? Pues para dar tiempo a
que se vea el contenido del Label; prueba a quitarla y verás lo que ocurre, o debería
ocurrir... que ya a estas alturas no me sorprendería nada que se mostrara...

El resto del programa es idéntico a este bucle, pero usando distintas variables y las
demás etiquetas. El caso es que Contar espera una variable de número entero y un
control, en el caso del control es obvio que se están poniendo las distintas etiquetas y
en el caso del número se convierte a entero, porque eso es lo que espera nuestra
instrucción y si no lo hacemos así, se quejará.

Ya sólo queda ver una línea del procedimiento Contar:

etiqueta.Caption = valor * elMaximo + unDoble
unDoble contará desde 1 hasta elMaximo, en cada vuelta del bucle, se asignará al
caption de la etiqueta pasada al procedimiento y el DoEVents que viene a
continuación se encargará de que se muestre ese contenido. Bueno, también se
asigna valor * elMaximo, es decir que cuando valor valga 1, se estará mostrando
1000 + unDoble, realmente para hacer un contador se tendría que haber usado lo
siguiente:
etiqueta.Caption = (valor -1) * elMaximo + unDoble, para que mostrara desde
el 1, en lugar de empezar desde el 1001.

Una vez que Contar termina, por el End Sub, vuelve el control al bucle que lo llamó y
se ejecuta la siguiente instrucción. Por tanto Contar se llamará tantas veces como
dure el bucle en el que se encuentra.

Creo que queda todo más o menos claro y aunque este código no es muy útil por sí,
ha servido para ver algunas cosillas del VB.

Para terminar vamos a ver una serie de cambios y a ver si adivináis que es lo que
hace... así os servirá de ejercicio, cosa que algunos me habéis pedido, pero que aún
no es el momento de hacerlos.

En las declaraciones generales añade esta declaración:

Dim Contando As Integer

En Contar, añade lo siguiente después del DoEvents:

If Contando = 0 Then Exit For

Al principio del Command1_Click, añade estas líneas:

If Contando Then
Command1.Caption = "Calcular"
Contando = 0
DoEvents
Exit Sub
End If
Contando = 1

En cada uno de los bucles, pon esto después de llamar a Contar...

If Contando = 0 Then Exit Sub

Y antes del End Sub añade esto otro:

Command1.Caption = "Calcular"
Contando = 0

Bueno, ahí dejo esto y como ejercicio podrías añadir dos controles TextBox para
especificar los valores de maxBucle y elMaximo, de forma que según los valores
introducidos, que por defecto deben ser 10 y 1000, se usen los que especifiques en
cada TextBox y se tengan en cuenta cuando pulsas (haces click) en el botón.
Como pista te diré que las variables usadas y/o declaradas dentro de un
procedimiento son sólo visibles dentro de ese procedimiento. No te quejarás del
"pedazo" de pista que te he dado...

If Contando Then...
Ah, si... no he explicado para que sirve esto del If...Then...
Las instrucciones If/Then se usan para comprobar si la 'expresión' que se usa después
del IF se cumple o no...
En caso de que se cumpla (sea cierta), se ejecutará todo lo que haya después de
THEN... algo así:

IF <EXPRESIÓN> THEN <INSTRUCCIONES>

También puede usarse de esta otra forma:

IF <EXPRESIÓN> THEN
<INSTRUCCIONES>
[<MÁS INSTRUCCIONES>]
END IF

En la primera forma de uso, las instrucciones se ponen a continuación de THEN como

en el caso de:
If Contando = 0 Then Exit For
En la otra forma de usarlo, las instrucciones se ponen en las siguientes líneas y
podemos escribir tantas líneas como queramos. Todas se intentarán procesar...
Esto para el caso de que al evaluar la expresión se cumpla como verdadero.
En las ocasiones en las que no se cumple la expresión se hará lo siguiente, según la
forma de usar el IF/THEN:
--En el primer método, se procesan las instrucciones que hay en la siguiente línea y
se continúa a partir de ahí el programa.
--En el segundo caso, se busca END IF y se continúa por la siguiente línea...

Más adelante, en otra entrega, veremos otras formas de usar IF...THEN...

Ahora voy a explicar un poco esto de la evaluación de las expresiones.

El IF espera encontrar un valor CERO (FALSO) o un valor distinto de cero (por
extensión VERDADERO)
En If Contando = 0 Then Exit For, la expresión es Contando = 0, aquí no
se está usando la asignación, sino que se está evaluando si el contenido de la variable
Contando es igual a cero; en caso de que sea cierto, es decir que Contando valga
cero, (algunas veces me maravillo de mi lógica aplastante...), se devuelve un valor
Verdadero (TRUE).
Por otra parte si Contando NO vale cero, se devolverá un valor Falso (FALSE, CERO).

En otros lenguajes se usa un símbolo distinto para el igual, según sea una asignación
o una comparación.
En Pascal (Delphi) la asignación es := y la comparación es =
En C, C++, la asignación es = y la comparación == (esto del == puede 'sonarte' si
has hecho algo con JavaScript)

En el caso de If Contando Then, al no haber una expresión que evaluar, lo que

se comprueba es si el contenido de la variable es cero o no es cero, en caso de que
sea NO CERO, se cumple la condición y se procesa todo lo que viene a continuación;
pero si la variable vale CERO, el IF lo interpretará como FALSO y pasa a ejecutar lo
que haya a continuación de End If.

Por tanto, (volviendo por fin al listado), la primera vez que se pulse en el botón
Command1 y se compruebe esto:
If Contando Then
No se cumplirá la condición, ya que el contenido de Contando es cero, y se pasará a lo
que hay después del End If, es decir a:
Contando = 1
y se continúa con el programa como antes de añadir todas estas cosas...

Pero, si pulsas de nuevo en el botón, se vuelve a procesar lo que hay dentro de

Command1_Click, (esto es posible porque al usar DoEvents, permitimos que Windows
siga recibiendo y procesando 'tiritos'), pero cuando entramos por segunda vez,
Contando vale 1 (uno), (ya que al ser una variable a nivel de módulo conserva el
último valor que hayamos asignado), y esta vez al evaluar:
If Contando Then
si se cumple, así que se procesan las líneas que vienen a continuación... entre ellas
está Contando = 0 y DoEvents que vuelve a permitir a Windows que las otras cosas
que antes de pulsar en el botón continúen ejecutándose, (esto se hace de
forma asíncrona, es decir, Windows se da por enterado y da los avisos (mensajes)
cuando quiera), pero continúa con la siguiente instrucción sin esperar a que esos
mensajes se terminen de procesar, entonces se encuentra con el Exit Sub que lo
manda fuera del evento... (Si no te ha quedado demasiado claro, no te preocupes
veremos más de esto a lo largo del curso...)

En caso de que hayamos pulsado el botón cuando aún no había terminado todo lo que
este Sub estaba haciendo, se continúa igual que si se hubiese hecho PAUSA y después
PLAY.
Con la salvedad de que si VB se encuentra con alguno de los If Contando = 0 Then
Exit Sub, dejará de procesar y se saldrá del procedimiento... Esta no es la mejor
forma de cancelar una tarea ya iniciada, pero algo es algo...
También es posible que al pulsar por segunda vez en el botón, se estuviese dentro del
Sub Contar, en este caso, también se evaluaría la expresión y se saldría del
procedimiento... así que también dejaría de procesarse todo.

Cuando pulsemos por tercera vez... iniciaremos el proceso de nuevo...

Como hemos visto anteriormente, la instrucción IF... THEN... nos permite tomar
decisiones según el valor de una variable o el resultado de una expresión. En esta
guía veremos cómo sacarle rendimiento a esta instrucción.
Pero antes de entrar en detalles, veamos cómo podemos decirle al VB que haga las
cosas. En realidad, vamos a ver la forma en que se le puede decir que las haga...

Forma de especificar las instrucciones en Visual Basic

Las instrucciones en Basic no tienen porqué estar cada una en una línea. Se pueden
escribir varias instrucciones en la misma línea, pero separando cada una de ellas con
el signo : (dos puntos).
Cuando VB encuentra los dos puntos, deja de 'interpretar' la instrucción y pasa a la
acción, una vez traducido a su lenguaje interno, toma lo que hay después del
signo : y sigue su camino en busca de más instrucciones o el final de la línea.

Veámoslo de forma práctica:

Nombre = "Pepe" : Print Nombre
Esta línea tiene dos instrucciones: una asignación y una instrucción Print.

Podemos poner cuantas instrucciones queramos, separadas con los dos puntos.

Pero, (siempre hay un pero), si una de las instrucciones es el IF/THEN la cosa puede
cambiar...

Ya vimos que IF comprueba la expresión que viene a continuación, si es cierta,

ENTONCES procesa lo que haya después de THEN. En caso de ser en la misma línea,
interpretará todas las instrucciones que estén a continuación; en caso de ser un
bloque IF... THEN... END IF, ejecutará todo lo que esté dentro de ese bloque. Ahora
bien, si la expresión es falsa pasa a la siguiente línea, tanto si es o no un bloque. En el
caso del bloque la siguiente línea a interpretar será la que esté después de END IF.

En los tiempos del BASIC interpretado de MS-DOS, era habitual encontrar las líneas
con varias instrucciones separadas por dos puntos.
En mi caso, cuando empecé a usar el QuickBasic 2.0 y al poder usar bloques IF...
THEN... END IF, fui dejando a un lado el "mogollón" de instrucciones en la misma
línea...
Ahora, salvo en contadas excepciones, escribo cada instrucción en una línea. Y te
recomiendo que hagas lo mismo, tu código ganará en claridad y si alguna vez vuelves
a verlo, te será más fácil de entender.

Después de este pequeño respiro, veamos cómo estaría formada una línea de VB para
usar con un IF... THEN...

[instrucciones:] IF <expresión> THEN <instrucciones si es cierto [:más

instrucciones...]>

A continuación de THEN podemos incluir cuantas instrucciones queramos, separadas

por dos puntos.
Estas sólo se ejecutarán cuando la expresión sea cierta. Si el resultado de la expresión
es falso, se obvia 'todo' lo que hay después de THEN y se pasa a la siguiente línea.
Espero que lo hayas asimilado y que no te indigestes con lo siguiente...

Pero, (...), existe otra instrucción que PUEDE acompañar al IF... THEN... y es para los
casos en los cuales el resultado de la expresión sea FALSO.
Si, ya sé que dije que cuando es falso se pasa a la siguiente línea, pero eso es cuando
no se usa la cláusula ELSE.
Con ésta, la definición de la instrucción "tomadora de decisiones" quedaría así:

IF <expresión> THEN <si se cumple> ELSE <si no se cumple>

Tanto en <si se cumple> como en <si no se cumple> pondremos tantas instrucciones

como queramos, (separadas por dos puntos).
Pero no te recomiendo que lo hagas, es preferible, al menos para darle "claridad" a
nuestro código, usar el bloque:

IF <expresión> THEN
<si se cumple>
ELSE
<si no se cumple>
END IF

Sé que esto puede ocupar más líneas de código, pero nuestro "coco" lo agradecerá, ya
que es más fácil de comprender, sino veamos un ejemplo:

IF numero > limite THEN

Print "tu número es grande"
ELSE
Print "OK, McKey!"
END IF

Ahora veámoslo en una sóla línea:

IF numero > limite THEN Print "tu número es grande" ELSE Print "OK,
McKey!"

En este ejemplo, aún queda claro, pero lo podríamos complicar con más instrucciones
para ambos casos, es decir, para cuando la expresión es cierta y también cuando es
falsa.

En los tiempos del BASIC que venían incorporados con los ordenadores, cada línea del
programa había que numerarla, ya que todo lo que se escribía sin número de línea, se
ejecutaba inmediatamente; al igual que ocurre con lo que se escribe en la ventana
Inmediate del Visual Basic.
Los números de líneas se usaban, además de porque era obligatorio, para cambiar el
orden de ejecución, sobre todo después de una comparación. De esta forma, aún sin
tener bloques IF/THEN/ELSE/END IF, se podían simular.
¿Cómo se lograba?
Usando una instrucción que muchos creen que es "indecente, antisocial, etc."
La estrella del Basic: (redoble de tambores) "GOTO"
A partir de hoy, más de un purista de la programación no me dirigirá la palabra...
pero no me importa...

Se ha "denostado" (injuriado) con exageración el uso de esta instrucción.

Realmente es una instrucción de "bifurcación", es decir, sirve para "IR A" otro sitio de
nuestro programa.
Su uso ha sido el más criticado de los NO PARTIDARIOS del Basic y siempre han
basado sus críticas en el exagerado uso del GOTO en todos los programas Basic. Pero
aclaremos que C también tiene esta instrucción y que cualquier programa en código
máquina (ensamblador) está "plagado" de JMP que para el caso es lo mismo que el
sufrido GOTO, realmente una instrucción GOTO número_linea se convierte en JMP
número_linea.

No voy a recomendar el uso del GOTO, para nada, ya que hoy día es innecesario su
uso. Antes no teníamos más remedio, porque el BASIC no disponía de instrucciones
para poder estructurar el código. Pero sería una tontería querer hacer creer que no
existe esta instrucción. Sabiendo que está y cómo podemos evitarla, es preferible a
decir que no existe y si por casualidad la descubres... a que la uses.
Por tanto, insisto en mi recomendación, (de esta forma los PURISTAS volverán a
dirigirme la palabra), NO USES EL GOTO, ni aún cuando creas que no tienes más
remedio... aunque, aquí entre nosotros, algunas veces es más cómodo usarlo... pero
que no se entere nadie...

Este es un programa de los de antes, sirve para mostrar en pantalla los números del 1
al 10 y sin usar el FOR/NEXT

10 A = 1
20 Print A
30 A = A + 1
40 IF A <= 10 THEN GOTO 20
'Con el Commodore este programa se solía escribir así:
10 A=1
20 PRINTA:A=A+1:IFA<=10GOTO20
'Sin ESPACIOS NI NADA... TODO APELMAZADO... ¿que más daba usar el GOTO?

Imagine there's no heaven... (es que está sonando J. Lennon... un momento...)

En este ejemplo, es obvio que podríamos sustituirlo con:

10 For A = 1 To 10
20 Print A
30 Next

El NEXT hace lo mismo que la asignación y la comparación.

Pero hay otras maneras, para ello existe una serie de instrucciones que funcionan de
manera similar, veamos otros ejemplos con más instrucciones para hacer bucles,
seguiré usando los números de línea por aquello de la "nostalgia", pero salvo en el
primer ejemplo, en los demás no es necesario.

10 A = 1
20 While A <= 10
30 Print A
40 A = A + 1
50 Wend
El WHILE/WEND ya casi ni se usa, porque tienen un sustituto más versátil, ahora lo
veremos, pero el uso sería:

WHILE <expresión>
<instrucciones si se cumple>
WEND

Es decir, MIENTRAS la expresión sea cierta, repite todo lo que haya hasta el WEND.
Por supuesto podemos ponerlo todo en una sola línea:
10 A = 1 : While A <= 10 : Print A : A = A + 1 : Wend

Pero esto tampoco es recomendable, queda algo "difuso"...

El WEND funciona como IF A <=10 THEN GOTO xxx, con la ventaja que evitamos el
GOTO y lo que hace es comprobar si la expresión que hay tras el WHILE es cierta o
no, en caso de que sea verdadero el resultado, (ya sabes, distinto de CERO), se
ejecutará todo lo que hay entre WHILE y WEND. Estas instrucciones ya existían en el
GWBASIC (el basic de los PCs)

Hay que tener cuidado con esto de que la expresiones evalúan el cero como FALSO y
cualquier otro valor como VERDADERO, por ejemplo:

A = 1 o
While A While 1
Print A Print A
A = A + 1 A = A + 1
Wend Wend

En ambos casos el bucle sería "infinito", realmente se detendría en un momento dado,

ya que llegaría a "desbordarse" el valor máximo y en ese momento el programa
acabaría por producirse un error... pero prueba esto y verás:

While 1
Print "Hola Mundo"
Wend

Esto nunca finalizará, salvo que pulses CRTL+BEAK (o INTERrumpir), para detener el
programa.

Más instrucciones para hacer bucles

Con el QuickBasic 3.0, (yo no llegué a tenerlo, pero creo que fue ahí dónde se
introdujo), entró en funcionamiento una nueva forma de hacer bucles:
DO... LOOP
El último ejemplo podríamos escribirlo así:

Do
Print "Hola Mundo"
Loop

Pero la "gracia" de este tipo de bucle es que podemos usar dos nuevas cláusulas para
evaluar cuanto durará el bucle.
La primera es WHILE y funciona igual que en WHILE/WEND

A = 1
Do While A <= 10
Print A
A = A + 1
Loop

La ventaja es que WHILE se puede poner tanto después de DO como a continuación

de LOOP.
Si lo usamos como DO WHILE <expresión>... la forma de actuar es igual que
WHILE/WEND, es decir, se evalúa la expresión y sólo en caso de que sea cierta, se
ejecuta lo que está dentro del bucle, es decir entre DO y LOOP.
Pero si evaluamos la expresión en LOOP, se ejecutará todo lo que hay tras el DO,
como mínimo una vez y se seguirá repitiendo si se cumple la condición. De esta
forma, como he dicho, se ejecutará el contenido del bucle, como mínimo una vez.
Veamos un ejemplo:

A = 1
Do
Print A
A = A + 1
Loop While A <= 10

El problema es que si A, en lugar de valer 1, tiene un valor superior a 10, también se

ejecutará, al menos, una vez.
A = 11 : Do : Print A: A = A + 1: Loop While A <= 10
Que mal queda en una sola línea, ¿verdad?

Pero con DO/LOOP también puede usarse UNTIL, en este caso, el bucle se repetirá
HASTA que se cumpla la expresión

A = 1
Do Until A > 10
Print A
A = A + 1
Loop

Fíjate que la expresión ha cambiado de <= (menor o igual) a > (mayor), ya que
ahora se evalúa de esta forma:
Hasta que A sea mayor que diez, REPITE todo hasta LOOP.
Por supuesto también podemos usarlo después del LOOP:

A = 1
Do
Print A
A = A + 1
Loop Until A > 10

Aquí hago la misma aclaración que antes, si el valor inicial de A es más de 10 se

ejecutará como mínimo una vez.
Realmente para contar de forma secuencial y prácticamente para casi todo tipo de
bucle, no es necesario hacer los bucles con DO/LOOP, ya que FOR/MEXT lo hace
bastante bien.

Sigamos con estos bucles, pero en lugar de contar de menor a mayor, vamos a contar
"pa trás", es decir de mayor a menor... quién sabe, lo mismo necesitas hacer un
programa que cuente al revés...

A = 10
Do While A >= 1
Print A
A = A - 1
Loop

Cuando se muestre el 1, A=A-1 se convertirá en A = 0 y la comparación A >= 1 no se

cumplirá, por tanto dejará de repetirse el bucle, pero esto también se puede hacer
con FOR/NEXT:

For A = 10 To 1
Print A
Next

El único inconveniente es que NO SE REPITE NI UNA VEZ... ¿Por qué?

Porque si no se le indica lo contrario, FOR/NEXT siempre cuenta de forma ascendente
y cuando ve que A debe ir de 10 hasta 1 y que eso no es ascendente... pasa de
ejecutar el bucle. Esto es una cosa a tener en cuenta, FOR siempre evalúa los valores
del bucle que tiene que hacer y si no está entre los valores que debe, no se ejecuta ni
una sola vez. En este caso debe empezar por DIEZ y llegar hasta UNO, así que se da
cuenta de que ya ha terminado... incluso sin haber empezado... ¡que listo es el FOR!
Para que el FOR cuente hacia atrás, necesitamos un nuevo peldaño (esto en inglés
quedaría "clavado"), en la escala evolutiva del FOR/NEXT (ahí queda eso!!!)
Ya sin coñas, se necesita la palabra STEP para indicarle que no queremos ir de uno en
uno de forma ascendente, en nuestro ejemplo lo usaríamos así:

For A = 10 To 1 Step -1
Print A
Next

De esta forma contará desde 10 hasta 1, restando uno en cada repetición.

Pero, ¿que hacer si queremos usar otros valores?
Simplemente ponerlo después de STEP, por ejemplo:
For A = 10 To 1 Step -1
For A = 1 To 10 Step 3, etc, etc.

Insisto, todo esto está muy bien, pero en la práctica usaremos otras cosas además de
contar de forma lineal, con incrementos o sin ellos... habrá veces que queramos salir
de un bucle.
Ya lo hemos visto, por ejemplo Exit Sub salía del procedimiento, ¿recuerdas el Exit
For?
Para salir de los bucles podremos Exit y a continuación For, Do, etc. Pero NO
podremos salir de un bucle WHILE/WEND.
Ya veremos ejemplos para estos casos y otros que surgirán más adelante.

Bien, creo que ya hemos dado demasiadas vueltas con tanto bucle, para terminar: los
ejercicios esos que tanto les gustan.

Bueno, hasta aquí esta primera guía que contiene tema 1 y 2 , pues creo que con
esto se pueden ir "entreteniendo". Con estas dos Asignaciones…QUE LES DEJO POR
CLASSROOM

EJERCICIOS

CALCULAR EL PROMEDIO DE UN SALON DE CLASES pts.5%

PEDRO 20 MARTHA 15

ALFREDO 18 MARIA 19

JUAN 14 LUZ 13

LUIS 12 LUISA 18

CARLOS 10 MARYCARMEN 16
FREDDY 16 KARLA 16

JOSE 17 ALYS 19

FEDERICO 14 FABIANNA 20

FELIPE 12

*MOSTRAR PROMEDIO DEL SALON pts. 5%

*LUEGO MOSTRAR CUANTOS ALUMNOS SACARON MENOS DE

16 pts. 5%

*Y CUANTOS SON HOMBRES Y CUANTAS MUJERES pts. 10%

APLICANDO LAS TECNICAS Y COMANDOS APRENDIDOS…