Está en la página 1de 11
CURSO DE VB CAPÍTULO 1 Índice de contenido 1.- INTRODUCCIÓN AL CURSO 2.- EL ENTORNO
CURSO DE VB
CAPÍTULO 1
Índice de contenido
1.- INTRODUCCIÓN AL CURSO
2.- EL ENTORNO DE TRABAJO
MÓDULOS
COMPARACIÓN Y DECLARACIÓN DE VARIABLES
2
2
4
4
3.-
VARIABLES Y TIPOS DE DATOS
VARIABLES
TIPOS DE DATOS
6
6
8
1
Visítame en http://neckkito.eu5.org
1.- INTRODUCCIÓN AL CURSO Hola a tod@s: Voy a empezar este curso diciendo que este
1.- INTRODUCCIÓN AL CURSO
Hola a tod@s:
Voy a empezar este curso diciendo que este no es un curso
de VBA para Access
en el sentido estricto del término.
Es decir: si cogéis un libro sobre VBA para Access (si tenéis
la suerte de “pillar” alguno que valga la pena) normalmente
hay una parte importante del curso que se refiere a teoría
pura y dura, con algún que otro ejemplo, pero pocos
Por otra parte resulta prácticamente imposible realizar un curso de VBA para Access que logre
abarcar “todo” lo que puede explicarse sobre este tipo de programación. Hay códigos que
funcionan perfectamente
hasta que no funcionan. ¿Por qué? Porque el código funciona si se
está aplicando sobre un textbox (por poner un ejemplo), pero si se aplica a un combobox la
cosa se nos “espachurra”. Tener en cuenta toda esta casuística es, definitivamente, “de locos”.
Sin embargo, no debemos desanimarnos por mis anteriores palabras. La cosa no es tan
drástica, en general, como acabo de comentar, pero mi intención de empezar esta introducción
así ha sido para que quede claro que:
• Si seguimos este curso podremos hacer un montón de cosas, pero no todas. Hay que
“moverse”, por eso
• No lo sé todo de VBA. Mi gran amiga es la tecla F1, y también los foros de ayuda que
hay por Internet. Pero, además
• Utilizad un poquito de imaginación
Mi gran ilusión sería que al acabar el curso fuerais capaces no sólo de hacer, sino de, si no lo
sabéis hacer, sacar de la “chistera” una solución vuestra, propia, o si encontráis algún código
que alguien ha pensado previamente, seáis capaces de “entender” que hace ese código, y
poder decir: “¡Vaya! Este “pedazo” de código me sirve para lo que yo necesito
adaptarlo!”
¡y sé cómo
Dicho lo anterior esta primera lección será un poco “dura” porque hay que empezar por utilizar
unos conceptos básicos, y eso representa un poquito de teoría. Intentaré hacerlo lo más
“suave” posible.
2.- EL ENTORNO DE TRABAJO
Nuestro entorno de trabajo va a ser el editor de VBA, que a partir de ahora, como soy tan
fashion, lo voy a llamar VBE (Visual Basic Editor). No me voy a meter “a fondo” con el VBE,
sino que sólo explicaré la terminología fundamental que utilizaremos durante el curso, para
saber como mínimo de qué estamos hablando.
Y como dicen que una imagen vale más que mil palabras aquí os presento al VBE.
2
Visítame en http://neckkito.eu5.org
    Vamos a ver a nuestros “amiguitos”: -- Barra de menú (más
Vamos a ver a nuestros “amiguitos”:
-- Barra de menú (más que evidente)
-- Barra de herramientas (más que evidente)
-- Ventana de proyecto: en esta ventana podemos ver los objetos de Access que tienen
algún módulo asociado (hablaremos de eso más adelante), y también podemos ver los
módulos estándar (mdlNeckkito) y los módulos de clase (clsContainers)
-- Ventana de propiedades: que nos muestra las propiedades del elemento que tenemos
seleccionado en ese momento. En la imagen, yo puedo ver que, por ejemplo, el Form1 permite
la adición de registros (AllowAdditions: True)
-- Ventana inmediato: es una ventana que nos permite ver ciertos resultados de las acciones
del código que estamos programando. Hablando en plata, es un poco para hacer “guarrerías”.
Por ejemplo, si tenemos la ventana inmediato a la vista (si no la tenemos debemos ir a menú
Ver → Ventana Inmediato, o pulsar la combinación de teclas CTRL+G), podemos escribir lo
siguiente:
?4 + 3
Y
pulsamos Enter
Y
como Access es tan listo nos dice que el resultado de esa operación es 7.
3
Visítame en http://neckkito.eu5.org

Access es tan listo nos dice que el resultado de esa operación es 7. 3 Visítame

Access es tan listo nos dice que el resultado de esa operación es 7. 3 Visítame
Otra prueba, utilizando un poco de álgebra. Escribamos lo siguiente: a=3 b=5 ?a+b Y la
Otra prueba, utilizando un poco de álgebra. Escribamos lo siguiente:
a=3
b=5
?a+b
Y la ventana inmediato nos mostrará que el valor es 8.
Flipante, ¿verdad? ;)
-- Ventana de código: aquí se nos abrirán las ventanas
de los módulos donde podremos escribir nuestros códigos.
Como vemos en el ejemplo, yo tengo abiertas tres ventanas
correspondientes a dos formularios y un informe.
Y por ahora esos seis elementos serán suficientes para “ir tirando”.
Aprovecharemos la imagen para explicar otros conceptos:
MÓDULOS
– Módulo de objeto: es el módulo que se asocia a aquel objeto de Access que contiene
código. Si miramos la ventana de proyecto veremos que mi BD tiene tres formularios y un
informe con código asociado.
– Módulo estándar: es un tipo de módulo que no está asociado a ningún objeto. En
general contiene código accesible desde cualquier módulo estándar o de objeto.
– Módulo de clase: es módulo que, como su nombre indica, sirve para definir clases. Este
tipo de módulo es algo complejo de entender para quien se inicia en VBA, por lo que lo
dejaremos para una explicación posterior.
¿Qué ventaja tiene programar módulos estándar? Para que nos entendamos, para “trabajar
menos”. Vamos a poner un ejemplo abstracto: imaginemos que tenemos un formulario con
diez cuadros de texto, y que necesitamos que en cada uno de ellos, tras escribir un valor, se
realice una comprobación para saber si el valor es correcto. Deberíamos programar el evento
“Después de actualizar” de cada TextBox de la manera siguiente:
.- Cógeme el valor introducido
.- Haz todas estas operaciones de comprobación
.- Avísame si el valor introducido no es correcto.
Ello nos obligaría a escribir ese código en cada uno de los TextBox (¡bendito copy-paste!).
Pero, ¿y si creamos un módulo que nos haga las operaciones de comprobación? Esas
operaciones sólo deberían ser escritas una sola vez, mientras que a los TextBox deberíamos
decirle: llámame al módulo y dime si ha detectado que el valor es incorrecto.
Sé que esta explicación es un poco abstracta, pero aún no tenemos las herramientas
necesarias para un ejemplo práctico. Que no cunda el pánico, que pronto podremos ver lo
abstracto “en acción” ;)
COMPARACIÓN Y DECLARACIÓN DE VARIABLES
Si nos fijamos en la imagen vemos que los tres módulos de objeto que se ven empiezan
siempre con dos líneas:
4
Visítame en http://neckkito.eu5.org
Option Compare Database Option Explicit La primera le está diciendo a Access que utilice el
Option Compare Database
Option Explicit
La primera le está diciendo a Access que utilice el sistema
predeterminado para comparar valores.
Vamos a clarificar este concepto con un ejemplo:
 En el VBE nos vamos a menú → Insertar → Módulo. Nos
