Capítulo 1

Introdução ao VBA
....................................................... 5

Introdução
..................................................................

Conceitos básicos de programação

.................................................. 6

Ambientes de programação
..............................................................
9

VBA (Visual Basic for Applications)

................................................. 10
Considerações finais
..................................................................
13

Capítulo 2

Comandos básicos do VBA

......................................... 15

Introdução
..................................................................
16

Editor do VBA
..................................................................
16

Funções e sub-rotinas
..................................................................
20

Variáveis
..................................................................

Constantes
..................................................................

As funções InputBox e MsgBox

....................................................... 37

Escopo das variáveis, constantes e

rotinas ................................... 42

Escopo de sub-rotinas e funções

.................................................... 44
Considerações finais
..................................................................
45

Capítulo 3

Estruturas de controle e repetição no

VBA ...............47

Introdução
..................................................................

Estruturas de controle
..................................................................

Coleções de objetos e objetos

......................................................... 60
Referência implícita
..................................................................

Considerações finais
..................................................................
67

Capítulo 4

VBA no Excel
..............................................................69

Introdução
..................................................................

Planilhas eletrônicas e o Excel

......................................................... 70
VBA no Excel
..................................................................
72

Exemplos de utilização
..................................................................
79

Considerações finais
..................................................................
91

Capítulo 5

VBA no Access
...........................................................93

Introdução
..................................................................

Definições sobre SGBD e BD

........................................................... 94

A linguagem SQL
..................................................................
97

0 SGBD Microsoft Access

.............................................................
103

Considerações finais
..................................................................
126
Introdução

Este livro tem como objetivo transmitir

ao leitor conceitos de VBA, com
exemplos reais, que possibilitem uma
melhor visualização do seu
funcionamento. Os exemplos possuem os
códigos-fonte completos, ou os passos
detalhados de como implementá-los.

Veremos a aplicação de macros em

dois aplicativos Microsoft Office: Excel
e Access. Teremos exemplos reais para
cada caso, o que facilitará o
entendimento do leitor.

Neste capítulo, veremos os conceitos

básicos de programação e de linguagens
de programação, essenciais para o leitor
que ainda não tem esta base teórica.
Veremos ainda breves descrições das
linguagens Basic e Visual Basic (VB) e,
em seguida, a definição e um breve
histórico a respeito de VBA.

Conceitos básicos de programação

Esta seção destina-se ao leitor que

nunca desenvolveu programas para
computadores, ou, ainda, que tenha
desenvolvido, mas não tem
conhecimento de todos os conceitos
básicos que se deve ter para ser um bom
programador.

Como vamos começar a entender o que

é o básico em programação, é preciso,
primeiro, conhecer alguns conceitos a
ela relacionados. Assim, a seguir,
daremos início a explanações um tanto
técnicas, porém, imprescindíveis para a
aprendizagem.

• Tecnologia: dentro do campo que nos

interessa, a tecnologia tem o objetivo
de eliminar as tarefas repetitivas,
facilitando o trabalho e tornando-o
mais eficiente, a fim de aumentar a
produtividade e os benefícios da
empresa;

• Programação: uma das etapas mais

importantes do ciclo de vida de um
projeto (detalharemos adiante o que é
este termo), e requer um método de
trabalho. A programação é o resultado
de tal trabalho. Nos capítulos
seguintes, "programaremos" com VBA
para automatizar certas tarefas.
Programação é o instrumento que
permite a execução das tarefas
automatizadas de um sistema de
informática;

• Programa: conjunto de instruções

interpretadas pelo computador,
permitindo realizar um trabalho ou
resolver um problema. Um programa
deve ser finito, ou seja, deve ter um
início e um fim. Além disso, precisa
ser bem confeccionado para que, ao se
introduzir um dado, obtenha-se um
resultado e, repetindo-se o processo
com o mesmo dado, obtenha-se
novamente a mesma solução;

• Metodologia da programação:
entende-se como metodologia da
programação o conjunto de normas,
métodos e anotações que nos indica a
forma de programar. Cada linguagem
de programação segue uma
metodologia diferente;
• Linguagem de programação: conjunto
de regras semânticas e sintáticas que
os programadores usam para a
codificação de instruções de um
programa ou algoritmo de
programação. Existem várias
linguagens de programação, como, por
exemplo: Basic, Java, Pascal, C, C++,
Visual Basic, entre outras. A linguagem
VBA que utilizaremos é uma "variante"
do Visual Basic. Daremos uma melhor
definição mais adiante, ainda neste
capítulo;

• Ambiente de programação ou
ambiente de desenvolvimento: é o
conjunto de ferramentas utilizadas para
a elaboração de um programa;
 • Recursos: conjunto de componentes
de hardware utilizados para a
elaboração de um programa (CPU,
disco rígido etc.).

Conhecidos os conceitos básicos

necessários para a aprendizagem da
programação, podemos estudar os
diferentes tipos de linguagens de
programação.

Algoritmos e linguagem de programação

Alguns pesquisadores afirmam que

programas são formulações concretas de
algoritmos abstratos, baseados em
representações e estruturas específicas
de dados.
 De forma mais simples, um algoritmo
pode ser definido como um conjunto de
procedimentos lógicos, bem definidos,
que descreve a solução de um problema.
Podemos pensar em algoritmo como uma
receita, uma seqüência de instruções que
dão cabo de uma meta específica. Estas
tarefas não podem ser redundantes nem
subjetivas, mas claras e precisas.

Ao pensarmos na solução de um
problema, encontramos ações
imperativas expressas por comandos. Os
algoritmos não são aplicados apenas ao
mundo da Informática; pelo contrário,
usamos - até sem perceber - algoritmos
em todos os momentos de nossa vida.
Trocar o pneu de um carro é claramente
um algoritmo:

• pegue o pneu estepe;

• pegue as ferramentas para trocar o

pneu (macaco e chave de roda);

• desparafuse a roda do carro;

• coloque o macaco no carro;

• termine de desparafusar o pneu do

carro;

• tire a roda do carro;

• coloque a outra roda;

 • parafuse a roda no carro;

• retire o macaco;

• guarde as ferramentas e o pneu com

problema no carro.

Veja que resolvemos esse algoritmo em

dez passos. Entretanto, se pedirmos para
que N pessoas resolvam o mesmo
problema, provavelmente teremos N
respostas diferentes. Isso ocorre, pois,
normalmente, visualizamos problemas a
partir de ângulos diferentes, com maior
ou menor riqueza de detalhes.

Algoritmo é a forma pela qual

descrevemos as soluções para os
problemas do nosso cotidiano,
esperando que elas sejam
implementadas utilizando recursos do
mundo computacional. Como este possui
severas limitações em relação ao mundo
real, é importante que sejam impostas
algumas regras básicas quanto à forma
de solucionar os problemas, para que
possamos utilizar os recursos de
hardware e software disponíveis. Os
algoritmos, apesar de servirem para
representar soluções para qualquer
problema, no caso do processamento de
dados devem seguir as regras básicas de
programação, para que sejam
compatíveis com as ditas linguagens de
programação.
Linguagem de programação

Linguagem de programação é uma

maneira de se comunicar que segue uma
forma e uma estrutura com significado
interpretável.

Portanto, linguagem de programação é

um conjunto finito de palavras,
comandos e instruções escritos com o
objetivo de orientar a realização de uma
tarefa pelo computador. Logicamente, a
linguagem que nós utilizamos em nosso
cotidiano é diferente da linguagem
utilizada pela máquina. Esta trabalha
somente com códigos numéricos
(linguagem de máquina), baseados nos
números zero e um (sistema binário),
que representam impulsos elétricos,
ausente e presente. Assim, qualquer
linguagem de programação deve se
situar en tre dois extremos: o da
linguagem natural do homem (muito
clara, porém, lenta) e o da linguagem de
máquina (muito rápida, porém,
complexa). Este é o conceito de nível de
linguagem: alto nível para as mais
próximas da linguagem humana; baixo
nível para as mais semelhantes à
linguagem de máquina.

Existem várias linguagens de

programação, cada uma com
características próprias, como, por
exemplo: Pascal, Clipper, Cobol, C,
Visual Basic, Delphi, Java, NET,
Python, Perl, PHP, entre outras.

Programas de computadores nada mais

são do que algoritmos escritos em uma
determinada linguagem de programação
(interpretadas ou compiladas) e
executados por uma máquina, no caso
um computador. A tradução das
instruções de uma linguagem de alto
nível para a linguagem de máquina pode
ser feita de duas maneiras diferentes:

• por meio de um interpretador, que

traduz os comandos "passo a passo", e
na medida da necessidade;

• por meio de um compilador, que

 primeiro traduz todos os comandos
encontrados e armazena a tradução na
memória como um conjunto de
instruções na linguagem de máquina, e
só depois executa todas estas
instruções.

A principal diferença entre um

interpretador e um compilador é que o
segundo possibilita armazenar as
instruções na linguagem de máquina
diretamente na forma de um arquivo de
programa executável.

Ambientes de programação

Ao se programar um software
utilizando alguma linguagem de
programação, é muito comum o uso de
um conjunto de funções já disponíveis,
que tem por finalidade auxiliar a
programação, reproduzindo as funções
mais comuns da linguagem em questão.
Ou seja, cada linguagem contém um
número finito de funções disponíveis,
que podem ser utilizadas como forma de
facilitar o desenvolvimento do software.
Entretanto, o número de funções
disponíveis para cada linguagem de
programação é extremamente grande,
tornando-se difícil lembrar todas as
funções disponíveis.

A partir destas necessidades, surgiu o

conceito de ambiente de programação,
que consiste basicamente em um editor
de texto com recursos adicionais, que
facilitam bastante o trabalho do
programador. Se não tivéssemos
disponível um ambiente de
programação, teríamos de lembrar a
sintaxe de todos os comandos, dos
métodos e propriedades dos objetos,
entre outras questões. Convenhamos que
isso é praticamente impossível, visto
que cada linguagem de programação
possui diversos métodos, atributos e
objetos para serem acessados.

Assim, o ambiente de desenvolvimento

fornece uma série de facilidades
enquanto estamos criando nosso código.
Por exemplo, ao digitar o nome de um
objeto e um ponto será aberta,
automaticamente, uma lista com todos os
métodos e propriedades deste objeto.
Ao invés de lembrar o nome dos
métodos/propriedades, basta selecioná-
los em uma lista. Se selecionarmos um
método, ao digitarmos o parêntese de
abertura, uma lista com os argumentos
esperados pelo método será exibida,
bem como o tipo (texto, número, data
etc.) de cada argumento. Se digitarmos
um comando incorretamente, o ambiente
de desenvolvimento emitirá uma
mensagem e colocará esse comando em
destaque. Estas são apenas algumas das
facilidades fornecidas por ambientes de
desenvolvimento.

Vamos conhecer maiores detalhes

sobre o ambiente de programação para
VBA no próximo capítulo.

VBA (Visual Basic for Applications)

Trata-se de uma estrutura de

programação baseada na linguagem
Basic. Foi concebida para funcionar em
conjunto com diferentes aplicações
(especialmente da Microsoft, como o
MS-Office) e suporta programação com
eventos e GUI (interface gráfica).

Foi inicialmente integrada com o Excel

5, em 1994, e a partir do Office 97 o
VBA passou a estar completamente
integrado no MS-Office (Word, Excel,
Access e PowerPoint). Atualmente, o
VBA é um produto independente.
Qualquer companhia pode adotá-lo e
incorporálo às suas aplicações.

Uma passagem rápida pelo Visual Basic

A versão moderna da linguagem Basic

para o sistema operacional Windows foi
desenvolvida pela Microsoft com
capacidade de criação rápida e fácil de
programas com ambiente gráfico MS-
Windows. A linguagem tem algumas
características específicas para
desenvolver rápida e facilmente a parte
"visual" (GUI - Graphical User
Interface, ou Interface Gráfica com o
usuário) de um programa.
 0 Visual Basic não é orientado a
objetos, como muitos pensam. Ele
implementa o modelo orientado a
eventos. Muitas das funções escritas
respondem a eventos do usuário, como,
por exemplo, o clique em um botão de
um formulário. Como resposta, é
chamada uma função com uma seqüência
de instruções em Visual Basic.

Usando o Visual Basic para

desenvolver aplicações para o
MSOffice, utilizamos um mecanismo
chamado macro. Veremos, a seguir, o
que é e como podemos criar uma macro.

Macro
 Uma macro é um pequeno programa
que contém uma lista de instruções. Por
ser um repositório de operações, uma
macro pode executar um conjunto de
tarefas mediante um único procedimento
que pode ser invocado rapidamente.

As instruções que formam o corpo da

macro são escritas num código próprio,
para que o computador possa
compreendê-las. Esta linguagem é
designada por VBA,
VisuaiBasicforAppiications.

Para criar macros, existem duas

possibilidades:

• por meio do gravador de macros;

 • utilizando o editor e programando em
VisuaiBasic forAppiications (veremos
esta possibilidade nos capítulos
seguintes).

Vamos ver o que fazer para gravar uma

macro. Neste exemplo, utilizaremos o
Excel, porém, o procedimento é
semelhante em outros aplicativos. Os
seguintes passos têm de ser obedecidos:

1. Vá ao menu Ferramentas, e siga as

opções Macros e Gravar nova macro. 0
Excel exibirá uma caixa de diálogo
semelhante à da figura a seguir:
 Figura 1.1: Caixa de diálogo para a
gravação de macros.

2. 0 nome da macro será constituído

por um conjunto de caracteres que
identificará a macro e a sua
funcionalidade.
 3. A tecla de atalho é composta por
uma combinação que poderá ser
utilizada para executar uma macro.

4. Opte por armazenar a macro em uma

das seguintes alternativas: Esta pasta de
trabalho, Nova pasta de trabalho ou
Pasta de trabalho pessoal de macros,
sendo que cada uma corresponde a
macros de âmbitos diferentes. Assim,
armazene a macro na opção Esta pasta
de trabalho, para que ela esteja ativa
sempre que o documento estiver aberto,
e para que ela esteja armazenada no
próprio arquivo, não correndo o risco
de ficar armazenada nas macros do
Excel.
 5. No campo Descrição introduza um
comentário à função; este poderá ser
importante para que não esqueça os
respectivos objetivo e funcionalidade.
Por padrão, é inserido o nome de quem
criou e a data.

6. Clique em OK para iniciar a

gravação da macro. Neste momento,
será exibida uma barra de ferramentas
com um botão para parar a gravação, e o
ícone do mouse será transformado,
indicando assim o estado de gravação.

7. Na barra de ferramentas que

aparecer, existem dois botões: Parar a
gravação e Referência relativa, sendo
que o botão Parar a gravação finaliza a
gravação da macro e o botão de
Referência relativa seleciona o modo de
gravação da macro - se é feito com base
em referências relativas (botão
selecionado) ou referências absolutas.

8. No caso da barra de ferramentas

desaparecer, ela pode ser reexibida por
meio do menu Exibir. Na opção Barra
de ferramentas, escolha Parar a
gravação. Caso a barra de ferramentas
não apareça listada, a gravação de
macros não está ativa.

Gravada uma macro, é possível

executá-la por meio do comando no
menu Ferramentas > Macro > Macros.
Assim, será apresentada uma janela
contendo todas as macros criadas e
salvas. Com isso, basta selecionar a
macro desejada e clicar no botão
Executar. A figura a seguir apresenta
esta tela:

Figura 1.2: Janela de execução/remoção

de macros.
 Um modo mais fácil de executar uma
macro é fazê-lo por meio de uma tecla
de atalho. Se notarmos, na Figura 1.1
existe uma opção para inserir a tecla de
atalho desejada, que sempre será CTRL
+ alguma tecla definida pelo usuário.

Por outro lado, existem diversas

opções para manipular uma macro, já
definidas pelo Excel, como: Depurar,
para analisar a execução da macro passo
a passo; Editar, para reprogramá-la (em
VBA); e, por fim, Excluir, que exclui
uma macro já criada.

Considerações finais

Neste capítulo, tivemos uma breve

introdução a respeito do
desenvolvimento de aplicações, como
elaborar um algoritmo e o que é o VBA.
Também definimos como criar uma
macro com o gravador de macros. Nos
capítulos seguintes, veremos
detalhadamente como funciona cada
instrução no VBA e, nos dois últimos
capítulos, traremos uma dedicação
exclusiva a aplicações do Excel e do
Access.
Introdução

Neste capítulo, aprofundaremos nosso

conhecimento em VBA por meio de
detalhes e exemplos para cada instrução
apresentada. 0 leitor aprenderá a utilizar
cada recurso disponível e como se
comportam as principais estruturas de
programação VBA. Veremos o editor do
VBA e construiremos aplicativos para
resolver alguns problemas formulados.
 0 presente capítulo e o seguinte darão a
base necessária para que o leitor
aprenda a trabalhar com os recursos do
VBA, por isso fique atento aos
comandos e instruções apresentados
nestes dois capítulos, e execute os
exemplos para que, assim, você possa
chegar aos Capítulos 4 e 5 entendendo
mais facilmente as aplicações para o
Excel e Access.

Editor do VBA

Para ter acesso ao editor do Visual

Basic for Applications você terá de ir
ao menu Ferramentas e escolher a
seqüência Macro > Editor do Visual
Basic. Veja na Figura 2.1 como acessar
o menu. Neste exemplo, estamos
utilizando o Excel, mas, para acessar o
Editor do VBA, você poderá utilizar o
mesmo menu em qualquer aplicativo do
MS-Office:

Figura 2.1: Menu de acesso ao Editor do

 VBA.

Após acessar esta opção do menu,

você encontrará uma janela dividida em
três grandes áreas (Figura 2.2):

• Project Explorer (1);

• Properties Window (II);

• Edição de textos (III).

Vamos entender detalhadamente para

que serve cada uma dessas áreas e saber
como utilizá-las:
 Figura 2.2: Editor do VBA.

Project Explorer (janela para

visualização e exploração dos
projetos)

Primeiramente, verifique se a janela

está visível; caso não esteja, vá ao menu
Exibir e escolha a opção Project
Explorer. Nesta janela, você poderá
visualizar a hierarquia dos projetos de
Visual Basic for Applications ativos
neste momento.

Entre eles, deverá encontrar um projeto

cujo nome corresponda ao do arquivo no
qual você está trabalhando no momento.
Por exemplo, se você estiver no MS-
Excel e estiver editando um arquivo
chamado Exemplo.xls, ao acessar o
Editor do VBA você deverá encontrar
um projeto com o nome VBAProject
(Exemplo.xls). Veja na parte 1 da Figura
2.2.

