Introducción a visual basic upn 6 final

UNIVERSIDAD PEDAGÓGICA NACIONAL FRANCISCO MORAZÁN
PROGRAMA DE APOYO A LA ENSEÑANZA MEDIA DE HONDURAS
PROGRAMA DE CAPACITACIÓN MODULAR (PCM) PARA DOCENTES
DE FORMACIÓN PROFESIONAL DE LA ENSEÑANZA MEDIA DE
HONDURAS
MÓDULO:
TALLER DE VISUAL BASIC 6.0 BÁSICO
“HONDURAS CRECE CON PROFESIONALES DE CALIDAD”
ELABORADO POR:
LEVÍ ASTUL CASTRO ORDÓÑEZ
TEGUCIGALPA M. D. C. MAYO, 2006

MÓDULO:
TALLER DE VISUAL BASIC 6.0 BÁSICO
LEVÍ ASTUL CASTRO ORDÓÑEZ

TABLA DE CONTENIDO
PRESENTACIÓN ............................................................................................................................................ 1
UNIDAD I. INTRODUCCIÓN ....................................................................................................................... 2
CONTENIDO.................................................................................................................................................... 2
OBJETIVOS DE LA UNIDAD .............................................................................................................................. 2
1. PARADIGMAS DE PROGRAMACIÓN.............................................................................................................. 2
1.1. Programación imperativa ................................................................................................................. 2
1.2. Programación modular..................................................................................................................... 2
1.3. Programación orientada a objetos (POO)........................................................................................ 3
1.4. Programación visual......................................................................................................................... 3
1.5. Programación orientada a eventos................................................................................................... 3
2. CARACTERÍSTICAS DE VISUAL BASIC 6 ...................................................................................................... 4
RESUMEN ....................................................................................................................................................... 5
EJERCICIOS..................................................................................................................................................... 5
EVALUACIÓN.................................................................................................................................................. 5
UNIDAD II. ENTORNO DE DESARROLLO INTEGRADO..................................................................... 6
CONTENIDO.................................................................................................................................................... 6
OBJETIVOS DE LA UNIDAD .............................................................................................................................. 6
1. INICIAR VISUAL BASIC ............................................................................................................................... 6
2. ELEMENTOS DEL ENTORNO DE DESARROLLO INTEGRADO.......................................................................... 7
2.1. El menú principal.............................................................................................................................. 7
2.2. La barra de herramientas ................................................................................................................. 7
2.3. Área de diseño de formulario ........................................................................................................... 7
2.4. El explorador Proyectos.................................................................................................................... 7
2.5. La ventana Propiedades.................................................................................................................... 8
2.6. La ventana posición del formulario.................................................................................................. 9
2.7. La barra de componentes.................................................................................................................. 9
2.8. Manipulación de componentes para crear objetos .......................................................................... 9
2.9. Editor de código .............................................................................................................................. 10
2.10. Ventanas Inmediato, Locales e Inspección.................................................................................. 10
3. OPCIONES DE ENTORNO ............................................................................................................................ 12
4. ESTRUCTURA DE UNA APLICACIÓN. .......................................................................................................... 13
5. TIEMPO DE DISEÑO, TIEMPO DE EJECUCIÓN Y MODO DE INTERRUPCIÓN .................................................... 14
5.1. Tiempo de diseño............................................................................................................................. 14
5.2. Tiempo de ejecución........................................................................................................................ 14
5.3. Modo de interrupción...................................................................................................................... 15
6. OPERACIONES SOBRE APLICACIONES ........................................................................................................ 15
6.1. Abrir un proyecto nuevo ................................................................................................................. 15
6.2. Guardar una aplicación.................................................................................................................. 15
6.2. Cerrar una aplicación..................................................................................................................... 17
6.2. Abrir una aplicación existente........................................................................................................ 18
7. EJECUTAR UNA APLICACIÓN ..................................................................................................................... 19
RESUMEN ..................................................................................................................................................... 20
EJERCICIOS................................................................................................................................................... 20
EVALUACIÓN................................................................................................................................................ 20
UNIDAD III. BREVE METODOLOGÍA DE PROGRAMACIÓN........................................................... 21
CONTENIDO.................................................................................................................................................. 21
OBJETIVOS DE LA UNIDAD ............................................................................................................................ 21
1. CREACIÓN DE ALGORITMOS ..................................................................................................................... 21
2. PLANIFICACIÓN DE INTERFAZ DE USUARIO .............................................................................................. 22
RESUMEN ..................................................................................................................................................... 24

ii
EJERCICIOS................................................................................................................................................... 24
EVALUACIÓN................................................................................................................................................ 24
UNIDAD IV. IDENTIFICADORES, TIPOS DE DATOS, EXPRESIONES Y SENTENCIAS BÁSICAS
.......................................................................................................................................................................... 25
CONTENIDO.................................................................................................................................................. 25
1. TIPOS DE DATOS........................................................................................................................................ 25
2. DECLARACIÓN DE IDENTIFICADORES........................................................................................................ 26
2.1. Variables.......................................................................................................................................... 26
2.1.1. Ámbito de las variables ................................................................................................................ 27
2.1.2. Declaración implícita................................................................................................................... 27
2.1.3. Declaración explícita ................................................................................................................... 28
2.1.4. Descripción del alcance de las variables ..................................................................................... 30
2.1.5. Variables estáticas........................................................................................................................ 31
2.2. Constantes ....................................................................................................................................... 32
2.2.1. Crear constantes propias.............................................................................................................. 32
3. EXPRESIONES............................................................................................................................................ 33
4. SENTENCIAS DE ENTRADA, ASIGNACIÓN, SALIDA Y DE LLAMADA............................................................. 34
4.1. Sentencia de entrada....................................................................................................................... 34
4.2. Sentencia de asignación.................................................................................................................. 35
4.3. Sentencia de salida.......................................................................................................................... 35
4.5 Sentencia de llamada ....................................................................................................................... 36
RESUMEN ..................................................................................................................................................... 36
EJERCICIOS................................................................................................................................................... 36
EVALUACIÓN................................................................................................................................................ 37
UNIDAD V. SENTENCIAS DE DECISIÓN................................................................................................ 38
CONTENIDO.................................................................................................................................................. 38
1. SENTENCIAS DE DECISIÓN......................................................................................................................... 38
1.1. Sentencia de decisión IF ... THEN ... ELSE ................................................................................. 38
1.2. Sentencia de decisión SELECT CASE........................................................................................... 45
RESUMEN ..................................................................................................................................................... 47
EJERCICIOS................................................................................................................................................... 48
EVALUACIÓN................................................................................................................................................ 48
UNIDAD VI. CAJAS O VENTANAS DE DIALOGO................................................................................ 49
CONTENIDO.................................................................................................................................................. 49
1.1. Visualizar datos con MsgBox ......................................................................................................... 49
1.2. Obtener datos con InputBox........................................................................................................... 50
2. CAJAS DE DIALOGO PERSONALIZADAS...................................................................................................... 51
3. CUADROS DE DIÁLOGO MODALES Y NO MODALES..................................................................................... 54
RESUMEN ..................................................................................................................................................... 55
EJERCICIOS................................................................................................................................................... 56
EVALUACIÓN................................................................................................................................................ 56
UNIDAD VII. ARREGLOS Y SENTENCIAS REPETITIVAS................................................................. 57
CONTENIDO.................................................................................................................................................. 57
1. ARREGLOS................................................................................................................................................ 57
1.1 Array estático ................................................................................................................................... 58
1.2. Array dinámico................................................................................................................................ 58
2. SENTENCIAS REPETITIVAS ........................................................................................................................ 58
2.1. Sentencia FOR ... NEXT................................................................................................................. 59

iii
2.2. Sentencia WHILE … WEND......................................................................................................... 61
RESUMEN ..................................................................................................................................................... 62
EJERCICIOS................................................................................................................................................... 62
EVALUACIÓN................................................................................................................................................ 63
UNIDAD VIII. GESTIÓN DE DATOS ........................................................................................................ 64
CONTENIDO.................................................................................................................................................. 64
1. BASES DE DATOS RELACIONALES............................................................................................................. 64
1.1. Estructura de una Base de Datos ................................................................................................... 64
1.1.1. Campos......................................................................................................................................... 64
1.1.2. Campo Clave ................................................................................................................................ 64
1.1.3. Registros....................................................................................................................................... 64
1.2.4. Tablas ........................................................................................................................................... 65
2. Relaciones de Bases de Datos............................................................................................................ 65
2.1. Tipos de Relaciones......................................................................................................................... 65
2.1.1. Relaciones de uno a uno.............................................................................................................. 65
2.1.2. Relaciones de uno a muchos........................................................................................................ 65
2.1.3. Relaciones muchos a muchos...................................................................................................... 65
2. CREACIÓN DE UNA BASE DE DATOS EN MSACCESS .................................................................................. 65
RESUMEN ..................................................................................................................................................... 84
EJERCICIOS................................................................................................................................................... 84
EVALUACIÓN................................................................................................................................................ 84
ANEXO I. TABLA DE CÓDIGOS ASCII................................................................................................... 92
GLOSARIO DE TÉRMINOS ....................................................................................................................... 93
BIBLIOGRAFÍA............................................................................................................................................ 94

1
PRESENTACIÓN
La Universidad Pedagógica Nacional (UPNFM) está ejecutando el Programa de Capacitación
Modular (CPM) para docentes de Formación Profesional de la Enseñanza Media de Honduras,
según convenio de trabajo entre el Programa de Apoyo a la Enseñanza Media de Honduras
(PRAEMHO), de la Secretaría de Educación (SE), y la UPNFM. El presente material fue
desarrollado en el marco de dicho programa y se utilizará para impartir el Taller de Visual Basic 6.0
dirigido a la formación profesional de la enseñanza madia.
En este contexto, este libro ha sido escrito pensando en profesores que posiblemente no tienen
conocimientos avanzados de programación y por lo tanto el desarrollo de las unidades es más o
menos intuitivo. No se hace un desarrollo profundo ni extenso de los temas, pero se presentan las
herramientas necesarias para iniciar al lector en el mundo de la programación con Visual Basic. Se
asume que el lector tiene conocimientos básicos del uso de computadoras y del sistema operativo
Windows 95, 98, Me o Xp.
Se inicia con una presentación general sobre el Entorno de Desarrollo Integrado de Visual Basic.
Luego se presentan algunos elementos de Paradigmas y Metodologías de Programación. A
continuación se tratan algunos elementos fundamentales de lenguaje de Visual Basic. Para el
manejo de Bases de Datos se incluye una pequeña sección sobre Bases de Datos Relacionales y si
implementación en MSAccess. Y finalmente se presenta una pequeña aplicación para manipular
bases de datos con Visual Basic.
Esperamos que el presente material sirva de base y motivación para estudios más profundos de la
materia y que contribuya al fortalecimiento de la gestión y docencia en el Nivel Medio de
Educación de Honduras.

