Manual de Macros

MANUAL DE VBA PARA EXCEL 2010
MANUAL DE VBA PARA

EXCEL 2010
AUTOR DEL MANUAL
Miguel Ángel de la Torre Hernández
Página 1 de 175
CENTRO DE FORMACIÓN
MSL Formación
C/ Marqués de Ahumada, 7-2ª planta (28028), Madrid
Tlf:91 724 92 09/35
Email: formacion@mslformacion.es
http://www.mslformacion.es/
FORMADOR DEL CURSO
Miguel Ángel de la Torre Hernández
Email: delatorre.miguelangel@gmail.com
Este manual, así como las prácticas proporcionadas para la

realización del curso, han sido elaborados por el formador del curso
Miguel Ángel de la Torre Hernández.
La combinación de ambos elementos constituyen aspectos
esenciales para la correcta asimilación y aprendizaje de los
contenidos que se van a impartir.
(Octubre, 2014)
Página 2 de 175
INDICE
LECCIÓN 1. LA GRABACIÓN DE MACROS .................................................................. 6
Diferentes utilidades de una macro .............................................................................. 6
Crear una macro automáticamente .............................................................................. 8
Ejecutar una macro..................................................................................................... 11
LECCIÓN 2. ASPECTOS BÁSICOS DEL LENGUAJE VBA (VISUAL BASIC FOR
APPLICATIONS). ........................................................................................................... 18
El entorno del editor de Visual Basic.......................................................................... 22
La ventana de proyecto ........................................................................................... 23
La ventana de Propiedades .................................................................................... 23
La ventana de Código ............................................................................................. 24
La ventana de inmediato ......................................................................................... 24
El menú del editor de Visual Basic ......................................................................... 24
La barra de botones ................................................................................................ 24
Configuración del Editor de VBA ................................................................................ 28
Guardar archivos con Macros..................................................................................... 29
LECCIÓN 3. LOS MÓDULOS ........................................................................................ 31
Los procedimientos ..................................................................................................... 32
Los procedimientos de función ................................................................................... 33
Sintaxis o estructura de los procedimientos y funciones ........................................... 34
Llamadas a los procedimientos .................................................................................. 35
LECCIÓN 4. EL MODELO DE OBJETO DE EXCEL..................................................... 36
Objetos, colecciones habituales ................................................................................. 37
El complemento automático de las instrucciones. ..................................................... 38
Reglas de escritura de código .................................................................................... 39
Crear fórmulas con VBA. ............................................................................................ 41
Estilo Formula.......................................................................................................... 41
Estilo FormulaL1C1 ................................................................................................. 41
Algunos ejemplos de procedimientos que modifican las propiedades de objetos de
Excel:........................................................................................................................... 44
LECCIÓN 5.EL USO DE VARIABLES EN VBA............................................................. 56
Los tipos de variables ................................................................................................. 57
Variable de tipo texto (o cadena). ........................................................................... 58
Página 3 de 175
Variable de tipo Booleana ....................................................................................... 59

Variable de tipo Fecha ............................................................................................ 59
Variable de tipo Variant. .......................................................................................... 59
Variable de tipo Objeto. ........................................................................................... 60
El alcance de las variables ......................................................................................... 60
La declaración de variables ........................................................................................ 61
Declaración implícita. .............................................................................................. 61
Declaración explícita. .............................................................................................. 62
Los operadores ........................................................................................................... 63
Operador & .............................................................................................................. 64
Variables estáticas ...................................................................................................... 64
Variables de objeto: Instrucción Set ........................................................................... 65
Las constantes ............................................................................................................ 65
Las matrices ................................................................................................................ 67
LECCIÓN 6. ESTRUCTURAS DE DECISIÓN Y SELECCIÓN ..................................... 76
Instrucción IF............................................................................................................... 77
Operadores lógicos en expresiones condicionales. ............................................... 78
Instrucción Select........................................................................................................ 82
Diseño de funciones básicas ...................................................................................... 84
LECCIÓN 7. ESTRUCTURAS DE REPETICIÓN Y BUCLE ......................................... 91
Instrucción For … Next ............................................................................................... 91
Instrucción For Each … Next...................................................................................... 94
Estructuras en bucle ................................................................................................... 95
Sintaxis 1: Instrucción Do While … Loop................................................................ 95
Sintaxis 2: Instrucción Do … Loop While................................................................ 96
LECCIÓN 8. LOS PROCEDIMIENTOS FUNCTION ................................................... 106
LECCIÓN 9: FORMULARIOS ...................................................................................... 112
Crear un formulario ................................................................................................... 113
Controles del formulario............................................................................................ 116
Sucesos de los controles.......................................................................................... 119
Ejemplo 01: Formulario para agregar datos a la hoja. ......................................... 121
Ejemplo 02: Formulario para realizar diferentes cálculos con los datos de la hoja
para luego grabarlos en una hoja determinada. ................................................... 128
Página 4 de 175
LECCIÓN 10. LAS TABLAS DINÁMICAS.................................................................... 135

Conceptos previos sobre tablas dinámicas.............................................................. 135
Crear una tabla dinámica en Excel con VBA. .......................................................... 140
Recuperar los campos de una tabla dinámica ......................................................... 146
Recuperar los diferentes valores de un campo........................................................ 147
Obtener un dato determinado de la tabla dinámica. ................................................ 149
Obtener el mismo dato de los diferentes valores de un campo. ............................. 150
LECCIÓN 11. DEPURACIÓN Y ERRORES................................................................ 153
Errores de sintaxis. ................................................................................................... 153
Errores de compilación. ............................................................................................ 155
Errores de ejecución. ................................................................................................ 157
Errores de lógica. ...................................................................................................... 158
Depuración del código .............................................................................................. 158
Ventana Locales ....................................................................................................... 159
Ventana Inmediato .................................................................................................... 160
Gestión de errores en VBA. ...................................................................................... 160
LECCIÓN 12. COMPLEMENTOS (ADD INS) ............................................................. 163
LECCIÓN 13. SEGURIDAD DE MACROS.................................................................. 169
Macros privadas y proteger el código ...................................................................... 170
Acelerar el código ..................................................................................................... 173
Página 5 de 175
LECCIÓN 1. LA GRABACIÓN DE MACROS
La Hoja de Cálculo Excel es una de las herramientas más poderosas para el

tratamiento de datos y su análisis. Una de las mayores ventajas que posee es la
flexibilidad que ofrece y la rapidez con la que podemos construir plantillas y todo tipo
de modelos, para diversos usos y aplicaciones.
Sin embargo, si realmente quieres sacarle el mayor partido a Excel, deberás

conocer y utilizar una de sus mayores y más potentes herramientas que dispone,
como son: LAS MACROS.
Pero, ¿qué es una Macro? Es un conjunto de instrucciones de código

(programado) que permiten realizar una tarea determinada, como así también expandir
e incrementar las prestaciones de Excel. Las macros se escriben en lenguaje de
programación VBA (Visual Basic for Applications). Además Excel ya trae incorporado
un editor de VBA, por lo que las macros se programan dentro del mismo programa
Excel.
Con las macros lo que se pretende es automatizar varias tareas y fusionarlas en

una sola, añadiendo por ejemplo un botón en nuestro libro, que al pulsar sobre él
realice todas esas tareas que hemos grabado previamente, como pueda ser la
consolidación de diferentes libros, ejecutar un filtro de manera automática, así como
personalizar con un único clic toda la apariencia de nuestra hoja.
Diferentes utilidades de una macro
Anteriormente definimos a las macros como algo que nos permite expandir e
incrementar las prestaciones de la hoja Excel. A grandes rasgos podemos comentar
que las 4 grandes “áreas” donde se aplican las macros son:
1. Automatización de procesos
Supongamos que todos los días debemos trabajar en nuestro libro Excel en el cual
debemos seleccionar un rango, centrarlo, cambiarle la fuente, poner la fuente en
cursiva, aplicarle negrita y finalmente aplicarle bordes a toda la selección. Estas 6
acciones las hacemos manualmente y no parecen muchas, ¿pero qué tal si hay que
hacer esto en repetidas ocasiones y todos los días? Una macro nos permite ejecutar
los 6 pasos automáticamente, tan solo presionando un botón o una tecla. Las tareas
ideales para automatizar son aquellas que se hacen de forma repetida e involucran
muchos pasos, por ejemplo: imprimir informes, configurar la vista de la hoja, actualizar
datos de tablas dinámicas, modificar el diseño de una hoja, etc...
Página 6 de 175
2. Creación de funciones a medida
Las funciones y fórmulas Excel son quizás la esencia de la hoja de cálculos (si no
se pudieran utilizar funciones y fórmulas no habría cálculos). Excel trae incorporada
más de 300 funciones estándar las cuales se pueden utilizar en forma aislada o en
forma combinada (anidadas). Sin embargo, suele suceder que justo la función que
necesitamos no existe. Así que con la programación podemos programar funciones a
medida que hagan exactamente lo que nosotros queremos. Y esas funciones se
comportarán igual que las de Excel, estas aparecerán en la categoría de funciones
Definidas por el usuario y tendrán los argumentos que hayamos decidido.
3. Creación de nuevos comandos, complementos y menús
Excel trae una gran cantidad de comandos y menús predefinidos que nos asisten
para las operaciones más habituales. Las macros nos permiten crear nuestros propios
comandos y menús personalizados, e incorporarlos al Excel. La utilidad de los mismos
depende tan solo de nuestras necesidades. Los complementos Excel también están
creados con macros. Si acudes al menú Herramientas > Complementos verás una
lista de los que tienes instalado en tu Excel. Los mismos suelen ser distribuidos de
forma gratuita o también se compran. Su utilidad reside en agregar alguna
funcionalidad extra a Excel para mejorar su funcionamiento, o personalizar sus
comandos.
4. Creación de aplicaciones a medida
Excel es utilizado en diversos campos y por una gran cantidad de usuarios. Las
macros te permitirán construir complejas y elegantes aplicaciones para cualquier uso
que quieras darles. El límite está solo en tu imaginación. Una aplicación Excel consiste
en algo más que una simple plantilla con datos y fórmulas. Una aplicación Excel es un
verdadero programa de software con una serie de características que lo hacen
utilizable, por cualquier usuario, sin que el mismo tenga que entender la lógica de
Excel que hay por detrás.
Página 7 de 175
Crear una macro automáticamente
La forma más fácil e intuitiva de crear macros es crearlas mediante el grabador de

macros del que dispone Excel. Este grabador de macros te permite grabar las
acciones deseadas que posteriormente serán traducidas al lenguaje de VBA, las
cuales podremos modificar posteriormente si tenemos conocimientos de programación
en este lenguaje.
Para grabar una macro debemos acceder a la ficha Vista y desplegar el submenú
Macros y dentro de este submenú seleccionar la opción Grabar macro...
Otra posibilidad para poder poner en marcha la grabadora de macros, la puedes

encontrar en la ficha de Programador, que no suele estar visible junto al resto de
fichas en las versiones 2007 y 2010 de Excel.
Si no tienes visible la ficha Programador, puedes activarla en la versión de Excel

2010 de la siguiente forma:
1) Presiona el botón de Archivo (botón verde en la parte superior izquierda

de la pantalla)
2) En la parte inferior del menú que se despliega, presiona el botón

Opciones.
3) En la lista de Personalizar cinta de opciones marca la casilla de

Programador para que podamos ver esta ficha en la cinta de opciones.
Página 8 de 175
Además de esta opción de grabación en el menú de Macros podemos encontrar

las siguientes opciones:
 Ver Macros... - Donde accedemos a un listado de las macros creadas en ese

libro.
 Usar referencias relativas - Con esta opción utilizaremos referencias relativas
para que las macros se graben con acciones relativas a la celda inicial
seleccionada, o en las mismas referencias, si el botón de Usar referencias
relativas esta desactivado.
Al seleccionar la opción Grabar

macro..., lo primero que vemos es el
cuadro de diálogo Grabar macro, en
donde podemos especificar la
siguiente información relacionada con
la macro:
Página 9 de 175
 Nombre de la macro: donde podemos dar un nombre a la macro, no está

permitido insertar espacios en blanco en el nombre de la macro, ni caracteres
especiales (#, %,@, etc.,).
 Método abreviado: mediante la combinación de las tecla CTRL + “una tecla
del teclado”. El problema está en encontrar una combinación que no utilice ya
Excel.
 Guardar macro en: con esta opción podemos seleccionar guardar la macro en
el libro activo, en el libro de macros personal o en otro libro, si la guardamos en
el libro de macros personal la macro estará disponible para cualquier libro que
abramos en Office.
 Descripción: podemos describir cuál es el cometido de la macro o cualquier
otro dato que creamos conveniente con respecto a la macro.
Para comenzar la grabación de la macro pulsamos el botón Aceptar y a

continuación, si nos fijamos en la barra de estado, encontraremos este botón en la
barra de estado donde tenemos la opción de Detener la grabación.
NOTA: A partir de entonces debemos realizar las acciones que queramos grabar, es
conveniente no seleccionar ninguna celda a partir de la grabación, ya que si
seleccionamos alguna celda posteriormente, cuando ejecutemos la macro, la selección
nos puede ocasionar problemas de celdas fuera de rango.
Una vez finalizadas el conjunto de las acciones que queremos grabar, podemos
presionamos sobre el botón Detener de la barra de estado, por ejemplo. Es muy
importante estar pendiente de detener la grabación, cuando hayamos realizado
nuestra última acción, ya que si no detenemos la grabación, la macro seguirá
grabando el resto de acciones que estemos realizando.
Página 10 de 175
Ejecutar una macro
Una vez creada una macro, la podremos ejecutar las veces que queramos.
Antes de dar la orden de ejecución de la macro, dependiendo del tipo de macro

que sea, será necesario seleccionar, o no, las celdas que queramos queden afectadas
por las acciones de la macro.
Por ejemplo, si hemos creado una macro que

automáticamente da formato a las celdas seleccionadas,
tendremos que seleccionar las celdas previamente antes
de ejecutar la macro. Para eso acudiremos a la opción de
Ver macros de la ficha de Vista, donde podremos
seleccionar y ejecutar la macro previamente grabada.
Desde esta ventana podemos tanto Ejecutar la macro

seleccionada, así como Eliminar la macro si no tenemos pensado volver a utilizarla, y
hasta editarla o Modificarla en el editor de Visual Basic para Aplicaciones, pero para
lo cual tenemos que tener ciertas nociones de programación en Vba.
Existe otra posibilidad además de la anteriormente mostrada para poder ejecutar

una macro, como por ejemplo, hacer un clic en algún botón situado en una ficha
personalizada de nuestra cinta de opciones, e incluso, se podría asociar su ejecución
a un botón incrustado en la propia hoja de cálculo.
Página 11 de 175
En el primer caso de asociar una macro a algún botón de la cinta de opciones lo

primero es crear una nueva ficha para poder ubicar el botón en dicha ficha. Los pasos
a seguir serían los siguientes:
1) Presiona el botón de Archivo (botón verde en la parte superior

izquierda de la pantalla)
Opciones.
3) En la lista de Personalizar cinta de opciones pulsaremos el botón de
Nueva ficha a la cual le podemos poner el nombre de Mis macros, en
dicha ficha aparecerá también un grupo al cual se puede poner un
nombre asociado al tipo de acciones que tengamos pensado incorporar.
A partir de ese momento en la cinta de opciones aparecerá una nueva ficha en la

cual podremos incorporar botones para ejecutar nuestras macros sin tener que acudir
al menú específico de las macros, lo cual facilitará la ejecución de la macro.
Página 12 de 175
NOTA: La ficha la puedes cambiar de posición en la cinta de opciones simplemente

arrastrándola desde la ventana Personalizar cinta de opciones a la posición que
desees.
En esta ficha se puede incorporar cualquiera de los botones que necesitemos pero
el botón al cual asociaremos nuestra macro, lo encontraremos buscándolo en el
desplegable de Comandos disponibles en, y seleccionando la opción de Macros. En
el momento de seleccionar la opción de Macros aparecerán las diferentes macros
grabadas anteriormente.
Para agregar el botón a nuestra ficha de Mis macros, simplemente tendremos que
seleccionar el botón con el nombre de la macro que previamente habíamos creado por
la grabadora de macros, y pulsar el botón de Agregar >> que se encuentra entre las
dos listas.
Página 13 de 175
Si además queremos cambiar la imagen y texto del botón, deberemos seleccionar

previamente el botón agregado, y a continuación pulsar el botón de Cambiar nombre
que podemos encontrar en la ventana de Personalizar cinta de opciones, para que
nos aparezca una ventana igual a la de la ilustración siguiente, en la cual podremos
realizar dichos cambios.
A partir de ese momento tendremos disponible dicho botón en nuestra ficha, para
poder ejecutar directamente la macro previamente creada.
La otra posibilidad de incrustar un botón en nuestra hoja de cálculo para poder

ejecutar la macro desde la propia hoja de cálculo, sin tener que acudir a ninguna ficha,
en tal caso, podemos recurrir a dos posibilidades diferentes:
Página 14 de 175
1) Utilizar cualquier forma de las que nos proporciona la ficha Insertar
Una vez incorporada tendremos que seleccionarla, y haciendo uso del menú
contextual del ratón, seleccionaremos la opción Asignar macro.
Página 15 de 175
Seleccionada la opción aparecerá una ventana donde podremos seleccionar

una macro entre una lista de macros grabadas en nuestro fichero.
2) La otra posibilidad para asociar la macro a un botón dentro de la hoja la

encontramos en la ficha Programador, donde se encuentran una serie
de controles de formularios, especialmente diseñados para la
asignación de macros.
De estos controles el más adecuado para asociar una macro para su ejecución,
sería el botón (el primero de la fila superior), ya que en el momento de ser
seleccionado e insertado en nuestra hoja de cálculo, nos muestra de manera
inmediata la anterior ventana para la selección de la macro que queremos
asociarle.
Página 16 de 175
Página 17 de 175
LECCIÓN 2. ASPECTOS BÁSICOS DEL LENGUAJE VBA

(VISUAL BASIC FOR APPLICATIONS).
El lenguaje de programación que utiliza Excel está basado en Visual Basic, un

lenguaje de programación orientado a objetos, es decir, la filosofía de los lenguajes
orientados a objetos es que el mundo real lo podemos abstraer de tal forma que lo
podemos representar como objetos y programar con ellos.
Un objeto es algo con entidad propia dentro de una clase. Y una clase es un
conjunto de objetos que tienen propiedades en común, y se comportan de una manera
igual o similar al resto de objetos pertenecientes a esa misma clase. Por ejemplo
tenemos la clase “persona” que tiene una serie de propiedades y comportamiento
claramente diferenciables de la clase “casa”, y dentro de la clase “persona”, existen
muchos objetos que son cada una de las personas, por ejemplo, pertenecientes a un
colegio. En nuestro caso de la hoja de cálculo, los objetos bien podrían ser el libro, la
hoja, la celda, o un rango.
Las propiedades hemos dicho que son aquellas características que definen a los
objetos de una clase, diferenciándolos del resto de clases, siguiendo con el ejemplo
persona unas propiedades podrán ser, la estatura, el peso, el color del pelo, el sexo, el
color de los ojos, y todas aquellas propiedades que puedan diferenciar m ás a cada
objeto dentro de una clase, como nombre, apellido, DNI, etc... En nuestro caso, como
te puedes imaginar las propiedades de una celda por ejemplo, puede ser el color de la
fuente, el color del fondo, el tipo de letra, etc.,
Además de las propiedades, hemos dicho que las clases se caracterizan por su
comportamiento, en la programación orientada a objetos se le suele llamar métodos,
que están diferenciados en funciones y procedimientos.
Los métodos característicos de la clase persona sería, hablar, andar, escribir,

escuchar, estudiar, etc., en una hoja de cálculo un método para el objeto fila, bien
podría ser la acción de su eliminación o inserción de la misma.
Un ejemplo sencillo de algunos objetos, propiedades y métodos en Excel son los

siguientes:
 Objetos: Prácticamente cada cosa que veas en Excel es un objeto.

Ejemplos de objetos son: un libro Excel, una hoja, un rango, una celda,
un menú, un gráfico, una tabla dinámica, un cuadro de diálogo, las
etiquetas de hojas, las columnas, las filas, etc. En fin, cada elemento de
Excel es un objeto. Un objeto es además algo que puedes ver e
identificar con un nombre.
Página 18 de 175
 Propiedades: Las propiedades son las características de los objetos.

Por ejemplo, para el objeto “celda” algunas de sus propiedades serían:
alto, ancho, color, bloqueada o desbloqueada, vacía, con un número o
con una fórmula, etc. Por ejemplo para el objeto “hoja” algunas de sus
propiedades serían: visible u oculta, con o sin líneas de división, con o
sin barras de desplazamiento vertical y horizontal, etc.
 Métodos: Un método es una acción que podemos realizar sobre el
