Crea programas Visual Basic

Indice
1. Introducción.............................................................................................................. 1

2. Creación de un programa ......................................................................................... 3

3. Entorno de Trabajo................................................................................................... 6

4. Componentes ........................................................................................................... 10

5. Proyectos ................................................................................................................. 13

6. Las variables............................................................................................................ 15

7. Operaciones básicas................................................................................................ 20

8. Funciones generales ............................................................................................... 22

9. Matrices ................................................................................................................... 25

10. Control de flujo.................................................................................................... 30

11. Organigramas ...................................................................................................... 32

12. Funciones y Procedimientos ............................................................................... 34

13. Control de errores ................................................................................................ 38

14. Depuración........................................................................................................... 39

15. Cuadro de mensaje .............................................................................................. 40

Creación de un menú .................................................................................................... 42

17. SQL....................................................................................................................... 43

18. DAO...................................................................................................................... 49

19. API ....................................................................................................................... 53

—I—

Visual Basic es un lenguaje de programación de alto nivel, cuyo único proveedor es Microsoft.
Su ámbito de aplicación se limita al sistema operativo Windows 95, 98 ó NT.

Tipos de lenguajes de programación:
• Lenguajes de bajo nivel: Son los lenguajes ensambladores (Assembler), que hablan el mismo
lenguaje que el procesador de un ordenador; el llamado código máquina. Son bastantes complejos y
difíciles de utilizar aunque con ellos se crean programas con un rendimiento óptimo.
• Lenguajes de alto nivel: Las instrucciones que componen un programa utilizan una especie de
sintaxis inglesa muy rígida. Al compilar, las instrucciones se traducen a código máquina.
Normalmente una instrucción equivale a muchas instrucciones de código máquina. Estos lenguajes
son más sencillos de utilizar que los ensambladores. Ejemplos de este tipo de lenguaje son: Java,
C++, Delphi (Pascal), y Visual Basic.
Visual Basic es utilizado generalmente para programas de gestión donde predomina el acceso intensivo a
bases de datos. Las aplicaciones del paquete ofimático Microsoft Office (Word, Excel o Access) incluyen
Visual Basic como lenguaje de programación.
Con Visual Basic seremos capaces de crear nuestros propios programas ya compilados, es decir
crearemos un archivo de extensión EXE. Hay que tener en cuenta de todos modos, que harán falta una
serie de archivos complementarios además del archivo EXE para que podamos distribuir nuestro
programa. Afortunadamente Visual Basic incluye una utilidad para crear una instalación de nuestro
programa.
Delphi de Inprise es una alternativa a Visual Basic. Los dos lenguajes tienen un ámbito de aplicación muy
parecido, siendo Delphi más sofisticado y por lo tanto algo más complejo de aprender.
Como su propio nombre indica Visual Basic es un lenguaje de programación VISUAL, es decir primero
se crea el diseño (el aspecto) del programa y luego se describe su comportamiento. Visual Basic, como
cualquier lenguaje para sistemas operativos gráficos, es un lenguaje que responde a una serie de eventos
predeterminados de la forma que el programador decida.
El lenguaje más potente es C/C++. Es un lenguaje de medio nivel puesto que está estructurado y se puede
utilizar como sustituto del ensamblador. Con este lenguaje se realizan, por ejemplo, los sistemas
operativos. A pesar de ser tan potente no es un lenguaje adecuado para realizar programas de gestión o
para Windows, ya que se ha de realizar un gran esfuerzo para conseguir lo mismo que con Visual Basic se
puede hacer en un abrir y cerrar de ojos.

Ventana principal de Visual Basic 6:

Visual Basic utiliza una estructura de programación orientada a eventos, el programador debe incluir el
código en los sucesos de los controles.

Un programa es una serie de instrucciones que se ejecutan una detrás de otra para
que de una serie de datos iniciales se obtenga el resultado deseado.

Para crear un programa con Visual Basic siempre hemos de pensar en lo que el usuario va a hacer y cómo
se quiere que responda el programa, así como tener muy en cuenta las otras acciones que los
procedimientos de evento pueden realizar, como desencadenar otros procedimientos de evento, cambiar
las propiedades de un objeto, llamar a otros procedimientos generales que no están asociados con ningún
evento, etc.
Mientras nuestra aplicación espera un suceso al cual deba responder, el usuario podrá ejecutar otras
aplicaciones. El código de nuestra aplicación estará siempre alerta para activarse cuando el usuario actúe
sobre nuestro programa.

• Para escribir comentarios en Visual Basic se ha de preceder el comentario con un apóstrofe (‘).
• Para seguir escribiendo una instrucción muy larga en la línea siguiente se utiliza el símbolo de
subrayado (_).
Para unir diferentes textos y variables en una sóla cadena se utiliza el símbolo ampersand (&).

Los pasos en general que se han de seguir son:
1. Se ha de crear el diseño de nuestro programa en un formulario. Básicamente consiste en añadir una
serie de controles, los cuales son una serie de componentes encapsulados que realizan una
determinado función.
2. Se ha de ajustar las propiedades de los controles. Las propiedades definen el aspecto y
comportamiento de los controles. Las propiedades más comunes son: name, caption, text, value,
backcolor,...
3. Escribir el código en respuesta a los eventos que sean necesarios. Un evento es un algo que le ocurre
a un control, como por ejemplo que se pulse una tecla o se haga clic con el ratón.

Objeto: También llamado control o componente. Elemento de Windows que cumple un
determinado cometido. Por ejemplo una ventana, un botón, un menú, etc. Los objetos pertenecen a
una clase la cual lleva asociado por su naturaleza una serie de eventos, propiedades y métodos que
se les atribuye.
Evento: Suceso o acontecimiento de un objeto. Se codidifica mendiante un procedimiento o
función dónde nosotros escribimos el código para ajustar el comportamiento del control a nuestros
designios. Ejemplos de evento son hacer un clic, pulsar una tecla, o mover el ratón sobre un
determinado control.
Propiedad: Característica que define el formato de visualización o el comportamiento de un objeto.
Algunas propiedades funcionan en tiempo de diseño y otras en tiempo de ejecución y otras son de
sólo lectura. Ejemplos de propiedades son el nombre del control, el texto que visualiza, su color de
fondo, el tipo de letra, etc. Las propiedades pueden ser modificadas o consultadas.
Método: Función o procedimiento de un objeto para que éste realice una determinada tarea.
Ejemplo de métodos en un objeto formulario son: dibujar un círculo, borrar el formulario, dibujar
una línea, asociar un menú contextual, etc.

Paleta de Propiedades en tiempo de diseño: Propiedades y métodos de un objeto:
Controles:

Lista de controles y lista de eventos:

Para examinar los elementos que disponemos para programar en Visual Basic (clases, propiedades,
métodos, eventos, constantes y procedimientos) disponemos de una herramienta muy potente denominada
examinador de objetos. Se puede utilizar tanto para buscar objetos que hayamos creado, como objetos de
otras aplicaciones.

! " # $
Archivo: Edición: Ver:

Proyecto: Formato: Depuración:

%
Los componentes o controles son las herramientas con las que construir un formulario. Visual Basic nos
muestra de forma predeterminada una serie de controles muy utilizados:
CONTROL TRADUCCIÓN PREFIJO DESCRIPCIÓN
Form Formulario frm Formulario; base los controles
PictureBox Cuadro de dibujo pic Imagen o marco para otros controles

Label Etiqueta lbl Texto fijo

TextBox Cuadro de texto txt Texto introducido por el usuario

CommandButton Botón de comando cmd Botón que ejecuta una orden

Frame Marco fra Sitio donde colocar botones de opción

OptionButton Botón de opción opt Para elegir una de varias opciones

CheckBox Casilla de verificación chk Indica opción activada o desactivada

ListBox Cuadro de lista lst Lista de elementos