2
UNIDAD I. INTRODUCCIÓN
CONTENIDO
1. Paradigmas de programación.
2. Características generales de Visual Basic 6.
OBJETIVOS DE LA UNIDAD
1. Conocer de manera general los diferentes paradigmas de lenguajes de programación.
2. Conocer de manera general las características de Visual Basic 6
1. PARADIGMAS DE PROGRAMACIÓN
De manera general un paradigma puede entenderse como un conjunto de reglas, explícitas o
implícitas que rigen una conducta. En el mundo de la computación existen diversos lenguajes de
programación de computadoras. Cada uno tiene características que lo ponen en ventaja en relación a
otros. Dichas características responden a uno más paradigmas de programación. En el caso de
Visual Basic (VB), estamos ante un lenguaje de programación imperativo, modular, orientado a
objetos (POO), visual y orientado a eventos, es decir, responde al menos a cinco paradigmas;
aunque el paradigma dominante es el de POO ya que éste incluye a los primeros dos. Una de sus
características importantes es su Entorno de Desarrollo Integrado (IDE) el cual proporciona al
programador todas las herramientas necesarias además de un ambiente amigable para el desarrollo
de aplicaciones. Si bien es cierto que los lenguajes visuales con IDE facilitan tremendamente el
desarrollo de aplicaciones siempre es necesario conocer el lenguaje y todo lo que implica
desarrollar una aplicación.
1.1. Programación imperativa
Cuando se construye un programa bajo este paradigma se debe considerar que los elementos
fundamentales para la construcción de algoritmos son los identificadores, expresiones y sentencias.
De hecho, un algoritmo se considera como un conjunto de sentencias que se ejecutan de manera
secuencial. Entonces, cuando se analiza un problema para resolverlo, en él se deben identificar los
hechos, atributos y procesos necesarios para su solución.
Ejemplo 1.1. Se desean dividir dos números reales y mostrar el resultado.
En este problema se identifican los siguientes elementos:
Atributos: El numerador: A
El denominador: B
El resultado de la división: D
Procesos: Si B≠0 entonces D=A/B
Como se observa toda la información se puede obtener a partir del enunciado del problema. Se
asigna identificador únicamente a los atributos y los hechos, mientras que a los procesos no se les
asigna identificador.
1.2. Programación modular
Cuando se resuelve un problema bajo este paradigma la idea fundamental es que un problema
original se puede descomponer en subproblemas más específicos. Cada subproblema debe ser una
tarea específica y claramente distinguible del resto de tareas. Luego, se aplica la programación
imperativa a esos subproblemas. En este sentido, la programación imperativa es una herramienta
dentro de la programación modular. Otro hecho importante es que en la programación modular se
asignan identificadores tanto a los atributos, los hechos como a los procesos. A los procesos se les
suele llamar módulos, subtareas, subprogramas o rutinas.

3
Ejemplo 1.2. El sistema para control de datos de alumnos en un colegio permite la matrícula de
alumnos, ingresar calificaciones y eliminar alumnos de los listados. Escribir un
programa para este sistema.
Subproblemas: Matrícula de alumnos: Matricula
Ingreso de calificaciones: Calificaciones
Eliminar alumnos de listados: Eliminar
Etc.
Atributos: Nombres de alumnos: NomAlu
Notas parciales de los alumnos: NP
Notas finales de los alumnos: NF
Nombres de asignaturas: NomA
Nombres de profesores: NomP
Etc.
En el ejemplo anterior no se hizo una lista exhaustiva de los atributos y procesos ni se incluyeron
hechos ya que no es la intención resolver el problema sino ejemplificar el concepto de subproblema;
nótese que los procesos son los subproblema.
1.3. Programación orientada a objetos (POO)
Cuando se resuelve un problema bajo este paradigma la tarea fundamental es identificar objetos. Un
objeto se interpreta como un conjunto de propiedades, métodos y eventos que es capaz de responder
a estímulos externos. Una vez identificados los objetos se establecen las relaciones entre ellos; estas
relaciones usualmente son procesos.
Ejemplo 1.3. El sistema para control de datos de alumnos en un colegio permite la matrícula de
alumnos, ingresar calificaciones y eliminar alumnos de los listados. Escribir un
programa para este sistema.
Objetos: Alumnos: Alumno
Un alumno tiene como atributos: Nombre, Edad, Sexo, Año académico,
notas parciales por asignatura, etc
Asignaturas: Asignatura
Una asignatura tiene como atributos: …
Profesores: Profesor
Un profesor tiene como atributos: …
Etc.
1.4. Programación visual
Un lenguaje visual es aquel cuyo método para crear la interfaz gráfica de usuario (GUI) consiste en
la ubicación de los elementos de la interfaz agregando objetos prefabricados en su lugar dentro de la
pantalla en lugar de escribir numerosas líneas de código para describir la apariencia. Debe quedar
claro que la gran ventaja de los lenguajes visuales que el programador no invierte muchas horas en
la construcción de la interfaz sino en aspectos de fondo de la aplicación como procesamiento de
datos y funcionamiento.
1.5. Programación orientada a eventos
En las aplicaciones tradicionales o "por procedimientos", la aplicación es la que controla qué partes
de código y en qué secuencia se ejecutan. La ejecución comienza con la primera línea de código y
continúa con una ruta predefinida a través de la aplicación, llamando a los procedimientos según se

4
necesiten. En una aplicación controlada por eventos, el código no sigue una ruta predeterminada; se
ejecutan distintas secciones de código como respuesta a los eventos. Los eventos pueden
desencadenarse por acciones del usuario, por mensajes del sistema o de otras aplicaciones, o incluso
por la propia aplicación. La secuencia de estos eventos determina la secuencia en la que se ejecuta
el código, por lo que la ruta a través del código de la aplicación es diferente cada vez que se ejecuta
el programa.
El código también puede desencadenar eventos durante la ejecución. Por ejemplo, cambiar
mediante programación el texto de un cuadro de texto hace que se produzca el evento Change del
cuadro de texto. Esto causaría la ejecución del código (si lo hay) contenido en el evento Change. Si
se supone que este evento sólo se desencadenará mediante la interacción del usuario, podría verse
resultados inesperados. Por esta razón es importante comprender el modelo controlado por eventos
y tenerlo en cuenta cuando se diseña una aplicación.
Independientemente del paradigma que se utilice exciten al menos tres elementos que son
fundamentales en la programación:
Los identificadores se utilizan para representar un elemento de la realidad ya sea hechos, atributos,
procesos, objetos, entre otros.
Los valores literales son aquellos valores específicos de un atributo o hecho el cual se expresa sin
necesidad de un identificador. Por ejemplo,
Si se hace referencia al atributo “edad de una persona”, se puede utilizar la palabra Edad
para identificar ese atributo. Luego para referirse a la edad de una persona en particular,
digamos 23 años, se puede hacer a través del identificador o mediante el valor literal 23.
Los operadores se utilizan para producir o acceder a información. Generalmente actúan sobre
identificadores y valores literales. Por ejemplo,
Si la edad de Ana es cinco años más que la de Sandra y la edad de Sandra está almacenada
en el identificador Edad, entonces la edad de Ana es Edad+5
2. CARACTERÍSTICAS DE VISUAL BASIC 6
Visual Basic se encuentra disponible en tres versiones, cada una de las cuales está orientada a unos
requisitos de programación específicos.
1. La Edición de Aprendizaje de Visual Basic permite a los programadores crear robustas
aplicaciones para Microsoft Windows y Windows NT®. Incluye todos los controles
intrínsecos, además de los controles de cuadrícula, de fichas y los controles enlazados a
datos.
2. La Edición Profesional proporciona a los profesionales un conjunto completo de
herramientas para desarrollar soluciones para terceros. Incluye todas las características de la
Edición de Aprendizaje, así como controles ActiveX adicionales, el diseñador de
aplicaciones para Internet Information Server y Visual Database Tools and Data.
3. La Edición Empresarial permite a los profesionales crear sólidas aplicaciones distribuidas
en un entorno de equipo. Incluye todas las características de la Edición Profesional, así
como herramientas de Back Office como SQL Server, Microsoft Transaction Server,
Internet Information Server, Visual SourceSafe, SNA Server, etc.
Visual Basic es un lenguaje de desarrollo para Windows, por ello es necesario familiarizarse con el
entorno Windows. El funcionamiento de Windows incluye tres conceptos clave: ventanas, eventos y
mensajes. Una ventana es simplemente una región rectangular con sus propios límites. Existen
varios tipos de ventanas pero todas ellas comparten algunas características y otras son propias:
cuadro de diálogo, un botón de comando, los iconos, cuadros de texto, botones de opción y barras
de menús entre otros.
El sistema operativo Microsoft Windows administra todas estas ventanas asignando a cada una un
único número identificador (controlador de ventana o hWnd). El sistema controla continuamente

5
cada una de estas ventanas para ver si existen signos de actividad o eventos. Los eventos pueden
producirse mediante acciones del usuario, como hacer clic con el ratón o presionar una tecla,
mediante programación o incluso como resultado de acciones de otras ventanas.
Cada vez que se produce un evento se envía un mensaje al sistema operativo. El sistema procesa el
mensaje y lo transmite a las demás ventanas. Entonces, cada ventana puede realizar la acción
apropiada, basándose en sus propias instrucciones para tratar ese mensaje en particular.
Todas las combinaciones posibles de ventanas, eventos y mensajes las controla automáticamente
Visual Basic, mientras que otros se tratan como procedimientos de evento. Esto le permite crear
rápidamente eficaces aplicaciones sin tener que tratar detalles innecesarios.
El proceso de desarrollo de las aplicaciones tradicionales se puede dividir en tres etapas diferentes:
escritura, compilación y comprobación del código. A diferencia de los lenguajes tradicionales,
Visual Basic utiliza una aproximación interactiva para el desarrollo, de manera que no se distingue
entre estos tres pasos.
En la mayoría de los lenguajes, si comete un error al escribir el código, el compilador intercepta este
error cuando comience a compilar la aplicación. Entonces el programador debe encontrar y corregir
el error y comenzar de nuevo con el ciclo de compilación, repitiendo el proceso para cada error
encontrado. Visual Basic interpreta el código a medida que lo escribe, interceptando y resaltando la
mayoría de los errores de sintaxis en el momento. Es casi como tener un experto vigilando cómo
escribe el código. Además, para interceptar errores sobre la marcha, Visual Basic también compila
parcialmente el código según se escribe. Cuando el programador está preparado para ejecutar y
probar la aplicación, tardará poco tiempo en terminar la compilación. Si el compilador encuentra un
error, quedará resaltado en el código. Se puede corregir el error y seguir compilando sin tener que
comenzar de nuevo.
RESUMEN
Cuando se desea resolver un problema mediante un algoritmo (o un programa) es necesario
establecer bajo que paradigma de programación se trabajará. El paradigma determinará la
metodología a utilizar. Visual Basic 6 es un lenguaje de programación que responde a varios
paradigmas: imperativo, modular, orientado a objetos, visual y orientado a eventos.
Independientemente de los paradigmas aquí mencionados existen tres elementos que son de suma
importancia al momento de construir programas, ellos son los atributos, los hechos y los procesos.
Con estos elementos básicos se construyen el resto de elementos que conforman una aplicación.
El compilador de Visual Basic proporciona al programador la ventaja de que compila según se va
escribiendo el código. Así, el programador cuenta con un “asistente” que le indica en cada momento
se ha cometido un error de sintaxis o no en lugar de esperar hasta terminar todo el código. Por otra
parte, ya que algunos errores no se detectan en tiempo de diseño, Visual Basic conserva una
memoria de las líneas de código que compilaron hasta el momento de error. Así, cuando el
programador corrige el error Visual Basic puede compilar más rápidamente la aplicación pues inicia
en el punto donde dejó de compilar.
EJERCICIOS
1. Investigar acerca de otros paradigmas de programación.
2. Investigar acerca de los diferentes lenguajes según los paradigmas de programación.
EVALUACIÓN
Presentar un breve ensayo, de al menos una página tamaño carta, tipo de letra NewRoman de 11,
acerca de los temas investigados en los dos ejercicios anteriores.

