Curso Básico de Programación
en Visual Basic

Segunda Entrega: 09/May/97.
por Guillermo "guille" Som


Seguimos con este cursillo básico. Antes de nada una pequeña aclaración, para que los ejemplos que se dieron en la entrega anterior, deberás 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 puntualización, vamos a la tarea.
El tema de hoy será 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 de la entrega anterior. 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 de la entrega anterior, 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 "cachillo" 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:

Tipo Espacio ocupado Tipo de declaración Ejemplo
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 Basic 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 como 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:

Figura 1

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.

Bueno, aquí voy a dejar la cosa, pues creo que con esto es te puedes ir "entreteniendo".

Nos vemos, espero en la próxima entrega. Y ya sabes que espero que me mandes tus comentarios, por lo menos para saber que hay alguien interesado en seguir este curso "super-básico".


 

entrega anterior ir al índice siguiente entrega

Ir al índice principal del Guille