vviissuuaall bbaassiicc ppaarraa...

VViissuuaall BBaassiicc

ppaarraa BBaacchhiilllleerraattooss TTeeccnnoollóóggiiccooss

FFiicchhaa 11 –– AAññoo 22000055 IInnttrroodduucccciióónn aa VVBB

LLiicc.. GGoonnzzaalloo PPaassttoorr

Visual Basic para Bachilleratos Tecnológicos – Ficha 1 Página 1

INDICE Introducción..........................................................................................................................2 Programa de la Asignatura Programación ................................................................................3 Metodología ..........................................................................................................................3 Evaluación ............................................................................................................................3 Antecedentes históricos..........................................................................................................5 VISUAL BASIC .NET ...............................................................................................................7 Objetos, Propiedades, Métodos y Eventos ................................................................................8 IDE.....................................................................................................................................10 Etiquetas y Botones..............................................................................................................16 Botones de Comando ...........................................................................................................17 Grabar un Proyecto..............................................................................................................18 Variables. Definición y Entorno..............................................................................................19 Notación Húngara ................................................................................................................24 Usa comentarios en tus programas .......................................................................................25 Sentencias condicionales......................................................................................................26 Sentencias de bucle.............................................................................................................27 TextBox ..............................................................................................................................29 Propiedades comunes de los formularios ...............................................................................30 Shape ................................................................................................................................31 Barras de Desplazamiento ....................................................................................................31 ListBox y ComboBox .............................................................................................................32 Frame (Recuadro) ...............................................................................................................35 Check Button y Option Button (botones de elección y opción)...................................................35 TIMER (Temporizador).........................................................................................................37 Funciones de cadenas..........................................................................................................38 Funciones Con Números.......................................................................................................41 Funciones con fechas...........................................................................................................44 Función FORMAT.................................................................................................................45 Bibliografía..........................................................................................................................46


IInnttrroodduucccciióónn Este Manual esta destinado a los alumnos que cursan la asignatura Programación en el tercer año del Bachillerato Tecnológico en Mantenimiento y Procesamiento Informático. Si bien esta destinado a los estudiantes del Consejo de Educación Técnico Profesional (UTU) y otras instituciones que dictan este Bachillerato, puede ser utilizado por todo aquel que quiere aprender a programar en Visual Basic. El material expuesto será de apoyo al curso, y no un curso propiamente dicho. No pretende enseñar, sino organizar los conocimientos para ayudar a la memoria. Dada la gran extensión de conceptos que existen en Visual Basic, solo se tratarán los temas que se correspondan con el programa oficial de UTU, ya que tratarlos todos generaría una obra demasiado extensa. Todos los temas del lenguaje son expuestos en los manuales del lenguaje que contienen 800 o más páginas dependiendo del autor. Este trabajo se ha diseñado en 3 fichas divididas de la siguiente manera: Ficha 1: Introducción a VB. Tiene como objetivo acercar los conocimientos necesarios para

programar en este lenguaje. Ofrece las herramientas mínimas necesarias de programación.

Ficha 2: Base de Datos. Está destinada a programar almacenando la información en Base de Datos. Esta temática se aborda sobre la mitad del año.

Ficha 3: APIs. Pretende abarcar los temas que no son tratados durante el curso pero que permiten expandir los alcances de los programas. Se deja a libre criterio de los estudiantes utilizar estos conocimientos.

El material que se expone en estas fichas deberá ser usado para ampliar los conocimientos del estudiante y solo es una guía auxiliar de conocimiento. El estudiante debe seguir el curso dictado por el docente para tener un máximo aprovechamiento de la asignatura. Leer y comprender el presente material no es suficiente para lograr el máximo desempeño escolar. Todos aquellos errores que usted encuentre y desee comentar, o cualquier comentario que desee hacer por favor diríjalos a [email protected] Mucha suerte. El Autor


PPrrooggrraammaa ddee llaa AAssiiggnnaattuurraa PPrrooggrraammaacciióónn

Curso: 3º Año – Bachillerato Tecnológico - Mantenimiento y Procesamiento Informático

Objetivos • Integrar a los estudiantes en la programación de un lenguaje Visual. • Manejar las distintas herramientas de programación visual desde los conceptos más básicos

hasta la crear programas complejos usando bases de datos a través de ODBC. • Crear programas de mediano y gran tamaño usando la metodología de trabajo en equipo. Contenidos Nº Contenido 1. Introducción a Visual Basic. IDE. Objetos: Propiedades, Métodos y Eventos. 2. Label. Botones. Ejercicio: Crear un Form con el nombre del alumno y un botón que cambie

dicho nombre por otro valor. Grabar. 3. Sentencia DIM. Datos enteros. Ejercicio: Contador de un click. 4. Herramientas del sistema. Análisis de algunas propiedades. Sentencia IF. 5. Ejercicio: El Semáforo. 6. Ejercicio con variables lógicas. Ejercicio: Selector de Imágenes. 7. ComboBox. Barra de Desplazamientos. Cuadro de Texto. 8. Botón de Radio. Frame. Check Box. Array de Controles. 9. Ejercicio: Calculadora con 4 botones. 10. Bucles: For..Next, Exit For, Function. 11. Variables Lógicas. Tipos de Variables. Alcance. 12. ItemData. Ej: Convertidor de Monedas. 13. Escrito. Corrección. 14. Trabajar con 2 Formularios. Show. Hide. Unload 15. Diseñar y crear una Base de datos con Access. 16. Repaso de SQL. Trabajar con bases de datos ADO. 17. Alta de Registros. Escrito Domiciliario. 18. Baja de Registros. 19. Consulta de Registros. Mover hacia atrás y hacia adelante. 20. Modificación de Tablas. Comando UPDATE. 21. Imprimir. Data Grid 22. Mover Botones. 23. Alta y Baja de Autores. 24. Data Report. SQL con varias tablas. 25. Escrito en equipo. Corrección de Escrito. 26. Presentación de un Sistema. 27. Menú. Clave de Acceso. 28. Sistema de Sueldos. 29. Arboles. 30. Preparación del Proyecto. 31. Fin del Curso. Evaluación Final. Metodología • Se trabajará sobre el modelo de clases teórico–practicas de manera que el alumno pueda

practicar inmediatamente los conocimientos adquiridos. • A medida que el estudiante incorpore los conocimientos básicos necesarios se le instará a

trabajar en equipo con sus compañeros en equipos de 2 a 4 personas. Evaluación • Se realizaran 3 escritos en el año de manera de evaluar individualmente los conocimientos

adquiridos por cada alumno. • Se agregará de manera intercalada, a la calificación de los escritos la obtenida en las dos

entregas del proyecto.


• Todos los alumnos van a examen obligatorio con un proyecto que defenderán en equipo primero e individualmente después.