6
UNIDAD II. ENTORNO DE DESARROLLO INTEGRADO
CONTENIDO
1. Definición de Entorno de Desarrollo Integrado.
2. Elementos del Entorno de Desarrollo Integrado.
3. Estructura de una aplicación.
1. Definir Entorno de Desarrollo Integrado.
2. Identificar los elementos del Entorno de Desarrollo Integrado.
3. Comprender la importancia del Entorno de Desarrollo Integrado para el desarrollo de
aplicaciones.
4. Conocer la estructura de una aplicación.
1. INICIAR VISUAL BASIC
En una instalación típica de Visual Basic en Windows XP la manera para iniciar el programa es la
siguiente:
1. Hacer clic en Inicio en la barra de tareas de Windows.
2. Seleccionar Todos los Programas, Microsoft Visual Studio 6.0 y luego Microsoft Visual
Basic 6.0.
Figura 2.1. Iniciar Visual Basic
O bien, si no está instalado Visual Studio completamente:
Haga doble clic en el icono de Microsoft Visual Basic 6.0.
También se puede crear un acceso directo a Visual Basic en el escritorio y hacer doble clic en él.
Cuando se inicia el Visual Basic 6 aparece una pantalla como la Figura 2.2. La ventana que aparece
en el centro de la pantalla, Nuevo Proyecto, es un menú que permite seleccionar el tipo de
aplicación que se desea desarrollar. Si bien es cierto que en Visual Basic se pueden desarrollar
diversos tipos de aplicaciones, en este manual sólo se estudiará cómo escribir aplicaciones EXE
Standard.

7
FIGURA 2.2. Pantalla inicial de Visual Basic 6.
2. ELEMENTOS DEL ENTORNO DE DESARROLLO INTEGRADO
Un Entorno de Desarrollo Integrado (IDE) es un conjunto de herramientas integradas que permite el
desarrollo de aplicaciones en un solo entorno. Las herramientas típicas en un IDE don el compilador
(elemento no visible), el editor de texto para la escritura del código fuente y el depurador entre
otros. Si se selecciona la opción Exe Estándar aparece la ventana de la Figura 2 en el cual se pueden
visualizar algunos de los elementos del IDE. Los elementos de esta ventana son:
2.1. El menú principal
Presenta los comandos que se usan para trabajar con Visual Basic. Además de los menús estándar
Archivo, Edición, Ver, Ventana y Ayuda, se proporcionan otros menús para tener acceso a
funciones específicas de programación como Proyecto, Formato o Depuración.
2.2. La barra de herramientas
Proporcionan un rápido acceso a los comandos usados normalmente en el entorno de programación.
De forma predeterminada, al iniciar Visual Basic se presenta la barra de herramientas Estándar. Es
posible activar o desactivar otras barras de herramientas adicionales para modificar, diseñar
formularios desde el comando Barras de herramientas del menú Ver.
Las barras de herramientas se pueden acoplar debajo de la barra de menús o pueden "flotar" si se
selecciona la barra vertical del borde izquierdo y la arrastra fuera de la barra de menús.
2.3. Área de diseño de formulario
Funciona como una ventana en la que se personaliza el diseño de la interfaz de su aplicación. Allí se
agregue controles, gráficos e imágenes a un formulario para crear la apariencia que se desea. Cada
formulario de la aplicación tiene su propia ventana diseñador de formulario.
2.4. El explorador Proyectos
Enumera los formularios y módulos del proyecto actual. Un proyecto es la colección de archivos
que usa para generar una aplicación. Mediante el explorador es fácil pasar de un formulario a otra
cuando la aplicación consta de más de uno.

8
FIGURA 2.3. Pantalla de trabajo para aplicaciones Exe Estándar.
2.5. La ventana Propiedades
Enumera los valores de las propiedades del control o formulario seleccionado. Una propiedad es
una característica de un objeto, como su tamaño, título o color. Muchas propiedades de un objeto
pueden ser modificadas mientras se escribe la aplicación o mientras se ejecuta
Figura 2.4. Elementos de la ventana Propiedades
Barra de
componentes
Barra de
herramientas
Menú Principal
Ventana de
propiedades
Posición del
formulario
Explorador de
proyectos
Área de diseño
de Formulario
Lista desplegable de
propiedades en el
formulario
Lista de propiedades
del objeto
seleccionado
Cuadro de explicación
de la propiedad
seleccionada
Clasificación de las propiedades
Barra de desplazamiento

9
Las propiedades están clasificadas por orden alfabético y por categorías. Dependiendo de su
experiencia usted decidirá trabajar con una u otra clasificación. Al lado izquierdo aparece el nombre
de la propiedad y el lado derecho aparece el valor de la propiedad, por ejemplo, en la figura anterior
la propiedad Caption tiene el valor Form1. Con la barra de desplazamiento se puede desplazar para
buscar el resto de propiedades del objeto seleccionado.
2.6. La ventana posición del formulario
La ventana Posición del formulario permite colocar los formularios de su aplicación utilizando una
pequeña representación gráfica de la pantalla. Esto es útil porque muestra la posición que tendrá la
pantalla de la aplicación cuándo ésta se ejecute.
2.7. La barra de componentes
Proporciona un conjunto de herramientas que puede usar durante el diseño para colocar controles en
un formulario. Además del diseño del cuadro de herramientas predeterminado, puede crear su
propio diseño personalizado si selecciona Agregar ficha en el menú contextual y agrega controles a
la ficha resultante. A continuación se describen los componentes de la barra de componentes:
FIGURA 2.5. Elementos de la barra de componentes.
2.8. Manipulación de componentes para crear objetos
Para colocar elementos (objetos) de la barra de componentes en el formulario se procede de una de
las siguientes formas:
1. Pulsar doble clic sobre el elemento, en este caso el elemento insertado aparecerá justo en el
centro del formulario con un tamaño predeterminado. Si se desea a continuación se puede
arrastrar el objeto y cambiar sus dimensiones.
2. Pulsar clic sobre el elemento y luego ubicar el puntero de ratón en la posición donde se
desea que aparezca el elemento, a continuación se presiona el botón izquierdo del ratón y
Caja de imagen
Caja de texto
Botón de comando
Botón de opción
Caja de lista
vertical
Lista de unidades de disco
Lista de ficheros
Línea
Datos
Puntero
Etiqueta
Marco
Casilla de verificación
Lista desplegable
Temporizador
vertical
Lista de direcciones
Figuras
Imagen
Ole

10
se arrastra el puntero hasta obtener el tamaño deseado del objeto que se está clocando en el
formulario.
2.9. Editor de código
Funciona como un editor de texto para escribir el código de la aplicación. Se crea una ventana
editor de código diferente para cada formulario o módulo del código de la aplicación. Esta ventana
si visualiza pulsando doble clic sobre el formulario. Desde la lista desplegable de objetos se puede
seleccionar el objeto para el cual se desea escribir o modificar código. Desde la lista desplegable de
eventos de objeto se puede seleccionar el evento para el cual se ha de escribir el código.
2.10. Ventanas Inmediato, Locales e Inspección
Estas ventanas adicionales se proporcionan para la depuración de la aplicación. Sólo están
disponibles cuando ejecuta la aplicación dentro del IDE.
Ejemplo 2.1. Inicie correctamente Visual Basic identifique cada uno de los elementos
mencionados. Si acerca el puntero del ratón a un elemento del IDE aparecerá un indicador del
nombre del elemento. Además, realice las siguientes actividades.
1. En la barra de herramientas identifique el elemento Examinador de objetos
2. Pulse clic sobre Form1 para seleccionarlo como objeto actual. En la ventana de propiedades
identifique la propiedad Font.
3. Pulse doble clic sobre Form1 y aparecerá el editor de código.
4. Utilizando la lista desplegable de eventos de objeto en el formulario selecciona el evento
Activate; observe lo que ocurre en el área de edición de código.
5. Utilizando la lista desplegable de objetos en el formulario selecciona la sección General;
observe lo que ocurre en el área de edición de código.
6. En la ventana Explorador de proyectos pulse doble clic sobre Form1 (Form1) ¿Qué ocurre?
7. Cambie el tamaño de Form1 y observe lo que ocurre en la ventana posición del formulario.
El siguiente ejemplo ilustra algunos de los elementos que se han mencionado hasta el momento.
Ejemplo 2.2. Colocar objetos en el formulario y manipular algunas propiedades. El objetivo es
obtener el formulario siguiente:
objetos en el formulario
eventos de objeto en el
formulario
Ventana para edición
de código

11
1. Colocar una etiqueta (Label) para mostrar el texto “Bienvenido” como título
a.Pulse doble clic sobre el componente Label (Etiqueta).
b.En la ventana de propiedades busque la propiedad Caption.
c. Pulse clic sobre el valor Form1 y cámbielo por Bienvenido.
d.Para cambiar el tamaño de letra busque la propiedad Font. Al pulsar clic sobre el
valor de propiedad y aparecerá un cuadrito con tres puntos suspensivos , pulse
clic sobre dicho cuadrito y aparecerá la ventana
e. En Estilo de fuente seleccione Negrita y en Tamaño seleccione 14, luego pulse clic
en Aceptar. Observe la etiqueta en el formulario y si no se logra ver todo el texto
Bienvenido modifique su tamaño convenientemente.
f. Para cambiar el color de letra busque la propiedad ForeColor, luego pulse clic sobre
el valor de la propiedad y aparecerá el cuadrito , pulse clic sobre él y aparecerá
la ventana