Quando expandir o seu projeto (clique

no sinal de + ao lado do nome do
projeto), encontrará uma pasta chamada
Microsoft Excel Objects (ou Microsoft
Word Objects ou, ainda, Microsoft
Access Ohjects, depende de onde
estiver editando seu programa em VBA).
Uma outra pasta, chamada Módulos,
aparecerá. Se não aparecer, significa
que o seu projeto ainda não possui
qualquer macro implementada. Para
criar esta pasta, vá ao menu Inserir e
escolha a opção Módulo.

Na pasta Microsoft Excel Objects,

você encontrará todos os objetos que
fazem parte do seu documento: neste
caso, as planilhas Plan1, Plan2 e Plan3
(veja na Figura 2.2). Se você clicar duas
vezes em cada um destes objetos, uma
nova janela será visualizada na área à
direita. Em cada uma dessas áreas é
possível definir a ação a ser executada
em função dos eventos de cada objeto.

Na pasta Módulos, aparecerá o

conjunto de arquivos (módulos) no qual
poderá programar as suas macros.
Dando um clique duplo em cada um dos
módulos indicados, é possível visualizar
as macros que o compõem, na janela da
direita.

Properties Window (janela de

visualização e manipulação de
propriedades)

Se você não estiver vendo a janela de

propriedades, vá ao menu Exibir e
escolha a opção Janela Propriedades.
Veja esta janela na parte II da Figura
2.2.

Nesta janela, você poderá visualizar e

alterar as propriedades definidas para
cada objeto. Na Figura 2.2, parte II,
pode-se ver que, para este caso, existe a
propriedade Name para o nome do
módulo.

Janela de edição

A janela de edição exibirá a cada

momento o código em VBA associado
ao elemento selecionado na janela
Project Explorer.
 Pesquisador de objetos

No Editor do Visual Basic for

Applications é possível encontrar ajuda
para o desenvolvimento do seu
procedimento. Assim:

1. Clique no ícone Pesquisador de

objeto ou vá ao menu Exibir e escolha a
opção Pesquisador de objeto. Também é
possível utilizar a tecla de atalho F2.

2. Na caixa de drop-down, onde

aparece a indicação <Todas as
bibliotecas>, selecione a aplicação para
a qual pretende ajuda, neste caso, o
Excel. Convém definir que você poderá
utilizar as funções de toda e qualquer
aplicação.

3. Na área intitulada Classes,

aparecem todos os objetos específicos
para a manipulação da aplicação
selecionada. A classe especial
designada por Globais refere-se às
funções disponíveis na aplicação,
independentemente dos objetos
selecionados.

4. Selecione um dos objetos e visualize

do lado direito os membros do elemento
selecionado.

5. Cada membro da classe dispõe de

uma ajuda on-line que o esclarece a
respeito de sua respectiva função e
funcionamento, dando exemplos
passíveis de teste. Para isto, basta clicar
sobre o botão de ajuda da janela (ícone
com o sinal de interrogação) do
Pesquisador de objeto.

Ajuda on-line

0 Editor do Visual Basic for

Applications fornece ao usuário um
sistema de ajuda permanente. Assim,
quando são construídos procedimentos,
na janela de edição, à medida que a
linguagem é escrita, o editor abre listas
de opções automaticamente para auxiliar
na implementação do código.
 As cores do VBA

Na janela de edição são programados,

armazenados e exibidos os
procedimentos VBA criados. Entretanto,
o código de cada procedimento é
composto por cores diferentes, sendo
que cada uma tem um significado
distinto. Vejamos a seguir uma lista que
descreve o significado de cada cor:

• azul: palavras-chave da linguagem.

Exemplo: Sub, EndSub, Function, If,
Then, Else, While, Loop etc. Veremos
maiores detalhes desses comandos
mais à frente;

• vermelho: sempre que se escreve uma

linha em linguagem VBA na janela, o
editor vai retificar a sintaxe da
linguagem a fim de indicar se existe ou
não algum erro de escrita. Se for
detectado um erro, a linha fica
vermelha e é exibida uma mensagem de
erro, caso contrário, todas as palavras
são reconhecidas, coloridas da cor da
respectiva categoria e alteradas para
letras maiúsculas ou minúsculas,
conforme predefinido;

• preto: nome de variáveis,

procedimentos, valores, operadores.
Veremos todas essas estruturas neste
livro;

• verde: comentários introduzidos nos