AAnntteecceeddeenntteess hhiissttóórriiccooss El lenguaje de programación BASIC (Beginner's All purpose Symbolic Instruction Code) nació en el año 1964 como una herramienta destinado a principiantes, buscando una forma sencilla de realizar programas, empleando un lenguaje casi igual al usado en la vida ordinaria (en inglés), y con instrucciones muy sencillas y escasas. Teniendo en cuenta el año de su nacimiento, este lenguaje cubría casi todas las necesidades para la ejecución de programas. Las máquinas existentes en aquella época estaban estrenando los transistores como elementos de conmutación, los ciclos de trabajo llegaban a la impensable cifra de 10.000 por segundo y la memoria no pasaba de unos pocos Kb en toroides de ferrita. La evolución del BASIC por los años 70 fue escasa, dado el auge que tomaron en aquella época lenguajes de alto nivel como el FORTRAN y el COBOL. En 1978 se definió una norma para unificar los Basics existentes creándose la normativa BASIC STANDARD Con la aparición de los primeras computadoras personales, dedicados comercialmente al usuario particular, allá por la primera mitad de los ochenta, el BASIC resurgió como lenguaje de programación pensado para principiantes, y muchos de estas pequeñas computadoras domésticos lo usaban como único sistema operativo (Sinclair, Spectrum, Amstrad) Con la popularización del PC, salieron varias versiones del BASIC que funcionaban en este tipo de computadoras (Versiones BASICA, GW-BASIC), pero todas estas versiones del BASIC no hicieron otra cosa que terminar de rematar este lenguaje. Los programadores profesionales no llegaron a utilizarlo por las desventajas de este lenguaje respecto a otras herramientas (PASCAL, C, CLIPPER). El BASIC con estas versiones para PC llegó incluso a perder crédito entre los profesionales de la informática. Las razones: • No era un lenguaje estructurado. • No existían herramientas de compilación fiables. • No disponía de herramientas de intercambio de información. • No tenía librerías. • No se podía acceder al interior de la máquina. • Un largo cumulo de desventajas respecto a otros lenguajes de programación. Tal fue el abandono por parte de los usuarios, que la aparición del Quick-BASIC de Microsoft, una versión ya potente del BASIC, que corregía casi todos los defectos de las versiones pasó prácticamente inadvertida, a no ser porque las últimas versiones del sistema operativo MS-DOS incluían una versión de Quick-BASIC algo recortada (Q-Basic) como un producto mas dentro de la amplia gama de ficheros ejecutables que acompañan al sistema operativo, y aprovecha de él el editor de textos (Cada vez que se llama al EDIT estamos corriendo el editor del Q-Basic). Esta versión del popular BASIC ya es un lenguaje estructurado, lo que permite crear programas modularmente, mediante subrutinas y módulos, capaz de crear programas ya competitivos con otros lenguajes de alto nivel. Sin embargo llegaba tarde, pues los entornos MS-DOS estaban ya superados por el entorno gráfico Windows. Sin embargo algo había en el BASIC que tentaba a superarse: su gran sencillez de manejo. Si a esto se le añade el entorno gráfico Windows, el aprovechamiento al máximo de las posibilidades de Windows en cuanto a intercambio de información, de sus librerías, de sus drivers y controladores, manejo de bases de datos, etc. el producto resultante puede ser algo que satisfaga todas las necesidades de programación en el entorno Windows. La suma de todas estas cosas es VISUAL - BASIC. Esta herramienta conserva del BASIC de los años 80 únicamente su nombre y su sencillez, y tras su lanzamiento al mercado, la aceptación a nivel profesional hizo borrar por fin el "mal nombre" asociado a la palabra BASIC. Actualmente se está comercializando la versión .NET de este producto (siguente a la versión 6). Desde su salida al mercado, cada versión supera y mejora la anterior. Dados los buenos


resultados a nivel profesional de este producto, y el apoyo prestado por el fabricante para la formación de programadores, Visual-Basic se ha convertido en la primera herramienta de desarrollo de aplicaciones en entorno Windows. Sin embargo sigue siendo BASIC. No se pueden comparar sus prestaciones con otros lenguajes cuando deseamos llegar al fondo de la máquina y controlar uno a uno sus registros. No es ese el fin perseguido con VB y si es necesario llegar a esas precisiones será necesario utilizar otro lenguaje que permita bajar el nivel de programación. (Visual-C). o realizar librerías (DLLs) que lo hagan. En la mayor parte de las aplicaciones, las herramientas aportadas por VB son mas que suficiente para lograr un programa fácil de realizar y de altas prestaciones. Características Generales de Visual-Basic Visual-Basic es una herramienta de diseño de aplicaciones para Windows, en la que estas se desarrollan en una gran parte a partir del diseño de una interface gráfica. En una aplicación Visual - Basic, el programa está formado por una parte de código puro, y otras partes asociadas a los objetos que forman la interface gráfica. Es por tanto un termino medio entre la programación tradicional, formada por una sucesión lineal de código estructurado, y la programación orientada a objetos. Combina ambas tendencias. Ya que no podemos decir que VB pertenezca por completo a uno de esos dos tipos de programación, debemos inventar una palabra que la defina : PROGRAMACION VISUAL. La creación de un programa bajo Visual Basic lleva los siguientes pasos: - Creación de un interface de usuario. Este interface será la principal vía de comunicación

hombre máquina, tanto para salida de datos como para entrada. Será necesario partir de una ventana -llamada Formulario en Visual Basic- a la que le iremos añadiendo los controles necesarios.

- Definición de las propiedades de los controles - Objetos - que hayamos colocado en ese

formulario. Estas propiedades determinarán la forma estática de los controles, es decir, como son los controles y para qué sirven.

- Generación del código asociado a los eventos que ocurran a estos objetos. A la

respuesta a estos eventos (click, doble click, una tecla pulsada, etc.) le llamamos Sub Rutina o Procedimiento, y deberá generarse de acuerdo a las necesidades del programa.

- Generación del código del programa. Un programa puede hacerse solamente con la

programación de los distintos procedimientos que acompañan a cada objeto. Sin embargo, VB ofrece la posibilidad de establecer un código de programa separado de estos eventos. Este código puede introducirse en unos bloques llamados Módulos, en otros bloques llamados Funciones, y otros llamados Procedimientos. Estos Procedimientos no responden a un evento acaecido a un objeto, sino que responden a un evento producido durante la ejecución del programa.

Se considera que Visual Basic es un lenguaje orientado a eventos. Depende de lo que decida hacer el usuario porque esto disparará un evento.


VVIISSUUAALL BBAASSIICC ..NNEETT El lenguaje de Visual Basic .NET se ha actualizado, simplificado y modernizado. Con Visual Basic .NET, ahora tiene acceso a un conjunto de herramientas mucho más completo y eficaz que en versiones anteriores de Visual Basic. Para satisfacer la fuerte demanda de los clientes, Visual Basic .NET ofrece un amplio conjunto de nuevas características, como capacidades de diseño completamente orientado a objetos, subprocesamiento libre y acceso directo a Microsoft .NET Framework. Asimismo, el lenguaje de Visual Basic se ha optimizado, eliminando palabras clave obsoletas que se habían heredado, mejorando la seguridad de tipos y revelando las construcciones de bajo nivel que los programadores avanzados necesitan. Ahora, Visual Basic .NET se integra plenamente con otros lenguajes de Microsoft Visual Studio® .NET. No sólo se pueden programar componentes de aplicaciones en diferentes lenguajes de programación, sino que ahora, las clases se pueden heredar de clases escritas en otros lenguajes utilizando la herencia entre lenguajes. Con el depurador unificado, ahora se pueden depurar aplicaciones en varios lenguajes, independientemente de si se ejecutan localmente o en equipos remotos. Por último, independientemente del lenguaje que se utilice, .NET Framework proporciona un amplio conjunto de interfaces de programación de aplicaciones (API) para el sistema operativo Microsoft Windows e Internet. Los programadores de Visual Basic .NET pueden unirse a la mayor comunidad de programadores, formada por más de 3 millones de programadores de Visual Basic de todo el mundo. Los programadores pueden usar componentes del inmenso mercado de controles de otros fabricantes para crear aplicaciones completas basadas en .NET y pueden aprender Visual Basic .NET rápidamente de los muchos libros y ejemplos disponibles. Para utilizar Microsoft Visual Basic® .NET, se necesita:

Requerimientos mínimos

Procesador Computadora personal (PC) con un procesador Pentium II, 450 megahertz (MHz)

Sistema Operativo Microsoft Windows® XP Professional Microsoft Windows 2000 Professional Microsoft Windows 2000 Server Microsoft Windows NT® 4.0 Workstation Microsoft Windows NT 4.0 Server

Memoria Microsoft Windows XP Professional 160 MB de RAM; se recomiendan 192 MB Windows 2000 Professional 96 MB de RAM; se recomiendan 128 MB Windows 2000 Server 192 MB de RAM; se recomiendan 256 MB Windows NT 4.0 Workstation 64 MB de RAM; se recomiendan 96 MB Windows NT 4.0 Server 160 MB de RAM: 160 MB de RAM; se recomiendan 192 MB

Disco Duro 500 MB en el disco de sistema, 2.0 gigabytes (GB) en el disco a instalarse

Unidad CD-ROM u DVD-ROM

Video Monitor Super VGA (800 x 600) o superior a 256 colores

Mouse Microsoft Mouse o dispositivo compatible


OObbjjeettooss,, PPrrooppiieeddaaddeess,, MMééttooddooss yy EEvveennttooss Los objetos, propiedades, métodos y eventos son las unidades básicas de la programación orientada a objetos. Un objeto es un elemento de una aplicación o programa. Propiedades, métodos y eventos son las unidades de creación básicas de los objetos y constituyen sus miembros. Objetos Un objeto representa un elemento indivisible de una aplicación, como un Formulario, un botón o un cuadro de texto. En Visual Basic, debe crear una instancia de un objeto (agregarlo a la aplicación) antes de poder aplicar uno de los métodos del objeto o cambiar el valor de una de sus propiedades. Propiedades Una propiedad es un atributo de un objeto que define una de las características del objeto, como tamaño, color o ubicación en pantalla, o un aspecto de su comportamiento, por ejemplo, si está habilitado o visible. Para cambiar las características de un objeto, se cambian los valores de las propiedades correspondientes. Para establecer el valor de una propiedad, establezca la referencia a un objeto con un punto, el nombre de propiedad, un signo igual (=) y el nuevo valor de la propiedad. Por ejemplo, cambiar el título de un formulario de Visual Basic mediante la definición de la propiedad CAPTION:

Form1.Caption = “Titulo del Formulario” La mayoría de las propiedades pueden modificarse pero algunas son de sólo lectura. La mayoría se pueden cambiar en tiempo de DISEÑO (cuando se está creando la aplicación) o en tiempo de EJECUCIÓN (cuando el programa está funcionando) pero algunas solo están disponible en Diseño o en Ejecución. Si quiere conocer el valor de una propiedad sólo tiene que llamarla. Por ejemplo: Titulo = Form1.Caption Métodos Un método es una acción que un objeto puede realizar. Por ejemplo, SHOW es un método que muestra un objeto. Si deseo por ejemplo mostrar un formulario escribo en el código: Form1.Show Eventos Un evento es una acción que un objeto reconoce, como hacer clic con el mouse (ratón) o presionar una tecla, y para el que puede escribir código para responder. Los eventos se producen como consecuencia de una acción del usuario o de código de programa, o bien pueden ser desencadenados por el sistema. También puede desarrollar eventos personalizados propios para que los generen sus objetos y los controlen otros objetos. Recuerde que Visual Basic es un POE (programa orientado a eventos). Todo lo que hacemos en un programa Visual Basic está generado por medio de eventos. Los formularios y controles de Visual Basic son objetos que exponen sus propios métodos, propiedades y eventos. Las propiedades se pueden considerar como atributos de un objeto, los métodos como sus acciones y los eventos como sus respuestas. Un objeto de uso diarios como el globo de un niño tiene también propiedades, métodos y eventos. Entre las propiedades de un globo se incluyen atributos visibles como el peso, el diámetro y el color. Otras propiedades describen su estado (inflado o desinflado) o atributos que no son visibles, como su edad. Por definición, todos los globos tienen estas propiedades; lo que varía de un globo a otro son los valores de estas propiedades. Un globo tiene también métodos o acciones propias que se puede efectuar. Tiene un método inflar (la acción de llenarlo de aire) o un método desinflar (sacar su contenido) y un método elevarse (si se lo eleva). Todos los globos pueden efectuar estos métodos. Los globos tienen además respuestas predefinidas a ciertos eventos externos. Por ejemplo un


globo respondería al evento de pincharlo desinflándose o al evento de soltarlo volando lentamente por el aire. Los objetos tienen propiedades, responden a eventos y ejecutan métodos. Si se pudiera programar un globo, el código de Visual Basic podría ser como el siguiente. Para establecer las propiedades del globo: Globo.Color = “Rojo” Globo.Diámetro = 10 Globo.Inflado = True Observe la sintaxis usada: el objeto (Globo) seguido de un punto, luego la propiedad (Color), el signo de igual (=) y luego el valor (Rojo) Existe en el editor de Visual Basic una ventana que contiene las propiedades donde se pueden cambiar el valor de las mismas sin escribir código. Los métodos se pueden invocar de la siguiente manera: Globo.Inflar Globo.Desinflar Globo.Elevar 10 La sintaxis es similar a la sintaxis de las propiedades: el objeto (un nombre) seguido de un método (un verbo). EN el tercer ejemplo hay un elemento adicional, llamado argumento, que indica la distancia que se eleva. Algunos métodos tendrá uno o más argumentos para describir más a fondo la acción que se va a ejecutar. El globo puede responder a un evento como se muestra a continuación:

Sub Globo_Pinchazo() Globo.Desinflar Globo.HacerRuido “Pum” Globo.Inflado = False Globo.Diámetro = 1

End Sub En este caso, el código describte el comportamiento del globo cuando se produce un evento Pinchazo: invoca el método Desinflar y luego invoca el método HacerRuido con un argumento “Pum” (el tipo de ruido que se va a hacer). Como el globo ya no está inflado, la propiedad Inflado tiene el valor False y la propiedad Diámetro tiene un nuevo valor.


IIDDEE Para comenzar a trabajar en Visual Basic se debe hacer: • Inicio/Programas/Microsoft Visual Studio 6.0/Microsoft Visual Basic 6.0 o en algunos casos (depende de la versión instalada): • Inicio/Programas/Microsoft Visual Basic 6.0/Microsoft Visual Basic 6.0

Esta es la primera pantalla que aparece donde se elige EXE estándar o simplemente se da Enter ya que esta es la opción por defecto. A continuación aparece la ventana principal de Visual Basic desde la cual se va a programar y a probar los programas realizados. Dicha ventana se llama IDE (Integrated Development Environment) y contiene todos los elementos necesarios para trabajar. Las secciones que posee esta ventana son las siguientes:

Como Visual Basic ya está pronto para trabajar se puede probar el programa pulsando F5 y se mostrará una ventana vacía con sus respectivas barras y botones.

Menú

Caja de Herramientas

Formulario a diseñar Explorador de Proyectos

Ventana de Propiedades Posición del Formulario (ya la puede ir cerrando)

Barra de Herramientas


Observe que en esta pantalla existen varias cosas. En la parte superior, la barra de título del programa Visual Basic, con el texto :

Proyecto1 - Microsoft Visual Basic (Diseño) Por debajo de esta barra de Título de VB, encontramos la barra de menú de VB, con las leyendas : Archivo Edición Ver Insertar Ejecutar Herramientas Complementos Ayuda Por debajo de esta barra de menú tenemos la barra de herramientas, que puede terner ver varios iconos, cada uno representa un determinada operación que usted puede realizar. Estas operaciones está todas en la línea de menú, y puede acceder a ellas abriendo los menús desplegables que existen en cada una de las palabrea Archivo Edición Ver… de esta línea de menú. El hecho de colocar las operaciones mas usuales en un icono en la barra de herramientas se hace para mayor comodidad del usuario. A la izquierda de la pantalla tiene una caja rectangular con tres columnas de iconos. Esa caja es la Caja de Herramientas (No la confunda con la barra de herramientas de la parte superior) En la Caja de Herramientas están los iconos que representan a los controles con los que usted va a desarrollar su aplicación VB. No están todos los que pueden estar, solo las mas usuales. Si necesita alguna mas, puede usarla de otra parte (Menú, Herramientas, Controles personalizados) y agregarlos a esa caja de herramientas. Posiblemente esta caja de herramientas no le aparezca tal y como la ve en estos apuntes. Eso depende si Ud. tiene la versión personal o la profesional, o si usa la versión de 16 ó 32 bits. Esa caja de herramientas puede personalizarla a su gusto. Para ello, deberá cargar un proyecto ya existente en los discos de distribución de Visual Basic, llamado AUTO32LD.VBP (versión 32 bits) ó AUTO16LD.VBP (Versión 16 bits) que se encontrará en el directorio donde haya cargado el programa Visual Basic. Este proyecto sirve para determinar las herramientas con las que quiere abrir el VB. Para introducir herramientas nuevas en la caja de herramientas, basta con desplegar el menú Herramientas de la barra de menú, e ir a Controles personalizados. Haciendo click en esta línea de controles personalizados, podemos seleccionar nuevos controles para añadir a la caja de herramientas, marcando la casilla que está a la izquierda del nombre del control que quiere introducir. Una vez seleccionados todos los nuevos controles, haga click en ACEPTAR, y podrá observar que esos nuevos controles ya se le han añadido a la caja de herramientas. Para que esos nuevos controles le aparezcan de entrada cuando inicia una sesión de VB, debe salir de Visual basic guardando los cambios. Vuelva a entrar y observará que ya le aparecen esos nuevos controles en la caja. No es prudente meter muchos controles en la caja. Ponga solamente los que necesite normalmente en sus aplicaciones. Ocupará menos memoria y tardará menos tiempo en cargar el programa VB. Además, cuando realice una aplicación y la distribuya una vez compilada, Visual Basic entregará en los disquetes de distribución las DLL’s u OCX’s correspondientes a todos los controles personalizados que Ud. tenga en la caja de herramientas, los necesite el programa o no los necesite. Esto le va a suponer que está cargando subprogramas inútiles en el computadora destino de su aplicación. A la hora de compilar el programa (Crear archivo .EXE) quite todos los controles personalizados que no necesite su aplicación. (Los controles comunes - CommandButton, Label, TextBox, etc.-, no se pueden eliminar de la caja de herramientas) Para quitar controles de su caja de herramientas, debe proceder de forma análoga, cargando el programa AUTOxxLD.VBP, abriendo menú de herramientas, Controles personalizados, quitando la marca al cuadro situado en la parte izquierda del control a eliminar, y guardando el proyecto al salir. En el centro, y ocupando casi toda la pantalla, tenemos el Formulario. Este Formulario es la interface gráfica de su aplicación, sobre el que podrá añadir los controles que necesite.


La Ventana de Propiedades, es donde puede ver las propiedades del formulario, Form1, y la otra, denominada Ventana de Proyecto contiene el detalle de los formularios de su proyecto. No se extrañe de que esta presentación gráfica del Visual Basic coincida con otros sistemas de desarrollo. La lógica de desarrollo de una aplicación en Windows ha llevado a varios fabricantes de software a utilizar un entorno gráfico similar (diríamos idéntico). A Visual basic le queda el orgullo de ser el primero en utilizarlo. A la Ventana de Código se accede pulsando el ícono o dando doble click sobre una parte vacía del Formulario.

Esta figura muestra un Formulario con su ventana de código. Cada objeto gráfico de VB tiene su propia ventana de código. Si en este formulario hubiésemos introducido un Label y dos CommandButton, todos ellos tendrían su propia ventana de código. La ventana de código la podemos ver haciendo doble click sobre cualquier objeto de nuestro proyecto. En este caso se ha hecho doble click sobre el único objeto que teníamos: el formulario. Observe las dos cajas de la parte superior, uno con la inscripción Objeto (contiene Form en este caso), y el otro con la inscripción Proc : (procedimiento), que muestra Load. A estas cajas se les denomina Lista de Objetos y Lista de Procedimientos respectivamente. Haciendo click sobre la flecha de cada lista, se despliega un menú. En la lista de objetos se desplegará una lista con los nombres de cada objeto existente en ese momento dentro del formulario. Haciendo click sobre uno de los nombres, nos presentará la ventana de código de ese objeto. Todos los objetos gráficos (controles) existentes dentro de un formulario y el propio formulario aparecerán en la misma lista de objetos. Haciendo click sobre la flecha de la lista de procedimientos, se despliega la lista con todos los procedimientos posibles para ese objeto. Siempre saldrá uno. Si tenemos escrito código en uno de los procedimientos, saldrá por defecto ese procedimiento para el cual hemos escrito el código. Si no hay código en ninguno de los procedimientos, saldrá el que tenga por defecto cada objeto. ¿Qué es un Procedimiento o Sub o Subrutina?


Un Evento es algo que le puede ocurrir a un objeto. En una interface gráfica, lo que le puede ocurrir a un objeto es que se le haga click, doble click, que se pase el cursor del ratón por encima, etc. Este es el Evento. El Procedimiento es la respuesta por parte de ese objeto, al evento que le está sucediendo. Esa respuesta, esa forma de Proceder del objeto al evento que le está sucediendo, debemos programarla según nuestras necesidades, es decir, debemos escribir el código que necesite nuestra aplicación como respuesta al evento que acaba de ocurrir. Posiblemente, no queramos ninguna respuesta a muchos de los eventos que pueden tener un objeto. Cada objeto tiene muchos eventos y solamente queremos aprovechar los que nos interesan. Para que un evento no produzca ningún efecto, basta con dejar sin código el procedimiento correspondiente a ese evento. En los eventos que queramos que realice alguna operación, le escribiremos en su procedimiento el código necesario para que esa operación se realice. Así se comienza a escribir el código de la aplicación. El primer elemento del menú desplegable de la lista de objetos se denomina General. Este no es en realidad ningún objeto, sino un apartado existente en cada formulario, que, al desplegar su lista de procedimientos tiene la sección de declaraciones, donde debemos declarar las variables que queremos que afecten a todo el formulario y sus controles, y tendrá además, los nombres de todos los procedimientos que introduzcamos. En este menú desplegable de la lista de procedimientos del General verá con frecuencia cosas que Ud. no puso allí. Cosas tales como Command1_click, y en la ventana un determinado código. Esto ocurre cuando se borra algún control que tenía escrito código en alguno de sus procedimientos. Visual Basic no lo tira inmediatamente, sino que lo reserva como un procedimiento en ese apartado General del formulario. Si en realidad queríamos borrar el control y todo su código, debemos quitarlo de ese apartado General de nuestro formulario, porque si no lo queremos, no hará otra cosa que estorbar. Para quitarlo basta con borrar todo el código que aparece en la ventana de código cuando hacemos click sobre el nombre del control eliminado. Deberemos borrar todo el código, incluida la cabecera donde figura el nombre del control eliminado, y la parte final, que siempre termina con EndSub. El primer estorbo lo observará si crea otro control con el mismo nombre, cosa fácil ya que VB da un nombre por defecto a cada control (Command1, Command2....). El código asociado al control eliminado pasará automáticamente al nuevo control con el mismo nombre. Podemos añadir cuantos procedimientos queramos. Estos procedimientos se añaden al formulario, y deberán definirse por un nombre que usted debe elegir. Para que se ejecuten las instrucciones (código) incluido en ese procedimiento, basta simplemente con llamarlo por ese nombre. Para insertar un procedimiento debe ir a la barra de menú, hacer click sobre Insertar, y en el menú que le desplegará, volver a hacer click sobre Procedimiento. VB le presentará un cuadro donde le pedirá el nombre, si quiere que sea un procedimiento, una función o una propiedad. Puede también hacerlo escribiendo en el código: SUB nombre_del_procedimiento en un lugar vacío. Módulos: Un Módulo es una parte del programa donde solamente puede escribir código. Es igual que un formulario pero sin interface gráfica.. En un módulo pueden existir procedimientos al igual que en los formularios, pero como un módulo no tiene interface gráfica, esos procedimientos debe introducirlos el programador “a mano”. El módulo tiene su propia ventana de código, al igual que un formulario, con un objeto único, el apartado General. Aquí también tenemos la sección de declaraciones, al igual que los formularios. En esta sección de declaraciones se comporta de manera similar a la de los formularios, pero permite algo que no nos permite la sección de declaraciones de un formulario: Declarar variables que se pueden utilizar en todo el programa con las sentencia de declaración Global y Public. Los módulos se emplean para la declaración de variables globales, y para escribir el código de la aplicación que sea común a varios formularios. Esto nos evita tener que repetir código inútilmente. Ese código común se escribirá en un procedimiento que previamente habremos insertado en este


módulo, y lo citaremos por su nombre desde cualquier parte del programa. ¿Cómo ejecuto un procedimiento existente dentro de un módulo? Si estamos ejecutando código escrito en otro procedimiento dentro del mismo módulo, por ejemplo, si estamos dentro de ese mismo módulo, basta con citarlo por su nombre: si en el MóduloA tenemos un procedimiento llamado Procedimiento1, y queremos llamarle desde una línea de código dentro de ese mismo módulo, basta con referirse a él con : Procedimiento1 Si la línea de código donde nos vamos a referir a él está fuera de MóduloA, deberemos referirnos a ese procedimiento con : MóduloA.Procedimiento1 Lo mismo podemos decir para cualquier procedimiento insertado en un formulario. Desde dentro del formulario basta con referirse a él citándolo por su nombre. Desde fuera de ese formulario deberemos citarle como : Formulariox.Procedimientoy donde damos por hecho que Formulariox es el nombre del formulario que lo contiene, y Procedimientoy es el nombre del procedimiento. No olvide el punto usado como separador entre el nombre del formulario y el nombre del procedimiento. VB usa como separador un punto. Usa el separador para separar el nombre de un control y una de sus propiedades (Label1.Caption), para separar el nombre del formulario del nombre de uno de sus controles (Formulario1.label1.caption) Funciones Al igual que introducimos Procedimientos, podemos introducir Funciones en nuestra aplicación. Una Función es un Procedimiento al que le pasamos uno o varios parámetros. (a veces Ninguno) Se usan para que devuelvan resultados. Al igual que los Procedimientos, pueden ser públicas (se verán en toda la aplicación) o privadas (se verán solamente en el formulario donde estén). Procedimiento Main Imaginemos una aplicación que tiene 3 Formularios. En cada uno de ellos tiene código. La aplicación tendrá que usar uno de ellos en primer lugar. Deberemos decirle a Visual Basic cual es el formulario inicial, y será ese por el que empiece. En ese formulario dispondremos el código necesario para que la aplicación se ejecute en el orden deseado. Si hacemos click en la Barra de Menú de Visual Basic, en Herramientas | Opciones obtendremos el siguiente cuadro de diálogo : Tiene 4 pestañas, y actualmente tiene abierta la pestaña correspondiente a Proyecto, y tiene desplegada una lista donde nos pide el Formulario Inicial. En esa lista figura también la expresión Sub Main. Si ponemos como formulario inicial uno de los formularios, la aplicación comenzará por ese formulario. Si en uno de los Módulos existentes en el proyecto, ponemos un procedimiento llamado Main, podemos comenzar la ejecución de la aplicación


justamente por ese procedimiento. En ese procedimiento pondremos el código necesario para que, posteriormente, se muestre uno de los formularios. Esto es muy practico cuando queremos hacer una función previa a mostrar cualquier formulario (abrir una base de datos, por ejemplo). Para comenzar la aplicación por Main se elige esa opción en la lista Formulario Inicial. Recuerde que Main debe estar en un Módulo El cuadro de diálogo anterior sirve además para otras cosas. Entre ellas poner el nombre del proyecto (nombre que no aparecerá por ninguna parte, solo en los datos internos de la aplicación) y su descripción. En otra pestaña podemos configurar varias prestaciones del entorno de trabajo : Guardar la aplicación antes de ejecutar. Esta prestación nos va a evitar muchos disgustos. Es muy práctico guardar la aplicación antes de ejecutarla, pues de esta forma evitamos que, si nuestra aplicación tiene un error tal que hagamos colgarse a Windows, siempre tendremos la aplicación metida en el disco duro. Pero también genera una pequeña demora tener que esperar a que se guarde cada vez que la ejecutamos. Si tenemos la activada la casilla Declaración de variables requerida nos pondrá automáticamente Option Explicit en el encabezamiento de todas las secciones de declaraciones de la aplicación. Podemos elegir también las ventanas que queremos que estén siempre visibles, y que verifique automáticamente la sintaxis de una instrucción en el momento de escribirla. La pestaña de Editor nos permite básicamente 2 cosas : Ver solamente el código correspondiente al procedimiento que estamos escribiendo ó Ver el código del Módulo (o Formulario) completo. En este último caso es un poco mas difícil de manejar la ventana de código, sobre todo si el programador no está muy habituado a ello. Le presenta procedimiento tras procedimiento, separados por una línea. Para seleccionar una u otra opción hay que seleccionar o deseleccionar la casilla: Ver módulo completo. Cambiar el color de la letra y del fondo del código, según el tipo que sea (código, comentario, error devuelto, etc.).


EEttiiqquueettaass yy BBoottoonneess Unas de las herramientas más utilizadas en los programas son las Etiquetas (Label) y los botones (Command Button) Para agregar una etiqueta o un botón arrástrelo desde la barra de herramientas hasta el formulario. Ejercicio: Arrastre una etiqueta y un botón intentando que tenga la apariencia de este ejemplo. Luego de que los objetos han sido agregados al formulario se pueden modificar sus propiedades desde la ventana de propiedades. Los botones y etiquetas tienen muchas propiedades en común aunque algunas son diferentes según el objeto. Visual Basic usa una unidad propia llamada twips para medir sus objetos, que es por defecto 1/15 de píxel. Las propiedades más usadas en las etiquetas son las siguientes:

Propiedad Descripción

Alignment Determina si el mensaje aparece justificado a la izquierda, a la derecha o al centro dentro de los límites de la etiqueta.

AutoSize Si está activado, ajusta las propiedades de tamaño de la etiqueta al asignar un mensaje que es demasiado grande o pequeño para sus dimensiones actuales.

BackColor Especifica el color de fondo. Haga clic en la flecha de la paleta BackColor para ver una lista de colores, y seleccione la ficha Sistema para ver los colores comúnmente usados en los controles de Windows.

BackStyle Determina si se muestra lo que está detrás de la etiqueta o no.

BorderStyle Determina si se muestra una línea bordeando la etiqueta

Caption Contiene el texto que aparece en la etiqueta.

Enabled Determina si la etiqueta está activa. A veces cambiará esta propiedad en tiempo de ejecución cuando no se necesite que la etiqueta dispare eventos.

Font Produce un cuadro de diálogo Fuente en el que podrá establecer el nombre, estilo y tamaño de la fuente usada para el texto del mensaje.

ForeColor Establece el color del texto del mensaje.

Height Contiene la altura del formulario en twips.

Left Establece la cantidad de twips desde el extremo izquierdo de la etiqueta hasta el extremo izquierdo del formulario.

MousePointer Determina la forma del cursor del ratón cuando el usuario lo mueve por el área de la etiqueta.

TabIndex Especifica el orden de enfoque asignado a la etiqueta cuando se pulsa la tecla TAB. Aunque la etiqueta no lo reciba, puede ser parte del orden de enfoque.

ToolTipText Contiene la información que se mostrará cuando el mouse lo enfoque en tiempo de ejecución.

Top Establece la cantidad de twips desde el extremo superior de la etiqueta hasta el extremo superior del área de trabajo del formulario.

Visible Determina si el usuario podrá ver o no la etiqueta.


Width Contiene el ancho de la etiqueta en twips.

WordWrap Determina si la etiqueta se expande para ajustarse al texto.

BBoottoonneess ddee CCoommaannddoo


Backcolor Especifica el color de fondo del botón. Haga clic en la flecha de la paleta BackColor par ver una lista de colores y seleccione la ficha Sistema para ver los colores comunes de los controles de Windows. Antes de que el botón de comando pueda desplegar el color de fondo, deberá cambiar la propiedad Style de 0 - Estándar a 1- Graphical.

Cancel Determina si el botón recibe el evento Click cuando el usuario oprime Esc.

Caption Contiene el texto del mensaje que aparece en el botón.

Default Determina se el botón reacciona cuando se pulse la tecla ENTER

Enabled Determina si el control está activado. A veces cambiará la propiedad Enabled mediante código en tiempo de ejecución cuando no se necesite el botón y desee atenuarlo.

Font Produce el cuadro de diálogo Fuente donde podrá establecer el nombre, estilo y tamaño de la fuente con que aparece el mensaje.

Height Contiene la altura del botón en twips.

Left Contiene la cantidad de twips desde el extremo izquierdo del botón hasta el extremo izquierdo del formulario.

Mouse Pointer Determina la forma del cursor del ratón cuando el usuario lo mueve dentro del área del botón.

Picture Contiene el nombre de alguna imagen que aparecerá en el botón. Debe establecer la propiedad Style a 1- Graphical.

Style Determina si el botón aparecerá de la forma tradicional que lo hace en Windows (sí está establecido en 0 -Standard) o con color y/o una imagen (sí está establecido en 1- Graphical).

TabIndex Especifica el orden de enfoque asignado al botón al pulsar TAB en tiempo de ejecución.

TabStop Determina si el botón puede recibir el enfoque.

ToolTipText Texto mostrado cuando el mouse se detenga sobre él en tiempo de ejecución.

Top Contiene la cantidad de twips desde el extremo superior del botón hasta el extremo superior del área de trabajo del formulario.

Visible Determina si el usuario puede ver o no el botón. (Los controles invisibles no pueden recibir el enfoque hasta que el código en ejecución cambie esta propiedad Visible a True.)

Width Contiene el ancho del botón en twips.

Ejercicio: Pruebe cambiar todas las propiedades enumeradas de la etiqueta y el botón, y luego ejecute el programa con F5 para ver los resultados. Ejercicio:


• Programe el evento Clic del Botón de forma que la etiqueta muestre el mensaje “Hola Mundo” cuando se presione el botón.

• Grabe el proyecto con el nombre “Hola Mundo” y al formulario llámele “frmHola”

GGrraabbaarr uunn PPrrooyyeeccttoo Para grabar la aplicación use Menú / Archivo / Guardar. Esto grabará tanto el formulario como los archivos del proyecto. Cuando se graba un proyecto, deben guardarse los archivos de los formularios (.FRM) y el archivo de proyecto (.VBP). Asegúrese que se están guardando en el directorio deseado. Existen cuatro formas de grabar en el menú Archivo • Guardar Form1 (Control+S)

o Graba el formulario con el nombre actual. Se graba el archivo "activo" esto es el que está iluminado en la ventana Project.

• Guardar Form1 como… o Igual que la anterior, pero le da la opción de cambiar el nombre

• Guardar Proyecto o Graba todas los formularios y demás archivos del proyecto usando sus nombres

actuales, además guarda el archivo .VBP del proyecto. • Guardar Proyecto como

o Igual que el anterior pero permite cambiar los nombres de archivos a cada uno de los archivos que se graban.


VVaarriiaabblleess.. DDeeffiinniicciióónn yy EEnnttoorrnnoo Una variable es un nombre que en el programa le asignamos a un dato. Ese dato podrá cambiar. En un programa consistente en la toma de datos de los alumnos de un centro escolar existirán varias variables para poder introducir los datos de los alumnos. Estas variables pueden tener nombre tales como: Nombre Apellido1 Apellido2 Dirección Teléfono Cédula La variable Nombre tomará valores distintos según vayamos introduciendo los datos de los distintos alumnos. Es posible, que a lo largo de la ejecución del programa, esta variable Nombre valga: José Pedro María Luis En otros sistemas de programación distintos de VB, es necesario realizar la declaración de cada variable. VB permite que no se declaren. Cuando a lo largo del programa le introducimos una variable nueva, asume que es una variable y que el tipo es el adecuado para el valor que le estamos introduciendo en ese momento. Por ejemplo, si VB encuentra estas instrucciones Cedula=50000000 Nombre ="Pedro" Teléfono = "1234567" entiende que Cedula, Nombre y Teléfono son variables, que Cedula es un número (porque no hemos escrito su valor entre comillas), y que Nombre y Teléfono son sucesiones de caracteres alfanuméricos (su valor está entre comillas) Esta particularidad de no necesitar declarar las variables hace que sea sencillo introducir una variable nueva. Sin embargo genera un gran peligro. Imagínese que en un paso posterior del programa, le mandamos escribir esos tres datos anteriores con la instrucción PRINT Print Cedula Print Nombre Print Telwfono Aparece en tercer lugar la palabra Telwfono, que por error ha introducido el programador. VB interpreta que Telwfono es una variable e irá a leer en memoria el valor que tiene. No tendrá ningún valor. Por lo tanto no escribirá nada y no dará ningún aviso de que se ha cometido un error. La facilidad para introducir variables sin definir se paga con la posibilidad de un error. La solución a este problema es la sentencia: OPTION EXPLICIT

Obliga a declarar previamente las variables que se vayan a usar. De no haberla declarado antes de usarla, el programa dará una mensaje de error.

NOTA: Luego de leer este capítulo puede leer el artículo de notación húngara (más

abajo) para tener una guía de que criterio usar para nombrar las variables.


TIPOS DE VARIABLES Las variables pueden ser de los siguientes tipos:

Tipo de datos Tamaño de almacenamiento

Intervalo

Byte 1 byte 0 a 255

Boolean 2 bytes True o False

Integer 2 bytes -32,768 a 32,767

Long (entero largo)

4 bytes -2,147,483,648 a 2,147,483,647

Single (coma flotante/ precisión simple)

4 bytes -3,402823E38 a –1,401298E-45 para valores negativos; 1,401298E-45 a 3,402823E38 para valores positivos

Double (coma flotante/ precisión doble)

8 bytes -1,79769313486232E308 a -4,94065645841247E-324 para valores negativos; 4,94065645841247E-324 a 1,79769313486232E308 para valores positivos

Currency (entero a escala)

8 bytes -922.337.203.685.477,5808 a 922.337.203.685.477,5807

Decimal 14 bytes +/-79.228.162.514.264.337.593.543.950.335 sin punto decimal; +/-7,9228162514264337593543950335 con 28 posiciones a la derecha del signo decimal; el número más pequeño distinto de cero es +/-0,0000000000000000000000000001

Date 8 bytes 1 de enero de 100 a 31 de diciembre de 9999

String (longitud variable)

10 bytes + longitud de la cadena

Desde 0 a 2.000 millones

String (longitud fija)

Longitud de la cadena

Desde 1 a 65.400 aproximadamente

Variant (con números)

16 bytes Cualquier valor numérico hasta el intervalo de un tipo Double

Variant (con caracteres)

22 bytes + longitud de la cadena

El mismo intervalo que para un tipo String de longitud variable

Cada tipo de variable ocupa unos determinados bytes. Si no se define una variable, VB toma como tipo por defecto para la variable el tipo Variant. Este tipo ocupa mas bytes que, por ejemplo, un integer. Si el tipo de dato que vamos a introducir en una variable es un integer, y no la hemos declarado como tal, VB asumirá para esa variable que es del tipo Variant, lo que le llevará a gastar mas bytes de memoria (16) que los que necesitaría (2) si la hubiésemos declarado previamente. Si esa variable va a estar en el rango de 0 a 255, y no declaramos previamente que la variable va a ser del tipo Byte, o la declaramos como integer, estamos desperdiciando memoria RAM y posiblemente, retardando la ejecución del programa. Lo mismo podemos decir del resto de las variables: lo importante es definirlas y definirlas bien.


NOTA. Observe en la lista anterior que un dato Booleano ocupa 2 Bytes, mientras que un dato tipo Byte ocupa un byte. En muchas ocasiones declaramos variables tipo Boolean con la intención de que ocupen menos espacio. Eso no ocurre así. Si la declaramos como Byte ocupamos menos espacio en memoria. Declarar una variable como Boolean tiene también sus ventajas (escribirá menos código por lo general cuando necesite leer o escribir una variable tipo Boolean), pero tenga presente esta observación respecto a los datos Boolean. Ejemplos Prácticos de declaración de variables En Visual Basic, cuando declaramos una variable como String (Cadena de caracteres), no es necesario declarar su longitud. VB aceptará cualquier número de caracteres. Si desea evitar que se puedan introducir más de un determinado número de caracteres, debe declarar su número. Por ejemplo : Dim Var1 as String ‘Var1 puede tener cualquier número de caracteres Dim Var2 as String * 15 ‘Var2 puede tener un máximo de 15 caracteres. En este segundo caso, si se introduce como Var2 una cadena de caracteres con mas de 15 caracteres, Var2 tomará solamente los 15 primeros. Visual basic no presenta ningún aviso de que esa variable ha omitido los caracteres que han sobrepasado la cifra de 15. Si desea que el usuario conozca esa circunstancia, debe introducir el código oportuno para producir el aviso. La declaración de variables tipo String con número de caracteres predefinido presenta también inconvenientes a la hora de tratar esa cadena de caracteres con sentencias tales como Mid, Left y Right, o a la hora de añadir una cadena a otra. La experiencia indica que NO merece la pena declarar variables tipo String con el número de caracteres prefijado. En todos los casos que una variable almacene número pero si el número no representa una cantidad numérica, es mejor declararla como String. Por ejemplo: el número de cédula, el número de celular, el código postal... ¿Qué variables debemos declarar como numéricas ? Aquellas que van a contener datos con lo que vamos a realizar operaciones matemáticas. Las variables booleanas (True/False) pueden en muchos casos sustituirse por una variable del tipo Byte. Si ese datos True / False se va a introducir en una base de datos o en un archivo en el disco, puede ser mas prudente poner 0 en vez de False y 1 en vez de True. Una variable byte ocupa muy poco, simplemente 1 byte como su nombre indica. Pero no puede contener números mayores de 255 ni números negativos. Cada vez que declare una variable numérica piense en los valores que puede tener, sobre todo cuando esa variable va a ser el resultado de una operación matemática. Recuerde el escaso margen de una variable tipo Integer ( de -32768 a 32767) Si la aplicación va a tratar moneda, piense en la forma de expresar los números decimales y el número de ellos permitidos, así como el redondeo. La variable correcta para este caso es Currency, pero Currency le añade automáticamente el tipo de moneda de cada país (Pts. Para España, $ para Uruguay) lo que podría generar problemas estéticos. Los datos del tipo de moneda los toma del sistema operativo de la computadora, por lo que no se extrañe si le expresa el número de pesetas en dólares. Cambie el país en su Sistema Operativo. Ambito de las variables. Denominamos ámbito de una variable a las partes del programa donde esa variable está declarada. Si se declara una variable dentro de un procedimiento o Función, esa variable "NO SALE" del Procedimiento o Función donde se declaró. El procedimiento puede estar en un Formulario o en un Módulo


En un Formulario, una variable puede declararse de dos formas: Privada o Pública . Para declarar una variable a nivel de formulario debe hacerse en la sección de declaraciones, que está la ventana de código Objeto = General, Proc. = Declaraciones. Si se declara Privada , esa variable se puede mover por todo el formulario, (es decir, por todos los procedimientos de todos los controles del formulario y por los Procedimientos que pudiésemos insertar en ese formulario), pero no sale de dicho formulario. Si se declara como Pública , esa variable puede moverse por todo el formulario, de la misma forma que lo haría declarada como Privada, y además puede ser usada desde otro Formulario o Módulo, citándola con el nombre del Formulario, seguido del nombre de la variable (Formulario.Variable) En un Módulo una variable puede declararse como Privada , con lo que no saldrá de ese Módulo, o Pública , pudiendo en este caso usarse en todo el programa. Cuando se declara una variable como pública en un Módulo, basta referirse a ella por su nombre, sin citar el nombre del Módulo donde se declaró. En VB es posible declarar varias veces las variables, es decir, pueden declararse a nivel de formulario, en su apartado de declaraciones, y esa variable conservará su valor en todas las partes de ese formulario. Sin embargo, si se declara una variable con el mismo nombre a un nivel inferior, por ejemplo al principio de un procedimiento, esa variable será una variable distinta a la anterior, aunque tenga el mismo nombre, a al declararla en un Procedimiento, solamente será válida en ese Procedimiento. Una vez que hayamos salido de ese procedimiento, la variable con ese nombre volverá a ser la declarada en el Formulario. En realidad, lo que tenemos son dos variables distintas, pero con el mismo nombre, una declarada para todo el formulario excepto para el procedimiento donde se volvió a declarar, y otra para ese procedimiento concreto. NOTA.- No es recomendable declarar una variable a dos niveles. Es mucho mejor utilizar otro nombre para esa variable dentro del procedimiento donde se le declararía por segunda vez. Una excepción es cuando declaramos variables para una operación tipo contador For I = 1 To N Esa variable I es práctico declararla con el mismo nombre en cada Procedimiento donde se use. Tipos de declaración de variables. Sentencia DIM Es la forma mas común de declarar una variable como Privada. Puede emplearse en un Procedimiento, Función, Formulario o Módulo. La sintaxis es: Dim nombre_variable As un_tipo_de_variable Declarando una variable con la sentencia DIM, en un formulario, Función, procedimiento o módulo, el entorno de la variable será declarada como Privada. Es decir, esa variable no sale del formulario, procedimiento ó módulo donde se declaró. Cada vez que entremos al formulario, procedimiento o módulo, esa variable tomará el valor cero (si es numérica) o nulo (si es string). Sentencia PRIVATE Es la forma de declarar una variable como Privada. Puede emplearse solamente en la sección de declaraciones de un Formulario o Módulo. La sintaxis es de la siguiente forma: Private nombrevariable As Tipovariable Declarando una variable mediante la sentencia PRIVATE en un Formulario o Módulo, esa variable puede usarse en todo ese Formulario o Módulo (En todos sus Procedimientos y Funciones), pero NO fuera del Formulario o Módulo donde se declaró. La sentencia Private no puede usarse en un procedimiento o función. Sentencia PUBLIC Es la forma de declarar una variable como Pública. Puede emplearse solamente en la sección de declaraciones de un Formulario o Módulo. La sintaxis es de la siguiente forma:


Public nombrevariable As Tipovariable Declarando una variable de esta forma en la sección de declaraciones de un Módulo, esa variable puede usarse en cualquier parte del programa citándola simplemente por su nombre. Si se declara de esta forma en la sección de declaraciones de un Formulario, esa variable puede usarse en toda el programa. Para nombrarla, si estamos en el Formulario donde se declaró basta con citarla por su nombre. Si no estamos en ese Formulario, habrá que citarla por el nombre del Formulario, seguido del nombre de la variable, separados por un punto : NombreFormulario.Nombrevariable En un Módulo puede usarse también la sentencia Global en vez de Public : Sentencia GLOBAL Declara una variable que es válida en todo el programa. La sintaxis es: Global nombrevariable As tipovariable La sentencia Global sólo puede usarse en el apartado de declaraciones de un Módulo. Mediante la sentencia Global la variable puede usarse en todo el espacio del programa. Sentencia STATIC Una variable declarada en un procedimiento pierde su valor al salir de él y una vez que el programa vuelva a entrar en ese procedimiento, la variable estará puesta a cero. Si declaramos una variable en un procedimiento o función, como estática, esa variable, aunque no la podremos utilizar fuera de ese procedimiento o función, cuando volvamos a él conservará el valor que tenía cuando lo abandonamos. Esta declaración como estática se realiza mediante la intrucción Static Static nombrevariable As tipovariable El nombre de una variable puede tener a 1 a 40 caracteres. En la versión VB en español se pueden usar incluso la Ñ y vocales acentuadas. Es indiferente usar mayúscula ó minúsculas. No se sorprenda, si por ejemplo, la ha declarado con mayúsculas y luego la cita con minúsculas al escribir el código, que automáticamente se cambie a mayúsculas. El nombre de una variable siempre debe comenzar por una letra. No hay problema por utilizar variables largas. Al compilar el programa no se lleva el nombre, es decir, no le va a ocupar mas espacio. Utilice siempre nombres que le definan la variable con algún sentido. Es muy útil a la hora de acordarse como se llaman, y sobre todo, a la hora de rehacer un programa que realizó hace seis meses. Pese a que Visual Basic no obliga a declarar variables, es muy útil hacerlo. De esta forma se tiene control sobre el programa. Error típico de un programador básico de Visual Basic Costumbre que viene del lenguaje C. Pero no funciona en VB. Se trata de declarar varias variables juntas en una misma línea : Dim Variable1, Variable2, Variable3, Variable4 As String Esta declaración está MAL hecha. Visual Basic interpretará que Variable1, Variable2 y Variable3 son del tipo Variant, y solamente Variable4 la supone como tipo String La forma correcta de hacerlo, si queremos declarar esas variables un una sola línea, es la siguiente : Dim Variable1 As String, Variable2 As String, Variable3 As String, Variable4 As String.


NNoottaacciióónn HHúúnnggaarraa Cuando escribimos el nombre de una variable es más fácil saber que la variable "Nombre" guarda un nombre que si la variable se llamara "n". Aunque se acostumbra a usar por ejemplo, en el uso de las variables i, j, k para los bucles. Los identificadores tanto de variables, funciones y procedimientos constituyen una buena parte del código. Su elección es muy importante ya que normalizan el código, y ayudan a entender el significado real de las acciones que realizan. Es muy importante usar una nomenclatura bien definida en nuestra código, ya que aumenta enormemente la legibilidad y la semántica del mismo y hace más sencillo el trabajo en equipo y la supervisión por parte de otras personas . La nomenclatura más ampliamente extendida es la ‘Notación Húngara’, que presupone que es mucho más importante dar información en los nombres de los identificadores que poder leer el código en voz alta. Una de las ideas centrales en esta notación es la del uso de prefijos que incluyan información sobre el tipo de los identificadores. El prefijo es la letra o letras (normalmente tres), que se usan delante del nombre de la variable, por ejemplo, las variables del tipo Integer se declararían así: Dim iContador As Integer

Dim sNombre As String

. Pero esto de los prefijos no sólo se aplican a las variables, también se hace a los controles y formularios. Por ejemplo:

Objeto Prefijo Objeto Prefijo

Label lbl

CheckBox chk Line lin

ComboBox cbo ListBox lst

CommandButton Cmd o btn OLE ole

CommandGroup cmg OptionButton opt

Control ctl Shape shp

EditBox edt Spinner spn

Form frm TextBox txt

Grid grd Timer tmr

HyperLink hpl Recordset rs

Image img

Tipo

Letra

Arreglo a Caracter c Moneda y Fecha d Fecha y Hora t Doble b Flotante f Lógico l Numérico n Objeto o Desconocido u


UUssaa ccoommeennttaarriiooss eenn ttuuss pprrooggrraammaass Y es que los comentarios, entre otras cosas, no ocupan espacio en el programa una vez compilado y a la larga, siempre es a la larga, ya que cuando el código está reciente, nos acordamos de todo... pero cuando se lee después de pasado algunos meses... al estar revisando programas antiguos, no se entiende lo que hace el código. Por tanto, si no quieres verte en este aprieto, usa y abusa de los comentarios, aunque sea un poco "pesado". Se se agradece, sobre todo si el código cae en manos de otro programador, por ejemplo en un grupo de trabajo y tiene que entender lo que "pretendías" hacer... Es de extrema importancia documentar el código que creamos. La razón principal de esto es que el mismo código pueda ser interpretado por otros programadores y por uno mismo luego de haber olvidado que se escribió y por qué. Para comentar se usa el apóstrofe (comilla simple) al principio de la línea o en medio. Lo que quede a su derecha será un comentario que no leerá el compilador. ‘ Se verifica que se haya escrito algo en el campo proveedor If Len(lblProveedor) = 0 Then MsgBox "Por favor indique el proveedor.", , "Faltan Datos" Exit Sub End If No se trata de escribir cosas como “Este es el código cuando se le hace clic al botón de aceptar”, no, realmente se trata de colocar un material para interpretar y entender en otra ocasión. Hay escribir toda la información que se considere necesaria y que no tenga que depender de nuestra memoria para recordar un proceso o procedimiento. Todos los procedimientos y funciones deben comenzar con un comentario breve que describa las características funcionales del procedimiento (qué hace). Esta descripción no debe describir los detalles de implementación (cómo lo hace), porque a veces cambian con el tiempo, lo que da como resultado un trabajo innecesario de mantenimiento de los comentarios o, lo que es peor, comentarios erróneos. El propio código y los comentarios de líneas necesarios describirán la implementación. Los argumentos que se pasan a un procedimiento se deben describir cuando sus funciones no sean obvias y cuando el procedimiento espera que los argumentos estén en un intervalo específico. También hay que describir, al principio de cada procedimiento, los valores de retorno de funciones y las variables globales que modifica el procedimiento, en especial los modificados a través de argumentos de referencia Nunca debemos olvidar que mientras mas ordenada y estandarizada resulte nuestra codificación, mas cómodo y fácil será revisar nuestro trabajo por nosotros en el futuro o por cualquier otro desarrollador en cualquier parte del mundo.


SSeenntteenncciiaass ccoonnddiicciioonnaalleess.. Llamamos sentencias condicionales a aquellas que se realizan si se cumple una determinada condición. La sentencia condicional mas usada es: Si se cumple una condición Entonces Realiza estas instrucciones Si no se cumple Realiza estas otras instrucciones Fin de la sentencia. Así se escribiría en pseudocódigo, en VB toma la siguienteforma: If condición Then Instrucciones Else Otras instrucciones End If En este ejemplo, la condición era que, o se cumple una condición y ejecuta unas determinadas instrucciones, o no se cumple, y ejecuta otras condiciones distintas. Puede ocurrir que, caso de no cumplirse la condicione primera, se abra un abanico de dos o tres posibilidades. La sentencia condicional tendría entonces la forma: If condición1 Then Instrucciones ElseIf Condición2 Otras instrucciones ElseIf Condición3 Otro juego de instrucciones Else Instrucciones que debe realizar caso de no cumplir las condiciones 1, 2 y 3. End If Existe otra muy usada: Select Case Selecciona, dependiendo del caso, un determinado juego de instrucciones: Select Case variable Supongamos que esta variable puede tomar valores de 1 a 4 Case 1 Instrucciones a ejecutar en caso de que variable = 1 Case 2 Instrucciones a ejecutar en caso de que variable = 2 Case 3 Instrucciones a ejecutar en caso de que variable = 3 Case 4 Instrucciones a ejecutar en caso de que variable = 4 End Select Este procedimiento resulta mucho mas sencillo y rápido que las sentencias If Then Else vistas anteriormente, cuando el margen de elección es mayor que 2. Con estas sentencias condicionales es posible realizar bifurcaciones del programa, cambiar las propiedades de un objeto, obtener resultados de operaciones, ....


SSeenntteenncciiaass ddee bbuuccllee Es muy común utilizar bucles a lo largo de un programa. Un bucle es una sucesión repetitiva de instrucciones, que se estarán realizando mientras se cumpla una condición o mientras no se cumpla otra condición. Por ejemplo: Mientras condición Instrucciones Fin del bucle Existen dos formas de bucle: Una, que realiza un número determinado de recorridos por el bucle. Es el denominado bucle por contador. Otra, realiza el bucle hasta que se cumpla (o deje de cumplirse) una condición. Es el llamado bucle por condición. Bucle por contador Realiza el bucle tantas veces como le indiquemos. Por ejemplo, en este bucle nos va a presentar las 26 letras mayúsculas del alfabeto inglés For N=65 To 90 Label1.caption = Chr ( N ) Next Este "programa" nos presentará en una caja (Label) los caracteres cuyo número ASCII vaya desde el 65 (A) al 90 (Z) Comenzará presentando el correspondiente al número 65, e irá presentando sucesivamente el 66, el 67, etc., hasta llegar al 90, donde se parará. Bucles por condición Ejecuta las instrucciones del bucle mientras se cumple una condición X = 0 Do While X < 1000 X = X + 1 Loop El programa toma una variable ( X ) que previamente tuvimos la curiosidad de ponerla a cero, e incrementa su valor una unidad. Analiza si el valor de X es menor que 1000, y si es cierto, vuelve a realizar el bucle. Así hasta que X ya no sea menor que 1000. Al dejar de cumplirse que X sea menor que 1000, sale del bucle. Acabamos de realizar un temporizador, y también de exponer las sentencias condicionales y los bucles, inicio de cualquier curso de Basic. Como final de lección, se propone un problema. Con el primer bucle, donde visualizábamos los caracteres A a la Z, posiblemente no nos diese tiempo de ver cada una de las letras que iban apareciendo en la pantalla, en la etiqueta Label1, dado que cambiaría con mucha velocidad, y solamente veríamos la Z, que es donde se detuvo el programa. Podemos poner un temporizador cada vez que presente una letra, y así nos dará tiempo a verla. Con los dos bucles vistos anteriormente ya podemos hacerlo. Si lo que queremos es que el programa se ejecute mientras no se cumpla una determinada condición, la sentencia será: X = 0 Do Until X > 1000 X = X + 1 Loop


Observe que la diferencia entre una y otra es la condición, While para indicar Mientras se cumpla que ... y Until para indicar Mientras no se cumpla que .... Para terminar bien el programa anterior utilizaremos la condición de While (Mientras se cumpla la condición) For N=65 To 90 Label1.caption = Chr ( N ) Label1.Refresh ' Refresca la etiqueta X = 0 Do While X < 1000 X = X + 1 Loop Next N Este es nuestro primer programa en BASIC. En VISUAL BASIC es idéntico, pero nos falta la interface gráfica. Para realizarla basta con abrir el VB y sobre el formulario que aparece al abrirlo, introducir una etiqueta, (Label) que llevará el nombre por defecto de Label1. Solo nos queda pensar donde introducimos el código anterior. Podemos introducir un botón de comando (Command Button) que saldrá con el nombre por defecto de Command1. Haga doble click sobre el botón. Aparecerá el procedimiento Click. Este procedimiento es el que se realiza cuando hacemos click sobre ese botón. Escriba en ese procedimiento este código. Private Sub Command1_Click() ' Esta línea sale automáticamente For N=65 To 90 Label1.caption = Chr ( N ) Label1.RefreshN ' Refresca la etiqueta X = 0 Do While X < 1000 ' Bucle de temporización X = X + 1 Loop Next N ' Termina el bucle de temporización End Sub ' Esta línea sale automáticamente Hemos puesto nuestra primera piedra en Visual Basic. Este ejemplo es muy sencillo. Visual Basic es tan sencillo como este ejemplo.


TTeexxttBBooxx Los TextBox o cuadros de texto se usan para ingresar datos. Permite que el usuario escriba y modique el contenido del objeto. Los datos ingresados son almacenados en la propiedad TEXT. A continuación se enumeran algunas propiedades de los TextBox. Las propiedades comunes con otros objetos ya analizados no se incluyen.


Aligment Determina si el texto aparece justificado a la izquierda, derecha o centrado en los límites del cuadro de texto. Para que funcione debe establecer previamente la propiedad Multiline.

BorderStyle Determina si una línea bordea al cuadro de texto.

Enabled Determina si un cuadro de texto está activo. En ocasiones cambiará esta propiedad en tiempo de ejecución si no ocupa el cuadro.

Locked Determina si el usuario puede editar el texto.

MaxLength Especifica la cantidad de caracteres que puede teclear el usuario.

MultiLine Permite que el cuadro de texto maneje el texto en una o varias líneas. Agregue barras de desplazamiento si desea que los usuarios puedan desplazar las líneas del texto.

PasswordChar Determina el carácter que aparece cuando el usuario teclea una contraseña (evita que los curiosos sepan lo que el usuario tecleó.)

ScrollBars Determina qué barras de desplazamiento aparecerán.

Text Contiene el texto del cuadro. Esta propiedad cambia en tiempo de ejecución conforme el usuario teclea. Si establece un valor inicial para esta propiedad, este valor será el que aparezca de forma predeterminada cuando el usuario se encuentre inicialmente con el cuadro de texto.

Visible Determina si el usuario puede ver o no el cuadro de texto.


PPrrooppiieeddaaddeess ccoommuunneess ddee llooss ffoorrmmuullaarriiooss Se listan a continuación algunas propiedades que poseen los formularios. No se incluyen las propiedades en común con otros objetos ya analizados.


BorderStyle Determina cómo aparece la ventana. Esta propiedad especifica si el usuario puede cambiar el tamaño o clase de formulario que desea desplegar.

Caption Despliega un mensaje en la barra de título.

Control Box Determina si el formulario aparece con el icono del menú Control. Este menú aparece cuando el usuario hace clic en el icono del extremo izquierdo de la barra de título.

Enabled Determina si el formulario está activo. Algunas veces cambiará esta propiedad en tiempo de ejecución cuando no se necesite el formulario. Generalmente, sólo aquellas aplicaciones que usen varios formularios, como las MDI, requieren modificar esta propiedad.

Icon Contiene el icono que se desplegará en la barra de tareas cuando el usuario minimice el formulario.

Left Tiene la cantidad de twips que hay desde el extremo izquierdo del formulario hasta el extremo izquierdo de la pantalla.

Max Button Especifica si el botón Maximizar aparecerá en la barra de título.

Min Button Especifica si el botón Minimizar aparecerá en la barra de título.

Moveable Especifica si el usuario puede mover el formulario en tiempo de ejecución.

Picture Determina la imagen de fondo que aparecerá en el formulario.

ScaleMode Determina si las medidas del formulario se darán en twips, pixeles (el punto gráfico más pequeño posible), pulgadas, centímetros, u otras medidas.

ShowInTaskbar Determina si el formulario aparecerá en la barra de tareas de Windows.

StartupPosition Determina el estado (centrado o predeterminado) del formulario cuando inicia la aplicación.

Top Contiene la cantidad de twips que hay desde el extremo superior del formulario, hasta el extremo superior de pantalla.

WindowState Determina el estado inicial (maximizado, minimizado, normal) en el que la venta aparecerá en el principio de la ejecución


SShhaappee Un Shape es una figura que podemos agregar al formulario, la cual podemos cambiar en tiempo de diseño o de ejecución. Se utilizan las siguientes propiedades: Shape Determina el tipo de formas que se dibujará. (0-Rectángulo, 1-Cuadrado, 2-

Elipse, 3-Círculo, 4-Rectángulo con bordes redondeados, 5-Cuadrado Redondeado)

BackStyle Determina si el fondo será transparente (0) o no (1) BorderColor Determina el color del contorno del objeto a dibujar BorderWidth Determina el grosor del contorno del objeto a dibujar BorderStyle Determina la forma del contorno del objeto a dibujar. (0-Transparente, 1-Sólido,

2-Rayas, 3-Puntos, 4-Rayas y Puntos, 5-Raya Punto Raya) FillColor, FillStyle El valor por defecto de la propiedad FillStyle es 1 - Transparente, por lo que si no

se cambia (0-Sólido, del 2 al 6-otros), el valor de la propiedad FillColor (color de relleno de la figura) no tendrá efecto

Cuando elegimos un cuadrado o un círculo al cambiar el Height automáticamente cambia el Width y viceversa.

BBaarrrraass ddee DDeessppllaazzaammiieennttoo Las barras de desplazamiento horizontal y vertical (HScrollBar y VScrollBar) informan de la posición del cuadro de desplazamiento dentro de la barra. Las propiedades que se suelen utilizar son: Value (valor) que contiene un número que representa la posición actual del cuadro de desplazamiento en el interior de la barra. LargeChange (gran cambio) representa el valor añadido o sustraído al número contenido en la propiedad Value cuando el usuario hace clic dentro de la barra de desplazamiento. Max (máximo) indica el valor de la propiedad Value cuando el cuadro de desplazamiento está en su posición más a la derecha o abajo posible. Min (mínimo) indica el valor de la propiedad Value cuando el cuadro de desplazamiento está en su posición más a la izquierda o arriba posible. SmallChange (cambio pequeño) representa el valor añadido o sustraído al número contenido en la propiedad Value cuando el usuario hace clic sobre una de las flechas de desplazamiento.


LLiissttBBooxx yy CCoommbbooBBooxx Estos dos controles, debido a su similitud, se estudian conjuntamente. Un control ListBox muestra una lista de elementos en la que el usuario puede seleccionar uno o más. Si el número de elementos supera el número que puede mostrarse, se agregará automáticamente una barra de desplazamiento al control ListBox. Un control ComboBox combina las características de un control TextBox y un control ListBox. Los usuarios pueden introducir información en la parte del cuadro de texto y seleccionar un elemento en la parte de cuadro de lista del control. En resumen, un ComboBox es la combinación de un ListBox, que se comporta como si de un ListBox se tratase, y de un TextBox, con comportamiento análogo a un TextBox sencillo, con la particularidad aquí de que el texto se le puede introducir por teclado, o elegir uno de los que figuran en la parte ListBox del Combo. Estos controles toman la siguiente forma : Puede verse en la figura un ejemplo de presentación de un ListBox (izquierda), un ComboBox con la lista desplegada (Centro) y un ComboBox con la lista sin desplegar (Combo2 a la derecha). La lista tiene varios elementos. Cada línea de esta lista es un elemento de la lista. Como el número de elementos de la lista tiene mas elementos de los que le podían caber, generó automáticamente la barra de desplazamiento vertical. El ComboBox está normalmente sin desplegar. Se despliega cuando se hace click con el ratón en la flecha que tiene en su parte derecha. Al desplegarse, muestra la lista con todos sus elementos. Haciendo click con el ratón en cualquiera de sus elementos, el elemento elegido pasa a la parte TextBox del Combo y la lista vuelve a replegar. El ListBox (y por tanto el ComboBox) tiene unas propiedades y métodos particulares que solamente se pueden aplicar durante el tiempo de ejecución : ListCount - Indica el número de elementos que tiene la lista ListIndex - Indica el número de orden del elemento seleccionado dentro de la lista. AddItem - Añade un elemento a la lista. RemoveItem - Elimina un elemento de la lista. Text - Obtiene el elemento seleccionado. List (n) - Obtiene el elemento cuyo orden dentro de la lista es n. ListCount valdrá 0 si la lista no tiene ningún elemento, y n si tiene n elementos. Para seleccionar un elemento de la lista, basta con hacer click con el ratón sobre él. Ese elemento se resaltará con fondo en azul. Una vez seleccionado un elemento, la propiedad ListIndex tomará el valor del número de orden que ocupa ese elemento en la lista, comenzando por el 0 para el elemento que ocupa el primer lugar. Si no se selecciona ningún elemento, el valor de la propiedad ListIndex será -1. El primer elemento de la lista es ListIndex 0, y el valor de la propiedad ListCount siempre es uno más que el valor mayor de ListIndex. En el ComboBox la propiedad Text contiene el texto que contenga la parte TextBox del Combo, bien haya sido introducida desde teclado o mediante la recuperación de un elemento la parte ListBox del mismo. Ejemplos


Supongamos que tenemos un ListBox llamado List1, y un ComboBox llamado Combo1. Se enumeran distintas formas de obtener información de ellos. Variable = List1.Listcount

Variable contendrá un número con el número total de elementos de la lista List1. Variable = List1.ListIndex

Variable contendrá un número con el número de orden del elemento de la lista seleccionado en ese momento.

List1.AddItem "ELEMENTO NUEVO" Añade un elemento a List1. En este caso, el elemento añadido son las palabras ELEMENTO NUEVO.

Variable = "VISUALBASIC" List1.AddItem Variable

Añade un elemento a List1. En este caso, el elemento añadido es la palabra VISUALBASIC. Variable = List1.Text

Variable contendrá el elemento que estaba seleccionado en List1. (Variable será una cadena de caracteres)

Variable = List1.List (n) Variable contendrá el elemento que ocupa el número de orden n dentro de la lista.

Variable = List1.List (List1.ListIndex) Variable contendrá el elemento que estaba seleccionado en List1. Se ha utilizado la propiedad List para obtener el elemento, y en vez de introducir un número para definir el elemento que se desea, se introdujo el valor ListIndex de List1, que es concretamente, el número de orden del elemento seleccionado en ese momento. Observe que poner List1.List (List1.ListIndex) es idéntico a poner List1.Text.

List1.RemoveItem (n) Elimina el elemento n de List1.

List1.RemoveItem (List1.ListIndex) Elimina el elemento que estaba seleccionado en ese momento.

List1.listIndex = n Selecciona el elemento n de List1 (Se resalta en azul el elemento n)

PROPIEDADES DE LISTBOX Y DE COMBOBOX Columns (Propiedad de ListBox solamente) Determina si los elementos se presentan en una sola columna o en varias columnas, y la forma de presentar los elementos en el ListBox. Si esta propiedad se pone a 0 la lista tendrá solamente una columna, y presentará los elementos uno debajo de otro. Cuando los elementos sean mas que los que se pueden presentar en la lista, aparecen automáticamente unas barras de desplazamiento vertical. Si la propiedad se pone a un número distinto a 0, el ListBox es de tipo multicolumna, presentará en cada columna los elementos que le quepan dependiendo de su dimensión vertical, y tendrá tantas columnas como sea necesario para albergar el número de elementos que tenga. Presentará en su cuadro tantas columnas como se le indique en el valor de esta propiedad, y si no puede presentar todos los elementos en las columnas que muestra, le aparecerán barras de desplazamiento horizontales para poder movernos por todas las columnas que tenga. Recuerde : El número que se le asigna a la propiedad Columns no indica el número de columnas que tendrá el ListBox sino el número de columnas que presenta. Esta propiedad puede asignarse en diseño, mediante la caja de propiedades, o en tiempo de ejecución mediante una instrucción como esta :

Nombrelista.Columns = número Esta propiedad no puede definirse a 0 o cambiada desde 0 en tiempo de ejecuciones decir, no se puede convertir en tiempo de ejecución un ListBox de múltiples columnas en un ListBox de columna única o un ListBox de columna única en un ListBox de múltiples columnas. Sin embargo, sí es posible cambiar durante la ejecución el número de columnas de un ListBox de múltiples columnas. DataField DataSource

Establecen la base de datos y el campo donde están los datos que se llevarán al TextBox o ComboBox para presentar datos procedentes de una Base de Datos


ItemData Devuelve o establece un número específico para cada elemento de un control ComboBox o ListBox. Sintaxis: objeto.ItemData(índice) [= número] La sintaxis de la propiedad ItemData tiene las siguientes partes: objeto Nombre del ListBox o ComboBox. índice El número de un elemento concreto del objeto. número El número que se asocia con el elemento especificado. La propiedad ItemData es una matriz de valores enteros largos cuyo número de elementos es el valor de la propiedad ListCount del control. Los números asociados con cada elemento se pueden usar para cualquier fin. Cuando se rellena el ListBox, también se rellena los elementos correspondientes de la matriz ItemData con los números correspondientes. Nota Cuando se inserta un elemento en una lista con el método AddItem, el elemento también se inserta automáticamente en la matriz ItemData. Sin embargo, el valor no se reinicializa a cero; retiene el valor que estaba en esa posición antes agregar el elemento a la lista

List Es el contenido de la lista. Si la lista de elementos es corta e invariable, pueden introducirse los elementos en el cuadro de propiedades durante el diseño. Se obtiene un valor de la lista escribiendo:

Objeto.List(indice) Sorted

Establece o devuelve un valor que indica si los elementos de un ListBox o ComboBox se colocan automáticamente en orden alfabético. Los valores que puede adoptar son True o False. True Los elementos de la lista se ordenan alfabéticamente (sin distinguir entre mayúsculas y minúsculas). False (Predeterminado) Los elementos de la lista no se ordenan alfabéticamente. Cuando esta propiedad tiene el valor True, Visual Basic se encarga de casi todo el procesamiento de cadenas necesario para mantener el orden alfabético, incluyendo el cambio de los números de índice cuando se agregan o eliminan elementos. Nota El uso del método AddItem para agregar un elemento en una posición específica de la lista puede romper el orden alfabético, y los elementos agregados con posterioridad pueden no ordenarse correctamente.


FFrraammee ((RReeccuuaaddrroo)) Tiene la siguiente forma :

Un control Frame proporciona un agrupamiento identificable para controles. También puede utilizar un Frame para subdividir un formulario funcionalmente por ejemplo, para separar grupos de controles OptionButton. Para agrupar controles, en primer lugar trace el control Frame y, a continuación, meta los controles dentro de Frame. De este modo podrá mover al mismo tiempo el Frame y los controles

que contiene. Si traza un control fuera del Frame y, a continuación, intenta moverlo dentro de éste, el control se colocará sobre el Frame, pero no pertenecerá a el. Es decir, si es un OptionButton este se comportará como si estuviese fuera del Frame, aunque físicamente esté dentro de el. Cuando un control Frame tiene dentro otros controles, y hacemos invisible al Frame, mediante su propiedad Visible = False, los controles interiores al Frame quedan también invisibles. Caption Es el título que aparece en el borde del Frame ClipControls

Si esta propiedad está a True, los métodos gráficos en eventos Paint vuelven a dibujar el objeto entero. Antes del evento Paint se crea una zona de recorte alrededor de los controles no gráficos del formulario. Si esta propiedad está a False dibujarán solamente las áreas últimamente expuestas. En tiempo de ejecución, esta propiedad es de sólo lectura

Enabled

Cuando esta propiedad está a False, tanto los procedimientos asociados al propio control Frame como todos los controles dentro del Frame estarán inhabilitados. Si esta propiedad está a True, todos ellos están habilitados.

Font

En esta propiedad, el tipo de letra afecta solamente al título del Frame, no a los controles internos a el.

ForeColor Color de las letras del título del Frame Visible

Cuando un Frame está con la propiedad Visible = False, tanto el propio Frame como todos los controles interiores a el serán invisibles

CChheecckk BBuuttttoonn yy OOppttiioonn BBuuttttoonn ((bboottoonneess ddee eelleecccciióónn yy ooppcciióónn)) Dada la similitud de ambos controles, se comentan conjuntamente. El control CheckBox, o casilla de verificación, permite elegir una opción (activada/desactivada, True/False) que el usuario puede establecer o anular haciendo click. Una X en una casilla de verificación indica que está seleccionada, activada, o con valor True. Cada casilla de verificación es independiente de las demás que puedan existir en el formulario, pudiendo tomar cada una de ellas el valor True o False, a voluntad del operador. Un control OptionButton muestra una opción que se puede activar o desactivar, pero con dependencia del estado de otros controles OptionButton que existan en el formulario. Generalmente, los controles OptionButton se utilizan en un grupo de opciones para mostrar opciones de las cuales el usuario sólo puede seleccionar una. Los controles OptionButton se agrupan dibujándolos dentro de un contenedor como un control Frame, un control PictureBox o un formulario. Para agrupar controles OptionButton en un Frame o PictureBox, dibuje en primer lugar el Frame o PictureBox y, a continuación, dibuje dentro los controles OptionButton. Todos los controles OptionButton que están dentro del mismo contenedor actúan como un solo grupo, e independientes de los controles OptionButton de otros grupos distintos. Aunque puede parecer que los controles OptionButton y CheckBox funcionan de forma similar, hay una diferencia importante: Cuando un usuario selecciona un OptionButton, los otros


controles del mismo grupo OptionButton dejan de estas disponibles automáticamente. Por contraste, se puede seleccionar cualquier número de controles CheckBox. En el ejemplo de la figura, existen tres grupos de OptionButton, uno en un PictureBox, que actúa, al tiempo que como cuadro de imagen, como contenedor de controles OptionButton. Otro grupo está en el interior de un control Frame, y el otro grupo está en el formulario. Los tres grupos son independientes entre sí, pero interiormente al grupo solamente puede seleccionarse uno de los OptionButton que lo componen. En el formulario también existen tres CheckBox, que como puede verse, se pueden seleccionar los que se desee, sin ningún tipo de exclusión entre ellos. Alignment Común a ambos controles. Admite los siguientes valores :

0 - Left Justify 1 - Right Justify Cuando se elige el valor 0, justificado a la izquierda, el título del control aparece a la derecha del botón, pegado a la figura del botón. Cuando se elige el valor 1, justificado a la derecha, el título (Caption) aparece a la izquierda del botón, comenzando en la parte izquierda del cuerpo total del control, es decir, no tiene porqué aparecer con su parte derecha pegado al botón, caso que el cuerpo total del control se haya hecho mas largo que la palabra del título

DataField DataSource

Propiedades del CheckBox solamente. Establecen la base de datos y el campo donde están los datos (True / False) que se llevarán a la propiedad Value . Al igual que en los controles Label y TextBox esta propiedad nos permite visualizar datos de una base de datos de una forma muy sencilla. En este caso, el CheckBox solamente permite presentar (lógicamente) datos de tipo Booleano.

Height Común a ambos controles La altura del control solamente afecta a la colocación del Titulo (Puede ponerse un título largo en varias líneas), no al tamaño del botón, que es invariable.

Value Común a ambos controles El valor de esta propiedad indica si el control está seleccionado (Value = 1) o no seleccionado (Value = 0 ó Value = False). Esta propiedad puede cambiarse en tiempo de ejecución. Mediante esta propiedad, podemos tanto forzar el valor como leerlo. Atención. Presenta una diferencia entre uno y otro control respecto a la forma de expresarse respecto a su valor cuando está seleccionado. Para forzar que el control NO esté seleccionado, o para leer el Value cuando no está seleccionado, podemos utilizar tanto Value = 0 como Value = False. Sin embargo, cuando lo que se quiere es poner la propiedad a True hay una diferencia entre ambos controles. Para el OptionButton podemos utilizar indistintamente las siguiente formas : Option1.Value = True Option1.Value = 1 Con cualquiera de ellas seleccionaremos ese control por programa. Para el CheckBox solamente se podrá usar para este propósito la instrucción : Check1.value = 1 El poner como Value el valor True nos dará en este control un error. Para la lectura del Value, existe una diferencia entre el valor devuelto por el CheckBox y el devuelto por el OptionButton. Para leer el dato existente en un CheckBox es necesario utilizar la forma :


variable = Check1.Value donde variable tomará el valor 1 (no True) Para el control OptionButton emplearemos una instrucción igual : variable = Option1.Value donde variable tomará el valor True (no 1)

TTIIMMEERR ((TTeemmppoorriizzaaddoorr)) Este objeto permite establecer temporizaciones. Este control solamente se ve durante el tiempo de diseño. En tiempo de ejecución, el control permanece invisible. La temporización producida por el Timer es casi independiente de la velocidad de trabajo del ordenador. No es un reloj exacto, pero se le parece Interval

El valor de esta propiedad nos dará el intervalo de tiempo (en milisegundos) en que se producirá un evento Timer y consecuentemente, realizará el procedimiento asociado a este evento. Si el valor de la propiedad Interval está a 0 (Predeterminado), no se produce el evento Timer. (El control Timer está deshabilitado cuando se pone la propiedad Interval = 0)

El procedimiento Timer se dispara cada vez que se cumple el tiempo indicado en Interval.


FFuunncciioonneess ddee ccaaddeennaass Se denomina CADENA o STRING a una sucesión de caracteres. Una cadena puede tener uno o varios caracteres alfanuméricos. Una cadena es también una sucesión de números. Ejemplo de cadenas: Curso de Visual Basic abcdefghijklmnopqrstuvwxyz1234567890 123456789 Hagamos una distinción entre una cadena que contenga números y un número. Un número tiene un valor, pero también tiene una presentación escrita. El valor es algo que estará en la computadora como una sucesión de bits. Dependiendo de como lo hayamos declarado, tendrá mas o menos bits. Pero esa información no es un número legible por el usuario. Lo que sí es legible por el usuario es la representación en numeración decimal (u octal, o hexadecimal, o incluso en binario) de ese número. Esa representación del número en un determinado sistema de numeración es una cadena. Así, el número nueve, que en la memoria del computadora será una sucesión de bits, el computadora puede presentárnoslo como: 9 En numeración decimal 9 En numeración hexadecimal 11 En numeración octal 1001 En numeración binaria Esas formas de presentarnos el número son CADENAS de caracteres. El valor del número dentro del computadora es un NUMERO. Para presentar un número en la pantalla, el computadora debe convertirlo previamente a una cadena. Cuando introducimos un valor numérico por teclado o pantalla, el computadora para hacer operaciones con él, debe transformarlo a un número. Estas consideraciones nos llevan a las dos primeras funciones con cadenas: Str (número) Convierte un número a una cadena en numeración decimal. Val (cadena numérica) Obtiene el valor (el número) correspondiente a esa cadena. Ejemplos Variablenumerica = Val (TextBox1.Text) Este ejemplo convierte la cadena de caracteres (numéricos) que hubiese en la caja de texto TextBox1 en un número, y asocia este número a la variable Variablenumerica. Si el contenido de la caja de textos no fuesen caracteres numérico (abcd, por ejemplo), Variablenumerica tomaría el valor 0. Label1.Caption = Str (Variablenumerica) Este ejemplo pondría en la etiqueta Label1 los caracteres correspondientes al valor que


tuviese la variable Variablenumerica . Nota para recordar: Siempre habrá que convertir un número a una cadena cuando queramos presentarlo en la pantalla. Siempre habrá que convertir a número la cadena de caracteres numéricos que hayamos introducido por teclado o por pantalla, cuando queramos operar con ese número. Un Label, cuando tiene que presentar un único número, no le pedirá que se lo convierta a cadena, pues VB hace automáticamente esa conversión. Sin embargo, cuando tiene que presentar un número, y además un texto en el mismo Label, VB no realizará automáticamente ese cambio, por lo que le dará un error. Le recomiendo que convierta los números a variables de cadena siempre que los quiera presentar en un Label o TextBox. Existe una función mas amplia que Str. Se trata de Cstr. Esta función no solamente transforma un número a una cadena, como hace Str, sino que convierte cualquier tipo de variable a una variable tipo String (cadena). Esta función transforma, por ejemplo, una variable tipo Booleana en una variable de cadena, devolviendo la cadena “Verdadero” si el valor de la variable booleana es True, y “Falso” si es False. Puede también transformar a una cadena de caracteres el valor de un CheckBox o de un OptionButton. En estos casos devuelve 0 y 1 para el CheckBox (Desactivado / Activado) y Verdadero ó Falso para el OptionButton (Activado / Desactivado) label1.Caption = CStr(booleana) Label1.Caption = Verdadero si booleana es true Label1.Caption = Falso si booleana es False Label2 = CStr(Check1.Value) Label2.Caption = 1 si Check1 está activado Label2.Caption = 0 si Check1 está desactivado Label3 = CStr(Option1.Value) Label3.Caption = Verdadero si Check1 está activado Label3.Caption = Falso si Check1 está desactivado Si se aplica Cstr a una variable tipo Fecha/Hora devuelve la fecha / Hora en formato corto. Mas funciones de cadena:

Left (cadena, n) Extrae los n primeros caracteres de una cadena, comenzando por la izquierda.

Si cadena = Curso de Visual Basic (Para todos los ejemplos) Resultado = Left (cadena, 10) ----> Resultado = Curso de V Right (cadena, n) Extrae lo n últimos caracteres de la cadena Resultado = Right (cadena, 10) ----> Resultado = sual Basic Mid (cadena, m, n) Extrae n caracteres de la cadena, siendo el primer carácter extraído el que ocupa el lugar m. (Vea Instrucción Mid mas abajo) Resultado = Mid (cadena, 3, 10) ----> Resultado = rso de Vis

LCase (cadena) Devuelve otra cadena igual, pero con todos los caracteres en minúsculas. (LCase = Lower Case)

Resultado = Lcase (cadena) ----> Resultado = curso de visual basic


UCase (cadena) Devuelve otra cadena igual, pero con todos los caracteres en mayúsculas. (UCase = Upper Case)

Resultado = UCase (cadena) ----> Resultado = CURSO DE VISUAL BASIC Len (cadena) Devuelve la longitud de la cadena Resultado = Len (cadena) ----> Resultado = 21 LenB (Cadena) Devuelve el número de Bytes empleados para almacenar la

cadena. Sorpréndase, es el doble que Len (Cadena) String (n, carácter) Devuelve una cadena de n caracteres como el indicado Resultado = String (8, "a") ----> Resultado = aaaaaaaa Resultado = String (8, Chr(65)) ----> Resultado = AAAAAAAA Resultado = String (8, 65) ----> Resultado = AAAAAAAA Space (n) Devuelve una cadena formada por n espacios. Resultado = "A" + Space (6)+ "B" ----> Resultado = A B LTrim Elimina los posibles espacios que tenga una cadena por su izquierda. Rtrim Elimina los posibles espacios que tenga una cadena por su derecha. Trim Elimina los espacios que tenga una cadena, tanto por su izquierda como por su derecha. (No elimina los espacios centrales de la cadena) Estas tres funciones se emplean para quitar los posibles espacios que pueden resultar de una entrada de datos. Tienen especial importancia cuando se toman los datos de un archivo o base de datos, donde fueron introducidos por otro programa. No se pone ningún ejemplo de estas funciones, pues sería difícil verlo impreso.

InStr (cadena, cadena1) Busca la cadena1 dentro de cadena y devuelve el número de orden dentro de cadena donde se encuentra la primera letra de cadena1

Resultado = InStr (cadena, "sua") ----> Resultado = 12 StrConv Convierte una cadena de caracteres en otra, según las instrucciones

que le sigan. Puede sustituir a UCase o LCase si la instrucción es UpperCase o LowerCase respectivamente, o poner la primera letra de

todas las palabras de la cadena en mayúsculas, si la instrucción es ProperCase.

Resultado = StrConv (cadena, UpperCase) ----> Resultado = CURSO DE VISUAL BASIC


Resultado = StrConv (cadena, LowerCase) ----> Resultado = curso de visual basic Resultado = StrConv (cadena, ProperCase) ----> Resultado = Curso De Visual Basic Instrucción Mid Mid puede usarse también para cambiar el contenido de una cadena. Observe la sutileza entre Mid como Función de cadena y Mid como Instrucción. La Instrucción Mid reemplaza un número especificado de caracteres en una variable de cadena con caracteres de otra cadena. Sintaxis Mid(cadena1, inicio[, longitud]) = cadena2 Resultado Mid (cadena, 7,2)=”Sobre” ---- > Resultado = Curso sobre Visual

Basic

FFuunncciioonneess CCoonn NNúúmmeerrooss Visual Basic puede operar con números tal como lo haría cualquier persona. Conoce las 4 reglas, y puede utilizar paréntesis de la misma forma que los escribimos sobre el papel. Los operadores que utiliza para las operaciones básicas son: + Suma - Resta * Multiplicación / División \ División sin decimales Mod Resto de una división ̂ Eleva a un exponente Ejemplos Resultado = 12 + 15 ----> Resultado = 27 Resultado = 15 - 12 ----> Resultado = 3 Resultado = 15 * 12 ----> Resultado = 180 Resultado = 15 / 12 ----> Resultado = 1.25 Resultado = 15 \ 12 ----> Resultado = 1 Resultado = 15 Mod 12 ----> resultado = 3 Resultado = 12 ^ 2 ----> Resultado = 144 resultado = ( ( 4 * 3 ) / 2 ) ^ 2 ----> Resultado = 36 Estos operadores se denominan Operadores aritméticos. Existen otras operaciones que se pueden realizar con números: comparaciones. Los operadores que realizan comparaciones se denominan Operadores relacionales. El resultado de las operaciones realizadas con estos operadores solamente admiten dos resultados: True (Cierto) o False (Falso) Estos operadores son: = Igual que <> No igual que < Menor que <= Menor o igual que > Mayor que


>= Igual o mayor que Estos operadores se suelen utilizar en estructuras de programa donde se tome una decisión. El operador = puede usarse también para comparar cadenas o fechas. Operadores Lógicos Estos operadores sólo tienen sentido cuando hablemos de variables Booleanas, es decir, aquellas que solamente pueden tomar los valores cero y uno. Operador Función Devuelve True si Devuelve False si And Función AND A=True y B=True Cualquier otro caso Or Función OR A=True o B=True A=False y B=False Xor Función XOR A=True y B=False A=True y B=True A=False y B=True A=False y B=False Eqv F. Equivalente A=True y B=True A=True y B=False A=False y B=False A=False y B=True Imp Implicación A=True y B=True A=True y B=False A=False y B=True A=False y B=False Not Negación A=False A=True Like Igualdad A=True A=False Otras Funciones con números CInt Parte entera Devuelve la parte entera de un número con decimales Abs Valor Absoluto Devuelve el valor absoluto de un número Sgn Signo Devuelve el signo de un número Sqr Raíz cuadrada Devuelve la raíz cuadrada de un número Exp Exponenciación Devuelve el número elevado al exponente indicado Log Logaritmo Devuelve el logaritmo natural de ese número Trigonométricas Sin Seno Devuelve el valor del seno de un ángulo (Expresado en radianes) Cos Coseno Devuelve el coseno de un ángulo (En radianes) Tan Tangente Devuelve la tangente de un ángulo Atn Arco Tang. Devuelve un arco cuya tangente sea el número (Angulo en radianes)


Una función curiosa Timer Tiempo acumulado Devuelve el tiempo (en segundos) que ha pasado desde las 12 de la noche. Generación de números aleatorios Randomize (Numero) Inicia el generador aleatorio tomando como dato de partida el Numero. Devuelve el resultado en una variable llamada Rnd. NOTA MUY IMPORTANTE.- Los números aleatorios generados de esta forma son siempre iguales, eso sí, dependiendo del número que se le introduzca como parámetro. Esta generación de números no produce números aleatorios pues como se dijo, dependen del numero que se meta como parámetro, y si este se repite, se repite la sucesión de números que nos crea el generador aleatorio. La forma de obtener números realmente aleatorios es introducir como parámetro un número que sea variable con el tiempo. Ese número no puede ser otro que el número timer visto antes. Y siempre con la precaución de que medie mas de un segundo entre dos instrucciones Randomize. La función toma entonces la forma: Randomize Timer La función Randomize devuelve una variable Rnd con un número comprendido entre 0 y 1 (Nunca será 0 ni 1) Leyendo el valor de la variable sucesivas veces, se puede obtener una sucesión de números aleatorios. No es necesario ejecutar la instrucción Randomize Timer cada vez que se quiera obtener un dato de la variable Rnd. Un ejemplo. Generador de números para la Lotería Primitiva Supongamos que tenemos un formulario con una etiqueta de nombre Label1, un botón de comando de nombre Command1. Cuando hagamos click sobre el botón de comando deberá generar un número comprendido entre el 1 y el 49. En el procedimiento click de Command1 pondremos el siguiente código: Private Sub Command1.click

Randomize Timer A = Rnd A = Rnd * 100 A = CInt(A) Do While A > 49 A = A - 49 Loop Do While A < 1 A = A + 49 Loop Label1.caption = A

End Sub Realice este pequeño programa, con la instrucción Randomize Timer y sin ella.


FFuunncciioonneess ccoonn ffeecchhaass.. Las fechas son cadenas especiales. Visual Basic sabe obtener y tratar la información relativa a la fecha y la hora. Dispone para ello de una declaración de variable: Date. Una variable declarada como date puede contener una fecha, una fecha y una hora o una hora solamente. Date Devuelve la fecha de hoy. Esta fecha la toma del reloj del computadora. Time Devuelve la hora actual. Now Devuelve la fecha y hora actual. WeekDay Devuelve el día de la semana (En número, 1=Domingo, 2=Lunes,...) Day Obtiene el día, a partir de una fecha Month Obtiene el mes a partir de una fecha. Year Obtiene el año a partir de una fecha. Hour Obtiene la hora a partir de una hora Minute Obtiene el minuto a partir de una hora. Second Obtiene el segundo a partir de una hora. DateAdd Añade un intervalo de tiempo a una fecha DateDiff Obtiene el intervalo de tiempo entre dos fechas DatePart Devuelve una parte de una fecha (semana, trimestre, etc.) DateSerial Compone una fecha a partir de parámetros relativos TimeSerial Compone una hora a partir de parámetros relativos. DateValue Devuelve una fecha a partir de un dato que se le parezca y VB pueda obtener de él una fecha válida Mediante estas instrucciones podemos obtener el dato necesario de una fecha u hora. Por ejemplo, para obtener el día de hoy solamente: Día = Day (Now) Día será un número El día de la semana lo obtendríamos Diasemana = WeekDay (Now) Diasemana será un número DateValue, una instrucción que le sacará mucho provecho Fecha = DateValue (120796) Fecha = DateValue (12 07 96) Fecha =12/07/96


FFuunncciióónn FFOORRMMAATT Esta función permite presentar cadenas de numéricas o fechas de una determinada forma. Permite establecer el Formato de esa cadena. Si recurre a la ayuda de VB acerca de esta función se va a enterar muy poco de lo que puede dar de sí. La sintaxis que presenta es :

Format(expresión[, formato[, primerdíadesemana[, primerasemanadelaño]]]) Lo mejor que puede hacer con esta definición de la sintaxis de Format es olvidarla. No le aclara mucho lo que se puede hacer con Format. La función Format se usa para poner una fecha en un determinado formato. Con la expresión : FechadeHoy = Format (Now, “yyyy-mm-dd”) la variable FechadeHoy tendrá el valor 1998-05-21, que se refiere al día 21 de mayo de 1998, según el formato recomendado por la norma ISO-8601 para la presentación de fechas. Si hubiésemos puesto la expresión FechadeHoy = Format (Now, “dd/mm/yy”) , la variable FechadeHoy contendría el valor 21/05/98 referido al día citado. Las posibilidades de Format llegan también al campo de las cadenas numéricas. Por ejemplo la cifra 123456 se transformará en las siguientes expresiones, según como empleemos la función Format Variable = Format(123456, "Currency") Variable = 123.456 Pts Variable = Format(123456, "Standard") Variable = 123.456,00 Veamos ahora con un poco mas de conocimiento la sintaxis de Format

Variable = Format (expresión[, formato[, firstdayofweek[, firstweekofyear]]]) Donde expresión es una cadena o fecha válida formato es uno de los formatos predefinidos (Standard, Currency, etc. Vea mas abajo) firstdayofweek. Especifica el primer día de la semana. Puede tomar uno de estos valores o constantes : Constante Valor Descripción vbUseSystem 0 El especificado en el sistema operativo. VbSunday 1 Domingo (valor por defecto) vbMonday 2 Lunes vbTuesday 3 Martes vbWednesday 4 Miércoles vbThursday 5 Jueves vbFriday 6 Viernes vbSaturday 7 Sábado firstweekofyear Especifica cual es la primera semana del año. Puede tomar uno de los siguientes valores o constantes : Constante Valor Descripción vbUseSystem 0 Usa el valor del sistema operativo


vbFirstJan1 1 La primera semana es la que contiene al día 1 de Enero(Valor por defecto

vbFirstFourDays 2 La primera semana es la que contiene al menos, 4 días de ese año (Rec. ISO - 8601)

vbFirstFullWeek 3 La primera semana es la que tiene todos sus días en ese año No se complique la vida con el tema del primer día de la semana ni la primera semana del año. No lo usará con frecuencia. Centrémonos mas en el parámetro Formato. Puede tomar muchos valores. Veamos los principales. Primero para números Observe que usamos la expresión Variable =Format (1234567,”Formato”) para todos los ejemplos de números. Para poner los números separados por millares : Variable = Format(1234567, "##,###,###") Variable = 1.234.567 (Cada carácter # indica que ahí va un número. El separador debe ser una coma, no un punto, aunque esto depende del idioma que esté usando) Puede poner una de estas expresiones, eso si, siempre entre comillas dobles : General Number Muestra el número tal como lo tecleó Currency En formato de la moneda de su sistema operativo Fixed Sin separador de millar y dos decimales (1234567,00) Standard Con separador de millares y dos decimales (1.234.567,00) Percent Multiplica el número por cien y lo presenta cono

porcentaje(123456700,00%) Scientific Usa notación científica (1,23E+06) . Para fechas (Observe que usamos el ejemplo Format(Now, “Formato”) y Now = 21/07/98

a las 22:16:00 y pico) General Date 21/07/98 22:16:00 Long Date martes 21 de julio de 1998 Medium Date 21-jul-98 Short Date 21/07/98 yyyy-mm-dd 1998-05-21 yy-mm-dd 98-07-21 Long Time 22:19:53 Medium Time 10:20 PM Short Time 22:20 hh :mm :ss 22 :21 :29 hh :mm 22 :21 Format dispone de mas opciones. Sería muy largo explicarlas aquí. Para mas información, en la WEB de Microsoft puede encontrar mas formatos posibles.

BBiibblliiooggrraaffííaa • SUAREZ BERNALDO Luis, “Visual Basic - Guía del Estudiante”, www.monografias.com • MICROSOFT DEPVELOMENT NETWORK, “Ayuda de Visual Basic”,

http://msdn.microsoft.com, www.microsoft.com • CORNELL Gary, “VISUAL BASIC 6.0 Manual de Referencia”, Mc Graw Hill Última modificación de este archivo: 30/03/2005

vviissuuaall bbaassiicc ppaarraa...

Documents