12
g.Pulse clic sobre paleta y seleccione el color apropiado
h.Cambie el nombre de la Etiqueta de Label1 por lTitulo. Para ello busque la propiedad
(Nombre) y cambie su valor por lTitulo.
2. Colocar un botón de comando (Command) con etiqueta Cerrar
a.Pulse doble clic sobre el componente CommandButton (Botón de comando)
b.En la ventana de propiedades busque la propiedad Caption y cambie su valor por
Cerrar.
c.Cambie el nombre del Botón de Command1 por cCerrar. Para ello busque la
propiedad (Nombre) y cambie su valor por cCerrar.
3. Guarde la aplicación en la carpeta de trabajo
a. Cree una subcarpeta con el nombre Ejemplos
b. Vuelva a Visual Basic y pulse clic en el botón Guardar grupo de proyectos .
c. Guarde el formulario con el nombre Principal
d. Guarde el proyecto con el nombre Suma
e. Si aparece una ventana preguntando si ¿Desea agregar este proyecto a SourceSafe?
Pulse clic en No.
f. Guarde el grupo con el nombre con que aparece Grupo1.
3. OPCIONES DE ENTORNO
Visual Basic proporciona un alto grado de flexibilidad, permitiéndole configurar el entorno de
trabajo que mejor se adapte a su propio estilo. Puede elegir entre una interfaz de documentos simple
o múltiple, y puede ajustar el tamaño y la posición de varios elementos del Entorno de Desarrollo
Integrado (IDE).
Con el IDE de Visual Basic hay disponibles dos estilos diferentes: la interfaz de documento simple
(SDI) o la interfaz de documentos múltiples (MDI). Con la opción SDI todas las ventanas del IDE
se pueden mover libremente por cualquier lugar de la pantalla; siempre y cuando Visual Basic sea la
aplicación actual, permanecerán encima de las demás aplicaciones. Con la opción MDI, todas las
ventanas del IDE están contenidas en una única ventana primaria de tamaño ajustable.
Para cambiar entre los modos SDI y MDI
1. En el menú Herramientas, seleccione Opciones.
2. Aparecerá el cuadro de diálogo Opciones.
3. Seleccione la ficha Avanzado.
4. Active o desactive la casilla de verificación Entorno de desarrollo SDI.
5. El IDE comenzará en el modo seleccionado la próxima vez que inicie Visual Basic.
Muchas de las ventanas del IDE se pueden acoplar o conectar a otra o al borde de la pantalla. Entre
estas ventanas se incluyen el cuadro de herramientas, la ventana Posición del formulario, el

13
Explorador de proyectos, la ventana Propiedades, la Paleta de colores y las ventanas Inmediato,
Locales e Inspección.
Con la opción MDI las ventanas pueden acoplarse en cualquier lado de la ventana primaria,
mientras que con SDI sólo se pueden acoplar debajo de la barra de menús. Las capacidades de
acoplado se pueden activar o desactivar para una ventana dada si activa la casilla de verificación
apropiada de la ficha Acople del cuadro de diálogo Opciones, disponible desde el comando
Opciones del menú Herramientas.
Para acoplar o desacoplar una ventana
1. Seleccione la ventana que desee acoplar o desacoplar.
2. Arrastre la ventana a la ubicación deseada manteniendo presionado el botón primario del
ratón.
3. El contorno de la ventana se mostrará al arrastrar la ventana.
4. Suelte el botón del ratón.
4. ESTRUCTURA DE UNA APLICACIÓN.
Una aplicación tiene una estructura jerárquica definida por los elementos que la componen. Cada
forma recibe el nombre de módulo. Cada módulo puede contener objetos y para cada objeto existe
una sección. Cada sección puede contener uno o más procedimientos. De manera general la
estructura se puede representar como:
FIGURA 2.6. Estructura de una aplicación
Por ejemplo, en la Figura x, una aplicación con una forma y un botón en la forma tiene: Un módulo
y tres secciones
FIGURA 2.7. Estructura de una aplicación
Sección para el
objeto Command1
Sección para el
objeto Form
Sección General
Módulo

14
5. TIEMPO DE DISEÑO, TIEMPO DE EJECUCIÓN Y MODO DE INTERRUPCIÓN
Para probar y depurar una aplicación necesita entender en cuál de los tres modos se encuentra en un
momento dado. Visual Basic en tiempo de diseño se utiliza para crear una aplicación y en tiempo de
ejecución para ejecutarla. Este capítulo presenta el modo de interrupción, que suspende la ejecución
de un programa para que usted pueda examinar y modificar datos.
Identificar el modo actual
La barra de título de Visual Basic siempre muestra el modo actual. La figura 13.6 muestra la barra
de título para el tiempo de diseño, el tiempo de ejecución y el modo de interrupción.
Figura 2.8. Identificación del modo actual con la barra de título de Visual Basic
5.1. Tiempo de diseño
La mayor parte del trabajo de creación de una aplicación se realiza en tiempo de diseño. Se puede
diseñar formularios, dibujar controles, escribir código y usar la ventana Propiedades para establecer
o ver los valores de las propiedades. No puede usar herramientas de depuración, excepto para
establecer los puntos de interrupción y crear expresiones de inspección.
En el menú Ejecutar, elegir Iniciar o hacer clic en el botón Ejecutar o pulsar F5 en el teclado para
cambiar a tiempo de ejecución.
Si su aplicación contiene código que se ejecuta cuando la aplicación se inicia, elegir Paso a paso
por instrucciones del menú Ejecutar (o presionar F8) para que la aplicación entre en modo de
interrupción en la primera instrucción ejecutable.
5.2. Tiempo de ejecución
Cuando una aplicación toma el control, el programador puede interactúa con la aplicación del
mismo modo que lo haría un usuario. Además, se puede ver el código, pero no cambiarlo. En el
menú Ejecutar, seleccionar Terminar o hacer clic en el botón Terminar para volver al tiempo de
diseño.
Barra de título en tiempo de
diseño
ejecución
interrupción
Botón Iniciar estará activo
Botón Iniciar estará inactivo,
Interrumpir y Terminar estarán
activos
Botón Iniciar y Terminar
estarán activos, Interrumpir
estará inactivo

15
5.3. Modo de interrupción
En el menú Ejecutar, elegir Interrumpir, hacer clic en el botón Interrumpir o presionar Ctrl-Pausa
para cambiar al modo de interrupción. La ejecución de la aplicación queda suspendida. Se puede ver
y modificar código (elegir Código en el menú Ver o presionar F7), examinar o modificar datos,
reiniciar la aplicación, terminar la ejecución o reanudarla desde el mismo punto.
Se puede establecer puntos de interrupción y expresiones de inspección en tiempo de diseño, pero
hay otras herramientas de depuración que sólo funcionan en modo de interrupción. Ver "Usar el
modo de interrupción", más adelante en este mismo capítulo.
Ejemplo 2.3. Si no se encuentra ejecutando Visual Basic, inícielo correctamente.
1. Pulse clic sobre el botón Iniciar (o presione F5) para ejecutar la aplicación actual.
2. Pulse clic sobre el botón Interrumpir ¿Qué ocurre?.
3. Pulse clic sobre el botón Terminar ¿Qué ocurre?.
6. OPERACIONES SOBRE APLICACIONES
Una aplicación un es programa que realiza una tarea más o menos compleja. Una aplicación es un
conjunto de proyectos o grupo. Cada proyecto a su vez es un conjunto de formularios (o módulos).
También cada formulario es un conjunto de funciones y procedimientos, los cuales son pequeños
programas que realizan tareas específicas. La sintaxis de de un procedimiento y una función son
respectivamente:
<Ámbito> Sub <ip> (argumentos)
<sentencias>
End Sub
<Ámbito> Function <if> (argumentos) <As tipo>
<sentencias>
End Function
No se tratará el tema de funciones y procedimientos de manera amplia pero el lector debe conocer
su estructura para comprender mejor los ejemplos desarrollados en este material.
6.1. Abrir un proyecto nuevo
Para abrir un proyecto nuevo se procede de varias formas, sin embargo el lector debe recordar que
aunque existen diversos tipos de proyectos aquí sólo se verán los de tipo Exe Estándar.
1. Una forma para abrir un proyecto es seleccionar Exe Estandar de la ventana inicial de
Visual Basic.
2. Otra forma es pulsar clic en la flecha del botón , lo cual desplegará una ventana.
Seleccione de esa ventana Exe Estándar.
Si ya cuenta con un proyecto abierto puede agregar otro proyecto a la aplicación siguiendo la
instrucción 2.
6.2. Guardar una aplicación
Como recordará una aplicación es un conjunto de proyectos que a su vez es un conjunto de
módulos. Para guardar una aplicación completa se debe guardar cada módulo y cada proyecto. Los
nombres que asigne a cada uno deben ser representativos del objetivo de cada uno de ellos. Para
guardar una aplicación competa se procede varias formas:

16
1. Pulsar clic en el botón de la barra de herramientas. Entonces aparecerá la ventana
Guardar archivo como:
Con esta ventana puede crear una nueva carpeta para guardar la aplicación o guardarla en la
carpeta actual. Una vez seleccionada la carpeta actual y escrito el nombre del formulario
debe pulsar clic en Guardar; nótese que la extensión de un formulario es frm. Después de
pulsar Guardar aparecerá la ventana Guardar proyecto como:
Crear carpeta
Nombre del formulario
Carpeta actual
Extensión o tipo

17
Los elementos de esta ventana son los mismos que en la anterior pero en la sección Tipo
aparece Proyecto (*.vbp); nótese que la extensión de un proyecto es vbp. Por omisión el
poryecto se guarda en la misma carpeta que el formulario. Una vez asignado el nombre del
proyecto pulse clic en Guardar. Si la aplicación consta de más de un proyecto aparecerá la
ventana Guardar grupo de proyectos como:
Nótese que la extensión de un grupo de proyectos es vbg. Por omisión el grupo se guarda en
la misma carpeta que los formularios y proyectos. Una vez asignado el nombre del grupo
pulse clic en guardar.
Una vez guardada la aplicación si realiza cambios en los diferentes elementos entonces al
pulsar el botón se guardarán dichos cambios pero no aparecerán las ventanas
anteriores a menos que haya agregado formularios o proyectos a la aplicación. En algún
momento del proceso de guardado es posible que aparezca la ventana siguiente, pulse clic
en No.
2. Otra forma de guardar aplicaciones es seleccionar en el menú principal Archivo, Guardar
grupo de proyectos como y proceda según lo explicado en las líneas anteriores. Este
mecanismo se utiliza también si desea almacenar la aplicación con otro nombre o en otro
lugar.
6.2. Cerrar una aplicación
Para cerrar una aplicación seleccione, en el menú principal, Archivo luego Quitar Proyecto. Debe
repetir esta operación hasta que el Explorador de proyectos esté vacío. Si ha realizado cambios
antes de que la aplicación se cierre le pedirá que guarde los cambios realizados:

18
Si dichos cambios no interesan pulse clic en No, de lo contrario pulse clic en Si. Si pulsa clic en
Cancelar, entonces se cancelará la operación Quitar proyecto.
6.2. Abrir una aplicación existente
Para abrir una aplicación existente puede proceder de dos formas.
1. En la barra de herramientas, pulse clic en el botón , aparecerá la ventana:
Usualmente la carpeta actual es la última que utilizó si no ha cerrado Visual Basic. Debe
seleccionar la carpeta donde tiene almacenada la aplicación.
a. Si su aplicación es un grupo de proyectos pulse clic en el nombre del grupo y luego
en Abrir. El icono de un grupo es .

19
b. Si su aplicación solo tiene un proyecto pulse clic en el nombre del proyecto y luego
en Abrir. El icono de un proyecto es .
c. También puede abrir un formulario únicamente, pero si el formulario es único se
abrirá también el proyecto. El icono de un formulario es .
Una vez abierta la aplicación para ver los formularios pulse doble clic en el formulario
deseado en el Explorador de proyectos.
2. La otra forma para abrir una aplicación es a través del menú Archivo. Una vez seleccionada
esta opción las instrucciones son las mismas que las descritas anteriormente.
7. EJECUTAR UNA APLICACIÓN
En cuanto a la ejecución de una aplicación existen diferentes opciones, algunas de ellas son útiles
para la depuración del código; no obstante, no se explicarán todas estas opciones. La forma de
ejecutar una aplicación es pulsando clic en el botón de la barra de herramientas. Si no existen
errores de sintaxis la aplicación se ejecutará correctamente, de lo contrario aparecerá un mensaje de
error
Si pulsa clic en Aceptar aparecerá un indicador del lugar donde se detectó el error
Desafortunadamente el error puede ser originado en otra sección del código.
También puede seleccionar Ayuda en la ventana de error y se desplegará una ventana indicando las
posibles fuentes de error.
Indicador de lugar donde se
detecta el error