ComboBox Cuadro combinado cmb Combina un cuadro de texto y una lista

HScrollBar Barra de desplaza-miento hsc Para realizar desplazamientos o variar un
horizontal. valor numérico.
VScrollBar Barra de desplaza-miento vsc Para realizar desplazamientos o variar un
vertical valor numérico.
Timer Temporizador tim Eventos a intervalos fijos de tiempo

DriveListBox Cuadro de lista de drv Lista de los discos del ordenador
unidades
DirListBox Cuadro de lista de dir Lista de carpetas de una unidad de disco
carpetas
FileListBox Cuadro de lista de fil Lista de archivos de una carpeta
archivos
Shape Forma shp Una forma: rectángulo, círculo, etc.

Line Línea lin Una línea separadora.

Image Imagen img Una imagen.

Data Datos dat Acceso a una tabla/consulta de una BD.
OLE Incrustación de objetos ole Otros objetos como por ejemplo una hoja de
vinculados cálculo.
CommonDialog Diálogos comunes dlg Diálogos comunes como Abrir o Guardar
archivos. “Microsoft Common Dialog
Control”

Además de los componentes básicos se pueden insertar más componentes. Algunos de ellos ya vienen con
el paquete de Visual Basic pero se pueden descargar nuevos componentes de Internet, o comprar
componentes a otras empresas distintas de Microsoft o incluso podemos crear nosotros mismos nuevos
componentes.

& ' ( )*
Se pueden encontrar bajo el nombre “Microsoft Windows Common Controls”
CONTROL TRADUCCIÓN PREFIJO DESCRIPCIÓN
TabStrip Pestañas tab Diferentes fichas donde mostrar controles.

ToolBar Barra de herramientas tlb Conjunto de botones situados en la parte
superior del formulario.
StatusBar Barra de estado stb Información del programa situado en la parte
inferior del programa.
ProgressBar Barra de progreso prb Indica el porcentaje de trabajo hecho.

TreeView Vista de árbol trv Vista de objetos clasificados.

ListView Vista de lista lsv Lista con iconos y detalles.

ImageList Lista de imágenes iml Imágenes para otros componentes.

Slider Deslizador sld Ajuste numérico.

+,
Permiten seleccionar objetos de otras aplicaciones para que estén disponibles en el código. Ello se hace
con una referencia a una “Biblioteca de objetos” (Object Library). Una biblioteca de objetos es un archivo
con extensión OLB que contiene información de objetos disponibles. Con el “Examinador de objetos” se
puede obtener información de dichos objetos.

* -
La forma de crear un programa en el entorno de desarrollo de
Visual Basic es a través de proyectos. Un proyecto agrupa una
serie de archivos que son necesarios para realizar un programa
(EXE).
Los archivos más comunes que se incluyen en un proyecto son:

DESCRIPCIÓN EXTENSIÓN TIPO CONTENIDO
El proyecto VBP Texto Propiedades del programa.
La posición y tamaño de los controles en
Formulario FRM Texto el formulario. Y también el código
asociado al formulario
Código fuente BAS Texto Código Basic de uso general.
Controles adicionales a los controles
Controles OCX Binario estándar. (Antes eran VBX)
Partes binarias del formulario, como las
Formulario FRX Binario imágenes.

Propiedades del proyecto:

Con las propiedades del objeto App podemos obtener el número de versión de nuestro programa, el
nombre del ejecutable, la trayectoria y otros datos interesantes.
Menú del proyecto:

$. &
Las variables son unas zonas de memoria con un nombre dónde podemos almacenar algún dato. En una
variable sólo se puede almacenar un dato a la vez; o dicho de otra forma, al almacenar un nuevo dato, el
anterior queda reemplazado y se pierde.
Las constantes son como las variables pero que contienen un valor fijo que no se puede variar a lo largo
del programa. La sintaxis es:
Constantes: [Global] Const nombreConstante = expresión
Variables: Dim nombreVariable [As tipo]
Global nombreVariable [As tipo]
Static nombreVariable [As tipo]

Los tipos de datos sencillos para las variables son:
TIPO DE DATOS CONV. SUFIJO TAMAÑO RANGO
Boolean CBool 1 bit True o False
Byte CByte 1 byte Enteros en el rango de 0 a 255.
Integer CInt % 2 bytes De -32.768 a 32.767.
Long CLng & 4 bytes Entero largo. De -2.147.483.648 a 2.147.483.647.
Single CSng ! 4 bytes Signo flotante con precisión simple:
De -3,402823E38 a -1,401298E-45 para valores negativos;
de 1,401298E-45 a 3,402823E38 para valores positivos; y 0.
Double CDbl # 8 bytes Signo flotante con precisión doble.
De -1,79769313486232E308 a -4,94065645841247E-324 para valores
negativos;
de 4,94065645841247E-324 a 1,79769313486232E308 para valores
positivos; y 0.
Currency CCur @ 8 bytes Entero a escala.
De –922.337.203.685.477,5808 a 922.337.203.685.477,5807.
Date CDate Fechas en el rango 1/1/100 a 31/12/9999
Object Referencias a objetos.
String * $ 1 byte por De 0 a aproximadamente 65.535 bytes. Es necesaria una cantidad
tamaño carácter adicional de espacio de almacenamiento.
Variant CVar Variable Cualquier valor numérico hasta el rango del tipo Double, o cualquier
cadena de caracteres o fechas o matrices.
Type El requerido Definido por el usuario.
por los El rango de cada elemento es el mismo que el de su tipo de datos
elementos
fundamental, de entre los anteriores.

Para referirnos al número Π por PI y no por su número se puede hacer una constante:
Const PI = 3.14159

"
El tipo Variant puede almacenar diferentes tipos de datos, haciendo las conversiones necesarias para
guardar el tipo de datos que convenga.
Para determinar el contenido de una variable Variant:
FUNCIÓN DEVUELVE VERDADERO SI TIENE
IsNumeric Cualquier tipo numérico
IsDate Una fecha u hora
IsObject Una referencia a un objeto
IsArray Una matriz
IsNull Contenido nulo
IsEmpty No se ha inicializado
IsError Contiene un error
o si queremos más detalle:
FUNCIÓN VARTYPE TIPO DE VALOR QUE DEVUELVE
vbBoolean Contiene un Boolean
vbByte Contiene un Byte
vbInteger Contiene un Integer
vbLong Contiene un Long
vbCurrency Contiene un Currency
vbSingle Contiene un Single
vbDouble Contiene un Double
vbDate Contiene un Date
vbString Contiene un String
vbObject Referencia a un objeto OLE
vbDateObject Referencia a un objeto no OLE
vbArray Contiene una matriz
vbNull Contenido nulo
vbEmpty No se ha iniciado
vbError Contiene un error

• El valor Null se propaga en las expresiones, es decir si algún valor es nulo, toda la expresión da nulo.
El valor Null se utiliza normalmente en Bases de Datos para indicar que no hay datos. Las variables
que no son Variant no admiten el valor Null, dando un error en caso de que se les intente asignar.
• El valor Empty es cuando a una variable Variant aún no se le ha asignado ningún valor. El valor
Empty es diferente de 0, Null o cadena vacía (“”), pero se trata como éste cuando se usa en
expresiones.

Se pueden declarar variables de tipo objeto y para asociar a la variable un objeto existente se utiliza la
instrucción Set.
Dim nombreVariable As Objeto
Set nombreVariable = expresiónObjeto

La mayoría de los tipos de datos de Visual Basic se corresponden con los tipos de datos de los campos
que contienen datos. Los pocos tipos de datos que no tienen un equivalente directo entre los tipos de
Access Basic pueden tratarse mediante otro tipo de datos de Access Basic.
TIPOS DE DATOS DE CAMPO TIPOS DE DATOS COMPATIBLE EN BASIC
Autonumérico Long
Moneda Currency
Fecha/Hora Date (Double)
Memo String
Número (Byte) Byte (Integer, String * 1)
Número (Entero) Integer
Número (Simple) Single
Número (Doble) Double
Objecto OLE Object (String)
Texto String
Sí/No Boolean (Integer)