aparecerá la ventana de código de ese módulo, en blanco.
Escribimos lo siguiente, debajo de esas dos líneas (a quien
le salga sólo una línea que no se preocupe: llegaremos a la
segunda en breve):
Option Compare Database
Private Sub miComparación()
If "Neckkito" = "NECKKITO" Then
MsgBox "Es el mismo nombre"
Else
MsgBox "Es un nombre diferente"
End If
End Sub
Si
ahora situamos el cursor “dentro” del código y en la barra de menús le damos al “Play” (o
pulsamos la tecla F5) veremos que Access nos dice que es el mismo nombre. Esto es así
porque lo ha comparado como texto.
¿Cómo podríamos hacer para discriminar entre mayúsculas y minúsculas? Pues para hacer eso
le deberíamos indicar que queremos otro sistema de comparación, que sería el BINARY.
Es decir, que si ahora cambiamos nuestra primera línea de código, de manera que nos quede
así:
Option Compare Binary
Private Sub miComparación()
If "Neckkito" = "NECKKITO" Then
MsgBox "Es el mismo nombre"
Else
MsgBox "Es un nombre diferente"
End If
End Sub
y ejecutamos el código el resultado será que se trata de un nombre diferente.
En definitiva, que tenemos tres opciones de comparación para nuestra base de datos:
– Option Compare Database
– Option Compare Text
– Option Compare Binary
 Truco: si en el VBE situamos el cursor sobre la palabra “Compare” y pulsamos F1 se nos