procedimentos. Estes comentários
servem para o usuário associar
algumas explicações aos
procedimentos realizados. As palavras
com esta cor são ignoradas, não
produzem qualquer efeito na execução
do procedimento. Para introduzir
comentários basta que o caractere `
anteceda o texto que será comentado;

• amarelo: um sombreado amarelo

pode aparecer sobre a linha que
identifica um procedimento. Essa cor
indica a ocorrência de um erro na
execução do respectivo procedimento
e seu estado de execução. Por
exemplo, o procedimento iniciou a
execução, durante a qual detectou um
 erro e agora está parado, mas ainda em
execução. Quando isto acontecer, você
não deve executar o procedimento
novamente sem antes interromper
(Stop) a execução mal-sucedida.

Funções e sub-rotinas

Como apontamos no capítulo anterior,

quando se grava uma macro no Excel,
este tem um comportamento em
background, que realiza a respectiva
codificação para o Visual Basic
forApplications. Este resultado é bem
visível quando procedemos a edição de
uma macro no editor do VBA. Cada
macro criada tem um comportamento
independente em relação a outras
macros implementadas, e tem como
objetivo executar um determinado
número de instruções que respondam às
necessidades e exigências do usuário.

Cada macro criada dá origem a um

procedimento ou rotina. Existem dois
tipos de rotinas: as sub-rotinas, ou
rotinas Sub, e as funções.

Sub-rotinas

Por definição, as sub-rotinas são

aquelas cuja definição é delimitada
pelas palavras-chave Sub e EndSub.
Assim, você perceberá que todas as
macros são deste tipo. A seguir,
podemos ver como é definido o corpo
das sub-rotinas:

Estas sub-rotinas são designadas pelos

nomes que lhe atribuímos e não recebem
parâmetros externos. Têm como função
executar o conjunto de tarefas que
compõem o seu corpo. 0 corpo da macro
é composto por um conjunto de
instruções, sendo que cada instrução
distinta necessita estar numa linha
diferente. Contudo, quando se trata de
instruções demasiadamente grandes, o
editor faz a sua partição por diversas
linhas, recorrendo ao operador a fim de
facilitar a leitura.

Como trabalhar no editor

de VBA: criando uma sub-
rotina

Para criar uma sub-rotina é necessário

que exista um módulo no qual se possa
escrever. Se ainda não tiver criado o
módulo, já que ainda não criou uma
macro, você deverá ir ao menu Inserir e
escolher a opção Módulo. Uma vez
posicionado nesse módulo, você poderá:

• Escrever a macro integralmente, ou;

 • Ir até o menu Inserir e escolher a
opção Procedimento, para que o VBA
crie automaticamente a estrutura. Veja na
figura a seguir a caixa de diálogo que
deve aparecer:
 Figura 2.3: Caixa de diálogo para a
criação de um novo procedimento.

Dessa forma, é preciso indicar o tipo

de rotina a criar - Sub - e o nome que
pretende dar à macro - rotina,
procedimento ou sub-rotina.
Automaticamente, o editor criará a
estrutura da rotina. No caso da Figura
2.3, ficaria:

Execução de uma sub-

rotina

No nosso caso, podemos considerar

que sub-rotina e macro são duas
designações para um mesmo objeto.
Portanto, todas as vezes que nos
referirmos a macros, a observação
também é válida para as sub-rotinas.
 Neste contexto, a execução de sub-
rotinas segue o mesmo mecanismo das
macros. Porém, neste momento já se
pode referir uma nova forma de executar
as macros ou sub-rotinas. Dentro de
outras rotinas, por exemplo: quando se
escreve dentro de uma rotina o nome de
outra, a execução da rotina tem
continuidade na execução daquela que
está sendo chamada.

Funções

Funções são rotinas cuja definição

começa com a palavra-chave Function e
termina com as palavras End Function.
Todas as funções utilizadas no Excel são
deste tipo. A sua definição sintática tem
a seguinte estrutura:

A função é identificada pelo nome,

pelo número e pelo tipo de parâmetros
recebidos, tendo como objetivo executar
um conjunto de instruções e produzir um
valor final; isto é, sempre que se
pretender executar uma função, sabe-se,
a priori que ela produzirá um valor.
Recorde-se, como exemplo, a função
SOMA, que recebe por parâmetro um
conjunto de valores a somar, assim o
resultado da aplicação dessa função ao
conjunto de valores será o valor oriundo
da soma.

Para definir o valor produzido por uma

função, basta atribuir ao nome da função
um determinado valor ou expressão em
seu interior. Veremos como isso é feito a
seguir.

Definição do tipo de
parâmetros e do tipo da
função

Todos os elementos de entrada (input)

e saída (output) de uma função têm um
tipo de dado atribuído. Assim os
parâmetros devem ser definidos com o
tipo de dado respectivo e a função deve
ser de finida a partir do tipo de dado
que ela envia para o exterior. Agora,
podemos refinar um pouco mais a
definição da função:

Se os tipos não forem definidos, serão

assumidos por padrão como sendo do
tipo variant. Veremos quais tipos são
aceitos no VBA mais adiante.

Como trabalhar no editor

de VBA: criando uma
função

Para criar uma função, é necessário

que exista um módulo no qual se possa
escrever.

Uma vez posicionado nesse módulo,

você poderá:

• Escrever a macro integralmente, ou;

• Ir até o menu Inserir, escolher a

opção Procedimento, dar o nome ao
procedimento e escolher o seu tipo,
que neste caso é uma função. 0 VBA
criará automaticamente a estrutura.
Veja na figura a seguir a caixa de
diálogo que deverá aparecer:
 Figura 2.4: Caixa de diálogo para a
criação de um novo procedimento:
função.

Nessa caixa de diálogo, indique o tipo

de rotina a criar (função) e o nome que
pretende dar a ela (no exemplo da
Figura 2.4 demos o nome de
MULTIPLICA). Automaticamente, o
Visual Basic for Applications criará a
estrutura da rotina, que, neste caso,
ficaria assim:

Execução de uma função

Uma vez que uma função produza um

valor, ela poderá ser executada:

• Dentro de uma célula numa planilha,

como qualquer outra função do Excel;
 • Dentro de qualquer outra função, ou
sub-rotina.

Com base na função MULTIPLICA,

definida na Figura 2.5, analisaremos as
formas de execução com mais detalhes:

Figura 2.5: Janela de edição com a

função MULTIPLICA.

Execução dentro de uma

 célula

Vamos executar um pequeno exemplo

para ver como seria feita a execução da
função dentro de uma planilha do Excel.
As seguintes etapas devem ser
obedecidas:

1. Posicione-se na célula em que

pretende inserir a função, ou seja, na
qual deseja ver o resultado da função
MULTIPLICA. No nosso exemplo,
posicionamos na célula A3. Veja a
Figura 2.6.

2. Vá ao menu Inserir e escolha a

opção Função.
 3. Selecione a categoria Definida pelo
usuário. Perceba que a função criada
(MULTIPLICA) aparecerá do lado
esquerdo. Veja a figura a seguir:
 Figura 2.6: Caixa de diálogo para
introdução da função.

4. Clique em OK e, de imediato, uma

janela de ajuda virá auxiliar a utilização
da sua função. Veja a figura a seguir:
Figura 2.7: Caixa de diálogo para apoio
à utilização da função MULTIPLICA.

S. Introduza os valores e clique em

OK. No nosso exemplo, introduzimos no
Valorl a célula Al e no Valor2 a célula
Bl. Veja a Figura 2.8:
 Execução dentro de uma
rotina

Quando dentro de uma rotina se faz

referência ao nome de outra, a execução
da primeira passa pela execução
daquela que está a ser invocada.

Vamos proceder a outro exemplo,

agora declarando uma segunda função,
que se chamará ValorFinal. No exemplo
que se segue, a função ValorFinal faz
uma chamada à função MULTIPLICA
para calcular seu resultado final. Veja
como é implementada esta função na
Figura 2.8:
 Figura 2.8: Implementação da função
ValorFinal com chamada para a função
MULTIPLICA.

Variáveis

Primeiramente, vamos definir o que

são variáveis. As variáveis constituem
estruturas para armazenamento
temporário de dados, e podem ser
utilizadas para diversos fins. Podemos
definir, ainda, como sendo um nome
utilizado para representar dados que
podem ser alterados enquanto o
programa, ou procedimento, está em
execução.

Vamos construir um exemplo que pode

parecer um pouco complicado, visto que
ainda não conhecemos todas as
estruturas da linguagem VBA. No
entanto, será bom para mostrar a
utilização de va riáveis. Assim que você
terminar este capítulo, recomendamos
que volte a este exemplo para uma
melhor fixação do conceito.
 No exemplo detalhado na Figura 2.9, o
usuário informará o seu nome e o valor
de duas notas por meio das caixas de
informação (InfoBox). A sub-rotina
mostrará em uma caixa de mensagem
(MsgBox) o texto Aprovado se a média
foi maior ou igual a sete, ou Não
Aprovado, se a média for menor do que
sete.

Para conseguir fazer esta sub-rotina,

foi preciso declarar quatro variáveis,
sendo três do tipo double (N1, N2 e
media) e uma do tipo string (Nome).
Veremos mais adiante todos os tipos
possíveis de variáveis em VBA. Por
hora, é importante saber que double são
variáveis para números reais e string
são variáveis para texto. A seguir,
vamos detalhar um pouco mais a sintaxe
de utilização das variáveis deste
exemplo:

Figura 2.9: Manipulação de variáveis

com a sub-rotina CalculaMedia.

Atribuição de valores a variáveis

 Quando se pretende atribuir valores a
variáveis, devemos indicar o nome dela,
o operador = e o valor que se pretende
que a variável armazene:

Observando as variáveis N1, N2, e

Nome, do exemplo da Figura 2.9,
podemos verificar que estas armazenam
os valores informados pelo usuário por
meio das InputBox (caixa de entrada,
veremos adiante detalhes sobre ela). À
variável media é atribuído o cálculo
resultante da média das duas notas
informadas pelo usuário (Ni e N2).
Utilização dos valores das variáveis

0 nome de uma variável representa o

seu conteúdo. Assim, sempre que
escrever o nome de uma variável, o seu
conteúdo será considerado.

Seguindo o mesmo exemplo da Figura

2.9, podemos ver que no cálculo da
média:

Ni representa o valor da primeira nota

informada e N2 representa o segundo
valor. Não se trata de adicionar o nome
de duas variáveis, mas de informar os
conteúdos que elas armazenam.
Tipos de variáveis

0 tipo de variável está associado ao

tipo de informação que esta poderá
armazenar. Vejamos a seguir os tipos
permitidos em VBA e o tamanho
permitido para cada tipo:

• Boolean (2 bytes): permite armazenar

valores booleanos, True OU False;

• Byte (1 byte): permite armazenar

números inteiros sem sinal entre 0 e
255;

• Currency (8 bytes): permite

armazenar valores monetários;
• Date (Bytes): permite armazenar
datas;

• Double (8 bytes): permite armazenar

um número real, de
-4.94065645841247E-324 a
4.94065645841247E-324;

• Single (4 bytes): permite armazenar

um número de -1.4011298E45 a
1.4011298E-45;

• Integer (2 bytes): permite armazenar

números inteiros entre -32.768 e
32.767;

• Long (4 bytes): permite armazenar

números inteiros entre -2147483648 e
 2147483648;

• Object (4 bytes): utilizado para fazer

referência a um objeto do Excel;

• String (1 byte por caractere): permite

armazenar conjuntos de caracteres;

• Variant (16 bytes): permite armazenar

qualquer tipo de dados;

• User-Defined: permite armazenar

valores de tipos diferentes.

Declaração de variáveis

Vejamos um exemplo de declaração de

variáveis:
 Em que:

• Dim: palavra-chave que indica uma

declaração de variáveis (abreviatura
de dimensão);

• N1, N2, Media: nomes dados às

variáveis;

• As: palavra-chave utilizada para

separar o nome da variável do tipo de
dados;

• Double: tipo de dados atribuído à

variável.

Também é possível declarar variáveis

de diversos tipos para a mesma
declaração. Veja o exemplo a seguir:

Variáveis do tipo objeto

Uma variável do tipo Objeto

representa uma referência a um objeto,
sendo ela uma variável de extrema
importância, que facilita a codificação e
melhora a performance da sub-rotina. A
declaração tem a seguinte sintaxe:

0 valor que será atribuído à variável

Objeto obrigatoriamente terá de ser do
mesmo tipo, assim a sua sintaxe é
expressa como vemos a seguir:

Em que:

• Set: palavra-chave que indica a

atribuição de uma variável objeto;

•<VarObjeto>: variável Objeto;

• =: operador de atribuição;

• <Objeto>: objeto a ser atribuído à

variável.

Podemos utilizar a variável do tipo

objeto como sendo genérica. Essa
utilização serve para suportar qualquer
tipo de objeto. No Excel, podemos
utilizar a planilha, as células etc.
Veremos em outro capítulo a utilização
de objetos para o MS-Access. Em
Excel, teríamos o seguinte exemplo:

Podemos também utilizar o tipo exato

do objeto que se pretende atribuir à
variável. Vejamos os exemplos a seguir:

Variáveis: declaração opcional e o tipo

variant
 A declaração de variáveis é opcional,
sendo que, se as variáveis não forem
declaradas, o VBA faz a sua declaração
por padrão. Assim, sempre que a
instrução do Dim é omitida para uma
variável, essa assume o tipo variant.

Os prós e contras da
utilização do tipo variant

• Prós:

• diminui o número de linhas de

código;

• não é necessário ficar preocupado se

a variável está ou não declarada, pois
o VBA faz isso automaticamente.
• Contras:

• aumenta o tempo de execução. 0 VBA

primeiro precisa reconhecer o tipo de
dado com o qual está a trabalhar;

• este tipo de dado consome mais

memória (uma vez que aloca espaço
para qualquer tipo de dado que lhe seja
atribuído);

• 16 bytes mais um byte por caractere

se for string;

• problemas de performance para sub-

rotinas grandes;

• não é possível saber o tipo de dado

 que uma determinada variável contém,
dificultando a detecção de erros.

Variáveis: declaração forçada

Para que o VBA detecte um erro

sempre que uma variável não for
declarada, faça o seguinte:

1. Vá ao menu Ferramentas e escolha a

opção Opções na aba Editor.

2. Requeira declaração de variável.

Ou então, você pode optar por

escrever no início de cada módulo o
comando Option Explicit.
 Neste caso, sempre que for detectada
uma variável ainda não declarada,
haverá uma mensagem de erro: Variable
Not Defined.

Variáveis: tipos definidos pelo usuário

(estruturas)

Definição do tipo

A primeira fase é constituída pela

definição do tipo. Vejamos o exemplo a
seguir, no qual você poderá criar um
novo módulo:
 Dessa forma, criamos um tipo de dado
que representa uma estrutura com dados
de diferentes tipos. Esta definição
sempre deverá ocorrer no início do
módulo VBA.

Observe detalhadamente a constituição

do código:

• Type: palavra-chave que indica a

definição de um tipo de dado criado
 pelo usuário;

•DadosPessoais: nome atribuído ao

tipo de dado;

• Nome As String: primeiro elemento

da estrutura de dados definida;

• Idade As Integer: segundo elemento

da estrutura de dados definida;

• DataNascimento As Date: terceiro

elemento da estrutura de dados
definida;

• RG As Long: quarto elemento da

estrutura de dados definida;
 • End Type: palavra-chave que indica o
fim da definição da estrutura de dados.

Utilização das estruturas de

dados

Agora que já aprendemos como se

declara uma estrutura de dados, vejamos
como utilizá-las:
 Isso feito, basta ir ao menu Executar e
escolher a opção Executar
Sub\userForm.

Variáveis: arrays

Um array é uma variável que

representa um conjunto de variáveis do
mesmo tipo. Os arrays podem ser
multidimensionais, sendo que todas as
dimensões são indexadas
numericamente.

Array unidimensional

Um array unidimensional é constituído

por uma lista única de elementos
indexáveis. Esta lista tem um elemento
inicial e um final, sendo que a cada
elemento é atribuído um único índice,
isto é, a posição que ocupa na lista e que
o identifica. Observe:

Tabela 2.1.

Array bidimensional

Um array bidimensional é um pouco

mais complexo, sendo constituído por
um conjunto de listas do mesmo
comprimento. Este formato é
normalmente conhecido como array, ou
matriz. É, portanto, constituída por
linhas e colunas; cada elemento é
identificado por um índice composto
pela intersecção dos números da linha e
da coluna:
Tabela 2.2.
 Declaração de um array

Arrays unidimensionais são assim

declarados:

ArrayNumerico é o nome da variável

array. 0 número entre parênteses indica
os elementos armazenados pelo array.
Observe:
 Tabela 2.3.

Em que cada elemento é do tipo

Integer.
 Arrays bidimensionais são assim
declarados:

Tabela_Textual é o nome da variável.

Os números entre parênteses indicam
que a tabela terá cinco linhas e quatro
colunas, podendo, assim, armazenar 20
elementos do tipo string. Observe:
 Tabela 2.4.

Utilização de um array

A sintaxe para ter acesso ao elemento:

Observe a atribuição de valores:

Vejamos o exemplo a seguir:

Após a atribuição de valores a cada

elemento do array, este passa a ter o
conteúdo seguinte:
 Tabela 2.5.

Estes valores serão exibidos por meio

de uma caixa de mensagem (MsgBox)
após executar o módulo.

Agora, vejamos o próximo exemplo:

 A função Rnd () gera um número
randômico, assim, sempre que for
executada, a sub-rotina mostrará três
números diferentes, que, na verdade,
estão armazenados em um array de
inteiros.

Option Base e array bounds

A indexação de um array tem início em

zero, assim os índices vão de zero a
dimensão-1. Para alterar a base de
indexação e ter o início em um, basta
colocar, no início do módulo, a
instrução Option Base1.

Entretanto, se deseja que um array

comece com outro número que não seja
zero ou um, é necessário especificar os
limites inferior e superior do índice da
declaração. Vejamos como isso é feito
no exemplo a seguir:

Constantes
 Constantes são valores que não se
alteram durante a execução de uma
rotina. São declaradas da mesma forma
que as variáveis, a única diferença é que
a atribuição deve ser feita na mesma
instrução da declaração, sendo feita uma
única vez:

Vamos ver o exemplo a seguir em que

declaramos a constante TaxaDesc como
valor 0.05:
As funções InputBox e MsgBox

Para haver interação entre o usuário e

uma macro, ou programa, é necessário
que exista uma interface de
comunicação, isto é, uma interface de
entrada e saída de informações. Assim,
em VBA nós podemos utilizar as funções
InputBox e MsgBox.

A InputBox é uma função que permite

ao usuário inserir dados no programa; é,
portanto, um mecanismo de entrada. 0
MsgBox é um mecanismo de saída e
permite ao usuário visualizar os dados
produzidos pelo programa.

InputBox

Esta função possui basicamente três

funcionalidades:

• exibe uma janela com uma caixa de

texto para o usuário inserir dados
(algum texto);

• fica na espera até que o usuário digite

algum texto, ou acione um dos botões;

• assim como todas as funções, ela

 também produz um valor final. Este
consiste nos dados inseridos pelo
usuário na forma de texto. 0 tipo
retornado é sempre uma string. A
sintaxe da função é apresentada logo a
seguir:

Apesar da função possuir diversos

parâmetros, somente o primeiro é
obrigatório, sendo que todos os outros,
quando ignorados, assumem valores
atribuídos por padrão.

Vamos ver, detalhadamente, como

funciona e para que serve cada
parâmetro desta função:
 • prompt (obrigatório): texto exibido
como mensagem na janela de entrada.
É o texto que o usuário deve ler para
saber quais dados deverão ser
informados na caixa de texto. A
dimensão máxima é de 1.024
caracteres.

Se for necessário elaborar uma

mensagem com mais de uma linha,
deverá ser utilizado o caractere Chr(13),
que significa uma quebra de linha. A
junção dos elementos que constituem a
mensagem é realizada pelo operador &.
Vejamos o exemplo a seguir:
• titie (opcional): título da janela de
entrada. Se este for omitido, aparecerá
o nome da aplicação;

• default (opcional): expressão

inserida na caixa de texto. Constituirá
na resposta padrão caso o usuário não
informe nenhuma. Se este parâmetro
for omitido, aparecerá uma caixa de
texto vazia;

• xpos (opcional): número que

identifica a distância horizontal entre o
lado esquerdo da tela e a janela de
entrada. Se este valor for omitido, a
janela aparecerá centralizada
horizontalmente;
• ypos (opcional): número que
identifica a distância vertical entre o
lado superior da tela e a janela de
entrada. Se este valor for omitido, a
janela ficará posicionada a 1/3 da
parte inferior da tela;

• helpfile (opcional): nome do arquivo

de ajuda que será utilizado para dar
apoio ao preenchimento desta janela.
Se for indicado este parâmetro, o
seguinte (context) é obrigatório;

• context (opcional): número do índice

do tópico de ajuda (help) constante em
helpfile, e que corresponde à janela em
questão.
 Temos de ter atenção se pretendemos
enviar mais de um parâmetro opcional,
pois devemos respeitar a ordem
mediante , (vírgulas). Assim, quando
quisermos colocar apenas alguns
parâmetros opcionais, devemos deixar
também as vírgulas dos outros
parâmetros. Vejamos o exemplo a
seguir:

Na janela de entrada, será exibida a

mensagem Introduza o Nome da
Aplicação, o título da caixa será o
definido por padrão e o valor na caixa
de inserção será Excel.

MsgBox
 Esta função possui basicamente três
funcionalidades:

• exibe na tela uma janela com uma

mensagem;

• fica na espera de que o usuário

acione um dos botões;

• assim como a função InputBox, esta

também produz um valor final. Neste
caso, é devolvido um número inteiro
indicando o botão clicado.

A sintaxe da função é apresentada a

seguir:
À semelhança da InputBox, pode-se
dizer que a função possui diversos
parâmetros, mas somente o primeiro é
obrigatório, sendo que todos os outros,
quando ignorados, assumem valores
padrões:

• prompt (obrigatório): é o texto

exibido como mensagem na janela. A
dimensão máxima é de 1024
caracteres;

• buttons (opcional): número que

identifica o tipo de botão que se
pretende visualizar na janela de saída.
Veja seus respectivos valores na figura
seguinte. Se for omitido, assumirá o
valor zero como padrão;
• titie (opcional): título da janela de
input. Se este for omitido, aparecerá
por padrão o nome da aplicação;

• helpfile (opcional): nome do arquivo

de ajuda que será utilizado para dar
apoio ao preenchimento desta janela.
Se for indicado este parâmetro, o
seguinte (context) é obrigatório;

• context (opcional): número do índice

do tópico de ajuda constante em
helpfile, e que corresponde à janela em
questão.

Parâmetros
 Assim como a função de entrada, esta
também requer atenção, se quisermos
enviar mais do que um parâmetro, pois é
preciso respeitar a ordem mediante ,
(vírgulas). Assim, quando quiser
colocar apenas alguns parâmetros
opcionais, devemos deixar também as
vírgulas dos outros parâmetros. Vejamos
o exemplo a seguir:

Na janela de output, será exibida a

mensagem Erro de Sintaxe!!!, o botão
exibido será o de OK (padrão) e o título
da janela será Mensagem de Erro:
 Figura 2.10: Valores dos botões para
serem utilizados na função MsgBox.

Pela análise desta figura, é possível

constatar que existem diferentes
agrupamentos de códigos: para definir o
tipo de botão (o a 5), para definir o tipo
de ícone (16, 32, 48, 64), para definir o
botão selecionado como padrão (0, 256,
512, 768). Será possível adicionar os
códigos e, assim, fazer combinações
entre diversas opções destes três grupos,
porém, nunca adicione mais de um
código por agrupamento. Vejamos o
exemplo a seguir:

Para a instrução anterior é exibida a

seguinte janela:
 Figura 2.11: MsgBox com ícone
de alerta.

Valores produzidos quando um botão é

acionado

Como já foi mencionado, a função

MsgBox produz um valor quando um
botão é acionado. Assim produzirá
como saída um dos valores constantes
da tabela a seguir:
 Tabela 2.6.

Escopo das variáveis, constantes e

rotinas

0 escopo ou domínio de um elemento

refere-se à área da aplicação na qual
esse elemento pode ser acessado e
utilizado.
 0 escopo das variáveis refere-se à área
na qual a variável permanece ativa,
mantendo o valor que lhe vai sendo
atribuído.

Existem 3 níveis de domínio para as

variáveis:

• no ambiente de um procedimento;

• no ambiente de um módulo;

• no ambiente de um projeto.

Vamos ver detalhadamente cada

ambiente.

Variáveis para o ambiente de um

procedimento

Estas variáveis são declaradas no

corpo do procedimento utilizando a
palavra-chave Dim.

São variáveis criadas para a execução

de um procedimento e automaticamente
destruídas quando o procedimento
termina; só são reconhecidas dentro do
procedimento em que foram declaradas.
Assim sendo, qualquer tentativa
realizada por um procedimento no
sentido de trabalhar com variáveis
definidas no corpo de outro
procedimento não terá êxito. Vamos ver
o exemplo a seguir:
 A execução destas rotinas resultará no
seguinte:

• a primeira mensagem (MsgBox no

Procedimentol) exibirá o número
informado pelo usuário e que foi
armazenado na variável Var1;

• a segunda mensagem, oriunda da

instrução MsgBox do Procedimento2,
não exibirá o valor informado, pois a
variável var_ 1 nele referida é
 considerada interna do processo, e,
portanto, criada dentro do
Procedimento2. Como tal, embora
possua o mesmo nome que a variável
da rotina Procedimentol, não existe
qualquer ligação entre elas, são duas
variáveis distintas.

Neste caso, se pretendêssemos que o

valor da primeira variável fosse
reconhecido no procedimento chamado,
teríamos de passá-lo por parâmetro.

Variáveis para o ambiente de um módulo

Uma variável pode ser acessada por

todas as rotinas existentes no módulo em
que foi declarada.
 Para declarar uma variável modular,
deve declará-la com a palavra-chave
Dim na seção Declarations do
respectivo módulo VBA. Neste caso,
qualquer variável aí declarada será
considerada para o ambiente modular
por padrão. Para tornar este fato
explícito, podemos utilizar a palavra-
chave Private na declaração. Vamos ao
exemplo:
 Neste caso, como a variável é
reconhecida no módulo por qualquer
rotina nele existente, desde que seja
referida sempre pelo mesmo nome, o
procedimento Modulo2 exibirá o valor
informado pelo usuário no procedimento
Modulol.

Variáveis para o ambiente de um projeto

As variáveis assim definidas têm o

escopo correspondente a todo o projeto,
isto é, podem ser acessadas e alteradas
em todos e quaisquer módulos. Para
declararmos variáveis deste tipo, é
preciso fazê Ias na seção Declarations
de qualquer módulo. Para tal, devemos
utilizar a palavra-chave Public. Vamos
ao exemplo a seguir. No Modulol tem-
se:

No Modulo2 tem-se:

A execução do procedimento Projetor

no Modulol mandou executar o
procedimento Projeto2 do Modulo2. 0
valor atribuído à variável var1 foi
acessado posteriormente em outro
procedimento de outro módulo. Isso é
possível por tratar-se de uma variável
global.

Escopo de sub-rotinas e funções

Estas só têm dois níveis de escopo: o

nível do projeto e o nível do módulo.

Por definição, as rotinas são de escopo

do projeto sem qualquer indicação
adicional. Entretanto, podemos tornar
isto mais explícito pela introdução da
palavra-chave Public, que, em termos
operacionais, não adicionará qualquer
funcionalidade, mas, em termos de
leitura, dará uma maior percepção.
Vejamos o exemplo a seguir:
 Para que uma rotina tenha o escopo do
módulo no qual está definida, deve ser
antecedida pela palavra-chave Private.

Considerações finais

Este capítulo forneceu uma introdução

ao VBA, porém, ainda estão faltando
algumas estruturas essenciais para o
desenvolvimento de uma aplicação.
Veremos isto no capítulo seguinte.

Mais uma vez, é importante ressaltar

que para o bom aprendizado o leitor
deverá acompanhar os exemplos e
executá-los. Acreditamos que esta é a
melhor forma de fixar os conceitos
discutidos. Todos os exemplos deste
livro estão completos; basta digitá-los
no editor do VBA e ver o seu
funcionamento.

No capítulo seguinte, veremos as

estruturas condicionais e, ainda, as
estruturas de repetição. Quando forem
aprendidas estas estruturas, nossas
aplicações terão um grande impacto de
melhora em sua capacidade de
resolução de algoritmos.
Introdução

Veremos, neste capítulo, as estruturas

de repetição e de tomadas de decisão.
São estruturas que podem alterar o fluxo
de execução de uma aplicação, tornando
as aplicações mais poderosas. Podem,
também, diminuir consideravelmente o
tamanho de seu código, se bem
empregadas. Contudo, podem deixar o
código mais difícil de entender.
 Daremos as instruções e suas sintaxes,
explicando detalhadamente como elas se
comportam. No fim deste capítulo,
veremos os objetos, suas propriedades e
seus métodos mais utilizados.

Estruturas de controle

0 VBA disponibiliza algumas

estruturas que podem ser utilizadas para
controlar o fluxo da execução de uma
rotina. Estas estruturas dão ao
programador um enorme poder de
construção de rotinas complexas e
flexíveis. As seguintes estruturas são
permitidas em VBA:

• If-Then-Else: testa uma condição e

executa um determinado conjunto de
instruções de acordo com o resultado
da avaliação;

• For-Next: executa uma determinada

tarefa um determinado número de
vezes;

• while-Wend: executa uma

determinada tarefa enquanto uma dada
condição for verdadeira, ou seja, com
o valor True;

• Do-Loop: executa uma determinada

tarefa enquanto a avaliação de uma
condição for True, ou até que seja
True;
 • Select-Case: seleciona um dos
segmentos de código a processar,
mediante a avaliação consecutiva de
condições;

• For-Each-Next: realiza uma

determinada tarefa repetitiva em cada
objeto de uma coleção ou em cada item
de um array.

Veremos cada uma dessas estruturas

detalhadamente a seguir.

If-Then-Else
A sintaxe da estrutura If-Then-Else é a
seguinte:
 A palavra Else é opcional num If-
Then-Else Statement, sendo que, no caso
de ser omitida, a avaliação negativa da
condição implica uma saída automática
da instrução If. Vejamos como fica em
um exemplo
 No exemplo, a rotina Aposta recebe
uma aposta do usuário e, mediante o
sorteio, realizado por esta função,
verifica se o jogador ganhou ou não a
aposta, comunicando-lhe do fato.

Vamos ver, detalhadamente, o

significado de cada instrução do
exemplo anterior:
• if: comando condicional. Em
português, nós podemos traduzir como
"se";

• NSorteio = NAposta: condição que

está sendo testada;

• Then: palavra reservada que

determina o fim da condição teste.
Todas as instruções que têm início
nesta palavra reservada até a palavra
reservada Else serão executadas se a
condição for verdadeira. Em
português, nós podemos traduzir como
"então";

• MsgBox "Parabéns ! ! Vocêacertou!":

instruções que serão executadas se a
condição for verdadeira;

• Eise: palavra reservada que

determina o fim da execução das
instruções quando o resultado da
avaliação for verdadeiro, e que deter
mina o inicio das instruções executadas
se o resultado da condição for falso;

• MsgBox "Continue tentando!! O

número sorteado foi o " & NSorteio:
instruções que serão executadas se a
condição for falsa;

• End If: palavra reservada que indica

o fim da estrutura condicional If-Then-
Else.
 A instrução adicional
ElseIf

Esta instrução propõe uma condição

alternativa se o teste da condição
anterior tiver um resultado negativo.
Vamos a um exemplo prático.

Imagine que pretendemos criar uma

macro para classificar indivíduos em
função da sua idade. Veja como seria a
implementação desta situação a seguir:
A instrução For-Next

Esta instrução permite a execução de

uma tarefa durante um determinado
número de vezes. É também chamada de
laço de execução.

A sintaxe desta instrução é a seguinte:

 Vejamos uma aplicação prática.
Imagine que tenhamos de fazer uma
rotina que, recebendo a base e a
potência, calcule o seu resultado. Veja a
seguir como ficaria esta implementação:
 Neste exemplo, a instrução For-Next
tem como função calcular a potência. 0
mesmo efeito poderia ser obtido
recorrendo à expressão Resultado =
Base ^ Potência, contudo, para fins de
demonstração de funcionamento, este
exemplo é bastante simples. Observe
detalhadamente a função de cada
instrução deste exemplo:

• Base: variável que armazena o

elemento que será elevado;

• Potencia: variável que armazena o

número de vezes que a base será
multiplicada;

• Contador: variável que armazena o

número de vezes que a base foi
multiplicada. É uma variável que será
automaticamente incrementada em cada
ciclo;

• Resultado: variável que armazena o

resultado sucessivo sempre que se
multiplica;

• For: palavra reservada que indica o

início do ciclo For-Next;
• Contador = 1 To Potência: expressão
que contém a inicialização do
contador, indicando o valor de início e
de fim. Assim, o número de vezes que
o ciclo é executado será Valor_Fim -
ValorInicio+1;

• To: palavra utilizada para separar o

valor do contador no momento inicial
de seu valor no momento final. 0
contador inicia em um e atingirá o
valor máximo traduzido pela variável
Potencia;

• step 1: palavra-chave utilizada para

especificar o valor incrementado, ou
decrementado, ao contador do ciclo
sempre que o laço é concretizado.
Normalmente, o valor incrementado é
um, mas qualquer outro valor pode ser
utilizado, de números decimais a
números negativos (provocando assim
a decrementação). A palavrachave step
é opcional. Sempre que for omitida é
assumido 1 como o valor padrão;

• Resultado = Resultado * Base:

instrução que será realizada cada vez
que o ciclo for executado. Neste caso,
a instrução é única, mas poderíamos
adicionar outras instruções;

• Next: palavra reservada que indica o

fim de um laço ForNext. Sempre que a
execução do laço chega à instrução
Next, a variável contador é
 incrementada e volta ao início do laço.

Funcionamento do laço, ou ciclo

A primeira execução do laço distingue-

se das restantes pelo fato dela estar
associada à inicialização de contador,
sendo o restante do procedimento
semelhante a qualquer outra execução.

No início de cada execução do laço, a

variável contador é comparada com o
valor final de execução. Se step for um
valor positivo (incremental) e o valor de
contador for superior ao valor final, isso
significa que o ciclo já foi realizado o
número de vezes pretendido. e então, o
código acabará a execução da instrução
For-Next e seguirá na linha de código
situada imediatamente a seguir. Caso
contrário, executa uma vez mais o laço e
incrementa a variável contador. Por
outro lado, se step contiver valor
negativo (decremental) e o valor de
contador for inferior ao valor final, isto
significa que o teste já foi realizado o
número de vezes pretendido, portanto, o
código finalizará a execução da
instrução For-Next e seguirá na linha de
código situada imediatamente a seguir.
Caso contrário, executa uma vez mais o
ciclo e decrementa a variável contador.

Vamos a outro exemplo. Agora, vamos

fazer uma aplicação para calcular o
fatorial de um número fornecido pelo
usuário. A implementação desta
aplicação é demonstrada a seguir:
 AS instruções While-Wend

As instruções While-Wend têm um

funcionamento similar a ForNext.
Realiza um laço por um determinado
número de vezes, até que uma dada
condição seja verdadeira. Veja como é a
sua sintaxe:

Vamos ver, agora, um exemplo em que

utilizaremos esta instrução para fazer
uma aplicação de loteria viciada:

No exemplo, a instrução While-Wend

tem como função gerar números
aleatórios entre um e dez a fim de
encontrar o número da aposta, e saber
quantas tentativas são necessárias para
que aquele valor seja obtido. Vejamos
detalhadamente cada instrução deste
exemplo:

• Num -Loteria: variável que armazena

o número sorteado. Esta será
inicializada em zero, de forma que não
corresponda a nenhum valor informado
pelo usuário e, assim, possa realizar o
primeiro sorteio;

• Aposta: variável que armazena o

número em que o usuário pretende
apostar;

• Num _ Lanc: variável que armazena o

número de tentativas realizadas até
obter o resultado da aposta. Este valor
tem de ser incrementado sempre que
for realizado um sorteio;

• While: palavra reservada que indica

o início do ciclo WhileWend;

• Num _ Loteria <> Aposta: condição

teste utilizada para determinar o fim da
realização do laço. Se esta condição
for verdadeira, executa as instruções
dentro do whiie-wend, se for falsa, a
execução do ciclo é terminada tendo o
programa seqüência nas instruções que
seguem a palavra reservada wend;

• Num _ Lotaria = Int (9 * Rnd() + 1):

instrução que será realizada sempre
que o laço for executado. Tem como
função gerar números aleatórios entre
 um e dez;

• Num Lanc = Num Lanc +1: instrução

que será realizada sempre que o ciclo
for executado. Tem como função fazer
a contagem de quantas tentativas foram
realizadas até se obter o valor da
aposta;

• Wend: palavra reservada que indica o

fim de um ciclo WhileWend.

As instruções Do-Loop

Estas instruções são similares às

instruções While-Wend. Entretanto,
fornecem duas possibilidades que estão
limitadas àquelas instruções:
• Do-Loop permite posicionar a
condição teste no início ou fim do laço.
A condição no fim do laço evita uma
inicialização prévia do valor das
variáveis envolvidas na condição teste,
dado que essa inicialização pode ser
feita no curso do laço com valores
reais;

• Do-Loop permite ainda especificar se

o laço se realizará enquanto (while)
uma expressão for verdadeira ou até
que (until) a condição seja verdadeira
(facilidade conseguida por meio do
operador Not).

Vamos ver a sintaxe destas instruções:

 Podemos, também, declará-la da
seguinte maneira:

Vamos ver, agora, uma seqüência de

quatro exemplos para a mesma
aplicação (Loteriaviciada) utilizando
vários tipos de condição.

Primeiro exemplo

Utilizaremos a condição teste no início

do Loop com a palavra While:
 Segundo exemplo

Utilizaremos a condição teste no início

do Loop com a palavra Until:
 Terceiro exemplo

Utilizaremos a condição teste no fim

do Loop com a palavra Until:
 Quarto exemplo

Utilizaremos a condição teste no fim

do Loop com a palavra while:

A instrução Select-Case

Esta instrução permite a escolha de um

percurso mediante a avaliação de N
condições. É de extrema utilidade para
evitar os códigos if encadeados, dando
um maior grau de legibilidade e
simplicidade ao código construído. A
sintaxe desta instrução está descrita a
seguir:

Vamos voltar ao exemplo da aplicação

que implementa uma determinada
classificação dependendo da idade
indicada pelo usuário. Vamos resolvê-la
com a instrução Select-case:

Vamos detalhar as novas instruções que

foram inseridas neste exemplo:

• Select-Case: palavras reservadas que

indicam o início de uma instrução
Select-Case;

• Idade: variável que armazena a idade

informada pelo usuário. Esta variável
será comparada sucessivamente pelos
valores alternativos apresentados nas
instruções case <Valor>. Se encontrar
o valor em alguma dessas opções,
executará as linhas de código que aí
terão início até a opção seguinte. Caso
o valor da variável a ser comparado
não corresponda a nenhum valor
apresentado nas opções case, serão
executadas todas as instruções que se
localizem entre o case Else e o End
Select;

• Case Is < 3 OU Case Is <= 12 OU

Case Is <= 17 ou Case Is <= 25 ou
Case Is<=65: se o valor da variável
for igual a qualquer um dos valores
apresentados em cada uma destas
expressões, o fluxo de execução terá
continuidade na linha abai xo da
expressão case, até que uma nova
expressão seja encontrada, sendo que
nesta altura termina o controle Select
Case, dando continuidade ao programa
nas instruções que se seguirem ao End
Select;

• Case Else: será a instrução case que

executará caso nenhuma das outras for
executada, ou seja, ela é selecionada
somente se nenhuma das outras o tiver
sido. Neste caso, serão realizadas
 todas as instruções de código que lhe
seguirem até a expressão End Selecta

• End Select: palavra reservada que

indica o fim da instrução Select-Case.

Instruções For-Each-Next

As instruções For-Each-Next são as

mais potentes do VBA. De fato, elas
permitem executar uma determinada
instrução em todos os elementos de uma
coleção de objetos, ou em todos os
elementos de um array.

Esta estrutura, quando aplicada em

arrays, não funciona para a atualização
dos valores do array, mas somente para
a extração do seu conteúdo. No entanto,
quando aplicada a coleções de objetos,
pode ser útil para alteração das suas
propriedades ou para extração de
valores.

Sua sintaxe é a seguinte:

Vamos aos exemplos para melhor

entender essas instruções. A seguir,
vamos inicializar um array com um
conjunto de cinco países e,
posteriormente, visualizar os elementos
que foram introduzidos:
 Vejamos detalhadamente cada
instrução do exemplo anterior:

• For Each: palavras reservadas que

indicam o início de uma instrução For-
Each;

• Pais: variável a qual serão atribuídos

sucessivamente todos os elementos do
grupo de objetos. Este grupo pode ser
constituído por um array, ou por uma
coleção de objetos. Sendo que, em
caso de se tratar de um array, esta
variável deverá ser do tipo variant. Se
for uma coleção, esta variável poderá
assumir o tipo variant;

• In: palavra reservada que separa a

variável do grupo;

•Array-Pais: grupo de elementos que

serão tratados. Poderá ser um array ou
uma coleção de objetos. 0 laço será
executado tantas vezes quantos os
elementos constantes do grupo. Na
primeira iteração, a variável assume o
valor do primeiro item do grupo; em
cada laço este valor será atualizado
pelo item seguinte;

• MsgBox Pais: instrução realizada em

cada volta do laço, sendo que em cada
volta a variável Pais terá um elemento
diferente;

• Next: palavra reservada que indica o

fim do laço. Neste momento, o
programa terá continuidade na
instrução For Each correspondente
caso a variável não corresponda ao
último item do grupo. Do contrário,
sairá da instrução For-Each-Next
prosseguindo a execução da rotina na
linha de código abaixo do Next.
Coleções de objetos e objetos

Objetos são elementos caracterizados

por um conjunto de propriedades, e que
têm, subjacente, um determinado
comportamento. Por exemplo, uma
janela do Windows é um objeto,
caracterizada por um nome, um título,
uma dimensão, um posicionamento do
monitor etc. Ela possui um
comportamento inerente, pode ser
aberta, fechada, minimizada,
maximizada, escondida, redimensionada
etc.

Seguindo esta lógica, podemos

identificar alguns objetos do ambiente
de trabalho Windows: o botão, o
gráfico, o menu, o documento, a imagem,
a caixa de texto, a fórmula, o workbook,
a worksheet, a célula, o conjunto de
células de uma worksheet etc.

Nesta seção, vamos ver coleções de

objetos e objetos do contexto do Excel.
No capítulo seguinte, haverá, também,
dedicação exclusiva ao aplicativo
Excel. Entretanto, no último capítulo,
abordaremos o ambiente de VBA para
Access.

Objetos: propriedades, métodos e

eventos
• Propriedades: as propriedades dos
objetos são as características que os
definem, como, por exemplo, nome,
cor, dimensão, designação, valor
contido etc.;

• Métodos: os métodos traduzem o

comportamento de um objeto.
Representam procedimentos que
executam uma determinada tarefa, que
pode ser complementada mediante a
passagem de parâmetros;

• Eventos: eventos ou acontecimentos

representam todas as atividades que
envolvam o objeto e que, normalmente,
direta ou indiretamente, são disparadas
pelo usuário. Por exemplo, abrir ou
 fechar um workbook, clicar sobre um
botão ou worksheet, alterar o conteúdo
de um elemento etc. Estes eventos
servem para que possamos ativar uma
determinada tarefa quando da sua
ocorrência.

Objetos mais utilizados no Excel

Os objetos mais utilizados no Excel

são Application, WorkBook, WorkSheet
e Range. Vejamos com mais detalhes
como utilizá-los.

Application

É o objeto de topo na hierarquia,

representando o próprio Excel. Tem as
seguintes propriedades.

• Caption: texto exibido na barra de

títulos do Excel;

• DisplayAlerts: quando é True, as

mensagens de alerta são exibidas
durante a execução da sub-rotina;

• Path: caminho completo (disco, pasta

etc.) no qual o Excel está instalado;

• ScreenUpdating: quando True,

atualiza a tela assim que uma sub-
rotina é executada. Caso contrário, a
tela não é atualizada durante a
execução da sub-rotina;
 • Windowworksheetstate: trata do
estado da janela da aplicação, que
pode estar nos seguintes estados:

• xlNormal: janela com tamanho

normal;

• XlMaximized: janela com tamanho

maximizado;

• xlMinimized: janela com tamanho

minimizado.

• DisplayStatusBar: mostra ou esconde

a barra de estados;

• DisplayFormulaBar: mostra ou
esconde a barra de fórmulas.
 Os métodos do objeto Application são
os seguintes:

• Calculate: refere-se ao cálculo de

todas as fórmulas de todas as
worksheets e workbooks abertos. Não
tem parâmetros;

• Help: exibe um tópico de um

determinado arquivo de ajuda. Tem os
seguintes parâmetros:

• xelpfile: nome do arquivo, incluindo

o path, se necessário;

• Helpcontextid: número que faz

referência ao índice de ajuda.
• Quit: fecha a aplicação Excel. Se a
propriedade DisplayAlerts estiver com
o valor False, o Excel não irá efetuar a
gravação de alterações nos arquivos
abertos. Não tem parâmetros;

• Run: utilizado para executar uma sub-

rotina de VB, ou uma macro do Excel.
Contém os seguintes parâmetros:

• Macro: nome da macro ou sub-rotina

que será executada;

• argl:=<valor 1>, arg2:=<valor 2>...:

parâmetros de que a sub-rotina
necessita para ser executada.

WorkBook
 Na hierarquia de objetos, segue de
imediato o objetoApplication e
representa um arquivo do Excel.
Vejamos suas propriedades:

• Name: nome do arquivo. Não permite

alteração. Para isso, é necessário
proceder ao Save/As;

• Path: caminho em que o arquivo se

encontra;

• Saved: é True se não houve nenhuma

alteração no arquivo desde a última
gravação. Veja o exemplo para
verificar:
Os métodos para o objeto WorkBook
são os seguintes:
• Activate: ativa um documento aberto.
Equivale a ir ao menu Janela e
selecionar um documento aberto,
trazendo-o para a janela principal do
Excel. Não tem parâmetros;
• C1ose: fecha um documento. Tem os
seguintes parâmetros:
• SaveChanges: se True, o documento é
gravado antes de ser fechado;

• FileName: se o argumento
SaveChanges for True, o objeto é
gravado com o nome indicado;

• RoutWorkBook: se True, e se o
WorkBook tiver endereços para envio
atribuídos, envia o arquivo por e-mail
antes de fechar;

• Protect: protege um documento contra

qualquer tipo de alteração. Tem os
seguintes parâmetros:

• Password: a senha que será utilizada

na proteção;

• Structure: quando True protege

também a estrutura;

• WindoWorkSheet: quando True, a

 estrutura da janela é protegida.

• Save: grava o WorkBook. Não tem

parâmetros;
• SaveCopyAs: cria uma cópia do
documento desejado. Tem o seguinte
parâmetro:
• FileName: nome da cópia pretendida
para o arquivo.

WorkSheet

Na hierarquia, situa-se abaixo do objeto

WorkBook, uma vez que este é
constituído por um conjunto de
WorkSheet. Vejamos suas propriedades:
• Index: refere-se ao índice de uma
WorkSheet num WorkBook;

• Name: nome da WorkSheet;

• UsedRange: traduz o range que contém

dados;

• Visible: quando True, está visível. 0

usuário pode visualizá-

Ia indo ao menu Formatar. Em

XlVeryHidden, está escondida e
ninguém a pode visualizar, a menos que
volte a aplicar uma subrotina que a
coloque visível.

Os métodos para esse objeto são os

seguintes:
• Activate: ativa uma determinada
WorkSheet. Não tem parâmetros;

• Calculate: efetua o cálculo de todas as

fórmulas constantes.

Não tem parâmetros;

• Delete: apaga uma planilha da pasta de

trabalho;

• Protect: protege uma WorkSheet contra

qualquer tipo de alteração. Tem os
seguintes parâmetros:

• Password: senha que será utilizada na

proteção;
 • DrawingObjects: se True, protege os
objetos gráficos;

• Contents: se True, protege as células

e conteúdos;

• Scenarios: se True, protege os

cenários da planilha;

• UserlnterfaceOnly: se True, protege

as interfaces contra alterações, apesar
de poder alterar as sub-rotinas.

• Celi: faz referência a uma célula,

mediante seus índices numéricos. Tem
dois parâmetros:

• Número da linha;
 • Número da coluna.

Range

Objeto utilizado para representar uma

ou mais células de uma WorkSheet. Este
objeto tem as seguintes propriedades:

• Count: número de células num

intervalo. Read-Only;

• Dependents: retorna um range, que

contém todos os dependentes (valores
indexados pelas fórmulas) do range em
questão. Read-Only;

• Name: nome de um range.

 Read/Write;

• Value: valor constante de um range

(célula ou conjunto de células).
Read/Write;

• Formula: retorna a fórmula contida

num range como uma string.
Read/Write;

• Text: busca o conteúdo de uma célula,

porém, em formato de texto.

Os métodos para esse objeto são os

seguintes:

• Calculate: executa o cálculo da

fórmula constante. Não tem
 parâmetros;

• ClearContents: apaga o conteúdo

(fórmulas e valores) de uma célula,
mantendo os formatos. Não tem
parâmetros;

• copy: copia o conteúdo de um

intervalo para outro de igual dimensão,
ou, então, para o clipboard. Tem o
seguinte parâmetro:

• Destination: range para o qual os

valores vão ser copiados (na ausência
deste parâmetro a cópia é feita para o
clip,board).

• offset: provoca um deslocamento de

um determinado número de linhas e de
colunas, tendo como base o range ao
qual este método é aplicado. Tem dois
parâmetros:

• Rowoffset: número de linhas que se

deslocam;

• columnoffset: número de colunas que

se deslocam.

• EntireRow: faz referência à(s) linha(s)

indicadas por um determinado range.
Não tem parâmetros;

• Select: seleciona o range em questão.

Contém somente o seguinte parâmetro:
 • Replace (Opcional).

• ce11: faz referência a uma célula, por

meio dos seus índices numéricos.
Contém os seguintes parâmetros:

• Número da linha;

• Número da coluna.

Objetos singulares vs. coleções de

objetos

Um objeto singular refere-se a um

único objeto, que pode ser referenciado
pelo nome.

As coleções de objetos constituem

conjuntos de objetos singulares
referenciados pelo índice que os
identifica na coleção.

As coleções de objetos também podem

ser consideradas objetos. WorkBooks
("Bookl.XLS") é um conjunto de objetos
do tipo WorkSheet, mas também é um
objeto do tipo WorkBook.

Indexação de coleções por número ou

nome

Quando temos uma coleção de objetos

e é necessário identificar cada um dos
diferentes itens que a compõe, por
analogia podemos mencionar o exemplo
do array. Este é uma variável plural,
dado que é composto por um conjunto de
variáveis. Quando se pretende acessar
uma posição do array, utiliza-se o nome
do array e o índice da posição
requerida.

Assim, a indexação de coleções pode

ser realizada com base:

• em números; ou

• em nomes.

Veremos ambos os tipos a seguir.

Indexação com base em

números
 Os números prendem-se com a ordem
pela qual o objeto está inserido na
coleção (começa em um). Vejamos o
exemplo:

Indexação com base no

nome

Seleciona um objeto numa coleção

pelo nome associado a esse objeto.
Vejamos:

A grande vantagem de usar nomes é o

fato de não ser necessário saber a ordem
pela qual o objeto foi inserido na
coleção.

Referência implícita

Referências a uma célula da planilha

podem ser feitas de diversas formas
equivalentes. No exemplo seguinte, é
exibida a equivalência entre a expressão
mais completa e a mais reduzida, sendo
que ambas têm a mesma função (colocar
na célula Al o valor um):

A diferença entre ambas as formas de

acesso está no fato de a segunda forma
(Range ("Al") Value = 1) admitir que já
estamos trabalhando na pasta de
trabalho e na planilha, nesse momento
ativas no Excel, enquanto na primeira
forma são indicadas as referências
identificadoras da pasta de trabalho e da
planilha, na qual se pretende trabalhar.
Assim, podemos afirmar que a segunda
forma faz uma alusão implícita à
aplicação, ao workbook e à worksheet
em que se trabalha.

Declaração implícita da aplicação

Para fazer a alusão implícita da

aplicação, basta não a indicar, e, por
padrão, o Excel assume que já estamos
trabalhando no seu contexto:
Declaração implícita da pasta de
trabalho

Omitir a referência ao workbook é

semelhante a assumi-lo como ambiente
de trabalho, ativo. Neste contexto, as
expressões indicadas assumem, por
padrão, que já estamos trabalhando no
Excel e no workbook, neste momento
ativo:

Declaração implícita da planilha

0 mesmo se aplica no que toca às

worksheets:
Considerações finais

Neste capítulo, vimos os comandos de

decisão e controle de fluxo de execução.
Com eles, podemos elaborar aplicativos
com menos repetição de código, mais
poderosos. É importante que o leitor vá
executando cada exemplo, para que
fique mais bem fixada a sintaxe de cada
comando passado.

0 leitor ainda deverá incrementar os

exemplos para ficar mais familiarizado.
Assim, perceberá se realmente aprendeu
o que foi passado. No capítulo seguinte,
teremos exemplos de como trabalhar
com VBA no Excel. Dessa forma,
esperamos que seja mais fácil para o
leitor contextualizar os comandos
aprendidos neste capítulo.
Introdução

Programas aplicativos para

automatização de processos de cálculo
são conhecidos como planilhas
eletrônicas. Surgiram no final da década
de 1970. Hoje, existem centenas, talvez
milhares, de programas que pertencem a
esta classe e o Excel, ferramenta
proprietária da Microsoft, é um deles.
 As planilhas eletrônicas são programas
que se assemelham a uma folha de
trabalho, na qual podemos colocar
dados ou valores em forma de tabela e
aproveitar a grande capacidade de
cálculo e armazenamento do computador
para conseguir efetuar trabalhos que,
normalmente, seriam resolvidos com
calculadora, lápis e papel.

0 Microsoft Office Excel foi criado

para prover recursos gráficos ao
usuário, o que nem sempre foi um ponto
forte das planilhas convencionais.
Assim, a ferramenta pode facilitar e
auxiliar o usuário em diversas tarefas,
como folha de pagamento, contabilidade
de uma empresa, controle de compras,
análise de investimentos, contas a
pagar/receber, controle de estoque,
plano de vendas, dentre outros.

0 Excel dispõe de um conjunto variado

de funções preprogramadas (estatística,
data e hora, matemática e trigonometria,
finanças, pesquisa e referência, bases de
dados, texto, lógica e informação) que
podem ser utilizadas para executar os
mais diversos cálculos.

No entanto, existem funções não

contempladas e que, por vezes, os
usuários gostariam de aplicar na
realização de seus cálculos usuais.
Neste contexto, permite-se o
desenvolvimento de funções
personalizadas com o VisuaiBasic
forAppiications (VBA).

Portanto, neste capítulo,

apresentaremos alguns conceitos
relacionados com a utilização de VBA
no Excel, mostrando exemplos práticos
de como utilizar essa ferramenta para
aumentar a produtividade das tarefas do
dia-a-dia.

Planilhas eletrônicas e o Excel

Em 1978, um aluno da Escola de

Administração da Universidade de
Harvard (Daniel Bricklin) percebeu que
seu mestre de finanças gastava muito
tempo para modificar e realizar, no
quadro negro, novos cálculos. Os dados
de tais cálculos estavam dispostos em
colunas e linhas, criando, desta forma,
uma tabela; quando ele alterava uma
variável, todos o dados a ela referentes
deveriam ser igualmen te atualizados.
Neste momento, o professor tinha de
calcular cada fórmula, o que provocava
demasiada demora.

Bricklin, juntamente com seu amigo e

programador Robert Frankston, elaborou
um programa que simulava o quadro
negro do professor. Tratava-se da
primeira planilha eletrônica. Fundaram a
empresa VisCorp, e o produto
desenvolvido chamava-se VisiCalc.
 Naquela época, os micros eram vistos
como brincadeira, ou hobbies, e suas
vendas cresciam muito pouco.
Entretanto, com o VisiCalc, houve um
repentino crescimento nas vendas, pois
percebeu-se que ele poderia ser
utilizado para assuntos mais sérios e
práticos do cotidiano.

Não havia apenas o VisiCalc; após ele

surgiram outros programas de planilhas
eletrônicas disputando espaço num
mercado em grande expansão. Em 1983,
ocorreu o lançamento de um programa
integrado chamado 1.2.3, criado pela
empresa Lotus Development
Corporation, hoje pertencente à IBM. 0
1.2.3, além de ser planilha, gerava
gráficos e tratava os dados como uma
ferramenta de base de dados. Desbancou
o VisiCalc da sua posição de líder.

Nos anos 1980, a Lotus seria a líder de

mercado, concorrendo com outras
planilhas (SuperCalc, Multiplan e
Quattro Pro). Nos idos de 1990, foi
lançado o MS-Windows pela Microsoft
e, em seguida, surgiu uma planilha
eletrônica integrante deste ambiente
(Excel 3.0), que se tornou líder em seu
segmento, mesmo concorrendo com os
posteriores, Quattro Pro para Windows
e Lotus 1.2.3 para Windows.

Hoje em dia, o Microsoft Excel é a

planilha eletrônica mais utilizanda em
todo o mundo.

Uma planilha eletrônica nada mais é

que uma folha de cálculo disposta em
forma de tabela, na qual poderão ser
efetuados rapidamente vários tipos de
cálculos matemáticos, simples ou
complexos. De acordo com uma
filosofia matricial, pode ser utilizada
por qualquer pessoa de qualquer setor
profissional que tenha no seu trabalho a
necessidade de efetuar cálculos
financeiros, estatísticos ou científicos.

A planilha eletrônica é o software que

impulsionou e revolucionou o mercado
da informática. Em sua evolução, a
humanidade sempre tentou criar
ferramentas para suprir necessidades
que apareciam em seu caminho. Com a
planilha eletrônica não foi diferente. A
planilha eletrônica do Microsoft Excel
está caracterizada como um dos mais
importantes aplicativos para uso em
microcomputadores. 0 nome Excel vem
da abreviatura da palavra excelent, ou
seja, exce lente. 0 termo Excel, em
inglês, significa primar, superar,
sobrepujar, ser superior.

0 Excel é uma planilha eletrônica

capaz de executar cálculos, funções
gráficas e de banco de dados, além de
diversas outras atividades. No nosso
dia-a-dia, podemos construir uma
planilha no Excel para controlar o
extrato bancário, as notas escolares de
nossos filhos, o estoque da empresa, as
despesas e receitas de nossa casa ou
empresa, o pagamento de funcionários, e
muito mais.

Assim, uma planilha eletrônica é uma

folha de cálculos desenvolvida no
computador, constituída por linhas e
colunas. A intersecção de uma coluna
com uma linha é chamada de célula, na
qual são armazenados dados, fórmulas e
funções. Existem milhares de células
disponíveis na planilha. As linhas são
identificadas com números no canto
esquerdo da tela, indo de 1 a 65.536. Ou
seja, em cada planilha podemos ter até
65.536 linhas. As colunas são
identificadas por letras de A a Z, e,
depois, por combinações de letras (AB,
AC etc.) até o total de 256 colunas. Por
fim, as células consistem na unidade de
uma planilha na qual você pode inserir e
armazenar dados. Você pode inserir em
uma célula um valor constante ou uma
fórmula. Um valor constante é,
normalmente, um número (incluindo data
ou hora) ou texto, mas pode também ser
um valor lógico ou valor indicando erro.

É fácil copiar ou mover células, além

de modificar qualquer fórmula criada. 0
Excel permite a organização de seus
dados, o que gera inclusive bancos de
dados e gráficos com tudo o que foi
elaborado.
 Em geral, informações pertencentes a
uma mesma categoria são digitadas em
uma dada coluna (a coluna A é a
descrição do produto vendido, a coluna
B é o valor unitário, e assim por diante),
mas essa estrutura não é rígida: você
pode agrupar as informações por linha
ou por formas mais convenientes para
seu caso. A possibilidade de usar
fórmulas é o que diferencia um
programa de planilha de uma
calculadora. Quando colocamos uma
fórmula em uma célula, indicamos que o
conteúdo dessa célula deve ser
calculado em função dos valores
contidos em outras células.

A seguir, analisaremos com mais

profundidade um dos recursos
disponibilizados no Excel, o Visual
Basic forApplication (VBA).

VBA no Excel

0 VBA é derivado do Visual Basic,

também da Microsoft. 0 Visual Basic é
um ambiente de desenvolvimento
completo, no qual pode mos criar
programas para o ambiente Windows.
Tanto um programa comercial para
controlar estoque de mercadorias quanto
um aplicativo de folha de pagamento
poderiam ser desenvolvidos utilizando o
Visual Basic.

Por outro lado, o VBA é uma

linguagem bastante poderosa, embora
não seja tão completa quanto o Visual
Basic para criação de aplicativos e
automação de tarefas baseadas nos
aplicativos do Microsoft Office:
Access, Word, Excel, PowerPoint e
Outlook. Assim sendo, este capítulo
apresentará a utilização de VBA no
Excel e, no próximo capítulo, serão
apresentados conceitos de VBA no
Access.

Em outras palavras, o VBA possui a

função de criar uma intersecção entre
produtos Microsoft e Visual Basic,
visando a fornecer um maior poder de
programação para desenvolvedores.
Com isso, é possível criar funções que
possam auxiliá-los na utilização de
planilhas do Excel, automatizando
diversas tarefas que ainda não são
disponibilizadas neste aplicativo.

Existem, basicamente, duas situações

diferentes em que podemos utilizar o
VBA:

• como resposta a um evento: o modelo

de programação do ambiente Windows
é baseado em eventos. Um evento é
uma ação do usuário ao utilizar o
teclado ou o mouse. Por exemplo,
quando o usuário clica em um botão de
comando é gerado o evento "Ao clicar"
associado a este botão. Quando o
usuário altera o valor em um campo de
dados e pressiona a tecla Tab para ir
ao próximo campo, são gerados dois
eventos associados ao campo
atualizado: "Após atualizar" e "Ao
perder o foco". Quando o usuário dá
um clique duplo em um determinado
elemento, é disparado o evento "Ao
clicar duas vezes", e assim por diante.
Por padrão, nenhuma ação é
programada para responder aos
eventos que são disparados. Assim, é
possível criar macros (programas
desenvolvidos pelo usuário que contêm
uma lista de instruções e realizam uma
determinada função) que serão
executadas em resposta a um
determinado evento. Podemos utilizar
o VBA para criar uma função (formada
por um ou mais comandos) que será
executada em resposta ao evento. Por
exemplo, podemos criar um
procedimento para validar um número
de CPF (calcular o DV do CPF). Este
procedimento pode ser configurado
para ser executado em resposta ao
evento. Após atualizar o campo CPF, o
código criado para ser executado em
resposta a um evento é gravado junta
mente com a tabela ou célula na qual
está o elemento que dispara o evento;

• criação de sub-rotinas e funções em

módulos separados: se quisermos criar
sub-rotinas ou funções que não estejam
ligadas a um evento específico em uma
 célula ou tabela (sendo possível,
porém, chamá-los em diversos eventos
diferentes), podemos criar funções
gravadas em módulos do Excel. Um
módulo é um objeto do Excel cuja
finalidade é armazenar códigos de sub-
rotinas e funções do VBA. Quando um
procedimento ou função é definido e
armazenado em um módulo, podemos
usá-lo em qualquer expressão como se
fosse uma função interna do Microsoft
Excel.

Uma sub-rotina, função ou módulo do

VBA é uma seqüência de comandos
executados para a realização de uma ou
mais tarefas (macro). Por exemplo,
posso escrever um grupo de comandos
que acessa os dados da tabela Pedidos e
aumenta o valor de um determinado
campo de acordo com determinadas
condições. Tome-se como exemplo a
função sui, que recebe por parâmetro um
conjunto de valores que se pretende
somar, e cujo resultado da aplicação
consiste no conjunto de valores do
respectivo somatório.

0 Excel fornece um ambiente de

programação bastante poderoso, com
uma série de recursos que facilitam a
criação de código VBA. Se não
tivéssemos disponível um ambiente de
programação, teríamos que lembrar a
sintaxe de todos os comandos, dos
métodos e propriedades dos objetos.
Convenhamos que isso é praticamente
impossível, pois com o VBA temos
acesso a milhares de objetos. Cada
objeto pode ter dezenas de
propriedades, métodos e coleções. 0
ambiente de desenvolvimento fornece
uma série de facilidades enquanto
criamos nosso código VBA. Por
exemplo, ao digitar o nome de um objeto
e um ponto; será aberta,
automaticamente, uma lista com todos os
métodos e propriedades deste objeto.
Ao invés de lembrar o nome dos
métodos/propriedades, basta selecioná-
los em uma lista. Se selecionarmos um
método, ao digitarmos o parêntese de
abertura, será exibida uma lista com os
argumentos esperados pelo método, bem
como o tipo (texto, número, data etc.) de
cada argumento. Se digitarmos um
comando incorretamente, o ambiente de
desenvolvimento emite uma mensagem e
coloca em destaque o comando digitado
de forma errada. Estas são apenas
algumas das facilidades fornecidas pelo
ambiente de desenvolvimento do VBA.
A Figura 4.1 apresenta o ambiente de
programação VBA no Excel:
 Figura 4.1: Ambiente de programação
VBA no Excel.

Como podemos ver, o ambiente de

programação é dividido em três áreas:

• (1) Project Explorer: nesta janela,

 você poderá visualizar a hierarquia
dos projetos de VBA ativos nesse
momento;

• (2) Properties Window: nesta janela

é possível visualizar e alterar as
propriedades que definem cada objeto;

• (3) Janela de edição de texto: a

janela de edição exibirá, a cada
momento, o código em VBA associado
ao elemento selecionado na janela
Project Explorer.

A seguir veremos maiores detalhes de

criação e desenvolvimento de macros
utilizando o VBA.
Funções e sub-rotinas

Quando gravamos uma macro no Excel,

este trabalha com um comportamento em
background, que realiza a respectiva
codificação para VBA. Este resultado é
bem visível quando procedemos à
edição de uma macro no editor de VBA.
Cada macro que se cria tem um
comportamento concreto e autônomo, e
tem como objetivo executar um
determinado número de instruções que
correspondam às exigências do usuário
(as explicações sobre como gravar uma
macro encontram-se no Capítulo 1).

Cada macro criada dá origem a uma

rotina. Existem dois tipos de rotinas: as
sub-rotinas e as funções. Basicamente,
as sub-rotinas são designadas pelos
nomes que lhe atribuímos, e não
recebem parâmetros externos. Já as
funções são identificadas pelos nomes e
pelos tipos de parâmetros recebidos, e
têm como objetivo executar um conjunto
de instruções, produzindo um valor
final. A seguir, um exemplo de sintaxe
de sub-rotina e de função:
 Para criar uma sub-rotina, basta ir ao
editor do VBA (Figura 4.1) e
desenvolver a sub-rotina utilizando a
sintaxe apresentada anteriormente. Para
executar uma sub-rotina, pode-se utilizar
os mesmos conceitos vistos em macros,
uma vez que os dois conceitos são
definições para a mesma realidade.
Entretanto, uma é feita automaticamente
e outra é programada pelo usuário. Uma
diferença básica, aqui, é que existe a
possibilidade de executar as macros ou
sub-rotinas dentro de outras rotinas, ou
seja, quando se escreve dentro de uma
rotina o nome de outra, a execução da
rotina tem continuidade na execução da
que será invocada.
 Por outro lado, uma função pode ser
executada de duas maneiras: dentro de
uma célula de uma tabela, semelhante a
qualquer outra função do Excel, ou
dentro de qualquer outra função ou sub-
rotina.

No primeiro caso, definiremos uma

função chamada calculo - Salarial, na
qual será calculado o salário líquido de
uma pessoa. Supondo que os valores de
INSS e de IR são definidos pelo usuário,
teríamos os seguintes parâmetros:
salario _ bruto, inss e ir. A Figura 4.2
apresenta a função desenvolvida:
 Figura 4.2: Exemplo de
desenvolvimento de uma função.

Após isso, é necessário salvar a função

(ou macro) e, assim, ela estará pronta
para ser utilizada em qualquer célula da
planilha. Para tanto, posicione o mouse
na célula em que deseja inserir a função.
Após isso, acesse o menu Inserir >
Função, que abrirá uma janela para
seleção da função que deseja inserir.
Selecione a categoria Definida pelo
usuário e, logo após, selecione a macro
Calculo - Salarial. Com isso, você
estará atribuindo uma função especifica
à célula selecionada, como é
apresentado na Figura 4.3:

Figura 4.3: Selecionando a função

Calculo_Salarial.
 Após clicar em OK, uma janela será
aberta para que o usuário possa entrar
com os valores dos atributos definidos
previamente, ou seja, Salario_bruto, Inss
e Ir (Figura 4.4). Assim, após a
definição dos valores de cada atributo, a
célula selecionada conterá o valor real
do salário líquido de determinada
pessoa. Com isso, o cálculo do salário
foi automatizado e pode-se ganhar tempo
no desenvolvimento de, por exemplo,
uma folha de pagamento de uma
empresa.

Assim, vimos até aqui como criar e

executar uma função definida pelo
usuário e inseri-la em uma célula
específica de uma tabela do Excel, para
que possamos criar relatórios de forma
automatizada:
Figura 4.4: Definição dos valores para a
função.

Já o segundo caso, no qual a função

pode ser executada dentro de uma sub-
rotina, a execução da primeira passa
para a execução daquela que será
invocada. Assim, a Figura 4.5 apresenta
uma macro que solicita três valores ao
usuário por meio do comando InputBox
(",) e recebe o valor digitado pelo
usuário nas variáveis inteiras definidas
previamente (Valori, Valore e Valora).
Após isso, a subrotina chama a função
de cálculo do salário, que calcula o
salário e retorna para a sub-rotina o
valor do salário líquido do empregado:
 Figura 4.5: Exemplo de sub-rotina
chamando uma função.

As funções são similares às sub-

rotinas, porém, existem três diferenças:

• as funções começam com a palavra-

 chave Function e terminam com as
palavras End Function;

• as funções podem ser chamadas a

partir de fórmulas introduzidas numa
célula;

• as funções retornam valores para as

fórmulas ou sub-rotinas que as
chamarem.

Com isso, apresentamos as principais

diferenças entre sub-rotinas e funções a
partir de um exemplo prático no Excel.
A próxima seção apresentará exemplos
mais elaborados de macros, ou sub-
rotinas, e funções que podem ser
utilizadas para automatizar certas
tarefas.

Exemplos de utilização

Esta seção apresentará três exemplos

da utilidade do VBA para facilitar e
automatizar certas tarefas no Excel.
Primeiramente, apresentaremos um
conversor de moedas. Depois,
demonstraremos como podemos
automatizar a folha de pagamentos
utilizando o VBA.

Conversor de moedas

Vamos, agora, criar uma pequena

calculadora para converter moedas.
Para isso, digite a tabela de conversão a
seguir em uma planilha vazia:

Tabela 4.1: Conversão de moeda.

A idéia é oferecer duas opções para a

conversão (DE/PARA) e também um
valor, que será convertido (por exemplo,
100 de US$ para Euro € é igual 100 *
0,72, resultando em € 72). Na Figura
4.6, as listas de opções DE/PARA são
dadas na forma de conjuntos de botões
de rádio. 0 valor a ser convertido é
dado via InputBox, e o resultado deve
ser escrito em uma MsgBox, após clicar
o botão CONVERTER:

Figura 4.6: Tela do conversor de

moedas.
 Inicialmente, devemos montar os
conjuntos de botões de rádio. Para que
eles funcionem como dois conjuntos
independentes de botões, cada elemento
dos grupos de botões (grupo DE e grupo
PARA) deve ter sua propriedade
GroupName distinguindo-os (os botões
do grupo DE devem ter um GroupName
e os do grupo PARA, outro). No
exemplo indicado, os quatro
OptionButton da categoria DE foram
inseridos em um GroupName e os outros
quatro OptionButton da categoria PARA
foram inseridas em outro GroupName.
Com isso, o usuário consegue selecionar
um dos quatro OptionButton da categoria
DE e, depois, um dentre os quatro
OptionButton da categoria PARA.

Após isso, resta implementar o código.

Aqui, trabalharemos com o conceito de
variável global, um valor que pode ser
acessado por qualquer procedimento
dentro de um mesmo projeto (grupo de
procedimentos). Criaremos duas
variáveis globais (De e Para), para
armazenarmos os tipos de moeda que
desejamos converter, o que também
indica a linha e a coluna na tabela de
conversão que devemos utilizar. Por
exemplo, se selecionarmos DE e depois
US $, a variável De assume valor 1, se
selecionarmos DE e depois yen, ela
receberá valor 2, e assim por diante.
 Para atribuir esses valores às variáveis
globais, é preciso atuar no evento Click
de cada um dos botões de rádio. 0
trecho a seguir mostra como associar os
botões DE à variável global De. Repare
que, no início do código, as variáveis
globais estão definidas fora dos
procedimentos, de modo que elas podem
ser acessadas por todos. Na seqüência,
devemos fazer o mesmo para os botões
de rádio do grupo PARA, alterando a
variável Para.

Quando o usuário seleciona um botão

de rádio, devemos atribuir algum valor
que o identifique para que possamos
fazer os cálculos da conversão. Assim,
ao primeiro botão de rádio relativo a
DE iremos atribuir o valor 1, ao
segundo, valor 2, e assim por diante. A
mesma coisa foi feita em relação aos
botões de rádio relativos a PARA; o
primeiro recebendo 1, e assim por
diante.

Finalmente, falta escrever o

procedimento do botão CONVERTER.
Ele começa pedindo o valor a ser
convertido por meio de uma InputBox.
Depois, ele usa a função
(WorksheetFunction) Index para pegar o
valor certo na tabela de conversão.
Finalmente, retorna o produto do valor
pela taxa em uma MsgBox:
 Observe que as variáveis valor, taxa e
resultado são declaradas como número
real. A variável valor é obtida via
InputBox. A variável taxa é obtida com a
função Index, na qual são usadas as
variáveis globais De e Para (a tabela de
conversão está nas células de D4 até
G7, neste caso). A variável resultado,
por sua vez, é o produto (valor taxa), e é
escrito na MsgBox.

Após desenvolver as macros (ou sub-

rotinas), é necessário atribuir cada
comando definido no Excel para uma
macro. Assim, basta clicar com o botão
direito do mouse sobre cada
optionButton e selecionar a opção
Atribuir Macro. Depois, basta
selecionar as respectivas macros
criadas e fazer a mesma coisa para o
botão CONVERTER, escolhendo a
macro commandButtonlclick para ele.

Com isso, temos um programa que

realiza conversões de moedas, no caso,
para US $, Euro €, Yen Y e Libra UK.
Porém, é possível estender esse
programa para todos os tipos de moedas
de forma bem simples e prática.

Folha de pagamento

Agora, apresentaremos um exemplo de

automatização de uma folha de
pagamento. A priori, consideraremos
apenas cinco tipos de informações.
Contudo, isto não impede a extensão do
programa, inserindo mais atributos para
deixá-lo compatível com uma
determinada empresa, com o aumento de
impostos, e com detalhes como nome do
funcionário, salário bruto, Imposto de
Renda (IR) a ser deduzido, INSS e
salário líquido.

Para a base de cálculo do Imposto de

Renda (IR), iremos nos referir à seguinte
tabela:

Tabela 4.2: Base de cálculo do imposto

 de renda.

Para calcular o valor relativo ao INSS

será considerada uma taxa de 11% sobre
o salário bruto, relativo ao valor que
deve ser contribuído.

Definidos os dados necessários para

nossa aplicação, podemos começar a
implementá-la. Como veremos a seguir,
será necessário obter, apenas, o nome do
funcionário e o valor do salário bruto,
para, então, a macro em VBA fazer os
cálculos relativos ao IR, INSS e salário
líquido, além do cálculo total de todos
os valores relativos a todos os
funcionários. Outro aspecto interessante
é que podemos desenvolver formulários
para interação com o usuário, como
aqueles que podem ser produzidos em
ambientes de programação, como o
Visual Basic, Delphi, C++, dentre
outros. Assim, desenvolveremos alguns
formulários para facilitar a obtenção dos
dados junto com o usuário e inserir tais
valores na planilha, apresentada na
Figura 4.7:
Figura 4.7: Tela principal da planilha de
folha de pagamentos.

Como podemos ver na Figura 4.7,

possuímos três botões (e,
conseqüentemente, três macros) para
fazer a interação com o usuário. 0 botão
Inserir irá solicitar o nome e o salário
bruto do funcionário e, então, irá
calcular os outros campos e imprimi-los
na tela. 0 botão Alterar irá solicitar ao
usuário o nome do funcionário que
deseja alterar, para então realizar a
consulta na tabela, obter os dados e
apresentá-los, para que o usuário realize
a alteração. Já o botão Excluir irá
solicitar o nome do funcionário que
deseja excluir da planilha e, então,
buscar o funcionário e o remover da
planilha.

Primeiramente, precisamos declarar as

variáveis globais de que necessitaremos
e a ligação dos botões com os
formulários. Para isso, devemos
declarar as variáveis requeridas, que
seriam ligadas ao nome e ao salário
bruto do funcionário. Após isso,
devemos fazer a ligação dos botões ao
formulário, como mostrado a seguir:
 Isso feito, devemos criar os
formulários utilizando a caixa de
ferramentas disponibilizada pelo VBA.
Diversas opções de interface são
disponibilizadas para facilitar a vida do
desenvolvedor na hora de criar a parte
visual de suas aplicações. 0 modo de
criação é exibido na Figura 4.8:
 Figura 4.8: Ambiente de criação de
formulários.

Criados os três formulários (que não

divergem muito do apresentado na
Figura 4.8), podemos começar a
programar os botões definidos, pois
quando o usuário clicar em algum botão,
devemos ter implementado o que a
macro necessita fazer, para que
possamos inserir, alterar e excluir
funcionários da planilha.

Com isso, agora, veremos como foi

construído o formulário que será
apresentado na Figura 4.9. 0 TextBoxi e
TextBox2 são as caixas de texto que se
encontram no local em que serão lidos
os valores Nome, Idade e Numero,
respectivamente. Uma vez clicado o
botão Incluir, os valores são lidos da
seguinte maneira: funcionario.nome e
funcionario.salariobruto. No passo
seguinte, atribui-se o valor introduzido
pelo usuário às respectivas variáveis. 0
incremento da variável nalunos destina-
se a indicar a próxima linha de escrita
na planilha. Após isso, indica-se a
célula na qual deve ser escrito cada
valor e realizados os cálculos relativos
ao IR, INSS e salário líquido. Então,
calcula-se o total relativo a cada
atributo de funcionário, imprimindo-se
na tabela. Por fim, caso o usuário clique
no botão Fechar, é chamada a sub-rotina
Button _ Fechar(), que fecha o
formulário em questão:
 Agora, apresentaremos o código
relativo ao botão Consultar. Para
encontrarmos o funcionário que
desejamos alterar, em primeiro lugar,
precisamos confirmar sua existência na
planilha em questão. Assim, se faz
necessário informar o nome do
funcionário que se deseja encontrar e,
após isso, procurar entre as células A2 a
A18, correspondentes aos cadastros com
nomes de usuários. Feita a busca, é
preciso exibir os dados para o usuário
(no caso, apenas nome e salário bruto) e
habilitar o botão para que ele possa
alterar e confirmar a alteração. Caso não
exista o funcionário desejado, o sistema
não exibe nenhuma mensagem de erro ou
de aviso, apenas não executa os
procedimentos:
 0 botão Alterar possui basicamente a
mesma estrutura de código do botão
Inserir, entretanto, ao invés de inserir um
novo usuário no final da linha, ele altera
os dados relativos ao funcionário
consultado, fixando o número da linha
da célula no VBA. Este algoritmo pode
ser visto a seguir:
 A Figura 4.9 apresenta o sistema com
alguns dados inseridos pelo usuário por
meio da macro Inserir e a caixa de
diálogo como forma do usuário inserir
novos dados. Podemos ver que o
sistema apenas solicita o nome e o
salário bruto do funcionário. Os outros
atributos são calculados pela macro,
além do cálculo do total relativo a cada
atributo:
 Figura 4.9: Macro com alguns dados
inseridos pelo usuário.

Com isso, percebemos a utilidade de

usar macros em conjunto com o Excel,
uma vez que novas funcionalidades
podem ser inseridas para a automação
de atividades cotidianas. A utilização de
VBA, como se pode ver, não é
complexa, visto o apoio ferramental (do
ambiente de programação) e do Visual
Basic, para a criação de formulários
personalizados.

Considerações finais

Este capítulo apresentou o conceito de

VBA e sua utilização no Microsoft
Excel. Diversos exemplos de utilização
prática de macros puderam ser
explorados como forma de mostrar os
ganhos que podemos ter com o auxílio
do VBA. Apresentamos também a
criação de formulários, ensinando o
leitor a fazê-los interagir com as
planilhas definidas no Excel, o que
integra (ainda mais) o usuário com as
planilhas.

Como é possível notar durante esse

capítulo, o VBA surgiu para auxiliar o
usuário no ganho de produtividade de
tarefas relacionadas a aplicativos do
Microsoft Office, neste caso, o Excel.
Com isso, diversas macros que o Excel
não contém embutidas podem ser
desenvolvidas, automatizando as tarefas
e aumentando a produtividade. No
capítulo seguinte, veremos exemplos do
desenvolvimento de macros para o
Access.
Introdução

Neste capítulo, apresentaremos alguns

conceitos relacionados ao Microsoft
Access e à linguagem VBA.
Primeiramente, vamos dispor alguns
conceitos a respeito de bancos de dados
e sistemas de gerenciamento de bancos
de dados, para contextualizar o leitor na
área da organização de informações. Em
seguida, será realizada uma seqüência
de atividades para demonstrar como
criar uma aplicação no Access
utilizando a linguagem VBA, bem como
para demonstrar como é feita a interação
entre um programa escrito em VBA e um
banco de dados do Access e seus
formulários.

Definições sobre SGBD e BD

Os termos Sistema Gerenciador de

Banco de Dados (SGBD) e Banco de
Dados (BD) muitas vezes são utilizados
como sinônimos. Entretanto, é
importante salientar que existe uma
diferença entre eles. Um banco de
dados, ou base de dados, são conjuntos
de dados com uma estrutura regular
capaz de organizar informações, que,
normalmente, são utilizadas para um
mesmo fim. Um BD é normalmente
mantido e acessado por meio de um
software conhecido como SGBD, que
tem como principal objetivo retirar da
aplicação cliente a responsabilidade de
gerenciar o acesso, a manipulação e a
organização dos dados. 0 SGBD
disponibiliza uma interface para que
seus clientes possam incluir, alterar ou
consultar dados de forma organizada,
segura e eficiente.

Um SGBD é um sistema extremamente

complexo, responsável pela
persistência, organização e recuperação
dos dados. As funções básicas que este
sistema deve disponibilizar são:

• Um modelo que defina a estrutura dos

dados armazenados no sistema. Os
modelos mais conhecidos são:
hierárquico, em rede, orientado a
objetos e relacional, no qual as
estruturas têm a forma de tabelas,
compostas por linhas e colunas. Vamos
detalhar o modelo relacional mais
adiante;

• Estruturas de dados otimizadas, que

possam manipular grandes quantidades
de informação;

• Uma linguagem que permita a

definição, atualização e consulta dos
dados armazenados na base de dados.
Geralmente, esta linguagem é dividida
em partes:

• Linguagem de Definição de Dados

(LDD), com comandos COMO
CREATE TABLE;

• Linguagem de Manipulação de Dados

(LMD), com comandos COMO
UPDATE e SELECT;

• Linguagem de Controle de Dados

(LCD), com comandos para controle
de acesso dos usuários do sistema,
como GRANT e REVOKE. A
linguagem padrão atualmente é o SQL
 (Structured QueryLanguage), ou
Linguagem de Consulta Estruturada,
que será estudada mais adiante.

• Um mecanismo transacional que

garanta a consistência, entre as
operações, dos dados armazenados.

Modelo relacional

0 modelo relacional é um dos modelos

de dados mais utilizados na atualidade.
Ele baseia-se no princípio de que todos
os dados estão armazenados em tabelas,
entidades, ou, matematicamente falando,
em relações. Sua definição é estruturada
na lógica de predicados e na teoria dos
conjuntos. Historicamente, este modelo
é o sucessor do modelo hierárquico e do
modelo em rede. Estas arquiteturas
antigas são, até hoje, utilizadas em
alguns data centers com alto volume de
dados, no quais a migração é
inviabilizada pelo custo que ela
demandaria. Existem ainda os novos
modelos baseados no paradigma de
orientação a objetos. 0 modelo
relacional foi desenvolvido por Edgar
Frank Codd e, subseqüentemente,
mantido e aprimorado por Chris Date e
Hugh Darwen como um modelo geral de
dados. Em um evento que foi chamado
de o Terceiro Manifesto (1995), eles
mostraram como o modelo relacional
pode ser estendido com características
de orientação a objeto sem comprometer
os seus princípios fundamentais:
 Figura 5.1: Exemplo de um modelo
relacional.

No modelo relacional, os dados são

armazenados em tabelas, entidades ou
relações. Tabelas, entidades ou relações
são formadas por atributos. A figura
anterior mostra um exemplo de banco de
dados conforme o modelo relacional.
Nesta figura, podemos perceber que foi
definida uma entidade chamada produto
contendo os atributos codigoproduto,
descricao, preco, quantidade e
_codigofornecedor._ Os atributos de
uma entidade também são, normalmente,
chamados de campo ou coluna. Também
podemos notar que a tabela fornecedor é
composta pelos atributos
codigo_fornecedor, nome e telefone. O
conjunto de valores atribuídos aos
campos, colunas ou atributos de uma
tabela é chamado de linha ou registro.

Em um banco de dados, existe o

conceito de chave primária. Chaves
primárias (em inglês Primary Keys ou
PK) referem-se a um dado campo ou
atributo, cujos valores nunca se repetem
e que podem ser usados como um índice
para os demais campos da tabela do
banco de dados. Nesta chave, não pode
haver valores nulos ou repetidos. As
chaves garantem a unicidade do registro.
Por exemplo, no banco de dados da
figura anterior, o campo de chave
primária da tabela produto é codigo
produto. Dessa forma, o produto
Impressora será identificado pelo
código de número dois; nenhum outro
produto terá este mesmo código.

As tabelas de um banco de dados

relacional podem ser interligadas ou
relacionadas mediante relacionamentos
definidos no momento da criação do
banco de dados. É neste ponto que entra
o conceito de chave estrangeira. Uma
chave estrangeira é um atributo ou
campo de uma tabela utilizado para criar
um relacionamento entre tabelas. Uma
chave estrangeira nada mais é que uma
chave primária pertencente à outra
tabela. Por exemplo, no banco de dados
da Figura 5.1, na relação produto, o
campo codigo_fornecedor é uma chave
estrangeira que faz o relacionamento
com a tabela fornecedor.

Ao definirmos relacionamentos, outro

conceito importante que surge é o de
integridade referencial. A integridade
referencial é utilizada para garantir a
integridade dos dados entre as tabelas
relacionadas. Por exemplo, considere
um relacionamento entre as duas tabelas
apresentadas na figura anterior. Com a
integridade referencial, o banco de
dados não permite que seja cadastrado
um produto de um fornecedor ainda não
cadastrado. Em outras palavras, ao
cadastrar um produto, o SGBD verifica
se o código do fornecedor digitado já
existe na tabela fornecedor. Se não
existir, o cadastro do produto não será
aceito.

No modelo relacional, os tipos de

relacionamentos existentes são:

• um-para-um (1..1): neste tipo de

relacionamento, um registro na tabela
A possui um único correspondente na
tabela B, e vice-versa;

• um-para-muitos (1..n): neste tipo de

relacionamento, um registro na tabela
A pode ter vários correspondentes na
tabela B. É o que acontece no
relacionamento entre as tabelas
produto e fornecedor do banco de
dados apresentado;

• muitos-para-muitos (n..m): quando

tabelas têm entre si uma relação n..m, é
necessário criar uma nova tabela com
as chaves primárias das tabelas
envolvidas, ficando assim uma chave
composta, ou seja, formada por
 diversos campos-chave de outras
tabelas. A relação então se reduz para
1..n, sendo que o lado n ficará com a
nova tabela criada.

A linguagem SQL

0 SQL foi desenvolvido originalmente

no início dos anos 1970 nos laboratórios
da IBM em San Jose, dentro do projeto
System R, que tinha por objetivo
demonstrar a viabilidade da
implementação do modelo relacional
proposto por Codd. 0 nome original da
linguagem era SEQUEL, acrônimo para
Structured Engllsh Query Language
(Linguagem de Consulta Estruturada em
Inglês).

Embora o SQL tenha sido

originalmente criado pela IBM,
rapidamente surgiram vários dialetos
desenvolvidos por outros fornecedores
de SGBD. Essa expansão levou à
necessidade de criar e adaptar um
padrão para a linguagem. Esta
padronização foi realizada pela
American Nationai Standards institute
(ANSI) em 1986, e pela ISO em 1987. A
especificação da linguagem SQL foi
revista em 1992 e a esta versão foi dado
o nome de SQL-92. Foi revisto
novamente em 1999 e 2003 para se
tornar SQL: 1999 (SQL3) e SQL: 2003,
respectivamente.
 A seguir, mostraremos os principais
comandos da linguagem SQL
necessários para criação de tabelas,
inserção, consulta e exclusão de
registros.

Criando tabelas com SQL

A sintaxe básica do SQL para a criação

de tabelas em um banco de dados é a
seguinte:

Como podemos analisar, na criação de

uma tabela em SQL, a definição de cada
coluna é separada por vírgula. Cada
coluna possui um tipo de dado e pode
conter um ou mais atributos. Os tipos de
dados e os atributos disponíveis para
uma coluna podem variar de um
fornecedor para outro. Entretanto, a
maioria das variações do SQL
disponibiliza todo o conjunto padrão de
tipos de dados e atributos definidos na
especificação da linguagem.

Alguns dos tipos de dados

disponibilizados pelo SQL para criação
de tabelas em um banco de dados são:

• VARCHAR, para armazenar dados do

tipo texto;
 • INT, para armazenar números
inteiros;

• DECIMAL, para armazenar números

decimais;

• DATE, OU DATETIME, para

armazenar dados do tipo data.

Dessa forma, segue um exemplo de

comando SQL para criar a tabela
fornecedor, do banco de dados
apresentado na Figura 5.1:
 De forma semelhante, a tabela produto
da Figura 5.1 pode ser criada da
seguinte forma:
 Na definição da tabela produto, o
campo preco foi definido Como
DECIMAL (5,2). Neste caso, 5
(precisão) representa o número de
dígitos decimais significantes
armazenados no valor, e 2 (escala)
representa o número de dígitos que
serão armazenados após o ponto
decimal. Assim como foi definida uma
chave primária para a tabela fornecedor,
em produto, definimos codigo _ produto
como chave primária. 0 diferencial
deste último comando SQL em relação
ao comando para a criação da tabela
fornecedor está na chave estrangeira e
na definição do relacionamento entre as
duas tabelas. A instrução
CONSTRAINT define o campo codigo _
fornecedor da tabela produto como
chave estrangeira (FOREIGN KEY),
fazendo referência ao campo codigo _
fornecedor da tabela fornecedor, criando
um relacionamento do tipo um-para-
muitos entre as duas entidades.

Inserindo dados na tabela

Na seção anterior, criamos o banco de

dados, mas não adicionamos registros
nas tabelas. Para a inserção de dados, a
linguagem SQL disponibiliza o comando
INSERT, que possui a seguinte sintaxe:

Para exemplificar a utilização do

comando INSERT, cadastraremos alguns
registros nas tabelas criadas
anteriormente:

0 comando anterior insere

um registro, ou linha, na
tabela fornecedor. É
importante notar que os
valores a serem inseridos
 nos campos são do tipo
texto e devem estar entre
aspas simples.

0 comando para inserir um registro na

tabela produto é o seguinte:

Como sabemos, o campo

codigofornecedor_ é a chave estrangeira
da tabela produto. Dessa forma, este
campo faz referência à tabela fornecedor
e o valor a ser inserido precisa estar
previamente cadastrado nesta tabela.

Recuperando dados do BD
 Para recuperar dados inseridos no
banco de dados, a linguagem SQL
oferece o comando SELECT. A sintaxe
deste comando é a seguinte:

Por exemplo, para recuperar os dados

cadastrados na tabela fornecedor,
podemos utilizar o seguinte comando:

Na linguagem SQL, o caractere

asterisco (*) pode ser utilizado para
referenciar todos os campos de uma
determinada tabela. Por exemplo, o
comando a seguir terá o mesmo efeito do
anterior:

Para selecionar campos de mais de

uma tabela por meio do relacionamento
definido com a chave estrangeira,
utilizamos o seguinte comando:

0 comando anterior recupera o código

(codigo_produto), a descrição
(descricao) e o preço do produto
(preco) da tabela produto e também o
nome do fornecedor que está na tabela
fornecedor. Em um comando SQL, para
informar a qual tabela pertence um
determinado campo, precede-se o nome
do campo com o nome da tabela, como,
por exemplo, a instrução
fornecedor.nome indica que o campo
nome pertence à tabela fornecedor.
Quando estamos recuperando dados de
mais de uma tabela, precisamos
adicionar uma restrição na cláusula
WHERE do comando SQL para
relacionar as tabelas e garantir que os
dados serão recuperados corretamente.
Assim, a instrução WHERE
produto.codigo_fornecedor=
fornecedor.codigo_fornecedor, utilizada
no comando anterior, garante que, para
cada registro da tabela produto, será
recuperado o nome do fornecedor
correspondente, que está sendo
referenciado pela chave estrangeira da
tabela produto.codigo fornecedor.

Em SQL, os nomes dos campos,

colunas ou atributos de uma tabela
podem ser renomeados no momento da
execução de um comando SELECT com
a utilização da instrução AS, conforme
mostra o comando a seguir:

Na cláusula WHERE de um comando

SQL, podemos adicionar inúmeras
restrições. Por exemplo, o comando a
seguir recupera somente os produtos do
fornecedor HP. Isto é realizado
adicionando a instrução AND LIKE `HP'
no final do comando. LIKE é um
operador para comparação de valores
do tipo texto. Os operadores lógicos
maior que (>), menor que (<), maior ou
igual (>=), menor ou igual (<=) e
diferente (<>) também podem ser
utilizados para especificar restrições na
cláusula WHERE. Por exemplo, para
selecionar somente os produtos com a
quantidade em estoque inferior a dez
unidades, teremos o seguinte comando:
Alterando dados cadastrados em uma
tabela

