Curso Básico de Programación
en Visual Basic

Undécima Entrega: 15/Nov/97. (primera parte)
por Guillermo "guille" Som

Desde aquí puedes enlazar con las entregas anteriores.

La segunda parte de la undécima entrega

¿Cuanto tiempo, verdad? Pues ya ves que no desisto, te costará librarte de mis cursos, jé, jé.

Antes de empezar, quiero agradecer a: Pedro José González Casares piter@arrakis.es por haberse entretenido en corregir los errores tipográficos esos que uno suelta de vez en cuando... gracias.
A ver si me acostumbro a escribirlos en el Word y así pasarle el corrector, es que me da algo de pereza y como me entiendo bien con el FrontPage Express este que incluye el IE4, pues para que cambiar.
Quizás te preguntarás porqué no uso el FrontaPage 98 (la beta que es la gratuita) y así puedo pasarle el corrector... pues porque el diccionario que incorpora está en "gringo" y así cualquiera corrige...

Lo primero es lo primero, así que, en este link tienes las soluciones de los ejercicios de la décima entrega.

Y ya vamos al tema de hoy:

Nuestras propias variables

Ya has visto prácticamente la totalidad de tipos de variables que Visual Basic soporta, también has visto cómo agrupar variables para crear arrays.
Ahora voy a explicar cómo puedes crear tus propias variables. Realmente no es crear una variable, sino un tipo de variable especial en el que se pueden agrupar variables de distintos tipos; es lo que en otros lenguajes se llaman estructuras.
En Basic son tipos definidos por el usuario (TDU o UDT User Defined Type, que dirían los English-speaken esos)

En un UDT podemos incluir variables que estén relacionadas, realmente puedes incluir casi todo lo que se te ocurra, pero no tendría mucho sentido incluir cosas que no tengan relación, vamos, digo yo.
Imagínate que quieres hacer una utilidad que dibuje puntos en la pantalla y necesitas tener la posición de, digamos 1000 puntos, una solución sería declarar dos arrays, una para la posición de la fila y otra para la columna de cada punto:

Dim PuntoY(1000) As Integer, PuntoX(1000) As Integer

Cuando necesitemos dibujar el punto N en X,Y, haríamos algo como esto:

PuntoY(N) = y: PuntoX(N) = x

Y si lo que pretendemos es averiguar la posición del punto A, lo sabríamos así:

y = PuntoY(A): x = PuntoX(A)

Simplemente estaríamos usando un array para la fila (PuntoY) y otro para la columna (PuntoX), para simplificar todo esto, podemos crear un tipo en el cual tendríamos almacenado la posición de cada punto, para ello, hay que hacer una declaración de la siguiente forma:

Type tPunto
    X As Integer
    Y As Integer
End Type

cada vez que necesitemos una variable de este Nuevo tipo, tendremos que declararla como cualquier otra variable:

Dim unPunto As tPunto

Mu bonito, pero ¿cómo asignamos los valores?
De una forma muy especial, para acceder a cada uno de los datos que puede almacenar nuestra variable tendremos que especificar el nombre de la variable, un punto y a continuación la variable interna que nos interese...
Veámoslo:

unPunto.X = 100
unPunto.Y = 20

Para saber el valor guardado en la X de nuestra variable lo sabríamos así: columna = unPunto.X

Siempre usando el punto después de la variable interna, esto puedes encontrártelo en algunos libros o manuales, usando la expresión: "para acceder a un miembro de una estructura de datos definida por el usuario..." pero el significado, al final, es el mismo...

Bien, ahora si queremos crear un array para guardar los mil puntos esos a los que me refería al principio:

Dim Puntos(1000) As tPunto

Para almacenar la posición del punto N:

Puntos(N).X = x: Puntos(N).Y = y

Y seguro que ahora sabrás como obtener la posición del punto A.
Pero también podemos almacenar el punto actual en una variable normal de este tipo y asignar ese valor a un elemento del array:

Dim PuntoActual As tPunto
PuntoActual.X = un_valor: PuntoActual.Y = otro_valor
Puntos(N) = PuntoActual

 

Distintos tipos de variables en un tipo definido

Los tipos definidos, no sólo sirven para "mezclar" variables del mismo tipo, sino que puedes tener variables de varios tipos, incluso variables de tipos definidos... Sí, un verdadero lío...

Espero que después de leerte esta entrega y con los ejemplos que veremos en las próximas, (cuando le toque el turno al manejo de ficheros), se te aclararán las dudas.

 

Otro ejemplo clásico

Este es uno de los más usados para este tipo especial de variables y la verdad es que es también el más usado, enseguida sabrás porqué.

Situación:	Tener los datos de todos los colegas y otros que no lo son tanto.
Datos:	Nombre y apellidos, dirección, teléfono fijo, teléfono móvil, dirección e-mail, URL y cualquier otra cosa que se te ocurra.
El Tipo:	Para un caso como este, (simplificando un poco), podríamos usar este tipo definido: Type tColega Nombre As String Apellidos As String Direccion As String Poblacion As String Edad As Integer VecesQueLeHeMandadoUnMailYNoContesta As Long 'Esto por si soy yo 8-) End Type

Fíjate en el último "campo" del tipo, es una chorrada (aunque más de uno no pensará así), pero es para que veas que se pueden usar nombres de variables "super-largos", ¡hasta 40 caracteres! Es decir, que si te gustó Mary Poppins, podrías tener una variable que se llamara: MeGustaSupercalifragilisticoespialidoso.