20
Si no existe ningún error de sintaxis entonces la aplicación se ejecutará. Para detener la ejecución
basta pulsar clic en el botón cerrar de la ventana; dicho botón se encuentre en la esquina superior
derecha del formulario en ejecución. También puede pulsar clic en el botón de la barra de
herramientas.
RESUMEN
El Entorno de Desarrollo Integrado de Visual Basic proporciona al programador de una serie de
herramientas que facilitan la escritura de aplicaciones. De esta forma el programador se puede
dedicar a pensar más en el funcionamiento de la aplicación que en aspectos de interfaz.
Una aplicación en Visual Basic se puede ver como un conjunto de módulos cada uno de los cuales
está dividido en secciones. Esto es importante comprenderlo al momento de definir los
identificadores (lo cual se verá más adelante).
EJERCICIOS
1. Al inicial Visual Basic aparece la ventana Nuevo Proyecto
a. ¿Para que sirve la ficha Existente?
b. ¿Para que sirve la ficha Recientes?
2. Cierre Visual Basic
a. Inicie Visual Basic y pulse Cancelar en la Ventana de Nuevo proyecto
b. Describa al menos dos formas para Abrir un Nuevo Proyecto Exe Estándar.
Sugerencia: Explore la Barra de Herramientas y el menú Proyecto.
3. Utilizando el menú Ayuda investigue la definición de ASCII
4. ¿En Cuál modo se encuentra actualmente el IDE de Visual Basic?
a. Interfaz de Documento Simple (SDI)
b. Interfaz de Documentos Múltiples (MDI)
5. Utilizando el menú Ayuda ubique el manual de Visual Basic que viene incorporado.
6. ¿Cómo puede hacer para guardar un formulario únicamente?
7. Suponga que tiene una aplicación con un formulario y que ya ha guardado la aplicación
¿Cómo puede hacer para cambiar el nombre al formulario?
8. Describa los pasos para abrir una aplicación mediante el menú principal.
EVALUACIÓN
La evaluación de esta unidad será en base a la participación activa. Se incentivará la curiosidad
cautelosa al explorar las diferentes opciones del IDE de Visual Basic.

21
UNIDAD III. BREVE METODOLOGÍA DE PROGRAMACIÓN
CONTENIDO
1. Creación de algoritmos.
2. Planificación de interfaz de usuario.
1. Aplicar una metodología para la construcción de algoritmos para el paradigma modular y
Orientado a Objetos.
2. Aplicar una metodología para la creación de interfaz de usuario.
1. CREACIÓN DE ALGORITMOS
Cuándo se va a desarrollar una aplicación buena parte del tiempo consiste en el diseño de la misma.
Se debe planificar cada algoritmo que será codificado y la interfaz a utilizar. También se debe
procurar planificar ambas cosas independientemente del lenguaje de programación pero en función
de uno o más paradigmas de programación. Dado que VB responde a más de un paradigma de
programación, existen varias fases en las que se debe construir algoritmos. La siguiente es una
breve metodología para facilitar la construcción de aplicaciones.
1. Comprender el problema.
2. Identificar los subproblemas en que se puede dividir el problema
3. Identificar los elementos importantes. Estos pueden ser:
a. Objetos
b. Relaciones entre objetos
4. Escribir un algoritmo general donde se establecen las relaciones entre subproblemas
5. Escribir un algoritmo para cada subproblema.
A continuación se presenta un resumen del lenguaje algorítmico de pseudocódigo y flujograma para
la construcción de algoritmos mediante programación imperativa y modular.
Tabla 3.1. Símbolos para el lenguaje de pseudocódigo y flujograma
Pseudocódigo Flujograma
Inicio (o fin)
Leer <iv1>, <iv2>, ..., <ivn> <iv1
>, <iv2
>, ..., <ivn
><iv1
>, <iv2
>, ..., <ivn
>
Hacer <i1>←<e1>
<i2>←<e2>
...
<in>←<en>
<i1
>=<e1
>,
<i2
>=<e2
>,
...
<in
>=<en
>
<i1
>=<e1
>,
<i2
>=<e2
>,
...
<in
>=<en
>

22
Pseudocódigo Flujograma
Escribir <e1>, <e2>,... , <en>
<e1
>, <e2
>, ..., <en
><e1
>, <e2
>, ..., <en
>
<i>
Ejemplo 3.1. Se desea dividir dos números reales y mostrar el resultado.
Objetos: Los operando: A y B
Un operando tiene dos propiedades: Etiqueta y Campo de información
La suma: S
Un operando tiene dos propiedades: Etiqueta y Campo de información
Relaciones: La relación entre los operando y la suma es el operador: S=A+B
Algoritmo
Inicio
Repetir
Leer A y B
Si (Clic en Sumar) Entonces
Hacer S←A+B
Sino Si (Clic en Limpiar) Entonces
Hacer A←’’, B←’’
Hasta_que (Clic en Salir)
Fin
Dado que este es un curso introductorio a Visual Basic 6 no se profundizará en la POO, más bien se
presentarán algunas ideas intuitivas para el desarrollo de aplicaciones. Por ello, no se declararán
objetos, más bien se utilizarán los objetos existentes para construir los necesarios para las
aplicaciones.
2. PLANIFICACIÓN DE INTERFAZ DE USUARIO
Para crear una interfaz de usuario es necesario haber creado el algoritmo. Luego se planifican las
diferentes pantallas que se mostraran al usuario al realizar ciertas acciones.
Ejemplo 3.2. Interfaz para el Ejemplo 3.1.
Al ejecutar la aplicación aparecerá la ventana:

23
Al pulsar clic en Sumar se efectuar la suma de la celda bajo A y B y se mostrará en la celda bajo S.
Al pulsar clic en Limpiar se borrarán los números de de las celdas bajo A, B y C. Al pulsar Salir se
cerrará la ventana. Si al pulsar Sumar no hay valores en las celdas bajo A o B entonces aparecerá
otra ventana
Faltan datos numéricos, revise el
contenido de las celdas bajo A o B
Cerrar
Al pulsar clic en Cerrar esta ventana se cerrará y quedará la anterior tal y como estaba
anteriormente.
Algunas aplicaciones son más complejas y requieren de más de una ventana. El siguiente ejemplo
ilustra este hecho.
Ejemplo 3.3. El registro de estudiantes de un instituto de educación media requiere de las
siguientes operaciones.
1. Ingresar nuevos estudiantes
2. Eliminar estudiantes
3. Ingresar notas de los estudiantes por cada bimestre
4. Emitir un reporte de calificaciones para cada estudiante.
5. Actualizar o corregir datos de estudiantes
Para realizar estas tareas el sistema cuenta con un sistema de base de datos relacional
con los siguientes archivos:
1. Alumnos
2. Curso
3. Asignatura
4. Profesor
Para escribir una aplicación que simule este sistema es necesario segmentar el problema en
subproblemas. Aquí son evidentes los siguientes:
1. Agregar
2. Eliminar
3. Notas
4. Reporte
5. Actualizar
Estas operaciones requieren un algoritmo de búsqueda por lo que se agrega el subproblema:
6. Buscar
Un detalle sumamente importante al planificar la interfaz de una aplicación es el principio “Menos
es mas”. Lo cual significa que cuánto menos detalles innecesarios se incorporen a la interfaz más
productiva y atractiva será la aplicación. No es conveniente utilizar toda la gama de colores o
recargar una ventana con información. Cada ventana debe contener la información necesaria para
que el usuario se sienta cómodo y sea productivo. La interfaz debe permitir que el usuario utilice el
tiempo mínimo para realizar una actividad.

24
RESUMEN
Cuándo se va a desarrollar una aplicación buena parte del tiempo consiste en el diseño de la misma.
Se debe planificar cada algoritmo que será codificado. También se debe planificar cada sección de
interfaz de manera que permita realizar una tarea en el mínimo tiempo posible. La planificación de
los algoritmos y de la interfaz depende de los paradigmas a que responde la aplicación. En general
esto se planifica independientemente del lenguaje de programación.
EJERCICIOS
1. Para el Ejemplo 3.3 escriba en papel un boceto de la interfaz que podría presentarse al
desarrollar la aplicación.
2. Escriba un algoritmo para calcular el interés simple para un capital C prestado para un
tiempo T con una taza de interés de R. Luego diseñe una interfaz para la aplicación que
calcula en monto de interés.
EVALUACIÓN
Para esta unidad se evaluarán los Ejercicios propuestos. Se discutirán las soluciones plateadas y se
retroalimentará a fin de consolidar lo aprendido.

25
UNIDAD IV. IDENTIFICADORES, TIPOS DE DATOS, EXPRESIONES Y SENTENCIAS BÁSICAS
CONTENIDO
1. Tipos de datos definidos en Visual Basic 6.
2. Declaración de identificadores.
3. Construcción y clasificación de expresiones.
4. Tipo de sentencias definidas en Visual Basic.
1. Identificar los tipos de datos definidos en Visual Basic 6.
2. Definir identificadores necesarios para una aplicación.
3. Construir expresiones para la construcción de aplicaciones.
4. Identificar los diferentes tipos de sentencias básicas.
1. TIPOS DE DATOS
Un tipo de dato en un lenguaje de programación define un conjunto y operaciones sobre él. Un
elemento pertenece a dicho conjunto si cumple con las características del tipo de dato. Una de esas
características es cómo se almacenan los bits que representan esos valores en la memoria de la
computadora. Uno de los usos más frecuentes de los tipos de datos es la declaración de variables.
Cuando se declara una variable también puede proporcionar un tipo de dato. Todas las variables
tienen un tipo de dato que determina la clase de datos que pueden almacenar. De forma
predeterminada, si no proporciona un tipo de dato, la variable toma el tipo de dato Variant, este se
explicará más adelante. Los tipos de datos se aplican a otras cosas además de a las variables.
Cuando asigna un valor a una propiedad, dicho valor tiene un tipo de dato; los argumentos de las
funciones tienen también tipos de datos. De hecho, todo lo relacionado con datos en Visual Basic
tiene un tipo de dato. Visual Basic proporciona varios tipos de datos:
Tabla 4.1 Tipos de datos definidos en Visual Basic
Tipo Descripción
Carácter
para
declaración
Rango
Integer
Long
Single
Double
Currency
Entero
Entero largo
Punto flotante
Punto flotante
Punto decimal fijo
%
&
!
#
@
-32768 a 32767
-2147483648 a -2147483647
-3.49 E+38 a 3.49 E+38
-1.78 E+308 a -1.78 E+308
±922337203685477.5807
String
Byte
Cadena de caracteres
Carácter
$ 231
caracteres
0 a 255
Boolean
Date
Object
Variant
Decimal
Lógico
Fecha/Hora
Referencia a un objeto
Tipo variable
Números con 0 a 28 decimales
Este tipo no se puede declarar
directamente como decimal,
debe ser declarado como tipo
Variant
False o True
1/Enero/100 a 31/Diciembre/9999
Cualquier referencia a tipo Object
Almacena datos de cualquier tipo de los
anteriores
Con 0 decimales:
±79,228,162,514,264,337,593,543,950,335
Con 28 decimales:
±7,9228162514264337593543950335
±0,0000000000000000000000000001