Para alteração de dados armazenados

em um banco, a linguagem SQL
disponibiliza o comando UPDATE. A
sintaxe deste comando é:

Dessa forma, se desejarmos alterar o

preço do produto de código 1 de 900,00
para 1000,00, utilizamos o seguinte
comando:
Excluindo dados de uma tabela

Outro comando importante da

linguagem SQL é o DELETE. Com este
comando, podemos excluir dados
armazenados em um banco de dados.
Sua sintaxe é:

Dessa forma, para excluirmos o

produto cadastrado no banco de dados
com o código 1, o comando SQL será:
O SGBD Microsoft Access

0 Microsoft Access é um Sistema

Gerenciador de Bancos de Dados
(SGBD) relacional. Ele foi
desenvolvido pela Microsoft e faz parte
do pacote Microsoft Office
Professional, sendo composto pelo
Microsoft Jet Database Engine, com uma
interface gráfica que facilita o
desenvolvimento de aplicações,
principalmente por usuários que não
possuem muitos conhecimentos de
bancos de dados, ou que estão iniciando
suas atividades nessa área. 0
desenvolvimento da estrutura de dados
se dá de forma muito intuitiva: basta que
o desenvolvedor possua conhecimentos
básicos em modelagem de dados e em
lógica de programação. Programadores
relativamente inexperientes e usuários
determinados podem usálo para
construir aplicações simples, sem a
necessidade de utilizar ferramentas
desconhecidas.