objeto, o alguna de sus propiedades. Por ejemplo sobre el objeto “hoja”
podemos: activar, mover, copiar o borrar dicha hoja.
La programación de macros se hace a través del lenguaje VBA (Visual Basic for
Applications) desde el editor VBA que trae incorporado Excel. Este tipo de
programación también se conoce como “Programación Orientada a Objetos” (OOP,
Objects Oriented Programming). La Programación orientada a Objetos nos permite
trabajar sobre los objetos propios de Excel, como así también crear nuestros propios
objetos.
Una de las grandes ventajas de la OOP, es que utiliza objetos ya definidos por
alguien, sin tener que conocer nada sobre su implementación, sólo debemos conocer
sus propiedades y métodos y utilizarlos de forma correcta.
El lenguaje VBA es muy fácil de entender y siempre gira en torno a seleccionar los
objetos, cambiar sus propiedades y/o ejecutarles distintos métodos. La única
particularidad es que el lenguaje VBA solo está en inglés, en las siguientes tablas
tienes unas cuantas traducciones de objetos de Excel a su correspondiente traducción
al español:
INGLES ESPAÑOL
Cell Celda
Range Rango
Worksheet Hoja
Workbook Libro
Ejemplos de Propiedades VBA (nombre original y su significado en español)

INGLES ESPAÑOL
Value Valor
Color Color
Format Formato
Página 19 de 175
Ejemplos de Métodos VBA (nombre original y su significado en español)
INGLES ESPAÑOL
Copy Copiar
Protect Proteger
Delete Borrar
El lenguaje VBA tiene miles de OPM, y existe una forma muy práctica de
conocerlos todos que es con la grabadora de macros tal y como has visto su utilización
en los apartados anteriores.
Aprender macros es mucho más fácil de lo que te imaginas. Es cierto que hay
macros muy complicadas que requieren un conocimiento muy avanzado del lenguaje
VBA. Pero es un lenguaje fácil y muy intuitivo. Además Excel posee una grabadora de
macros que las escribe de forma automática. Y luego siempre podrás retocarlas a tú
gusto.
El código VBA asociado a un libro se agrupa en un proyecto con varias carpetas:
 La carpeta Microsoft Excel Objetos: Contiene un módulo de clase

asociado al libro del proyecto (llamado de modo predeterminado
Thisworkbook) y un módulo de clase por cada hoja de cálculo u hojas
gráficas del libro.
 La carpeta Formularios: Contiene los formularios (UserForm) del
proyecto y el código VBA asociado.
 La carpeta Módulos: Reúne los diferentes módulos estándar
(compuestos por uno o más procedimientos) que pueden llamarse
desde cualquier procedimiento del proyecto.
 La carpeta de Módulos de clase: Contiene los módulos de clase
utilizados para la creación de nuevas clases de objetos. Los módulos de
clase se utilizan normalmente para la escritura de procedimientos de
sucesos asociados a los objetos Application y Chart.
La programación que realicemos en Excel, sean procedimientos o funciones va a

estar clasificada en diferentes módulos. Un módulo sirve principalmente para agrupar
procedimientos y funciones. El procedimiento y la función son entidades de
programación que sirven para agrupar instrucciones de código que realizan una acción
concreta.
La diferencia fundamental entre funciones y procedimientos, es que las

funciones al llevarse a cabo devuelven algún tipo de valor, mientras que los
procedimientos realizan su cometido y pueden, o no, devolver algún valor.
Página 20 de 175
En la programación orientada a objetos existe también un concepto muy

importante que son los eventos. Los eventos son sucesos que son provocados por
algún tipo de estímulo externo y que hacen que pueda alterarse el comportamiento de
la clase. Seguimos con el ejemplo persona, un evento sobre persona sería el evento
“despertarse”, que provoca que la persona comience a funcionar, o un evento externo
como “llamar”, que provoca que la persona atienda a la persona que le ha llamado. En
nuestro caso, eventos asociados a una celda puede ser su selección, actualizar el
valor introducido, salir de la celda, entrar en la celda, etc.,
Está introducción es muy básica y sólo pretende mostrar algunos de los conceptos
más importante para empezar a realizar las primeras prácticas de programación.
Página 21 de 175
El entorno del editor de Visual Basic
El Editor de Visual Basic es la aplicación que trae Excel desde donde se escriben y
guardan las macros, y se pueden escribir los procedimientos y funciones. Las
diferentes formas que tenemos de acceder al editor de Visual Basic son:
1) Desde la ficha Programador pinchando en el botón Visual Basic
2) O bien, desde el teclado (Teclas de Método Abreviado): ALT+F11
NOTA: Recuerda que en la versión de Excel 2010, las opciones del menú de
macros se encuentran en la ficha Programador. Si no tienes visible la ficha
Programador, puedes activarla de la siguiente forma:
1) Presiona el botón de Archivo (botón verde en la parte superior izquierda

de la pantalla).

Opciones de Excel
3) En la lista de Personalizar cinta de opciones marca la casilla de
Programador para que podamos ver esta ficha en la cinta de opciones.
Página 22 de 175
Una vez que hayas accedido al editor de Visual Basic, por cualquiera de los
métodos, botón de Visual Basic, o método abreviado ALT+F11, verás algo similar a la
figura siguiente (no importa si no lo ves estrictamente similar, eso dependerá de las
ventanas que tengas visibles y ocultas). Puedes mostrar u ocultar estas ventanas
desde el menú Ver.
Ventana proyectos
Ventana de código
Ventana de
propiedades
Ventana de
inmediato
La ventana de proyecto
A cada libro abierto en Excel se le asocia un proyecto. La ventana del explorador

de proyectos permite mostrar todos los proyectos y todos los m ódulos de cada
proyecto, según una estructura de un árbol. Los módulos se agrupan en cuatro
categorías como vimos antes, en módulos asociados a los objetos de Excel (libro y
hojas), a formularios, a módulos estándar o a módulos de clase.
La ventana de Propiedades
Esta ventana permite mostrar las propiedades relativas al libro, a las hojas de
cálculo, a las hojas gráficas y a los formularios.
Página 23 de 175
La ventana de Código
Esta será la ventana en la que incluiremos nuestros procedimientos y quedarán

guardadas nuestras líneas de código para su posterior utilización.
La ventana de inmediato
Es la ventana donde podremos comprobar los valores de nuestras variables que

se hayan definido previamente tras la ejecución de nuestras instrucciones, sin tener
que abandonar la ventana del editor de programación.
El menú del editor de Visual Basic
Esta es la barra de menú del editor de Visual Basic donde podemos acceder a las
diversas opciones y comandos del propio editor.
La barra de botones
Esta es la barra de botones de Visual Basic, donde podemos acceder de una

manera más rápida a las opciones más comúnmente utilizadas, como son la
ejecución, la parada, guardar, etc...
Página 24 de 175
En la parte izquierda de la pantalla podemos ver dos recuadros, el recuadro

superior es el explorador de proyecto. Aquí se encuentran los módulos, las hojas
utilizadas en los procedimientos/funciones, etc.
A parte de estas ventanas podemos encontrar en el editor otros elementos

interesantes que nos pueden ayudar en la programación en este entorno (VBE), como
son:
 El complemento automático de instrucciones, con el cual se muestra

automáticamente una lista desplegable cuando se escribe un nombre
de un objeto seguido de un punto. Esta lista nos ofrece los métodos,
propiedades y constantes disponibles para dicho objeto.
Página 25 de 175
 La ventana de Inspecciones, que contiene todos los valores de las

variables que se hayan definido previamente como variables de
inspección, a través del menú Depuración, y Agregar una
inspección…
Una vez agregada la variable a la inspección podremos

comprobar de manera directa los valores que van adquiriendo estas
variables, como podemos ver en la siguiente ilustración:
Página 26 de 175
 El examinador de objetos, nos permite visualizar para cada objeto,

sus propiedades, métodos y constantes.
Página 27 de 175
Configuración del Editor de VBA
En algunas circunstancias puede ser interesante personalizar algunos aspectos del

editor, en cuanto a el diseño de tipografías, que van asociadas a los diferentes
elementos que vamos a incorporar en nuestra ventana de código que podemos
diferenciarlos en base a su formato.
Así las palabras clave, las funciones y las instrucciones de VBA se muestran en
azul, los objetos, métodos y propiedades en negro y los comentarios en verde. Y las
instrucciones que contienen errores se suelen resaltar en rojo.
Para modificar el estilo (colores, tipo y tamaños) de las diferentes partes del
código, tenemos que acudir a las Opciones del menú de Herramientas, y seleccionar
por ejemplo, la ficha Formato de editor.
Además de la modificación de las diferentes opciones de formato de código de

VBA, también podemos modificar ciertas opciones previas en el momento de la
introducción de código, como pueda ser la verificación automática de la sintaxis, la
declaración obligatoria de las variables, y el complemento automático de instrucciones
que suelen facilitar la introducción y mantenimiento del código en VBA.
Para activar estas herramientas tenemos que acudir a la ficha Editor de las
Opciones del menú Herramientas que hemos comentado anteriormente.
Página 28 de 175
Guardar archivos con Macros
Cuando guardamos un archivo y queremos que las Macros que hemos creado se
almacenen con el resto de las hojas de cálculo deberemos utilizar un tipo de archivo
diferente.
Para ello deberemos ir al Botón de Archivo, y seleccionar la opción Guardar como,

y elegir la opción de Libro habilitado para macros.
Página 29 de 175
Se abrirá el cuadro de diálogo Guardar como. En el desplegable Guardar como

tipo seleccionar Libro de Excel habilitado para macros (*.xlsm).
Página 30 de 175
LECCIÓN 3. LOS MÓDULOS
Un módulo sirve para agrupar procedimientos y funciones. El procedimiento y la

función son entidades de programación que sirven para agrupar instrucciones de
código que realizan una acción concreta. Para insertar un módulo simplemente hay
que utilizar la opción del menú Insertar/ Módulo.
Este elemento es la base para la introducción y organización del código en VBA.
Página 31 de 175
Los procedimientos
Los procedimientos son subprogramas que permiten descomponer una tarea de

programación compleja en una serie de tareas más pequeñas y más simples. Permiten
organizar el código dentro de los módulos para obtener un código más fácil de
mantener y de reutilizar.
En VBA Excel se distinguen tres tipos de procedimientos:

 Los procedimiento Sub (de subrutina) llamados subprogramas o
procedimientos Sub.
 Los procemientos Function llamados funciones,
 Y los procedimiento Property llamados de propiedad.
Los dos primeros son los que más se utilizan habitualmente que principalmente
tienen en común el que ambos tienen instrucciones y/o métodos de VBA, aceptan
argumento y pueden llamarse desde otras funciones o procedimientos Sub.
Mientras que las funciones se diferencian de las subrutinas porque no ejecutan

acciones propiamente dichas, sino que devuelven valores tras la ejecución de un
algoritmo específico.
Los procedimientos se distinguen entre procedimientos generales que es aquel

que es declarado en un módulo (generalmente módulo estándar). Y la llamada se
define explícitamente en el código.
Y los procedimientos vinculados a su suceso (o evento) el cual es asociado al

suceso de un objeto determinado, como pueda ser la apertura de un libro, la activación
de una hoja, etc., Su nombre normalmente se compone del nombre del objeto, seguido
del carácter subrayado “_” y del nombre del suceso (por ejemplo: Workbook_Open).
La llamada a un proceso de este tipo es implícita, es decir, que el procedimiento se
pone en marcha o se ejecuta automáticamente cuando se produce el suceso
asociado.
Ejemplo de procedimiento general:

Este procedimiento simplemente va a incorporar el dato 1000 en la referencia A1
de la hoja de cálculo activa en ese momento.
Página 32 de 175
Ejemplo de procedimiento vinculado a un suceso:

Este procedimiento va a permitir abrir automáticamente el libro Ventas.xlsx al abrir
el libro. Este procedimiento se asocia al suceso Open (abrir) del objeto Workbook
(libro).
Los procedimientos de función
Los procedimientos Function, llamados más habitualmente funciones, devuelven

un valor, como el resultado de un cálculo. El valor devuelto debe tener el nombre de la
función.
El lenguaje VBA ya cuenta con numerosas funciones integradas, como las

funciones relativas a las fechas (day, week, year, format...), u otra de cálculo
matemático tradicional (Sum, Average, Max, Min, …).
Pero además de estas funciones integradas también se pueden crear funciones

propias personalizadas, como se puede ver en la siguiente ilustración. Y así, esta
función es capaz de convertir los minutos a horas.
Página 33 de 175
Sintaxis o estructura de los procedimientos y funciones
La estructura de los procedimientos es de la siguiente manera:

[Private | Public | Friend] [Static] Sub Nombreprocedimiento
(lista de argumentos)
Instrucciones o sentencias del código
End Sub
La estructura de las funciones es muy parecida a la de las funciones:
[Private | Public | Friend] [Static] Function Nombrefunción
(lista de argumentos)
Instrucciones o sentencias del código
End Function
Esta estructura de los procedimientos o funciones se encarga de establecer las
siguientes aspectos del procedimiento o función:
 [Private | Public | Friend] estas expresiones del procedimiento se encargan
de establecer el alcance o visibilidad del procedimiento.
o Private o friend es un procedimiento que sólo puede ser llamada desde
un procedimiento del mismo módulo.
o Public es un procedimiento que puede ser llamado desde todos los
módulos de todos los proyectos de Excel.
 [Static] con esta expresión en el procedimiento indicamos que los valores de la
variable se preserva entre llamadas, o no se reinicializa.
 Lista de argumentos: Los argumentos se utilizan para transmitir a los
procedimientos parámetros den forma de datos. El número de argumentos
puede variar de 0 a muchos.
o Optional: Indica que el argumento no es obligatorio para la función.
o Identificación del argumento: El paso de los argumentos a un
procedimiento teniendo en cuenta su orden de aparición puede resultar
complicado en ciertas ocasiones, cuando los argumentos del
procedimiento son muchos. Así que en muchas ocasiones resulta más
útil hacer referencia directa al argumento con su propio nombre.
NombreArgumento:=Valor
Ejemplo de procedimiento con referencia a argumentos con nombres:
Este procedimiento va mostrar una ventana tras su ejecución donde aparecerá el
título, el mensaje de la misma junto a dos botones, haciendo uso de los argumentos
Title, Buttons y Prompt.
Página 34 de 175
Llamadas a los procedimientos
De modo predeterminado, los procedimientos son públicos por lo cual pueden ser
llamados desde cualquier procedimiento del proyecto de Excel, y hay que saber cómo
pueden ser llamados desde otros procedimientos dependiendo donde se encuentren.
Llamadas a los procedimientos:

 En un mismo módulo: Call Nombreprocedimiento
 Para un módulo distinto: NombredelMódulo.NombredelProcedimiento
 Para un libro distinto:
Application.Run Nombredellibro!NombredelMódulo.NombrredelProcedimiento
Página 35 de 175
LECCIÓN 4. EL MODELO DE OBJETO DE EXCEL
VBA es un lenguaje de programación orientado a objetos, por lo que la mayor

parte de los elementos manipulados en Excel son objetos: los libros, las hojas de
cálculo, los rangos de celdas, las celdas, etc.,
Los objetos de Excel se organizan según un modelo jerárquico: ciertos objetos

contienen otros objetos que puede a su vez contener otros… Estos objetos se llaman
contenedores u objeto Padre. Por ejemplo, el objeto Application es el contenedor
de los objetos Workbook (libros de Excel), que a su vez son contenedores de los
objetos Worksheet (hojas de cálculo de un libro). El contenedor más amplio es el
objeto Application.
Un conjunto de objetos de la misma naturaleza constituye una colección (colección

de libros, workbooks, colección de hojas, worksheets), que se distinguen del objeto
padre porque suelen ir en plural, en lugar, de en singular.
Un objeto dispone de una serie de características llamadas propiedades (por

ejemplo, el objeto celda o rango, tiene propiedades como el valor de la celda, el color,
el formato de la fuente, la alineación del texto, etc.,) y de comportamientos o acciones
llamadas métodos (por ejemplo, el objeto fila puede ser eliminado o insertado).
Página 36 de 175
Un objeto es capaz de responder a sucesos provocados por el usuario (al hacer

un clic, o actualizar un control, etc.,) o por el propio sistema.
Las clases son modelos que permiten crear objetos de la misma naturaleza. Los
objetos procedentes de una misma clase heredan sistemáticamente todos los
métodos, propiedades y sucesos de su clase de origen. Es posible crear clases de
objetos con VBA Excel utilizando módulos de clase.
Objetos, colecciones habituales
Una muestra de los objetos que podemos encontrar en Excel se encuentran los
siguientes:
 Application: Es el objeto referido a la aplicación Microsoft Excel activa

y contiene al resto de objetos.
 Debug: Este objeto permite mostrar datos en la ventana de ejecución
o inmediato, donde podemos comprobar el resultado de la ejecución
de nuestros procedimientos, para comprobar el valor de nuestras
variables o funciones.
 WorkSheetFunction: Contiene todas las funciones disponibles de
Excel. Así por ejemplo, con este objeto podemos obtener el resultado
de una función aplicada a un rango de celdas.
 Worksheet: Es el objeto que representa la hoja activa del libro activo
o libro especificado.
 Workbook: Representa el libro de la ventana activa.
 Range: Representa la o las celdas seleccionadas.
Las colecciones a las cuales podemos acceder para recorrer sus elementos
podemos encontrar:
 AddIns: Colección que contiene todas las macros creadas hasta ese
momento.
 Workbooks: Colección de los libros abiertos (Workbook).
 Worksheets: Colección de las hojas de cálculo (Worksheet).
 Dialogs: Colección de los cuadros de diálogo integrados de Excel.
También podemos encontrar en la lista automática para la ayuda a la

programación toda una lista de métodos y constantes. Recuerda que los métodos
pueden efectuar acciones vinculadas a los objetos, mientras que las constantes son
valores predefinidos con un nombre determinado que suelen ser necesarias en los
argumentos de algunas funciones de Excel.
Página 37 de 175
Microsoft Excel utiliza muchas de ellas en sus objetos y suelen ser identificadas en
el desplegable automático de instrucción del editor, porque suelen ir precedidas por
prefijos como xl, vb o mso.
El complemento automático de las instrucciones.
El editor VBA dispone de una tecnología que ayuda en la programación para la

introducción de los objetos, así como la búsqueda de sus propiedades, métodos y
constantes asociados al mismo. Cuando escribes un nombre de objeto o de colección
seguido de un punto (.) suele aparecer (aunque no siempre), una lista desplegable de
métodos y propiedades del objeto seleccionado previamente. Tal y como el que
puedes ver en la siguiente ilustración:
De esta lista se pueden distinguir principalmente dos tipos distintos de símbolos, el

icono que representa los métodos, y el icono que representa las propiedades.
Puedes hacer deslizar los elementos de la lista desplegable escribiendo las

primeras letras del método, propiedad o colección buscada o mediante la barra de
desplazamiento. Para seleccionar un elemento de la lista, simplemente hay que hacer
doble clic sobre él.
Página 38 de 175
Cuando el elemento seleccionado es un método hay que incorporar un espacio

para abrir la lista de parámetros del método, como puede ver en el método Open del
objeto Workbooks.
En el momento que aparece la lista de argumentos esta se va adaptando a medida

que se van introduciendo los argumentos. Los argumentos van entre corchetes. El
argumento actual para introducir se destaca en negrita, y si para un argumento
determinado existe una lista de valores predefinidos, aparecerá una lista desplegable
con las constantes correspondientes.
Reglas de escritura de código
 Comentarios
Cuando se escribe código en cualquier editor de programación se suelen seguir

una serie de instrucciones o reglas, que nos pueden ayudar a mantener el código para
posibles revisiones futuros, o compartirlo con otros programadores.
La incorporación de comentarios suele ser muy útil para revisar en el futuro

nuestro código, o simplemente poder resumir cual es el objetivo de nuestros
procedimientos. Existen dos posibles maneras de incorporar código en el editor VBA,
con una comilla simple (‘) previamente a los comentarios, o con la introducción previa
de la expresión Rem.
Como puedes observar en la ilustración anterior, cuando el comentario ha sido

validado con un salto de línea, nuestro comentario aparece en color verde.
Página 39 de 175
 Carácter de continuación
En determinadas circunstancias puede ocurrir que nuestras líneas de código sean

demasiado extensas para poder visualizarlas en la pantalla, para lo cual puede ser
muy útil generar un salto de línea sin inutilizar el código creado, para los cual
utilizaremos el signo de subrayado “_” precedido de un espacio.
 Los sangrados
Los sangrados (o tabulaciones) permiten una mejor legibilidad del código. Es

