Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Unidad 1 ............................................................................................................ 12
Introducción a Visual Basic ............................................................................... 12
1.1. Nociones básicas .................................................................................... 12
1.1.1. Historia ....................................................................................................... 12
1.1.2. Concepto .................................................................................................... 14
1.1.3. Ventajas ..................................................................................................... 14
1.1.4. Requerimientos ........................................................................................... 15
1.1.5. Compilación ................................................................................................ 15
1.1.6. Modos de operación .................................................................................... 16
1.1.7. Reglas de Visual Basic ................................................................................. 16
1.2. Teoría de Objetos ................................................................................... 18
1.2.1. Clase .......................................................................................................... 18
1.2.2. Objeto ........................................................................................................ 18
1.2.3. Propiedades ................................................................................................ 19
1.2.4. Métodos...................................................................................................... 20
1.2.5. Evento ........................................................................................................ 20
1.2.6. Procedimientos de evento ............................................................................ 21
1.2.7. Encapsulación ............................................................................................. 22
1.2.8. Polimorfismo ............................................................................................... 22
Unidad 2 ............................................................................................................ 23
Trabajar con Visual Basic .................................................................................. 23
2.1. Estructura de proyecto ........................................................................... 23
2.1.1. Proyecto ..................................................................................................... 23
2.1.2. Módulos ...................................................................................................... 23
2.1.3. Procedimientos ............................................................................................ 24
2.1.4. Declaraciones .............................................................................................. 24
2.2. IDE de Visual Basic................................................................................. 25
2.2.1. Entorno de Desarrollo Integrado (IDE).......................................................... 25
2.2.2. Ventana Explorador de Proyecto ................................................................... 25
2.2.3. Ventana Diseñador de Formularios ............................................................... 26
2.2.4. Ventana de código....................................................................................... 26
2.2.5. Caja de herramientas................................................................................... 27
2.2.6. Ventana de propiedades .............................................................................. 27
2.2.7. Funciones básicas del IDE ............................................................................ 28
2.3. Crear una aplicación............................................................................... 32
2.3.1. Pasos básicos .............................................................................................. 32
2.3.2. Colocar los objetos ...................................................................................... 32
2.3.3. Establecer las propiedades ........................................................................... 33
2.3.4. Escribir el código ......................................................................................... 34
Unidad 3 ............................................................................................................ 36
Objetos de Visual Basic ..................................................................................... 36
3.1. El formulario .......................................................................................... 36
3.1.1. Formulario (Clase: Form) ............................................................................. 36
3.1.2. Propiedades de formularios .......................................................................... 37
3.1.3. Métodos de formularios ............................................................................... 38
3.1.4. Eventos de formularios ................................................................................ 38
3.2. Los controles .......................................................................................... 39
3.2.1. Etiqueta (Clase: Label) ................................................................................ 39
3.2.2. Botón de comando (Clase: CommandButton) ................................................ 40
3.2.3. Caja de texto (Clase: TextBox) ..................................................................... 41
3.2.4. Marco (Clase: Frame) .................................................................................. 43
3.2.5. Caja de imagen (Clase: PictureBox) .............................................................. 43
3.2.6. Botón de opción (Clase: OptionButton) ......................................................... 44
3.2.7. Caja de verificación (Clase: CheckBox) ......................................................... 44
3.2.8. Caja de lista (Clase: ListBox) ........................................................................ 44
3.2.9. Caja combinada (Clase: ComboBox) ............................................................. 45
3.2.10. Barra de desplazamiento (Clase: HScrollBar, VScrollBar) ................................ 46
3.2.11. Temporizador (Clase: Timer)........................................................................ 46
3.2.12. Imagen (Clase: Image) ................................................................................ 46
3.2.13. Figura (Clase: Shape) .................................................................................. 47
3.2.14. Línea (Clase: Line) ...................................................................................... 47
3.2.15. Ubicación de los controles básicos ................................................................ 47
3.2.16. Ejemplo de los controles básicos .................................................................. 48
Unidad 4 ............................................................................................................ 50
Código en Visual Basic ....................................................................................... 50
4.1. Espacios de memoria .............................................................................. 50
4.1.1. Identificadores ............................................................................................ 50
4.1.2. Tipos de datos ............................................................................................ 50
4.1.3. Declaración de espacios de memoria ............................................................ 52
4.1.4. Alcance de variables y constantes................................................................. 53
4.1.5. Declaración de variables .............................................................................. 53
4.1.6. Declaración de constantes (simbólicas) ......................................................... 54
4.1.7. Constantes intrínsecas ................................................................................. 54
4.1.8. Arreglos ...................................................................................................... 55
4.1.9. Objetos y espacios de memoria .................................................................... 56
4.2. Operadores ............................................................................................. 57
4.2.1. Aritméticos.................................................................................................. 57
4.2.2. Lógicos ....................................................................................................... 58
4.2.3. Relacionales ................................................................................................ 58
4.2.4. Operadores especiales ................................................................................. 59
4.2.5. Precedencia de los operadores ..................................................................... 59
4.3. Estructuras de control ............................................................................ 60
4.3.1. Programación estructurada .......................................................................... 60
4.3.2. Tipos de estructuras .................................................................................... 60
4.3.3. Estructura bifurcativa If-Then-ElseIf-Else ...................................................... 60
4.3.4. Estructura bifurcativa Select-Case................................................................. 61
4.3.5. Estructura repetitiva For-Next ...................................................................... 62
4.3.6. Estructura repetitiva Do-Loop ....................................................................... 63
4.4. Procedimientos....................................................................................... 64
4.4.1. Procedimientos y subrutinas ......................................................................... 64
4.4.2. Ventajas de los procedimientos .................................................................... 65
4.4.3. Clasificación de procedimientos .................................................................... 66
4.4.4. Alcance de procedimientos ........................................................................... 67
4.4.5. Trabajar con procedimientos ........................................................................ 67
4.4.6. Transferencia de parámetros........................................................................ 69
4.4.7. Ejemplo completo de la unidad .................................................................... 70
Unidad 5 ............................................................................................................ 71
Funciones intrínsecas ........................................................................................ 71
5.1. Funciones en general ............................................................................. 71
5.1.1. Expresiones ................................................................................................ 71
5.1.2. Funciones ................................................................................................... 71
5.1.3. Instrucciones .............................................................................................. 72
5.2. Funciones de cadena .............................................................................. 72
5.2.1. Tratamiento de cadenas .............................................................................. 72
5.2.2. Cambiar a mayúsculas y minúsculas ............................................................. 73
5.2.3. Determinar la longitud de una cadena .......................................................... 73
5.2.4. Buscar caracteres dentro de una cadena ....................................................... 73
5.2.5. Extraer e insertar caracteres a una cadena ................................................... 74
5.2.6. Tratamiento de espacios en blanco ............................................................... 74
5.2.7. Convertir a número y a cadena .................................................................... 75
5.2.8. Obtener cadenas de caracteres con formato ................................................. 75
5.2.9. Mapa de caracteres ..................................................................................... 77
5.3. Funciones numéricas.............................................................................. 78
5.3.1. Funciones matemáticas ................................................................................ 78
5.3.2. Funciones de ajuste decimal ........................................................................ 78
5.3.3. Función de número aleatorio ........................................................................ 79
5.4. Funciones de fecha y hora...................................................................... 79
5.4.1. Obtener la fecha y hora del sistema.............................................................. 79
5.4.2. Establecer la fecha y hora del sistema .......................................................... 79
5.4.3. Realizar cálculos con fechas y horas ............................................................. 79
5.4.4. Devolver fechas y horas ............................................................................... 82
5.4.5. Cronometrar procesos ................................................................................. 82
5.5. Funciones de Objetos ............................................................................. 82
5.5.1. Cuadro de diálogo de entrada InputBox ........................................................ 82
5.5.2. Cuadro de diálogo de mensajes MsgBox ....................................................... 83
Unidad 6 ............................................................................................................ 87
Archivos............................................................................................................. 87
6.1. Nociones básicas .................................................................................... 87
6.1.1. Unidades .................................................................................................... 87
6.1.2. Archivos ...................................................................................................... 88
6.1.3. Directorios .................................................................................................. 88
6.2. Instrucciones de archivos ...................................................................... 89
6.2.1. Instrucciones para manipular directorios ....................................................... 89
6.2.2. Instrucciones para manipular archivos .......................................................... 89
6.3. Funciones de archivos ............................................................................ 91
6.3.1. Funciones para manipular directorios ............................................................ 91
6.3.2. Funciones de archivos cerrados .................................................................... 92
6.3.3. Funciones de archivos abiertos ..................................................................... 92
6.4. Objetos de archivos................................................................................ 93
6.4.1. Caja de lista de archivos (Clase: FileListBox) ................................................. 93
6.4.2. Caja de lista de directorio (Clase: DirListBox) ................................................ 93
6.4.3. Caja de lista de unidades (Clase: DriveListBox) ............................................. 93
6.4.4. Cuadro de diálogo común (Clase: CommonDialog) ........................................ 94
6.5. Archivos secuenciales............................................................................. 97
6.5.1. Abrir archivos secuenciales .......................................................................... 97
6.5.2. Leer archivos secuenciales ........................................................................... 97
6.5.3. Escribir en archivos secuenciales .................................................................. 97
6.6. Archivos aleatorios ................................................................................. 98
6.6.1. Abrir archivos aleatorios............................................................................... 98
6.6.2. Leer registros de archivos aleatorios ............................................................. 99
6.6.3. Escribir registros en archivos directos ..........................................................100
6.6.4. Localizar una posición de registro ................................................................100
6.6.5. Tareas comunes de archivos aleatorios ........................................................100
Unidad 7 .......................................................................................................... 103
Bases de Datos ................................................................................................ 103
7.1. Introducción a Bases de Datos ............................................................. 103
7.1.1. Nociones básicas ........................................................................................103
7.1.2. Arquitectura de bases de datos ...................................................................104
7.1.3. Tecnologías de bases de datos ....................................................................104
7.1.4. Proveedores OLE DB...................................................................................105
7.1.5. Lenguajes de bases de datos ......................................................................106
7.1.6. Modos de manipulación de registros ............................................................107
7.2. Objetos de acceso a datos ADO ............................................................ 107
7.2.1. Modelo de objetos de ADO..........................................................................107
7.2.2. El objeto Connection...................................................................................108
7.2.3. El objeto Recordset ....................................................................................110
7.2.4. Procedimiento para utilizar el modelo ADO ...................................................112
7.3. Acceso a datos mediante Visual Basic y ADO ....................................... 113
7.3.1. Métodos para utilizar ADO...........................................................................113
7.3.2. Controles enlazados a datos ........................................................................114
7.3.3. El control de datos ADO ..............................................................................114
7.3.4. Creación de objetos ADO en código .............................................................118
7.3.5. El diseñador de entorno de datos ................................................................120
7.4. Lenguaje de consulta estructurado SQL ............................................... 122
7.4.1. Introducción a SQL .....................................................................................122
7.4.2. Elementos del lenguaje SQL ........................................................................123
7.4.3. Consultas de selección (SELECT) .................................................................124
7.4.4. Consultas de acción (DELETE, INSERT, UPDATE) .........................................125
7.5. Reportes de bases de datos.................................................................. 126
7.5.1. Introducción a reportes ..............................................................................126
7.5.2. Pasos para crear un reporte ........................................................................127
7.5.3. Partes del generador de reportes ................................................................131
7.5.4. Campos de un reporte ................................................................................132
Unidad 8 .......................................................................................................... 134
Tecnología OLE ................................................................................................ 134
8.1. Teoría de OLE ....................................................................................... 134
8.1.1. Estándar COM ............................................................................................134
8.1.2. Automatización ..........................................................................................134
8.1.3. Tecnología OLE y ActiveX ............................................................................135
8.1.4. Componentes ActiveX .................................................................................135
8.1.5. Componentes en proceso y fuera de proceso ...............................................136
8.2. Aplicaciones habilitadas para ActiveX .................................................. 137
8.2.1. Objetos insertables .....................................................................................137
8.2.2. Control contenedor OLE ..............................................................................137
8.2.3. Control de aplicación ActiveX.......................................................................140
8.3. Componentes de código ....................................................................... 141
8.3.1. Referencias a un objeto ..............................................................................141
8.3.2. Crear referencias a objetos .........................................................................142
8.3.3. Utilizar las propiedades y métodos de un objeto ...........................................142
8.3.4. Responder a los eventos de un objeto .........................................................143
8.3.5. Ejemplo completo usando componente de código .........................................144
8.4. Controles ActiveX ................................................................................. 145
8.4.1. Cargar controles ActiveX .............................................................................145
8.4.2. Archivos de controles ActiveX ......................................................................145
8.4.3. Control ActiveX Animation ...........................................................................146
8.4.4. Control ActiveX CoolBar ..............................................................................147
8.4.5. Control ActiveX DTPicker .............................................................................148
8.4.6. Control ActiveX ImageList ...........................................................................148
8.4.7. Control ActiveX TreeView ............................................................................149
8.4.8. Control ActiveX ListView..............................................................................151
8.4.9. Control ActiveX ToolBar ..............................................................................154
8.4.10. Control ActiveX TabStrip .............................................................................155
8.4.11. Conclusiones sobre ActiveX .........................................................................156
Unidad 9 .......................................................................................................... 157
Funciones API.................................................................................................. 157
9.1. Teoría de funciones API ....................................................................... 157
9.1.1. Funciones API ............................................................................................157
9.1.2. Las API de Windows ...................................................................................157
9.1.3. Declarar funciones API ................................................................................157
9.1.4. Utilizar funciones API ..................................................................................158
9.1.5. Visor de texto API ......................................................................................159
9.2. Técnicas para usar funciones API ........................................................ 160
9.2.1. Resolver conflictos de nombre de API ..........................................................160
9.2.2. Enviar cadenas a funciones API ...................................................................160
9.2.3. Recibir cadenas de funciones API ................................................................160
9.2.4. Utilizar procedimientos generales auxiliares ..................................................161
9.2.5. Utilizar funciones API sin parámetros ...........................................................162
Consideración final .......................................................................................... 163
Índice de figuras
Figura 1.1.- Evolución del Basic. ............................................................................... 13
Figura 2.1.- Estructura de un proyecto ...................................................................... 24
Figura 2.2.- Ventana Proyecto .................................................................................. 25
Figura 2.3.- Ventana Diseñador de formulario ........................................................... 26
Figura 2.4.- Ventana de código ................................................................................. 26
Figura 2.5.- Cuadro de herramientas ......................................................................... 27
Figura 2.6.- Ventana de propiedades. ....................................................................... 27
Figura 2.7.- Diálogo Nuevo proyecto al iniciar Visual Basic ......................................... 28
Figura 2.8.- Diálogo Nuevo proyecto estándar ........................................................... 28
Figura 2.9.- Diálogo Agregar formulario .................................................................... 29
Figura 2.10.- Menú emergente del explorador de proyecto ........................................... 29
Figura 2.11.- Diálogo Agregar módulo ........................................................................ 30
Figura 2.12.- Diálogo Propiedades del proyecto ........................................................... 31
Figura 2.13.- Diálogo Opciones de editor .................................................................... 31
Figura 2.14.- Agregar objetos a un formulario ............................................................. 33
Figura 2.15.- Modificar las propiedades de objetos ...................................................... 33
Figura 2.16.- Seleccionar objeto para procedimiento de evento .................................... 34
Figura 2.17.- Seleccionar evento para procedimiento de evento ................................... 35
Figura 2.18.- Escribir código en un procedimiento de evento ........................................ 35
Figura 3.1.- Despliegue del operador punto. .............................................................. 37
Figura 3.2.- Elementos básicos de una ventana. ........................................................ 38
Figura 3.3.- Caja de herramientas (Clases). ............................................................... 47
Figura 3.4.- Ejemplo de los controles básicos. ........................................................... 48
Figura 4.1.- Diálogo Examinador de objetos. ............................................................. 55
Figura 4.2.- Estructura If-Then-Else simple................................................................ 61
Figura 4.3.- Estructura If-Then-Else completa............................................................ 61
Figura 4.4.- Estructura Select Case ........................................................................... 62
Figura 4.5.- Estructura For-Next. .............................................................................. 63
Figura 4.6.- Estructuras Do-Loop. ............................................................................. 64
Figura 5.1.- Función supuesta Licuar......................................................................... 71
Figura 5.2.- Función en general ................................................................................ 72
Figura 5.3.- Función Seno. ....................................................................................... 72
Figura 5.4.- Posiciones de una cadena de caracteres ................................................. 73
Figura 5.5.- Cuadro de diálogo InputBox ................................................................... 83
Figura 5.6.- Cuadro de diálogo MsgBox ..................................................................... 83
Figura 5.7.- Cuadro de mensaje de Información ........................................................ 84
Figura 5.8.- Cuadro de mensaje de Crítico ................................................................. 84
Figura 5.9.- Cuadro de mensaje de Exclamación ........................................................ 84
Figura 5.10.- Cuadro de mensaje de Pregunta ............................................................. 85
Figura 5.11.- Cuadro de mensaje Si y No .................................................................... 85
Figura 5.12.- Cuadro de mensaje Aceptar y Cancelar ................................................... 85
Figura 5.13.- Cuadro de mensaje Crítico Aceptar y Cancelar ......................................... 85
Figura 6.1.- Memorias de un sistema de cómputo ...................................................... 88
Figura 6.2.- Archivo de documento de Word .............................................................. 88
Figura 6.3.- Estructura de directorios y archivos ........................................................ 89
Figura 6.4.- Objetos de archivos. .............................................................................. 94
Figura 6.5.- Diálogo Componentes (Control Diálogo Común) ...................................... 95
Figura 7.1.- Tabla “Productos” de una base de datos. ...............................................104
Figura 7.2.- Arquitectura de Bases de Datos .............................................................104
Figura 7.3.- Acceso de Visual Basic a Bases de Datos ................................................105
Figura 7.4.- Modelo de objetos ADO. .......................................................................107
Figura 7.5.- Diálogo de componentes (Control de datos ADO) ...................................115
Figura 7.6.- Ventana de la propiedad ConnectionString .............................................115
Figura 7.7.- Asistente para crear una conexión a un origen de datos ADO ..................116
Figura 7.8.- Diálogo de propiedades para establecer el origen de registros .................116
Figura 7.9.- Ventana de referencias a librerías de objetos .........................................118
Figura 7.10.- Diálogo Componentes (Diseñadores) .....................................................120
Figura 7.11.- Diseñador del objeto Entorno de datos ..................................................121
Figura 7.12.- Diálogo Crystal Report Gallery ...............................................................127
Figura 7.13.- Diálogo de selección de Tablas para reportes .........................................128
Figura 7.14.- Diálogo de selección de Campos para reportes .......................................128
Figura 7.15.- Diálogo para agrupar los registros de un reporte ....................................129
Figura 7.16.- Diálogo para filtrar los registros de un reporte........................................129
Figura 7.17.- Diálogo para seleccionar la plantilla de diseño de un reporte ...................130
Figura 7.18.- Diálogo de confirmación para crear un reporte .......................................130
Figura 7.19.- Vista de diseño de un reporte de Crystal Report .....................................131
Figura 7.20.- Vista preliminar de un reporte de Crystal Report ....................................131
Figura 7.21.- Tipos de campos de Crystal Report ........................................................132
Figura 7.22.- Editor de ecuaciones de Crystal Report ..................................................133
Figura 7.23.- Campos especiales de Crystal Report .....................................................133
Figura 8.1.- Diálogo Insertar objeto .........................................................................138
Figura 8.2.- Diálogo Pegado especial .......................................................................138
Figura 8.3.- Diálogo Componentes (Objetos insertables) ...........................................141
Figura 8.4.- Cuadro de herramientas (Objetos insertables) ........................................141
Figura 8.5.- Ventana de código con eventos de un objeto componente ......................143
Figura 8.6.- Ejemplo del control ActiveX Animation ...................................................146
Figura 8.7.- Ejemplo de control ActiveX CoolBar .......................................................147
Figura 8.8.- Ejemplo del control ActiveX DTPicker .....................................................148
Figura 8.9.- Propiedades del control ActiveX ImageList .............................................149
Figura 8.10.- Ejemplo del control ActiveX TreeView ....................................................150
Figura 8.11.- Ejemplo del control ActiveX ListView Vista Iconos grandes ......................152
Figura 8.12.- Ejemplo del control ActiveX ListView Vista Iconos pequeños....................152
Figura 8.13.- Ejemplo del control ActiveX ListView Vista Lista ......................................152
Figura 8.14.- Ejemplo del control ActiveX ListView Vista Reporte .................................153
Figura 8.15.- Ejemplo del control ActiveX ToolBar.......................................................154
Figura 8.16.- Ejemplo del control ActiveX TabStrip .....................................................155
Figura 9.1.- Visor de texto API ................................................................................159
Índice de tablas
Tabla 1.1.- Lista de prefijos de objetos de Visual Basic. ............................................ 17
Tabla 3.1.- Propiedades más importantes del formulario. .......................................... 38
Tabla 3.2.- Métodos más importantes del formulario ................................................. 38
Tabla 3.3.- Eventos más importantes del formulario. ................................................ 39
Tabla 3.4.- Algunas propiedades de la etiqueta. ....................................................... 39
Tabla 3.5.- Algunas propiedades del botón de comando............................................ 40
Tabla 3.6.- Algunas propiedades de la caja de texto. ................................................ 41
Tabla 3.7.- Propiedades más importantes de listas. .................................................. 45
Tabla 3.8.- Métodos más importantes de las cajas de lista ........................................ 45
Tabla 3.9.- Propiedades más importantes de la barra de desplazamiento. .................. 46
Tabla 4.1.- Tipos de datos provistos por Visual Basic. ............................................... 51
Tabla 4.2.- Operadores aritméticos de Visual Basic ................................................... 57
Tabla 4.3.- Resultados de operaciones lógicas. ......................................................... 58
Tabla 4.4.- Operadores relacionales de Visual Basic. ................................................. 58
Tabla 4.5.- Precedencia de operadores .................................................................... 59
Tabla 5.1.- Constantes de formato para números ..................................................... 76
Tabla 5.2.- Símbolos especiales de formato para números ........................................ 76
Tabla 5.3.- Constantes de formato para fechas y horas ............................................. 76
Tabla 5.4.- Símbolos para crear formatos de fecha y hora ......................................... 77
Tabla 5.5.- Juego de caracteres ASCII de 0 a 127 .................................................... 78
Tabla 5.6.- Funciones matemáticas .......................................................................... 78
Tabla 5.7.- Funciones de ajuste numérico ................................................................ 78
Tabla 5.8.- Valores del parámetro Intervalo de funciones de fecha y hora .................. 80
Tabla 5.9.- Funciones que devuelven parte de una fecha .......................................... 81
Tabla 5.10.- Estilos de cajas de mensajes MsgBox ...................................................... 84
Tabla 5.11.- Valores devueltos por MsgBox ................................................................ 86
Tabla 6.1.- Especificaciones del parámetro “Tipo” de la instrucción Open ................... 90
Tabla 6.2.- Propiedades del objeto Diálogo Común ................................................... 95
Tabla 6.3.- Valores de la propiedad Flags. ................................................................ 96
Tabla 6.4.- Métodos del objeto Diálogo Común......................................................... 96
Tabla 7.1.- Propiedades del objeto Connection de ADO ............................................109
Tabla 7.2.- Opciones de la propiedad CursorLocation. ..............................................109
Tabla 7.3.- Métodos del objeto Connection de ADO .................................................109
Tabla 7.4.- Propiedades del objeto Recordset de ADO..............................................110
Tabla 7.5.- Opciones de la propiedad CursorType ....................................................110
Tabla 7.6.- Opciones de la propiedad LockType .......................................................111
Tabla 7.7.- Valores que devuelve la propiedad EditMode ..........................................111
Tabla 7.8.- Métodos del objeto Recordset de ADO ...................................................112
Tabla 7.9.- Eventos del objeto Recordset de ADO ....................................................112
Tabla 7.10.- Algunos comandos de SQL ....................................................................123
Tabla 7.11.- Algunas cláusulas de SQL......................................................................124
Tabla 7.12.- Operadores de comparación SQL ...........................................................124
Tabla 7.13.- Funciones de agregado SQL ..................................................................124
Tabla 8.1.- Propiedades del control contenedor OLE ................................................139
Tabla 8.2.- Métodos del control contenedor OLE ......................................................139
Tabla 8.3.- Archivos de controles ActiveX ................................................................146
Tabla 8.4.- Constantes del argumento relationship ..................................................151
Tabla 8.5.- Estilos del objeto Button de ToolBar ......................................................155
Tabla 9.1.- Archivos contenedores de funciones API ................................................157
Visual Basic 6.0 Unidad 1.- Introducción a Visual Basic
Unidad 1
12
Visual Basic 6.0 Unidad 1.- Introducción a Visual Basic
PASCAL. Basic debía evolucionar y la IBM crea una versión modificada de Basic
llamaba BASICA, la cual fracasó. Paralelamente, la empresa Microsoft saca al
mercado la versión estructurada de Basic denominada GWBASIC para DOS.
Posteriormente otra empresa, Borland, crea su propia versión de Basic
estructurado, pero agrega mejoras de velocidad optimizando la compilación en su
producto TURBO BASIC. Microsoft compite con Borland optimizando también la
compilación y corrigiendo casi todos los defectos de las versiones anteriores, para
finalmente obtener Quick-BASIC. Las últimas versiones del sistema operativo MS-
DOS incluían una versión algo recortada de Quick-BASIC llamada QBASIC.
En 1985 aparece Windows, la Interfaz de Usuario Gráfica (GUI) de Microsoft para
su sistema operativo MS-DOS; y comienzan a aparecer conceptos tales como
multitarea, multiprocesamiento y objetos de programación. El programa Windows
permitía administrar casi la totalidad de servicios de usuario del sistema con
procesadores de texto, hojas de cálculo, programas de dibujo y diseño, antivirus y
hasta una calculadora. Era necesario crear aplicaciones que se ejecutaran
utilizando esta GUI. Es así como los diseñadores de Microsoft combinan,
convenientemente, la interfaz gráfica con su lenguaje de programación por
excelencia, QBASIC; obteniéndose una de las primeras versiones visuales de
lenguajes de programación, la cual recibió el nombre Visual Basic.
Desde que apareció Visual Basic, ya Basic no es sólo para novatos, sino que
representa una alternativa para programadores de todos los niveles, quienes
estimulados por su gran versatilidad y potencia, comienzan a utilizarlo. Para los
años de 1993 y 1994, Visual Basic comienza a hacerse muy popular con su versión
3.0 de 16 bits. La versión 4.0 estuvo lista para 1995, casi paralelo con la aparición
del primer sistema operativo de Microsoft con ambiente gráfico: Windows 95. Este
era el momento de transición de los buses de datos de los microprocesadores de
16 a 32 bits; hecho determinante para que Visual Basic 4.0 estuviera disponible
para ambos buses de datos, por lo que la instalación era opcional para 16 ó 32
bits. No tardó mucho en evolucionar un poco más con su versión 5.0
exclusivamente para 32 bits. A mediados de 1998, Visual Basic adopta su versión
6.0, la cual viene como parte de un paquete de lenguajes de programación visual
para desarrollar aplicaciones Windows llamado Visual Studio 6.0, el cual incluye:
Visual C++ 6.0, Visual FoxPro 6.0, Visual J++ 6.0, Visual InterDev 6.0 y Visual
Basic 6.0. A partir del año 2000 surge la plataforma de Microsoft para servicios
Web (o cualquier servicio basado en red) conocida como framework.NET, la cual
incluye las herramientas para el desarrollo de aplicaciones Visual Studio .NET,
entre ellas se encuentra Visual Basic .NET.
documento de Excel, como objeto, a una aplicación Visual Basic, para efectuar
las operaciones normales de una hoja de cálculo, pudiendo modificar datos de
las celdas del documento original si está vinculado, o sólo visualizar y
manipular celdas si está incrustado.
f) ADO (ActiveX Data Object)
Visual Basic provee tres modelos de objetos para acceso a datos: Objetos de
Datos ActiveX (ADO), Objetos de Datos Remotos (RDO) y Objetos de Acceso a
Datos (DAO). La tecnología más reciente es ADO, con un modelo de objetos
más sencillo (y aún más flexible) que RDO o DAO. Un modelo de objetos de
acceso a datos es una colección de objetos que permite la manipulación y
definición de bases de datos diversas sin tener que conocer las directivas
intrínsecas de cada base de datos. Con esta ventaja se puede controlar en
forma gráfica o codificada la conexión, los generadores de instrucciones y los
datos devueltos de bases de datos, que se usarán en cualquier aplicación de
Visual Basic.
g) Otras ventajas
Compilador de archivos de ayuda para añadir ayuda personalizada a las
aplicaciones, biblioteca de iconos e imágenes, asistente de empaquetado y
distribución para crear los discos de la aplicación terminada, ayuda completa
en línea, y un editor de código con menús emergentes e interpretador del
código.
1.1.4. Requerimientos
Los requerimientos de instalación que aquí se tratan se refieren a la versión de
Visual Basic 6.0. Para versiones anteriores refiérase a los manuales
correspondientes.
a) Requerimientos de software:
Sistema operativo de red: Microsoft Windows NT 3.51 o posterior.
Sistema operativo cliente: Microsoft Windows 95 o posterior.
b) Requerimientos de hardware:
Microprocesador: Pentium® 90MHz o superior.
Vídeo: Pantalla VGA de 640x480 o de resolución superior.
Memoria RAM: 24 MB para Windows 95, 32 MB para Windows NT.
Espacio en disco duro Edición Estándar: de 48MB a 80 MB.
Espacio en disco duro Edición Empresarial: de 128MB a 147 MB.
Espacio en disco duro para MSDN (Documentación multimedia): 67MB.
CD-ROM (no se supone soporte para MS-DOS).
1.1.5. Compilación
La compilación es el proceso mediante el cual cualquier lenguaje de programación
convierte su seudo lenguaje al código máquina o código binario para su
procesamiento y ejecución según el sistema operativo instalado. Se dice que el
código máquina (unos y ceros) es el lenguaje de mas bajo nivel, ya que posee las
directivas que interactúan directamente e internamente con el microprocesador.
15
Visual Basic 6.0 Unidad 1.- Introducción a Visual Basic
16
Visual Basic 6.0 Unidad 1.- Introducción a Visual Basic
17
Visual Basic 6.0 Unidad 1.- Introducción a Visual Basic
MiCarro.Velocidad = 20
Tacómetro = MiCarro.Velocidad
En los ejemplos anteriores y en adelante el signo igual “=” se lee como “se le
asigna”. Este signo se usa en BASIC para asignar el valor de la parte izquierda a la
parte derecha del signo. De esta manera, el primer ejemplo se lee “Propiedad
Velocidad de MiCarro se le asigna 20”.
Se pueden establecer casi todas las propiedades en tiempo de diseño usando una
ventana del IDE de Visual Basic conocida como Propiedades sin tener que escribir
código alguno. Otras propiedades no están disponibles en tiempo de diseño, ya
que no aparecen en la ventana de propiedades, por lo que se necesitará escribir
código para establecer u obtener esas propiedades en tiempo de ejecución.
Por otra parte, es posible que durante la ejecución del programa ciertas
propiedades no puedan ser modificadas, mientras que otras sí. En este sentido se
tienen los siguientes tipos de propiedades:
a) Propiedades de lectura y escritura
Las propiedades cuyo valor se puede establecer y obtener en tiempo de
ejecución se llaman propiedades de lectura y escritura.
b) Propiedades de sólo lectura
Las propiedades que sólo se pueden leer (obtener su valor), pero que no se
pueden cambiar (establecer) en tiempo de ejecución se conocen como
propiedades de sólo lectura. Estas propiedades sólo se pueden cambiar en
tiempo de diseño.
Por ejemplo, la propiedad Velocidad de MiCarro es de lectura y escritura, ya que
puede ser leída y establecida en tiempo de ejecución (auto andando); pero la
propiedad “NivelDeGasolina” de MiCarro es de sólo lectura, ya que no se puede
cambiar en tiempo de ejecución (auto andando), y se debe detener la aplicación
19
Visual Basic 6.0 Unidad 1.- Introducción a Visual Basic
NombreDeObjeto.Propiedad = Valor
Sugerencia: Si va a usar el valor de una propiedad más de una vez, el código se ejecutará
más rápidamente si almacena el valor en una variable.
1.2.4. Métodos
Corresponden a los diversos procedimientos que pueden operar sobre el objeto.
Los métodos son parte de los objetos del mismo modo que las propiedades.
Generalmente, los métodos son acciones que desea o está posibilitado a realizar el
objeto, mientras que las propiedades son los atributos que puede establecer o
recuperar. Se podría decir que MiCarro tiene un método "Acelerar" y podría usar la
siguiente sintaxis para cambiar la velocidad:
MiCarro.Acelerar 20
Los métodos pueden afectar a los valores de las propiedades e inclusive activar
procedimientos de evento que veremos mas adelante. En el ejemplo de MiCarro, el
método Acelerar cambia la propiedad Velocidad. Cuando utiliza un método en el
código, la sintaxis depende de los argumentos que necesite el método y de si el
método devuelve o no un valor. En general se utiliza la sintaxis siguiente:
NombreDeObjeto.Método
Si el método devuelve un valor útil, debe asignar el valor a una variable y utilizar
paréntesis con o sin argumentos como se muestra a continuación:
1.2.5. Evento
Un evento es una acción reconocida por un objeto, como cuando el usuario hace
clic con el Mouse o presiona una tecla. Los eventos no sólo son producidos por el
usuario, también pueden ser ocasionados por el sistema, por aplicaciones
externas, e inclusive por la misma aplicación. Por ejemplo, MiCarro podría tener los
eventos "CambioDeVelocidad”, “Estacionarse”, Encendido”, “GiroIzquierdo”, etc. La
sintaxis para alguno de estos eventos de MiCarro sería:
MiCarro_CambioDeVelocidad
20
Visual Basic 6.0 Unidad 1.- Introducción a Visual Basic
MiCarro_Encendido
MiCarro_Estacionarse
NombreDeObjeto_NombreDeEvento
Distintos tipos de eventos pueden ser reconocidos por un mismo objeto; por
ejemplo, el objeto Form es susceptible al evento Click, y también al evento
DblClick. El código de respuesta a los eventos, en cada caso, será como sigue:
Por otra parte, distintos tipos de objetos pueden ser susceptibles a un mismo
evento. Por ejemplo, la mayoría de los objetos reconocen el evento Click. Si el
usuario hace clic sobre el cuerpo del formulario, o sobre el área de un botón de
comando, se ejecutan códigos diferentes:
Private Sub Form_Click()
{Área de código para un clic sobre el formulario}
End Sub
21
Visual Basic 6.0 Unidad 1.- Introducción a Visual Basic
1.2.7. Encapsulación
Esta característica de la OOP es la facultad de unificar el código y los datos que la
clase u objeto contiene, así como ocultar el código que maneja dicha información.
La encapsulación nos ayuda a olvidarnos de cual es la implementación realizada en
los procedimientos y datos (métodos y propiedades) de una clase, para que sólo
nos preocupemos de cómo usarlos. La encapsulación es la característica que
permite ocultar cómo están codificados los métodos y propiedades de las clases. El
mero hecho de crear un método o una propiedad en una clase ya implica que
estamos usando la característica de la encapsulación en Visual Basic.
1.2.8. Polimorfismo
Muchas clases pueden proporcionar la misma propiedad o el mismo método y el
que llama no tiene por qué saber la clase a la que pertenece el objeto antes de
llamar a la propiedad o al método. Por ejemplo, una clase Automóvil y una clase
Avión podrían tener la misma propiedad Velocidad o el mismo método Acelerar. El
polimorfismo significa que puede establecer la Velocidad o invocar Acelerar sin
saber si el objeto es MiCarro o MiAvión. Todos los métodos implementados en las
clases deben tener una forma única de comportarse, y las propiedades de las
clases deben ser consistentes con la información que corresponde tratar. El
polimorfismo sería el contrato firmado para que esos procedimientos y datos se
utilicen de forma adecuada. Se dice que una clase es polimórfica cuando podemos
usar sus métodos y propiedades sin importarnos qué objeto los implementa. El
Polimorfismo en Visual Basic se puede usar de dos formas diferentes, según se
compruebe si el miembro de una clase (propiedad o método) pertenece al objeto
que lo utiliza, en tiempo de diseño o en tiempo de ejecución.
22
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
Unidad 2
23
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
2.1.3. Procedimientos
Cada módulo se divide en procedimientos. Los procedimientos son estructuras que
delimitan un conjunto de instrucciones. Los procedimientos pueden tener alcance
público o privado. Los procedimientos privados sólo se pueden acceder desde el
módulo en el cual están creados, mientras que los procedimientos públicos se
pueden acceder desde cualquier módulo del proyecto. También los procedimientos
existen en tres tipos: Sub, Function, y Property que se estudiarán en detalle en la
unidad 4; por lo pronto sólo es necesario conocer su estructura, la cual según el
alcance y el tipo se pueden ver de la siguiente manera:
Los procedimientos se inician con la sentencia Sub y termina con End Sub. De esta
misma manera las funciones comienzan con la sentencia Function y terminan con
End Function. En general, todas las estructuras de Visual Basic se inician con
NombreDeEstructuta y terminan con End NombreDeEstructura. No está permitido
escribir código que no sea dentro de la estructura de procedimientos.
2.1.4. Declaraciones
Independientemente del tipo de módulo, todos poseen un área especial fuera de
la estructura de los procedimientos al inicio del módulo conocida como Sección de
Declaraciones. En esta sección del módulo no se pueden escribir instrucciones,
sólo declaraciones. Las declaraciones consisten en especificar localidades de
memoria o funciones externas (API) mediante un nombre o identificador. En la
figura 2.1 se puede apreciar una aproximación gráfica de la estructura completa
de un proyecto, con dos módulos de formulario, un formulario estándar y la
estructura interna de cada módulo en declaraciones y procedimientos.
Proyecto.vbp
Formulario1.frm Formulario2.frm Módulo.bas
‘Declaraciones ‘Declaraciones ‘Declaraciones
24
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
a b c
25
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
26
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
Puntero Pictute
Label TextBox
Frame CommandButton
CheckBox OptionButton
ComboBox ListBox
HScrollBar VScrollBar
Timer DriveListBox
DirListBox FileListBox
Shape Line
Image
Data
OLE
b c
27
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
Sugerencia: Seleccione EXE estándar en cualquiera de los casos para aplicaciones sencillas.
Mediante el teclado: “CTRL+N” tiene el mismo efecto.
28
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
g) Configurar el entorno:
Para configurar el IDE se hace clic en el menú “Herramientas | Opciones” y
aparece el diálogo que se muestra en la figura 2.13, en la se pueden apreciar
las pestañas Editor, Formato del editor, General, Acople, Entorno y Avanzado.
32
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
33
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
34
Visual Basic 6.0 Unidad 2.- Trabajar con Visual Basic
35
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
Unidad 3
3.1. El formulario
3.1.1. Formulario (Clase: Form)
Un objeto formulario es una ventana o un cuadro de diálogo que forma parte de la
interfaz de usuario de una aplicación cuando esta se ejecuta. Los formularios
pertenecen a la clase “Form”, a la vez que “Form” también es un objeto. Los
formularios son objetos contenedores. Los contenedores son objetos diseñados
para albergar o agrupar a otros objetos, de tal manera que si se mueve o se
elimina al contenedor, también se mueven o eliminan a los objetos contenidos en
él. Para hacer referencia a un objeto contenido dentro de un formulario, se debe
especificar el nombre del formulario seguido de un punto y luego el nombre del
objeto.
NombreForm.NombreObjeto.Propiedad = Valor
NombreForm.NombreObjeto.Método [Parámetro1, Parámetro2,…]
Me.NombreObjeto.Propiedad = Valor
Me.NombreObjeto.Método [Parámetro1, Parámetro2,…]
36
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
La palabra “Me”, más que sintaxis, es una gran ayuda a la hora de escribir código,
ya que al colocar el punto justo después de “Me” se despliegan, no sólo las
propiedades y métodos del formulario, sino también los objetos que este contiene
(ver Figura 3.1), facilitándose la escritura y verificándose si existe o no el objeto.
Propiedad
Método
Objeto
Esta funcionalidad es gracias al operador punto del editor de código, y aplica para
todos los objetos del sistema, instancias de objetos y estructuras. Observe que se
presentan iconos diferentes para distinguir entre propiedades, métodos y objetos.
Regla de Visual Basic de prefijo para nombre de objeto Formulario: frm.
Propiedad Descripción
ScaleWidth Ancho interior del objeto. Según ScaleMode.
ShowInTaskBar Si muestra o no la aplicación en la barra de tareas de Windows.
StarUpPosition Posición inicial del formulario cuando se carga o se ejecuta la aplicación.
Tag Información adicional del objeto.
Top Distancia del lado superior del objeto al borde de su contenedor. Según ScaleMode.
Visible Si se muestra o no en la pantalla.
Width Ancho del objeto. Según ScaleMode.
WindowState Modo del formulario “Normal”, “Maximizado” o “Minimizado”
Tabla 3.1.- Propiedades más importantes del formulario.
Caja de control
Barra de menú
Borde Height
Fondo
Width
38
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
Veremos sólo las propiedades, métodos y eventos específicos que no hayan sido
tratados anteriormente para cada objeto.
a) Propiedades de etiquetas
Propiedad Descripción
Alignment Justificación de texto centrada, derecha o izquierda.
AutoSize Si ajusta o no su tamaño al contenido.
BackColor Color de fondo. No tiene efecto si la propiedad BackStyle = 0-Transparent
BackStyle Estilo de fondo de etiquetas (Label) y figuras (Shape).
BorderStyle Estilo del borde del objeto. Puede ser con o sin borde.
Caption Título o rótulo del objeto.
DragIcon Icono que se muestra durante la operación arrastrar y colocar del objeto.
DragMode Modo de la operación arrastrar y colocar del objeto.
ToolTipText Mensaje de la etiqueta de ratón cuando se señaliza al objeto.
WordWrap Si ajusta o no su tamaño en altura al contenido (Caption).
Tabla 3.4.- Algunas propiedades de la etiqueta.
39
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
40
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
41
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
txtMiCaja.SetFocus
Len: Es una función que devuelve el número de caracteres de una cadena de texto
42
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
La primera instrucción indica que si el caracter está entre “0” y “9”, debe salir
del procedimiento (Exit Sub), de lo contrario continúa con la siguiente
instrucción, la cual convierte en caracter nulo a la tecla presionada, lo que es
equivalente a bloquear el teclado para ese caracter. También, conociendo que
el código ASCII de la tecla ENTER es 13, se puede seleccionar la siguiente caja
de texto utilizando el método SetFocus.
Private Sub txtMiCaja_KeyPress(KeyAscii As Integer)
If (KeyAscii = 13) Then txtSelección.SetFocus
End Sub
Regla de Visual Basic de prefijo para nombre del objeto Caja de imagen: pic.
44
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
Propiedad Descripción
NewListIndex Número del elemento agregado nuevo a una caja de lista.
Selected Si está o no seleccionado un elemento de una lista.
Sorted Si ordena o no los elementos de una lista.
Style Estilo gráfico de objetos.
Tabla 3.7.- Propiedades más importantes de listas.
lstMiLista.Selected(0) = True
PictureBox TextBox CommandButton OptionButton ListBox VScrollBar DriveListBox FileListBox Line Data
Label Frame CheckBox ComboBox HScrollBar Timer DirListBox Shape Image OLE
47
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
48
Visual Basic 6.0 Unidad 3.- Objetos de Visual Basic
49
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
Unidad 4
50
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
d) Tipo de datos para fecha y hora (Date): Permite efectuar cálculos de fecha y
hora. El valor de una fecha u hora se delimita mediante los caracteres
numerales (#), y se utilizan los caracteres barra (/) o guión (-) para separar
día, mes y año, y el caracter dos puntos (:) para separar hora, minuto y
segundo.
51
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
Option Explicit
b) Constantes
Las constante generalmente se utilizan para presentar valores que aparecen
en muchas partes del código o para presentar valores numéricos difíciles de
recordar; de tal manera, que una modificación de la cadena o del número se
pueda efectuar en una sola parte del código del programa, y no sea necesario
navegar toda la aplicación efectuando la misma modificación. Por ejemplo, el
mensaje de error: “Ha ocurrido un error irrecuperable, debe abortar la
operación”, es una gran cantidad de caracteres que resultaría tedioso escribir
cada vez que se requiera para mostrar al usuario que ha ocurrido un error; y
también si el programador decide escribir este texto en varias zonas del
programa y desea cambiar el mensaje de error, tendrá que efectuar el cambio
en todas las secciones del código donde se encuentre el texto. Visual Basic
provee un conjunto de constantes denominadas constantes intrínsecas. Las
constantes creadas por el usuario se conocen como constantes simbólicas.
52
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
53
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
54
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
4.1.8. Arreglos
Los arreglos permiten definir varios espacios de memoria del mismo tipo con un
solo identificador, pudiendo diferenciar cada espacio de memoria mediante
apuntadores o marcadores que se conocen como índices. Los arreglos pueden ser
de una dimensión (vectores), cuando utilizan un solo índice; o de varias
dimensiones (matrices), cuando utilizan varios índices. Mediante los índices se
puede acceder directamente a cada uno de los elementos de un arreglo. Para
declarar arreglos de una dimensión se usa:
De esta manera se han creado 5 espacios de memoria tipo Long identificados por:
Mivector (0), Mivector (1), Mivector (2), Mivector (3) y Mivector (4).
También se puede especificar un rango de índices que inicie distinto de cero:
Para declarar matrices, los rangos de cada dimensión se separan mediante comas:
55
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
Alumno = 5
Evaluación = 3
Nota(Alumno, Evaluación) = 20.5
Me.cmdBotón(0).Enabled = True
Me.cmdBotón(1).Enabled = False
Me.cmdBotón(2).Enabled = True
56
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
Dim i As Integer
For i = 0 To Me.cmdBotón.Count - 1
Me.lstObjetos.AddItem Me.cmdBotón(i).Caption
Next i
4.2. Operadores
4.2.1. Aritméticos
Los operadores aritméticos permiten efectuar los cálculos matemáticos mostrados
a continuación (ver Tabla 4.2).
Operación Operador
Suma o adición +
Resta o sustracción, e Inversión de signo -
Multiplicación o producto *
División o fraccionamiento /
División entera \
Módulo o resto Mod
Elevación a potencia ^
Tabla 4.2.- Operadores aritméticos de Visual Basic
La división entera (\) devuelve el valor de la parte entera del resultado de una
división. Por ejemplo, 5\2 es igual a 2, ya que 5/2 es igual a 2,5. Por otra parte, el
operador Mod permite obtener el resto o residuo de una división. Para el caso 5
Mod 2, el resultado es igual a 1, ya que 2x2 es igual a 4 y falta 1 para 5.
57
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
4.2.2. Lógicos
Los operadores lógicos permiten obtener resultados lógicos (True o False)
mediante una comparación bit a bit de dos expresiones. En Visual Basic, False
representa al número 0, y True a cualquier otro valor distinto de 0 (cero). La tabla
4.3 muestra los operadores lógicos de Visual Basic y sus resultados según las
expresiones A y B.
A And A Xor A Eqv A Imp
A B A Or B Not(A) Not(B)
B B B B
True True True True False False False True True
False True False True True False True False True
True False False True False True True False False
False False False False True True False True True
Tabla 4.3.- Resultados de operaciones lógicas.
4.2.3. Relacionales
Los operadores relacionales se utilizan para comparar dos condiciones lógicas de
una expresión. Por lo general se utilizan en las estructuras de control que veremos
más adelante. A continuación (ver Tabla 4.4) se muestra los operadores
relacionales.
Operación Operador
Es igual a =
Es distinto de <>
Es menor que <
Es mayor que >
Es menor o igual que <=
Es mayor o igual que >=
Es como (el patrón de cadena) Like
Tabla 4.4.- Operadores relacionales de Visual Basic.
El operador Like compara una cadena de caracteres con un patrón, el cual incluye
los siguientes caracteres comodines:
58
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
b) Operador de concatenación (&): Para unir dos cadena de texto en una sola, se
acostumbra a utilizar el operador &, aunque también se puede usar el operador
+. En el ejemplo siguiente, el título de un formulario es el resultado de una
concatenación. Si en la caja de texto se escribe el caracter “5”, el título del
formulario será “Ventana 5”. Observe que si no se dejara el espacio antes de
la comilla de cierre, el título resultante sería: “Ventana5”
Me.Caption = “Ventana ” & Me.txtNumero.Text
c) Operador punto (.): Este operador se usa para relacionar un objeto con su
propiedad, método u objeto dependiente. También aplica para hacer
referencia a variables de tipo de datos definidos por el usuario. Cada vez que
se escribe un punto después de la variable de objeto, se despliegan todos sus
miembros, permitiendo al usuario buscar y seleccionar el miembro requerido.
4.2.5. Precedencia de los operadores
La precedencia de los operadores se refiere al orden en que las operaciones
matemáticas se efectúan. En la tabla siguiente (ver Tabla 4.5) se muestra el orden
de precedencia de los operadores aritméticos, lógicos y relacionales.
Orden Aritméticos Lógicos Relacionales
1 Potencia (^) Igual a (=) Negación (Not)
2 Inversión de signo (-) Distinto de (<>) Conjunción (And)
3 Multiplicación (*) y división (/) Menor que (<) Disyunción (Or)
4 División entera (\) Mayor que (>) Exclusión (Xor)
5 Módulo (Mod) Menor o igual a (<=) Equivalencia (Eqv)
6 Suma (+) y Resta(–) Mayor o igual a (=>) Implicación (Imp)
Tabla 4.5.- Precedencia de operadores
59
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
60
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
If
False True
Expresión
Else Then
End If
If
False True
Expresión 1
ElseIf Then
False True
Expresión 2
Then
ElseIf
False True
Expresión N
Else Then
End If
Observación: En cada bloque de instrucciones tipo Then o Else se pueden anidar estructuras If
– Then – Else.
Select Case A
61
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
Case 0
'Instrucciones si A es 0
Case 3
'Instrucciones si A es 3
Case 4, 7
'Instrucciones si A es 4 ó 7
Case 8 To 10
'Instrucciones si A es 8, 9 ó 10
Case Is > 10
'Instrucciones si A es mayor a 10
Case Else
'Instrucciones para los otros casos
End Select
Select Case A
True
A=v1 ó A=v2
False Case v1, v2
True
A >=v3 y A<=v4
False Case v3 To v4
False True
A >vN
End Select
Cada vez que se ejecuta el ciclo For-Next, el sistema evalúa la relación entre el
valor de la variable Control y Fin. Para valores positivos de Paso se tiene variación
ascendente de Control, y siempre que Control sea menor o igual que Fin, el bucle
se repite, de lo contrario termina. Para valores negativos de Paso, la variación es
descendente y el bucle se mantiene mientras Control sea mayor que Fin. Para
interrumpir un ciclo For-Next, independientemente del valor de Control, se puede
usar la palabra Exit For. Los ciclos For-Next anidados están permitidos.
62
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
For Control
Control = Inicio
False
Control < Fin*Paso
True
Instrucciones del
Bucle
63
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
Do While Do Do Until Do
False True
¿Condición? Instrucciones ¿Condición? Instrucciones
True False
Loop While Loop Until
Instrucciones Instrucciones
True False
¿Condición? ¿Condición?
Loop Loop
False True
Salir del Do: Se puede terminar el bucle Do-Loop mediante la sentencia Exit Do.
4.4. Procedimientos
4.4.1. Procedimientos y subrutinas
Una de las características que definen a un lenguaje de programación estructurado
es que el código se encuentra agrupado en bloques de instrucciones con
sentencias de inicio y final del bloque. Estos bloques de instrucciones reciben el
nombre de procedimientos. Podríamos definir un procedimiento como una
secuencia de instrucciones para efectuar tareas específicas que se ejecutan como
una unidad que tiene nombre o identificador. La estructura básica del código de
Visual Basic es el procedimiento, de hecho todo el código ejecutable esta
contenido en procedimientos.
A diferencia de las estructuras de control, los procedimientos no se pueden anidar
dentro de otros procedimientos. Sin embargo, se pueden crear pequeñas
secciones de código enmarcados dentro de un procedimiento. Estos pequeños
bloques se conocen como Subrutinas, las cuales carecen de nombre o
identificador, y en su lugar, se accede a ellos mediante etiquetas de código. Las
etiquetas son marcadores de posición y están constituidas por un nombre seguido
de dos puntos en una línea de código libre dentro de un procedimiento. Las
subrutinas, en términos de lenguajes de programación en general, son porciones
lógicas de código que se encargan de resolver un problema específico. La
subrutina en términos de Visual Basic se aplica a la porción de código que se
ejecuta dentro de un procedimiento mediante las sentencias GoTo, GoSub y
Return. Por esta razón, no se deben confundir los “procedimientos” con las
“subrutinas” en Visual Basic. Aunque las subrutinas están disponibles, el analista
debe evitar al máximo su uso, ya que estas rompen con la definición de Lenguaje
Estructurado. En su lugar, se debe procurar la creación de procedimientos para
esas secciones de código necesarias por otros procedimientos.
La sentencia GoTo produce un salto incondicional a una etiqueta de línea, a partir
de la cual continúa el control del programa. Por su parte, la sentencia GoSub
también lleva el control del programa a una etiqueta de línea, pero mediante la
sentencia Return, el control del programa puede regresar a la línea siguiente
desde la cual se efectuó el llamado de la subrutina. A continuación se muestra un
ejemplo del uso de subrutinas. En el ejemplo la instrucción GoTo Terminar es
imprescindible, ya que las etiquetas de línea sólo son marcadores de posición y no
64
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
66
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
67
Visual Basic 6.0 Unidad 4.- Código de Visual Basic
Me.BackColor = QBColor(7)
c) Salir de procedimientos
Hemos visto en las estructuras de control repetitivas, que no es necesario
esperar a que termine el ciclo para salir de la estructura, ya que esta puede
ser interrumpida mediante la sentencia Exit seguida del nombre de la
estructura. Para salir de un ciclo For se utiliza Exit For, por ejemplo.
Los procedimientos, como estructuras, también permiten su terminación sin
necesidad de esperar alcanzar la línea de código donde se encuentra la
sentencia End Sub o End Function. Esto se logra mediante las sentencias Exit
Sub o Exit Function, según sea el caso.
70
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
Unidad 5
Funciones intrínsecas
“El entusiasmo es la madre del esfuerzo, y sin este nunca se logró nada importante”
.- Emerson
5.1.2. Funciones
Una función es un cálculo preprogramado que se puede realizar bajo petición
desde cualquier lugar de un programa. Puesto que una función adopta uno o más
argumentos y devuelve un único valor, esta se puede incluir en una expresión. Por
ejemplo, se puede definir la función Licuar que permite el uso de una licuadora
para múltiples aplicaciones. Para preparar una Merengada fría, se debe escribir la
siguiente expresión:
Merengada = Hielo + Licuar(Leche, Fruta, Azúcar, Vainilla)
Leche
Fruta
Licuar Merengada caliente
Azúcar
Vainilla
Figura 5.1.- Función supuesta Licuar
Observe que la función Licuar no devuelve Merengada fría y se debe agregar Hielo
en una expresión completa. La merengada obtenida dependerá del tipo e fruta, y
cantidades de leche, azúcar y vainilla. Se dice que estos últimos son las variables
independientes de la función, mientras que la merengada es la variable
dependiente. En general todas las funciones se caracterizan por una serie de
valores de entrada conocidos como argumentos o variables independientes, y sólo
un valor de salida conocido como resultado o variable dependiente.
71
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
A
B
Función Y=Función(A, B, …, C)
C
Figura 5.2.- Función en general
x Sin y
Figura 5.3.- Función Seno.
Para facilitar el estudio de las funciones, estás se han clasificado según su relación
con cadenas, números, fechas, objetos o archivos.
5.1.3. Instrucciones
Mientras que las funciones son operaciones sobre ciertos argumentos para obtener
o devolver un valor, las instrucciones consisten en órdenes para el sistema, y no
devuelven valor alguno. Las instrucciones prescinden del par de paréntesis que
caracterizan a todas las funciones. Podríamos comparar a las instrucciones con
procedimientos Sub intrínsecos del sistema. Según el ejemplo, la función Licuar
también podría utilizarse como una instrucción, en lugar que como una función, y
en este caso no existe devolución de un valor, sino que se ejecuta una orden y se
prescinde del par de paréntesis como se muestra a continuación:
Reunir ingredientes
Licuar Leche, Fruta, Azúcar, Vainilla
Agregar Hielo
72
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
V i s u a l B a s i c
1 2 3 4 5 6 7 8 9 10 11 12
Me.txtCadena.Text = UCase(Cadena)
Me.txtCadena.Text = LCase(Cadena)
Me.txtNúmero.Text = Len(Cadena)
73
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
usa Ltrim, para eliminar al final de la cadena se usa Rtrim, y para eliminar
cualquier espacio al principio y al final de la cadena, se usa simplemente Trim.
En el siguiente ejemplo se muestran estos tres casos:
txtCadena.Text = Space(7)
Format(Número|Fecha|Cadena, Formato)
75
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
b) Formatos de fecha: al igual que para valores numéricos, Visual Basic provee
constantes intrínsecas (ver Tabla 5.3) y símbolos especiales (ver Tabla 5.4)
para la presentación de valores de fecha y hora.
Constante Descripción
General Date Muestra la fecha y hora si están disponibles en la expresión.
Long Date Muestra día de la semana, día del mes, el mes y el año.
Médium Date Muestra día del mes, el mes en tres letras y el año.
Short Date Muestra día del mes, el mes y el año
Long Time Muestra la hora, minutos y segundos con indicación AM/PM
Médium Time Muestra la hora y minutos con indicación AM/PM
Short Time Sólo muestra hora y minutos
Tabla 5.3.- Constantes de formato para fechas y horas
Símbolo Descripción
: Separador de hora, minutos y segundos
/ Separador de día, mes y año.
“d” Día del mes 1-31
“dd” Día del mes 01-31
“ddd” Día de la semana Dom-Sáb
“dddd” Día de la semana Domingo-Sábado
“w” Día de la semana 1-7 (Dom = 1)
“ww” Semana del año 1-54
“m” Mes del año 1-12
“mm” Mes del año 01-12
“mmm” Mes del año Ene-Dic
“mmmm” Mes del año Enero-Diciembre
“q” Cuatrimestre del año 1-4
“y” Día del año 1-366
“yy” Año en dos dígitos 00-99
“yyyy” Año en cuatro dígitos 0100-9999
76
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
Símbolo Descripción
“h” Hora del día 0-23
“hh” Hora del día 00-23
“n” Minuto de la hora 0-59
“nn” Minuto de la hora 00-59
“s” Segundo transcurrido 0-59
“ss” Segundo transcurrido 00-59
“AM/PM” Muestra AM o PM según corresponda
“am/pm” Muestra am o pm según corresponda
Tabla 5.4.- Símbolos para crear formatos de fecha y hora
77
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
78
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
Date = #12/10/2003#
Time = #18:10:00#
79
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
Para conocer fechas pasadas, suponga que desea conocer la fecha de una
mercancía la cual tiene 10 meses en almacén:
Observe que se recurre a la función Date para obtener la fecha actual del
sistema, y así utilizarla como argumento.
b) Calcular el intervalo de tiempo entre dos fechas
Este tipo de cálculo es muy útil para determinar la duración, el retardo o la
cantidad de tiempo transcurrido entre dos fechas u horas. Para este efecto se
usa la función DateDiff:
Observación: A diferencia de la función DateAdd, que devuelve una fecha, DateDiff devuelve
un número entero.
Veamos los siguientes ejemplos, donde una vez más se ha definido la variable
D como entero para albergar el resultado de DatePart:
Dim D As Integer
D = DatePart(“yyyy”, #31/12/1999#) 'Devuelve 1999
D = DatePart(“m”, #31/12/1999#) 'Devuelve 12
D = DatePart(“w”, #31/12/1999#) 'Devuelve 6 (viernes)
D = DatePart(“ww”, #31/12/1999#) 'Devuelve 53
D = DatePart(“d”, #31/12/1999#) 'Devuelve 31
81
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
Por su parte, las funciones DateValue y TimeValue convierten una cadena con
formato de fecha y hora a un tipo de dato Date.
Fecha = DateValue(Cadena)
Hora = TimeValue(Cadena)
La función Timer también suele usarse para hacer una pausa temporal en la
secuencia del programa. Para este caso es imperante utilizar la instrucción
DoEvents, mediante la cual, durante la pausa causada en un ciclo, el programa no
acapara los recursos del sistema. Veamos esto con un ejemplo donde se crea un
retardo de 20 segundos.
Dim Inicio As Long
Inicio = Timer
Do While Timer < (Inicio + 20)
DoEvents
Loop
83
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
84
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
Por otra parte, el cuadro de mensaje como toda función devuelve valores. Los
valores devueltos por un cuadro de mensaje se detallan en la Tabla 5.11.
Constante Valor Si se hace clic en el botón
vbOK 1 Aceptar
vbCancel 2 Cancelar
vbAbort 3 Anular
vbRetry 4 Reintentar
85
Visual Basic 6.0 Unidad 5.- Funciones del intrínseca
86
Visual Basic 6.0 Unidad 6.- Archivos
Unidad 6
Archivos
87
Visual Basic 6.0 Unidad 6.- Archivos
6.1.2. Archivos
Los archivos se pueden definir como un conjunto de bytes relacionados mediante
un identificador y almacenados en una unidad de disco. El sistema operativo
define la estructura mediante la cual los archivos son etiquetados, almacenados y
organizados en el disco, para lo cual crea y mantiene en cada unidad de disco a su
disposición, una tabla de asignación de archivos conocida como FAT (File
Allocation Table), que actúa como un índice si la unidad fuera un libro. La FAT es
una tabla que contiene el estatus de varios segmentos, de espacio de disco,
usados para el almacenamiento de archivos. Cada vez que se copian, borran o
modifican archivos, la FAT es actualizada automáticamente por el sistema
operativo. En las nuevas versiones de Windows la FAT se ha reemplazado por
estructuras más eficientes como FAT32 y NTSF.
Los archivos son decodificados o interpretados por otros archivos con instrucciones
llamados programas, para lo cual se requiere transferir o copiar la información del
archivo desde la memoria secundaria hasta la memoria primaria RAM. La acción de
abrir un archivo consiste en crear una copia del archivo en memoria RAM para su
manipulación directa de parte del microprocesador. Al cerrar un archivo se libera
toda traza del mismo de la memoria RAM, pero la memoria secundaria permanece
intacta si no se guardan los cambios. Si se toma la previsión de guardar los
cambios, los cuales se efectúan en memoria RAM, la información es actualizada,
transferida o copiada a la unidad de disco correspondiente.
Visual Basic permite manipular tres tipos de archivos según el modo de acceso:
secuencial, aleatorio y binario. Los archivos secuenciales, carecen de estructura y
deben ser recorridos en su totalidad para acceder a un dato intermedio. Los
archivos aleatorios se organizan en registros de longitud fija, por lo que se puede
acceder directamente a cualquier dato intermedio. Los archivos binarios también
permiten acceso directo, pero los registros son de longitud variable. En esta
unidad sólo trataremos a los archivos de acceso secuencial y aleatorio.
La Coruña, 2003
Señores
Microsoft
101111010
010011111
101111010
101000011
100110111
101111111
100111010
CompuSoft, S.A.
Word Ciudad.-
Estimados señores
6.1.3. Directorios
Los directorios, o carpetas como también se les conocen, representan una
estructura organizativa soportada por la mayoría de los sistemas operativos que
88
Visual Basic 6.0 Unidad 6.- Archivos
Archivos Archivos
Archivos Archivos
Subdirectorio 1 Subdirectorio 2
Archivos
Directorio 1 Directorio 2
Unidad de disco Raíz
ChDrive “A:\”
89
Visual Basic 6.0 Unidad 6.- Archivos
c) Copiar archivos
Para copiar un archivo, este debe estar cerrado. La instrucción es FileCopy:
90
Visual Basic 6.0 Unidad 6.- Archivos
e) Borrar archivos
Finalmente, para eliminar o borrar un archivo existente del disco se utiliza Kill:
Kill nombre_archivo
Observación: Las instrucciones para copiar, renombrar y eliminar archivos, se deben aplicar
solamente a archivos cerrados; de lo contrario, se produce un error.
Archivo = Dir(ruta)
91
Visual Basic 6.0 Unidad 6.- Archivos
Observación: La función Dir se usa sin argumentos para repetirse con la última ruta
especificada.
b) Directorio activo
Como vimos anteriormente, la unidad y el directorio activo se establecen
mediante las instrucciones ChDrive y ChDir. Es posible visualizar el directorio
activo de una unidad con la función CurDir según la siguiente sintaxis:
Tamaño = FileLen(archivo)
Dim Tamaño As Long
Tamaño = FileLen(“C:\Windows\Win.ini”)
93
Visual Basic 6.0 Unidad 6.- Archivos
En la figura siguiente se muestran los tres controles de archivo para acceder a las
unidades de almacenamiento secundario.
DriveListBox
FileListBox
DirListBox
94
Visual Basic 6.0 Unidad 6.- Archivos
Por ejemplo, para mostrar sólo archivos de texto .txt, y de imágenes .bmp e
.ico:
La propiedad Flags se puede usar para cambiar varios elementos del cuadro
de diálogo, así como para avisar al usuario cuando pueden producirse ciertas
situaciones, tal como la escritura en un archivo existente, o la apertura de uno
95
Visual Basic 6.0 Unidad 6.- Archivos
96
Visual Basic 6.0 Unidad 6.- Archivos
97
Visual Basic 6.0 Unidad 6.- Archivos
Suponiendo que txtMiCaja (0) contiene “Carabobo”, txtMiCaja (1) contiene “0241”
y txtMiCaja (2) contiene “Valencia”; la forma como se almacenan es:
Carabobo
0241
Valencia
Como se observa, Print dispone de una línea completa por cada campo. Si usamos
la Instrucción “Write”, tanto la sintaxis como el resultado son diferentes. Los
campos se separan con comas, y no se usa punto y coma, como en el caso de
Print.
Private Sub cmdBotón_Click()
Open "A:\Estados.txt" For Append As #3
Write #3, txtDato(0).Text
Write #3, txtDato(1).Text, txtDato(2).Text
Close #3
End Sub
“Carabobo”
“0241”, “Valencia”
Para que todos los campos queden en una sola línea se debe escribir la
instrucción:
Observación: La instrucción Line Input se utiliza para leer un archivo que se ha escrito con la
instrucción Print. Por otra parte, la instrucción Input se utiliza para leer un
archivo que se ha escrito con la instrucción Write.
Observación: Por simple regla de Visual Basic, se acostumbra a comenzar el nombre del tipo
de datos con la letra T mayúscula
99
Visual Basic 6.0 Unidad 6.- Archivos
100
Visual Basic 6.0 Unidad 6.- Archivos
b) Retroceder registros
Private Sub cmdRetroceder()
If Posición > 1 Then I = 1 Else I = 0
Posición = Posición – I
If Posición = 1 Then cmdRetroceder.Enabled = False
If Registros > 1 Then cmdAvanzar.Enabled = True
Leer
End Sub
c) Buscar un registro
Private Sub Buscar(ByVal Buscado As String)
Dim I As Long
For I = 1 To Registros + 1
Get #1, I, Estado
If Trim(Estado.Nombre) Like Buscado + “*” Then Exit For
Next I
If I > Registros Then 'No se encontró
txtMicaja(0).Text = “”
txtMicaja(1).Text = “”
txtMicaja(2).Text = “”
Else 'Si se encontró
txtMicaja(0).Text = Estado.Nombre
txtMicaja(1).Text = Estado.CódigoDeArea
txtMicaja(2).Text = Estado.Capital
End If
End Sub
d) Eliminar un registro
Private Sub Buscar(ByVal Buscado As String)
Dim I As Long
Estado.Nombre = “”
Put #1, Posición, Estado
Open “Temporal.tmp” For Random As #2 Len = Len(Estado)
For I = 1 To Registros
Get #1, I, Estado
If Trim(Estado.Nombre) <> “” Then Put #2, , Estado
Next I
Close #1, #2
Kill “A:\Estados.dat”
Name “A:\Temporal.tmp” As “A:\Estados.dat”
Open “A:\Estados.dat” For Random As #1 Len = Len(Estado)
Posición = Posición – 1
cmdAvanzar
End Sub
101
Visual Basic 6.0 Unidad 6.- Archivos
102
Visual Basic 6.0 Unidad 7.- Bases de datos
Unidad 7
Bases de Datos
103
Visual Basic 6.0 Unidad 7.- Bases de datos
Interfaz
de
Usuario
Motor de
Base de
Datos
Origen de
Datos
Modelo Interfaz
Proveedor 2
Origen de Datos 2 de de
OLE DB
Objetos Usuario
Proveedor 3
Origen de Datos 3 OLE DB
106
Visual Basic 6.0 Unidad 7.- Bases de datos
Connection
Command Objeto
Properties Property
Colección
Parameters Parameter
Rercorset
Properties Property
Fields Field
Properties Property
Properties Property
Errors Error
107
Visual Basic 6.0 Unidad 7.- Bases de datos
a) Propiedades
Propiedad Descripción
ConnectionString Cadena que contiene la información que se utiliza para establecer una conexión a un
108
Visual Basic 6.0 Unidad 7.- Bases de datos
Propiedad Descripción
origen de datos.
Provider Indica el nombre del proveedor de la base de datos en una conexión.
DefaultDatabase Indica el nombre de la base de datos predeterminada en una conexión.
Indica el intervalo de espera mientras se establece una conexión antes de que se genere
ConnectionTimeout
un error.
Establece o devuelve la posición de un motor de cursores. (AdUseNone, adUseClient,
CursorLocation
adUseServer).
Indica los permisos disponibles para modificar datos en un objeto Connection. (Lectura,
Mode
escritura...).
State Indica el estado de la conexión: abierta, cerrada.
Tabla 7.1.- Propiedades del objeto Connection de ADO
El método Open sólo establece una conexión física con la base de datos, para
lo cual requiere el establecimiento de las propiedades ConnectionString,
ConnectionTimeout y CursorLocation. La propiedad ConnectionTimeout esta
109
Visual Basic 6.0 Unidad 7.- Bases de datos
a) Propiedades
Propiedad Descripción
AbsolutePosition Especifica la posición ordinal del registro actual.
ActiveConnection Indica a qué objeto Connection pertenece actualmente el objeto.
BOF Indica que la posición del registro actual está antes del primer registro.
EOF Indica que la posición del registro actual está después del último registro.
CursorLocation Establece o devuelve la posición de un motor de cursores.
CursorType Indica el tipo de cursor que se usa en el objeto.
EditMode Indica el estado de modificación del registro actual.
Filter Indica un filtro para los datos del conjunto de registros.
LockType Indica el tipo de bloqueo que se pone en los registros durante el proceso de edición.
RecordCount Indica el número actual de registros del objeto.
Indica el origen de los datos (una instrucción SQL, un nombre de tabla o un
Source
procedimiento almacenado).
State Describe el estado del objeto: abierto o cerrado.
Indica el estado del registro actual referente a las actualizaciones por lotes u otras
Status
operaciones masivas.
Tabla 7.4.- Propiedades del objeto Recordset de ADO
110
Visual Basic 6.0 Unidad 7.- Bases de datos
111
Visual Basic 6.0 Unidad 7.- Bases de datos
Método Descripción
MoveFirst Pasa al primer registro y lo convierte en el registro actual.
MoveNext Pasa al siguiente registro y lo convierte en el registro actual.
MovePrevious Pasa al anterior registro y lo convierte en el registro actual.
MoveLast Pasa al último registro y lo convierte en el registro actual.
Actualiza los datos de un objeto Recordset volviendo a ejecutar la consulta en que se
Requery
basa el objeto.
Elimina el registro actual o al grupo de registros especificados mediante la propiedad
Delete
Filter.
Tabla 7.8.- Métodos del objeto Recordset de ADO
c) Eventos
Eventos Descripción
FetchProgress, Estado de recuperación: notificación del progreso de una operación de
FetchComplete recuperación de datos, o de que la operación de recuperación ha concluido.
WillChangeField, Administración de cambio de campo: Notificación de que el valor del campo
FieldChangeComplete actual cambiará o ha cambiado.
WillMove, MoveComplete, Administración de exploración: Notificación de que la posición de fila (registro)
EndOfRecordset actual en un Recordset cambiará, ha cambiado o ha llegado al final del
Recordset.
WillChangeRecord, Administración de cambios en la fila: Notificación de que algo en la fila
RecordChangeComplete (registro) actual del Recordset cambiará o ha cambiado.
WillChangeRecordset, Administración de cambios en el Recordset: Notificación de que algo en el
RecordsetChangeComplete Recordset actual cambiará o ha cambiado.
Tabla 7.9.- Eventos del objeto Recordset de ADO
113
Visual Basic 6.0 Unidad 7.- Bases de datos
114
Visual Basic 6.0 Unidad 7.- Bases de datos
b) Crear la conexión con la base de datos: Una vez dibujado el control de datos
ADO, se utiliza su propiedad ConnectionString para crear la cadena de
conexión, la cual despliega un diálogo que facilita este procedimiento (ver
Figura 7.6).
115
Visual Basic 6.0 Unidad 7.- Bases de datos
Figura 7.7.- Asistente para crear una conexión a un origen de datos ADO
d) Enlazar controles a los datos del Recordset: Los controles enlazados se crean
estableciendo las propiedades DataSource y DataField en tiempo de diseño;
pero también se pueden establecer en tiempo de ejecución de la siguiente
116
Visual Basic 6.0 Unidad 7.- Bases de datos
manera. Suponga que el control de datos ADO tiene como nombre MiAdoDC, y
que se desea enlazar una caja de texto MiCaja al campo Apellido de una tabla
de datos (Recordset con CommandType = adCmdTable):
Set Me.MiCaja.DataSource = Me.MiAdoDC.Recordset
Me.MiCaja.DataField = "Apellido"
117
Visual Basic 6.0 Unidad 7.- Bases de datos
b) Crear las variables de objeto: Para crear eventos en una variable tipo objeto se
utiliza la sentencia WithEvents después de Dim, Public o Static.
Dim WithEvents Cnn As ADODB.Connection
Dim WithEvents Rst As ADODB.Recordset
f) Enlazar los datos del Recordset a un control: Una vez mas, basta con
establecer las propiedades DataSource y DataField del objeto que se desea
enlazar, en este caso una caja de texto llamada MiCaja en la que se quieren
mostrar los valores del campo Apellido:
Set Me.MiCaja.DataSource = Rst
Me.MiCaja.DataField = "Apellido"
Buscar un registro cuyo Apellido comience con lo que esté en una caja de
texto
Dim Buscar As String
Rst.MoveFirst
Buscar = "Apellido Like '" & Me.Text4.Text & "*'"
Rst.Find Buscar
If Rst.EOF Then
Me.Label1.Caption = "No se encontró"
Rst.MoveFirst
End If
119
Visual Basic 6.0 Unidad 7.- Bases de datos
120
Visual Basic 6.0 Unidad 7.- Bases de datos
121
Visual Basic 6.0 Unidad 7.- Bases de datos
Buscar un registro cuyo Apellido comience con lo que esté en una caja de
texto
Dim Buscar As String
MiEntornoDeDatos.rsAlumnos.MoveFirst
Buscar = "Apellido Like '" & Me.Text4.Text & "*'"
MiEntornoDeDatos.rsAlumnos.Find Buscar
If MiEntornoDeDatos.rsAlumnos.EOF Then
Me.Label1.Caption = "No se encontró"
MiEntornoDeDatos.rsAlumnos.MoveFirst
End If
122
Visual Basic 6.0 Unidad 7.- Bases de datos
b) Cláusulas SQL
Las cláusulas son condiciones de modificación utilizadas para definir los datos
que desean seleccionar o manipular, y la forma como estos se presentan.
Cláusula Descripción
FROM Especifica las tablas de las cuales se van a seleccionar los registros.
WHERE Especifica las condiciones de los registros que se van a seleccionar.
GROUP BY Separa los registros seleccionados en grupos específicos.
HAVING Especifica las condiciones que deben satisfacer cada grupo generado por GROUP BY.
ORDER BY Indica los campos para el ordenamiento de los registros.
123
Visual Basic 6.0 Unidad 7.- Bases de datos
c) Operadores SQL
Existen dos tipos de operadores en el lenguaje SQL, operadores lógicos y
operadores relacionales. Los operadores lógicos se usan para conectar
expresiones lógicas, normalmente dentro de una cláusula WHERE o HAVING.
Para SQL los operadores lógicos son: AND, OR y NOT. Por otra parte, los
operadores relacionales (ver Tabla 7.12) se usan para comparar valores
relativos de dos expresiones.
Operador Significado/Uso
< Menor que
> Mayor que
= Igual que
BETWEEN Especifica un intervalo de valores
IN Especifica registros de una base de datos
<= Menor o igual que
>= Mayor o igual que
<> Distinto de
LIKE Utilizado en la comparación de un modelo
Tabla 7.12.- Operadores de comparación SQL
La consulta SELECT más simple, seleccionando sólo los campos Nombre y Apellido
es:
SELECT [Nombre], [Apellido]
FROM Empleados;
Sintaxis SQL: Los nombres de campos se colocan entre corchetes y se separan con comas. Las
instrucciones SQL terminan con punto y coma.
124
Visual Basic 6.0 Unidad 7.- Bases de datos
SELECT *
FROM Empleados;
Sintaxis SQL: El asterisco en SQL indica todos los campos. Para el operador LIKE el comodín
asterisco se sustituye por el caracter porcentaje %.
Sintaxis SQL: Las cadenas de caracteres se especifican entre apóstrofes. Las fechas se
delimitan con el signo numeral. Los valores numéricos no utilizan delimitadores.
DELETE *
FROM Empleados
WHERE [Estatus] = 'Despedido';
125
Visual Basic 6.0 Unidad 7.- Bases de datos
FROM expresiónTabla
UPDATE Empleados
SET [Sueldo] = [Sueldo]*1.1,
[Edad] = DateDiff('yyyy', [Nacimiento], Date()),
WHERE [Antiguedad] >= 5;
126
Visual Basic 6.0 Unidad 7.- Bases de datos
127
Visual Basic 6.0 Unidad 7.- Bases de datos
128
Visual Basic 6.0 Unidad 7.- Bases de datos
129
Visual Basic 6.0 Unidad 7.- Bases de datos
130
Visual Basic 6.0 Unidad 7.- Bases de datos
131
Visual Basic 6.0 Unidad 7.- Bases de datos
b) Campos de texto:
Estos campos se corresponden al objeto etiqueta conocido de Visual Basic. Un
campo de texto es simplemente un campo que contiene texto independiente.
Puede contener un único carácter, una palabra, frases completas o párrafos.
Este es un comando usado para agregar etiquetas, títulos, notas al pie,
disculpas, explicaciones, comentarios o cualquier otra clase de texto que fuera
necesario. Para agregar un campo de texto, este se debe escoger de la clase
TextObject en la caja de herramientas, para dibujarlo luego en la sección
correspondiente.
Observación: Como el tamaño máximo de un campo de texto es 32K (incluyendo
los caracteres retorno de carro y salto de línea), se recomienda que los campos
de texto se usen sólo con bloques de texto de tamaño más manejable.
c) Campos de fórmula:
Los campos de fórmula permiten crear un objeto de datos calculados. Una
fórmula es una instrucción que establece ciertas acciones sobre determinados
datos antes de imprimirlos en el informe. Crystal Report ofrece un editor de
ecuaciones, el cual se activa automáticamente con el botón derecho del ratón
y seleccionar New. El editor de ecuaciones contiene un conjunto de funciones
132
Visual Basic 6.0 Unidad 7.- Bases de datos
d) Campos especiales:
La información adicional de un informe referida a fecha, número de página,
número de registros, etc., se puede insertar utilizando los campos especiales.
Los campos especiales son como los campos de fórmula, pero están
predefinidos en el sistema.
133
Visual Basic 6.0 Unidad 8.- Tecnología OLE
Unidad 8
Tecnología OLE
“A pocos hombres les falta capacidad; si fracasan es porque les falta dedicación”
.- Calvin Coolidge
135
Visual Basic 6.0 Unidad 8.- Tecnología OLE
136
Visual Basic 6.0 Unidad 8.- Tecnología OLE
137
Visual Basic 6.0 Unidad 8.- Tecnología OLE
138
Visual Basic 6.0 Unidad 8.- Tecnología OLE
139
Visual Basic 6.0 Unidad 8.- Tecnología OLE
140
Visual Basic 6.0 Unidad 8.- Tecnología OLE
Libro.Close
142
Visual Basic 6.0 Unidad 8.- Tecnología OLE
143
Visual Basic 6.0 Unidad 8.- Tecnología OLE
144
Visual Basic 6.0 Unidad 8.- Tecnología OLE
Nombre del
Nombre del componente Controles ActiveX
archivo
Microsoft PictureClip Control 6.0 PICCLP32.OCX PictureClip
Microsoft RichTextBox Control 6.0 RICHTX32.OCX RichTextBox
Microsoft SysInfo Control 6.0 SYSINFO.OCX SysInfo
Microsoft TabbedDialog Control 6.0 TABCTL32.OCX Microsoft Tab Control
Microsoft Windows Common Controls- Animation, UpDown, MonthView, DTPicker,
MSCOMCT2.OCX
2 6.0 FlatScrollbar
Microsoft Windows Common Controls-
COMCT332.OCX CoolBar
3 6.0
Microsoft Winsock Control 6.0 MSWINSCK.OCX WinSock
TabStrip, Toolbar, StatusBar, ProgressBar,
Microsoft Windows Common Controls
MSCOMCTL.OCX TreeView, ListView, ImageList, Slider,
6.0
ImageCombo
Tabla 8.3.- Archivos de controles ActiveX
Aunque las secuencias AVI pueden tener sonido, cuando lo tienen no pueden
usarse con el control Animation y se producirá un error si intenta cargar un archivo
de ese tipo. Sólo puede usar secuencias AVI sin sonido. Para reproducir archivos
.avi con sonido, utilice el control Multimedia (MCI).
Nota: Encontrará diversos archivos .avi sin sonido en el directorio \Graphics\ AVI del
CD-ROM de Visual Basic.
146
Visual Basic 6.0 Unidad 8.- Tecnología OLE
147
Visual Basic 6.0 Unidad 8.- Tecnología OLE
149
Visual Basic 6.0 Unidad 8.- Tecnología OLE
Sin embargo, si se ha asignado al nodo una clave única (propiedad Key), por
ejemplo "7 ID", el mismo código se podría escribir de esta forma:
MsgBox tvwMiÁrbol.Nodes(10).Parent.Text
MsgBox tvwMiÁrbol.Nodes(10).Parent.Index
Puede usar la instrucción Set con una variable de objeto de tipo Node para
manipular referencias a otros objetos Node. Por ejemplo, el código siguiente
establece una variable de objeto Node con la referencia que devuelve la
propiedad Parent. Después se utiliza la variable de objeto en lugar del objeto:
Por ejemplo, suponga que hay tres nodos y que desea colocar un cuarto nodo
entre el segundo y el tercero. El código sería el siguiente:
tvwMiÁrbol.Nodes.Add "nodo 2", tvwNext
Otros argumentos del método Add son key, text e image. Con estos
argumentos puede asignar las propiedades Key, Text e Image al crear el
nuevo objeto Node.
8.4.8. Control ActiveX ListView
El control ListView muestra datos en forma de objetos ListItem. Cada objeto
ListItem puede tener un icono opcional asociado con la etiqueta del objeto. Este
control es idóneo para representar subconjuntos de datos (como los miembros de
una base de datos) u objetos discretos (como plantillas de documentos). Puede
151
Visual Basic 6.0 Unidad 8.- Tecnología OLE
funcionar junto con un control TreeView, para dar al usuario una visión ampliada
de un nodo del control TreeView.
El control ListView puede mostrar los datos en cuatro vistas diferentes:
a) Iconos: permite arrastrar y colocar cada objeto y reorganizar los objetos.
b) Iconos pequeños: igual que iconos, pero permite que se vean más objetos
ListItem.
152
Visual Basic 6.0 Unidad 8.- Tecnología OLE
Para cambiar la vista, puede usar la propiedad View. Con la propiedad View puede
permitir al usuario cambiar dinámicamente la vista. En el código siguiente se
establece la propiedad View a vista de Informe (3), mediante la constante
intrínseca lvwReport:
ListView1.View = lvwReport
Un objeto ListItem consta de una etiqueta (la propiedad Text) y una imagen
opcional suministrada por un control ImageList. Sin embargo, el control ListView, a
diferencia de otros controles, puede usar dos controles ImageList, que se
establecen a través de las propiedades Icons y SmallIcons. En las vistas de: Lista,
Iconos pequeños e Informe, puede usar iconos pequeños suministrados por un
control ImageList, para representar cada objeto ListItem. Por el contrario, cuando
está en vista de Iconos, el control utiliza un conjunto de imágenes distinto,
suministrado por un segundo control ImageList. Para establecer las propiedades
Icons y SmallIcons en tiempo de diseño, utilice el cuadro de diálogo Páginas de
propiedades.
Nota: El control ImageList determina el tamaño de los iconos empleados. Los tamaños
disponibles son 16 x 16, 32 x 32, 48 x 48 y Personalizado.
Una vez establecida las imágenes de un ListItem con las propiedades SmallIcon e
Icon, estas aparecerán automáticamente al cambiar de vista con la propiedad
View. En la vista Reporte, existen los objetos ColumnHeader y ListSubItem. Tanto
la presencia como el número de objetos ListSubItem dependen de la presencia y el
número de objetos ColumnHeader. Es decir, no puede crear ningún objeto
ListSubItem si no hay presentes objetos ColumnHeader. Además, el número de
objetos ColumnHeader determina el número de objetos ListSubItem que puede
establecer para el objeto ListItem, que serán siempre uno menos que el número
153
Visual Basic 6.0 Unidad 8.- Tecnología OLE
Para crear una barra de herramientas, debe agregar objetos Button a una
colección Buttons. Cada objeto Button puede tener un texto y una imagen
opcionales, indicados por un control ImageList asociado. El texto se establece con
la propiedad Caption y la imagen con la propiedad Image de cada objeto Button.
En tiempo de diseño, puede agregar objetos Button al control en el cuadro de
diálogo Página de propiedades de Toolbar. Al hacer doble clic en una barra de
herramientas en tiempo de ejecución se invoca el cuadro de diálogo Personalizar
barra de herramientas, que permite al usuario ocultar, mostrar o reorganizar los
botones de la barra de herramientas. También puede abrir el cuadro de diálogo
Personalizar barra de herramientas si invoca el método Customize. Esto es posible
siempre que se establezca la propiedad AllowCustomize en True. Si desea guardar
y restaurar el estado de una barra de herramientas o permitir que el usuario final
lo haga, utilice los métodos SaveToolbar y RestoreToolbar.
La propiedad Style del objeto Button determina su comportamiento. A
continuación se indican los cinco estilos de botones, con sus usos posibles:
Constante Valor Uso posible
Predeterminado. Puede usar el estilo Default cuando la función que representa el
tbrDefault 0 botón no depende de otras funciones. Además, al hacer clic en el botón, vuelve a
su posición normal cuando la función ha terminado.
Verificación. Debe usar el estilo Check cuando el botón representa una alternancia
TbrCheck 1 de algún tipo. De esta forma, cuando el botón está presionado, continuará así hasta
que se presione de nuevo y queda liberado.
Grupo de botones. Puede usar este estilo ButtonGroup cuando un grupo de
tbrButtonGroup 2 funciones se excluyan mutuamente. Es decir, en un momento dado sólo una de las
funciones que representa el grupo de botones puede estar activada.
Separador. Este estilo Separator no tiene otra función que crear un botón de ocho
tbrSeparator 3 píxeles de ancho. Puede usarlo para separar otros dos botones o para agrupar
varios botones que tengan el estilo ButtonGroup.
154
Visual Basic 6.0 Unidad 8.- Tecnología OLE
Para identificar la función de una ficha, puede asignar una imagen del control
ImageList al objeto Tab. Para ello, primero debe asociar un control ImageList al
control TabStrip, lo que puede hacer en tiempo de diseño o en tiempo de
ejecución. Para crear objetos Tab en tiempo de diseño haga clic con el botón
secundario del Mouse en el control TabStrip y, después, haga clic en Propiedades
para abrir el cuadro de diálogo Páginas de propiedades.
155
Visual Basic 6.0 Unidad 8.- Tecnología OLE
156
Visual Basic 6.0 Unidad 9.- Funciones API
Unidad 9
Funciones API
157
Visual Basic 6.0 Unidad 9.- Funciones API
Luego, en cualquier parte del código del programa, se puede llamar a la función.
En este caso, para el ejemplo, se utiliza el procedimiento de evento Click de un
botón de comando para reiniciar el equipo (se usa la constante EWX_REBOOT):
158
Visual Basic 6.0 Unidad 9.- Funciones API
También se puede apagar por completo el equipo, pero esta vez se deberá usar la
constante EWX_SHUTDOWN:
Private Sub cmdBotón_Click()
Dim Ret As Long
Ret = ExitWindowsEx (EWX_SHUTDOWN, 0)
End Sub
La utilidad principal del visor de texto API consiste en que le evita al programador
la tediosa tarea de tener que escribir las declaraciones necesarias para hacer
accesible una función API. El programador selecciona la función, las constantes y
estructuras, las copia y luego las pega en módulos del proyecto.
Los elementos de la interfaz del visor de texto API se describen a continuación:
a) En Tipo de API se selecciona el tipo de elemento que se buscará en el Cuadro
de búsqueda, sólo escribiendo las primeras letras del nombre de la función, es
decir, puede ser la declaración, las constantes o las estructuras.
b) En elementos disponibles aparecerán las declaraciones, constantes o
estructuras disponibles según se halla escogido en Tipo de API.
159
Visual Basic 6.0 Unidad 9.- Funciones API
Text1.Text = DirWindows()
161
Visual Basic 6.0 Unidad 9.- Funciones API
La próxima vez que se deseen determinar las condiciones de capacidad del disco,
basta con utilizar el procedimiento general Espacio:
A diferencia del punto anterior (9.2.4), en estos casos se debe evitar el uso de
funciones o procedimientos auxiliares como este:
Function Tiempo()
Tiempo = GetTickCount()
End Sub
Retardo (10000)
162
Visual Basic 6.0 Unidad 9.- Funciones API
Consideración final
En esta guía sólo se han mostrado algunos ejemplos de utilidades de las funciones
API. En realidad existe una enorme cantidad de funciones API y controles ActiveX,
tanto en el sistema operativo Windows, como en otros; siendo Internet la principal
fuente de ellos. Este es el inicio para el desarrollo de aplicaciones más robustas y
profesionales.
El programador mas destacado es aquel que aprovecha, no sólo las herramientas
intrínsecas de Visual Basic, sino las provistas a través de la API y los componentes
ActiveX. Esta es la línea divisoria que separa a los novatos, de los programadores
avanzados. Aún queda algo de camino que recorrer: crear nuestros propios
objetos, diseñar aplicaciones para redes incluyendo Internet con DHTML, agregar
ayuda a las aplicaciones, controlar puertos u otro hardware del PC para desarrollos
SCADA o similares, etc.; pero estamos armados con los fundamentos necesarios
para alcanzar, muy pronto, el nivel de expertos.
¡Suerte programadores!
163