abrirá la ayuda, que nos ampliará un poquito más estos conceptos.
Y ahora vayamos con la segunda de las líneas. Para programar código solemos utilizar
variables (veremos las variables más adelante). Una variable es simplemente una “palabra”
que utilizamos para poder almacenar un valor. Podemos definir directamente un valor para una
variable, simplemente escribiendo esto en el código (siempre y cuando no nos aparezca la
5
Visítame en http://neckkito.eu5.org
línea Option Explicit): miValor = 3 Sin embargo, como su nombre indica, podemos pensar que
línea Option Explicit):
miValor = 3
Sin embargo, como su nombre indica, podemos pensar que
miValor va a almacenar un número, y durante el código
podría ser que almacenara, por ejemplo, una fecha. Eso
produciría un error de código, que sería difícil de depurar
(según el código). Para evitar lo anterior podemos decidir
que Access nos “obligue” a indicar qué tipo de variable (qué
tipo de dato) va a ser nuestra variable. Así, cuando no se
cumpla que miValor es un número Access nos llevará a la
línea donde miValor ya no es un número, con lo que la
depuración es más eficaz.
Cuando “forzamos” la definición de variables Access nos avisa añadiendo esa línea en los
módulos: Option Explicit.
¿Y cómo podemos llevar a cabo esa definición de variables? Pues muy fácil: nos vamos a menú
→ Herramientas → Opciones, y marcamos el check “Requerir declaración de variables”. A partir
de ese momento módulo que se cree nuevo módulo que requerirá la declaración de variables.
3.- VARIABLES Y TIPOS DE DATOS
VARIABLES
Y ya que estamos hablando de variables vamos a ver cómo podemos definir las variables.
Antes de empezar vamos a ver un par de tipos de variables:
– CONST: si declaramos una variable como Const estamos diciéndole a Access que esa
variable siempre tendrá un valor constante y que no puede cambiar.
– DIM: si declaramos una variable como Dim estamos diciéndole a Access que esa
variable puede ir cambiando su valor
– STATIC: si declaramos una variable como STATIC estamos diciéndole a Access que esa
variable puede ir cambiando su valor, el cual no se reiniciará en cada “pasada” del código.
¿Claro, verdad? Como yo no lo tengo tan claro vamos a utilizar un ejemplo muy simple para
ver cómo funciona la historia.
Creamos un módulo (ahora ya deberíamos saber cómo hacerlo) y escribimos el siguiente
código:
Private Sub misVariables()
Const miConstante As Integer = 5
Dim miDim As Integer
Static miStatic As Integer
miDim = miDim + 1
miStatic = miStatic + 10
Debug.Print miConstante
Debug.Print miDim
Debug.Print miStatic
End Sub
6
Visítame en http://neckkito.eu5.org
Si ahora ejecutamos el código (F5) en la ventana Inmediato encontraremos los siguientes valores: 5
Si ahora ejecutamos el código (F5) en la ventana Inmediato encontraremos los siguientes
valores:
5
1
10
Volvamos a ejecutar el código. Los valores obtenidos ahora
son:
5
1
20
La constante, como buena constante, ha seguido manteniendo su valor en 5
La variable DIM, en la primera ejecución, ha asumido que su valor inicial era cero y como le
hemos sumado uno el resultado final ha sido 1.
En la segunda ejecución la DIM se ha reinicializado, de manera que ha vuelto a suponer que su
valor inicial era cero y como le sumamos 1 el resultado final ha sido 1.
La variable STATIC, en la primera ejecución, ha asumido que su valor inicial era cero y como le
hemos sumado 10 el resultado final ha sido 10.
En la segunda ejecución, por ser static, no se ha reinicializado, sino que ha “guardado” el valor
final de la primera ejecución. Por ello, si volvemos a sumarle diez, el resultado final será,
lógicamente, 20.
◊ ¿Qué más cosas podemos aprender del código que hemos utilizado? Pues, por ejemplo,
cómo se declaran las variables. Así, ahora ya sabemos que:
– Una variable Const se declara con la siguiente estructura
– Const <nombreVariable> As <tipoDato> = <valor>
– Una variable Dim se declara con la siguiente estructura
– Dim <nombreVariable> As <tipoDato>
– Una variable Static se declara con la siguiente estructura
– Static <nombreVariable> As <tipoDato>
◊ Otra cosa que podemos ver es que las variables numéricas, como en este caso, aceptan la
realización de operaciones matemáticas.
Es decir, hemos utilizado la suma, pero podríamos haber utilizado expresiones del tipo:
miDim = miDim * 3
miDim = miDim / 2
Y lógicamente podemos mezclar las distintas variables, siempre y cuando sean del mismo tipo
de dato.
Por ejemplo, podríamos haber escrito:
miDim = miConst + miStatic
◊ También ahora ya sabemos que para ver los resultados en la ventana Inmediato debemos
7
Visítame en http://neckkito.eu5.org
utilizar Debug.Print <valor/variable> TIPOS DE DATOS Hay varios (unos cuantos) tipos de datos. Vamos a
utilizar Debug.Print <valor/variable>
TIPOS DE DATOS
Hay varios (unos cuantos) tipos de datos. Vamos a realizar
aquí una enumeración de los tipos de datos, sin entrar en
detalles, porque como durante este curso vamos a
utilizarlos la práctica nos permitirá ver peculiaridades.
De todas maneras no voy a repetir lo que Microsoft ya ha
escrito. Así, si estamos interesados en saber las
peculiaridades de cada tipo de variable, lo que tenemos que
hacer es, simplemente:
1.- En cualquier ventana de código escribimos el tipo de dato (v.gr., escribimos String)
2.- Situamos el cursor encima de lo que hemos escrito y pulsamos F1
Y ahora sí, vamos con los tipos de datos:
 String: es una cadena de texto (se incluyen los espacios en blanco). Deben definirse