especialmente indicado utilizarlos en las estructuras de control (en especial si hay
varias instrucciones If anidadas) y en las estructuras de decisión.
 Nombres de procedimientos, variables y constantes.
Los nombres de los procedimientos, de las constantes, de las variables y de los

argumentos deben respetar una serie de reglas:
- El primer carácter debe ser una letra.

- Las minúsculas y mayúsculas no se diferencian (se aceptan las letras
acentuadas) aunque se respeta la diferenciación.
- No se deben utilizar nombres reservados de Visual Basic como
palabras claves, nombres de objetos, etc.,
- No se debe usar el punto, el espacio, ¡, $, # ni @.
- El nombre no puede tener más de 255 caracteres.
- Para los procedimientos del tipo Function no se debe utilizar un nombre
que pueda ser una referencia a una celda.
- No se deben indicar varias veces los mismos nombres de variables ni
constantes en un mismo nivel de alcance o visibilidad.
Página 40 de 175
Crear fórmulas con VBA.
Para la creación de fórmulas disponemos de varias vías a través de diferentes

propiedades del objeto Range, como puedan ser:
- Range(Referencia).Formula
- Range(Referencia).FormulaLocal
- Range(Referencia).FormulaRC
- Range(Referencia).FormulaRCLocal
Estilo Formula
Además de la propiedad Value que tienen todas las celdas en Excel, cada una
de ellas también tendrá la propiedad Formula, la cual almacenará la fórmula asociada.
La distinción entre la propiedad Formula y FormulaLocal, la podemos establecer en
cuanto a fórmulas que se guardan con la referencia en el idioma local (en nuestro
caso, en castellano), o con la referencia en inglés. Así por ejemplo, si queremos
sumar los datos de un rango, el uso de una u otra propiedad, implicará la necesidad de
recurrir a los nombres de las funciones en el idioma en inglés, o a la designación local
del ordenador dependiendo de la configuración regional del mismo. En la siguiente
ilustración podemos comprobar la diferencia entre ambas:
Estilo FormulaL1C1
La necesidad de aprender el estilo de referencias L1C1 puede resultar útil

simplemente por el mero hecho, de que las macros graban las fórmulas en este tipo de
referencia, diferente al habitual de A1, D4,… al que solemos estar más
acostumbrados, lo cual nos puede permitir editar muchas de las macros creadas con
la herramienta de grabadora de macros.
Página 41 de 175
Aparte de esta ventaja utilitarista, para aprovechar el código realizado con la

grabadora de macros, nos proporciona otro tipo de ventajas, en el momento de copiar
fórmulas a localizaciones amplias de la hoja de cálculo con evidentes beneficios por la
simplicidad del código.
Para entender cómo funciona este tipo de referencia tenemos que abandonar
las habituales referencias de columnas por letras, y filas por números, por la siguiente
sintaxis de L (línea o R, para versión en inglés, row) y la C (para columna, igual para la
versión en inglés). Si lo que necesitamos es desplazar la referencia hacia otras
ubicaciones, utilizaremos números positivos para desplazarnos hacia abajo en el caso
de las filas, o hacia la derecha en el caso de las columnas, y negativos para
desplazamientos hacia arriba, en el caso de las filas, y hacia la izquierda, en el caso
de las columnas. Así por ejemplo, desde la referencia E5, utilizaremos L[1]C para
hacer referencia a E6, y utilizaremos L[-1] para hacer referencia a E4.
Con este tipo de designación la no inclusión del corchete para la L (o R, para

una versión de código en inglés) o la C significa que se está apuntando a una celda en
la misma fila o columna en que se encuentre la fórmula.
Así por ejemplo, si se escribe =L[-1] C[-1] en la referencia D5, significa que se
está haciendo referencia a una celda de la fila de más arriba y a una columna a la
izquierda, en este caso sería a la celda C4.
Sin embargo, si se escribe =LC[-1] en la celda D5, hace referencia a la misma

fila, pero una columna a la izquierda, es decir, sería la celda C5. Y si se escribe =LC[1]
en la misma celda D5, esto significa que se está haciendo referencia a la celda E5. En
la siguiente ilustración se puede ver como se escribiría una referencia en la celda D5
como se podría hacer referencia a las celdas circundantes a la misma:
Recuerda que una referencia absoluta es aquella donde la fila y la columna

permanecen fijas cuando la fórmula se copia a otra ubicación. En una notación del
estilo letra y número (A1), Excel utiliza un dólar ($) delante del número de la fila o la
letra de la columna para que esa fila o columna sea absoluta cuando se copia la
fórmula.
Página 42 de 175
Sin embargo en este estilo de notación para hacer referencia a un número

absoluto de fila o columna, simplemente no hay que incluir los corchetes. Con la
siguiente notación =L1C1 se hace referencia a $A$1.
Una referencia mixta es aquella en la que la fila es fija y la columna puede ser
relativa, o a la inversa, donde la columna sea fija y la fila pueda ser relativa. Son
muchas las circunstancias donde este tipo de referencias puede ser de utilidad, todo
dependerá de la operación matemática que necesites realizar.
En este caso, tenemos que combinar la utilización de números sin corchetes

para el caso de las referencias absolutas, y los corchetes ([ ]) para las referencias
relativas. En el siguiente ejemplo = R5C5*R[-3]C[-3]
En algunas ocasiones puede ser necesario escribir una fórmula que tenga que
hacer referencia a toda una columna. Por ejemplo, es posible tener que obtener el
valor máximo de la columna D. Si no se sabe cuántas filas tiene la columna D, se
podría escribir una función como la siguiente: =MAX($D:$D) en estilo A1 o, =MAX (C4)
en estilo L1C1. Para saber el valor mínimo en la fila 2, tendríamos que escribir la
siguiente función en estilo A1 =MIN($2:$2), mientras que en estilo L1C1 sería la
siguiente: =MIN(L2). Para el caso de referencias relativas, cuando quisiéramos
calcular el promedio de la fila superior en la que estemos situados tendríamos que
utilizar la FormulaR1C1Local =PROMEDIO(L[-1]).
Después de utilizar la formulación con el estilo L1C1, realmente son mucho

más intuitivas de manejar que las habituales del estilo A1. Un ejemplo clásico vendría
dado por la construcción de una tabla de multiplicar.
En este ejemplo típico, necesitaríamos bloquear la columna en el caso de la

referencia $A2, para evitar que se modificase cuando se copiase la fórmula hacia la
derecha, mientras que en el otro elemento de la fórmula, tendremos que bloquear el
número B$1, para evitar que se modifique el número de la fila cuando vayamos a
copiar la fórmula hacia abajo.
Para un caso de referencias del estilo L1C1, la fórmula sería =RC1*R1C, que
vendría a decir que se multiplicase la primera columna C1, por la primera fila R1.
Página 43 de 175
Algunos ejemplos de procedimientos que modifican las

propiedades de objetos de Excel:
Ejemplo 01: Generar un mensaje emergente.
El procedimiento más sencillo con el cual se suele empezar en la programación es

aquel que nos puede ofrecer ventanas emergentes con información. Para estos casos,
se suele utilizar la función MsgBox.
Tras su ejecución haciendo uso del botón de Ejecutar Sub.
Se puede observar una ventana similar a la siguiente:
Ejemplo 02: Cambiar el valor de una celda.

Otro tipo de procedimientos sencillos nos pueden permitir modificar los valores de
referencias determinadas con una sencilla instrucción que modifica la propiedad Value
del objeto Range.
Página 44 de 175
Para escribir datos de tipo texto o cadena simplemente hay que estar pendiente de
incorporar comillas (“) en el valor que incorporaremos en la referencia.
Ejemplo 03: Recuperar el nombre y dirección del fichero en la ventana

inmediato.
En ciertas ocasiones puede ser interesante obtener el nombre del fichero y su

ubicación para poder utilizarlo en una grabación posterior del fichero sin tener que
sobreescribir el fichero existente, para lo cual esta instrucción nos podría ser de
utilidad.
NOTA: En este procedimiento se ha hecho uso del objeto Debug.Print que nos
permite visualizar en la ventana Inmediato el resultado del procedimiento. Este objeto
es de mucha utilidad para la depuración del código introducido. Recuerda que la
ventana inmediato sirve para escribir, ejecutar y probar un código rápidamente.
También se puede comprobar el resultado de una instrucción copiando dicha
instrucción en la ventana precedido por el símbolo de interrogación (?).
En la siguiente ilustración podemos comprobar el resultado de una instrucción que
nos devuelve el número de hojas que tiene nuestro libro, antes de que forme parte de
un procedimiento más extenso.
Página 45 de 175
Pero recuerda desde la Ventana Inmediato puedes ejecutar procedimientos de

forma inmediata, como su nombre lo indica. Pero dichas macros solo se ejecutan una
vez al presiona Enter, y no quedan disponibles en la lista de macros ni las puedes
utilizar en tus desarrollos (asignándolas a botones o formularios).
Ejemplo 04: Referenciar diferentes objetos de Excel.
Con esta instrucción podemos acceder al valor de una referencia concreta desde
el objeto más superior que sería Application.
Ejemplo 05: Modificar el valor de diferentes referencias de una hoja.
Con esta instrucción podemos modificar el valor de las celdas de distintas

referencias a la vez.
Ejemplo 06: Eliminar el contenido de diferentes referencias de una hoja.

Con esta instrucción podemos eliminar los contenidos anteriormente generados en
las diferentes referencias.
Página 46 de 175
Ejemplo 07: Modificar el formato de los datos incorporados.
Este procedimiento tiene por objetivo modificar el formato de los datos además de
incorporar cierta información previamente.
Ejemplo 08: Código abreviado del caso anterior.
Este procedimiento es más eficiente que el anterior, en cuanto a ejecución y

escritura del
mismo.
Ejemplo 09: Copiar datos de una referencia a otra.

Entre las acciones más habituales que podemos realizar en la hoja de cálculo se
encuentra la posibilidad de copiar nuestra información de unas referencias a otras, con
un procedimiento también lo podemos hacer para asignar dicho procedimiento al
evento de un objeto determinado, como pueda ser al hacer clic sobre un botón.
Página 47 de 175
NOTA: Recuerda que para comprobar el resultado del procedimiento de los estos
ejemplos deberás hacer uso del botón de Ejecutar Sub, que puedes encontrar en la
barra de herramientas.
Ejemplo 10: Métodos de selección y desplazamiento por rangos

Cuando queremos situarnos al final del rango de un listado que puede tener
diferente cantidad de datos tendremos que utilizar instrucciones de este tipo.
Ejemplo 11: Selección de un rango para aplicar un formato

Una de las acciones más habituales como usuario en la hoja de cálculo es la
selección de sus datos. Esta selección en el código la hacemos con una instrucción o
el método Select del objeto Range, y el cambio de formato de los mismos se puede
hacer modificando la propiedad NumberFormat.
Página 48 de 175
Ejemplo 12: Selección automática de un rango.

Además del método anterior también poder utilizar el método Select del objeto
CurrentRegion, para modificar su formato o eliminar los datos, como hace la siguiente
instrucción.
Ejemplo 13: Modificar los datos de la columna A.

Con este procedimiento se puede seleccionar una columna para modificar su
formato y conseguir que se amplié el ancho de la columna para que se vea su
resultado.
Página 49 de 175
Ejemplo 14: Realizar los cálculos de una hoja a través de fórmulas.
Con este procedimiento se van a realizar los cálculos de una tabla haciendo uso de
diferentes estilos de fórmulas.
Ejemplo 15: Añadir una hoja, y modificar algunas de sus propiedades, como
son, su nombre y ocultación.
Con este procedimiento vamos a modificar algunas de las propiedades más
comunes de las hojas, como son, añadir una nueva hoja, modificar su nombre u
ocultar su visibilidad a los usuarios, para lo cual tendremos que hacer uso del
método Add y las propiedades Name y Visible, asignando los valores adecuados
para su correcta modificación.
Página 50 de 175
Ejemplo 16: Eliminar una hoja.

Del mismo modo que tenemos un método para añadir un objeto, disponemos
del contrario, que nos va a permitir eliminarlo, con la posibilidad de evitar la aparición
de ventanas de confirmación, para conseguir que el procedimiento se ejecute sin la
necesidad de confirmación por parte del usuario.
Ejemplo 17: Procedimientos para mover y copiar una hoja.

Con los siguientes ejemplos de procedimiento podemos comprobar cómo
mover y copiar hojas dentro de nuestro libro.
Página 51 de 175
PRÁCTICAS DEL CAPÍTULO:
NOMBRE DEL PROCEDIMIENTO: “Practica01”.
1. Incorpora en la referencia A1 de la hoja PRACTICA01 escribe la dirección del libro

que se encuentra abierto.
2. En la referencia A2 de la misma hoja el nombre del fichero actual.
3. Copia el nombre del fichero a las siguientes referencia de la misma hoja de
cálculo: C1:C10, y a las referencias D1 y E1.
4. Modifica el formato de las celdas que tienen datos para que el formato sea en
negrita y con un color de relleno.
5. Genera un mensaje que nos diga que ya se ha realizado la Actividad01.
1. Crea una fórmula en el rango E8:E13 y E15:E20 para que multiplique las
unidades compradas del mes de enero, por el precio de compra que se
encuentra en la referencia B4.
2. Haz los mismo para el caso de las ventas, en este caso la fórmula será el
precio de venta por las unidades vendidas, para el rango F8:F13 y F15:F20.
3. Incorporar una fórmula para sumar los semestres del producto.
4. Incorporar el resto de fórmulas de estilo Formulalocal y FórmulaRC.
5. Aplica un formato de moneda para el rango donde se ha copiado las fórmulas.
6. Muestra un mensaje final de confirmación, con el texto: Se han rellenado las
fórmulas correctamente.
Página 52 de 175
1. Añade una nueva hoja al final del libro con el nombre de Hojasdelibro.
2. En las referencias A1:A4 incorporar los tres primeros nombres de las hojas, y
en A4, el nombre de la penúltima hoja.
3. Oculta la hoja.
4. Muestra un mensaje al final del procedimiento que nos diga que ya se ha
realizado la Practica03.
Página 53 de 175
SOLUCIONES DE LAS PRÁCTICAS:
Solución Práctica01:
Página 54 de 175
Página 55 de 175
LECCIÓN 5.EL USO DE VARIABLES EN VBA
Una variable es un lugar de almacenamiento con nombre que puede contener

cierto tipo de datos que puede ser modificado durante la ejecución del programa. Cada
variable tiene un nombre único que la identifica dentro de su nivel de ámbito. Puede
especificar un tipo de datos o no. Los nombres de variable deben comenzar con un
carácter alfabético, deben ser únicos dentro del mismo ámbito, no deben contener más
de 255 caracteres y no pueden contener un punto o carácter de declaración de tipo.
Es decir las variables pueden contener caracteres alfanuméricos, pero siempre

deben empezar por una letra y no deben exceder en longitud de 255 caracteres
Se recomienda evitar el uso de caracteres no presentes en nuestro alfabeto para

evitar problemas.
A su vez VBA tiene reservados algunos nombres, los cuales obviamente no

pueden ser utilizados como variables propias, algunas de estas palabras son: Sub,
End, with, do, loop etc, ya que son nombres que tienen un significado propio dentro de
VBA.
Cuando declaramos una variable, lo hacemos con la siguiente sintaxis, por

ejemplo:
Dim Variable as TipoVariable
El uso de las variables tiene sentido ya que nos permiten guardar valores
intermedios durante la ejecución del código VBA para efectuar cálculos
posteriormente. La estructura básica de un procedimiento podría estar compuesta por
las siguientes partes.
 Declaración de las variables

 Asignación de valores a las variables
 Algoritmo del procedimiento
 Comprobación o aplicación de la variable (opcional)
Página 56 de 175
Los tipos de variables
La tabla siguiente muestra los tipos de datos compatibles, incluyendo el tamaño de

almacenamiento y el intervalo.
En la 1º columna (Tipo de datos) se define el tipo variables que podemos usar
En la 2º columna (Tamaño) se define cuanto espacio ocupa en memoria
En la 3º columna (Intervalo) se definen los valores que puede adquirir la variable
TIPO DE DATOS TAMAÑO INTERVALO
Byte 1 byte 0 a 255

Boolean 2 bytes True o False
Integer 2 bytes -32,768 a 32,767
Long (entero largo) 4 bytes -2,147,483,648 a 2,147,483,647
Single (coma flotante/ 4 bytes -3,402823E38 a -1,401298E-45 para valores
precisión simple) negativos; 1,401298E-45 a 3,402823E38 para
valores positivos
Double (coma flotante/ 8 bytes -1.79769313486231E308 a -
precisión doble) 4,94065645841247E-324 para valores
negativos; 4,94065645841247E-324 a
1,79769313486232E308 para valores
positivos
Currency (entero a 8 bytes -922.337.203.685.477,5808 a
escala) 922.337.203.685.477,5807
Decimal 12 bytes +/-79.228.162.514.264.337.593.543.950.335
sin punto decimal; +/-
7,9228162514264337593543950335 con 28
posiciones a la derecha del signo decimal; el
número más pequeño distinto de cero es +/-
0,0000000000000000000000000001
Date 8 bytes 1 de enero de 100 a 31 de diciembre de 9999
Object 4 bytes Referencia a tipo Object
String (longitud bytes + longitud de la0 a 2.000 millones
variable) cadena
String (longitud fija) longitud de la cadena 1 a 65.400 aproximadamente
Variant (con números) 16 bytes valor numérico hasta el intervalo de un tipo
Double
Variant (con 16 bytes + longitud de laMismo intervalo que para un tipo String de
caracteres) cadena longitud variable
Definido por el Número requerido porIntervalo de cada elemento es el mismo que el
usuario (utilizando los elementos intervalo de su tipo de datos.
Type)
Página 57 de 175
Las VARIABLES permiten almacenar valores intermedios en cualquier

momento de la ejecución del código VBA con el fin de poder utilizarlas posteriormente
para realizar cálculos, comparaciones, pruebas, …
Las VARIABLES se identifican con un nombre que permite referenciar el valor que
estas contienen y un tipo que determina la naturaleza de los datos que pueden
almacenar.
Existen diferentes tipos de variables en base el tipo de valor que vayan a guardar,
así suele ser conveniente adaptar el tipo de variable al contenido que vaya a
almacenar para optimizar la memoria de almacenamiento.
Variable de tipo texto (o cadena).

Esta variable se establece con el tipo String. Y existen dos tipos posibles de
cadena, las cadenas de longitud variable que pueden contener aproximadamente dos
mil millones de caracteres (231) caracteres, y las de longitud fija que pueden contener
desde 1 hasta 64.000 caracteres.
Página 58 de 175
Variable de tipo Booleana

El tipo es Boolean. La variable puede tomar el valor True (Verdadero) o False(Falso)
que es el valor predeterminado. Ocupa dos bytes en la memoria.
Variable de tipo Fecha

Esta variable se corresponde con el tipo Date. La variable puede tomar los valores
de fecha y de hora desde el 1 de enero de 100 al 31 de diciembre de 9999. Ocupa
ocho bytes.
Variable de tipo Variant.

Esta variable permite almacenar valores de datos de todo tipo: fechas, números,
cadenas de texto, referencias a objetos, etc., El problema es que ocupa dieciséis
bytes, más un byte por carácter si el valor es de una cadena de texto.
Página 59 de 175
Variable de tipo Objeto.

Se corresponde con la variable Object. Esta variable permite almacenar la
referencia a un objeto en la forma de dirección de cuatro bytes. Este tipo de variable
es genérica, pero para obtener mayor rendimiento es recomendable utilizar el nombre
del objeto tal y como está definido, es decir, que si queremos referenciar a un objeto
de tipo hoja o rango, utilicemos el objeto Worksheet o Range, como se puede ver en la
siguiente ilustración:
El alcance de las variables
Una variable es local para un procedimiento o función, si se declara en el cuerpo

del procedimiento o función con Dim o Static. Esta variable no es visible ni utilizable
fuera del procedimiento.
Una variable puede ser visible para todos los procedimientos o funciones de un
módulo, si está declarada en la sección de declaración del módulo (al principio del
módulo) mediante Private o Dim.
Una variable también puede ser pública para toda la aplicación (es decir, visible
desde cualquier parte de la aplicación), si está declarada en la sección de declaración
de un módulo con la instrucción Public.
Sintaxis para la declaración de variables.

<Instruccióndeclaracion>NombreVariables as <TipoDatos>
Página 60 de 175
Entre las instrucciones para la declaración de las variables tenemos varias

