Las variables son espacios en la memoria donde el programa guarda datos. A este lugar en la memoria se hace referencia mediante un identificador: el nombre de la variable. Un nombre de variable tiene que cumplir con las mismas reglas que con los nombres de los objetos.
La variable almacenará un determinado tipo de dato, y de esto dependerá la cantidad de memoria que ocupe. Las variables, por tanto, serán de distinto tipo y en el código se puede declarar (crear) una variable del tipo que se especifique. La sentencia para declarar una variable será:
Alcance nVariable as tDato
Donde Alcance será el alcance de la variable (Private o Public); nVariable será el nombre de la variable y tDato será el tipo de dato que almacenará.
Los tipos de datos son los siguientes:
| Tabla 3 - Tipos de Datos |
| Tipo Dato |
Descripción |
Rango |
Espacio (en bytes) |
| Boolean |
Valores binarios |
True o False (1 o 0) |
2 |
| Byte |
Números naturales |
0 a 255 |
1 |
| Integer |
Enteros cortos |
-32.768 a 32.767 |
2 |
| Long |
Enteros largos |
-2.147.483.648 a 2.147.483.647 |
4 |
| Single |
Reales Precisión Simple |
-3,40x1038 a -3,40x1038 |
4 |
| Double |
Reales Precisión Doble |
1,79x10308 a 1.79x10308, es más preciso que el Single |
8 |
| Date |
Fechas y Horas |
1/01/100 a 31/12/9999; 0:00:00 a 23:59:59 |
8 |
| String |
Cadena de caracteres |
Hasta 65.500 caracteres |
1 por c/caracter |
| Variant |
Cualquier tipo de dato |
|
16 (+1 por c/caracter en caso de ser texto) |
Hay otro tipo de dato, que son los tipos definidos por el usuario. También llamados Estructuras se verán en el item Tipos definidos por el usuario.
Las variables que se utilicen pueden estar declaradas explícita o implícitamente. Una variable está declarada en forma explícita cuando se la declara con una sentencia, o implícitamente cuando se la utiliza sin la sentencia de declaración. El inconveniente de las variables de este tipo es que son de tipo Variant y ocupan mucho espacio; conviene declarar todas las variables que se utilicen.
Para dar valor a una variable se utiliza la siguiente sentencia:
nVariable.Valor
Supóngase una variable de tipo Integer llamada número a la cual se quiere dar el valor -3.790; la declaración de la variable podría ser:
Dim número as Integer
Para asignarle el valor -3.790 se escribe la siguente sentencia:
número=-3790
Si se quisiera consultar el valor de una variable se podría utilizar alguna sentencia donde se le asigne, por ejemplo, su valor a la propiedad Caption de una etiqueta, imprimirla en la ventana Inmediato, etc:
lblResu.Caption=número
Debug.Print número
Alcance de las variables.
Se denomina alcance de una variable a los lugares desde donde ésta puede ser accesible, o sea, desde donde se la puede utilizar. Este alcance dependerá del lugar donde haya sido declarada (formulario, módulo estándar, etc) y la forma en que haya sido declarada (Private o Public). Vale decir que una variable declarada con Dim equivale a Private.
Una variable declarada en un módulo estándar como Public es accesible desde todo el proyecto; declarada como Private es accesible sólo dentro de ese módulo.
Una variable declarada en un formulario como Public es accesible en todo ese formulario y en otros, siempre que esté precedida por el nombre del formulario. Declarada como private es accesible en todo ese formulario.
Una variable declarada dentro de un procedimiento o función sólo será accesible dentro de ese procedimiento o función y será declarada con Dim.
Ejemplo 1
Crea un nuevo proyecto estándar y coloca en el formulario los siguientes controles:
| Control |
Propiedad |
Valor |
| Form |
Name |
frmProg |
| Textbox |
Name |
txtValor |
| " " |
Text |
|
| Frame |
Name |
fraCont |
| " " |
Caption |
Variables |
| Option |
Name |
optBool |
| " " |
Caption |
Boolean |
| Option |
Name |
optInte |
| " " |
Caption |
Integer |
| Option |
Name |
optStri |
| " " |
Caption |
String |
| Option |
Name |
optDate |
| " " |
Caption |
Date |
| Label |
Name |
lblValor |
| " " |
Caption |
|
| Commandbutton |
Name |
cmdAsignar |
| " " |
Caption |
Asignar |
| Commandbutton |
Name |
cmdMostrar |
| " " |
Caption |
Mostrar |
Escriba el siguiente código en la ventana de código del formulario:
Option Explicit
Dim bool as Boolean, inte as Integer, stri as String, fech as Date
Private Sub cmdAsignar_Click()
If optBool.Value=True Then
bool=txtValor.Text:lblValor.Caption=bool
End If
If optInte.Value=True Then
inte=txtValor.Text:lblCaption=inte
End If
If optStri.Value=True Then
stri=txtValor.Text:lblCaption=stri
End If
If optDate.Value=True Then
fech=txtValor.Text:lblCaption=fech
End If
End Sub
Private Sub cmdMostrar_Click()
Debug.Print "El valor de bool es"& bool
Debug.Print "El valor de inte es"& inte
Debug.Print "El valor de stri es"& stri
Debug.Print "El valor de fech es"& fech
End Sub
Private Sub optBool_Click()
lblValor.Caption=bool
End Sub
Private Sub optInte_Click()
lblValor.Caption=inte
End Sub
Private Sub optStri_Click()
lblValor.Caption=stri
End Sub
Private Sub optFech_Click()
lblValor.Caption=fech
End Sub
Pulse F5 para probar la aplicación.
Si se asigna, por ejemplo, a la variable bool el valor 17, la aplicación enviará un mensaje en tiempo de ejecución (Desbordamiento). Para el correcto de la aplicación, debe darse a las variables valores adecuados a ellas.
Constantes.
Las constantes son como las variables, con la excepción de que su valor es asignado una única vez y luego no puede ser cambiado. Su valor es asignado en la misma declaración y si luego se intenta cambiar su valor se producirá un error. Las constantes son privadas por defecto y si se desea que sean públicas habrá que declararlas como Public.
A continuación los ejemplos generales de una constante privada y otra pública:
Const nConst as tDato=Valor
Public Const nConstante as tDato=Valor
Donde nConstante es el nombre la constante, tDato es el tipo de dato que almacenará (Integer, Single, Date, etc.) y valor es el valor que almacenará. La declaración de una constante que almacene velocidad de la luz, en forma privada y pública, sería:
Const velocidadluz as Long=300000
Public Const velocidadluz as Long=300000
El valor de una constante se utiliza de la misma forma que el valor de una variable y cumple con los mismos criterios de alcance.
Tipos definidos por el usuario.
Hay otro tipo de dato para asignar a una variable, el cual es un tipo de dato creado por el usuario, ya que los existentes pueden no adaptarse plenamente a lo que el usuario quiere almacenar en la variable.
Los tipos de datos definidos por el usuario no son más que agrupaciones de variables de distintos tipos reunidas bajo el nombre de una variable común. Estos tipos de datos se denominan también estructuras y se construyen en un módulo estándar (*.bas). La forma de la sentencia a utilizar es la siguiente:
Public Type ntDato
nvDato1 as tDato
nvDato2 as tDato
...
nvDato as tDato
End Type
Donde ntDato es el nombre del tipo de dato que se creará, nvDato son los nombres de las variables que compondrán la estructura y tDato es el tipo de dato de de dichas subvariables, y que podrá ser de cualquier tipo, incluso de otro tipo definido por el usuario.
Suponga un tipo de dato denominado Paciente, en el cual figure su número de ficha, su apellido, su nombre, su edad y su fecha de ingreso. La estructura podría ser la siguiente:
Public Type Paciente
ficha as Long
apellido as String*15
nombre as String*10
edad as Byte
ingreso as Date
End Type
Sólo en las variables de tipo String se colocó un asterisco seguido de un número. Este indica la cantidad máxima de caracteres que almacenará la variable y de esta forma se sabrá con exactitud cuántos bytes ocupará la variable y, por consecuencia, el nuevo tipo creado. En este caso el tipo creado ocupará 44 bytes porque:
| ficha as Integer |
2 bytes |
| apellido as String*15 |
15 bytes |
| nombre as String*10 |
10 bytes |
| edad as Byte |
1 byte |
| ingreso as Date |
8 bytes |
| TOTAL |
36 bytes |
Para declarar una variable de este tipo se procede como para declarar cualquier variable. Con respecto al acceso a la misma, a continuación del nombre de la variable se digita un punto y se escribe la subvariable de este tipo, para recuperar o para dar valor. En el caso del tipo Paciente:
Dim pac as Paciente
pac.ficha=12037
pac.nombre="Claudio"
lblApellido.Caption=pac.apellido
Los tipos definidos por el usuario son muy útiles a la hora de guardar la información en ficheros (archivos) y recuperarla luego.
Arrays.
Un array es una variable que almacena varios datos del mismo tipo; estos datos ocupan posiciones contiguas en la memoria y cada dato particular del array tiene un indice que lo identifica. Un array se declara como una variable pero luego de escribir el nombre de ésta, se pone entre paréntesis la cantidad de elementos que lo conformarán. Por ejemplo:
Private unarray(5) as Integer
Es la declaración de un array de 6 elementos, numerados de 0 a 5. Para entenderlo más fácilmente, en forma gráfica se representaría así:
Cada elemento del array almacena un Integer, por lo que todo el array ocupará 12 bytes (2 bytes x 6 elementos).
Todos los arrays comienzan a ser numerados por cero, a menos que se declare el array de la siguiente forma:
Private unarray(1 To 5) as Integer
En este caso se está declarando un array de 5 elementos, numerados de 1 a 5 (1 To 5), por tanto ocupará 10 bytes (2 bytes x 5 elementos), gráficamente este array se representaría así:
Estos tipos de array tienen una sola dimensión y se denominan Vectoriales.
Supóngase ahora el siguiente array:
Private otroarray(4) as Byte
Este es un array de 5 elementos numerados de 0 a 4, donde cada elemento almacena un dato de tipo Byte y ocupará 5 bytes (1 byte x 5 elementos).
Si se quiere dar valor a cualquier elemento del array, se procede como se ha visto para dar valor a una variable, pero seguido al nombre de la variable se escribe entre paréntesis el índice del elemento. Para dar el valor 87 al primer elemento de este array, se escribe la siguiente sentencia:
otroarray(0)=87
otroarray(3)=207
Para recuperar el elemento de índice 3 de otroarray y presentar su valor en una caja de texto llamada txtVarray, se escribe la siguiente sentencia:
txtVarray.Text=otroarray(3)
Los arrays no solamente pueden tener una dimensión (vectoriales o unidimensionales) sino varias, a estos arrays se los denomina multidimensionales o matrices.
Se declaran como los arrays vectoriales, pero se especifica también la cantidad de dimensiones que tiene a continuación de la cantidad de elementos y separada por una coma (,). Un array de nombre matríz, que conste de 5 elementos por cada dimensión y 3 dimensiones, que almacene datos Byte, se declara así:
Private matriz(4,2) as Byte
Cada elemento del array estará identificado por una coordenada que representa el índice que tiene y su dimensión; gráficamente se representa así:
| 0,0 |
1,0 |
2,0 |
3,0 |
4,0 |
| 0,1 |
1,1 |
2,1 |
3,1 |
4,1 |
| 0,2 |
1,2 |
2,2 |
3,2 |
4,2 |
Este array ocupará 15 bytes (1 byte x 5 elementos x 3 dimensiones). Para este caso, si se desea asignar el valor 9 al tercer elemento de la primera dimensión, el valor 18 al quinto elemento de la segunda dimensión y el valor 100 al primer elemento de la tercera dimensión se escriben las siguientes sentencias:
matriz(2,0)=9
matriz(4,1)=18
matriz(0,2)=100
También puede declararse una matriz de 5 elementos por dimensión y 3 dimensiones de la siguiente manera:
Dim otramatriz(1 To 5, 1 To 3) as Byte
En este caso, la matriz contendrá también 15 elementos por dimensión y ocupará 15 bytes, pero los elementos y las dimensiones no comenzarán a numerarse por cero, sino por uno. En esta matriz, para dar el valor 18 al quinto elemento de la sengunda dimensión la sentencia será:
otramatriz(5,2)=18
Ejemplo 2
Crea un nuevo proyecto estándar y coloca en él los siguientes elementos:
| Control |
Propiedad |
Valor |
| Form |
Name |
frmArray |
| Textbox |
Name |
txtVarray |
| " " |
Text |
|
| HScroll |
Name |
hsbElem |
| " " |
Min |
0 |
| " " |
Max |
7 |
| " " |
Value |
0 |
| VScroll |
Name |
vsbDimen |
| " " |
Min |
0 |
| " " |
Max |
3 |
| " " |
Value |
0 |
| Commandbutton |
Name |
cmdCambio |
| " " |
Caption |
Cambiar |
Escribe el siguiente código en la ventana de código del formulario:
Option Explicit
Dim matriz(7,3) as Integer
Private Sub hsbElem_Change()
txtVarray.Text=matriz(hsbElem.Value,vsbDimen.Value)
End Sub
Private Sub vsbDimen_Change()
txtVarray.Text=matriz(hsbElem.Value,vsbDimen.Value)
End Sub
Private Sub cmdCambio_Click()
matriz(hsbElem.Value,vsbDimen.Value)=txtVarray.Text
End Sub
Pulse F5 para probar la aplicación.
El array matriz declarado almacena datos Integer; 8 elementos por dimensión y tiene 4 dimensiones, por tanto ocupa 64 bytes (2 bytes x 8 elementos x 4 dimensiones). Los índices de los elementos de la matriz a ser consultados o cambiados están determinados por las propiedades Value de las barras de desplazamiento. Si el tipo de dato ingresado no es un Integer, se generará un error en tiempo de ejecución.
Redimensionar un array.
Antes de explicar cómo se redimensiona un array se explicará qué es un array dinámico.
Un array dinámico es un array en el cual no se especifica cuántos elementos tendrá. Si se quiere declarar un array dinámico de nombre dinarray que almacene datos de tipo Double se utiliza la siguiente sentencia:
Dim dinarray() as Double
Redimensionar un array significa cambiar el número de elemetos, pero no se puede cambiar sus dimensiones. Esto implica que no se puede transformar, por ejemplo, un vector en una matriz. Solamente se puede redimensionar un array una vez por procedimiento o función. Esta operación se realiza con la sentencia Redim, y su sintaxis es la siguiente:
Redim nArray(nValor)
Se redimensiona el array dinarray para que almacene 12 elementos:
Redim dinarray(11)
Al redimensionar un array se borran todos los elementos que contuviera: si los datos son numéricos se ponen a 0, si son texto se ponen a cadena vacía, si son Variant se ponen a Empty, etc.
Si se quiere redimensionar un array y conservar los valores ya almacenados se utiliza la palabra Preserve luego de la palabra Redim, de la siguiente forma:
Redim Preserve nArray(nValor)
Arrays de controles.
Los arrays de controles son un conjunto de controles del mismo tipo que tienen el mismo nombre, pero cada uno se individualiza de los demás por su propiedad Index.
La ventaja de utilizar array de controles es que si los controles responden de forma similar a un evento, bastaría con escribir el código del evento por el que responderán todos los controles que conformen el array.
Para crear un array de controles basta con colocar un control, copiarlo y pegarlo. Se preguntará si se desea crear una matriz de controles, a lo que se responde que sí.
Cuando se escribe el código de un evento que involucra un array de controles, aparecerá un argumento denominado Index as Integer, el cual permite identificar a cada control en particular.
Ejemplo 3
Crea un nuevo proyecto estándar y coloca un Commandbutton de propiedad Name: cmdArray. Copiarlo y pegarlo 5 veces, hasta que se forme un array de 6 botones.
Escribir el siguiente código en la ventana de código del formulario:
Private Sub cmdArray_Click(index as Integer)
Debug.Print "Ha presionado el botón de índice"& index
End Sub
Pulse F5 para probar la aplicación
