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:
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".