26
Aunque el tipo Variant acepta datos de cualquier otro tipo usar un tipo de dato numérico emplea
normalmente menos espacio de almacenamiento que un tipo Variant.
Visual Basic proporciona varias funciones de conversión que puede usar para convertir valores en
tipos de datos específicos. Por ejemplo, para convertir un valor a Currency, utilice la función CCur:
PagoPorSemana = CCur(horas * PagoPorHora)
Tabla 4.2 Funciones de conversión entre tipos de datos
Funciones de
conversión
Convierten una
expresión en
Cbool Boolean
Cbyte Byte
Ccur Currency
Cdate Date
CDbl Double
Cint Integer
CLng Long
CSng Single
CStr String
Cvar Variant
CVErr Error
2. DECLARACIÓN DE IDENTIFICADORES
Un identificador es una palabra que se utiliza para representar algo. En POO este algo puede ser un
objeto, un proceso, un atributo o un hecho. Algunos identificadores tienen memoria asociada en la
cual es posible almacenar información, ejemplos de ellos son las variables y constantes.
Un identificador debe cumplir los siguientes requisitos:
• Debe comenzar con una letra.
• No puede incluir un punto o un carácter de declaración de tipo.
• No debe exceder de 255 caracteres.
• Debe ser único en el mismo alcance o ámbito, que es el intervalo desde el que se puede
hacer referencia a la variable: un procedimiento, formulario, etc.
2.1. Variables
Una variable es un identificador que almacena información de manera variable durante la ejecución
de un programa, es decir la información no necesariamente permanece constante en dicha variable
en el transcurso de la ejecución de la aplicación. Al declarar una variable se sigue el siguiente
formato:
<Ámbito> <iv> As <tipo>
donde
<Ámbito> puede ser: Public, Dim, Private, Static.
As <tipo> declara el tipo de dato que acepta <iv>. Esta parte puede ser omitida en una declaración,
en este caso también se omite el <Ámbito>.
Para almacenar valores durante la ejecución de una aplicación se utilizan variables. Al definir una
variable se debe especificar el identificador o nombre y el tipo de dato que almacena la variable. El
siguiente diagrama de ámbitos ilustra el alcance de una variable en relación al ámbito

27
Public
Dim o Private
Dim o Static
Ámbito 1
Ámbito 2
Ámbito 3
FIGURA 4.1. Diagrama de ámbitos de una aplicación
El diagrama muestra como se divide la aplicación en ámbitos en relación a los subprogramas que
contiene. Al ámbito 1 se refiere a toda la aplicación, es decir, una variable Public puede ser utilizada
en cualquier parte del Módulo, Dim y Private en una sección y Dim y Static en un procedimiento.
Si la variable a declarar es de tipo Variant entonces se omite As <tipo> en la sintaxis de
declaración.
Ejemplo 4.1. Declaración de variables
Private I As Integer
Dim Cantidad As Double
Static SuNombre As String
Public PagadoPorJuan As Currency
Private H As Integer, Amt As Double
Private Nombre As String, Pagado As Currency
Private Prueba, Cantidad, J As Integer
En el ejemplo anterior note que Prueba y Cantidad son variables de tipo Variant pues no se
especificó un tipo de dato para ellas.
2.1.1. Ámbito de las variables
Las variables que se declaran en un procedimiento mediante la instrucción Dim sólo existen
mientras se ejecuta el procedimiento. Cuando termina el procedimiento, desaparece el valor de la
variable. Además, el valor de una variable en un procedimiento es local a dicho procedimiento; es
decir, no puede tener acceso a una variable de un procedimiento desde otro procedimiento. Estas
características le permiten usar los mismos nombres de variables en distintos procedimientos sin
preocuparse por posibles conflictos o modificaciones accidentales.
Declarar una variable en la sección declaraciones (General) de un módulo de formulario, estándar o
de clase, en vez de en un procedimiento, hace que la variable esté disponible para todos los
procedimientos del módulo. Declarar una variable mediante la palabra clave Public hace que esté
accesible para toda la aplicación. Declarar una variable local mediante la palabra clave Static
preserva su valor aunque termine el procedimiento.
2.1.2. Declaración implícita
Contrario a otros lenguajes de programación en Visual Basic no se tiene por qué declarar una
variable antes de usarla. Esto puede resultar ventajoso el momento de desarrollar una aplicación
pero también puede ser peligroso para un programador inexperto. Las siguientes sentencias son
válidas aun sinde clarar las variables:
TempVal = Abs(num)

28
SafeSqr = Sqr(TempVal)
Visual Basic crea automáticamente una variable con ese nombre, la cual se puede usar como si la
hubiera declarado explícitamente. Aunque es cómodo, puede provocar errores sutiles en el código si
se equivoca de nombre de variable.
2.1.3. Declaración explícita
Para evitar problemas al equivocarse de nombre en las variables, puede estipular que Visual Basic
le avise siempre que encuentre un nombre que no se haya declarado explícitamente como una
variable. Para declarar variables de forma explícita se incluye esta instrucción en la sección General
del módulo de clase, de formulario o estándar:
Option Explicit
o bien en el menú Herramientas, elija Opciones, haga clic en la ficha Editor y active la opción
Requerir declaración de variables. Esto inserta automáticamente la instrucción Option Explicit en
los módulos nuevos, pero no en los ya creados, por lo que tendrá que agregar manualmente Option
Explicit a los módulos existentes en el proyecto.
Si no se declara apropiadamente una variable aparecerá
Indicando la variable que no ha sido definida
Al activar Requerir declaración de variables deberá reiniciar Visual Basic para que tenga efecto.
Marcar aquí para que
exija siempre
declaración explícita
de variables

29
Ejemplo 4.2.
1. Inicie Visual Basic si no está ejecutándose
2. Pulse doble clic sobre Form1
3. Escriba el código necesario para ver lo siguiente en el editor
Private Sub Form_Load()
A = 3
End Sub
4. Ejecute la aplicación (pulsando F5 o )
5. Detenga la ejecución de la aplicación pulsando .
6. Active Requerir declaración de variables
7. Cierre Visual Basic sin guardar la aplicación
8. Inicie nuevamente Visual Basic
A = 3
End Sub
11. Ejecute la aplicación.
12. ¿Qué ocurre?
13. Corrija el código de manera que se lea como:
Dim A
A=3
End Sub
14. Ejecute la aplicación
15. ¿Qué ocurre?
16. Desactive Requerir declaración de variables
17. Cierre Visual Basic
18. Inicie nuevamente Visual Basic
a = 3
End Sub
22. ¿Qué ocurre?
23. Seleccione de Lista desplegable de objetos en el formulario la sección (General)
24. Escriba Option Explicit en la sección (General)
26. ¿Qué ocurre?
La instrucción Option Explicit funciona sobre módulo a módulo; debe colocarse en la sección
Declaraciones de todos los módulos de formulario, estándar o de clase en los que desee que Visual
Basic obligue a declarar explícitamente las variables. Si activa Requerir declaración de variables,
Visual Basic insertará Option Explicit en todos los módulos de formulario, estándares o de clase
siguientes, pero no lo agregará en el código existente. Deberá agregar manualmente Option Explicit
a los módulos ya existentes en el proyecto.

30
2.1.4. Descripción del alcance de las variables
El alcance de una variable define qué partes del código son conscientes de su existencia. Cuando
declara una variable en un procedimiento, sólo el código de dicho procedimiento puede tener acceso
o modificar el valor de la variable; tiene un alcance que es local al procedimiento. A veces, sin
embargo, se necesita usar una variable con un alcance más general, como aquella cuyo valor está
disponible para todos los procedimientos del mismo módulo o incluso para todos los
procedimientos de toda la aplicación. Visual Basic le permite especificar el alcance de una variable
cuando la declara.
Dependiendo de cómo se declara, una variable tiene como alcance un procedimiento (local) o un
módulo.
Alcance Privado Público
Nivel de
procedimiento
Las variables son privadas del
procedimiento en el que aparecen.
No es aplicable. No puede declarar
variables públicas dentro de un
procedimiento.
Nivel de módulo Las variables son privadas del
módulo en el que aparecen.
Las variables están disponibles
para todos los módulos.
Las variables a nivel de procedimiento sólo se reconocen en el procedimiento en el que se han
declarado. Se las conoce también como variables locales. Se declaran mediante las palabras clave
Dim o Static. Por ejemplo:
Dim Temp As Integer
Static Permanent As Integer
Los valores de variables locales declaradas con Static existen mientras se ejecuta la aplicación,
mientras que las variables declaradas con Dim sólo existen mientras se ejecuta el procedimiento.
Las variables locales resultan una elección apropiada para cálculos temporales. Por ejemplo, puede
crear varios procedimientos distintos que contengan una variable llamada Temp. Como cada Temp
se ha declarado como una variable local, cada procedimiento sólo reconoce su propia versión de
Temp. Cualquier procedimiento puede alterar el valor de Temp local sin que ello afecte a las
variables Temp de los demás procedimientos.
Ejemplo 4.3. Declaración de variables
1. Inicie Visual Basic y seleccione Exe Estándar
2. Pulse doble clic en el botón CommandButton de la barra de controles.
3. Pulse doble clic en el botón Label de la barra de controles
4. Mueva los objetos para obtener la siguiente ventana:
5. Pulse doble clic sobre el formulario y seleccione la sección General y escriba el siguiente
código:
Function Suma(A, B As Single) As Single

31
Suma=A+B
End Function
6. Pulse doble clic en el botón Command1 y escriba el siguiente código:
Private Sub Command1_Click()
Dim X, Y As Single
X = 3
Y = 11
Label1.Caption = CStr(Suma(X, Y))
End Sub
7. Ejecute la aplicación y observe lo que ocurre al pulsar clic en el botón Command1
8. Detenga ejecución de la aplicación
9. Pulse doble clic en el botón Command1 y cambie las variables X y Y por A y B en
Command1_Click, el código debe quedar así:
Private Sub Command1_Click()
Dim A, B As Single
A = 3
B = 11
Label1.Caption = CStr(Suma(A, B))
End Sub
10. Ejecute nuevamente la aplicación. Nota algo diferente
En este último caso A y B aparecen definidas en la función Suma, como parámetros (variables
locales) y en el evento Command1_Click, como variables locales. Entonces A y B en Suma son
diferentes a A y B en Command1_Click. No obstante, como A y B son argumentos en la
sentencia de llamada:
Suma(A, B))
entonces el contenido de A y B de Command1_Click es transferido a A y B de la función Suma.
De forma predeterminada, una variable a nivel de módulo está disponible para todos los
procedimientos del módulo, pero no para el código de otros módulos. Cree variables a nivel de
módulo declarándolas con la palabra clave Private en la sección Declaraciones al principio del
módulo (General). Por ejemplo:
Private Temp As Integer
A nivel de módulo, no hay diferencia entre Private y Dim, pero es preferible Private porque
contrasta con Public y hace que el código sea más fácil de comprender.
Para hacer que una variable a nivel de módulo esté disponible para otros módulos, utilice la palabra
clave Public para declarar la variable. Los valores de las variables públicas están disponibles para
todos los procedimientos de la aplicación. Al igual que todas las variables a nivel de módulo, las
variables públicas se declaran en la sección Declaraciones al principio del módulo (General). Por
ejemplo:
Public Temp As Integer
No se puede declarar variables públicas en un procedimiento, sólo en la sección Declaraciones de
un módulo.
2.1.5. Variables estáticas
Además de un alcance, las variables tienen un tiempo de vida, el periodo de tiempo durante el cual
mantienen su valor. Se preservan los valores de las variables a nivel de módulo y públicas durante
el tiempo de duración de la aplicación. Sin embargo, las variables locales declaradas con Dim sólo