0 Access permite o desenvolvimento

rápido de aplicações que envolvam
tanto a modelagem e a estrutura de
dados como, também, a interface a ser
utilizada pelos usuários. 0 Access é
capaz de acessar dados armazenados em
outros SGBD compatíveis com a
tecnologia ODBC (Opera Data Base
Connectivity).
 Versões mais recentes do Microsoft
Access vêm acompanhadas da
linguagem VBA, com um ambiente de
programação próprio. Geralmente, uma
aplicação desenvolvida com o Access
por meio da linguagem de programação
VBA consiste em dois ambientes, um
que se denomina BackEnd, no qual
ficam armazenadas todas as tabelas com
seus respectivos relacionamentos, e
outro denominado FrontEnd, no qual
ficam armazenados os códigos-fonte,
formulários, módulos, consultas e
macros, encapsulados em um arquivo
com a extensão MDB. 0 código-fonte
pode ser compilado, mas não é possível
gerar um executável. Para rodar os
aplicativos desenvolvidos, é necessário
que o usuário possua em seu computador
o Access instalado ou, pelo menos, o
seu runtime, versão simplificada do
Access que será utilizada apenas para
rodar os aplicativos, sem a
possibilidade de desenvolvimento. Com
o Access, é possível desenvolver de
aplicações simples, como um cadastro
de clientes ou um controle de pedidos, a
aplicações mais complexas, como, por
exemplo, todo o controle operacional,
administrativo e financeiro de uma
pequena, média ou até mesmo de uma
grande empresa, pois os aplicativos
desenvolvidos podem ser configurados
para rodar em uma rede de
computadores e os dados armazenados
pelo sistema podem ser publicados na
intranet da empresa, ou mesmo na
Internet.