/ &
Para almacenar valores en un programa se utilizan las variables. Las variables son nombres que han de
empezar por una letra y además el nombre sólo puede contener letras, números o el símbolo de subrayado
(_). El nombre de una variable no puede coincidir con el de una palabra reservada.
En principio Visual Basic permite la declaración implícita de variables, es decir al usarla queda
automáticamente declarada. Pero esto no es más que una fuente de errores ya que podemos pensar que
estamos usando una variable cuando en realidad es otra variable (por un error de mecanografiado). Otros
lenguajes de programación como C o Pascal sólo permiten la declaración explícita de variables, es decir,
se indican cuales son las variables que vamos a usar, así si ponemos una variable escrita incorrectamente
el compilador nos avisará del error. Visual Basic permite también la declaración explícita de variables
pero para ello tenemos que incluir en el código como primera línea: Option Explicit

0 &
El ámbito de una variable se refiere al lugar donde se puede utilizar una variable. Puede ser de tres tipos,
dependiendo de dónde fue declarada.
ÁMBITO DECLARACIÓN DESCRIPCIÓN
Local Dim, Static Variables declaradas dentro de procedimientos o funciones, sólo
disponibles allí dentro. Las variables se crean al iniciar la subrutina y
se destruyen al finalizar.
Módulo Dim Estas variables se declaran en la sección de declaraciones de un
formulario o módulo de código. Están disponibles dentro del módulo
dónde fueron declaradas, pero no se ven desde otros módulos.
Global Global Variables declaradas en la sección de declaración de un módulo de
código, y se pueden utilizar en ése o cualquier otro módulo, ya sea de
formulario o de código.

Cuando tenemos el mismo nombre de variable en ámbitos diferentes, el que tiene preferencia es el más
local.
Por ejemplo:
Dim a As Integer

Sub procediment ()
Dim a As Integer
a = 10 ‘Se refiere a la “a” local
End Sub

& &
El tiempo de vida de una variable nos indica cuánto tiempo podemos utilizar una variable hasta que
finalmente esta se destruye.
Las variables con ámbito de módulo y global se crean cuando la aplicación comienza y no se destruyen
hasta que se acaba. De esta forma, no perdemos el valor de la variable a no ser que le demos otro valor
distinto.
En cambio, las variables locales declaradas con Dim se crean cuando la función comienza y se destruyen
al acabar. Su tiempo de vida se reduce al tiempo de vida de la función.
Por ejemplo:
Sub Proc1 ()
Dim var1 As Long

Print var1
var1 = 344
End Sub

Cuando llamamos por primera vez al procedimiento Proc1, obtendremos el resultado 0 por pantalla.
Después la variable var1 toma el valor 344, pero a continuación acaba el procedimiento y la variable
queda destruida. Así cuando volvamos a llamar al procedimiento Proc1, volverá a pasar otra vez lo
mismo: visualizará un 0 por pantalla. Para que esto no pase, es decir que la variable conserve su valor, se
ha de utilizar el modificador Static al declarar la variable. Otra posible solución sería hacer que var1
fuese una variable global.
Posibles soluciones:
Variable estática: Todas son estáticas: Variable global:

Sub Proc1 () Static Sub Proc1 () Dim var1 As Long
Static var1 As Long Dim var1 As Long
Sub Proc1 ()
Print var1 Print var1 Print var1

var1 = 344 var1 = 344 var1 = 344
End Sub End Sub End Sub

,
Un tipo definido por el usuario no es más que una serie de variables agrupadas como una sola. En el
lenguaje C es el struct y en Pascal es el record.
Por ejemplo:
Type Cine
nombre As String
domicilio As String
numVentas As Integer
End Type
Para declarar una variable con el nuevo tipo de datos Cine se hace de la siguiente forma:
Dim arcadia As Cine
Para acceder a uno de los elementos de la estructura se utiliza un punto entre el nombre de la estructura y
del campo. Por ejemplo:
arcadia.nombre = “Cine Arcadia”
arcadia.domicilio = “Balmes, 28”
arcadia.numVentas = 3

o también con With:
With arcadia
.nombre = “Cine Arcadia”
.domicilio = “Balmes, 28”
.numVentas = 3
End With

12
.
El símbolo de la asignación es el igual. Lo que hace es evaluar la expresión de la derecha y el resultado
introducirlo en la variable de la izquierda. Esta es la forma que tenemos de iniciar o cambiar el valor que
guarda una variable.
variable = expresión

2 3
OPERADOR OPERACIÓN ARITMÉTICA QUE EFECTÚA EJEMPLO
+ Suma 2 + 10 12
- Resta 2 – 10 -8
* Multiplicación 2 * 10 20
/ División 2 / 10 0.2
División entera (sin decimales) 2 10 0
Mod Módulo: resto de la división 2 Mod 10 2
^ Elevación o exponenciación 2 ^ 10 1024

2
OPERADOR DEVUELVE VERDADERO SI DEVUELVE FALSO SI
= A y B son iguales A y B son distintos
<> A y B son distintos A y B son iguales
< A es menor que B A es mayor o igual que B
> A es mayor que B A es menor o igual que B
<= A es menor o igual que B A es mayor que B
>= A es mayor o igual que B A es menor que B

2
OPERADOR SIGNIFICADO DEVUELVE VERDADERO SI
And Y Los dos operandos A y B son verdadero
Or O Alguno de los operandos es verdadero
Xor O exclusivo Los operandos son distintos: uno verdadero y otro falso.
Eqv Equivale Los operandos son iguales: los dos verdadero o los dos falso.
Imp Implica Cuando el primer operando implica el segundo: si el primero
es verdadero el otro tiene que ser verdadero.
Not No Al contrario: si era verdadero es falso y viceversa.

&
A B A And B A Or B A Xor B A Eqv B A Imp B Not A Not B
True True True True False True True False False
True False False True True False False False True
False True False True True False True True False

False False False False False True True True True

45
5 3
FUNCIÓN SIGNIFICADO
Abs Devuelve el valor absoluto de un número (sin signo).
Sgn Indica el signo del número.
Sqr Indica la raíz cuadrada.
Exp Calcula el número e elevado al exponente indicado.
Log Halla el logaritmo natural del número dado.
Rnd Número aleatorio entre 0 y 1 con decimales.
Round Redondea un número con las posiciones decimales indicadas.

5 3
Sin Seno de un ángulo en radianes.
Cos Coseno de un ángulo en radianes.
Tan Tangente de un ángulo en radianes.
Atn Arcotangente: Atn(1)*4 3,14159265358979

5 ,
DDB Cálculo de la depreciación en un período de tiempo.
FV Valor futuro de unas aportaciones periódicas.
IPmt Interés pagado en un determinado período.
IRR Tasa interna de retorno.
MIRR Tasa interna de retorno modificada.
NPer Número de períodos de un pago constante.
PPmt Capital pagado en un determinado período.
PV Valor actual de un pago futuro.
Rate Tipo de interés por período.

5
La función iif viene de “Inmediate if” (“Si inmediato”). Se utiliza para asignar a una variable uno de dos
valores posibles dependiendo de una condición.
Por ejemplo:
importe = iif(descuento = True; precio * 0.95; precio) * unidades