32
existen mientras se ejecuta el procedimiento en el cual se han declarado. Normalmente, cuando
termina la ejecución de un procedimiento, no se conservan los valores de sus variables locales y se
reclama la memoria utilizada por las variables locales. La próxima vez que se ejecute el
procedimiento se reinicializarán todas sus variables locales. Sin embargo, puede preservar el valor
de una variable local si hace que la variable sea estática.
Para hacer que todas las variables locales de un procedimiento sean estáticas, incluya la palabra
clave Static al principio del encabezado del procedimiento. Por ejemplo:
Static Function Total(Vent)
Esto hace que todas las variables del procedimiento sean estáticas sin tener en cuenta si se
declararon con Static, Dim, Private o de forma implícita. Puede colocar Static delante de cualquier
encabezado de procedimientos Sub o Function, incluyendo los procedimientos de eventos y
aquellos que se declararon como Private.
2.2. Constantes
A menudo existen en el código contiene valores constantes que reaparecen una y otra vez, o puede
que el código dependa de ciertos números que resulten difíciles de recordar (números que, por sí
mismos, no tienen un significado obvio). En estos casos se puede mejorar mucho la legibilidad del
código y facilitar su mantenimiento si se utiliza constantes. Una constante es un identificador
significativo que sustituye a un número o una cadena que no varía (constantes literales). Aunque
una constante recuerda ligeramente a una variable, no puede modificar una constante o asignarle un
valor nuevo como ocurre con una variable.
2.2.1. Crear constantes propias
La sintaxis para declarar una constante es la siguiente:
<Ámbito> Const <ic> As <tipo>=<expresión>
donde
<Ámbito> puede se: Public o Private.
<ic> es el identificador de constante.
As <tipo> declara el tipo de dato que acepta <iv>. Esta parte puede ser omitida en una declaración.
<expresión> determina el valor que toma la constante.
Ejemplo 4.4. Declaración de constantes
Const cPi = 3.14159265358979
Public Const cMaxPlanetas As Integer = 9
Una vez que defina las constantes, puede colocarlas en el código para hacerlo más legible. Por
ejemplo:
Static SistemaSolar(1 To conMaxPlanetas)
If numPersonas > conPopMundial Then Exit Sub
Una instrucción Const tiene igual alcance que una declaración de variable y se le aplican las mismas
reglas:
• Para crear una constante que sólo exista en un procedimiento, declárela dentro del
procedimiento.
• Para crear una constante disponible para todos los procedimientos de un módulo, pero no
para el código que está fuera del módulo, declárela en la sección Declaraciones del módulo.
• Para crear una constante disponible en toda la aplicación, declare la constante en la sección
Declaraciones de un módulo estándar y coloque delante de Const la palabra clave Public.
No se pueden declarar las constantes públicas en un módulo de clase o de formulario.

33
3. EXPRESIONES
Una expresión es la operación válida entre identificadores y valores literales. Existe una gran
variedad de operadores: aritméticos, de cadena, relacionales, lógicos, para conversión entre tipos de
datos, sobre arreglos, sobre objetos, entre otros. Los operadores son importantes porque permiten
producir y tener acceso a información. Algunos de los operadores más importantes utilizados en
este material son:
Tabla 4.3 Operaciones de Visual Basic
Tipo Operación Operador
Aritmético Potencia
Multiplicación
División
Suma
Resta
^
*
/
+
-
Relacional Igual
Distinto
Menor
Mayor
Menor o igual
Mayor o igual
=
<>
<
>
<=
>=
Lógico Negación
Conjunción
Disyunción inclusiva
Not
And
Or
Cadena de caracteres Concatenación &
Visual Basic cuenta además con una serie de funciones que permiten manipular cadenas de
caracteres.
Tabla 4.4. Funciones sobre cadenas de caracteres
Función Descripción
Len(iv) Número de caracteres de una cadena
LCase(x), UCase(x) Conversión a minúsculas o a mayúsculas
Str(n), CStr(n),Val(string) Conversión de cadenas a números y de
números a cadenas
Mid(string, ini[, n]),
Right(string, length),
Left(string, length)
Extracción de un nº de caracteres en un
rango, de la parte derecha o izquierda de
una cadena
el parámetro n de Mid es opcional
e indica el número de caracteres a
extraer a partir de "ini"
Split(string, [[delim], n]) Extracción de sub-cadenas
devuelve un array con las n (-1 para
todas) subcadenas separadas por
delim (por defecto, el espacio)
Join(string, [delim]) Unión de sub-cadenas
strComp(str1, str2) Comparación de cadenas de caracteres
devuelve -1, 0, 1 según str1 sea
menor, igual o mayor que str2

34
InStr([n], str1, str2) Hallar si una cadena es parte de otra
(está contenida como sub-cadena)
devuelve la posición de str2 en str1
buscando a partir del carácter n
InstrRev(str1, str2, [n]) Hallar una cadena en otra a partir del
final (reverse order)
devuelve la posición de str2 en str1
buscando a partir del carácter n
Replace(string, substring,
replacewith)
Buscar y reemplazar una subcadena por
otra en una cadena
reemplaza substring por
replacewith
Visual Basic también cuanta con funciones sobre tipos de datos numéricos
Tabla 4.5. Funciones sobre tipos de datos numéricos
Abs(x) Valor absoluto
Log(x) Logaritmo
Exp(x) Exponencial
Rnd Nº aleatorio
Sgn(x) Signo (1, 0, -1)
Round(x, ndec) Redondeo
Int(x), Fix(x) Parte entera
Sqr(x) Raíz cuadrada
Sin(x), Cos(x) Seno y coseno
Tan(x) Tangente
Atn(x) Arco tangente
4. SENTENCIAS DE ENTRADA, ASIGNACIÓN, SALIDA Y DE LLAMADA
La estructura básica de un algoritmo consiste de un mecanismo para capturar datos provenientes de
un entorno, un mecanismo para procesar esos datos y un mecanismo para devolver información al
entrono. Visial Basic cuenta con más de una sentencia que permite realizar estas tareas. Una
sentencia es una instrucción que indica que la aplicación debe realizar algo. Las sentencias más
básicas en una aplicación son las de entrada, las de proceso y las de salida.
4.1. Sentencia de entrada
Las sentencias de entrada permiten que la aplicación capture datos desde el entorno. La fuente de
datos en el entorno puede ser un usuario o un archivo de datos, entre otros. En el caso de que el
usuario proporcione datos a la aplicación usualmente lo hace mediante el teclado o el ratón.
Algunos componentes típicos para esto son los Caja de texto, Botón de opción (OptionBox) y
Casilla de verificación (CheckBox). Se tratará con más detalle la Caja de texto (TextBox) porque
permite al usuario ingresar a la aplicación datos de diversos tipos.
Cuando el usuario ingresa datos mediante una Caja de texto lo que hace es modificar la propiedad
Text, la cual, como su nombre lo indica, almacena texto. Sin embargo mediante operaciones de
conversión es posible pasar de texto a otro tipo de datos siempre y cuando sea compatible.

35
4.2. Sentencia de asignación
Este tipo de sentencia es de suma importancia porque permite trasladar el valor de una expresión a
una variable. Una sentencia de asignación tiene la sintaxis siguiente:
<iv>=<e>
Donde <iv> es un identificador de variable, el cual puede ser una variable declarada por el
programador o una propiedad de un objeto. La expresión <e> es evaluada y el valor resultante es
asignado a <iv>. Por supuesto, el tipo de dato de <e> debe ser compatible con el de <iv>.
4.3. Sentencia de salida
Al igual que la sentencia de entrada la sentencia de salida es una forma de comunicación entre el
entorno y el algoritmo. Este tipo de sentencia permite que la aplicación devuelva información hacia
el entorno ya sea a un usuario, a un archivo entre otros. En el caso de que se proporcione
información al usuario se pueden utilizar objetos como Etiqueta y Caja de texto entre otros
Ejemplo 4.6. Escribir una aplicación para el Ejemplo x.
1.Sino está ejecutando Visual Basic inícielo. Si ya está en ejecución cierre la aplicación actual y
abra una nueva de tipo Exe Estándar
2. Coloque sobre el formulario Form1 los elementos necesario para obtener lo siguiente:
Procure que los elementos que coloca en el formulario estén en el orden Label1 para A,
Label2 para B, Label3 para S, Label4 para + y Label5 para =; Text1 para tA, Text2 para tB y
Text3 para tS; Command1 para Sumar, Command2 para Limpiar y Command3 para Salir.
3.Cambie la propiedad Caption de acuerdo a las indicaciones anteriores y la propiedad Text de
los objetos Text debe estar en blanco.
4.Cambie el nombre de los objetos:
a. Label1 por lA, Label2 por lB y Label3 por lS
b. Text1 por A, Text2 por B y Text3 por S
c. Command1 por cSumar, Command2 por cLimpiar y Command3 por cSalir.
5. Pulse doble clic en el botón Limpiar y escriba el siguiente código:
Private Sub cSumar_Click()
Dim A, B, S As Single
A = CSng(tA.Text)
B = CSng(tB.Text)
S = A + B
tS.Text = CStr(S)
End Sub
6. Pulse doble clic en Salir y escriba el siguiente código
Private Sub cSalir_Click()
End
End Sub
7. Pulse clic en Limpiar y escriba el siguiente código
Private Sub cLimpiar_Click()

