Type NombreTipoRegistro
' Campos individuales de variables
End Type
En mayor detalle:
Type NombreTipoRegistro
NombreCampo1 As tipo
NombreCampo2 As tipo
NombreCampo3 As tipo
.............
End Type
Como puede verse, cada definición de campo consiste de un nombre dado al campo seguida de la clásula As que define el tipo de dato de dicho campo (Integer, Single, Double, String, etcétera). La especificación del tipo puede ser cualquiera de los tipos de datos de Visual Basic, numéricos o de hilera, e inclusive un tipo de registro previamente definido por el usuario.
El segundo componente es un enunciado Dim que declare a una variable como perteneciente al tipo de registro definido:
Dim NombreVariable As NombreTipoRegistro
A modo de ejemplo, supóngase que se quiere definir una variable estructurada que sea capaz de almacenar los nombres de los pacientes de un hospital con sus características principales. Una manera de hacerlo es la siguiente:
Type Paciente
Nombre As String
Apellido As String
Edad As Integer
Peso As Single
Estatura As Single
End Type
Podemos decir que esto nos define un “molde”, un “esqueleto” que será usado para crear instancias específicas (variables) de dicha estructura. Hecho lo anterior, podemos definir las siguientes dos variables:
Dim PacienteMasculino As Paciente
Dim As PacienteFemenino As Paciente
Lo anterior es apenas la declaración de dos variables, PacienteMasculino y PacienteFemenino, ambas del tipo (definido por el usuario) Paciente.
Para quienes han tenido algún contacto previo con el lenguaje C, esto les parecerá muy semejante a lo que se puede definir en dicho lenguaje con la palabra reservada struct. Y de hecho se trata de lo mismo, lo único que cambia es la sintaxis usada para especificar el tipo de dato.
¿Y cómo habremos de meter y sacar campos individuales de cada variable para casos específicos? Pues mediante un operador punto. Visual Basic reconoce un formato especial para referencias a campos individuales en una variable de registro. En este formato, el nombre de la variable de registro es seguida por un punto (el operador punto) seguida por el nombre del campo (sin espacios en blanco intermedios):
NombreVariable . NombreCampo
que en forma más genérica, usando la terminología que corresponde al manejo de las bases de datos, podemos interpretar como:
Registro . Campo
A estas alturas, tal vez haya quien considere la posibilidad de que, además de poder especificarse con una misma estructura un “molde” que agrupe varias variables distintas organizadas en campos, se puedan especificar también algunas acciones llevadas a cabo mediante la manipulación de tales variables, cada una de las cuales incorporaría un código ejecutable. O sea, que además de que la estructura posea variables que podemos llamar propiedades, posea también porciones de código que podamos llamar métodos. Pero algo así resulta ser mucho más potente que un nuevo tipo de dato, se trata de un objeto que nos envía directamente al ámbito de la programación en el cual se lleva la programación orientada a objetos.
¿Y qué nos podría llevar a embrollarnos en tales cosas que al principio nos podrían parecer casi esotéricas, metiéndonos en camisa de once varas sin aparente necesidad de hacer tal cosa?
Supóngase que se quiere desarrollar un programa de tipo científico implementando una fórmula de la física clásica, en donde si se tiene la velocidad inicial V0 de un vehículo y se tiene la aceleración A (que se supone uniforme) podemos calcular el espacio recorrido en cierto tiempo T mediante la siguiente fórmula:
Usando única y exclusivamente cajas de entrada y una caja de salida podemos escribir el código que implemente el programa de la siguiente manera:
Sub Form_Click ()
Dim V0, A, T, S As Single
V0 = InputBox("Dame la velocidad inicial")
A = InputBox("Dame la aceleracion")
T = InputBox("Dame el tiempo")
S = V0 * T + .5 * A * T ^ 2
MsgBox "La distancia recorrida es " & S
End Sub
Al hacer clic con el Mouse dentro de la ventana que corresponde a esta aplicación, este código abre una caja de entrada que le pide la velocidad inicial al usuario esperándose que se escriba algún valor numérico (por ejemplo 6); al oprimir el botón OK en esta primera caja de entrada aparece una segunda caja de entrada que le pide al usuario la aceleración esperándose que se escriba algún valor numérico (por ejemplo 3), y al oprimir el botón OK en la segunda caja de entrada aparece una tercera caja de entrada que le pide al usuario el tiempo esperándose que se escriba algún valor numérico (por ejemplo 5). Finalmente, al oprimir el botón OK en la tercera caja de entrada, aparece una caja de mensaje que da la respuesta, o sea la distancia recorrida para el tiempo transcurrido (por ejemplo 67.5).
El programa logra su propósito básico, de ello no hay duda alguna. El problema con este tipo de programa es que no representa ninguna ventaja sobre el primitivo método de la interfaz de línea de comandos. Si se comete una equivocación al escribir cualquiera de los tres valores V0, A y T y se dá uno cuenta de ello después de haber oprimido el botón OK en cualquiera de las tres cajas de entrada, entonces hay que comenzar de nuevo pero recorriendo todo el procedimiento hasta terminarlo antes de empezar de nuevo. Podemos transcribir muchos programas que fueron elaborados en el BASIC tradicional a Visual Basic con el simple recurso de substituír una caja de entrada en cada uno de los lugares en donde haya una instrucción BASIC del tipo INPUT y una caja de mensaje en cada uno de los lugares en donde haya una instrucción BASIC del tipo PRINT, lo cual no presenta mayores problemas. Pero si la interfaz visual con el usuario dependiera únicamente de cajas de entrada y cajas de mensaje, posiblemente aún estaríamos usando la ventana clásica de comandos de línea, porque para el usuario esta forma de trabajar no presenta ninguna ventaja útil sobre la clásica ventana de líneas de comandos.
Para poder justificar el uso de una interfaz visual tipo Windows en la elaboración de una calculadora que permita obtener el espacio recorrido dados la velocidad inicial, la aceleración y el tiempo (y de hecho, cualquier otra evaluación o tarea mediante cualquier fórmula matemática), se requiere de algo más sofisticado. Y esa es precisamente lo que nos conduce de modo casi irremediable a la razón de ser de los objetos y la programación orientada a objetos.
Usando el entorno de Visual Basic, construiremos nuevamente una calculadora para evaluar la fórmula anterior de la física clásica. Pero lo haremos poblando la forma inicial predeterminada (que será la ventana principal de trabajo) con seis controles: cuatro etiquetas Label (para identificar cada uno de los controles de entrada de datos), cuatro controles de entrada de datos TextBox (cajas de texto), un control de salida de dato TextBox (una caja de texto para proporcionar el resultado), y dos botones de comando CommandButton, llegando de este modo a algo como lo siguiente:
Hasta este punto hemos creado la interfaz de la aplicación con el usuario. Obsérvese que no se ha puesto un tercer botón de comando titulado “Salir” para dar por terminada la aplicación y cerrar la ventana principal de la misma. No es indispensable, porque Visual Basic pone en todas las formas en la esquina superior derecha los tres botones usuales del sistema operativo Windows para minimizar la ventana a la barra de tareas (Taskbar), para minimizar la ventana a un tamaño intermedio (si la ventana de la aplicación lo permite) y para cerrar la ventana. De cualquier modo, se le puede agregar un botón tal.
¿Y en dónde habremos de meter el código necesario para que se lleve a cabo la evaluación matemática de la fórmula? Ello debe ser claro, el procedimiento a ser ejecutado debe ser puesto en el procedimiento que pone las cosas en marcha, o sea en el botón “Evaluar”, en respuesta a un evento Click(). Obsérvese que hay otro botón titulado “Reiniciar” cuyo único propoósito es inicializar todas las variables ya sea a cero o “limpiar” las tres cajas de texto dejándolas en blanco (usaremos lo segundo). Esto último se logra en la ventana de propiedades para cada caja de texto borrando en la propiedad Text cada uno de los textos Text1, Text2, Text3 y Text4. Esto se logra en cada caja accesando la ventana de propiedades de cada caja de texto y cambiando el contenido en la cajita de la ventana de propiedades (en este caso, borrándolo) como se muestra a continuación:
Haciendo clic en el botón de comando que corresponde a evaluar hace su aparición en forma automática la ventana de procedimientos para dicho botón (o la ventana de declaraciones y procedimientos para la forma, desde donde podemos llegar a la ventana de procedimientos para el botón). Teniendo la precaución de seleccionar el evento Click() para el botón de comandos Command1 (en caso de que el programador no le haya cambiando el nombre al control), se abre la ventana de procedimientos en donde podemos meter el siguiente código para el botón:
Sub Command1_Click ()
Dim V0, A, T, S As Single
V0 = Text1.Text
A = Text2.Text
T = Text3.Text
S = V0 * T + .5 * A * T ^ 2
Text4.Text = S
End Sub
Obsérvese que hay una simplificación en el código que se requiere escribir en comparación al código requerido cuando se usan únicamente cajas de entrada y cajas de mensajes. Si ejecutamos la aplicación bajo el entorno protegido de Visual Basic, al correr la aplicación y meter valores obtenemos algo como lo siguiente al oprimir el botón Evaluar:
La explicación de la manera en la cual funciona esto es la siguiente: en la primera línea de código dentro del procedimiento Sub, se declaran cuatro variables numéricas V0, A, T y S de tipo flotante de precisión sencilla (Single). En la segunda línea de código, cualquier cosa que esté escrita en la propiedad Text del objeto identificado como la primera caja de texto Text1 (por ejemplo, el número 6) es asignada a la variable numérica V0. En la tercera línea de código, cualquier cosa que esté escrita en la propiedad Text del objeto identificado como la segunda caja de texto Text2 (por ejemplo, el número 3) es asignada a la variable numérica A. Y en la cuarta línea de código, cualquier cosa que esté escrita en la propiedad Text del objeto identificado como la tercera caja de texto Text3 (por ejemplo, el número 5) es asignada a la variable numérica T. Al llegar a la quinta de línea de código, se tienen ya los valores numéricos asignados a las tres variables, los cuales son usados para calcular el valor de S usando la fórmula matemática proporcionada. Por último, el valor numérico de S obtenido como resultado de la evaluación es asignado a la propiedad Text del objeto identificado como la cuarta caja de texto Text4, lo cual hace que de modo inmediato y automático se ponga la respuesta en dicha caja.
No se ha especificado el tipo de código a ser usado en el cado de un evento de clic en el botón Reiniciar. En este caso no hay problema alguno, porque todo lo que se requiere es “limpiar” las cuatro cajas de texto con algo como lo siguiente:
Sub Command2_Click ()
Text1.Text = ""
Text2.Text = ""
Text3.Text = ""
Text4.Text = ""
End Sub
Una vez que el programador está satisfecho con la manera en la cual funciona su programa, puede proceder a crear el programa ejecutable (guardándolo bajo algún nombre descriptivo como CINEMATICA.EXE). Sin embargo, se pueden introducir mejoras, tales como en el caso de que el usuario meta algún dato no numérico (por ejemplo, una hilera de texto) aparezca una caja de mensaje diciendo algo como “Entrada inválida” y esperar a que el usuario meta un dato válido (en rigor de verdad, para esto es lo único para lo que se debe recurrir a cajas de mensaje).
Obsérvese que además de tener una interfaz mucho más intuitiva y descriptiva, podemos meter los datos en cualquier orden, lo cual permite mantener todos los datos de entrada fijos e ir variando uno solo de ellos con la finalidad de poder apreciar la forma en la cual va variando el resultado de salida al ir cambiando una sola de las variables, ya sea la velocidad inicial, la aceleración o el tiempo. En rigor de verdad, cuando se desarrolló el sistema operativo Windows sus creadores iban precisamente tras algo como esto.
Tal vez el lector se haya dado cuenta de que, con lo que se ha descrito arriba, se le han proporcionado los recursos esenciales que necesita para transcribir muchos programas escritos en el BASIC tradicional que se ejecutaba en la ya obsoleta ventana de comandos a programas que se ejecutan mediante una interfaz visual, lo cual no es poca cosa. Hay, desde luego, muchas otras cosas que se pueden llevar a cabo, pero se requiere familiarizarse de modo más formal con otros conceptos.
Así pues, cuando estamos programando para un entorno visual y el usuario está haciendo uso de lo que tiene que ver con un entorno visual se puede decir que se ha llevado a cabo una programación-orientada-a-objetos. Es de lo que se trata, y no hay forma de darle la vuelta a la hoja cuando se llega a este punto. Precisamente porque estamos lidiando con un concepto que es fundamental para el nuevo paradigma de programación, formalizaremos los conceptos teóricos de esto con la terminología que se usa en Visual Basic, terminología que es de uso casi universal inclusive en otros lenguajes y entornos de programación.
Por principio de cuentas, los objetos están encapsulados, estos es, contienen tanto su propio código como sus propios datos, lo cual les permite susceptibles de un mantenimiento más sencillo que las formas tradicionales de escribir código.
Los objetos en Visual Basic tienen propiedades, métodos y eventos. Las propiedades son los datos que describen a un objeto. Los métodos son cosas que le pedimos a un objeto que haga. Y los eventos son cosas que el objeto hace en respuesta a un estímulo externo; podemos escribir el código a ser ejecutado cuando ocurran ciertos eventos (como en el ejemplo dado arriba, la opresión mediante el Mouse de un botón usado para llevar a cabo una evaluación).
Los objetos en Visual Basic son creados a partir de clases, las cuales son el “molde” o “esqueleto” de un objeto. Por esto mismo se dice que un objeto es una instancia (ocurrencia) de una clase. Cuando en la etapa de diseño depositamos un control de botón de comando dentro de una forma, se lleva a cabo una instanciación de la clase de objetos a la que pertenece el botón de comando. La clase es lo que define las interfaces que puede tener un objeto, es lo que define si el objeto puede ser público (accesible por todos los módulos del proyecto), así como bajo qué circunstancias se puede crear un objeto. Las definiciones de las clases son almacenadas en librerías de tipo, y pueden ser inspeccionadas mediante navegadores de objetos (object browsers).
Para poder usar un objeto, se debe hacer una referencia al mismo mediante una variable de objeto (esto será explicado más abajo en mayor detalle). El tipo de enlazado (binding) determinará la velocidad a la cual los métodos de un objeto pueden ser accesados usando una variable de objeto. Una variable de objeto puede ser de enlace tardío (late binding) o enlace temprano (early bound), siendo el primero el más rápido.
Un conjunto de propiedades y métodos es lo que se conoce como una interfaz. La interfaz de un objeto en Visual Basic es una interfaz dual que dá soporte a todas las formas de enlazado.
Además de su interfaz dual, los objetos en Visual Basic pueden implementar interfaces adicionales para proporcionar lo que se conoce como polimorfismo. El polimorfismo nos permite manipular muchas diversidades de objetos sin tener que preocuparnos acerca de lo que es cada uno de ellos.
Todo proyecto elaborado en Visual Basic tiene por lo menos un objeto, el objeto Form1, el cual sirve como la ventana principal de la aplicación (puede tener no solo uno sino otros objetos del tipo Form como Form2, Form3, etc., pero siempre tiene al menos a Form1). Cada objeto Form tiene las siguientes propiedades:
| ActiveControl | DrawWidth | Height | Name |
| ActiveForm | Enabled | HelpContextID | Picture |
| AutoRedraw | FillColor | hWnd | ScaleHeight |
| BackColor | FillStyle | Icon | ScaleLeft |
| BorderStyle | FontBold | Image | ScaleMode |
| Caption | FontItalic | KeyPreview | ScaleTop |
| ClipControls | FontName | Left | ScaleWidth |
| ControlBox | FontSize | LinkMode | Tag |
| Count | FontStrikethru | LinkTopic | Top |
| CurrentX | FontTransparent | MaxButton | Visible |
| CurrentY | FontUnderline | MDIChild | Width |
| DrawMode | ForeColor | MinButton | WindowState |
| DrawStyle | hDC | MousePointer |
Además de poseer propiedades, un objeto Form posee los siguientes métodos:
| Circle | Move | PSet | TextHeight |
| Cls | Point | Refresh | TextWidth |
| Hide | Scale | ZOrder | |
| Line | PrintForm | Show |
Y un objeto Form puede responder a los siguientes eventos:
| Activate | GotFocus | LinkExecute | MouseUp |
| Click | KeyPress | LinkOpen | Paint |
| DblClick | KeyDown | Load | QueryUnload |
| Deactivate | KeyUp | LostFocus | Resize |
| DragDrop | LinkClose | MouseDown | Unload |
| DragOver | LinkError | MouseMove |
Todo lo que es un objeto está definido por sus propiedades. En el caso de un objeto Form, es posible sin ver en lo absoluto el aspecto de la forma que se está generando en la etapa de diseño, construír una forma al gusto especificando valores nuevos a las propiedades cambiando con ello los valores predeterminados ofrecidos por Visual Basic. Para ello podemos usar la ventana de Propiedades disponible en todas las versiones de Visual Basic:
Haciendo, mediante la ventana de Propiedades, las siguientes modificaciones en las propiedades del objeto Form1:
BackColor = &H0080FFFF&
Caption = Ejemplo de Forma
Height = 5000
Width = 5000
se obtiene una forma con el siguiente aspecto:
Quizá la mejor manera de aprender el efecto que tiene cada una de las propiedades visuales de un objeto sea el experimentar un poco cambiándole los valores ligeramente a cada una de las propiedades y ver el efecto que tiene dicho cambio en el objeto (Visual Basic efectúa el cambio de inmediato cuando se está en la etapa de diseño).
Si podemos definir en Visual Basic un nuevo tipo de variable a nuestro antojo que en realidad es multi-variable usando Type, ¿no podremos ir más lejos haciendo algo parecido cuando se trate de objetos, abriendo la posibilidad de que podamos definir objetos que tengan otras características diferentes de las características que tienen los objetos predefinidos por Visual Basic? La respuesta es afirmativa, y podemos hacerlo usando Object de la siguiente manera:
Dim nombre As Object
Por ejemplo:
Dim Paciente As Object
Las variables de objetos genéricos, esto es, variables declaradas como As Object, pueden contener objetos de distintas clases (como un objeto del tipo Form, que puede contener varios objetos del tipo TextBox así como varios objetos del tipo Label). Cuando se usan variables de estos tipos, tal vez sea necesario tomar distintas acciones dependiendo de la clase de un objeto (por ejemplo, tal vez algunos objetos no den soporte a una propiedad o método en particular). Para poder tomar distintas acciones dependiendo del objeto de que se trate, Visual Basic proporciona dos maneras para lograr tal cosa: la palabra clave TypeOf y la función TypeOf(). Las palabra clave TypeOf solo puede ser utilizada en enunciados del tipo If... Then... Else, y el nombre de la clase debe ser incluído directamente en el código, por ejemplo:
If TypeOf MiControl Is CheckBox Then
La función TypeName es más flexible. Se puede usar en cualquier parte del código, y en virtud de que nos regresa el nombre de la clase como una hilera de texto, se puede usar para compararla con el valor de una variable de hilera.
Las variables de objeto son almacenadas como domicilios de 32 bits (4 bytes) que se refieren a objetos dentro de alguna aplicación. Una variable que ha sido declarada como del tipo Object es una que puede ser asignada subsecuentemente (usando el enunciado Set) para referirse a cualquier objeto actual reconocido por la aplicación. Por ejemplo:
Dim objBaseDatos As Object
Set objBaseDatos = OpenDatabse("C:\VB5\Biblio.mdb")
Obsérvese que en la creación del nombre objBaseDatos para la variable de objeto se ha recurrido a la notación húngara (véase la entrada “La programación visual”) anexando un prefijo de tres caracteres que sugiere el tipo de variable de que se trata. De este modo, al ver en porciones de código nombres de variables tales objGrafica, objPortapapeles y objNavegador, sabemos del nombre que se trata de variables del tipo objeto.
Al declarar nombres de variables de objeto, es preferible usar clases específicas, por ejemplo, TextBox en lugar de Control, o en el caso precedente HojaTrabajo en lugar del nombre genérico Object. Visual Basic puede resolver referencias a las propiedades y métodos de objetos con tipos específicos antes de que se ejecute una aplicación. Esto permite que la aplicación se ejecute con mayor rapidez en el tiempo de ejecución (run time).
A continuación se da un listado de la notacion usada para definir algunas clases específicas propias de Visual Basic:
| Clase | Convención |
| Barra de desplazamiento horizontal |
HScrollBar |
| Barra de desplazamiento vertical |
VScrollBar |
| Botón de comando | CommandButton |
| Botón de opción | OptionButton |
| Caja combo | ComboBox |
| Caja de chequeo | CheckBox |
| Caja de listado | ListBox |
| Caja de listado de archivos |
FileListBox |
| Caja de listado de directorios |
DirListBox |
| Caja de imagen | PictureBox |
| Caja de texto | TextBox |
| Datos | Data |
| Diálogo común | CommonDialog |
| Etiqueta | Label |
| Forma | Form |
| Forma geométrica | Shape |
| Linea | Line |
| Rejilla | Grid |
| Temporizador | Timer |
Dentro del código, como vimos en el ejemplo dado al principio, podemos fijar la propiedad de un objeto con la ayuda del operador punto. En ocasiones será necesario llevar a cabo varias acciones diferentes en el mismo objeto en un mismo bloque de código, para que las propiedades del objeto cambien no en la etapa de diseño del programa sino en la etapa de su ejecución. Una manera de hacerlo es como se muestra a continuación:
Private Sub Form_Load()
Command1.Caption = "OK"
Command1.Visible = True
Command1.Top = 200
Command1.Left = 5000
Command1.Enabled = True
End Sub
Obsérvese que todos estos objetos usan la misma variable de objeto, Command1. Podemos hacer este código más fácil de escribir, más fácil de leer, y más eficiente de ejecutar mediante el enunciado With... End With como se muestra en la siguiente simplificación del código dado arriba:
Private Sub Form_Load()
With Command1
.Caption = "OK"
.Visible = True
.Top = 200
.Left = 5000
.Enabled = True
End With
End Sub
Muchos objetos tienen una propiedad de default (default property) que podemos usar para almacenar y recuperar valores simplemente refiriéndonos a dicho control sin necesidad de usar (con el operador punto) el nombre de la propiedad. A esto se le llama el valor del objeto, y usualmente es la propiedad más importante o más utilizada de dicho objeto. Podemos usar los valores de un objeto en nuestro código sin tener que referirnos en forma explícita a la propiedad al usar el código. Para un objeto en el cual la propiedad Value es su propiedad default, podemos hacer una asignación de la manera usual mediante el operador punto:
objeto.Value = 45
Pero también podemos lograr lo mismo escribiendo simplemente:
Objeto = 45
Los controles de Visual Basic, siendo objetos, tienen cada uno de ellos en su mayoría algún valor que es su propiedad característica de default con la cual funciona, y esto nos permite también usar los valores de los controles sin necesidad de tener que referirnos explícitamente a la propiedad con el operador punto. La siguiente tabla proporciona un listado de la propiedad que es considerada por Visual Basic como el valor de cada control:
| Control | Propiedad |
| Check box | Value |
| Combo box | Text |
| Command button | Value |
| Common dialog | Action |
| Data | Caption |
| Data-bound combo box | Text |
| Data-bound grid | Text |
| Data-bound list box | Text |
| Directory list box | Path |
| Drive list box | Drive |
| File list box | FileName |
| Frame | Caption |
| Horizontal scroll bar | Value |
| Image | Picture |
| Label | Caption |
| Line | Visible |
| List box | Text |
| Option button | Value |
| Picture box | Picture |
| Shape | Shape |
| Text box | Text |
| Timer | Enabled |
| Vertical scroll bar | Value |
Para ver la manera en la que trabaja esto, podemos incrustar primero dentro de una forma un botón de comando y una caja de texto, agregando el siguiente enunciado al evento Click() del botón de comando:
Sub Command1_Click ()
Text1 = "Hola"
End Sub
Si corremos el programa y oprimimos el botón de comando, en la caja de texto se escribirá Hola. en virtud de que Text es la propiedad default de una caja de texto. Esta opción proporcionada por Visual Basic nos permite reescribir de la siguiente manera el código usado en la construcción de la calculadora que se dió arriba para el cálculo del espacio recorrido por un móvil en movimiento uniformemente acelerado (para que el programa modificado funcione sin errores señalados por Visual Basic, se requiere que en la ventana de propiedades de cada caja de texto se vayan borrando en la propiedad Text cada uno de los textos Text1, Text2, Text3 y Text4):
Sub Command1_Click ()
Dim V0, A, T, S As Single
V0 = Text1
A = Text2
T = Text3
S = V0 * T + .5 * A * T ^ 2
Text4 = S
End Sub
Habiendo visto que, además de los tipos de datos numéricos e hileras, tenemos objetos del tipo Object, cabe preguntarnos a estas alturas: ¿no habrá otros tipos de datos que aún no han sido cubiertos? Si los hay, ¿cómo evitar confundirlos? Aquí es en donde el uso de la notación húngara (prefijando cada variable con una hilera de tres caracteres alfabéticos en minúsculas que sugieran el tipo de variable) puede resultar útil. En respuesta a estas interrogantes, a continuación se presenta una lista más completa de los tipos de datos disponibles en Visual Basic (válida a partir de Visual Basic 5.0), dándose el prefijo de notación húngara sugerido para cada caso así como ejemplos apropiados:
| Tipo de dato | Prefijo | Ejemplo |
| Boolean | bln | blnEncontrado |
| Byte | byt | bytPixelImagen |
| Objeto de colección | col | colWidgets |
| Currency | cur | curIngresos |
| Date (Tiempo) | dtm | dtmInicio |
| Double | dbl | dblTolerancia |
| Error | err | errNumError |
| Integer | int | intContador |
| Long | lng | lngDistancia |
| Object | obj | objActual |
| Single | sng | sngPromedio |
| String | str | strApellido |
| Tipo definido por el usuario |
udt | udtEmpleado |
| Variant | vnt | vntSuma |
En Visual Basic la notación húngara es optativa en la sintaxis de la declaración de las variables. ¿Que razón tendríamos para tomar conocimiento de su existencia? Independientemente de que su empleo nos puede facilitar nuestra tarea como programadores manteniendo clara la distinción entre los diversos tipos de variables, en Internet existe mucho código disponible en Visual Basic para el cual miles de programadores profesionales han recurrido a esta convención, lo cual nos permite tomar dicho código escrito por otros y leerlo sin muchas dificultades. La notación húngara así como el uso generoso de comentarios puede hacer que el código en ocasiones tan laboriosamente desarrollado por nosotros sea mucho más legible para otros, lo cual permite compartir programas grandes tomando asimismo de ellos lo que se requiera para que podamos hacer nuestros programas más compactos y eficientes.
Un objeto en Visual Basic que puede ser usado para la construcción de tablas de entrada de datos como se acostumbra hacerlo en hojas de trabajo es el objeto Grid. Al igual que con cualquier otro objeto, podemos fijar sus propiedades durante la ejecución de un programa. A modo de ejemplo, el siguiente código puesto en el evento Load() del cargado de una forma en la cual se ha creado un objeto de la clase Grid:
producirá una rejilla de cinco columnas y siete renglones, usándose el renglón superior para etiquetar las columnas con letras, y usándose la columna derecha para etiquetar los renglones con números:
Sub Form_Load()
Dim I As Integer
Grid1.Cols = 5
Grid1.Rows = 7
Grid1.Row = 0
Grid1.FixedAlignment(0) = 2
For I = 1 To Grid1.Cols - 1
Grid1.FixedAlignment(I) = 2
Grid1.Col = I
Grid1.Text = Chr(64 + I)
Next I
Grid1.Col = 0
For I = 1 To Grid1.Rows - 1
Grid1.Row = I
Grid1.Text = I
Next I
End Sub
producirá el siguiente resultado cuando aparezca la forma:
No todos los objetos en Visual Basic se pueden “ver” como ocurre con las formas, los botones de comando, las cajas de texto y las etiquetas. Hay algunos objetos que el usuario final nunca llega a ver, e inclusive el mismo programador solo los puede utilizar cuando está diseñando su programa sin llegar a “verlos” como tales, enterándose de tales objetos solo porque la existencia de los mismos le es revelada en la documentación que viene incluída con el software del entorno de programación. Uno de tales objetos es el objeto Debug. Y este objeto no tiene propiedades ni eventos, solo cuenta con un método, el método Print. El propósito de este objeto, como su nombre lo indica, es ayudarle al programador en la a veces dura tarea de depurar errores que hacen que el programa de aplicación se venga abajo al estarse ejecutando. La sintaxis de su uso es la siguiente:
Debug.Print hilera descriptiva; variable reportada
En los puntos en donde aparece este tipo de enunciado, hace que se impriman ya sea (dependiendo de la versión de Visual Basic que se esté utilizando) en la Ventana de Debug (Debug Window) o en la Ventana Inmediata (Immediate Window) del entorno de diseño Visual Basic (cuando se está corriendo una ejecución simulada del programa bajo el mismo entorno Visual Basic) los valores de las variables que son especificados. Unos ejemplos de su uso es el siguiente:
Debug.Print "P = "; P
Debug.Print "Nombre = "; Nombre
Debug.Print "X = "; X
Un ejemplo de su uso, con los enunciados agregados al programa anterior de cinemática física, es el siguiente:
Sub Command1_Click ()
Dim V0, A, T, S As Single
V0 = Text1
A = Text2
T = Text3
S = V0 * T + .5 * A * T ^ 2
Debug.Print "V0 = "; V0
Debug.Print "A = "; A
Debug.Print "T = "; T
Debug.Print "S = "; S
Text4 = S
End Sub
Si el programador tiene la ventana Inmediata (o la ventana Debug, en su caso, o el equivalente) abierta, al ejecutar el programa verá que aparecen en la ventana para la forma los cuatro valores numéricos de interés.
Una vez que el programador está satisfecho que su proyecto está libre de errores, todas las referencias al objeto Debug tienen que ser borradas cuando el proyecto sea compilado y convertido en un programa de aplicación ejecutable.
Existen incluso otros objetos que ni siquiera están comprendidos dentro de Visual Basic pero con los cuales los programas de aplicación elaborados con Visual Basic se pueden comunicar. Entre estos objetos están los que corresponden al sistema operativo que tiene el control de la máquina. Tal vez esto al principio cause algún asombro, pero en realidad no nos debería de sorprender. Después de todo, ¿por qué no podría construírse un sistema operativo (como Windows XP) usando la misma metodología de programación que ha resultado tan útil en la programación visual y en la construcción de interfaces visuales? Un ejemplo de un objeto que forma parte integral de los sistemas operativos de Microsoft es el Portapapeles (Clipboard) usado en forma intensiva para el copiado y empastado de texto e imágenes. De hecho, cuando se copia o corta información que puede ser de cualquier tipo, ésta se coloca en el Portapapeles. Y el Portapapeles no es un programa que se eche a andar con un clic del Mouse en algún ícono, se trata de algo que está incrustado hasta la médula dentro de otro objeto, el Explorador (Explorer) usado por los sistemas operativos Windows para visualizar los contenidos de carpetas y llevar a cabo copiado y empastado no solo de archivos individuales sino de carpetas completas que pueden contener miles de archivos.
De este modo, cuando la computadora está encendida podemos imaginar a la memoria RAM poblada con una multitud de objetos, muchos de los cuales están latentes a la espera de ser invocados con algún evento. Los objetos de un buen programa de aplicación, compatible con el sistema operativo que se esté utilizando, tienen que poder comunicarse con los objetos que corresponden al sistema operativo, de modo tal que la operación de una computadora moderna está basada en una multitud de objetos comunicándose entre sí de muchas maneras posibles:
Para que se puede llevar a cabo la comunicación de un objeto a otro, es necesario establecer convenciones, las cuales serán arbitrarias y diferentes de un entorno a otro. Sin embargo, los conceptos fundamentales serán los mismos. Es algo así como el escribir una serie de símbolos que describa una manzana. Los símbolos usados en castellano serán diferentes de los símbolos que se usen en chino para describir la manzana, pero la manzana sigue siendo la misma. En lo que respecta a los sistemas operativos desarrollados por Microsoft, pensando precisamente en este paradigma se desarrolló un modelo en la cual se consideraba a los objetos como componentes de algo mayor, y ello fue lo que condujo a adoptar la terminología del COM (Component Object Model), refinado con la introducción posterior del DCOM (Distributed Component Object Model).
Otra cosa implícita en cualquier metodología que lleve a cabo una programación mediante objetos es que siempre existe lo que se conoce como una jerarquía de objetos, la cual determina el tipo de objetos que se pueden incrustar dentro de otro, en lo que técnicamente se conoce como embedding. Si bien es posible incrustar un botón de comando dentro de una forma, no es posible incrustar una forma dentro de un botón de comando, lo cual carecería de sentido y sería completamente ilógico. Es responsabilidad del programador de aplicaciones el estar al tanto de las jerarquías de los objetos y respetar dichas jerarquías en todo momento.
La posibilidad de poder incrustar un objeto dentro de otro y vincularlos conduce a interrogantes interesantes. ¿Podemos incrustar algo más complejo, por ejemplo, un objeto tal como una hoja de trabajo tipo Excel, dentro de una forma? En principio, tal cosa debería ser posible, y esto es lo que condujo a la empresa Microsoft a tomar el liderazgo en la formalización de la tecnología informática conocida como Enlazamiento e Incrustación de Objetos OLE (Object Linking and Embedding). Esto es lo que permite hacer lo siguiente bajo Visual Basic 3.0 al incrustar un control OLE 2.0 dentro de una forma:
Al efectuar esta operación, aparece de inmediato otra ventana que nos pregunta de manera muy explícita cuál es el tipo de objeto que queremos incrustar, dándonos una lista de opciones:
Obsérvese que se está pidiendo la incrustación de un objeto del tipo de dibujo técnico AutoCAD (una empresa diferente e independiente de Microsoft). Obviamente, llevar a cabo vinculaciones e incrustaciones OLE de esta naturaleza requiere de una cantidad abundante de código que el programador de aplicaciones nunca llega a ver jamás.
Es importante destacar que los conceptos fundamentales de lo que se conoce como la programación orientada a objetos precede la aparición de interfaces visuales como Windows, dichos conceptos ya existían previamente e inclusive eran implementados mediante lenguajes de programación tales como el lenguaje Smalltalk, un lenguaje orientado a objetos disponible públicamente desde 1980, o sea desde los tiempos cuando aún no se inventaba la interfaz visual al estilo Windows. Tres años después vendría una alternativa mucho más potente y de mayor utilidad para los programadores de sistemas basada en el lenguaje C permitiendo la creación de objetos mediante una metodología seria y robusta, cuya sintaxis encontraría posteriormente su lugar en otro lenguaje orientado a objetos, el lenguaje Java. La introducción del sistema operativo Windows introdujo la primera gran aplicación práctica importante de dicha tecnología informática basada en el concepto de objetos, y hoy encontramos una gran variedad de programas que aplican dicha metodología, entre ellos los navegadores de Internet (browsers). Posteriormente en la serie de entradas que tratan acerca de las aplicaciones del lenguaje JavaScript veremos cómo mediante el lenguaje JavaScript el navegador Mozilla Firefox hizo posible la creación de páginas Web con una enorme gama de posibilidades dinámicas, ¡sin tener que recurrir para nada a los objetos especificados por Microsoft!
Algo que todavía no hemos visto aún en Visual Basic es la creación de listas ordenadas de objetos del mismo tipo conocidas como arreglos (¡no confundir con los arreglos de hileras de caracteres para los cuales se usa como definición de tipo la palabra String!). El estudio de esta estructura de datos resulta interesante por el hecho de que así como se pueden crear arreglos de números enteros o arreglos de hileras de caracteres, también se pueden crear arreglos de objetos en tiempo de ejecución, o sea, se pueden crear objetos nuevos al momento de ejecutarse un programa. Con la finalidad de evitar confusiones, usaremos la palabra array (se pronuncia como “arrei”) para referirnos a este concepto.
En términos generales, un array es una estructura de datos representa una lista (arreglo unidimensional), una tabla (arreglo bi-dimensional) e incluso un arreglo multi-dimensional de valores de datos equiparables. El nombre de un array es el nombre dado al array seguido por uno o varios índices, encerrados entre paréntesis y separados mediante comas. Una referencia a un array unidimensional utiliza un solo índice, en el formato NombreArray(i), refiriéndose al i-avo elemento en una lista de valores. Podemos declarar un array unidimensional fijo de la siguiente manera:
Dim Gallinas(14) As Integer
Dim Nombres(20) As String
La primera declaración se encarga de crear el array fijo Gallinas(i) capaz de contener 15 elementos del tipo Integer, tomando en cuenta que el elemento Gallinas(0) también forma parte del array, mientras que la segunda declaración se encarga de crear el array fijo Nombres(i) capaz de contener 21 elementos del tipo hilera (String). Obsérvese que todos los elementos dentro de un array deben pertenecer al mismo tipo de dato.
Para especificar una acotación (bound) baja en lugar de la acotación predeterminada de cero, podemos usar la palabra reservada To como se muestra en los siguientes ejemplos:
Dim Gallinas(1 To 15) As Integer
Dim Nombres(10 To 50) As String
En la primera declaración los números permisibles del índice van desde 1 hasta 15, pudiendo contener el array Gallinas 15 elementos, mientras que la segunda declaración los números permisibles del índice van desde 10 hasta 50.
Los índices de un array también pueden ser enteros negativos, por ejemplo:
Dim A(-5 To 35) As Currency
Un array bi-dimensional usa dos índices, en el formato NombreArray(i,.j), refiriéndose al elemento en el renglón i y en la columna j de la tabla, y así sucesivamente. La siguiente declaración se encarga de crear un array bi-dimensional 10 por 10:
Dim Matriz(10,10) As Double
Cualquiera de las dos dimensiones o ambas pueden tener una acotación inferior como se muestra en el siguiente ejemplo:
Dim Matriz(1 To 10, 1 To 10) As Long
Podemos extender este concepto a más de dos dimensiones, por ejemplo:
Dim Tensor(5, 1 To 20, 1 To 15) As Single
Esta declaración crea un array tri-dimensional cuyos tamaños son 5, 20 y 15. El número total de elementos es el producto de estas tres dimensiones, en este caso 1,500. Obsérvese que al agregar dimensiones adicionales a un array, el número de elementos aumenta en forma dramática, así que se debe tener mucha precaución al usarlos, ya que inclusive en estos tiempos en los que parece haber memoria RAM de sobra ésta memoria se puede agotar rápidamente con la declaración de arrays multidimensionales grandes.
Los ejemplos que se acaban de dar son ejemplos de arrays fijos, estáticos, cuyo tamaño es conocido y prefijado de antemano. En el caso de arrays que son creados dinámicamente, o sea los arrays dinámicos, el tamaño de los mismos es desconocido hasta que se ejecuta el programa, dependiendo con frecuencia de alguna opción que escoja el usuario final. Un array dinámico es declarado en dos pasos. Primero se declara un nombre para el array dando una lista de dimensión vacía:
Dim ArrayDinamico() As tipo
Hecho lo anterior, se asigna el número de elementos a ser asignados al array dinámico (en tiempo de ejecución, cuando el usuario selecciona alguna opción del programa) con un enunciado ReDim:
ReDim ArrayDinamico(X + 1)
El enunciado ReDim solo puede aparecer una sola vez dentro de un procedimiento. Se trata de un enunciado ejecutable, esto es, hace que la aplicación lleve a cabo la creación del mismo durante el tiempo de ejecución. El enunciado ReDim apoya la misma sintaxis que se usa para arrays fijos, así como las acotaciones inferiores y superiores, para cada dimensión. Sin embargo, el número de dimensiones no puede cambiar. Así tenemos algo como lo siguiente:
ReDim ArrayDinamico(5 To 12)
De este modo, el array dinámico MatrizActiva es creado de la siguiente manera declarándolo primero al nivel del módulo del procedimiento:
Dim MatrizActiva() As Integer
Hecho lo anterior, un procedimiento se encarga de adjudicar espacio para el array:
Sub CalculoMatricial()
ReDim MatrizActiva(19,29)
.
.
.
.
End Sub
El enunciado ReDim aquí mostrado adjudica una matriz de 20 por 20 enteros. Alternativamente, los acotamientos de un array dinámico pueden ser fijados usando variables:
ReDim MatrizActiva(X,Y)
Además de los arrays de datos, Visual Basic también reconoce arrays de controles que representan grupos de controles que comparten el mismo tipo y nombre, y que también comparten los mismos procedimientos de eventos, por ejemplo, un array de botones de opción. La sintaxis usada es la misma que la que vimos arriba, la única diferencia es que los elementos son objetos. Un array de controles contiene por lo menos un elemento y puede crecer hasta contener tantos elementos como lo permitan la memoria y los recursos de un sistema.
Agregar controles al estarse ejecutando un programa, o sea arrays dinámicos de controles, utiliza menos recursos del sistema que simplemente agregar controles múltiples del mismo tipo a una forma durante la etapa de diseño del programa. Los arrays de controles también son útiles si se desea que varios controles compartan el mismo código. Por ejemplo, si se crean tres botones de opción como un array de control, se puede ejecutar el mismo código sin importar cuál de ellos sea usado.
Si se desea crear un control nuevo en tiempo de ejecución (run time), ese control debe ser miembro de un array de controles. Con un array de controles, cada elemento nuevo que se vaya creando hereda los procedimientos de eventos comunes del array.
Sin el mecanismo de arrays de controles, crear controles nuevos en tiempo de ejecución no es posible, puesto que cada control completamente nuevo no tendría ningún procedimiento de eventos. Los arrays de controles resuelven este problema, porque cada control nuevo hereda los procedimientos de eventos comunes que ya se han escrito para el array. Por ejemplo, si una forma contiene varias cajas de texto que reciben cada una de ellas un valor de fecha, un array de controles puede ser elaborado para que todas las cajas de texto tengan el mismo código de validación de fecha.
Hay por lo menos tres maneras de crear un array de controles en la etapa de diseño:
(1) Darle el mismo nombre a más de un control.
(2) Copiar un control ya existente y empastarlo en la forma.
(3) Fijar la propiedad Index (Indice) del control a un valor que no sea Null (Nulo).
En lo que toca a arrays de controles de menú (para líneas de menú en la forma), se requiere utilizar el Editor de Menú (Menu Editor) que es una herramienta especializada de Visual Basic.
Para agregar o remover controles dinámicamente a un array de controles en tiempo de ejecución, se usan los siguientes enunciados Load y Unload de la siguiente manera:
Load objeto(índice)
Unload objeto(índice)
siendo objeto el nombre del control que será agregado o removido del array de controles, y siendo índice el valor del índice del control en el array. Cuando se carga con Load (esto es, se agrega) un nuevo elemento a un array de controles, la mayoría de los valores de las propiedades son copiados del elemento más bajo que existe en el array, en este caso, el elemento cuyo índice tiene un valor igual a cero. Puesto que las propiedades Visible, Index y Tab no son copiadas automáticamente a los nuevos elementos de un array de controles, para cada control nuevo que vaya siendo creado su propiedad Visible tiene que ser puesta a True.
A modo de ejemplo, podemos poner en una forma vacía lo suficientemente grande un botón de opción:
asignándole a dicho botón como propiedades el nombre (Name) de BotonOpcion, un valor Index igual a 0, valores Width (anchura del botón de opción) y Height (altura del botón de opción) iguales a 615 y 375 respectivamente, valores Left (distancia del botón de opción al borde izquierdo de la forma) y Top (distancia del botón al borde superior de la forma) de 960 y 120 respectivamente, y un valor Caption igual a 0, poniendo en el procedimiento Load() que corresponde a la forma el siguiente código:
Sub Form_Load ()
Dim i As Integer
For i = 1 To 10
Load BotonOpcion(i)
BotonOpcion(i).Visible = True
BotonOpcion(i).Enabled = True
BotonOpcion(i).Height = 375
BotonOpcion(i).Width = 500
BotonOpcion(i).Left = 960
BotonOpcion(i).Top = 100 + (i * 375)
BotonOpcion(i).Caption = LTrim$(Str$(i))
Next i
End Sub
En el programa anterior, cada vez que se ejecuta la línea:
Load BotonOpcion(i)
se va creando dinámicamente un nuevo botón de opción, que es puesto por debajo de los controles que ya se han ido creando arriba. El resultado final, al ejecutarse el programa (y no en la etapa de diseño) será un array completo de botones de opción como el siguiente:
¿Y cómo habrá de saber un programa cuál de los botones en un array de botones de opción ha sido activado? Mediante la propiedad de valor Value de los botones de opción. El siguiente enunciado, una vez que se ha creado un array de botones de opción como el anterior:
BotonOpcion(7).Value = True
hará que el botón de opción cuyo índice numérico es 7 se “encienda” y que todos los demás botones de opción se “apaguen” automáticamente.
Del mismo modo, mediante la propiedad Caption podemos darle a cada botón de opción un título representativo de la selección que queremos que se lleve a cabo, por ejemplo:
BotonOpcion(4).Caption = "Manzanas"
Podemos modificar el código anterior para incorporar el uso de las propiedades Value y Caption de la siguiente manera:
Sub Form_Load ()
Dim i As Integer
For i = 1 To 10
Load BotonOpcion(i)
BotonOpcion(i).Visible = True
BotonOpcion(i).Enabled = True
BotonOpcion(i).Height = 375
BotonOpcion(i).Width = 1300
BotonOpcion(i).Left = 960
BotonOpcion(i).Top = 100 + (i * 375)
Next i
BotonOpcion(8).Value = True
BotonOpcion(0).Caption = "Manzanas"
BotonOpcion(1).Caption = "Peras"
BotonOpcion(2).Caption = "Mangos"
BotonOpcion(3).Caption = "Uvas"
BotonOpcion(4).Caption = "Manzanas"
BotonOpcion(5).Caption = "Duraznos"
BotonOpcion(6).Caption = "Kiwis"
BotonOpcion(7).Caption = "Chabacanos"
BotonOpcion(8).Caption = "Naranjas"
BotonOpcion(9).Caption = "Platanos"
BotonOpcion(10).Caption = "Melones"
End Sub
Si se ejecuta lo anterior (ampliando, al tanteo, la anchura Width de la forma a algo como 3225 para dar cabida en la ventana a los titulares de cada botón de opción), se obtiene algo como lo siguiente:
Obsérvese que el botón de opción que está pre-seleccionado (por el programador) es el botón titulado “Naranjas”, indexado como el botón de opción número 8, como corresponde a la instrucción previa:
BotonOpcion(8).Value = True
Otra manera en la cual podemos poner en marcha, oprimiendo un botón de comando, la creación dinámica de un array de botones de opción que aparezca al oprimir el botón, es poniendo en una forma un botón de comando y un botón de opción de la manera que se muestra a continuación:
y asignando las siguientes propiedades a los tres objetos:
| Valores asignados a las propiedades | ||
| Forma | Botón de Comando | Botón de opciones |
| Height = 4830 | Height = 375 | Height = 375 |
| Width = 4020 | Width = 1935 | Width = 615 |
| Name = frmControles | Name = cmdOpciones | Name = optOpciones |
| Left = 240 | Left = 3000 | |
| Top = 1800 | Top = 120 | |
| Caption = Crear Opciones | Caption = 0 | |
| Index = 0 | ||
Para la forma, el procedimiento de eventos Load() cuando la forma se carga en la memoria RAM es sencillo, limitándose a hacer “invisible” el botón de opción cero (0) al empezar:
Sub Form_Load ()
optOpciones(0).Visible = False
End Sub
Para el botón de comando designado cmdOpciones, usamos el siguiente procedimiento de eventos Click():
Sub cmdOpciones_Click ()
Dim i As Integer
optOpciones(0).Visible = True
For i = 1 To 10
Load optOpciones(i)
optOpciones(i).Visible = True
optOpciones(i).Enabled = True
optOpciones(i).Height = 375
optOpciones(i).Width = 1215
optOpciones(i).Left = 3000
optOpciones(i).Top = 120 + i * 375
optOpciones(i).Caption = LTrim$(Str$(i))
Next i
End Sub
Estos son los únicos procedimientos de eventos que necesitamos. Cuando se ejecuta el programa, no aparece nada en la ventana excepto el botón de comando “Crear Opciones”. Al oprimir el botón de comando con un clic del Mouse la ventana se llena a la derecha de once botones de opción:
Algunos lectores tal vez se preguntarán cuál fue el procedimiento cuasi “mágico” para determinar los valores numéricos dados en la tabla mostrada arriba para el ejemplo que se acaba de citar. Aquí no hay ningún misterio, en realidad todo empieza con un procedimiento puramente visual “al tanteo” colocando en una forma -mediante operaciones de arrastre con el Mouse- los controles y moviéndolos y acomodándolos dentro de la forma (lo cual incluye cambiar las dimensiones rectangulares de la forma) de modo tal que se obtenga un efecto visual estético; conforme los controles dentro de la forma son movidos de un lugar a otro o cambiados de tamaño los valores numéricos de sus parámetros de tamaño y ubicación van siendo ajustados automáticamente por el entorno Visual Basic. No se requiere cálculo teórico alguno.
Se puede, desde luego, crear un array de botones de opción durante la etapa de diseño (en lugar de hacerlo cuando el programa se está ejecutando) metiendo cada botón de opción dentro de una forma, uno por uno, pero por principio de cuentas esto require una colocación cuidadosa para que los botones de opción estén perfectamente alineados y espaciados igualmente el uno del otro, además de tener que ir fijando las propiedades de cada botón de opción, todo lo cual puede resultar algo tedioso. Con la creación de un array dinámico de botones de opción, nos podemos ahorrar una buena cantidad de trabajo al llevar a cabo el diseño.
En virtud de las conveniencias de los arrays de controles, Visual Basic proporciona otra manera adicional y fácil de crear arrays de controles, y ello consiste en meter en la forma el primer control del array dándole cierto nombre a dicho control (en su ventana de Propiedades), por ejemplo “Boton”, y tras esto meter un segundo control del mismo tipo en la forma dándole al segundo control el mismo nombre que se le dió al primero, o sea “Boton”. Visual Basic, al ver que el programador le quiere dar a dos controles el mismo nombre, abrirá de inmediato una ventana que dice: “Usted ya tiene un control llamado 'Boton'. Desea crear un array de control?”:
y al dar el programador su visto bueno entonces Visual Basic se encarga de convertir los dos controles en un array de controles usando el mismo nombre para ambos controles pero anexando al nombre de cada control un número entero entre paréntesis que sirve como índice para distinguir un control de otro en un array ordenado de controles.
Con lo que hemos visto hasta este punto, se puede lograr mucho, pero Visual Basic cuenta con herramientas adicionales y recursos con los que se puede lograr aún más que iremos viendo más a fondo y en mayor detenimiento en las siguientes entradas.