Ya en serio, no es conveniente el uso de nombres tan largos, no hagas caso de la propaganda esa que te dicen que es mejor usar nombres descriptivos, ya que ¡¡¡es una lata tener que escribirlos!!!
En caso de que te de el "punto" de escribir nombres largos, puedes hacerlo, incluso puedes usar más de 40 letras, sólo que las primeras 40 tienen significado... es decir que si al supercali... ese le añades más letras, sólo reconocerá las 40 primeras.
Por ejemplo:
SupercalifragilisticoespialidosoChitiChitiBangBangVolando
SupercalifragilisticoespialidosoChitiChitiBangBangParado
Para el VB será la variables (un momento que cuente las letras): SupercalifragilisticoespialidosoChitiChi

De todas formas sigo pensando que es algo tedioso eso de escribir nombres tan largos...

Otro caso de las variables, creo que este aún no lo hemos visto, es este:
Cuando vayamos a usar este tipo de variables para guardar los datos en ficheros (dentro de un par de entregas ya los estarás usando), es conveniente "definir" la longitud máxima de las cadenas de caracteres, por ejemplo:
Reservar 20 caracteres para el nombre ó 50 para la dirección, en este caso la declaración de las variables se harían así:

Dim Nombre    As String * 20
Dim Direccion As String * 50

Y si están en un tipo definido:

Type tFijos
    Nombre    As String * 20
    Direccion As String * 50
End Type

La ventaja de hacerlo así: al tener una longitud fija, podemos acceder a cualquier registro haciendo unos pequeños cálculos... aunque de esto se encarga de forma automática el propio Basic y como he dicho antes: lo veremos más después.

 

Vamos con algunos ejemplos.

Ya tenemos definido el tipo tColega, si queremos usarlo sólo hay que DIMensionar una variable para que sea de ese tipo:

Dim unColega As tColega

Y para guardar el nombre de ese colega:

unColega.Nombre = "Pepito"

Con los demás campos se haría igual.

Ahora, se nos presenta la situación de que tenemos, por poner un ejemplo, 50 colegas; así que vamos a reservar espacio para todos ellos:

Dim misColegas(1 To 50) As tColega

Para almacenar el nombre del colega número uno:

misColegas(1).Nombre = "Maria de las Mercedes"

Para mostrarlos, simplemente hacemos un bucle que recorra este array y asunto concluido:

For i = 1 To 50
    Print misColegas(i).Nombre, misColegas(i).Apellidos, ...etc.
Next

Que quieres imprimir de forma aleatoria uno de los 50 nombres, digamos para gastarle una inocentada, pues haces esto:

Print misColegas(Int(Rnd * 50) + 1).Nombre

Ya sabes, si no lo sabias, ahora lo sabrás, que el índice de un array, el numérico ese que se pone dentro de los paréntesis, puede ser cualquier expresión numérica, que de como resultado un valor que esté dentro de los límites de la cantidad de variables que tiene ese array... Sí, es que si ese valor no está "dentro" de los elementos que tienes dimensionados, te "regañará" el VB diciéndote: Index Out of Range (o sea: T'as pasao, colega)

 

Un alto en el camino.

Toma papel y lápiz, porque esto es una nueva instrucción.

Ya has visto en el ejemplo de imprimir los 50 nombres, que cada vez que accedes a uno de los campos (o variables internas) del tipo definido, tienes que usar el nombre de la variable el punto y después el campo.
Pues a partir del VB4, este asunto se ha simplificado y no sólo para los tipos definidos, ya verás, en un futuro no muy lejano, calculo que antes del año 2010, que se puede usar en todas las situaciones en las que "algo" tenga otros "algos" dentro de él y haya que acceder por medio del punto... Si no lo captas, no te preocupes, ya te enterarás bien...

La palabra mágica es: WITH

No te voy a hacer una presentación formal de esta instrucción, ya tienes el manual del VB o la ayuda y allí seguro que estará bien "definida", vamos a ver cómo usarla en el ejemplo este que nos traemos entre manos:

For i = 1 To 50
    With misColegas(i)
	Print .Nombre, .Apellidos, .Direccion, ...etc.
    End With
Next

¡Ves que fácil! Hasta he puesto otro de los campos...
De esta forma no tienes que repetir el nombre de la variable, el Visual ya sabe que te estás refiriendo a misColegas(i), porque esa es la variable que has usado después de With.

Esto mismo se puede usar con cualquier objeto del VB, los tipos definidos no son objetos, pero se parecen, en unas cuantas de miles de entregas más, te enterarás del porqué...

Por ejemplo para asignar varias de las propiedades de un TextBox llamado Text1:

With Text1
    .SelStart = 0
    .SelLength = Len(.Text)
End With

Este mismo ejemplo sin With, como lo tendrían que hacer con el VB3, sería esto:

Text1.SelStart = 0
Text1.SelLength = Len(Text1.Text)

Como comprobarás, está más claro si se usa el With

Además, se pueden anidar varios Withs... unos dentro de otros, pero siempre el PUNTO hará referencia al último que se ha puesto, esta situación ni la voy a "ejemplificar" ya que cuando le toque el turno, le tocará...

 

Bueno, vamos a dejarlo por ahora; en la siguiente parte de esta entrega, usaremos todo esto en un pequeño programa en el cual se introducirán los datos y todas esas cosas... Pero eso será mañana (hoy realmente, pero más tarde)

En seguida nos vemos.

---