36
tA.Text = ""
tB.Text = ""
tS.Text = ""
End Sub
8. Guarde la aplicación en una carpeta llamada Suma
a.El formulario con nombre Principal
b.El proyecto con nombre Suma
El lector puede identificar en esta aplicación los diferentes tipos de variables, expresiones y
sentencias.
4.5 Sentencia de llamada
En el Ejemplo 4.3 la sentencia
Suma(A, B))
Es una sentencia de llamada. Una sentencia de llamada permite ejecutar funciones y
procedimientos. Casi todos los objetos en Visual Basic poseen un conjunto de funciones y
procedimientos llamados eventos, por ello las sentencias de llamada son fundamentales en este
lenguaje. Muchas sentencias de llamada se ejecutan de manera automática, otras se ejecutan por la
acción del usuario a través del teclado o el ratón. En el Ejemplo 4.3 cuando el usuario pulsa clic en
el botón Command1 se ejecuta el evento Command1_Click.
RESUMEN
En un lenguaje de programación, con los paradigmas aquí mencionados, los conceptos de valor
literal, identificador, tipo de dato, expresión y sentencia son fundamentales por que una aplicación
es, en última instancia un conjunto de dichos elementos. Los tipos de datos en un lenguaje
caracterizan a los valores en un determinado conjunto y determinan que operaciones se pueden
efectuar sobre ellos. Un identificador representa un hecho, atributo, proceso u objeto. Algunos
identificadores permiten almacenar valores ya sea de manera variable o constante. Las operaciones
válidas entre valores literales e identificadores generan expresiones. Visual Basic facilita una gran
variedad de operaciones y funciones sobre expresiones ya sean de tipo numérico, cadena o lógicas.
Las sentencias son órdenes que el programa debe ejecutar y usualmente actúan sobre expresiones.
Tres de las sentencias más básicas son las de entrada, las de proceso y las de salida pero en el caso
de los lenguajes orientados a objetos y a eventos son fundamentales las sentencias de llamada o
invocación, las cuales se requieren para utilizar funciones y procedimientos. Un tipo especial de
funciones y procedimientos son los eventos, los cuales están presentes en casi todos los objetos de
Visual Basic
Los identificadores en una aplicación tienen efecto en diferentes ámbitos de la aplicación. Estos
ámbitos están relacionados con la sección de la aplicación donde se declaran y también se
especifican con las palabras Public, Dim, Static y Private.
EJERCICIOS
1. Escriba una aplicación que muestre el área de un círculo. El usuario deberá ingresar el
radio. También la aplicación deberá contener una constante llamada cPi con valor 3.14.
Además, la aplicación deberá tener una función llamada Area para el cálculo del área, dicha
función será invocada al pulsar clic en el botón Calcular, luego se mostrará el área en la
etiqueta correspondiente. La interfaz de la aplicación será:

37
2. Escriba una aplicación para el Ejercicio 2 de la unidad anterior.
EVALUACIÓN
Se revisará la correcta realización de los ejercicios de esta sección. También se considerará la
participación y generación de ideas.

38
UNIDAD V. SENTENCIAS DE DECISIÓN
CONTENIDO
1. Concepto de sentencias de decisión.
2. Sentencia If… Then… Else
3. Sentencia Select Case.
4. Sentencias de decisión anidadas.
1. Definir sentencia de decisión
2. Comprender la sentencia If… Then… Else
3. Aplicar sentencias If… Then… Else
4. Aplicar sentencias de decisión anidadas.
5. Comprender la sentncia Select Case
6. Aplicar sentencias Select Case
Existen otras sentencias que son de suma importancia para la creación de aplicaciones. Estas son las
sentencias de decisión y las sentencias repetitivas. Visual Basic cuenta con más de una sentencia
para cada uno de estos tipos.
1. SENTENCIAS DE DECISIÓN
Una sentencia de decisión permite ejecutar otras sentencias en función del valor de verdad de una
expresión lógica. Estas sentencias son de suma importancia porque en la mayoría de los procesos de
la realidad las acciones están condicionadas.
1.1. Sentencia de decisión IF ... THEN ... ELSE ...
Permite ejecutar una o más sentencias de manera condicionada. Existen tres formas para escribir la
sentencia if. Su sintaxis es la siguiente:
If <el> Then
<sentencia 1>
If <el> Then
<sentencia 1>
Else <sentencia 2>
End If
If <el1> Then
<Sentencia 1>
ElseIf <el2> Then <sentencia 2>
…
ElseIf <eln> Then <sentencia n>
Else <sentencia n+1>
End If
Donde <el> es una expresión lógica
Los grupos de sentencias <Sentencia i> se ejecutan dependiendo del valor de verdad de la
expresión lógica
Ejemplo 5.1. Dados el nombre y cuatro notas parciales de un alumno calcular su nota promedio y
mostrar el nombre, la nota promedio y un mensaje según la siguiente tabla:

39
Promedio (P) Mensaje
0-59 Reprobado
60-100 Aprobado
1. El siguiente algoritmo muestra como se ha de calcular la nota y determinar el mensaje
Notas
{Este algoritmo capturar el nombre y cuatro notas parciales, luego calcula la nota promedio
y muestra el nombre, la nota promedio y un mensaje
Nombre es el nombre del alumno
N1, N2, N3, N4 son als cuatro notas parciales
NP es la nota promedio}
Inicio
Leer Nombre, N1, N2, N3, N4
Hacer NP← (N1+N2+N3+N4)/4
Escribir Nombre, NP
Si NP<60 Entonces Escribir “Reprobado”
Sino Escribir “Aprobado”
Fin
2. Se diseñará la siguiente interfaz:
La siguiente tabla resume las propiedades de cada objeto:
Objeto Propiedad Valor
Form1 (Nombre)
Caption
Principal
Cálculo de Nota Promedio
Label1 (Nombre)
Font
Caption
lNombre
Negrita, 12
Nombre
Label2 (Nombre)
Caption
lN1
Nota 1:

40
Label3 (Nombre)
Caption
lN2
Nota 2:
Label4 (Nombre)
Caption
lN3
Nota 3:
Label5 (Nombre)
Caption
lN4
Nota 4:
Label6 (Nombre)
Caption
lResultados
Resultados
Text1 (Nombre)
Text
tNombre
En blanco
Text2 (Nombre)
Text
tN1
En blanco
Text3 (Nombre)
Text
tN2
En blanco
Text4 (Nombre)
Text
tN4
En blanco
Text5 (Nombre)
Text
tN4
En blanco
Command1 (Nombre)
Caption
cCalcular
Calcular
Command2 (Nombre)
Caption
cLimpiar
Limpiar
Command3 (Nombre)
Caption
cCerrar
Cerrar
3. Pulse doble clic en Calcular y escriba el siguiente código:
Private Sub cCalcular_Click()
Dim Nombre As String * 45
Dim N1, N2, N3, N4 As Single
Dim NP As Integer
N1 = CSng(tN1.Text)
N2 = CSng(tN2.Text)
N3 = CSng(tN3.Text)
N4 = CSng(tN4.Text)
Nombre = tNombre.Text
NP = CInt(N1 + N2 + N3 + N4) / 4
tResultados.Text = Nombre + " " + CStr(NP)
End Sub
4. Pulse doble clic en Limpiar y escriba el siguiente código:
Private Sub cLimpiar_Click()
tNombre = ""
tN1 = ""
tN2 = ""
tN3 = ""
tN4 = ""
tResultados = ""
End Sub
5. Pulse doble clic en Cerrar y escriba el siguiente código
Private Sub cCerrar_Click()

41
End
End Sub
6. Guarde la aplicación en una carpeta llama Notas
a. Guarde el formulario Principal (Form1) con el nombre Principal
b. Guarde el proyecto con el nombre Notas
7. Ejecute el programa y pruébelo con algunos datos
8. Cierre la aplicación
También pueden existir sentencias de decisión anidadas. El siguiente ejemplo ilustra esta situación
Ejemplo 5.2. Una empresa de correos ha clasificado los lugares de destino en cuatro grupos. El
costo de envío de un paquete depende del peso, en gramos, y del lugar de destino conforme a la
siguiente tabla:
Grupo de destino Peso Costo
Grupo 1 0-1
1-3
3-5
7.50
15.20
20.90
Grupo 2 0-3
3-6
6-12
20.00
40.00
55.50
Grupo 3 0-5
5-10
10-15
21.50
45.00
62.10
Dados el peso en gramos de una carta y el lugar de destino determinar el costo de envío
1. El siguiente algoritmo muestra como se ha de calcular la nota y determinar el mensaje
Correo
{Este algoritmo permite capturar el peso en gramos y el lugar de destino de un paquete y
devuelve el costo de envío
Lugar es el lugar de destino
Peso es el peso en gramos
Costo es el costo de envío}
Inicio
Leer Lugar, Peso
Si Lugar=1 Entonces
Si 0<Peso≤1 Entonces Hacer Costo=7.5
Sino Si 1<Peso≤3 Entonces Costo=15.20
Sino Escribir “Peso no válido para un paquete”
Sino Si Lugar=2 Entonces
Si 0<Peso≤3 Entonces Costo=20.00
Sino Si Lugar=3 Entonces
Si 0<Peso≤5 Entonces Costo=21.50

42
Sino Escribir “Lugar no válido”
Fin
2. Se diseñará la siguiente interfaz:
3. La siguiente tabla resume las propiedades de cada objeto:
Form1 (Nombre)
Caption
Principal
Costo de envío de paquetes
Label1 (Nombre)
Font
Caption
lLugar
Negrita, 12
Lugar
Label2 (Nombre)
Font
Caption
lPeso
Negrita, 12
Peso
Label3 (Nombre)
Font
Caption
lCosto
Negrita, 12
Costo:
Label4 (Nombre)
Font
Caption
lMensaje
Negrita, 12
En blanco
ListBox (Nombre)
List
Font
lbLugar
Grupo 1
Grupo 2
Grupo 3
Normal, 12
Text1 (Nombre)
Text
Font
tPeso
En blanco
Normal, 12
Command1 (Nombre)
Caption
cCalcular
Calcular
Command2 (Nombre)
Caption
cLimpiar
Limpiar
Command3 (Nombre)
Caption
cCerrar
Cerrar
4. para agregar elementos a la propiedad List del objeto ListBox

43
a. Pulse doble clic en la casilla de valor (Lista) de la propiedad y se desplegará una
lista vacía
b. Escriba Grupo 1 y luego pulse ctrl.+Enter para añadir una nueva fila vacía
c. Escriba Grupo 2 y luego pulse ctrl.+Enter para añadir una nueva fila vacía
d. Escriba Grupo 3 y luego pulse Enter para finalizar la lista
5. Para Label4 colóquela justo por encima de los botones Calcular , Limpiar y Cerrar
6. Pulse doble clic en Calcular y escriba el siguiente código:
Private Sub cCalcular_Click()
Dim Lugar As String
Dim Peso, Costo As Single
lbLugar.ListIndex = 0
Lugar = lbLugar.ListIndex
Peso = CSng(tPeso.Text)
If Lugar = 0 Then
If (0 < Peso) And (Peso <= 1) Then
Costo = 7.5
ElseIf (1 < Peso) And (Peso <= 3) Then
Costo = 15.2
Costo = 20.9
Else
lMensaje.Caption = "Peso no válido para un paquete"
End If
ElseIf Lugar = 1 Then
Costo = 20
Costo = 40
Costo = 55.5
Else
End If
ElseIf Lugar = 2 Then
Costo = 21.5
Costo = 45
Costo = 62.1
Else
End If
Else
lMensaje.Caption = "Lugar no válido"
End If
If Costo > 0 Then lCosto.Caption = "Costo: " + CStr(Costo)
End Sub

Introducción a visual basic upn 6 final

Introducción a visual basic upn 6 final

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Destacado

Destacado (11)

Similar a Introducción a visual basic upn 6 final

Similar a Introducción a visual basic upn 6 final (20)

Último

Último (20)

Introducción a visual basic upn 6 final