posibilidades:
Dim : Con esta instrucción las variables declaradas están disponibles para todos los
procedimientos del módulo, y no son accesibles desde ningún otro módulo. Las
variables declaradas con la instrucción Dim a nivel de procedimiento (entre las
expresiones Sub y End Sub), sólo están disponibles dentro del procedimiento.
Private: A nivel de módulo (y no de procedimiento) las variables sólo están
disponibles para el módulo en el que se declaran.
Public: A nivel de módulo únicamente, las variables declaradas con las instrucción
Public son accesibles desde todos los módulos de todos los proyectos abiertos de
Excel.
Static: Es una instrucción utilizable sólo a nivel de procedimiento, las variables
declaradas mediante la instrucción Static conservan su valor durante todo el tiempo
de ejecución del código.
La declaración de variables
En el momento de trabajar con variables existen dos maneras diferentes de

trabajar con ellas: de manera implícita o explícita.
Declaración implícita.
En el momento de ejecutarse un procedimiento si VBA encuentra una variables
que no ha sido declarada de forma explícita a través de la expresión Dim, entonces se
hará de forma implícita a adjudicando a dicha expresión un tipo Variant.
Recuerda que el tipo Variant permite almacenar sucesivamente en la misma

variable valores de distinto tipo. El tipo de la variable cambiará en función del valor que
se le asigne.
Página 61 de 175
Declaración explícita.
Debido a la circunstancia anterior es conveniente declarar previamente el tipo de
variables con las cuales vamos a trabajar, ya que sino se encargará VBA de hacerlo
de manera implícita con la asignación de variables del tipo Variant, con el despilfarro
de recursos que supone tal circunstancia.
De todos modos, es posible imponer la declaración explicita utilizando la

instrucción Option Explicit en la sección de la declaración de cada módulo, que se
corresponde con el principio del módulo.
También podemos establecer de manera predeterminada esta opción desde las

Opciones del menú Herramientas, activando la opción Requerir declaración de
variables que se puede encontrar en la ficha Editor.
Página 62 de 175
La declaración de variables se realiza mediante alguna de las siguientes

estructuras en el procedimiento:
Mientras que si lo que queremos es declararlos en el módulo podemos utilizar

las siguientes expresiones al principio del módulo.
Los operadores
Los operadores permiten efectuar operaciones matemáticas sobre las variables

y constantes, comparar variables entre, evaluar condiciones, etc.,
Las categorías de los operadores son del tipo:
 Aritméticos (+, -,/,*, etc.,)

 De comparación (<,>,<=, >=, = <>).
 Lógicos. (And, Or, Not, )
 Concatenación (&).
Página 63 de 175
Operador &
Este operador nos permite unir o encadenar información de diferentes variables.
Variables estáticas
La vida de una variable está directamente relacionada con la forma y el lugar

donde se declara como hemos visto en los apartados anteriores. El valor de las
variables declaradas a nivel de módulo y públicas se preserva durante todo el tiempo
de ejecución. Sin embargo, las variables locales declaradas con Dim sólo existen
mientras se ejecuta el procedimiento en el cual se han declarado. La próxima vez que
se ejecute el procedimiento se reinicializarán todas sus variables locales.
Sin embargo es posible preservar el valor de una variable local si se declara

como estática, utilizando la palabra clave Static:
Página 64 de 175
Variables de objeto: Instrucción Set
La instrucción Set permite atribuir una referencia de objeto a una variable,

llamada variable de objeto. Esta instrucción puede emplearse para crear una
referencia hacia un nuevo objeto (utilizando eventualmente un método que permita
crear el objeto) o para asignar una referencia a un objeto ya existente.
Utilizar una variable de objeto es similar a utilizar una variable convencional,

pero con un paso adicional: asignar un objeto a la variable.
Primero, declararemos la variable con una sentencia
Dim variable As clase
Luego, asignaremos un objeto a esa variable, utilizando la instrucción Set:
Set variable = objeto
En la siguiente ilustración podemos observar una declaración de variables objeto para

objetos de tipo Rango y Hoja.
Las constantes
Una constante representa un valor numérico o texto que no debe ser

modificado. Así la instrucción Const permite declarar una constante y definir su valor
como fijo. Una vez declarada, la constante no puede modificarse ni recibir un nuevo
valor.
La declaración de una constante se puede realizar dentro de un procedimiento

o en la sección de declaración de un módulo.
Página 65 de 175
Las constantes a nivel de módulo son privadas por defecto. Sin embargo para
declarar una constante a nivel de módulo como pública, es necesario preceder la
expresión Const con la palabra clave Public.
Pero estas no son las únicas constantes con las cuales nos podemos
encontrar, Visual Basic dispone de una serie de constantes llamadas intrínsecas que
son visibles en el examinador de objetos, y pueden aparecer en el momento de
completar determinados argumentos de algunos objetos o funciones de VBA. El más
básico lo constituye la función MsgBox cuando queremos mostrar diferentes tipos de
botones en la ventana, para lo cual tenemos que seleccionar un tipo de constante
diferente.
De igual modo, existen constantes que nos van a permitir realizar tareas
habituales en los cuadros de mensaje, como pueda ser realizar saltos de línea para
ver en varias líneas el prompt del Msgbox, para lo cual tendremos que emplear
constantes del tipo vbCr, para realizar un salto de párrafo, o vbLf para realizar un salto
de línea, con la utilización de la constante vbCrLf, se puede realizar tanto un salto de
carro y un salto de línea.
Página 66 de 175
Las matrices
Una matriz se declara del mismo modo que las variables, mediante
instrucciones Dim, Static, Private o Public. Una matriz es una variable que contiene
diversas celdas que permiten almacenar el mismo número de valores. Mientras, que
una variable estándar sirve para guardar un único valor.
Se puede referenciar a una matriz de forma global o individualmente a sus

elementos mediante la utilización de índices.
Cualquiera que sea el tipo de elementos, una matriz requiere 20 bytes de

memoria, a los que hay que añadir cuatro bytes para cada dimensión y el número de
bytes ocupados por los datos.
Si no se específica el tipo de datos que va a almacenar, se sigue la regla

general, en cuanto a la asignación de variable del tipo Variant, para aquellas que no
han sido declaradas previamente.
Al primer elemento de la matriz se le asigna el índice 0 (por defecto). Sin

embargo, es posible convertir este valor predeterminado a 1 utilizando, en la sección
de declaración, la instrucción Option Base 1.
La declaración de las matrices se puede realizar de diferente manera,

permitiendo hasta 60 dimensiones en una misma matriz, como recintos de diferente
tamaño para almacenar diferentes valores en un mismo recipiente.
Página 67 de 175
Una vez, se hayan establecido las dimensiones de la matriz, lo que queda es

asignar los valores a cada uno de sus elementos, esta acción se realizará mediante la
siguiente sintaxis:
La recuperación de los diferentes valores de la matriz hace uso de una sintaxis

similar, a la que permite su almacenamiento, en la siguiente ilustración podemos
comprobar cómo se recuperan los elementos 1,3 y 5 de la anterior matriz para poder
ser visualizados a través de la ventana de inmediato.
Las matrices no tienen que tener siempre unos elementos estáticos, sino que
puede ser redefinidos sus elementos durante la ejecución del procedimiento porque
dichos elementos se han podido variar, por la eliminación o incorporación de algún
nuevo elemento.
Página 68 de 175
La declaración de las variables dinámicas se realizaría con la siguiente sintaxis:
Dim Matriz ()
Pero antes de utilizarla, es necesario dimensionarla por medio de la instrucción Redim:
ReDim Matriz (1 to 15)
Es posible utilizar esta instrucción ReDim para modificar la estructura de una

matriz tantas veces como será necesario. Por defecto, los valores presentados en una
matriz se eliminan. Pero con la instrucción ReDim Preserve se puede modificar el
tamaño de una matriz conservando los valores existentes.
Redim Preserve Matriz (15 to 70)
El uso de estas variables es más eficiente cuando se combinan con las

estructuras de repetición o bucles que permiten asignar los valores de los elementos
de la matriz de una manera más rápida y eficaz, como se puede ver en la siguiente
ilustración:
Página 69 de 175
Ejemplo 1: Declaración de diferentes tipos de variable.

La declaración de variables adaptadas al tipo de datos que vayan a contener sería
una de las reglas principales para conseguir que un procedimiento pueda llegar a ser
lo más eficiente posible, y que no consuma más recursos de los necesarios.
Ejemplo 2: Procedimiento para unir diferentes variables en una nueva.
El siguiente procedimiento nos va a permitir encadenar una nueva variable los

valores asignados previamente en dos variables anteriores, para los cual tendremos
que hacer uso del operador & (unir) que es de uso habitual en el diseño de
procedimiento para poder encadenar variables con otros elementos de nuestras
sentencias en VBA.
Página 70 de 175
Ejemplo 3: Procedimiento para calcular el promedio de un rango

determinado.
El uso de funciones en la creación de procedimientos en Excel es bastante

habitual, la poder hacer uso de ellas podemos recurrir a dos tipos de objetos diferentes
como es VBA, o el objeto, WorksheetFuntion.
Otra posibilidad para poder hacer uso de funciones desde el código de VBA lo
encontramos en el objeto VBA.
Página 71 de 175
Ejemplo 4: Proporcionar el dato al propio procedimiento a través de la

función INPUTBOX
En muchas circunstancias puede resultar muy interesante que el usuario pueda

proporcionar información al procedimiento para establecer el valor de la variable, en el
ejemplo anterior el procedimiento tendría la siguiente modificación.
En el momento de ejecutar el procedimiento este nos solicitará que le proporciones

un valor a la variable a través de una ventana de este tipo:
Ejemplo 5: Procedimiento para guardar la cantidad de hojas del libro en

una variable.
Página 72 de 175
Ejemplo 6: Procedimiento para guardar los tres primeros nombres de la

hoja en una variable de tipo matriz.
Cuando lo que queremos es guardar varios valores en una única variable, el

recurso que tenemos es guardar dichos en una variable de tipo matriz.
Ejemplo 7: Procedimiento para localizar la fila que tiene el último dato, así
como el dato de la última fila.
En muchas circunstancias necesitamos localizar el último dato de un rango, o bien,

la última posición de un rango para poder agregar un dato al final del listado, para tales
circunstancias tenemos las siguientes posibilidades:
Página 73 de 175
OBJETIVO: “Diseñar un procedimiento para informar sobre la cantidad de

productos y importe medio de la factura a través de variables”.
1. Crea diferentes variables para guardar la siguiente información:

a. Nombre completo del cliente con Nombre y apellidos.
b. Cantidad de filas incorporadas en la factura.
c. Importe medio de la factura.
d. El nombre del último producto.
e. Muestra esta información en diferentes líneas a través de un cuadro de
mensaje.
2. Introduce a través de un Inputbox la siguiente información:

a. Introduce la fecha en la referencia C2 con dos días más a la fecha actual.
b. Una numeración que debe recordar el último valor incorporado.
3. Crea variables para guardar toda la información solicitada, así como para los
rangos sobre los cuales se van a realizar los cálculos.
a. Escribe en las celdas reservadas de la factura los cálculos realizados.
Página 74 de 175
Página 75 de 175
LECCIÓN 6. ESTRUCTURAS DE DECISIÓN Y SELECCIÓN
A menudo es necesario comprobar condiciones específicas antes de ejecutar

instrucciones. Las estructuras de decisión, llamadas también alternativas o
bifurcaciones condicionales, permiten, al término de una evaluación, optar por un
bloque de código u otro.
Una de las herramientas más útiles en cualquier lenguaje de programación lo
constituyen las “expresiones condicionales”, que es una parte de una instrucción del
programa que responde a una pregunta de verdadero-falso sobre una propiedad de un
objeto, una variable o cualquier otro dato del código.
Por ejemplo, la expresión condicional:
Importe >1000
Se evalúa como True (o verdadero) si la variable Importe contiene un valor mayor de

1000, y como False (o falso) si contiene un valor menor o igual a 1000.
Entre los operadores de comparación que podemos utilizar se encuentran los

siguientes:
Operador de Significado
comparación
= Igual
<> No igual o distinto
> Mayor
< Menor
>= Mayor o igual
<= Menor o igual
Las “estructuras de decisión”, llamadas también o de bifurcación condicional,

controla si otras instrucciones de su programa se ejecutan y en qué orden lo hacen.
Se puede utilizar una estructura de decisión If…Then para evaluar una condición en un
programa y seguir el curso de la acción basada en el resultado.
Se distinguen principalmente dos tipos de instrucciones de bifurcación condicional:

 If … Then … Else
 Select … Case
Página 76 de 175
Instrucción IF
Permiten ejecutar instrucciones en función del resultado de una condición.

IF <condición> THEN <instrucción>
Las estructuras condicionales tienen diferentes tipos de estructuras, en base a
que se evalúen las condiciones de manera independiente, o se aniden, una
condiciones dentro de otras.
Estructura condicional simple
Si la condición se cumple pasará a ofrecernos un cuadro de mensaje del tipo

siguiente:
Estructura condicional anidada.
Cuando lo que queremos es evaluar varias condiciones lo que tenemos que

hacer es recurrir a un tipo de estructura más compleja que la anterior versión simple.
La sintaxis de las estructuras condicionales anidadas es la siguiente:
IF <condición> THEN
<instrucción>
ELSEIF <condición> THEN
<instrucción>
ELSE
<instrucción>
END IF
Página 77 de 175
Con este tipo de sintaxis el bloque de instrucciones puede tener varias líneas y
contiene las siguientes palabras claves para configurar su estructura como son If,
Elseif, Else y End If. Con este tipo de estructuras podemos establecer mayor número
de condiciones en base a nuestras necesidades.
Operadores lógicos en expresiones condicionales.

Para evaluar más de un criterio en una expresión condicional, las condiciones
extras se pueden vincular con los siguientes operadores lógicos que se pueden ver en
la siguiente tabla:
Operador lógico Significado

And Si ambas expresiones condicionales son Verdaderas, entonces
el resultado es Verdadero.
Or Si cualquiera de las expresiones condicionales es Verdadera,
entonces el resultado es Verdadero.
Not Si la expresión condicional es Falsa, entonces el resultado es
Verdadero. Y si la expresión condicional es Verdadera, entonces
el resultado es Falso.
Xor Si una, y sólo una, de las expresiones condicionales es
Verdadero, entonces el resultado es Verdadero. Y si ambas son
Verdaderas o Falsas, entonces el resultado es Falso.
Página 78 de 175
Con esta variación en la estructura condicional lo que podemos hacer es

evaluar varias condiciones por cada estructura condicional, es decir, que una única
estructura condicional puede evaluar varias condiciones a la vez, con la siguiente
sintaxis:
IF <condición1> AND/OR <condición2> … N THEN <instrucción>
En la siguiente ilustración podemos observar un caso de estructura condicional

con dos condiciones que pasa a ejecutar la instrucción para el caso en que ambas
condiciones sean verdaderas:
Si lo que queremos es ejecutar la instrucción para casos en los que se cumplan

una única condición, tendremos que cambiar el operador AND, por el operador OR. En
este ejemplo, podemos establecer dos condiciones para el caso de que se cumpla
alguna de ellas, se pasé a ejecutar de manera inmediata la instrucción verdadera.
Página 79 de 175
Ejemplo 01: Estructura condicional para mostrar dos mensaje posibles.
Las estructuras condicionales se pueden complicar más, al poder ofrecer más

mensajes alternativos, en lugar de uno sólo. Por ejemplo, podemos establecer una
estructura que nos devuelva el mensaje de Buenos días si la hora es menor de las 12
h, o, Buenas tardes, si por el contrario, la hora es superior a las 12 h de la mañana.
Ejemplo 02: Estructura condicional para evaluar notas.
Pero puede ocurrir que necesitemos más posibilidades con la función lógica para
lo cual tendremos que crear condiciones anidadas. En el siguiente ejemplo, se crea un
diseño de funciones condicionales para evaluar la nota proporciona a través de un
Inputbox.
Página 80 de 175
Ejemplo 03: Estructura condicional para evaluar si hay contenido en una

celda.
Para este caso tendremos que hacer uso de una función denominada IsEmpty que
permite evaluar si una celda tiene contenido o no.
Ejemplo 04: Estructura condicional para abandonar la aplicación.
Con este procedimiento podemos generar una ventana donde nos permitirá elegir
entre permanecer o salir de la aplicación a través de un cuadro de mensaje que tiene
dos botones.
Página 81 de 175
Instrucción Select
Con esta estructura podemos ejecutar una de las secuencias de instrucciones

especificadas en función del valor de la expresión.
SELECT CASE <expresión>

CASE <opción>
<instrucciones>
CASE <opción>
<instrucciones>
CASE <opción>
<instrucciones>
CASE ELSE
<instrucciones>
END SELECT
Con VBA también podemos controlar la ejecución de las instrucciones en sus

programas utilizando también las estructuras de decisión Select Case. Una estructura
de decisión Select Case es parecida a una estructura If…Then…Elseif, pero es más
eficaz cuando lo que se pretende evaluar es una única variable, en este caso, no se
establecen condiciones, sino posibilidades para la variable que tenemos que
establecer en la expresión CASE de la estructura, que permite varias modificaciones
para detectar un valor único, varios o un intervalo.
En la siguiente ilustración podemos visualizar las diferentes posibilidades para

establecer los casos de la estructura:
Página 82 de 175
Ejemplo 01: Estructura Select Case para generar diferentes mensajes.
Con este ejemplo se va a evaluar la hora actual para generar diferentes tipos de
mensajes con una estructura de decisión.
Ejemplo 02: Estructura Select Case para evaluar la temperatura con

diferentes tipos de casos.
Con este ejemplo se pueden comprobar los diferentes sistemas que tenemos
para hacer referencia a los casos, tanto a través de intervalos como a varios casos
determinados.
Página 83 de 175
Diseño de funciones básicas
Los procedimientos Function, llamados habitualmente como funciones,

devuelven un valor, como resultado de un cálculo que realicen. Es importante tener en
cuenta que el valor devuelto debe tener el nombre de la función.
El lenguaje Visual Basic cuenta ya con numerosas funciones integradas, como

las funciones relativas a las fechas (now, day, weekday, year,…), y otras muchas
relacionadas con otras categorías como puedan ser las de texto (left, right, mid,…).
Además de contar con estas posibilidades se pueden crear nuestras propias

funciones personalizadas para luego poder hacer uso de ellas en cualquier momento.
Las funciones se crean dentro de cualquiera de los módulos que tengamos

creados y para lo cual hay que seguir la siguiente sintaxis:
FUNCTION <nombrefuncion> (<variable> AS <tipo>) AS <tipo>
<nombrefuncion>= <instrucciones y algoritmos>
END FUNCTION
Ejemplo 01: Función para calcular el IVA de una celda.
El ejemplo más básico de función viene dado por la utilización de una única
variable la cual la multiplicares por una constante o valor, el caso, más sencillo lo
puede constituir una función que calcule el IVA, de una cantidad determinada.
La complicación en el diseño de funciones lo encontramos en la posibilidad de

poder incorporar estructuras de decisión de las vista en el presente capítulo para
conseguir resultados más elaborados.
Página 84 de 175
OBJETIVO: “Diseñar un procedimiento para evaluar correctamente la nota

proporcionada a través de un Inputbox”.
1. Crea variables para guardar la nota y el resultado de la calificación.

2. Crea varias condicionales para que a través de una función Inputbox podamos
proporcionar una nota a la variable, y nos devuelva la calificación correspondiente
a través de un cuadro mensaje.
3. Prueba a cambiar la nota para comprobar que evalúa correctamente.
NOMBRE DEL PROCEDIMIENTO:”Practica06.
OBJETIVO: Diseñar un procedimiento con los mismos objetos de la práctica

anterior pero en este caso, con estructuras de decisión Select Case.
NOMBRE DE LA FUNCIÓN: “Convertir_claves”.
OBJETIVO: “Diseñar una función para convertir los las siguientes

nomenclaturas a su texto correspondiente, utiliza una estructura de Select Case”
Devolver texto en base a una codificación

' MS = Muy satisfecho.
' S = Satisfecho.
' PS = Poco satisfecho.
' NS = Nada satisfecho.
' I = Insatisfecho.
Página 85 de 175
OBJETIVO: “Diseñar un procedimiento para establecer el perfil correcto para

valores mayoritarios según los valores que tienes en la hoja PRACTICA05”.
1. Crea variables para guardar el perfil mayoritario para cada grupo según sea
hombre o mujeres, de población urbana o rural, y por último, con estudios o sin
estudios.
2. Crea un sistema de condiciones para que el resultado sea el correcto en base a los
datos de la tabla.
3. Cuando ejecutes el procedimiento nos tiene que devolver el perfil en un cuadro de
mensaje.
OBJETIVO: “Modifica el sistema anterior de condiciones para detectar solo los

perfiles en los cuales tengan estudios, y en el resto, que muestre el mensaje de
que no interesa el perfil.”
Página 86 de 175
Solución Practica05:
Página 87 de 175
Solución Convertir_claves:
Página 88 de 175
Continuación del código anterior:
Página 89 de 175
Continuación del código anterior:
Página 90 de 175
LECCIÓN 7. ESTRUCTURAS DE REPETICIÓN Y BUCLE
Las estructuras en bucle (o repetitivas) permiten repetir la ejecución de una serie