siempre entre comillas. Por ejemplo:
Const miNick As String = “Neckkito”
 Date: es un dato de tipo fecha/hora. Lo debemos definir entre almohadillas. Por ejemplo
Const miDtm As Date = #22/03/11#
 Boolean: es un dato de tipo verdadero/falso. Las palabras claves para definirlo son True o
False. Por ejemplo
Const miBln As Boolean = True
Hay que tener en cuenta que también puede coger su valor en función de si se cumple una
condición o no. Por poner un ejemplo “tonto”, el booleano miBln cogería el valor False si lo
defino así: miBln = 8<3
 Variant: es un dato de tipo “cajón de sastre”. La podemos utilizar cuando no estamos
seguros de qué tipo de dato adquirirá la variable. Por ejemplo
Dim niIdea As Variant
Si escribimos en el código algo así como
niIdea = “Ahora ya sé lo que es” esta variable Variant adquirirá las características de una
variable tipo String.
Los siguientes tipos son números “sin decimales”:
 Byte: es un dato de tipo numérico, que va de 0 a 255. Por ejemplo
Const miBit As Byte = 3
 Integer: es un dato de tipo numérico, que abarca un mayor rango de valores que el tipo
anterior. Por ejemplo
Const miInt As Integer = 10000
 Long: es un dato de tipo numérico, que abarca un mayor rango de valores que los dos
anteriores. Por ejemplo
Const miLng As Long = 100000
8
Visítame en http://neckkito.eu5.org
Y los siguientes son tipos de números “con decimales”; es decir, lo que se denomina
Y los siguientes son tipos de números “con decimales”; es decir, lo que se denomina “con coma
flotante”:
 Single: es un dato de tipo numérico con . Por ejemplo