Criando um banco de dados no Access

Para demonstrar o funcionamento do

Access junto com a linguagem VBA,
construiremos uma aplicação utilizando
o Access versão 2002, em português.
Primeiramente, devemos criar o arquivo
MDB que armazenará todos os itens
relacionados com a aplicação em
desenvolvimento. Para isso, é
necessário abrir o Microsoft Access,
acessar o menu Arquivo e selecionar a
opção Novo. Ao selecionar a opção
Novo nesta versão do Access, deve
aparecer um menu ao lado direito da
janela, como nos mostra a Figura 5.2, no
qual será necessário selecionar a opção
Banco de dados em branco para criar
um novo banco de dados. Em seguida, é
necessário salvar o arquivo em algum
diretório no computador. Neste exemplo
de aplicação, daremos ao arquivo o
nome de bd access.mdb:
Figura 5.2: Criando um banco de dados
no Access.

Após salvar corretamente o novo

banco de dados, a área de trabalho do
Microsoft Access será apresentada. Ela
pode ser visualizada na Figura 5.3.
Nesta área de trabalho, na parte
superior, ficam os menus, e, ao lado
esquerdo, a relação de objetos que
podem ser criados no banco de dados,
como tabelas, consultas, formulários,
relatórios e macros. Do lado direito da
área de trabalho são apresentadas as
instâncias de cada objeto criado no
banco de dados:

Figura 5.3: Área de trabalho do

Microsoft Access.
 0 banco de dados que criaremos no
Access é o que foi apresentado na
Figura 5.1, na qual temos as tabela
produto e fornecedor, ligadas por um
relacionamento do tipo um-para-muitos.
Para isso, será necessário selecionar o
objeto Tabelas na lista ao lado esquerdo
da área de trabalho, e, em seguida,
selecionar a opção Criar tabela no modo
estrutura, que aparecerá na área ao lado
direito da tabela, conforme mostra a
figura anterior. A criação de tabelas no
modo estrutura, no Microsoft Access,
permite que os campos da tabela sejam
definidos e o tipo de cada campo seja
determinado.

Será necessário criar duas tabelas no

modo estrutura, a tabela produto e a
tabela fornecedor, com os mesmos
campos ou colunas apresentados na
Figura 5.1. O resultado final, após as
duas tabelas criadas, será semelhante ao
apresentado na Figura 5.4 (parte A). Um
ponto importante a ser lembrado é que,
ao final da criação de cada uma das
tabelas, o atributo ou campo chave
primária deve ser selecionado e a opção
Chave primária (cujo ícone se
assemelha a uma chave) do menu do
Access deve ser acionada para definir a
chave primária da tabela. Ao final da
criação das duas tabelas, a janela aberta
ao selecionar a funcionalidade de
criação de tabelas no modo estrutura
dever ser fechada, e a opção
Relacionamentos no menu Ferramentas
deve ser acionada para abrir o ambiente
para criação do relacionamento entre as
duas tabelas. As duas tabelas devem ser
adicionadas ao ambiente de criação dos
relacionamentos e a opção Editar
relacionamentos, do menu
Relacionamentos, deve ser selecionada
para abrir a caixa de diálogo que irá
criar a ligação entre as duas tabelas.
Nesta janela de configuração, deve ser
clicado o botão Criar novo, e então
definidas quais tabelas e campos serão
utilizados para criar a ligação. A
configuração correta é apresentada na
Figura 5.4 (parte B) e o resultado final,
com as tabelas relacionadas e a
indicação do tipo de relacionamento,
pode ser visualizada na Figura 5.4
(parte C):
 Figura 5.4: Criando tabelas e
relacionamentos.

Neste ponto, o banco de dados já está

criado, com as duas tabelas
relacionadas, e nas próximas seções
mostraremos como utilizar a linguagem
VBA para criar programas no Microsoft
Access e interagir com tabelas de um
banco de dados.

Criando procedimentos em VBA no

Access

Nossa primeira atividade será criar um

pequeno programa, para entender o
funcionamento da linguagem VBA no
Access. Assim, construiremos um
subprograma para exibir a mensagem
Olá Mundo!!. Para isso, selecione a
opção Módulos, na lista de objetos
localizada à esquerda na área de
trabalho do Access, e, em seguida,
clique no botão Novo, que será ativado
na parte superior da área de trabalho.
Após clicar no botão Novo, o ambiente
de programação VBA será ativado e
uma tela, semelhante à apresentada na
Figura 5.5, será exibida. Todos os novos
subprogramas serão digitados na área à
direita da janela. Dessa forma, para
criar nosso primeiro programa
utilizando VBA e Access, digite o
programa seguinte, de forma semelhante
à apresentada na figura a seguir. Quando
realizamos o procedimento descrito
anteriormente, estamos criando um novo
módulo, em que podem ser definidos
vários subprogramas ou procedimentos.
Para salvar o módulo criado, selecione
a opção Salvar do menu Arquivo e, em
seguida, escolha um nome para ele.
Neste exemplo o módulo será salvo com
o nome MeuPrimeiroModulo:

Figura 5.5: Ambiente de programação

VBA do Access.
 Perceba que as sentenças sub e End
sub aparecerão na cor azul quando
digitadas no editor VBA do Access,
indicando que estas são palavras
reservadas em VBA. Digitando o código
conforme indicado, estaremos criando
nosso primeiro procedimento ou
subprograma na linguagem VBA.
Observe que a estrutura de um
subprograma sempre será esta:

• começa com a palavra reservada Sub

seguida pelo nome do procedimento;

• as instruções relacionadas ao novo

procedimento são digitadas nas linhas
seguintes;
 • a instrução End Sub finaliza o
subprograma.

Para executar o procedimento criado,

selecione a opção Executar
Sub/UserForm do menu Executar, ou
simplesmente pressione a tecla F5. 0
resultado da execução será uma caixa de
mensagem com os dizeres Olá Mundo!!.
Caso o subprograma não seja digitado
cor retamente, algum caractere seja
inserido por descuido ou o nome de
alguma função seja digitada
incorretamente, o procedimento não será
executado e uma mensagem de erro será
exibida, indicando a linha que contém o
erro.
 0 segundo subprograma a ser criado é
para cálculo da média aritmética. Para
isso, digite as seguintes instruções no
editor VBA:

Neste subprograma, o usuário não

digitará as notas, mas atribuiremos
valores para cada uma delas logo após a
definição das variáveis notal, nota2 e
media, que são do tipo double. Ao
executar este programa, por meio do
menu Executar, ou pressionando a tecla
F5, uma mensagem será exibida com a
média final (neste caso, 7,5),
informando se o aluno foi aprovado ou
reprovado. Para relembrar, o caractere
& no VBA é utilizado para
concatenação, por isso é inserido neste
procedimento para montar a mensagem
final.

Para interagir com o usuário,

solicitando que ele digite o nome e as
notas do aluno, podemos escrever um
programa semelhante ao seguinte:
 Para facilitar o reuso de código e,
também, a depuração de programas em
caso de erro, é interessante criar
funções. Por exemplo, para
subprogramas listados anteriormente,
pode ser definida uma função com o
nome de CalculaMedia, que recebe duas
notas e retorna o valor do cálculo. Esta
função pode ser acionada de dentro de
qualquer outro subprograma criado no
módulo. 0 código para este caso seria
semelhante ao apresentado a seguir:

Integrando subprogramas com

formulários
 Agora que entendemos os princípios
básicos para a criação de um programa
utilizando a linguagem VBA no
MicrosoftAccess, faremos a integração
com formulários. De volta ao ambiente
de trabalho criado no tópico Criando um
banco de dados no Acess, apresentado
na Figura 5.3, será necessário selecionar
o objeto Formulários na lista localizada
no lado esquerdo da área de trabalho e,
em seguida, escolher Criar formulário
no modo estrutura. Com isso, uma tela
será exibida para criarmos, utilizando
componentes visuais, um formulário
para interagir com o código VBA. Salve
o formulário recémcriado com o nome
FormularioCalcularMedia e obedeça às
seguintes instruções para configurar sua
aparência:

1. Clicando com o botão direito do

mouse em qualquer área do formulário,
selecione a opção Propriedades (Figura
5.6) e altere as propriedades Legenda,
Barras de rolagem, Seletores de
registro, Botões de navegação e Linhas
divisórias, conforme mostra a figura
seguinte:
 Figura 5.6: Criando um formulário no
modo Estrutura.

2. Em seguida, utilizando a Caixa de