de instrucciones.
Se distinguen varios tipos de estructuras de estructuras en bucle:

 For … Next
 For Each … Next
 Do while … Loop
 Do … Loop While
Con esta estructura podemos ejecutar una instrucción determinada cantidad de

veces en base al valor de un contador.
Instrucción For … Next
Con un bucle For … Next, se puede ejecutar un grupo específico de

instrucciones de programa varias veces en un procedimiento de evento o en un
módulo de código. Un bucle For … Next es realmente una forma abreviada de escribir
una larga lista de instrucciones de programa.
Esta estructura permite la ejecución de una secuencia de instrucciones

similares en función de un contador, o recorrer una colección de objetos según el tipo
de aplicación en la cual estemos trabajando, para el caso de Excel se pueden recorrer
las colecciones de los libros, hojas, celdas, etc.,
Para esta estructura se necesitan las siguientes palabras claves For, To y Next, así
como el operador igual (=). La variable i, en este caso, sigue el rastro de una cuenta,
según los puntos de partida y finales del bucle. En el caso, que nos muestra la
ilustración el comienzo se sitúa en el valor 1 y el final en al 10. Mientras que la o las
líneas que se encuentran entre las expresiones For y Next son las instrucciones que
se repiten cada vez que se ejecuta el bucle.
For <contador>=<inicio> to <fin>
<instrucciones>
Next <contador>
Página 91 de 175
El siguiente ejemplo permite comprobar como es el funcionamiento básico de una

estructura de repetición:
La estructura de repetición permite ciertas variaciones que nos permiten

obtener diferentes resultados en el momento de la ejecución del procedimiento,
como pueda ser por ejemplo, modificar el incremento de la secuencia:
For <contador>=<inicio> to <fin> Step <incremento>
<instrucciones>
Next <contador>
Página 92 de 175
Con esta modificación podemos conseguir series que vayan aumentando no de

uno en uno, sino en base a otra cantidad distinta como podemos ver en el
siguiente ejemplo:
Otra posibilidad que nos pueden ofrecer las estructuras de repetición, es la de

anidar una estructura de repetición dentro de otra, con lo cual tendremos que
posibilidad de combinar dos estructuras de repetición simultáneamente, para que cada
elemento de una secuencia se asocie a todos los elementos de la siguiente, la
siguiente ilustración nos mostrará como es el procedimiento, y cuál sería el resultado.
Página 93 de 175
Instrucción For Each … Next
Este tipo de estructura es similar a la anterior, es capaz de repetir una

instrucción una serie de veces, la diferencia radica en que este caso se requiere de la
existencia de una colección de objetos para que la estructura sea capaz de recorrer
toda la colección, como puedan ser los las hojas del libro, la celdas de un rango, etc.,
For Each<elemento> to <colección>
<instrucciones>
Next <elemento>
El siguiente ejemplo permite comprobar como es el funcionamiento básico de una

estructura de repetición basada en la estructura For Each … Next para conseguir el
nombre de cada una de las hojas de nuestro libro.
Todas aquellas colecciones del modelo de objetos de Excel puede ser recorrido
a través de estructuras de este tipo, como por ejemplo, las celdas que componen un
rango como en el ejemplo siguiente:
Página 94 de 175
Estructuras en bucle
Las estructuras en bucle (o repetitivas) permiten repetir la ejecución de una serie

de instrucciones en base al cumplimiento de una condición determinada, y no parará
su ejecución hasta que dicha condición se cumpla.
Se distinguen varios tipos de estructuras en bucle:
Sintaxis 1: Instrucción Do While … Loop
Las instrucciones se ejecutan mientras la condición es verdadera.
Do while <condición>
<instrucciones>
<modificación o incremento de la condición>
Loop
En la siguiente ilustración puedes comprobar se puede ver un caso básico

de creación de un bucle para generar una serie secuencia de uno en uno hasta que se
cumpla la condición que el número de la serie sea un diez.
Página 95 de 175
Sintaxis 2: Instrucción Do … Loop While
Do
<instrucciones>
<modificación o incremento de la condición>
Loop while <condición>
Otra variante del bucle condicional es la posibilidad de incorporar la condición

al final de la estructura condicional, en lugar, de al principio, con lo cual la primera
instrucción del bucle se realizaría aun no cumpliendo la condición de la estructura.
NOTA IMPORTANTE: En este tipo de estructuras es muy importante que en el

bloque de las instrucciones incorporemos una instrucción que modifique la
condición para poder dejar de cumplirla en algún momento, ya que en caso
contrario, podemos entrar en bucles infinitos, en los cuales el procedimiento
saturara el procesador ante un ejecución permanente de procedimiento, en tales
casos, la interrupción del procedimiento se puede forzar haciendo uso de la
combinación de teclas Control+ Pausa.
Página 96 de 175
Página 97 de 175
Ejemplo 01: Estructura de repetición para rellenar series numéricas.
Con este ejemplo se va a evaluar la hora actual para generar diferentes tipos de
mensajes para lo cual hay que hacer uso del objeto Cells (fila,columna) que permite
incorporar valores en una celda en base a dos argumentos numéricos.
Ejemplo 02: Estructura de repetición para conseguir los nombres de las

hojas.
Con este ejemplo se va a conseguir incorporar los nombres de las diferentes hojas
del libro, haciendo uso de una estructura de repetición que va a recorrer dos
colecciones diferentes: la colección Sheets para recuperar la propiedad name, además
de la colección Cells (fila,columna) que nos va a permitir grabar los diferentes nombres
de las hojas en celdas distintas.
Página 98 de 175
Ejemplo 03: Estructura de condicional para mostrar un cuadro de diálogo

que solicita un número, y no se cerrará hasta que incorporemos el dato
correcto.
Con este procedimiento vamos a lanzar un cuadro diálogo en el cual se va a

solicitar un dato numérico con la condición múltiple que sea un número entre 0 y 100 y
no un texto, y si no se introduce un dato cumpliendo dichas condiciones el cuadro de
diálogo no se cerrará, hasta el dato incorporado cumpla dicha condición.
NOTA IMPORTANTE: En algunas ocasiones puede que un procedimiento con la

estructura de bucle, no se produzca la condición para poder salir del él, ya sea porque
el usuario no introduzca el dato con la condición, o bien, se haya diseñado mal el
procedimiento y una vez que se ejecute no se pueda producir, dicha condición, por lo
cual, es interesante saber que combinación de teclas nos puede ayudar a detenerlo,
que es CONTROL + PAUSA.
Página 99 de 175
PRACTICAS DEL CAPÍTULO:
OBJETIVO: “Diseñar un procedimiento crear una serie lineal desde 100, de cien en
cien hasta 10.000 de manera continua en una hoja en la columna A”.
OBJETIVO: “Diseñar un procedimiento para crear una tabla de números aleatorios de

15 filas y 10 columnas”.
Página 100 de 175

OBJETIVO: “Diseñar un procedimiento para que guarde en una matriz los nombres de
las hojas del libro, y nos muestre los nombres de todas las hojas en un Msgbox en
columnas”.
OBJETIVO: “Modifica el siguiente código para que realice una comparación correcta
de los datos, para que si son todos iguales diga todos son iguales, o son distintos”.
Página 101 de 175

OBJETIVO: “Diseña un procedimiento con una estructura de tipo bucle para que
localice la primera celda vacía de los datos situados en la hoja PRACTICA13, y nos
muestre en un Msgbox el número de la fila que se encuentra en blanco, y se situé en
dicha celda.”
OBJETIVO: “Diseña un procedimiento con una estructura de tipo bucle para que nos
muestre un Inputbox en el cual tengamos que incorporar un número mayor de 20, y
hasta que no lo hagamos no se cierre el Inputbox.”.
NOMBRE DE LA FUNCIÓN: “Practica15”.
OBJETIVO: “Diseñar una función para separar los números del texto de una celda”
OBJETIVO: “Diseñar una función para contar los espacios que hay en una celda”
Página 102 de 175

Página 103 de 175

Página 104 de 175

Página 105 de 175

LECCIÓN 8. LOS PROCEDIMIENTOS FUNCTION
Los procedimientos Function, llamados más habitualmente funciones, devuelven

un valor, como el resultado de un cálculo. El valor devuelto debe tener el nombre de la
función.
El lenguaje Visual Basic cuenta con numerosas funciones integradas, como las
funciones relativas a las fechas (day, week, year, format,…). Pero además de estas
funciones integradas, se pueden crear funciones propias personalizadas.
Sintaxis de un procedimiento Function

Function Nombre_función ([lista de argumentos] as type)
<Secuencia de instrucciones>
End function
Una función es lo mismo que un procedimiento con la salvedad que este devuelve
un valor al procedimiento o función que lo llama. Vea el siguiente ejemplo, es una
función muy sencilla ya que suma dos números (X e Y), que guarda en una variable
llamada Resultado, para posteriormente devolvérselo a la función Sumar.
Página 106 de 175

Para poder utilizar esta función en nuestra hoja de cálculo tendremos que
acudir al asistente de funciones que podemos encontrar en la barra de fórmulas, para
posteriormente seleccionar la categoría de funciones Definidas por el usuario.
Ejemplo 01: Función que calcula el IVA de un valor monetario.
Ejemplo 02: Función que transforma minutos a horas.
Página 107 de 175

Ejemplo 03: Función que calcula la diferencia entre el promedio de un

rango y un dato.
Ejemplo 04: Función para calcular la edad con la fecha de nacimiento
Ejemplo 05: Función para extraer la primera palabra por la izquierda
Con esta función vamos a conseguir la primera palabra o expresión de una

celda que tengan varias expresiones o palabras.
Página 108 de 175

Ejemplo 06: Función para separar el texto de los números que tiene una
celda.
Con esta función vamos a conseguir separar parte del contenido de la celda
haciendo uso tanto de estructuras de repetición, junto a condicionales que nos
permitan valorar cada uno de los caracteres que componen el texto de una celda. Con
el siguiente ejemplo podemos ver como una función puede complicarse combinando
ambas estructuras.
Página 109 de 175

OBJETIVO: “Diseñar una función para separar los números del texto de una celda”
OBJETIVO: “Diseñar una función para contar los espacios que hay en una celda”
Página 110 de 175

Página 111 de 175

LECCIÓN 9: FORMULARIOS
Un Formulario (o su denominación en inglés Userform) se utiliza para crear un

Cuadro de Diálogo donde el usuario puede introducir información, o realizar otras
operaciones. Al ejecutar muchas de las opciones del menú de Excel se abren
formularios.
Esta ventana es realmente un formulario que se abre al entrar en las opciones

de alineación de las celdas, en la pestaña Inicio.
Tiene muchos elementos que nos permiten modificar aspectos del formato de
las celdas. Consta de pestañas, cuadros de lista, cuadros combinados, casillas de
verificación, etc.
Pero también podemos crear nuestros propios formularios como se ve a
continuación:
Página 112 de 175

Los UserForms se utilizan mucho para crear aplicaciones Excel que luzcan de
forma profesional y permitan al usuario introducir datos o elegir opciones de una forma
guiada y más intuitiva.
Los formularios permiten diseñar interfaces de usuario simples y amigables
para la introducción, modificación o visualización de los datos. En estos formularios
personalizados podemos:
 Incorporar controles ActiveX como cuadros de texto, listas
desplegables, cuadros combinados, casillas de verificación, botones de
comando …
 Asociar código VBA que permita responder a los distintos sucesos o
eventos del usuario (como hacer un clic sobre un botón de comando,
entrar datos en un cuadro de texto, seleccionar un valor de una lista
desplegable …)
Crear un formulario
Un formulario se crea en una hoja UserForm.
El procedimiento para crear un Userform es muy sencillo, lo primero que hay
que hacer es Abrir el editor de VBA (por ejemplo, con CTRL+F11). Y a continuación
insertar una hoja UserForm a través del menú Insertar.
Una vez seleccionada esta opción se insertara un hoja UserForm en la cual

podremos añadir diferentes tipos de controles para mejorar la interacción entre la
aplicación y los usuarios.
También podemos incorporar un formulario haciendo uso del botón derecho del
ratón sobre la ventana de proyectos, de forma similar a como lo hemos hecho
anteriormente.
Página 113 de 175

En la ventana de Código de la derecha, veremos que aparece un UserForm en

blanco, sin controles. Para abrir su Cuadro de Herramientas puedes hacerlo desde el
menú Ver > Cuadro de Herramientas. Ahí figuran los controles que podremos agregar
dentro del Userform. Para añadir uno, simplemente hacemos clic izquierdo en el
control deseado y luego clic izquierdo dentro del Userform, en el sitio donde queramos
agregar el control.
Todos los controles incorporados, así como el formulario UserForm poseen una
serie de propiedades que podemos modificar para personalizar su apariencia, o
mejorar su funcionamiento. Algunas de las propiedades más destacables del
formulario son por el ejemplo:
 Name: Da un nombre al formulario y permite cambiar su nombre para

modificar el que nos viene de manera determina.
 Caption: Con esta propiedad podemos cambiar el texto que aparece en la
barra de título.
Estas propiedades y otras muchas más las podemos encontrar en la ventana

de propiedades, que podemos mostrar si no estuviera activa desde el menú Ver /
Ventana de propiedades.
Página 114 de 175

Para modificar el tamaño del formulario, seleccionaremos el formulario y

arrastraremos los puntos o manejadores, o bien, modificaremos las propiedades
Height y Width del formulario.
La idea es que mediante estos controles podremos tanto capturar como enviar
información o datos desde o hacia las celdas de Excel respectivamente. También
podemos asociar macros a los controles que agreguemos al Userform
Si te posicionas sobre los Controles del Cuadro de herramientas, verás que
aparece su nombre. Simplemente hacemos clic izquierdo en el control deseado y
luego clic izquierdo en el Userform, en el sitio donde queramos agregar el control. En
nuestro caso hemos agregado algunos controles de forma desordenada dentro del
Userform.
Página 115 de 175

Controles del formulario

Como hemos visto en el apartado anterior existen toda una serie de controles
que se pueden agregar al Userform, con diferentes tipos de funcionalidades que
pueden facilitar nuestro trabajo con los formularios. La visualización del cuadro de
herramientas lo podemos activar en el caso de no visualizarlo desde el menú Ver y
seleccionando la opción Cuadro de Herramientas.
Si necesitásemos algún tipo de control diferente a los incorporados en el

cuadro de herramientas, lo podríamos añadir desde la opción Controles adicionales
del menú Herramientas.
Página 116 de 175

Los controles nos van a permitir diferente tipos de funcionalidades en el

formulario, en algún caso simplemente en la vista de diseño para poder seleccionar los
diferentes controles, y otros tienen una funcionalidad orientada en el momento de su
uso. La siguiente tabla tiene una breve descripción de los mismos , en el mismo orden
que aparecen en el Cuadro de Herramientas.
Seleccionar objetos: sirve para seleccionar controles que hayamos insertado

en el Userform.
Etiqueta (Label): sirve para poner un título o un texto.
Ejemplo: podemos poner un texto del tipo “Complete las opciones a
continuación” y ubicarlo en cualquier sitio del Userform. También podemos
agregar títulos o descripciones al resto de comandos que agreguemos en el
Userform.
Cuadro de texto (Textbox): sirve para que un usuario introduzca datos.
Ejemplo: queremos que el usuario introduzca una fecha o un nombre (que
luego llevaremos a alguna celda de Excel).
Cuadro combinado (ComboBox): sirve para que un usuario elija una opción
de una lista.
Ejemplo: creamos una lista con los meses de Enero a Diciembre para que el
usuario elija uno de ellos.
Cuadro de lista (ListBox): sirve para que un usuario rellene o elija varias
opciones de una lista.
Ejemplo: creamos una lista con Regiones o Ciudades y el usario deberá elegir
una o varias de ellas.
Casilla de verificación (CheckBox): sirve para que un usuario active una
determinada función.
Ejemplo: podemos hacer que al cerrar el Userform se imprima un reporte solo
si la casilla de selección está tildada.
Botón de opción (OptionButton): sirve para que un usuario seleccione una
opción determinada entre varias posibilidades.
Ejemplo: queremos que el usuario indique si es de sexo Masculino o
Femenino. De todas las opciones solo se puede seleccionar una de ellas.
Botón de alternar (ToggleButton): sirve para activar o desactivar alguna
funcionalidad. Este botón adopta el modo “Encendido” / “Apagado”.
Ejemplo: queremos que el usuario defina su idioma, en modo encendido
español y en modo apagado inglés.
Marco (Frame): sirve para agrupar elementos de un Userform (los elementos
se deben ubicar dentro del Frame).
Ejemplo: tenemos varias grupos de OptionButton y para distinguirlos los
agrupamos con un Frame. Si tenemos un grupo de opciones tipo
masculino/femenino los agrupamos dentro de un frame. Si luego tenemos otro
grupo de opciones del tipo Mayor de Edad / Menor de Edad los agrupamos
dentro de otro Frame.
Botón de comando (CommandButton): es un simple botón que nos permite
ejecutar acciones.
Ejemplo: un botón de Ayuda que ejecuta otro Userform con ayuda para el
usuario.
Barra de tabulaciones (TabStrip): en un mismo Userform se pueden crear
Página 117 de 175

distintas secciones.
Ejemplo: un userform con cuatro secciones: Norte, Sur, Este y Oeste. Dentro
de cada sección podemos ubicar distintos controles.
Página múltiple (MultiPage): en un mismo Userform se pueden crear
distintas páginas.
Ejemplo: un userform con 2 páginas: España y Resto del Mundo. Dentro de
cada página podemos ubicar distintos controles o distintas secciones.
Barra de desplazamiento (ScrollBar): si tenemos una lista con muchos
elementos el scrollbar nos permite navegarlos.
Ejemplo: tenemos una lista con 150 países. Con el ScrollBar podemos subir y
bajar por la lista de los mismos utilizando las flechas de desplazamiento.
Botón de número (SpinButton): permite aumentar o disminuir valores.
Ejemplo: tenemos una lista con tipos de interés y queremos que sean
incrementados o disminuidos en cantidades predeterminadas desde el
SpinButton.
Imagen (Image): permite introducir imágenes en el Userform.
Ejemplo: queremos introducir una fotografía como fondo del Userform para
darle un aspecto más profesional.
Referencia (RefEdit): permite hacer referencia a una celda de Excel.
Ejemplo: queremos que el usuario seleccione un dato que fue introducido
previamente en una celda Excel.
Todos los controles poseen igualmente diferentes tipos de propiedades

dependiendo del tipo de control, ya que existen varias que son comunes, y otras que
son específicas de cada uno de los controles. Entre aquellas propiedades más
comunes de los controles podemos encontrar las siguientes:
 Name: Sirve para asignar un nombre al control, para poder referenciarlo a

través del código.
 Caption: Es el texto de la etiqueta que aparece de cara al usuario.
 ControlTipText : Crea un ayuda flotante.
 Visible: Especifica si un control está visible u oculto.
 Enabled: Determina si un control puede recibir el foco.
 Value: Define el estado o el contenido de un control.
 ControlSource: Vincula un control a una celda (cuadro de texto) o un rango de
celdas (cuadro de lista).
 Font: Define el tipo de letra.
 BackColor: Especifica el color de fondo.
 ForeColor: Especifica el color de primer plano.
 BorderColor: Especifica el color del borde.
 BorderStyle: Especifica el tipo de borde.
 AutoTab: Fuerza una tabulación automática cuando una entrada alcanza el
número máximo permitido de caracteres.
 Locked: Indica si un control puede modificarse.
 MultiLine: Define si un control puede aceptar y mostrar varias líneas de texto.
Página 118 de 175

Sucesos de los controles.
El manejo de eventos es esencial para lograr un dominio del manejo de

Formularios en Excel, la creación de los formularios suele ser sencilla e intuitiva, pero
comprender el funcionamiento de alguno de los eventos es necesario para logar poder
usar los formularios con todas las funcionalidades posibles.
La elección del suceso más adecuado es esencial, para poder ejecutar nuestros
procedimientos una vez iniciado el comportamiento o el suceso seleccionado, para
conseguir que se ponga en marcha el código que lleva asociado. La elección de cada
suceso tiene que ver principalmente con la lógica que tengamos pensado aplicar a
nuestra aplicación, para que el usuario pueda utilizar nuestros controles del formulario
de la manera más intuitiva posible, sin incurrir en dudas o errores de funcionamiento.
Entre los sucesos o eventos más comunes a gran parte de los controles podemos
encontrar los siguientes:
 AfterUpDate: Ocurre tras modificar datos.

 BeforeDragOver: Ocurre cuando está en curso una operación de arrastrar y