Const miSing As Single = 2.1
 Double: es un dato de tipo numérico, de mayor rango
que el single (y de mayor precisión en los decimales). Por
ejemplo
Const miDbl As Double = 24.456
 Currency: es un dato de tipo numérico, de mayor precisión que el double. Por ejemplo
Const miCurrency As Currency = 1526.63579
Aunque pueda parecer que el tipo currency lo utilizamos sólo para valores de moneda, lo
podemos utilizar si queremos una precisión muy grande en los decimales.
 Decimal: es un dato de tipo numérico, con una enorme precisión en los decimales. En
Access no podemos declararlo directamente, sino que primero lo tenemos que declarar como
Variant y después convertirlo a decimal. Esto lo veremos en un capítulo posterior.
Un par de puntualizaciones al tema de las variables y tipos de datos:
 Existen lo que se denominan “caracteres de definición de tipos”, que permiten identificar el
tipo de la variable sin tener que escribir dicho tipo. Es decir, que si yo escribo
Dim miVariable% es como si escribiera Dim miVariable As Integer
La lista de equivalencias existentes la tenéis aquí:
CARÁCTER DE DEFINICIÓN DE TIPO
TIPO VARIABLE
$
String
%
Integer
&
Long
!
Single
#
Double
@
Currency
 Existen unos “valores” que no pueden ser definidos por los tipos de datos que hemos visto,
exceptuando uno: el tipo de dato Variant.
Es decir, si no hay valor en un campo ese campo es nulo (NULL), o también podemos tener un
dato vacío (EMPTY), un valor “nada” (NOTHING), o un valor error (ERROR). Para recoger esa
“ausencia” o tipo especial de valor debemos emplear el tipo Variant. Ahora es un poco difícil
entrar en detalles sobre esta característica, pero a lo largo del curso veremos algunos ejemplos
de lo anterior y lo entenderemos perfectamente.
Y ya para acabar con este tema vamos a ver la utilidad de nuestra Option Explicit, ahora que
“controlamos” el tema de las variables y de los tipos de datos. Vamos a hacer lo siguiente:
1.- En nuestro VBE creamos un nuevo módulo (o reciclamos uno que tengamos con las
pruebas que hayamos podido hacer). Escribimos el siguiente código:
9
Visítame en http://neckkito.eu5.org
… Private Sub miError() Dim miInt As Integer miString = "Aquí hay un error" Debug.Print
Private Sub miError()
Dim miInt As Integer
miString = "Aquí hay un error"
Debug.Print miString
End Sub
Si ejecutamos el código nos salta el siguiente error:
Y nos marca la variable que no se ha definido (miString). Ahora nos ha marcado
Y nos marca la variable que no se ha definido (miString).
Ahora nos ha marcado en amarillo la primera línea del procedimiento que hemos escrito,
bloqueando cualquier ejecución de código.
Para desbloquear la interrupción del código le damos al botón “stop” (restablecer)
Ahora, detectado el error, reescribimos el código de la siguiente manera:
Private Sub miError()
Dim miInt As Integer
miInt = "Aquí hay un error"
Debug.Print miString
End Sub
Y
ejecutamos el código
Je, je
¿alguien nos “chiva” que hay algo mal?
Por tercera vez reescribimos el código de la siguiente manera:
Private Sub miError()
Dim miInt As Integer
miInt = "Aquí hay un error"
Debug.Print miInt
End Sub
Y
lo ejecutamos
obteniendo lo siguiente:
10
Visítame en http://neckkito.eu5.org
¿Por qué? Porque hemos definido miInt como Integer y cuando el valor que hemos asignado
¿Por qué? Porque hemos definido miInt como Integer y cuando el valor que hemos asignado
¿Por qué? Porque hemos definido miInt como Integer y cuando el valor que hemos asignado es
de tipo String.
Es interesante que nos vayamos familiarizando con el error “13 en tiempo de ejecución”, dado
que, en nuestros primeros proyectos, con toda probabilidad se va a convertir en un buen
amigo nuestro
¡O al menos así lo dicta mi experiencia!
Os dejo como ejercicio (fácil, fácil) la corrección del código para que en la ventana inmediato
os aparezca un valor.
¡Suerte!
11
Visítame en http://neckkito.eu5.org