ferramentas do editor de formulários do
Access (Figura 5.7, parte A), escolha o
item Caixa de texto e adicione três
caixas de texto no formulário, de forma
semelhante à apresentada na figura.
Cada objeto adicionado ao formulário,
por meio da caixa de ferramentas,
precisa ser nomeado para facilitar a sua
utilização durante a escrita dos
programas. Então, para cada uma das
caixas de texto adicionadas ao
formulário, é preciso fazer as seguintes
modificações: clicar com o botão direito
do mouse sobre a caixa de texto e
selecionar a opção Propriedades (Figura
5.7, parte B) para exibir a lista de
propriedades do objeto. Em seguida, é
necessário alterar o valor de Nome
(Figura 5.7, parte C) para CaixaNotal. O
mesmo procedimento deve ser realizado
para alterar o nome da segunda caixa de
texto para CaixaNotal e da terceira
caixa para CaixaMedia:
 Figura 5.7: Configurando as caixas de
texto do formulário.

3. De forma semelhante, altere o rótulo

das três caixas de texto adicionadas,
clicando com o botão direito do mouse
sobre cada um dos rótulos e alterando o
valor da propriedade Legenda para Nota
1, do segundo rótulo para Nota 2,
inserindo Média no último rótulo.

4. Para completar o formulário, será

necessário adicionar dois botões, um
para limpar os campos da tela e outro
para executar o cálculo da média. Então,
utilizando a barra de ferramentas
exibida na Figura 5.8 (parte A),
adicione dois botões de comando
clicando no item Botão de comando. Ao
clicar em Botão de comando, se o
assistente de controle estiver ativado,
aparecerá uma tela semelhante à
apresentada na Figura 5.8 (parte B),
porém, para este exemplo não
necessitaremos de assistente de
controle, bastando clicar no botão
Cancelar.

S. De maneira semelhante à realizada

para alterar as propriedades das caixas
de texto e dos rótulos, será necessário
alterar a legenda dos dois botões de
comando adicionados ao formulário.
Para isso, é preciso clicar com o botão
direito do mouse sobre cada um dos
botões, escolher a opção Propriedades
(Figura 5.8, parte C) e, na lista de
propriedades, alterar o valor de
Legenda do primeiro botão para
calcular, o valor de Nome para
Botaocalcular, a legenda do segundo
botão para Limpar e seu nome para
BotaoLimpar, conforme exibido na
Figura 5.8 (parte D). Para finalizar a
interface gráfica, utilize o componente
Rótulo da caixa de ferramentas para
adicionar um rótulo no formulário,
posicionando-o ao lado direito da caixa
de texto da média e, em seguida,
acessando suas propriedades. Clicando
com o botão direito do mouse sobre ele,
altere o valor de Nome para
RotuloResultado. Este rótulo será
utilizado para exibir a mensagem
Aprovado caso a média seja igual ou
superior a sete, e a mensagem
Reprovado, caso contrário:
 Figura 5.8: Configurando os botões de
comando.

Agora que os componentes da interface

foram definidos, e as caixas de texto,
rótulos e botões nomeados,
construiremos o código VBA necessário
para realizar o cálculo da média. É
importante ressaltar que nesta aplicação
temos dois ambientes: a interface
gráfica, constituída pelo formulário e
seus componentes, e o código VBA, que
irá interagir com a interface para
recuperar os dados de entrada, realizar
os processamentos necessários e
devolver o resultado para ser exibido na
interface gráfica. Assim, começaremos
definindo o código do botão Calcular.

Clicando com o botão direito do mouse

sobre o botão, escolhendo a opção
Propriedades e, em seguida,
selecionando a aba Eventos, podemos
definir inúmeros eventos, especificando,
por exemplo, o que acontecerá quando o
mouse for posicionado sobre ele, ou
quando for clicado duas vezes, entre
outros. Para esta aplicação, o evento
utilizado será do tipo "Ao clicar", ou
seja, quando o usuário clicar no botão,
ele deverá recuperar os dados digitados
nos campos referentes às notas um e
dois, realizar o cálculo da média
aritmética e, em seguida, colocar o
resultado do processamento na caixa de
texto criada para exibir a média.

Para iniciar a definição do evento,

clique no botão com o rótulo ...
localizado ao lado direito do evento
requerido, conforme exibido na Figura
5.9 (parte A). Na janela que será
exibida na seqüência (Figura 5.9, parte
B), selecione a opção Construtor de
código e clique no botão OK. Com isso,
será exibido o mesmo ambiente de
programação VBA utilizado para criar
nosso primeiro programa, no tópico
Criando procedimentos em VBA no
Access. Como mostramos na Figura 5.9
(parte C), o código para o evento
requerido será:
Figura 5.9: Definindo o código do botão
Calcular.

Como podemos observar na Figura 5.9

(parte C), na primeira linha é definido o
nome do procedimento ou subprograma,
de forma semelhante à descrita no tópico
Criando procedimentos em VBA no
Access. Na segunda linha do
procedimento é criada uma variável do
tipo double, que armazenará o resultado
do cálculo da média. Na terceira linha, é
acionada a função calculaMedia, criada
no módulo MeuPrimeiroModulo,
definido em Criando procedimentos em
VBA no Access; ou seja, estamos
reutilizando o código escrito
anteriormente. Os valores passados
como parâmetro para a função
calculaMedia são os valores contidos
nas caixas de texto caixaNotal e
CaixaNota2. É importante salientar que,
para simplificar o código, não estamos
fazendo nenhum tipo de validação nos
campos, ou seja, se o usuário digitar um
texto como valor para a primeira nota,
ou para a segunda, um erro ocorrerá no
programa.

Com a execução da terceira linha do

subprograma, o valor da média
aritmética será armazenado na variável
m. Com a instrução CaixaMedia = m,
este valor será exibido na caixa de texto
cai xaMedia. Caso o valor do cálculo da
média seja igual ou superior a sete, a
propriedade caption do rótulo
RotuloResultado será alterado para
Aprovado com a instrução
RotuloResultado.Caption = "Aprovado".
A cor do texto que aparecerá no rótulo
será alterada para azul com a instrução
RotuloResultado.ForeColor = vbBlue.
Caso o valor da média seja inferior a
sete, a mensagem exibida no rótulo será
Reprovado e terá a cor vermelha,
conforme define o código na Figura 5.9
(parte B). Isso é possível, pois no VBA
as propriedades dos objetos podem ser
acessados por meio de um ponto (.),
após o nome do objeto, como ocorre no
paradigma de programação orientado a
objetos.

De forma semelhante, defina o código

para o botão Limpar da presente
aplicação. Para isso, realize a mesma
seqüência de atividades que resultaram
na implementação do botão Calcular. A
função do botão Limpar é simplesmente
limpar os campos relativos à primeira
nota, à segunda nota e à média. 0 código
será semelhante a este:

Ao finalizar a definição dos eventos,

podemos fechar o ambiente de
programação VBA e retornar para a área
de trabalho do Access. Ainda estamos
com o formulário
FormularioCalcularMedia no modo
estrutura; sua aparência é semelhante à
Figura 5.10 (parte A). Para rodar a
aplicação, basta selecionar a opção
Exibir modo formulário, no menu Exibir,
o que resultará em uma tela semelhante à
apresentada na Figura 5.10 (parte B). A
Figura 5.10 (parte C) exibe o resultado
da utilização da aplicação criada nesta
seção:
 Figura 5.10: Resultado da
execução da aplicação.

Interagindo com tabelas de um banco de

dados

Agora que já foram apresentados os

conceitos básicos para a criação de um
subprograma ou procedimento no
Microsoft Access utilizando a linguagem
VBA, veremos como interagir com as
tabelas de um banco de dados.
Utilizaremos aqui o banco de dados
criado no tópico Criando um banco de
dados no Access. Começaremos com a
criação de um formulário que irá conter
os seguintes componentes:

• um rótulo na parte superior cujo valor

de Legenda seja CADASTRO DE
FORNECEDORES;

• uma caixa de texto para o nome do

fornecedor com o valor de Nome igual
a CaixaNomeFornecedor;
 • uma caixa de texto para o telefone do
fornecedor com o valor de Nome igual
a CaixaTelefoneFornecedor;

• um botão de comando com Legenda

igual a Cadastrar e Nome igual a
BotaoCadastrar;

• um botão de comando com Legenda

igual a Limpar e a propriedade Nome
igual a BotaoLimpar.

Não foi criada uma caixa de texto para

o código do fornecedor, pois este foi
definido como sendo do tipo auto-
numeração no momento da criação da
tabela. Dessa forma, o código será
gerado automaticamente pelo Access
quando um novo registro for inserido. A
aparência do formulário criado será
semelhante ao apresentado na Figura
5.11 (parte A), quando estiver no modo
estrutura, e semelhante ao da Figura 5.11
(parte B), quando estiver sendo exibido
no modo formulário. Também será
necessário criar o código VBA para os
botões Cadastrar e Limpar (Figura 5.11,
parte C). Para isso, siga a mesma
seqüência de passos listados no tópico
Integrando subpro gramas com
formulários, criando um evento do tipo
clique para o botão Cadastrar com o
seguinte código:
Figura 5.11: Interagindo com um banco
de dados.
 Para o código do evento de clique do
botão Cadastrar foram definidas as
variáveis nomeFornecedor, para
armazenar o nome do fornecedor
digitado pelo usuário no formulário,
telefoneFor necedor, para armazenar o
telefone do fornecedor e comandoSQL,
para armazenar o comando SQL que vai
inserir os dados na tabela de
fornecedores.

Os comandos nomeFornecedor =
CaixaNomeFornecedor e
telefoneFornecedor =
CaixaTelefoneFornecedor fazem com
que os dados digitados pelo usuário nas
caixas de texto do formulário sejam
armazenados nas variáveis
nomeFornecedor e telefoneFornecedor,
respectivamente.

A linha de comando comandoSQL =

"INSERT INTO fornecedor
(nome,telefone) VALUES ("'&
nomeFornecedor& &
telefoneFornecedor &"') "gera uma
instrução na linguagem SQL para
armazenar as informações digitadas no
formulário da tabela de fornecedores.

0 comando DoCmd.RunSQL
comandoSQL executa o comando SQL
armazenado na variável comandoSQL,
inserindo os dados digitados pelo
usuário no formulário da tabela de
fornecedores do banco de dados em
questão.

Os comandos CaixaNomeFornecedor =
"" e CaixaTelefoneFornecedor = ,,,são
utilizados para limpar as caixas de texto
do formulário e a instrução
CaixaNomeFornecedor. SetFocus é
utilizada para posicionar o cursor dentro
da caixa de texto do nome do
fornecedor. Finalmente, uma mensagem
informando que o registro foi inserido
corretamente com o comando MsgBox
"Fornecedor Cadastrado com Sucesso!".

0 código para o evento de clique do

botão Limpar, apresentado na Figura
5.11 (parte C) é o seguinte:
 De forma semelhante, será necessário
criar o formulário para o cadastro de
produtos. Para isso, na área de trabalho
do Access, selecione o objeto
Formulários e, em seguida, escolha
Criar formulário no modo estrutura,
configurando o formulário de acordo
com as instruções passadas
anteriormente. Salve-o com o nome
FormCadastraProdutos. Na seqüência,
adicione os seguintes objetos ao
formulário, utilizando a barra de
ferramentas do Access:
• um rótulo, alterando o valor de
Legenda para CADASTRO DE
PRODUTOS;

• uma caixa de texto com o valor de

Nome igual a CaixaDescricao;

• uma caixa de texto com o valor de

Nome igual a CaixaPreco;

• uma caixa de texto com o valor de

Nome igual a CaixaQuantidade;

• adicione um botão de comando ao

formulário, alterando Legenda para
Cadastrar e seu nome para
BotaoCadastrar. Insira outro botão com
Legenda igual a Limpar e nome igual a
 BotaoLimpar;

• uma caixa de combinação, também

presente na barra de ferramentas do
Access. A configuração deste objeto
difere um pouco dos demais. A idéia é
utilizar uma caixa de combinação que
liste todos os registros armazenados na
tabela de fornecedores, possibilitando
assim que o usuário escolha com o
mouse o fornecedor de cada produto.
Esta caixa irá armazenar o código do
fornecedor. Sendo assim, obedeça às
seguintes instruções:

1. Certifique-se de que a opção

Assistentes de controle esteja ativada na
caixa de ferramentas. Este assistente irá
auxiliar na configuração da caixa de
combinação.

2. Adicione um objeto de caixa de

combinação no formulário em questão.
No momento exato em que a nova caixa
de combinação é adicionada no
formulário, o assistente de controle do
Access entra em ação, e uma tela
semelhante à apresentada na Figura 5.12
(parte A) é apresentada.

3. Selecione a opção Eu quero que a

caixa de combinação procure os valores
em uma tabela ou consulta e clique no
botão Avançar.

4. Na próxima tela (Figura 5.12, parte

B), selecione a tabela de fornecedores e
clique em Avançar. Na próxima etapa,
selecione todos os campos disponíveis,
adicionando-os na caixa localizada no
lado direito da janela (Figura 5.12, parte
C).

6. Selecione o campo
codigo_fornecedor e clique em Concluir
(Figura 5.12, parte D).

7. Mude Nome para CaixaFornecedor.

 Figura 5.12: Configurando a caixa de
combinação.

Após inserir todos os objetos e alterar

suas propriedades, o formulário
FormCadastraProduto, quando estiver
no modo estrutura, deve ser semelhante
ao apresentado na Figura 5.13 (parte A)
e semelhante ao formulário da Figura
5.13 (parte B) quando estiver sendo
executado no modo formulário:
 Figura 5.13: Configurando a caixa de
combinação.

Com o formulário criado, com todos os

objetos necessários adicionados e
devidamente nomeados, será necessário
criar o código VBA para os eventos dos
botões Cadastrar e Limpar, de forma
semelhante ao que foi feito nas seções
anteriores. Então, no modo estrutura do
formulário FormCadastraProduto,
selecione o botão Cadastrar e abra o
editor de código VBA para criar a série
de comandos para o evento de clique
deste botão (Figura 5.13, parte C). A
seqüência de comandos é muito
semelhante à do botão Cadastrar do
formulário de cadastro de fornecedores.
Veja este código na seqüência:
 De forma semelhante, também será
necessário criar o código VBA para o
evento de clique do botão Limpar. Este
código é apresentado a seguir:
 Agora que os formulários para
cadastro de produtos e fornecedores já
foram criados, bem como o código VBA
de cada um deles, criaremos uma
espécie de menu principal, que será
constituído por um formulário com
botões de comando para chamar os
formulários de cadastro e também para
acionar o código VBA criado para listar
os produtos e fornecedores cadastrados
no banco de dados.
 Para isso, será necessário criar um
novo formulário no modo estrutura,
alterar algumas de suas propriedades, da
mesma forma que fizemos no tópico
Integrando subprogramas com
formulários e mostrado na Figura 5.6.
Este formulário deverá ser salvo como
FormMenu.

Utilizando a caixa de ferramentas,

adicione um novo botão de comando de
formulário (certifique-se de que a opção
Assistentes de controle esteja ativada).
Ao abrir a janela do assistente de
controle, selecione a categoria
Operações de formulário e a ação Abrir
formulário, conforme exibido na Figura
5.14 (parte A). Na tela seguinte, será
necessário indicar qual formulário será
aberto, para isso, selecione o formulário
FormCadastraFornecedores (Figura
5.14, parte B). Na próxima tela, a opção
Texto deverá ser selecionada e o rótulo
Cadastrar Fornecedor deve ser digitado
na caixa de texto, conforme indica a
Figura 5.14 (parte C). Para finalizar,
clique no botão Concluir. Este
procedimento cria um código VBA para
o evento de clique do botão, que, neste
caso, possibilitará que, quando este
formulário estiver sendo exibido no
modo formulário, ao clicar no botão,
FormCadastraFornecedores seja
exibido. Este código VBA pode ser
visualizado no evento de clique do
botão.

De forma semelhante, adicione um

novo botão de comando no formulário
FormMenu, para abrir o formulário de
cadastro de produtos:
 Figura 5.14: Configurando a caixa de
combinação.

Também serão adicionados ao

formulário FormMenu dois botões com
um código em VBA que permita a
listagem de produtos e fornecedores
cadastrados no banco de dados. Para
isso, insira um novo botão de comando
no formulário e altere sua propriedade
Nome para BotaoListarProdutos e sua
propriedade Legenda para Listar
Produtos. No evento de clique deste
botão, digite o seguinte código:

Neste subprograma criado para listar

os produtos cadastrados no banco de
dados, definimos uma variável banco do
tipo Database, que será utilizada para
referenciar o banco de dados em que
estamos trabalhando. A variável
comandoSQL irá armazenar a instrução
SQL necessária para consultar as tabelas
do banco de dados e listar todos os
produtos cadastrados, juntamente com
seus respectivos fornecedores. Por sua
vez, a variável definicaoConsulta será
utilizada para criar uma nova consulta
ao banco de dados em questão,
utilizando a instrução SQL armazenada
na variável comandoSQL, o que é
realizado com o comando Set
definicaoConsulta =
banco.CreateQueryDef("consultaProdutos
comandoSQL). A instrução Set banco =
CurrentDb faz com que a variável banco
seja associada ao banco de dados do
Access aberto no momento. 0 comando
DoCmd.OpenQuery "consultaProdutos",
acNormal, acReadonly executa a
consulta e exibe o resultado em uma
tabela somente de leitura, conforme
pode ser visualizado na Figura 5.15
(parte C). Em seguida, o comando
banco.QueryDefs. Delete
"consultaProdutos" é utilizado para
liberar a variável criada anteriormente.

Para que o Access possa reconhecer os

tipos de dados para interação com banco
de dados, como Database, por exemplo,
é preciso que a biblioteca Microsoft
DA0 Objects Library esteja ativada,
caso contrário, ocorrerá um erro na
execução do programa. Para verificar se
esta biblioteca está ativa, basta
selecionar a opção Referências, do
menu Ferramentas do ambiente de
programação VBA.

Também será necessário criar um

botão de comando e seu código VBA
para listar os fornecedores cadastrados
no banco de dados. 0 código VBA para
o botão Listar Fornecedores será o
seguinte:
 Figura 5.15: Formulário de menu e
resultado das consultas.

A Figura 5.15 (parte A) exibe o

formulário FormMenu no modo
estrutura. A parte B o exibe no modo
formulário. As partes C e D exibem,
respectivamente, o resultado obtido ao
clicar nos botões Listar Produtos e
Listar Fornecedores.

Considerações finais

Como vimos neste último capítulo,

utilizando a linguagem VBA é possível
desenvolver aplicações para interagir
com bases de dados definidas no
Microsoft Access. Os exemplos
apresentados neste capítulo mostram ao
usuário os princípios básicos para a
programação VBA no Microsoft Access,
possibilitando o desenvolvimento de
aplicações para interagir com
formulários, tabelas e consultas criadas
no Access.