desplazar.
 BeforeUpDate: Ocurre antes de modificar datos.
 Change: Ocurre al modificarse la propiedad Value.
 Click: Ocurre cuando el usuario pulsa sobre un control o cuando selecciona
de una forma definitiva un valor entre otros.
 DblClick: Ocurre cuando el usuario hace doble clic.
 DropButtonClick: Ocurre cada vez que una lista desplegable modificable
aparece y desaparece.
 Error: Ocurre cuando un control detecta un error o no puede devolver datos
sobre el error o un programa de llamada.
 Exit: Ocurre inmediatamente antes de que un control pierda el foco en
provecho de otro control de la misma hoja.
 KeyDown: Ocurre cuando el usuario pulsa una tecla.
 KeyUp: Ocurre cuando el usuario suelta una tecla.
 Initialize: Ocurre cuando la hoja o el UserForm se ha cargado, y antes de
que sea visible.
 MouseDown: Ocurre cuando el usuario pulsa un botón del ratón.
 MouseMove: Ocurre cuando el usuario mueve el ratón.
 Terminate: Ocurre después de descargar la hoja o el UserForm.
Página 119 de 175

La manera más rápida de poder acceder al suceso de un control, simplemente

tenemos que hacer doble clic en sobre el control al que queremos asociar el código, a
partir de ese momento se abrirá una venta donde podremos escribir y asociarle una
macro.
Puede ocurrir que el suceso predeterminado no sea el que queremos elegir

para asociar el código, en tal caso, tendremos que hacer uso del desplegable de
sucesos y elegir aquel que nos interese.
Una vez seleccionado nos aparecerá automáticamente el nuevo procedimiento

delimitado en su comienzo y final, para que asociemos el código que nos interese.
Página 120 de 175

Ejemplo 01: Formulario para agregar datos a la hoja.
OBJETIVO: Crear un Userform para que un usuario complete unos datos personales
(Nombre, Edad y Fecha de Nacimiento). Luego que el usuario complete sus datos, al
pulsar un botón, los mismos se volcarán en una tabla de Excel.
Los controles que utilizaremos en el formulario serán:
 Cuadro de texto(Textbox): para que el usuario introduzca los datos
 Etiqueta (Label): para darle el nombre a los Textbox
 Botón de comando (CommandButton): para proceder con la introducción de
datos o cancelar
La secuencia de los pasos que deberemos seguir para realizar el ejercicio será:
1) Crear la tabla en la hoja Excel que contenga una tabla donde se volcarán los
datos del Userform. Para esto creamos un nuevo libro llamado Datos.xls xm?
donde crearemos una tabla con la siguiente estructura.
2) Crearemos un Userform desde el editor de Visual Basic. Para lo cual abriremos

el editor con el método ALT+F11, e insertaremos un nuevo formulario desde la
opción Userform del menú Insertar.
Página 121 de 175

3) El siguiente paso será cambiar el nombre del formulario a través de la

propiedad Name, que podremos encontrar en la ventana de Propiedades, y le
pondremos el nombre de FDatos, luego presionaremos Enter (y este será el
nuevo nombre con el que nos referiremos al Userform desde el editor de Visual
Basic).
4) El nombre del Userform cambió en la Ventana de Proyecto, pero el Userform

mismo sigue mostrando “Userform1” en su barra de su título. Para cambiarlo
vamos a la Ventana Propiedades,
hacemos doble clic en Caption,
escribimos Datos Personales
(encima de Userform1), y luego
Enter. Ahora, la barra de título del
Userform es más apropiada para
nuestro propósito, y para darle
mejor información al usuario.
Página 122 de 175

5) En el siguiente paso agregaremos un Cuadro de Texto para permitir que el

usuario ingrese datos en el Userform para lo cual, agregamos un control
Cuadro de texto, desde el Cuadro de Herramientas. Para lo cual haremos clic
en el control de Cuadro de texto, y luego hacemos clic en el Userform, en la
parte donde queramos ubicarlo.
6) Con el nuevo TextBox seleccionado hacemos doble clic en la Ventana de

Propiedades, propiedad (Name), y escribiremos la palabra FNombre y luego
enter (este es el nombre que le asignamos al objeto para luego referirnos a él
desde el código VBA).
7) A continuación agregaremos un texto para identificar correctamente el tipo de

información que deberemos incorporar en el cuadro de texto anterior.
Página 123 de 175

8) Haremos clic en alguna parte vacía del Userform para seleccionarlo y mostrar
el cuadro de herramientas, para que nos permita agregar el resto de controles
que faltan para completar el formulario. Intenta que el formulario quede como el
que se ve en la siguiente ilustración.
9) Recuerda cambiar el nombre a los controles del formulario siguiendo las

instrucciones de la siguiente tabla de referencias.
CONTROL NAME CAPTION

Cuadro de texto: FNombre
NOMBRE
Cuadro de texto: FApellidos
APELLIDOS
Cuadro de texto: FECHA FFechanacimiento
NACIMIENTO
Etiqueta1 Label1 NOMBRE
Etiqueta2 Label2 APELLIDOS
Etiqueta3 Label3 FECHA NACIMIENTO
Botón de comando1 BGrabar GRABAR
Botón de comando2 BCerrar CERRAR
NOTA IMPORTANTE: Es muy importante que no olvides asignar bien los nombres
(Name) a los Cuadros de texto (Textbox), y a los botones de comando, de no
hacerlo correctamente el procedimiento puede dar lugar a errores por este sencillo
error de designación de los controles.
Página 124 de 175

10) Por último agregaremos el código a los botones de comando para que puedan
adquirir cierta funcionalidad en nuestro formulario.
Empezaremos por el botón Grabar datos, que dando doble clic sobre él, y
pasaremos al editor de código de Vba, con una vista similar a la siguiente:
Entre las instrucciones Private Sub BGrabar_Click() y End Sub copiaremos el

siguiente código.
Private Sub BGrabar_Click()
'Declaración de variables que utilizaremos

Dim Vfila As Long
Dim Vhoja As Worksheet
Set Vhoja = Worksheets(1)

'Encuenta la siguiente fila vacía
Vfila = Vhoja.Cells(Rows.Count, 1).End(xlUp).Offset(1, 0).Row
'Verifica que se ingrese un nombre
If Trim(Me.FNombre.Value) = "" Then
Me.FNombre.SetFocus
MsgBox "Debe ingresar un nombre"
Exit Sub
End If
'Copia los datos del formulario a la hoja

Vhoja.Cells(Vfila, 1).Value = Me.FNombre.Value
Vhoja.Cells(Vfila, 2).Value = Me.FApellidos.Value
Vhoja.Cells(Vfila, 3).Value = Me.FFechanacimiento.Value
'Limpia el formulario
Me.FNombre.Value = ""
Me.FApellidos.Value = ""
Me.FFechanacimiento.Value = ""
Me.FNombre.SetFocus
End Sub
Página 125 de 175

Si queremos volver a ver el formulario tendremos que elegir la opción Objeto del
menú Ver.
Al botón Cerrar agregaremos un procedimiento mucho más breve, que

simplemente se encargará de cerrar el formulario con la instrucción Unload Me.
Recuerda que para agregar el código sobre este botón con un doble clic sobre el
mismo es suficiente.
Private Sub BCerrar_Click()
Unload Me
End Sub
Una vez terminado el formulario podremos probar si funciona correctamente para

lo cual lo primero que tendremos que hacer es volver de nuevo al formulario desde la
vista de código con la instrucción Objeto del menú Ver.
A continuación haremos clic en alguna parte vacía del Formulario para

seleccionarlo, una vez se encuentre seleccionado tendremos que hacer uso de la
instrucción Ejecutar desde diferentes vías, ya será desde la barra de herramientas, o
desde el menú Ejecutar, o como última opción haciendo uso del método abreviado F5.
Página 126 de 175

Ahora podemos comenzar a completar el primer cuadro de texto del formulario,

y escribimos un nombre, por ej. Juan, apellidos López, y por último fecha de
nacimiento 2/5/1975.
Cuando hayamos completado todos los cuadros de texto, haremos clic en el

botón de Grabar datos y los datos se completarán en la Tabla de Excel. Podemos
repetir los pasos anteriores e ir agregando distintos nombres con sus respectivos
datos para comprobar si graba correctamente la información del formulario. Y por
último haremos clic en Cerrar para volver al editor de macros
NOTA: La tecla TAB sirve para moverse entre los distintos controles de un Userform.
Si al presionar TAB el orden del movimiento no es el correcto, es posible cambiarlo:
1. Clic derecho en una parte vacía del Formulario.
2. Elegimos Orden de Tabulación.
3. Seleccionamos el control de la lista y con los botones de Mover Arriba o Mover

Abajo ajustamos el orden.
4. Y haremos clic en Aceptar, para confirmar nuestros cambios.
Página 127 de 175

Ejemplo 02: Formulario para realizar diferentes cálculos con los datos de
la hoja para luego grabarlos en una hoja determinada.
OBJETIVO: Crear un Userform para que un usuario pueda seleccionar un rango de la

hoja de cálculo de tipo numérico, y pueda especificar el tipo cálculo que quiere hacer
con ellos, para luego guardarlo en otra hoja diferente llamada Resultados.
Los controles que utilizaremos en el formulario serán:
 Cuadro de texto(Textbox): para que el usuario introduzca los datos
 Etiqueta (Label): para darle el nombre a los Textbox
 Botón de comando (CommandButton): para proceder al cálculo, grabar y
cerrar el formulario.
 Botón de opción (OptionButton): para seleccionar diferentes tipos de
cálculos.
 Referencia (RefEdit): Es un control que se utilizará para seleccionar datos
de la hoja.
NOTA: En ciertas ocasiones puede que necesitemos algún tipo de control especial
que no tiene por que aparecer de manera inmediata en el cuadro de controles. En tal
caso, tendremos que acudir a la opción Controles adicionales del menú Herramientas.
Y marcar el control que deseemos incorporar en una lista de controles para que
luego pueda aparecer en el cuadro de herramientas.
Página 128 de 175

La secuencia de los pasos que deberemos seguir para realizar el ejercicio será:
1) Abrir un nuevo libro con dos hojas con el nombre de Datos y Resultados, que
contenga las siguientes estructuras que puedes ver en las siguientes
ilustraciones. Puedes guardar el libro con el nombre de Formulario02.xlsm
(libro habilitado para macros).
HOJA
HOJA RESULTADOS
DATOS
2) Lo primero que tendrías que hacer en este ejemplo activar los controles que
pudieras necesitar incorporar en nuestro formulario y que no esté, en el cuadro
de controles de nuestra configuración. En este caso concreto, el control
Referencia (RefEdit) suele ser uno de los casos, y tendrás que activarlo tal y
como lo has visto en la nota anterior.
3) Crearemos un Userform desde el editor de Visual Basic. Para lo cual abriremos

el editor con el método ALT+F11, e insertaremos un nuevo formulario desde la
opción Userform del menú Insertar.
Página 129 de 175

4) El siguiente paso será cambiar el nombre del formulario a través de la

propiedad Name, que podremos encontrar en la ventana de Propiedades, y le
pondremos el nombre de FDiferentescalculos, luego presionaremos Enter (y
este será el nuevo nombre con el que nos referiremos al Userform desde el
editor de Visual Basic).
5) Diseñaremos el formulario con los siguientes controles que simplemente

tendrás que arrastras desde el cuadro de herramientas para que tenga una
apariencia a la de la siguiente ilustración.
Control
Referencia
(RefEdit) Control Botón de
opción (OptionButton)
Cuadro de texto
Botones (Textbox)
de
comando
Etiquetas (Labels)
Página 130 de 175

6) A continuación tendremos que cambiar los nombres de los diferentes controles

que integran el formulario. La siguiente tabla te orientará para asignar
adecuadamente los nombres de cada uno de ellos, modificando la propiedad
Name, así como el texto que tendría que ofrecer, a través de la propiedad
Caption que podemos encontrar en la ventana de propiedades.
La siguiente tabla tiene las diferentes correspondencias entre el control y el

nombre y texto que tiene que ofrecer:
CONTROL NAME CAPTION

Etiqueta (Label): 1 Label1 CALCULAR DATO
Referencia (RefEdit): RefDatos
Botón de opción OptionSuma Suma
(OptionButton): Suma
Botón de opción OptionMax Máximo
(OptionButton): Máximo
Botón de opción OptionPromedio Promedio
(OptionButton): Promedio
Cuadro de texto: que muestra TxtResultado
el resultado
Botón de comando: Aceptar CmdAceptar Aceptar
Botón de comando: Grabar CmdGrabar Grabar
Botón de comando: Cerrar CmdCerrar Cerrar
Etiqueta (Label): 2 Label2 Muestra el resultado en
el cuadro de texto
Etiqueta (Label): 3 Label3 Graba el resultado de
la función en la hoja
resultados
Etiqueta (Label): 4 Label4 Cierra el formulario
NOTA IMPORTANTE: Es muy importante que no olvides asignar bien los nombres
(Name) a los Cuadros de texto (Textbox), a los botones de comando y al resto de
controles, de no hacerlo correctamente el procedimiento puede dar lugar a errores
por este sencillo error de mal designación de los controles.
Página 131 de 175

7) Por último agregaremos el código a los botones de comando para que puedan
adquirir cierta funcionalidad en nuestro formulario.
a. Empezaremos por el botón Aceptar, que al hacer doble clic sobre él, nos
permitirá ir al editor de código de Vba, con una vista similar a la siguiente:
Entre las instrucciones Private Sub CmdAceptar_Click() y End Sub copiaremos el

siguiente código.
Private Sub CmdAceptar_Click()
'Declaración de la variables
Dim Rango As String
Dim Maximo As Long
Dim Suma As Long
Dim Promedio As Single
'Asignación de un rango al control Referencia

Rango = RefDatos.Value
'Asignación de valores a las diferentes variables

Suma = Application.WorksheetFunction.Sum(Range(Rango))
Promedio = Application.WorksheetFunction.Average(Range(Rango))
Maximo = Application.WorksheetFunction.Max(Range(Rango))
'Establecer las condiciones para decidir que resultado se va a ver

'en el cuadro de texto de resultado
If OptionSuma = True Then TxtResultado.Value = Suma
If OptionPromedio = True Then TxtResultado.Value = Promedio
If OptionMax = True Then TxtResultado.Value = Maximo
End Sub
Página 132 de 175

Con este código podremos seleccionar un rango de nuestra hoja de cálculo

para posteriormente seleccionar un tipo de cálculo en base a la selección de los
botones de opción, y que tras pulsar el botón Aceptar podamos ver el resultado de la
operación en un cuadro de texto.
b. El siguiente botón al que asociaremos el siguiente código será al botón

Grabar, en el cual agregaremos el siguiente código:
Private Sub CmdGrabar_Click()
Dim Vfila As Long

Dim Vhoja As Worksheet
Set Vhoja = Worksheets("Resultados")
'Encuenta la siguiente fila vacía

'Graba el resultado del cuadro de texto en la hoja resultados.
If OptionSuma = True Then

Vhoja.Cells(Vfila, 1) = TxtResultado.Value
ElseIf OptionPromedio = True Then
Else
End If
End Sub
Con este código podremos grabar el resultado del cáculo que se encuentra en
el cuadro de texto, en diferentes columnas de la hoja Resultados, en base a la
operación matemática que previamente hayamos seleccionado, con pulsar
simplemente el botón de Grabar.
Página 133 de 175

c. El último botón por programar será al botón Cerrar, en el cual tendremos

que asociar el código más sencillo, haciendo primero doble clic sobre el
botón para poder acceder al editor de programación con el siguiente
código.
Private Sub CmdCerrar_Click()
Unload Me
End Sub
Por último una vez terminado el formulario nos quedará probarlo para
comprobar que todo funciona correctamente, para conseguirlo tendremos que poner
en marcha el formulario con el botón Ejecutar que se encuentra en la barra de
herramientas.
Página 134 de 175

LECCIÓN 10. LAS TABLAS DINÁMICAS
Conceptos previos sobre tablas dinámicas.
Las tablas dinámicas es una de las herramientas más potentes que tiene la hoja de
cálculo. Una tabla dinámica básica nos puede servir, por ejemplo, para generar
rápidamente un resumen de datos en cuestión de segundos.
Este resumen de datos de un conjunto de datos suele realizarse teniendo en

cuenta varios criterios de agrupación, representado como una tabla de doble entrada,
que nos facilita la interpretación de dichos datos. Además es dinámica porque nos
permite ir obteniendo diferentes totales, filtrando datos, cambiando la presentación de
los datos, visualizando o no los datos de origen, etc., haciendo uso de la memoria
cache del ordenador, por eso unos de los pasos esenciales en el momento de crear
una tabla dinámica desde el código será crear un objeto de caché dinámico para poder
realizar las actualizaciones correspondientes con la modificación de los desplegables.
Los conceptos previos que hay que tener en cuenta antes del diseño de
cualquier tabla dinámica es el de campo, que viene dado por el tipo de información de
la base de datos, y el de registro que es cada una de las filas del listado.
La tabla dinámica nos va a realizar un resumen de los datos de tipo recuento o

cálculo de diferentes funciones con respecto a algunas de sus columnas. En este caso
concreto, el resumen o recuento de datos solo se podrá realizar sobre campos que
tengan sus valores repetidos, ya que la repetición del valor es la condición previa
para realizar cualquier resumen. Sobre una columna, que no tenga los datos
duplicados, el resumen no tiene mucho sentido, ya que no nos proporcionaría ningún
tipo de información nueva de la que ya tuviésemos al comienzo, es decir, que nos diría
que tendríamos un registro de cada valor. Para el caso, por ejemplo de nombre y
apellidos, pero eso, ya lo sabríamos, antes de realizar la tabla dinámica. Para este
Página 135 de 175

ejemplo, tiene sentido utilizar columnas dónde los datos estén repetidos como pueda
ser profesión, ciudad, país, empresa o situación laboral.
Sin embargo, las tablas dinámicas se pueden utilizar de diferentes formas, y en

algunos casos, se puede utilizar como motor de cálculo para conseguir un dato
determinado por uno o varios criterios. O en otros casos, nos puede interesar
conseguir los cinco primeros o los últimos de cualquier criterio.
La verdad que el uso de VBA no es el mejor método para la creación de tablas

dinámicas, incluso para un usuario que haya tenido contacto con la programación. El
código que se debe utilizar puede resultar bastante complejo, sin embargo, puede
resultar de mucha utilidad cuando lo que necesitamos es recuperar un datos
determinado por una serie de criterios, y tenemos que hacerlo con cada uno de los
valores del campo que hemos incorporado en un filtro de informe.
Aunque las tablas dinámicas es una de las herramientas más utilizadas por
todos los usuarios de Excel, detallaré los aspectos más relevantes de sus uso, para
que aquellos usuarios que queriéndose iniciar en el mundo de la programación,
todavía no hayan tenido contacto con las mismas.
Tomando como ejemplo de partida el listado de la ilustración anterior, en la cual

aparecían en cada fila nombres de individuos con algunas características específicas
de los mismos, como pudieran ser su retribución salarial, ciudad de residencia, país y
situación laboral actual. Pasaremos a utilizar estos campos como elementos de una
tabla dinámica. Lo más importante antes de adelantar cualquier diseño consiste en
saber qué tipo de información podemos conseguir con la tabla dinámica, y de manera
inmediata podemos adelantar que nos podría indicar cuántos registros se
corresponden de cada una de las profesiones, ciudades, empresas, etc.,.
Veamos cómo podemos crear una tabla dinámica a partir de unos datos que ya
tenemos. Para crear una tabla dinámica, Excel nos proporciona las tablas y gráficos
dinámicos, que se encuentra en la ficha Insertar.
Los pasos a seguir son pinchar en alguna referencia del listado y

posteriormente buscar la ficha de Insertar y la opción Tabla dinámica.
Página 136 de 175

En el momento de pulsar la opción aparecerá una nueva ventana con las

siguientes opciones:
La primera opción hace

referencia a la tabla o rango con del
cual queremos obtener el resumen.
Y el segundo bloque de
opciones nos solicitaría donde
queremos ubicar la tabla dinámica
que suele tener una estructura de
tabla de doble entrada (títulos de fila y
de columna).
Lo más habitual va a ser no

cambiar nada ya que con las opciones predeterminadas vamos a conseguir
seleccionar perfectamente todo el listado si previamente está seleccionado alguno de
sus elementos, y agregar una nueva hoja para la estructura de la tabla dinámica.
Una vez confirmadas las opciones predeterminadas, nos aparecerá una nueva
hoja de cálculo con una vista similar a la de la siguiente ilustración. En donde la zona
más importante la constituye la zona de arrastre de los campos de nuestro listado.
La zona de arrastre de campos está solicitando que depositemos en cada una

de ellas, diferentes campos de nuestro listado.
Página 137 de 175