5
FUNCIÓN SIGNIFICADO Y EJEMPLO
Left Extrae un número determinado de caracteres de la izquierda.
Left (“Basic”,2) “Ba”
Right Extrae un número determinado de caracteres de la derecha.
Right(“Basic”,2) “ic”
Mid Extrae caracteres de cualquier punto de la cadena.
Mid(“Basic”,2,3) “asi”
LTrim Elimina los espacios que hubiese al principio de la cadena.
LTrim (“ Basic”) “Basic”
RTrim Elimina los espacios que hubiese al final de la cadena.
RTrim(“Basic “) ”Basic”
Trim Elimina espacios del principio y del final.
Trim(“ Basic “) ”Basic”
LCase Convierte la cadena a minúsculas.
LCase(“Basic”) “basic”
UCase Convierte la cadena a mayúsculas.
UCase(“Basic”) “BASIC”
StrConv Convierte una cadena según una opción.
StrConv("visual basic", vbProperCase) “Visual Basic”
StrReverse Invierte la secuencia de caracteres de la cadena.
StrReverse(“Basic”) “cisaB”
Space Genera una cadena de espacios en blanco.
Space(10) “ ”
String Genera una cadena con el carácter indicado.
String(5,"*") "*****"
Len Nos devuelve la longitud de la cadena.
Len(“Basic”) 5
InStr Indica la posición de una cadena contenida en otra cadena.
InStr("Basic","asi") 2
Replace Realiza búsquedas y sustituciones en una cadena.
Replace (“Visual Basic”,“a”,“x”) “Visuxl Bxsic”

06
FUNCIÓN SIGNIFICADO EJEMPLO
Chr Obtiene el caracter correspondiente a un código ASCII. Chr(65) “A”
Asc Obtiene el código ASCII correspondiente a un carácter. Asc("A") 65