Existe una serie de criterios generales a tener en cuenta para saber qué tipo de
campos está solicitando en cada zona:
1) Primer criterio: A la zona de filtro del informe, rótulos de columna y de fila se

puede arrastrar cualquier campo que tenga sus valores repetidos, en nuestro
ejemplo, valdrían tanto profesión, ciudad, país, empresa y situación laboral.
2) Segundo criterio: De los campos que tengamos repetidos a fila habrá que
llevar principalmente, aquel que tenga más valores diferentes, ya que la
visualización es más compacta cuando el campo con mayor cantidad de
valores está en fila.
3) Tercer criterio: Debemos incorporar primero los valores con carácter más
general, y posteriormente los de nivel inferior o su detalle, así por ejemplo, si
primero llevamos país como nivel superior, a continuación convendría arrastrar
el de ciudad, para que sea capaz de agrupar en cada país sus ciudades
correspondientes.
4) Por último cuarto criterio: A la zona de valores suele valer cualquier campo,
dependiendo del cálculo que pretendamos realizar y además se puede repetir
el mismo campo sobre esta zona, para conseguir diferente tipo de cálculo.
En nuestro ejemplo, si queremos saber cuántos registros o clientes son de un

determinado país, y además que nos detalle su ciudades, habría que arrastrar los
campos País y Ciudad a rótulos de fila, y para contar los registros, arrastraríamos un
campo de texto, por ejemplo apellidos, a la zona de valores. El resultado sería como el
siguiente:
Página 138 de 175

Si además queremos tener en cuenta en el recuento algún criterio más, como

la profesión del cliente, podríamos arrastrar el campo de profesión a la zona de filtro
del informe, o a rótulos de columnas, que son las zonas que nos quedan libres, la
diferencias principal está en que en filtro del informe no se visualizarán todas las
opciones, y en la de columnas, sí podríamos ver los diferentes valores del campo.
Si quieres realizar más cálculos en la zona de valores, se pueden realizar sin

problemas, y en el ejemplo anterior, podría ser interesante también calcular el
promedio de ingresos de
los clientes de esta base de
datos. Para lo cual,
simplemente tendremos que
arrastrar el campo de sueldos
sobre la zona de valores. Y el
resultado será el siguiente.
El cálculo obtenido no será el promedio seguramente será el sumatorio de

sueldos, ya que de manera predeterminada la tabla dinámica ofrece el sumatorio del
dato, si es de tipo numérico. Si lo que nos interesa es el promedio deberemos obtener
con el menú contextual del botón derecho sobre un cálculo de suma, la opción de
Configuración del campo de valor...
y seleccionar la opción de Promedio.
Página 139 de 175

Crear una tabla dinámica en Excel con VBA.
Como habíamos indicado en la introducción del capítulo el dinamismo de las

tablas dinámicas viene dado por el uso de la memoria cache que utiliza para poder
actualizar sus cálculos. Por este motivo, uno de sus primeros pasos suele ser el crear
un objeto de caché dinámico para describir el área de entrada de los datos. Además
de esto, también tendremos que crear una serie de variables para hacer referencia a la
hoja donde se encuentra los datos, en qué hoja irá la tabla dinámica, hacer referencia
a la propia tabla dinámica con una variable, o si se ampliará el número de registros o
columnas de la hoja donde se seleccionarán los datos para la tabla dinámica. Para
contemplar cada uno de estos supuestos se crearán las siguientes variables que nos
muestra la siguiente ilustración:
El primer paso antes de iniciar el proceso de creación de las tablas dinámicas,

va a ser eliminar las posibles tablas dinámicas existentes en la hoja de destino, que
será donde se incorporará la tabla dinámica que se va a crear, ya que de haber alguna
tabla dinámica previamente en esta hoja, podría dar lugar a un error en el momento de
su creación. Esto lo conseguimos con la siguiente instrucción, que previamente tendrá
que tener la asignación de una referencia a un objeto a través de variable HojaTabla
para que pueda realizarse correctamente:
Página 140 de 175

Una vez eliminadas las posibles tablas dinámicas que estuvieran en la hoja de
destino, pasaremos a asignar referencias de objeto a las diferentes variables
previamente declaradas o valores, según sea el caso, lo cual nos va a permitir
modificar el diseño de la tabla dinámica de manera más eficaz y cómoda.
El siguiente paso importante a realizar una vez asignados los valores y objetos
a las variables es definir un área de entrada y establecer un caché dinámico, que lo
conseguiremos con la siguiente instrucción:
Resulta imprescindible situarse o activar previamente la hoja donde se

encuentran los datos, ya que el argumento SourceData, no contempla la referencia
completa con la hoja, sino solo con las referencias de las celdas, es decir, que el valor
de la propiedad Address es “$A$1:I$151$”, suponiendo que se refiere a la hoja que se
encuentre en ese momento activa, por eso, hay que establecerlo previamente con la
instrucción Sheets(“Datos”).Activate.
Con el método CreatePivotTable, se especifica la ubicación de la tabla y se le

asigna un nombre a la tabla. Si el procedimiento solamente llegase hasta esta
instrucción lo que se conseguiría sería una tabla dinámica en blanco algo extraña que
estaría a la espera de ser diseña mediante código.
Página 141 de 175

Cuando el diseño se hace como usuario desde la vista gráfica, resulta de lo

más sencillo, ya que se trataría simplemente de arrastrar campos desde el listado de
campos hasta sus zonas correspondientes, como pudieran ser el filtro de informe,
etiquetas de fila, etiquetas de columna o valores. Mientras que si lo hacemos por
código tendremos que especificar al procedimiento como vamos a depositar dichos
campos sobre estas zonas.
Cuando se utiliza este cuadro de diálogo de Diseño en la interfaz de usuario para

crear la tabla dinámica, Excel no recalcula la tabla dinámica después de soltar cada
uno de los campos de las tablas sobre las diferentes zonas. Pero por defecto en VBA,
si se calcula la tabla dinámica a medida que se ejecuta cada paso de la construcción
de la tabla dinámica. Esto podría ocasionar que la tabla dinámica se ejecutara hasta
media docena de veces antes de llegar al resultado final. Para evitar dicha
circunstancia y aligerar la ejecución del código, tendremos que desactivar
temporalmente el cálculo de la tabla dinámica, estableciendo el valor de la propiedad
ManualUpdate en Verdadera o True.
Página 142 de 175

A partir de este momento ya se puede pasar a diseñar la tabla dinámica

añadiendo campos a cada una de las zonas de la misma. Con el método .Addfields se
puede especificar uno o más campos para las zonas de Fila, Columna o Página de la
tabla dinámica:
Como puedes ver para aquellos casos que tienen más de un campo en la zona
hacemos uso de una Array para poder contemplarlo.
Una vez que hayamos decidido cuáles van a ser los campos que van a
componer el diseño de nuestra tabla, y en qué zonas de la tabla los estableceremos,
pasaremos a configurarlos para decidir qué tipo de cálculo, en qué posición y valor
seleccionaremos, todo ello lo conseguiremos con propiedades como Orientation,
Position, Function o CurrentPage.
Con el siguiente código de la ilustración anterior, lo que conseguiremos será

establecer el filtro de informe con el campo de Categoría Laboral, para lo cual
modificaremos la propiedad con la constante xlPageField, si lo que quisiéramos hacer
es establecer dicho campo para el área de fila, cambiaríamos dicha propiedad por la
constante xlRowField, y para el de columna por la de xlColumnField. Además dicho
campo aparecerá en primer lugar haciendo uso de la propiedad Position con el valor 1,
si tuviésemos más campos de filtro del informe podríamos modificar la posición en la
que aparecen cambiando el valor de esta propiedad. Por último, podemos conseguir
establecer un valor en el filtro del informe, que en este caso, será el valor “Gerente de
contabilidad” haciendo uso de la propiedad CurrentPage. Para el resto de áreas,
tendremos que ocultar aquellos valores que no nos interese visualizar, haciendo uso
de la propiedad PivotItems(Campo).Visible = False, tal y como podemos ver en la
siguiente ilustración:
Página 143 de 175

Mención especial merece el caso del área de valores, que es aquella zona de la
tabla dinámica donde se realizan los diferentes cálculos de recuento o suma de la
tabla de datos. Para lo cual, lo primero que tendremos que indicar es el campo
utilizado que reflejará los cálculos, justo en el bloque With podemos observar que ha
sido el campo PivotFields(“NIF”) el que se utilizará para el recuento, esta circunstancia
la explicitaremos estableciendo en la propiedad Orientation, el valor o la constante,
xlDataField. A parte de esta propiedad tendremos que modificar otras más para
conseguir establecer el tipo de función que nos interese realizar, si queremos contar
los registros tendremos que establecer el valor o constante de xlCount en la propiedad
Function, si lo que queremos es el promedio, entonces tendremos que hacer uso de la
constante xlAverage, y si lo que nos interesa es sumar el valor, entonces será la
xlSum. Además podremos cambiar el rótulo del campo por el texto que nos interese
modificando la propiedad Name. También podemos añadir varios cálculos a la tabla,
para lo cual tendremos que establecer dos zonas diferentes de código para conseguir
dicho resultado como se puede apreciar en la siguiente ilustración.
Página 144 de 175

Y por último para terminar el procedimiento de creación de la tabla dinámica,

tendremos desactivar el sistema de cálculo manual de la tabla dinámica con el cambio
del valor de True a False para la propiedad ManualUpdate, situarnos en la hoja que se
va a crear la tabla dinámica, y generar un cuadro de mensaje para comprobar que
todos los pasos previos se han realizado correctamente.
Página 145 de 175

Recuperar los campos de una tabla dinámica
Una vez que se ha creado la tabla dinámica puede resultar interesante recuperar
algún tipo de información de la misma, a través del código de VBA. Entre la
información relevante que podríamos recuperar podría estar los campos que son el
origen de la tabla, un cálculo de alguno de los filtros, o incluso un dato de toda una
serie de valores.
Para poder realizar esta tarea lo primero que tendremos que hacer es saber que
clase, colección, propiedad o método tenemos que utilizar para recuperar la
información que necesitamos. Si por ejemplo, lo que necesitamos es el nombre de los
campos de una tabla, en tal caso, tendremos que hacer uso de la colección
PivotFields, que representaría el conjunto de campos que forman parte del origen de
los datos de la tabla dinámica que hemos creado.
En la siguiente ilustración vemos que haciendo uso de una estructura de repetición

podemos recorrer cada uno de los elementos que integran dicha colección:
Página 146 de 175

Tal y como muestra el código, la secuencia del procedimiento consiste en declarar

previamente las variables que vamos a utilizar para guardar un valor, o establecer la
referencia a un objeto, como pueda ser la tabla dinámica. Las variables utilizadas son
i, que nos va permitir utilizarla como contador para recorrer cada uno de los campos, la
variable Total, que establecerá el límite para el número total de campos, y por último,
la variable PivotTabla de tipo PivotTable, que nos va permitir asignar una referencia a
una tabla dinámica con la expresión Set.
Una vez que se han asignado los objetos o los valores a la variables, pasamos a
recorrer los diferentes elementos que integran la colección haciendo uso de una
estructura de repetición del tipo For…Next. Para pasar a visualizar dicha información
en la ventana de inmediato como se puede comprobar en la ilustración anterior.
Recuperar los diferentes valores de un campo.
Un caso parecido al anterior, vendría dado por la necesidad de recuperar cada uno
de los valores de un campo determinado. En tal circunstancia, lo primero que
tendremos que hacer es poder referenciar a través de la colección anterior de
PivotFields, el campo concreto sobre el cual queremos el detalle de todos sus valores.
La manera más cómoda de poder comprobarlo de manera inicial, sería haciendo
referencia de manera literal al campo que nos interesa, lo cual lo podemos hacer
incorporando entre paréntesis el nombre del campo después de la colección de la
siguiente manera PivotFields(“Categoría Laboral”). Y paso siguiente como en el caso
anterior, hacer uso de una estructura de repetición del tipo For … Next, o bien, del tipo,
For Each … Next, para poder conseguir acceder a cada uno de los diferentes valores
de la colección PivotItems.
Para el supuesto, de una estructura de repetición del tipo For… Next, el

procedimiento sería como el de la siguiente ilustración:
Página 147 de 175

Mientras que en el supuesto, de una estructura del tipo For Each… Next, y el
procedimiento sería como el de la siguiente ilustración:
También puede ocurrir que nos interese obtener o acceder a todos los valores
o ítems diferentes de cada uno de los campos, en tal caso, tendremos que recorrer
tanto los diferentes campos, así como los valores de cada uno, para lo cual tendremos
que hacer uso de dos estructuras de repetición.
Página 148 de 175

Obtener un dato determinado de la tabla dinámica.
Cuando la tabla dinámica ya ha sido creada puede ser también bastante útil el
poder recuperar algún dato de la tabla dinámica, en base a una serie de criterios, para
tal circunstancia podemos hacer uso del método GetPivotData, perteneciente a la
clase PivotData. Este método tiene una serie de argumentos que nos van a permitir
recuperar alguno de los datos de la tabla dinámica, en base, a uno o varios criterios.
La sintaxis del método es el siguiente:
expression.GetPivotData(DataField, Field1, Item1, Field2, Item2, … FieldN,

Itemn)
En el cual la expresión se corresponde con el objeto o clase en la cual se

encuentra el método GetPivotData, que este caso, se corresponde con el objeto
PivotData, para a continuación proporcionar los argumentos del método, en donde,
DataField se correspondería con el nombre del campo de que está utilizando para el
cálculo en la tabla dinámica, y los siguientes argumentos con los criterios que
utilizaremos en donde Field1 es el nombre del campo del criterios, e Item1, el valor
correspondiente de ese campo.
En la siguiente ilustración tenemos el ejemplo, de un caso, en donde estamos

recuperando el promedio del salario base del mes de Enero.
Página 149 de 175

Obtener el mismo dato de los diferentes valores de un campo.
Si necesitamos añadir más criterios simplemente tendremos que ampliar los

argumentos con el nombre de otro campo más y su correspondiente valor, en el
siguiente ejemplo obtendremos el promedio del salario base del mes de Enero, de la
categoría laboral, Administrador de pedidos.
En determinadas circunstancias nos podría interesar recuperar el mismo dato, por

ejemplo, como en el caso anterior, el promedio del salario del mes de enero, no de una
categoría determinada, sino de cada una de las diferentes categorías laborales que
tenga nuestra tabla dinámica, en tal caso, los pasos son varios y más complejos que
en los casos anteriores.
El primer paso, sería poder detectar cada uno de los valores o ítems del c ampo
Categoría laboral que se encuentra en el filtro del informe. Esto lo podríamos
conseguir con el siguiente procedimiento que hemos visto anteriormente:
Página 150 de 175

Una vez realizado este paso, el siguiente sería guardar cada uno de los valores
diferentes en una variable para poder utilizarla en el procedimiento
Crear_tabla_dinámica, para que se puedan ir sustituyendo los diferentes valores en el
área del filtro del informe. Para conseguir este objetivo necesitamos una nueva
variable que llamaremos ValorFiltro de tipo String (esta variable también podría ser de
tipo matriz para guardar cada uno de los valores), que nos va permitir guardar cada
uno de los valores del filtro, y además tendremos que poder utilizarlo en el
procedimiento Crear_tabla_dinámica. Para conseguir este objetivo tendremos que
declarar dicha variable como Pública en la cabecera del módulo, para utilizar su valor
desde dos procedimientos distintos, y justo paso siguiente, tendremos que llamar
desde la estructura de repetición al procedimiento Crear_tabla_dinámica, para que
inmediatamente detectemos el valor del filtro ponga en ejecución el procedimiento que
permite crear la tabla. Estas variaciones las podremos observar en la siguiente
ilustración:
Cuando hayamos realizado estos cambios, tendremos que hacer uso del valor de
la variable ValorFiltro, en el procedimiento Crear_tabla_dinámica para que se tenga en
cuenta esta variación en el momento de recuperar el dato del promedio del salario. Es
decir, que primero lo haga con el Administrador de pedidos, y posteriormente con el
resto de categoría laborales. Esta modificación la realizaremos en la línea del código
donde se establece el valor del filtro del informe.
Página 151 de 175

Y por último si queremos visualizar en un cuadro de mensaje el dato recuperado

tras la ejecución de procedimiento Recorrer_Items_Filtro tendremos que incorporar las
siguientes instrucciones al final del procedimiento Crear_tabla_dinámica:
El resultado obtenido tras su ejecución será una serie de ventanas consecutivas

que nos mostrarán el dato que hemos recuperado de la tabla dinámica:
Página 152 de 175

LECCIÓN 11. DEPURACIÓN Y ERRORES
Se pueden distinguir varios tipos de errores en el momento de hacer frente a un

trabajo de programación con el lenguaje VBA:
 Los errores de sintaxis.

 Los errores de compilación.
 Los errores de ejecución.
 Y los errores de lógica.
Errores de sintaxis.
Es común que cuando ejecutamos una macro la misma tenga algún error. Los
errores pueden ser errores de estructuras mal escritas. El editor de macros tiene un
autocontrol que permite corregir estos errores comunes.
Para activar la verificación de sintaxis tendremos que acudir al menú

Herramientas del Editor de Vba, y seleccionar Opciones, y dentro de este cuadro de
diálogo seleccionaremos la ficha Editor y marcar que la casilla Comprobación de
sintexis automática.
Veamos algunos casos:
En este primer ejemplo utilizaremos una macro sencilla cuya única función es
seleccionar la celda A2. Si escribimos correctamente la macro, el editor asigna
automáticamente los colores azules, lo que significa que ha reconocido la estructura
Sub() - End Sub.
Página 153 de 175

Ejemplo:
'Esta macro selecciona la celda A2
Sub Macro()
Range("A2").Select
End Sub
Si las instrucciones están bien escritas el editor convierte automáticamente las

mayúsculas y asigna los colores azules a las estructuras reconocidas y verde a los
comentarios.
Si cometiéramos un error al referirnos al objeto "Range" y por ejemplo

olvidáramos poner la comilla luego del 2, al dar enter a dicha línea aparecería un
mensaje de error y la línea se pintaría automáticamente de rojo, como se ve a
continuación.
Cuando sucede esto aparece un aviso que nos indica el error cometido. Si
vemos que la línea está roja es señal que debemos corregir algo (usualmente falta o
sobra algún carácter). En nuestro caso, hemos olvidado poner la comilla (el objeto
Range siempre requiere que la celda esté entre comillas y luego entre paréntesis).
Veamos otro error de transcripción del código. En ese caso escribimos

erróneamente "Sab", en lugar de "Sub". A pesar que no aparecerá ningún mensaje de
error, vemos que el editor no ha pintado de azul la palabra "Sab".
Al intentar ejecutar esta macro no sucederá nada, porque no se ha respetado la

estructura de Sub() - End Sub con la que debe comenzar y finalizar una macro
respectivamente.
Página 154 de 175

Errores de compilación.
En otras ocasiones, la macro arrastra un error pero el mismo no aparece hasta
ejecutarla. Los errores de compilación se detectan cuando Excel intenta compilar el
código. El código se puede compilar de dos maneras:
 Por iniciativa del programador al seleccionar la opción Compilar del

menú Depuración, en este caso el código se compila completamente.
 O automáticamente, cuando se ejecuta el código, en este caso, sólo se

compilará la primera llamada al procedimiento y los procedimientos no
llamados no se compilarán.
Veamos el caso de la siguiente macro. Al escribirla no ha generado error y

ninguna línea se ha pintado de rojo. Sin embargo, al ejecutarla sí aparece un error.
Sub Macro()
If Range("a2").value = 2 Then
MsgBox "Mal"
End Sub
El error que aparece al ejecutarla es un

aviso que como el de la siguiente ilustración:
Página 155 de 175

Al hacer clic en aceptar la macro queda en "Modo Interrupción", lo que significa

que todo queda en pausa y no se podrán ejecutar nuevas macros (el modo de
interrupción se identifica porque el nombre de la macro queda resaltado en amarillo).
Lo que debemos hacer en esta instancia es salir de modo interrupción desde el mismo
editor, menú Ejecutar >Restablecer.
Luego procedemos a corregir la macro. En este caso el mensaje fue claro: la

estructura estaba incompleta, nos faltó el EndIf.
Una vez que se ha interrumpido la macro, tenemos la opción de ejecutarla paso

a paso (o línea por línea) y así determinar en qué línea está el error. Este lo puedes
hacer posicionándote en la primera fila de la macro y luego presionar la tecla F8..
También puedes hacerlo desde la opción del menú Depuración > Paso a paso por
instrucciones.
Página 156 de 175

De esta forma se irá resaltando con amarillo y ejecutando cada fila, hasta que
llegues a la que produce el error.
Errores de ejecución.
Los errores de ejecución se detectan cuando Excel intenta ejecutar el código.

Una instrucción, una operación, o una llamada a una función no válidas provocará un
error de ejecución. Por ejemplo, al hacer uso de un índice erróneo en una colección o
cuando se busca el nombre de una hoja que no existe en nuestro libro.
En la siguiente ilustración podemos comprobar que con la ejecución del código

buscamos el nombre de la hoja octava cuando nuestro libro tiene una cantidad menor,
en este caso, la aplicación nos ofrece un cuadro mensaje donde nos informa sobre el
tipo de error cometido al establecer un índice fuera del intervalo existente.
Página 157 de 175

Errores de lógica.
Los errores de lógica están relacionados con errores de razonamiento o

de incorrecta traducción de un razonamiento sobre realizar una tarea en el código
VBA. Por ejemplo, un algoritmo de cálculo puede producir un error de resultado si en
traducción a VBA se olvida incluir una operación importante para que dicho resultado
sea correcto.
Estos errores son los más difíciles de localizar, ya que no suponen un error de
ejecución, pero se traducen en un resultado distinto al esperados. En este caso, la
aplicación no nos ofrecerá ninguna ayuda para realizar su corrección. En tales casos
se resulta de gran ayuda hacer uso de los diferentes sistemas de depuración del
código para identificar donde hemos cometido el error de razonamiento que no
percibimos tras la ejecución del código.
Depuración del código
La depuración del código puede realizarse de diferentes formas:
 Ejecutando el programa paso a paso.

 Marcando puntos de detención en instrucciones concretas de VBA.
 Pulsando el botón de comando Depurar cuando ha ocurrido un error en
ejecución.
Los diferentes métodos de depuración permiten en cualquier caso:
 Conocer el valor de variables o expresiones.

 Ejecutar una parte del código.
 Modificar interactivamente el código.
 Ejecutar el código paso a paso.
 Añadir puntos de detención en el código.
Página 158 de 175

La barra de herramientas de Depuración permite acceder directamente a las

distintas herramientas de depuración.
 Modo de diseño: activa o desactiva el modo de diseño.

 Ejecutar: (método abreviado F5)
 Interrumpir (método abreviado Control+Pausa): interrumpe la ejecución
del programa en curso y pasa al modo de Parada.
 Restablecer: borra el contenido de las variables y reinicia el proyecto.
 Alternar punto de interrupción (método abreviado F9): define o suprime
un punto de parada en la línea en curso; el código se ejecuta hasta el
punto de parada, y pasa al modo depuración.
 Paso a paso por instrucciones (método abreviado F8): ejecuta el código
marcando una parada tras cada instrucción del procedimiento en curso
y los procedimientos llamados, para poder continuar con la depuración
por el resto de líneas simplemente tendremos que volver a pulsar la
tecla F8.
 Paso a paso por procedimientos (método abreviado Mayús + F8:
ejecuta el código marcando una parada tras cada instrucción del
procedimiento en curso (las instrucciones de los procedimientos
llamados se ejecutan sin interrupción).
 Paso a paso para salir (método abreviado Control+Mayús+F8): ejecuta
seguidas las líneas restantes del procedimiento en curso.
 Ejecutar hasta el cursor (método abreviado Control+F8): ejecuta las
instrucciones hasta donde se encuentre el cursor y ahí se para para
poder seguir paso a paso con F8.
Ventana Locales
Muestra los valores de variables locales del procedimiento
Página 159 de 175

Ventana Inmediato
Muestra la ventana de ejecución y permite ejecutar interactivamente una
instrucción, también podemos activarla haciendo uso del método abreviado Control+G.
Con el objeto Debug.Print se puede la actualización del código enviando los

datos de salida a la ventana de inmediato en el momento de la ejecución.
Gestión de errores en VBA.
Cuando se produce un error, VBA genera en ocasiona un error de ejeucación

que interrumpe la aplicación. Para evitar esto, es posible tratar el error mediante las
instrucciones y funciones siguientes:
 On Error
Indica una secuencia de instrucciones a ejecutar en caso de error.
Sintaxis 1:
On Error Goto <línea>
Con esta sintaxis se activa la rutina de gestión de error que empieza en el lugar
especificado por el argumento línea. El argumento línea deber ser una línea o un
número de línea. La línea debe pertenecer al mismo procedimiento que la instrucción
One Error. Si el argumento línea es un número de línea, éste tiene que ser
obligatoriamente el primer carácter no vacío de la línea.
Página 160 de 175

Sintaxis de la rutina gestión de error:
Línea:
<Instrucciones>
Resume
La instrucción Resume permite retomar la ejecución del código cuando la

rutina de gestión de error termina, es decir, una vez resuelto el problema presentado
por el error.
Se puede usar tres sintaxis diferentes para Resume:
Resume 0: Retoma la ejecución del código donde se produjo el error.
Resume Next: Sigue a partir de la instrucción que sigue inmediatamente a la

que ha generado el error.
Resume Línea: Sigue en el lugar especificado por el argumento Línea.
Para impedir la ejecución del código de gestión de error en ausencia de

errores, pon una instrucción Exit Sub, Exit Function o Exit Property inmediantamente
antes de la rutina de gestión de error.
Sintaxis 2:
On Error Resume Next
Especifica que en caso de error de ejecución, la ejecución debe proseguir.
Sintaxis 3:
On Error GoTo 0
Permite interrumpir la gestión de errores cuando el procedimiento está aún en curso

de ejecución.
Página 161 de 175

El siguiente código es un ejemplo de control de errores, ante la selección de

una hoja que no existe:
Página 162 de 175

LECCIÓN 12. COMPLEMENTOS (ADD INS)
Una vez que tengamos nuestras propias macros, es

posible "empaquetarlas" bajo la forma de un Complemento,
también conocidos como Add-in, de tal forma que se pueden
distribuir a otros usuarios para que lo instalen y tengan acceso a
las macros.
En general, estos complementos no son más que

nuevas funcionalidades y opciones para Excel, realizadas con
macros.
Si quieres instalar nuevos complementos, deberás

hacerlo desde la opción Complementos que podemos encontrar
en las Opciones predeterminadas de la aplicación que se
encuentra en el botón Archivo. Cuando hayas seleccionado esta
opción nos aparecer un cuadro de diálogo que con varios
enlaces en la zona de la izquierda que nos permitirá acceder a
la sección de Complementos.
Con el botón Ir podrás abrir el cuadro de complementos y poder agregar

nuevos complementos a nuestra aplicación para poder ponerlos en uso.
Página 163 de 175

El cuadro que se abrirá será similar al siguiente, en donde podrás activar los
complementos que nos e encuentren con la casilla de verificación para poder hacer
uso de los mismos:
A la izquierda se ve la lista de complementos disponibles siendo posible

activarlos o desactivarlos (seleccionando o deseleccionando la casilla a la izquierda de
su nombre).
Cuando queremos instalar nuevos complementos debemos hacerlo con el

botón Examinar. Dicho botón nos permitirá buscar el directorio donde se encuentra el
complemento que deseamos instalar. La extensión de los archivos de complementos
es XLA.
Página 164 de 175

La utilidad de un complemento es que podemos crear nuestras macros y luego

guardarlas como complemento. De esta forma, dichas macros estarán disponibles en
todas las hojas Excel que abramos, dado que el complemento se cargará
automáticamente (Excel carga automáticamente todos los complementos que estén
seleccionados al abrirse).
El proceso de creación de un complemento es sencillo:
1. Primero debes crear tus macros normalmente, desde el editor de macros de

VBA en donde podremos incorporar el código que necesitemos. En el siguiente
ejemplo, tenemos una función que es capaz de contar los espacios que
contiene una celda, ya que con las funciones habituales no podemos realizar
esta operación.
2. Una vez que la tengamos diseñada deberemos guardar dicho archivo Excel
desde el menú Archivo > Guardar como...y en la parte inferior deberemos
seleccionar el desplegable que tiene el título de tipo, para elegir en dicha lista
la opción Complemento de Microsoft Excel.
Página 165 de 175

3. Una vez seleccionado el tipo de archivo deberás elegir un nombre para tu

complemento y guardarlo normalmente. Dicho archivo se guardará
automáticamente con la extensión XLA, en una ubicación determinada para
guardar dichos complementos, que se encuentra en la siguiente ubicación de
directorios AppData\Roaming\Microsoft\Complementos. Aunque si lo que tienes
pensado es proporcionar este complemento a otro usuario podrás guardarlo en
la ubicación que mejor te convenga para luego localizarlo.
4. Para instalar el complemento debes hacerlo desde el menú Herramientas >

Complementos y luego la opción Examinar, tal como te señalábamos al
comienzo. Deberás buscar el directorio donde guardaste el archivo XLA y
seleccionarlo. De este modo, cada vez que abras el Excel, el complemento
estará activo.
5. Una vez seleccionado el

complemento veremos que nos
aparece en la lista de complementos
del menú ir, y además ya aparece
activado para poder hacer uso de él.
Página 166 de 175

6. Al ser una función podremos localizarla en cualquier opción que nos dé acceso
a las funciones de la hoja de cálculo como pueda ser el botón de funciones de
la barra de fórmulas, para luego seleccionar la categoría de funciones
Definidas por el usuario.
Si en lugar de ser una función hubiese sido un procedimiento tendremos que

buscar la opción de asociar nuestro procedimiento a un botón de comando, en una
nueva ficha, por ejemplo. Para crear una nueva ficha recuerda que tienes que acudir a
las Opciones de Excel anterior, y a la sección de Personalizar cinta de opciones.
Página 167 de 175

Una vez que ya este creada la ficha simplemente tendremos que cambiar la
selección de la lista desplegable de comandos disponibles, para elegir la opción de
Macros, donde podremos encontrar el nombre de la macro o procedimiento que
hemos instalado, en este caso, el nombre se corresponderá con el del procedimiento y
no con el del complemento instalado, es decir, que este caso se llamara
Separarnombreyapellidos.
Cuando ya la tengamos localizada la incorporaremos a nuestra ficha con el

botón agregar que se encuentra en el medio del cuadro de diálogo.
De esta manera, podremos ampliar las funcionalidades de nuestra hoja con

una nueva ficha que puede integrar aquellas tareas que realizamos de manera más
habitual:
Página 168 de 175

LECCIÓN 13. SEGURIDAD DE MACROS
Las opciones de niveles de seguridad de macros las encontramos en la

sección Centro de confianza de las Opciones predeterminadas de Excel tal como
podemos ver en la siguiente ilustración:
Al presionar el botón de Configuración del Centro de confianza aparece una

nueva ventana en la cual debemos elegir de Configuración de macros (parte
izquierda) y luego seleccionar la opción Deshabilitar todas las macros con notificación.
Esto hará que cada vez que se abra un libro con macros, aparezca un m ensaje
notificando de las mismas y dando la opción de habilitarlas o deshabilitarlas.
Página 169 de 175

No mostrar el mensaje de "Habilitar Macros"
Otra opción muy interesante que ofrece Excel 2010 es la de generar "Carpetas
de confianza", de tal modo que para cualquier archivo que esté guardado en esas
carpetas, se habilitarán automáticamente las macros (nos evitaremos el molesto
mensaje de "Habilitar macros"). Para configurar esto vamos al Centro de Confianza,
seleccionamos Ubicaciones de confianza y luego indicamos una carpeta desde el
botón de Agregar nueva ubicación...
Macros privadas y proteger el código
Recuerda que puedes visualizar las macros de tu libro presionando ALT+F8.

Verás que se abre un cuadro como el siguiente.
Página 170 de 175

En el mismo figuran los nombres de las macros creadas, así que solo tienes
que seleccionar la macro y luego hacer clic en el botón de Ejecutar.
Si deseas ocultar las macros del libro en dicho cuadro puedes hac erlo
utilizando la instrucción Private cuando escribas tu macro. Debes utilizar dicha
instrucción delante de la palabra Sub. De este modo solo ocultarás la macro en
cuestión. Ejemplo:
Private Sub MiMacro()

'Esta macro no aparecerá en la lista de macros
'Código de tu macro aquí
End Sub
Si tienes muchas macros en el módulo y quieres ocultarlas todas, en lugar de

escribir la palabra Private en cada una de ellas, puedes colocar la siguiente instrucción
al comienzo de tu módulo:
OptionPrivate Module
De esta forma todas las macros de dicho módulo quedarán ocultas.
Pero la opción más fiable para evitar que puedan verse los procedimientos que
hemos diseñados es protegerlos con una contraseña, y esto lo podemos hacer
accediendo al editor de VBA, y seleccionar el proyecto que queremos proteger desde
la ventana proyectos, y seleccionar la opción Propiedades de VBAProject…
Página 171 de 175

Una vez seleccionada esta opción aparecerá un cuadro de diálogo con dos
fichas General y Protección. En la primera ficha podremos cambiar el nombre de
nuestro proyecto, así como detallar una breve descripción del mismo.
Pero será en la segunda ficha de Protección donde se podrá incorporar una

contraseña para impedir la visualización de nuestros procedimientos y funciones
incorporadas al proyecto.
Para que la contraseña surta efecto tendremos que guardar el fichero, y

cerrarlo y abrirlo de nuevo, para comprobar que la protección tiene efecto en el
momento de acceder a la ventana de código e intentamos abrir alguno de los módulos
de nuestro proyecto.
Página 172 de 175

Acelerar el código
En la medida que la cantidad de código contenido en las macros se

incrementa, es posible que la velocidad de ejecución de las mismas disminuya. Sin
embargo, existen algunas recomendaciones para mantener la velocidad de ejecución
de las macros:
1. Evitar actualización de pantalla
Cuando ejecutamos la macro, podemos ir viendo en la pantalla todo lo que

sucede, sobre todo en el caso de macros que activan o desactivan hojas, seleccionan
rangos, etc. Esto hace que la macro se ejecute un poco más lento. Si solo queremos
ver el resultado final y ganar velocidad, debemos utilizar la instrucción
Application.ScreenUpdating=False.
En general se recomienda incluir siempre esta línea al comienzo de cada

macro, por ejemplo:
Sub SuperMacro()
Application.ScreenUpdating=False
'El código de la macro aquí
Application.ScreenUpdating=True
End Sub
Al final, volvemos a dejarla en True, que es como debe quedar por defecto.
2. Prevenir cálculos mientras se ejecuta el código
Si nuestra macro realiza cambios en distintas celdas, en cada cambio realizado se

recalculará la hoja. Si el libro tuviera muchas fórmulas y la macro cambiara muchas
celdas, esto haría que se ejecute muy lento, porque se estaría recalculando la hoja
repetidas veces. Lo recomendable es deshabilitar el cálculo, ejecutar la macro y luego
volver a activar el modo de cálculo automático. Por ejemplo:
Sub SuperMacro()
Application.Calculation = xlCalculationManual
'El código de la macro aquí
Application.Calculation = xlCalculationAutomatic
End Sub
Página 173 de 175

3. Utilizar la instrucción With
Cuando tenemos que definir muchas propiedades de un único objeto, no es

necesario hacer mención al objeto cada vez, porque esto le quita velocidad de
ejecución a la macro. Para ganar velocidad y mantener el código más simple, conviene
hacer mención al objeto una única con la instrucción With y luego definir sus
propiedades, por ejemplo:
Sub CambiarFormatoRango()
With Range("A1")
.Value = 10
.Font.Bold = True
.Interior.ColorIndex = 5
End With
End Sub
Esto se explica mejor en la 2º parte del curso, capítulo Estructuras.
4. Insertar fórmulas relativas
Si queremos insertar fórmulas en celdas mediante macros, existe una forma

más rápido de hacerlo que con Copiar y pegar. Por ejemplo:
Sub CopiarFormula()
Range("A1:A10").FormulaR1C1 = "=SUM(RC[1]:RC[5])"
End Sub
Para saber cómo obtener la fórmula podemos hacer lo siguiente:
4.1 Insertamos la fórmula en la celda

4.2 Vamos al menú Herramientas > Macros > Grabar nueva macro
4.3 Desde la celda con la fórmula presionamos la tecla F2 y luego Enter.
4.4 Revisamos la macro grabada para obtener el código
Página 174 de 175

5. Evitar el uso de Copiar, Pegar y Seleccionar
Cuando se utiliza la grabadora de macros, es común que se genere más

código del necesario y esto hace que funcione un poco más lento. Las intrucciones
que suelen ser redundantes son Select, Selection.Copy y Paste. Supongamos que
queremos copiar un rango en otro rango. Si utilizamos la grabadora el código será el
siguiente:
Sub CopiaRango()
Range("C10:C12").Select
Selection.Copy
Range("E10").Select
ActiveSheet.Paste
End Sub
Sin embargo hay una forma más directa donde evitamos el Select, el Selection
y el Paste:
Sub CopiaRango()
Range("C10:C12").Copy Range("E10")
End SuB
Página 175 de 175

Manual de Macros

Cargado por

Información del documento

Descripción:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Descripción:

Copyright:

Formatos disponibles

Manual de Macros

Cargado por

Descripción:

Copyright:

Formatos disponibles

MANUAL DE VBA PARA EXCEL 2010

MANUAL DE VBA PARA

AUTOR DEL MANUAL

Miguel Ángel de la Torre Hernández

C/ Marqués de Ahumada, 7-2ª planta (28028), Madrid

Tlf:91 724 92 09/35

FORMADOR DEL CURSO

Miguel Ángel de la Torre Hernández

Este manual, así como las prácticas proporcionadas para la

Variable de tipo Booleana ....................................................................................... 59

LECCIÓN 10. LAS TABLAS DINÁMICAS.................................................................... 135

LECCIÓN 1. LA GRABACIÓN DE MACROS

La Hoja de Cálculo Excel es una de las herramientas más poderosas para el

Sin embargo, si realmente quieres sacarle el mayor partido a Excel, deberás

Pero, ¿qué es una Macro? Es un conjunto de instrucciones de código

Con las macros lo que se pretende es automatizar varias tareas y fusionarlas en

Diferentes utilidades de una macro

2. Creación de funciones a medida

3. Creación de nuevos comandos, complementos y menús

4. Creación de aplicaciones a medida

Crear una macro automáticamente

La forma más fácil e intuitiva de crear macros es crearlas mediante el grabador de

Otra posibilidad para poder poner en marcha la grabadora de macros, la puedes

Si no tienes visible la ficha Programador, puedes activarla en la versión de Excel

1) Presiona el botón de Archivo (botón verde en la parte superior izquierda

2) En la parte inferior del menú que se despliega, presiona el botón

3) En la lista de Personalizar cinta de opciones marca la casilla de

Además de esta opción de grabación en el menú de Macros podemos encontrar

 Ver Macros... - Donde accedemos a un listado de las macros creadas en ese

Al seleccionar la opción Grabar

 Nombre de la macro: donde podemos dar un nombre a la macro, no está

Para comenzar la grabación de la macro pulsamos el botón Aceptar y a

Ejecutar una macro

Antes de dar la orden de ejecución de la macro, dependiendo del tipo de macro

Por ejemplo, si hemos creado una macro que

Desde esta ventana podemos tanto Ejecutar la macro

Existe otra posibilidad además de la anteriormente mostrada para poder ejecutar

En el primer caso de asociar una macro a algún botón de la cinta de opciones lo

1) Presiona el botón de Archivo (botón verde en la parte superior

A partir de ese momento en la cinta de opciones aparecerá una nueva ficha en la

NOTA: La ficha la puedes cambiar de posición en la cinta de opciones simplemente

Si además queremos cambiar la imagen y texto del botón, deberemos seleccionar

La otra posibilidad de incrustar un botón en nuestra hoja de cálculo para poder

1) Utilizar cualquier forma de las que nos proporciona la ficha Insertar

Seleccionada la opción aparecerá una ventana donde podremos seleccionar

2) La otra posibilidad para asociar la macro a un botón dentro de la hoja la

LECCIÓN 2. ASPECTOS BÁSICOS DEL LENGUAJE VBA

El lenguaje de programación que utiliza Excel está basado en Visual Basic, un

Los métodos característicos de la clase persona sería, hablar, andar, escribir,

Un ejemplo sencillo de algunos objetos, propiedades y métodos en Excel son los

 Objetos: Prácticamente cada cosa que veas en Excel es un objeto.

 Propiedades: Las propiedades son las características de los objetos.

Ejemplos de Propiedades VBA (nombre original y su significado en español)

Ejemplos de Métodos VBA (nombre original y su significado en español)

El código VBA asociado a un libro se agrupa en un proyecto con varias carpetas:

 La carpeta Microsoft Excel Objetos: Contiene un módulo de clase

La programación que realicemos en Excel, sean procedimientos o funciones va a

La diferencia fundamental entre funciones y procedimientos, es que las

En la programación orientada a objetos existe también un concepto muy

El entorno del editor de Visual Basic

1) Desde la ficha Programador pinchando en el botón Visual Basic