5 ,7
Para introducir una fecha directamente se escribe entre almohadillas. Por ejemplo: #4/28/1999# Y con la
hora: #7/30/1999 17:25#
FUNCIÓN SIGNIFICADO Y EJEMPLO
Date Devuelve la fecha actual de tipo Date.
Date #2/16/99#
Now Devuelve la fecha y hora actuales de tipo Date.
Now #2/16/99 11:33:23 AM#
Time Devuelve la hora actual de tipo Date
Time #11:33:23 AM#
Day Obtiene el día de una fecha
Day(#2/16/99#) 16
Month Obtiene el mes de una fecha.
Month(#2/16/99#) 2
Year Obtiene el año de una fecha.
Year(#2/16/2000#) 2000
WeekDay Devuelve el día de la semana correspondiente.
WeekDay(#2/16/99#, vbMonday) 2 (Martes)
Hour Obtiene la hora.
Hour(#11:38:07 AM#) 11
Minute Obtiene los minutos.
Minute(#11:38:07 AM#) 38
Second Obtiene los segundos.
Second(#11:38:07 AM#) 7
DateAdd Añade un intervalo de tiempo a una fecha.
DateAdd("ww", -1, #2/16/99#) #2/9/99#
DateDiff Obtiene el intervalo transcurrido entre dos fechas.
DateDiff("ww", #2/16/99#, #2/9/99#) -1
DatePart Devuelve una parte de una fecha: semana, trimestre, etc.
DatePart("yyyy", #2/16/99#) 1999
DateSerial Compone una fecha a partir de parámetros relativos
DateSerial(1999, 2, 16) #2/16/99#
TimeSerial Compone una hora a partir de parámetros relativos
TimeSerial(11, 33, 23) #11:33:23 AM#
MonthName Obtiene el nombre del un mes
MonthName (#2/16/99#) “Febrero”
WeekdayName Obtiene el nombre de un día de la semana
WeekdayName (#2/16/99#) “Martes”
Timer Número de segundos desde medianoche.
Timer 41758

Intervalos de tiempo
CADENA UNIDAD
“s” Segundos
“n” Minutos
“h” Horas
“y” Días de año
“d” Días de mes
“w” Días de la semana
“ww” Semanas
“m” Meses
“q” Trimestres
“yyyy” Años

5 ,
La función Format nos muestra un número o una fecha de la forma deseada: número de decimales,
separación de millares, año de 2 o 4 cifras, etc.
Ejemplos:
Format (5000.789, “#,##0.00 ”) “5.000,78 ”
Format (2000.95, “#,##0 Pts”) “2.001 Pts”

5 3
NOMBRE DEL FORMATO DESCRIPCIÓN
“General Number” Visualiza el número sin separador de millares.
“Currency” Visualiza el número con el separador de millares si hace falta; visualiza dos
decimales. El símbolo monetario depende de la configuración local del
sistema.
“Fixed” Visualiza al menos un dígito a la izquierda y dos dígitos a la derecha del
separador decimal.
“Standard” Visualiza el número con el separador de decimales, al menos un dígito a la
izquierda y dos dígitos a la derecha del separador decimal.
“Percent” Visualiza el número multiplicado por 100 con el signo de tanto por ciento
(%) añadido a su derecha; siempre visualiza dos dígitos a la derecha del
separador decimal
“Scientific” Utiliza la notación científica estándar, también llamado coma flotante.
“Yes/No” Visualiza “No” si el número es 0; en otro caso, visualiza “Yes”
“True/False” Visualiza “False” si el número es 0; en otro caso, visualiza “True”
“On/Off” Visualiza “Off” si el número es 0; en otro caso, visualiza “On”

)
Las matrices (arrays) son también variables pero dónde se pueden guardar muchos datos a los que se les
hace referencia mediante un índice numérico.
Para averiguar el índice mínimo y máximo permitidos en una matriz, tenemos las funciones LBound y
UBound respectivamente.

Las matrices con un solo índice son unidimensionales, también llamadas vectores. Las matrices con dos
o más índices son multidimensionales.
Hay dos tipos de matrices: los estáticos y los dinámicos. Los primeros son los que encontramos en otros
lenguajes como C y Pascal: tienen un número fijo de elementos que no podemos cambiar. Las matrices
dinámicas, por contra, pueden variar su tamaño (número de elementos) cuando queramos.

Sintaxis de matrices estáticas:
[Dim|Global|Static] nombreMatriz (tamaño [, tamaño]) As tipo
[Dim|Global|Static] nombreMatriz (Inferior To Superior) As tipo
Sintaxis de matrices dinámicas:
Dim nombreMatriz () As Tipo
ReDim nombreMatriz (tamaño [, tamaño])

8
Para referirnos a un elemento en concreto de una matriz se ha de poner el nombre de la matriz y a
continuación el índice entre paréntesis. Por ejemplo:
Dim matriz(-2 To 2) As String
ELEMENTO INDICE CONTENIDO (DE EJEMPLO)
1º matriz(-2) “Alfa”
2º matriz(-1) “Beta”
3º matriz(0) “Gamma”
4º matriz(1) “Delta”
5º matriz(2) “Epsilon”

/ 8
Una matriz se puede declarar indicando su tamaño o indicando el índice inferior y superior.
Dim matriz (0 To 9) As Integer
o bien
Dim matriz (10) As Integer
Cuando se declara por su tamaño el índice inicial es 0 y el índice mayor es igual al número de elementos
menos uno. De todas formas se puede variar el índice inicial con la orden:
Option Base indiceInicial
Para recorrer todos los elementos de una matriz unidimensional se utiliza un sólo bucle For. Por
ejemplo:
Dim i As Integer
For i = LBound(matriz) To UBound(matriz)
Print matriz(i)
Next
o bien
Dim i As Integer
For i = 0 To 9
Print matriz(i)
Next

Para declarar una matriz de dos dimensiones se han de indicar dos índices. Por ejemplo:
Dim matriz10x25 (0 to 9, 0 to 24) As Double
o bien
Dim matriz10x25 (10, 25) As Double
Para recorrer una matriz de varias dimensiones se utilizan una serie de For encadenados, uno por cada
dimensión. Por ejemplo:
Dim i As Integer, j As Integer
For j=0 to 24
For i=0 to 9
Print matriz (i, j)
Next
Next

Para declarar una matriz dinámica haremos:
Dim vector () As Byte
Y cuando necesitemos un número determinado de elementos, la redimensionaremos así:
ReDim vector (20)
El comando ReDim es una orden de ejecución y no de declaración, y como tal puede ser utilizado cuando
haga falta.
ReDim admite la misma sintaxis que se utiliza para las matrices estáticas normales. Hay una restricción:
podemos cambiar el número de elementos de la matriz, pero no el número de dimensiones.
Cuando se utiliza la orden ReDim reinicia o vacía todos los elementos que pudiésemos tener antes en la
matriz. Para que esto no ocurra se utiliza la palabra reservada Preserve:
ReDim Preserve vector (30)
En este ejemplo y continuando con el ejemplo anterior, los primeros 20 elementos quedan inalterados y
tenemos 10 nuevos elementos al final de la matriz.

8
Una matriz de controles se compone de controles del mismo tipo que tienen todos el mismo nombre y que
tienen un índice (propiedad Index) que los identifican. Al compartir también los mismos eventos éstos
incorporan un argumento que indica el índice del elemento que invocó el evento.

Private Sub txtMatriz_Change(Index As Integer)
End Sub

Para crear una matriz de controles se siguen los siguientes pasos:
1. Crear el primer control y darle un nombre, que
será el nombre de la matriz.
2. Dar la orden de copiar y pegar (Ctrl+C, Ctrl+V)
3. Visual Basic nos preguntará si deseamos crear
una matriz de controles, le respondemos que sí.
4. Pegamos tantas veces como controles se necesiten

El primer control tendrá índice 0, el segundo 1, etc. El
índice se puede cambiar con la propiedad Index. Si se
borra dicha propiedad estamos haciendo que ese elemento
deje de pertenecer a una matriz, para lo cual antes se le
debería cambiar de nombre (para que no coincida con el
nombre de la matriz).

9 ,
El control de flujo nos permite decidir en que orden se ejecutarán las instrucciones de nuestro programa:
si hay instrucciones que se deben ejecutar sólo en una algunas ocasiones o otras instrucciones que se
deben repetir una serie de veces.
La siguiente tabla muestra el nombre de las sentencias para control de flujo, una descripción y la sintaxis.
Lo que está entre corchete son elementos opcionales.
Call Transfiere el control del programa a un procedimiento Sub de Access Basic o a un
procedimiento de biblioteca de vínculos dinámicos (DLL).
Call nombre [(listaArgumentos)]

Do ... Repite un bloque de instrucciones siempre que una condición sea verdadera o hasta que
la condición se vuelva verdadera
Loop
Do [{While | Until} Do
condición] [bloqueInstrucción]
[bloqueInstrucción] [Exit Do]
[Exit Do] [bloqueInstrucción]
[bloqueInstrucción] Loop [{While | Until} condición]
Loop

If ... Then Permite la ejecución condicional, basándose en la evaluación de una expresión.
If condición Then entonces [Else sino]
If condición1 Then
[bloqueInstrucción-1]
[ElseIf condición2 Then
[bloqueInstrucción-2] ]
. . .
[Else
[bloqueInstrucción-n] ]
End If

For ... Next Repite un grupo de instrucciones el número de veces especificado.
For contador = inicio To fin [ Step incremento ]
[bloqueInstrucción]
[Exit For]
Next [contador [, contador]]

GoSub ... Bifurcan hacia una subrutina dentro de un procedimiento y vuelven desde dicha
subrutina. Se uso está obsoleto y no es recomendable.
Return GoSub {etiquetaDeLínea| númeroDeLínea}
etiquetaDeLínea: o númeroDeLínea
. . .
Return

Goto Se bifurca incondicionalmente a una línea especificada dentro de un procedimiento. Se
uso está obsoleto y no es recomendable excepto para el control de errores.
GoTo {etiquetaDeLínea | númeroDeLínea}

Select Case Ejecuta uno de varios bloques de instrucciones dependiendo del valor de una
expresión.

Select Case expresiónPrueba
[Case listaExpresiones1
[Case listaExpresiones2
. . .
[Case Else
[bloqueInstrucción-n] ]
End Select

While ... Ejecuta una serie de instrucciones en un bucle, siempre y cuando una condición
determinada sea verdadera. Se uso está obsoleto y no es recomendable.
Wend While condición
Wend

2 " #
Type ... Define una nueva estructura de datos creada por el usuario.

End Type Type nombre
[Declaración de variables]
End Type

With ... Se utiliza para hacer más cómoda la utilización de propiedades y métodos de un objeto.
Dentro de la estructura para utilizar una propiedad o método del objeto no es necesario
End With preceder del nombre del objeto sino tan sólo del punto.
With objeto
End With

Ejemplos:
TYPE WITH
Type EmployeeRecord With MyObject
ID As Integer .Height = 100
Name As String * 20 .Caption = "Hello World"
Address As String * 30 With .Font
Phone As Long .Color = vbRed
HireDate As Date .Bold = True
End Type End With
End With

2
Los organigramas se utilizan para representar gráficamente la secuencia de ejecución de las instrucciones
de un programa. Una instrucción normal se representa por una rectángulo y una pregunta o condición se
representa por un rombo. Si una de las líneas que salen del rombo da marcha atrás nos encontramos ante
un bucle, es decir, una serie de instrucciones que se repiten un determinado número de veces. Como por
ejemplo el DO LOOP o el FOR. Si en cambio siempre van hacia delante se trata de un IF o de un
SELECT CASE.
Ejemplo de programa que calcula la factorial de un número:

INICIO

LEER N SÍ FACT=FACT*N
FACT=1 N >1? N=N-1

NO

ESCRIBIR FACT
FIN

Ejemplo de ejecución del programa cuando se quiere calcular la factorial de 3:
INSTRUCCIÓN VARIABLES
ORDEN CÓDIGO N FACT El programa codificado en Visual Basic sería:
Sub CalcularFactorial()
1 LEER N Dim n As Double
2 FACT=1 3 Dim fact As Double
3 N>1? (si) 3 1
n = InputBox("Introduce un número")
4 FACT=FACT*N 3 1 fact = 1
5 N=N-1 3 3 Do While n > 1
6 N>1? (si) 2 3 fact = fact * n
n = n - 1
7 FACT=FACT*N 2 3 Loop
8 N=N-1 2 6 MsgBox "El factorial es " & fact
End Sub
9 N>1? (no) 1 6
10 ESCRIBIR FACT 1 6

6
Averiguar si un número es positivo o negativo:

INICIO

LEER N

SÍ NO
N<0?

ESCRIBIR: Es negativo ESCRIBIR: Es positivo

FIN

El programa codificado en Visual Basic sería:
Sub EsNegativo()
Dim n As Double

n = InputBox("Introduce un número")
If n < 0 Then
MsgBox “Es negativo”
Else
MsgBox “Es positivo”
End If
End Sub

5 -
Las funciones y procedimientos se utilizan para encapsular un código que ha de realizar una determinada
tarea. Una función es como un procedimiento pero que además nos retorna un valor de vuelta o retorno.
La sintaxis es:
[Static] [Private] Function nombreDeFunción [(lista de argumentos)] [As tipo]

[bloque de instrucciones]

[nombreDeFunción = expresión]

[Exit Function]


[nombreDeFunción = expresión]

End Function

[Static] [Private] Sub nombreDeSub [(lista de argumentos)]


[Exit Sub]

End Sub

La sintaxis de cada argumento es la siguiente:
[ByVal nombreVariable [()] [As tipo]

Las partes habituales de las que consta una función o procedimiento son:
1. Una cabecera de comentarios que describa el propósito de la
rutina, los argumentos que acepta y los posibles valores que
devuelve.
2. Declaraciones de constantes locales (Const)
3. Declaraciones de variables (Dim)
4. Código de iniciación de las variables
5. Código restante
6. Código para la gestión de errores

.
Los procedimientos no retornan ningún valor. Hay dos formas de utilizar (o llamar) a un procedimiento:
• Método 1:
NombreDelProdimiento par1, par2, ... parN
• Método 2:
Call NombreDelProcedimiento (par1, par2,..., parN)

. ,
Las funciones son igual que los procedimientos pero además retornan un valor que puede ser Boolean,
Integer, String, etc. Si no se indica el tipo de retorno se asume que es Variant. Dos formas habituales de
llamar a una función son:
• Método 1:
Dim a as integer
a = FuncionSuma(3, 5)
• Método 2:
If FuncionSuma(3, 5) = 7 then
También se puede llamar a una función con la instrucción Call, aunque así no podemos utilizar el valor
de retorno.

, -,
• Procedimientos de eventos: Son llamados automáticamente al ocurrir un determinado suceso,
aunque existe también la posibilidad de que el programador los invoque a mano.
• Eventos de un control:
Sub NombreControl_NombreEvento (parámetros)
• Eventos de un formulario:
Sub Form_NombreEvento (parámetros)
• Procedimientos y funciones generales: Son llamados exclusivamente por el programador. Hay dos
tipos:
• Locales: Sólo pueden ser utilizados desde el módulo en que están definidos y no desde otros
módulos. Son los que van precedidos de la palabra Private.
• Globales: Pueden ser llamados desde otros módulos diferentes al que fueron definidos. Van
precedidos por la palabra Public.

El paso de parámetros a procedimientos o funciones puede ser de dos formas distintas:
Por referencia. Por valor
Es el método por defecto. No se pasa el valor Tan solo se pasa el valor del parámetro, y no su
del parámetro sino tan sólo su dirección. De esta dirección. De esta forma, el valor del parámetro será el
forma dentro de una función o procedimiento se mismo después de ejecutar la función o procedimiento.
puede variar el valor del parámetro pasado. Es Estos parámetros vienen antepuestos por ByVal.
una forma de poder retornar diferentes valores.
Ejemplo: Ejemplo:
Sub Incrementar(i As Integer) Sub Incrementar(ByVal i As Integer)
i = i + 1 i = i + 1
End Sub Print i ‘Imprime 1
End Sub
Dim a As Integer
a = 0 Dim a As Integer
Incrementar a a = 0

Print a ‘Imprime 1 Incrementar a
Print a ‘Imprime 0

" - ,
Si no se indica el tipo de datos de un parámetro se asume que es Variant.
No se puede pasar un Variant como parámetro real si el parámetro formal es de otro tipo. El siguiente
código no funcionaría:
Function NumCars (s As String) As Integer
...
End Function

Dim v As Variant
v = “Hola”
Print NumCars(v)

Para solucionarlo tenemos tres opciones:
1. Convertir el Variant en una expresión poniéndolo entre paréntesis:
Print NumCars((v))
2. Convertir el Variant en una cadena con CStr:
Print NumCars(CStr(v))
3. Se declara el parámetro formal con ByVal:
Function NumCars (ByVal s As String) As Integer

Cuando ocurre un error en nuestro programa podemos controlar la acción a tomar mediante la inclusión
de un controlador de errores. Para saber de qué error se trata disponemos de la variable error y de la
variable err que nos indican el error en String y en Integer respectivamente.
Un control de errores típico en un procedimiento:
Sub nombreProc ()
On Error Goto Error_nombreProc
...
Exit_nombreProc:
[On Error Resume Next]
...
Exit Sub
Error_nombreProc:
MsgBox Error, vbCritical, “Error nº” & Err
Resume Exit_nombreProc
End Sub

Se pueden generar errores en la instrucción:
Error códigoError

INSTRUCCIÓN DESCRIPCIÓN
Resume Reanuda la ejecución del programa desde la instrucción que
originó el error.

Resume Next Reanuda la ejecución del programa desde la instrucción
inmediatamente siguiente a la que originó el error.

Resume línea Reanuda la ejecución del programa en la etiqueta especificada
por línea, donde línea es una etiqueta de línea.

Error Err Vuelve a activar el error en tiempo de ejecución más reciente. Si
se ejecuta esta instrucción dentro del código de manejo de
errores, Access Basic buscará retrospectivamente otro código de
manejo de errores por la ruta de llamadas a procedimientos.

On Error GoTo 0 Desactiva el control de errores en el procedimiento.

% /
La depuración consiste en ejecutar el programa instrucción a instrucción para ver en que orden se
ejecutan las instrucciones, cómo éstas modifican las variables y así poder encontrar fácilmente dónde se
encuentran los errores que podamos haber cometido.
La forma habitual de proceder es primero insertar un punto de ruptura en alguna instrucción (señalado por
un punto rojo). El punto de ruptura nos asegura que el programa se parará al llegar a dicha instrucción. A
partir de ahí y pulsando F8 repetidamente veremos como se ejecuta nuestro programa paso a paso.
Si mostramos la ventana de Variables Locales veremos como éstas van siendo modificadas a medida que
ejecutamos nuestro programa paso a paso.
La ventana Inmediato nos permite evaluar cualquier expresión que se nos ocurra al momento. Para ello
anteponemos un interrogante al escribir una instrucción en la ventana de Inmediato, por ejemplo: ? 5
* 3

*
Para visualizar cuadros de mensajes tenemos la orden MsgBox que se puede utilizar tanto como
procedimiento o función. Lo más atractivo de MsgBox es su gran flexibilidad de formas de presentación
dependiendo de tres conceptos que se pueden sumar:
BOTONES
Aceptar
0 vbOkOnly
Aceptar
1 vbOkCancel Cancelar

2 vbAbortRetryIgnore Repetir Ignorar
Anular
3 vbYesNoCancel Sí No Cancelar

4 vbYesNo Sí No

5 vbRetryCancel Repetir Cancelar

ICONOS

16 vbCritical 48 vbExclamation

32 vbQuestion 64 vbInformation

BOTONES POR DEFECTO
1ro
0 vbDefaultButton1
1ro
256 vbDefaultButton2 2do
512 vbDefaultButton3 2do 3ro
1ro

Primer ejemplo:
MsgBox "El cliente ya no existe", vbInformation, "Mensaje"

Segundo ejemplo:
Do Until vbCancel = MsgBox("No se tiene acceso al disco", _
vbCritical + vbRetryCancel + vbDefaultButton2)
...
Loop

Tercer ejemplo:
If vbYes = MsgBox("¿Guardar el archivo?", _
vbQuestion + vbYesNoCancel) Then
...
End If

$ !
En la barra de herramientas de Visual Basic encontraremos el botón para que nos aparezca el Editor
de menús.

Cómo se hace el menú:
• Al poner el título del menú podemos poner un ampersand (&) delante de la letra que se quiere que
aparezca subrayada.
• Todos los elementos del menú que hagamos deben tener un nombre, normalmente con el prefijo
“mnu”.
• Podemos asociar un atajo del teclado a una opción.
• Las opciones del menú pueden ser una matriz de controles poniendo el mismo nombre en todas las
opciones y variando tan sólo el índice.
• Para insertar una línea separadora se pone como título un guión y como nombre mnuBar1 (por
ejemplo).
• Para que una opción aparezca desactivada (como apagada) se le desactiva la propiedad Enabled
como apagada
(desde código sería False).

• Para que una opción aparezca marcada se le activa la propiedad Checked.

1 6:.
Visual Basic es uno de los lenguajes favoritos por los desarrolladores de bases de datos, en especial por el
hecho de que VB implemente el lenguaje SQL, uno de los más potentes y sencillos lenguajes de Bases de
Datos

/,
SQL es un lenguaje orientado a bases de datos cuyas siglas significan: “Structured Query Language”, es
decir, “Lenguaje estructurado de consultas”.

+ 6:.
1. Un mandato SQL se expresa en una cadena (String)
2. Los nombres de tablas y campos con más de una palabra se encerrarán entre corchetes.
3. Cuando un campo aparece en diferentes tablas, se ha de agregar el nombre de la tabla y un punto
delante del campo al que hagamos referencia. Por ejemplo: [Tabla1].[Campo1]
4. Al especificarse una expresión de búsqueda referida a una cadena, ésta se ha de encerrar entre
comillas simples (aunque también podrían ser dobles). Por ejemplo: “[Cliente]=’Pepe’”
5. Para especificar una expresión de búsqueda de fechas, ésta se ha de encerrar entre almohadillas. Por
ejemplo:
“[Fecha factura]=#1/31/1999#”
Las fechas se han de ajustar al formato estadounidense dónde primero va el mes, después el día y por
último el año. Por ejemplo:
“[Fecha factura] = ” & Format(miFecha,”#mm/dd/yyyy#).

6:.
• Una forma de aprender SQL o de crear sentencias SQL algo complejas es mediante Microsoft Access,
puesto que todas las consultas de Access se pueden mostrar en formato SQL.
• Un mandato SQL se puede escribir en la propiedad RecordSource de un control Data. Al cambiar
dicha propiedad se ha de ejecutar a continuación el método Refresh del control Data.

6. 5+2
Es la estructura básica para seleccionar campos de una tabla. Si se quieren seleccionar todos los campos
se utiliza el asterisco.
Sintaxis:
SELECT campo1, campo2, ... FROM tabla1, tabla2, ... [WHERE criterios [ORDER BY campo1,
campo2, ... ]]
Ejemplos:
“select Nombre, Apellidos from Clientes;”
“select * from Categorías;”
“select Clientes.Nombre, Productos.Nombre from Clientes, Productos;”

'; +
Se utiliza para seleccionar qué registros aparecerán en la consulta.
Ejemplos:
“select * from Clientes where Nombre=’Alfredo’;”
“select * from Abonados where Provincia=’MADRID’ or
Provincia=’VALENCIA’;”
“select * from Abonados where Edad >= 18 and Edad <= 45;”
“select * from Abonados where edad between 18 and 45;”
“select * from Diario where Fecha <= #7/31/97#;”
“select * from Clientes where Nombre like ’AL*’;”
“select * from Clientes where Apellidos like ’*EZ’;”
“select * from Clientes where Apellidos like ’*ZAMO*’;
“select * from Clientes where Provincia in (‘MADRID’, ‘BARCELONA’,
‘VALENCIA’, ‘SEVILLA’);”

2+/ + #<
Se utiliza para ordenar los registros de la consulta. Esta cláusula se pone al final de la sentencia SQL. La
palabra reservada ASC es para orden ascendente y DESC para descendente.
Sintaxis:
ORDER BY campo1 [ASC | DESC] [, campo2 [ASC | DESC] ... ]
Ejemplos:
“select Nombre, Apellidos, Teléfono from Clientes order by
Apellidos, Nombre;”
“select * from Pedidos order by [Fecha pedido] desc;”
“select * from Abonados order by Apellidos, Nombre, Nacimiento
desc;”

0 3 6:.
Para realizar cálculos con los campos se pueden utilizar los operadores aritméticos convencionales y las
funciones que se detallan a continuación:
SUM Suma un campo numérico o operaciones con campos numéricos.
AVG Promedio
MIN Mínimo valor de un campo numérico o de fecha
MAX Máximo valor de un campo numérico o de fecha.
COUNT Para contar número de registros.

Los campos que surgen de una fórmula no tienen nombre, así que es conveniente darles algún alias. Para
ello se utiliza la palabra reservada AS (como).
Ejemplos:
“select sum(Unidades) from Pedidos;”
“select sum(Ingresos – Gastos) from Diario;”
“select sum(Unidades) as Total, [Id Pedido] from Pedidos where
Fecha=now();”
“select avg(Unidades) from Pedidos;”

“select min(Unidades) as Minimo, max(Unidades) as Maximo from
Pedidos;”
“select count(*) as NumPedidos from Pedidos where Fecha=now();”
“select count(*) as Casados from Clientes where Casado=True;”
“select count(*) as [Número pagos] from Diario where gastos>=10000;”
“select sum(Unidades) as Total, avg(Unidades) as Media, count(*) as
Registros, max(Unidades) as Maximo from Pedidos where Fecha between
#1/1/1999# and #6/31/2000#;”

2
En una consulta podría ser útil omitir los registros que estén duplicados, para ello se utiliza el predicado
DISTINCT.
Por ejemplo: Queremos un listado de los clientes que han hecho pedidos por día, sin importar cuántos
pedidos ha solicitado el cliente durante un mismo día.
“select distinct [Id Cliente], Fecha from Pedidos;”

6 / . 5+2
Se utiliza para borrar registros de una tabla. Si no se utiliza la cláusula WHERE, se borrarían todos los
registros de la tabla.
Sintaxis:
DELETE FROM tablas WHERE criterios
Ejemplo:
“delete from Clientes where [Código cliente]=4 and Fecha=Now();”

6 = /0
Se utiliza modificar el contenido de los campos de una tabla. Si no se utiliza la cláusula WHERE, se
modificarían todos los registros de la tabla.
Sintaxis:
UPDATE tablas SET campo1=valor1 [, campo2=valor2 ... ] [WHERE ... ]
Ejemplos:
“update Artículos set Precio=Precio * 1.1;”
“update Productos set Precio1 = Precio1 * 1.15, Precio2 = Precio2 *
1.25;”
“update Asegurados set Importe=Importe/1.1 where Edad > 22 and
year(now) – year(Expedición) > 2;”

>+2= #<
Se utiliza para agrupar registros, es decir, para realizar resúmenes y totales, prescindiendo del detalle.
Ejemplos:
“select [Código cliente], count([Código cliente]) as NumPedidos,
sum(Unidades) as Cantidad from Pedidos group by [Código cliente];”
“select Fecha, count(Fecha) as NumPedidos from Pedidos group by
Fecha;”
“select Fecha, sum(Unidades) as Cantidad from Pedidos group by
Fecha;”
“select Fecha, [Código cliente], count([Código cliente]) as
NumPedidos, sum(Unidades) as Cantidad from Pedidos group by Fecha,
[Código cliente] having Fecha < #1/26/1999#;”
“select Fecha, count(Fecha) as Pedidos, sum(Unidades) as Subtotal,
min(Unidades) as Minimo, max(Unidades) as Maximo, avg(Unidades) as
Promedio from Pedidos group by Fecha;”

Para combinar datos de dos tablas utilizaremos la operación JOIN. Para ello las tablas deben tener al
menos un campo en común.
INNER JOIN Combina los datos de las dos tablas siempre que haya valores coincidentes en
los campos comunes o enlazados.
LEFT JOIN Incluye todos los registros de la primera tabla y aquellos registros de la segunda
tabla en que los campos comunes sean iguales a los de la primera tabla.
RIGHT JOIN Incluye todos los registros de la segunda tabla y aquellos registros de la primera
tabla en que los campos comunes sean iguales a los de la segunda tabla.

TABLA 1: CLIENTES TABLA 2: PEDIDOS
NOMBRE IDCLIENTE PEDIDO IDCLIENTE
Ana 1 Alfa 1
María 2 Beta 3
Pepe 3 Gamma 5

INNER JOIN LEFT JOIN RIGHT JOIN
NOMBRE PEDIDO NOMBRE PEDIDO NOMBRE PEDIDO
Ana Alfa Ana Alfa Ana Alfa
Pepe Beta María Pepe Beta
Pepe Beta Gamma

Sintaxis:
tabla1 {INNER | LEFT | RIGHT} JOIN tabla2 ON tabla1.campo = tabla2.campo
Ejemplos:
“select * from Pedidos inner join Clientes on Pedidos.IdCliente =
Clientes.IdCliente;”
“select * from Pedidos left join Clientes on Pedidos.IdCliente =
Clientes.IdCliente;”
“select Fecha, [Código producto], Unidades, Apellidos, Nombre from
Pedidos inner join Clientes on Pedidos.[Código cliente] =
Clientes.[Código cliente] where Fecha < #1/17/1999#;”
“select Fecha, Unidades, Productos.* from Pedidos inner join
Productos on Pedidos.IdProducto = Productos.IdProducto;”
“select Fecha, Unidades, Productos.* from Pedidos inner join
Productos on Pedidos.IdProducto = Productos.IdProducto order by
Fecha, Producto;”

" /
Para realizar sentencias SQL hay un programa VISDATA.EXE que podemos encontrar en el menú de
Complementos de Visual Basic:

Para empezar a trabajar podemos abrir la base de datos BIBLIO.MDB (en formato Microsoft Access 97)
que contiene las tablas: Author (autores), Publishers (editoriales), Title Author (Autores de los libros) y
Titles (Libros). Además hay la consulta All Titles dónde están enlazadas todas las tablas.
Relaciones entre las tablas de Biblio:

4 /02
DAO es una colección de objetos que se utiliza para acceder a bases de datos y es utilizada también por
Access. DAO significa Data Access Objects (Objetos para acceso a datos). Para utilizar DAO hemos de ir
al menú de nuestro proyecto y luego en Referencias agregar “Microsoft DAO 3.51 Object Library”. Los
objetos de DAO son los que utiliza el control Data.
Las bases de datos a los que tendremos acceso son:
• Access (Microsoft Jet)
• dBase y Paradox
• Otras bases de datos mediante ODBC

2 /
Base de datos por defecto y abrir una base de datos:
Dim db as Database
Set db = DBEngine.Workspaces(0).Databases(0)
Set db = OpenDatabase (“Neptuno.mdb”)
Set db = CurrentDB
...
db.Close

+
Los objetos Recordset se utilizan par manipular los datos existentes en una B.D. Hay tres tipos de objetos
Recordset:
1. Table. Una tabla que no sea adjunta.
2. Dynaset. Hoja de respuestas dinámica. Permite extraer y actualizar
datos procedentes de varias tablas.
3. Snapshot. Instantánea. No se puede actualizar.

Creación de un objeto Recordset para objetos de base de datos:
Set variable = baseDeDatos.OpenRecordset(origen[,tipo[,opciones]])

Creación de un objeto Recordset para el resto de tipos de objeto
Set variable = objeto.OpenRecordset(origen[,tipo])

Cerrar un Recordset después de utilizarlo:
variable.Close

ARGUMENTO VALORES POSIBLES

objeto Database
TableDef
QueryDef
Recordset

origen TableDef
QueryDef
Consulta o instrucción SQL

tipo dbOpenTable
dbOpenDynaset
dbOpenSnapshot

opciones Constantes intrínsecas que especifican la posibilidad de acceso multiusuario a
los datos.

Ejemplos de creación de Recordset:
Set rs = db.OpenRecordset(“Clientes”)
Set myRS = db.OpenRecordset(“select * from Clientes order by [Id Cliente]”)
Set rs = formulario.RecordsetClone
...
rs.Close

2 +
Para ordenar con índice
rs.Index = “Ciudad”

Para ordenar con un nuevo Recordset:
Set rs = db.OpenRecordset(“Pedidos”)
rs.Sort = “[País], [Cód postal] DESC”
Set rs = rs.OpenRecordset()

5 +
Limitar el número de registros que aparecerán.
rs.Filter = “[Región] = ‘Norte’ And [Estado] = ‘D’”
Set rs2 = rs.OpenRecordset()

Utilizar variables QueryDef (consultas):
Set query = db.QueryDefs(“Clientes del norte”)
Set rs = query.OpenRecordset()

# +
Recorrido de registros mediante bucles:
Set rs = db.OpenRecordset (“Empleados”, dbOpenTable)
rs.MoveFirst
Do Until rs.EOF
rs.Edit
rs!Cargo = “Ejecutivo de cuenta”
rs.Update
rs.MoveNext
Loop
rs.Close

Recorrido en orden inverso:
rs.MoveLast
Do Until rs.BOF
...
rs.MovePrevious
Loop

! +
Si da -1 no hay cuenta de registros disponible
Dim total As Long
rs.MoveLast
total = rs.RecordCount

# + +
Para buscar registros:
criterio = “Cargo = ‘Representante comercial’”
rs.FindFirst = criterio
Do Until rs.NoMatch
...
rs.FindNext criterio
Loop

Para buscar registros mediante índices (en Recordset tipo Table). Se puede utilizar para comparar los
siguientes signos: “=“, “>=“, “>“, “<=“, “<“
rs.Index = “PrimaryKey”
rs.Seek “=“, idPedido, idProducto
Do Until rs.NoMatch
...
rs.Seek “=“, idPedido, idProducto
Loop

Uso de marcadores para identificar registros (en lugar de números de registro). Los Bookmark son válidos
entre Recorset generados con Clone.
Dim record As String
...
record = rs.Bookmark
...
rs.Bookmark = record

+
Para modificar un registro existente:
rs.Edit
...
rs.Update

Para eliminar un registro existente:
rs.Delete

Para agregar un nuevo registro:
rs.AddNew
...
rs.Update

A menudo, para exigir la integridad de los datos, una serie de operaciones debe considerarse como una
sola unidad. Con una transacción tenemos la posibilidad de realizar una serie de operaciones sobre los
datos y si dichas operaciones tienen éxito, guardar los cambios y sino, anular todos los cambios.

Set ws = DBEngine.Workspaces(0)
ws.BeginTrans
...
If MsgBox (“¿Guardar cambios?”, 32+4) = 6 Then
ws.CommitTrans
Else
ws.Rollback
End If
Además de garantizar la integridad de los datos, las transacciones son importantes para mejorar el
rendimiento de las base de datos, pues aumentan la velocidad ya que indican el momento de poder volcar
la memoria caché sobre disco. Además permite aumentar la concurrencia (número de usuarios que
pueden acceder a los datos simultáneamente en aplicaciones multiusuario). Por ejemplo:
ws.BeginTrans
rs = db.OpenRecordset(“Consulta larga en ejecución”)
ws.CommitTrans

) 0
Las Bibliotecas de Vínculos Dinámicos (DLLs) son uno de los elementos fundamentales de Microsoft
Windows. Estas bibliotecas contienen procedimientos que utilizan todas las aplicaciones para llevar a
cabo sus actividades, como mostrar ventanas y gráficos, administrar la memoria etc. Estos
procedimientos también se conocen como interfaz de programación de aplicaciones (API) de Windows.

/ /..
Declare Sub nombre Lib “nombreDLL” (argumentos)
Declare Function nombre Lib “nombreDLL” (argumentos) As Tipo

Los nombre de bibliotecas más comunes son: User, GDI, Kernel, MMSystem.
Para transferir un argumento por valor se añade ByVal al principio.
Un argumento con tipo flexible de datos se ha declarar de tipo Any
Se pueden utilizar los procedimientos con un nombre diferente al original mediante. Se incluye la palabra
Alias seguida del nombre original del procedimiento, justo después del nombre de la biblioteca.
Las cadenas pasadas a un procedimiento de DLL debe tener reservado un tamaño mínimo, por ejemplo
con: cadena = String (255,0)
Una cadena transferida con ByVal es una cadena ASCIIZ (terminada en cero)
Un puntero nulo se pasa mediante ByVal 0&
Los procedimientos DLLs utilizan intensivamente los controladores (handles) como hWnd y HDC. Los
formularios y controles tienen propiedades hWnd y HDC que se pueden pasar a procedimientos DLLs.

Crea programas Visual Basic

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Crea programas Visual Basic

Similaire à Crea programas Visual Basic (20)

Plus de alexcruz28

Plus de alexcruz28 (20)

Crea programas Visual Basic