Apostila VBA

Prévia do material em texto

SUMÁRIO 
 
MÓDULO 1 - INTRODUÇÃO A MACROS NO EXCEL 
IMPORTÂNCIA DA UTILIZAÇÃO DE MACROS ....................................... 3 
INTRODUÇÃO A MACROS........................................................................... 3 
COMO CRIAR MACROS? .............................................................................. 4 
GRAVADOR DE MACROS X CÓDIGO VBA .............................................. 4 
CRIAR UMA MACRO USANDO O GRAVADOR DE MACROS................ 6 
ESTRUTURA DE UMA MACRO ................................................................... 9 
OPERAÇÕES COM MACROS...................................................................... 11 
RENOMEAR UMA MACRO......................................................................... 11 
ALTERANDO A TECLA DE ATALHO E A DESCRIÇÃO ASSOCIADA A 
MACRO .......................................................................................................... 14 
EXCLUIR UMA MACRO.............................................................................. 15 
ASSOCIANDO MACROS A CONTROLES DE FORMULÁRIOS ............. 16 
ASSOCIAR A MACRO AO BOTÃO ............................................................ 17 
MÓDULO 2 - INTRODUÇÃO AO VBA NO EXCEL 
O AMBIENTE DE PROGRAMAÇÃO (EDITOR VBA)............................... 20 
PROJETO – VBA PROJECT E JANELA DE PROPRIEDADES ................. 20 
PESQUISADOR DE OBJETO ....................................................................... 22 
MÓDULO 3 – VARIÁVEIS 
DECLARAÇÃO DE VARIÁVEIS................................................................. 26 
OPTION EXPLICIT ....................................................................................... 26 
TIPOS DE VARIÁVEIS ................................................................................. 27 
SUBTIPOS DO TIPO VARIANT................................................................... 28 
OPERADORES ARITMÉTICOS................................................................... 29 
OPERADOR DE ATRIBUIÇÃO.................................................................... 29 
OPERADORES RELACIONAIS ................................................................... 30 
EXERCÍCIO 1 ................................................................................................ 30 
VARIÁVEIS - ARRAYS................................................................................ 34 
ARRAY UNIDIMENSIONAL ....................................................................... 34 
ARRAY BIDIMENSIONAL .......................................................................... 34 
DECLARAÇÃO DE ARRAYS ...................................................................... 35 
EXERCÍCIO 1 ................................................................................................ 36 
EXERCÍCIO 1 ................................................................................................ 39 
ESCOPO OU DOMÍNIO DAS VARIÁVEIS................................................. 41 
ESCOPO DE PROCEDIMENTO/FUNÇÃO.................................................. 41 
ESCOPO DE MÓDULO................................................................................. 43 
ESCOPO DE PROJETO ................................................................................. 45 
MÓDULO 4 – SUB-ROTINAS E FUNÇÕES 
SUB-ROTINAS .............................................................................................. 47 
EXERCICIO ................................................................................................... 49 
FUNÇÕES....................................................................................................... 50 
EXECUTANDO A FUNÇÃO CRIADA, NO EXCEL................................... 53 
MÓDULO 5 – FUNÇÕES INTERNAS DO VBA 
FUNÇÕES DE TIPO ...................................................................................... 55 
FUNÇÕES PARA TRATAMENTO DE TEXTO .......................................... 56 
FUNÇÕES DE DATA E HORA..................................................................... 60 
OUTRAS FUNÇÕES ÚTEIS ......................................................................... 71 
EXERCÍCIO 1 ................................................................................................ 72 
MÓDULO 6 – TRATAMENTO DE ERROS 
EXERCÍCIO 1 ................................................................................................ 76 
MÓDULO 7 – ESTRUTURAS DE CONTROLE 
A ESTRUTURA IF... THEN .......................................................................... 78 
A ESTRUTURA IF... THEN... ELSE............................................................. 79 
A ESTRUTURA IF... THEN... ELSEIF ......................................................... 81 
EXERCICIO 1 ................................................................................................ 83 
A ESTRUTURA FOR... NEXT ...................................................................... 84 
EXERCICIO ................................................................................................... 85 
A ESTRUTURA DO... LOOP ........................................................................ 86 
EXERCICIO 1 ................................................................................................ 94 
REVISÃO 1 .................................................................................................... 95 
REVISÃO 2 .................................................................................................... 96 
REVISÃO 3 .................................................................................................... 99 
MÓDULO 8 – MSGBOX E INPUTBOX 
A FUNÇÃO MSGBOX ................................................................................ 100 
A FUNÇÃO INPUTBOX ............................................................................. 105 
EXERCÍCIO ................................................................................................. 109 
MÓDULO 9 – MODELOS DE OBJETOS DO EXCEL 
PROPRIEDADES, MÉTODOS, EVENTOS E COLEÇÕES DOS OBJETOS111 
DESCRIÇÃO DOS PRINCIPAIS OBJETOS DO EXCEL .......................... 112 
UTILIZAÇÃO DOS PRINCIPAIS OBJETOS DO EXCEL......................... 121 
MÓDULO 10 – FORMULÁRIOS NO VBA (USERFORMS) 
INTRODUÇÃO SOBRE FORMULÁRIOS ................................................. 123 
CRIANDO UM USERFORM....................................................................... 124 
CAIXA DE FERRAMENTAS...................................................................... 125 
JANELA DE PROPRIEDADES................................................................... 125 
PROPRIEDADES DOS CONTROLES........................................................ 126 
CONTROLES DE FORMULÁRIOS............................................................ 130 
PROJETO FINAL.............................................................................................. 138 
MÓDULO 1 - INTRODUÇÃO A MACROS NO EXCEL 
Neste módulo veremos os principais fundamentos sobre Macros. 
Conheceremos exatamente o que é uma macro, como esta definida a 
sua estrutura e aprenderemos a realizar algumas operações. Os 
conceitos vistos neste módulo, serão de extrema importância para o 
entendimento dos demais módulos. 
IMPORTÂNCIA DA UTILIZAÇÃO DE MACROS 
Em determinados problemas, que surgem durante a criação das 
planilhas em Excel, não conseguimos resolvê-los simplesmente 
utilizando os comandos e fórmulas do Excel. 
Nessas situações temos que fazer uso de recursos como Macros e 
Programação. A linguagem de programação do Excel é o VBA – Visual 
Basic for Applications. O VBA é a linguagem de programação para 
todos os aplicativos do Microsoft Office como: Word, Excel, Access e 
PowerPoint. 
INTRODUÇÃO A MACROS 
Se caso surgir uma necessidade de se executar uma tarefa várias 
vezes no Microsoft Excel, ao invés de perder tempo executando-as 
diversas vezes,podemos automatizar esta tarefa simplesmente com a 
criação de uma macro. 
Macro é uma seqüência de comandos ou funções armazenados em 
um código VBA, que pode ser executado sempre que se precisar 
executar a tarefa. 
As macros são uma excelente opção para automatizar tarefas 
repetitivas. Com o uso de macros temos um ganho de produtividade 
considerável, ao evitar que tenhamos que executar manualmente, os 
diversos passos de uma tarefa, passos estes que podem ser 
automatizados através do uso de uma macro. 
COMO CRIAR MACROS? 
Existem duas maneiras possíveis para a criação de uma macro: 
• Gravador de Macros – Destinado a iniciantes em criação 
de Macros. 
• Código VBA – Destinado a profissionais que possuem uma 
boa lógica de programação e que dominam a linguagem 
VBA. 
GRAVADOR DE MACROS X CÓDIGO VBA 
No método de gravação, o Excel grava cada uma das ações que 
farão parte da macro e transforma estas ações nos comandos VBA 
equivalentes. Quando a macro for executada, os comandos VBA é que 
serão efetivamente executados. Cada comando VBA corresponde a uma 
ação efetiva da macro. 
Por exemplo, vamos supor que por diversas vezes, você precisa 
formatar uma determinada célula com Negrito, Itálico, cor de fonte Verde, 
Fonte Arial com Tamanho 16. Ao invés de ter que executar todos os 
comandos de formatação sempre que precisar deles, você pode criar 
uma macro que aplica todos os comando de formatação. Após criada a 
macro, cada vez que você precisar aplicar o conjunto de comandos de 
formatação, basta executar a macro, bem mais fácil do que aplicar cada 
comando individualmente. 
Antes de gravar uma macro, planeje muito bem as etapas e os 
comandos que você deseja que a macro execute. Se cometer um erro 
durante a gravação da macro, as correções feitas também serão 
gravadas como comandos da macro. Ao gravar macros, o VBA 
armazena cada macro em um módulo de código VBA, anexado a uma 
pasta de trabalho (arquivo. xls). 
Depois de gravada a macro, você poderá exibir o código da macro 
com o Editor do VBA para corrigir erros ou alterar a função da macro. O 
Editor do VBA é um programa criado para facilitar a escrita e a edição do 
código de macro para principiantes. Você não precisa aprender a 
programar ou a usar a linguagem do Visual Basic para fazer alterações 
simples nas suas macros. Nos próximos módulos veremos como 
trabalhar melhor com o Editor do VBA. 
Na figura a seguir temos um exemplo de código associado a uma 
macro. Esse é um exemplo de código VBA: 
 
Além disso, no Editor do VBA, podemos editar macros, copiar 
macros de um módulo para o outro, copiar marcos entre pastas de 
trabalho diferentes e renomear as macros. Por exemplo, se você 
quisesse que a macro formatar, da figura acima, também deixasse a 
célula formatada com sublinhado, você poderia gravar outra macro para 
aplicar o sublinhado e copiar as instruções dessa nova macro para a 
macro formatar. 
CRIAR UMA MACRO USANDO O GRAVADOR DE MACROS 
Iremos criar uma macro chamada FormataCelula usando o 
gravador de macros, onde esta macro deverá formatar a célula atual com 
Negrito, cor de fonte Verde e com cor de plano de fundo cinza. 
Para isso, proceda da seguinte maneira: 
1. Abra o arquivo Exercício 1.xls, localizado na pasta da 
turma. 
2. Clique a célula B5. 
3. Clique o menu Ferramentas. 
4. Selecione a opção Macros, clique a opção Gravar nova 
macro... 
Sugira assim a tela Gravar macro: 
 
5. No campo Nome da macro, digite FormataCelula. 
6. No campo Tecla de atalho, digite L. 
Observe que o Excel troca para Ctrl+Shift+L, pois a 
combinação Ctrl+L já esta associada a outro comando do 
Excel. 
7. No campo Descrição, digite Formata em 
negrito, verde e fundo cinza. 
8. Clique o botão OK. 
Com isso, a gravação da macro será iniciada e todos os comandos 
que você executar durante a gravação da macro, farão parte da macro. 
Perceba que uma nova barra de ferramentas chamada Parar 
Gravação surge, onde através dela podemos interromper a 
gravação da macro. 
A partir deste ponto, devemos executar todos os comandos que 
farão parte da macro. 
9. Clique o menu Formatar. 
10. Clique a opção Células. 
11. Formate em Negrito, cor Verde e cor de plano de fundo 
cinza. 
12. Clique o botão Parar Gravação , para encerrar a gravação 
da macro. 
Com isso, a macro FormataCelula foi criada e podemos 
utilizá-la sempre que for necessário. 
 
Para executar a macro FormataCelula, proceda da seguinte 
maneira: 
1. Clique a próxima célula a ser formatada, exemplo C8. 
2. Pressione Ctrl+Shift+L. 
A macro FormataCelula é executada e as informações definidas 
pela macro são automaticamente aplicadas a célula selecionada. 
Uma outra maneira de executar macros é utilizando o menu 
Ferramentas, opção Macro, subopção Macros. 
Com isso será exibida a janela Macro, onde estão listadas as 
macros existentes na pasta de trabalho atual, confirme visto na figura a 
seguir: 
 
Nesta tela, você irá selecionar o nome da macro a ser executada e 
clicar sobre o botão Executar. 
A macro será executada e as formatações serão aplicadas à célula 
que estava selecionada. 
Sua planilha deverá exibir o seguinte aspecto: 
 
ESTRUTURA DE UMA MACRO 
Na macro criada anteriormente chamada de FormataCelula, 
podemos perceber que ao executá-la os comandos de formatação são 
novamente executados e aplicados á célula onde esta o cursor ou na 
faixa de células selecionadas. Isto acontece porque no ato da gravação 
da macro o Excel gera para cada comando que efetuamos um código 
VBA equivalente formando assim a nossa macro. 
O que iremos ver agora é justamente esta estrutura que compõem 
toda a nossa macro. Para acessar os comandos VBA associado a uma 
macro, proceda da seguinte maneira: 
1. Com o arquivo já aberto, clique o menu Ferramentas. 
2. Selecione a opção Macro, clique a subopção Macros. 
Com isso será exibida a janela Macros. 
3. Selecione a macro FormataCelula. 
4. Clique o botão Editar. 
Com isso o Editor do VBA será carregado e serão exibidas as 
linhas de código referente a nossa macro. 
 
Estes são os comandos VBA referentes a macro 
FormataCelula. Caso não entenda os comandos, não se 
preocupe, pois ainda os estudaremos mais adiante. 
 
A seguir esta descrito o que faz cada um dos principais comandos 
desta macro: 
E
stes 
com
and
os 
apli
cam 
a fonte Arial, o estilo Negrito, o tamanho 10 e a cor de fonte verde, para 
as células atualmente selecionadas. 
With Selection.Font 
 .Name = "Arial" 
 .FontStyle = "Negrito" 
 .Size = 10 
 .ColorIndex = 10 
End With 
E
stes 
com
and
os 
apli
cam a cor de plano de fundo cinza, para as células atualmente 
selecionadas. 
5. Salve e feche o Editor do VBA. 
OPERAÇÕES COM MACROS 
Depois de criadas as macros podemos futuramente precisar realizar 
algum de tipo de alteração nelas, seja em seu código ou no comando de 
teclado (tecla de atalho). Podemos precisar também renomeá-las e até 
mesmo excluí-las caso seja necessário. Todas estas ações estão ligadas 
às operações com macros. 
RENOMEAR UMA MACRO 
Esta ação deve ser realizada toda vez que se deseja modificar o 
nome de uma ou mais macros do arquivo. 
Para poder renomear uma macro, proceda da seguinte maneira: 
1. Com o arquivo aberto, clique o menu Ferramentas. 
2. Selecione a opção Macro, clique a sub-opção Macros. 
 Será exibida a janela Macros 
With Selection.Interior 
 .ColorIndex = 48 
 .Pattern = xlSolid 
 .PatternColorIndex = xlAutomatic 
 End With 
 
 
3. Clique a macro FormataCelula para selecioná-la. 
4. Clique o botão Editar. 
Com isso, será aberto o Editor do VBA com o código da macro, 
onde o nome da mesma vem após o comando Sub na primeiralinha. 
 
5. Altere o nome da macro FormataCelula para Formatar. 
6. Clique o botão Salvar. 
7. Feche o Editor do VBA. 
Com isso a macro foi renomeada, caso deseje 
confirmar, clique o menu ferramentas, selecione a opção 
macro e clique na sub-opção macros, você verá na tela que a 
macro agora se chama Formatar. 
ALTERANDO A TECLA DE ATALHO E A DESCRIÇÃO ASSOCIADA 
A MACRO 
Esta ação deve ser realizada caso seja necessário modificar por 
algum motivo a tecla de atalho que esteja associada a uma macro e o 
seu comentário que é de extrema importância, pois resume o 
funcionamento da macro. 
Para fazer a alteração, proceda da seguinte maneira: 
1. Com o arquivo aberto, clique o menu Ferramentas. 
2. Selecione a opção Macro, clique a sub-opção Macros. 
 Será exibida a janela Macros. 
 
3. Clique a macro Formatar para selecioná-la. 
4. Clique o botão Opções. 
Com isso, será exibida a janela Opções de Macro. 
 
Nesta tela podemos fazer a alteração da tecla de atalho e da 
descrição atribuídos à macro. 
5. Na Tecla de Atalho, digite: W. 
6. Na Descrição, digite: Formatação em negrito, com cor 
verde e plano de fundo na cor cinza. 
7. Clique o botão OK. 
Com isso a tecla de atalho e a descrição da macro 
foram alteradas. 
 
EXCLUIR UMA MACRO 
Esta ação deverá ser realizada quando não houver mais a 
necessidade da utilização da macro no arquivo. 
Para isto, proceda da seguinte maneira: 
1. Com o arquivo aberto, clique o menu Ferramentas. 
2. Selecione a opção Macro, clique a sub-opção Macros. 
3. Selecione a macro a ser excluída, no nosso caso selecione 
a macro Formatar. 
4. Clique o botão Excluir. 
Com isso irá surgir uma caixa de mensagem para confirmar a 
exclusão da macro. 
 
5. Clique o botão Sim. 
IMPORTANTE! Caso a macro esteja associada a 
algum controle de formulário, por exemplo, um botão, a 
simples exclusão do botão NÃO EXCLUI A MACRO 
associado a este. 
Com isso a macro Formatar foi excluída do arquivo. 
 
ASSOCIANDO MACROS A CONTROLES DE 
FORMULÁRIOS 
A associação de uma macro a um controle de formulário deve ser 
feita sempre que se deseja executar uma macro de uma forma mais 
simples e rápida, onde ao invés de irmos no menu Ferramentas, opção 
Macro, sub-opção Macros, selecionar a macro desejada e clicar o botão 
executar, podemos apenas clicar sobre um botão e a macro associada a 
ele é automaticamente executada. Esta associação é importante 
principalmente quando a sua planilha for usada por usuários leigos em 
Excel, facilitando assim os seus trabalhos. 
Para testar este recurso, iremos criar uma nova macro com o nome 
de Classificar, cuja tarefa será de classificar a tabela pelo campo Código 
em ordem crescente, depois inserir um botão na planilha e associá-lo a 
macro classificar. 
Para isso, proceda da seguinte maneira: 
1. Abra o arquivo Exercício 2.xls, localizado na pasta da 
turma. 
2. Clique o menu Ferramentas. 
3. Clique a opção Macro, clique a sub-opção Gravar nova 
macro. 
Surgirá assim à tela Gravar macro. 
4. Em Nome da macro, digite Classificar. 
5. Clique o botão OK. 
Aparecerá então, a barra de ferramentas Parar Gravação. 
6. Selecione a linha de cabeçalho da tabela correspondente ao 
intervalo de células A1:F1. 
7. Pressione as teclas SHIFT + END + ↓, com isso toda a 
tabela deverá ser selecionada. 
8. Classifique a tabela pelo campo Código em ordem 
crescente. 
9. Clique a célula A1. 
10. Clique o botão Parar Gravação. 
ASSOCIAR A MACRO AO BOTÃO 
1. Clique o menu Exibir. 
2. Clique a opção Barra de Ferramentas. 
3. Clique a sub-opção Formulários. 
Com isso, aparecerá a barra de ferramentas Controle de 
Formulários. 
 
4. Insira na planilha o controle chamado Botão. 
Com isso, surgirá à tela Atribuir Macro. 
 
5. Clique a macro classificar para selecioná-la. 
6. Clique o botão OK. 
Pronto! Com isso a macro Classificar encontra-se associada 
ao botão, onde um simples clique sobre este, implicará na 
execução das instruções que compõem a macro. 
MÓDULO 2 - INTRODUÇÃO AO VBA NO EXCEL 
Uma linguagem de programação, basicamente, é uma forma que o 
programador tem de se comunicar com a máquina, através de um 
conjunto de comandos, rotinas, objetos e funções que executam tarefas 
específicas. 
Utilizar-se do código VBA para a criação das macros, oferece ao 
programador uma grande quantidade de opções para solucionar 
problemas mais complexos e que não podem ser somente resolvidos 
com o uso de comandos e funções internas do Excel. 
A linguagem de programação utilizada no Microsoft Excel é o VBA 
– Visual Basic for Applications. Com o VBA é possível que o 
programador tenha acesso completo a todos os objetos de uma planilha 
do Excel. 
Fazer uso do VBA em planilhas do Excel, garante ao programador 
algumas vantagens como: 
• Acessar dados de uma ou mais planilhas; 
• Manipular objetos; 
• Criar funções definidas pelo usuário, onde este é sem 
dúvida um dos maiores benefícios do VBA. 
• Definir condições e controlar o fluxo de dados através de 
estruturas para a realização de testes condicionais e para a 
repetição de um conjunto de comandos; 
• Realizar cálculos complexos e solucionar problemas que 
envolvam uma lógica complexa. 
O AMBIENTE DE PROGRAMAÇÃO (EDITOR VBA) 
O Microsoft Excel nos oferece um ambiente de programação 
bastante poderoso, com uma série de recursos que facilitam a criação do 
código VBA. Dentro deste ambiente, são oferecidas uma série de 
facilidades e dicas para que o programador possa encontrar facilmente 
os objetos disponíveis. 
Para conhecermos melhor o Editor VBA temos na figura abaixo um 
exemplo de uma macro chamada AplicaNegrito. 
 
PROJETO – VBA PROJECT E JANELA DE PROPRIEDADES 
Dentro do Editor VBA no lado esquerdo, temos duas janelas que 
são de extrema importância, a janela do projeto o VBA Project e a 
Janela de Propriedades. 
VBA Project – Nesta janela são exibidos os vários elementos que 
fazem parte da Pasta de trabalho atual, onde são exibidas as planilhas e 
módulos. 
 
Ao criar uma macro, podemos cria-la em uma determinada planilha, 
mas esta somente poderá ser utilizada dentro da planilha onde ela foi 
criada, caso deseje criar uma macro que possa ser trabalha em qualquer 
uma das planilhas do arquivo, esta deverá ser criada em um dos 
módulos existentes. 
Podemos dentro de uma pasta de trabalho possuir diversos 
módulos, principalmente quando se tem planilhas complexas, daí 
podemos dividir estes módulos em categorias como, por exemplo: criar 
um módulo somente para a criação de funções para cálculo de data, 
outro para funções de validação de dados, outro para funções de 
cálculos financeiros e assim por diante. Esta divisão facilita a localização, 
manutenção e alteração das funções e códigos existentes. 
Janela de Propriedades – Exibe as propriedades do objeto 
selecionado na janela VBA Project. 
Por exemplo, ao selecionar Plan1, na janela VBA Project, na janela 
propriedades serão exibidas as propriedades de Plan1. 
 
PESQUISADOR DE OBJETO 
O Editor do VBA facilita muito o trabalho do programador na 
manipulação de um objeto pois possui uma janela que exibe uma 
listagem de todas as bibliotecas disponíveis, bem como a lista de cada 
objeto de cada biblioteca, juntamente com todas as suas propriedades e 
métodos, esta janela é chamada de Pesquisador de Objeto. 
Para exibi-la proceda da seguinte maneira: 
1. Dentro do Editor VBA, clique o menu Exibir. 
2. Clique a opção Pesquisador de Objeto. 
Com isso, irá surgir a janela do Pesquisador de Objeto. 
 
Na lista Todas as Bibliotecas, podemos selecionar uma biblioteca 
específica, para que o pesquisador mostre somente os objetos da 
biblioteca selecionada. 
Por exemplo, selecione a bibliotecaExcel, na lista de objetos do 
lado esquerdo selecione o objeto Range, com isso do lado direito do 
painel será exibida uma lista com os métodos e propriedades do objeto 
Range. 
 
Além do Pesquisador de Objeto, o Excel oferece um outro recurso 
para localizar um método ou propriedade de um objeto, este recurso se 
dá no momento da digitação do código onde após digitar o nome do 
objeto sucedido de um ponto, surgirá automaticamente uma lista com 
estes métodos e propriedades. 
 
Pronto! Com isso aprendemos algumas noções básicas sobre 
o Editor do VBA. 
MÓDULO 3 – VARIÁVEIS 
Uma variável é um espaço criado na memória do computador 
durante a execução de um programa, utilizado para armazenar um ou 
mais valores. Estes espaços são referenciados pelo programador através 
da atribuição de nomes, ou seja, atribuímos nomes as variáveis utilizadas 
no programa. 
Elas possuem esta nomenclatura, pelo fato de poder ter o seu 
conteúdo modificado durante a execução do programa, daí o nome 
Variáveis. 
O programador antes de utilizar a variável dentro do código, deve 
primeiramente declará-la, ou seja, nas linhas iniciais do código deve-se 
definir o nome de todas as variáveis que serão utilizadas, bem como o 
conteúdo que será armazenado nesta, a esta definição damos o nome de 
Tipos de Dados. 
Tipos de Dados é basicamente determinar para o programa qual o 
tipo do conteúdo que a variável irá armazenar, por exemplo: podemos 
definir que uma variável irá armazenar somente valores inteiros numa 
faixa de 0 a 250, ou podemos também definir que a variável irá 
armazenar caracteres de texto de tamanho variável ou ainda definir que 
a variável poderá armazenar números com casas decimais. Esta 
definição do tipo de dados da variável é extremamente importante, pois 
economizamos espaço na memória do computador. 
Esta economia de espaço na memória através da definição do tipo 
de dados mais adequado para uma variável se da pelo fato de que cada 
tipo de dados ocupa um determinado espaço em memória, por exemplo: 
uma variável do tipo de dados que armazena números inteiros ocupa na 
memória menos espaço que uma variável do tipo de dados que 
armazena caracteres de texto. 
No VBA, não é obrigatório à declaração de variáveis. Porém é 
recomendável que as declaremos, para a economia de espaço 
mencionada anteriormente e também para que o código fique mais claro 
e de fácil compreensão. 
DECLARAÇÃO DE VARIÁVEIS 
Para a declaração de uma variável devemos sempre utilizar o 
comando Dim, que vem do termo Dimensão, seguido do nome da 
variável, conforme exemplo: 
Dim x 
Dim nome 
Dim idade 
Neste exemplo, estamos apenas declarando o nome da variável, 
sem declarar de que tipo (texto, número inteiro, data, decimal, etc.) é a 
variável. Deste modo a sintaxe completa de declaração de variáveis é a 
seguinte: 
Dim nome_da_variável As tipo_da_variável 
Podemos também em um único comando Dim, declarar mais que 
uma variável, sendo estas do mesmo tipo de dados, por exemplo: 
Dim idade, quantidade As tipo_da_variável 
Dim nome, produto, codigo As tipo_da_variável. 
OPTION EXPLICIT 
Embora a declaração de variáveis seja importante, também 
podemos utilizar variáveis que não foram, explicitamente, declaradas 
com o comando Dim. Com isso, a variável é criada na memória, no 
momento da sua utilização. Mas se desejar que toda variável tenha que 
estar declarada para poder ser utilizada, basta utilizar o comando Option 
Explicit na seção de declaração do módulo. 
Ao definirmos este comando na seção de declaração do módulo, 
estamos definindo que toda variável deve ser declarada, antes de ser 
utilizada. Caso se utilize de uma variável não declarada, será gerado um 
erro de compilação e a execução dos comandos é interrompida. 
Abaixo temos um exemplo de variáveis não explicitamente 
declaradas: 
Dim num1, num2 As tipo_da_variável 
Soma = num1 + num2 
Ao tentarmos executar este código, estando definido o comando 
Option Explicit, iremos obter uma mensagem de erro, pois utilizamos a 
variável soma que não foi declarada, conforme a figura abaixo: 
 
TIPOS DE VARIÁVEIS 
O tipo de uma variável serve para determinar na memória o espaço 
que será alocado para armazenar uma informação. 
O tipo de variável padrão do VBA é o tipo Variant, que é formado 
por pequenas unidades, chamadas de subtipos, onde cada subtipo 
identifica de que maneira os dados serão armazenados em uma variável 
do tipo Variant. 
Não é indicado utilizar-se de variáveis com o tipo Variant, 
pois daí será difícil restringir ao usuário o tipo da informação 
que será armazenada, exemplo: Desejo que o usuário digite 
apenas números inteiros. Caso a variável que receberá este 
número tenha sido declara com o tipo Variant, o usuário poderá então 
digitar qualquer outra informação que não seja um número inteiro. 
SUBTIPOS DO TIPO VARIANT 
Subtipo Significado Tamanho 
Empty 
Valor zero para variáveis numéricas ou 
String de tamanho (“”), para variáveis 
de texto. 
- 
Boolean 
Variáveis que só podem assumir dois 
valores: Verdadeiro ou Falso (True or 
False). 
2 Bytes 
Byte Valor Inteiro, na faixa de 0 a 255. 1 Byte 
Integer Valor Inteiro, na faixa de -32768 a 32767. 2 Bytes 
Currency 
Valor real na faixa de -
923.337.203.685.447,5808 até 
923.337.203.685.447,5807. 
8 Bytes 
Double 
Valor real na faixa de 
1.79769313486232E308 até 
4.94065645841247E-324. 
8 Bytes 
Long Valor Inteiro, na faixa de -2.147.483.648 até 2.147.483.647. 4 Bytes 
Date 
(Time) 
Número que representa a data entre 
01 de janeiro do ano 100, até 31 de 
dezembro de 9999. 
8 Bytes 
String 
Texto de tamanho variável, pode 
conter, aproximadamente, 2 bilhões de 
caracteres. 
1 Byte por 
caractere 
Object Pode conter um objeto qualquer, como Controle ActiveX. 4 Bytes 
 
OPERADORES ARITMÉTICOS 
Para podermos realizar cálculos entre as variáveis, devemos utilizar 
operadores. 
Abaixo segue uma tabela com os operadores aritméticos 
disponíveis: 
Operador Símbolo Descrição 
Adição + Soma o valor das variáveis. 
Subtração - Subtrai o valor das variáveis. 
Multiplicação * Multiplica o valor das variáveis. 
Divisão / Divide o valor das variáveis. 
Inteiro da 
divisão entre 2 
números 
\ Parte inteira da divisão das 
variáveis. 
Exponenciação 
^ 
x^y – número x elevado a potência 
y. 
Módulo Mod Resto da divisão de 2 números. 
OPERADOR DE ATRIBUIÇÃO 
Quando pretendemos atribuir valores as variáveis, devemos indicar 
o nome da variável, seguido do operador (=) e o valor a ser armazenado 
na variável. 
Como exemplo observe o código a seguir: 
Nome = “Fábio Abreu” 
Qtd = 86 
No código acima a variável Nome esta armazenando o texto “Fábio 
Abreu” e a variável Qtd esta guardando o número 86. 
 
OPERADORES RELACIONAIS 
Para podermos estabelecer relações entre as variáveis, devemos 
utilizar operadores. 
Abaixo segue uma tabela com os operadores relacionais 
disponíveis: 
Operador Símbolo 
Maior > 
Menor < 
Maior ou Igual >= 
Menor ou Igual <= 
Diferente <> 
Igual = 
EXERCÍCIO 1 
Para utilizarmos os conceitos vistos até aqui, proceda da seguinte 
maneira: 
1. Abra o arquivo Exercício 3.xls, localizado na pasta da 
turma. 
2. Abra o Editor do VBA. 
3. Abra o módulo chamado Módulo1. 
Com isso, irá aparecer uma macro chamada calcular. 
 
Dentro desta macro, digite o seguinte código: 
 
 
4. Depois de digitado o código aperte a tecla de atalho F5, para 
executar a macro. 
Será exibida uma caixa de mensagem: 
 
5. Clique em OK. 
Será exibida uma caixa de mensagem: 
 
6. Clique em OK. 
Será exibida uma caixa de mensagem: 
 
7. Clique em OK. 
Será exibida uma caixa de mensagem: 
 
8. Clique em OK. 
Seráexibida uma caixa de mensagem: 
 
9. Clique em OK. 
Será exibida uma caixa de mensagem: 
 
10. Clique em OK. 
Será exibida uma caixa de mensagem: 
 
Neste exercício, utilizamos operadores aritméticos para realizar 
operações com os valores das variáveis “num1” e “num2”. 
Além disso, fizemos uso de uma função chamada Msgbox, que 
exibe mensagens em uma pequena janela, chamada de Pop-Up e 
utilizamos também o operador de concatenação (&). 
VARIÁVEIS - ARRAYS 
Uma variável que representa um conjunto de variáveis do mesmo 
tipo. 
Um array pode ser unidimensional ou bidimensional. 
ARRAY UNIDIMENSIONAL 
Constituído por uma única lista de elementos indexáveis, onde 
possuímos um elemento inicial e outro elemento final, sendo que cada 
elemento da lista corresponde a um único índice. 
 0 
 1 
 2 
 3 
 4 
 5 
ARRAY BIDIMENSIONAL 
Um pouco mais complexo que o unidimensional, é constituído por 
um conjunto de listas do mesmo comprimento, sendo que este formato é 
normalmente conhecido como array ou matriz. 
Constituído, portanto de linhas e colunas, onde cada elemento é 
identificado por um índice composto pela interseção dos números das 
linhas e colunas. 
0 1 2 
 0 
 1 
 2 
 3 
Note que o primeiro elemento de qualquer array sempre 
possuí índice 0. 
DECLARAÇÃO DE ARRAYS 
A declaração de um array é semelhante a declaração de uma 
variável comum, com exceção de um índice que identifica quantas linhas 
e colunas este array deve possuir. 
Em um array unidimensional, como temos apenas uma única lista 
correspondente a quantidade de elementos que a variável deve 
armazenar a sintaxe se dá da seguinte maneira: 
Dim nome_array (índice) As tipo_da_variável 
Onde, índice representa o número de elementos que farão parte do 
array, exemplo: 
Dim ArrayNumerico(10) As Integer 
Na declaração do array anterior, estamos declarando que o array 
terá 10 posições ou 10 elementos, do mesmo tipo Integer. 
Com isso, ao invés de declararmos 10 variáveis, temos apenas 
uma, tornando assim o código mais legível e simples. 
ArrayNumerico 
 0 
 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
Em que cada elemento é do tipo Integer. 
Já em um array bidimensional, como a variável é composta por 
diversas listas correspondente a quantidade de elementos que esta deve 
armazenar a sintaxe se dá da seguinte maneira: 
Dim nome_array (índice) As tipo_da_variável 
Onde, índice representa o número de linhas e colunas que farão 
parte do array, exemplo: 
Dim TabelaTextual (5, 4 ) As String 
Na declaração do array anterior, estamos declarando que o array 
terá 5 linhas e 4 colunas, podendo assim armazenar 20 elementos, do 
mesmo tipo String. 
Com isso, ao invés de declararmos 20 variáveis, temos apenas 
uma, tornando assim o código mais legível e simples. 
TabelaTextual 
0 1 2 3 
 0 
 1 
 2 
 3 
 4 
Em que cada elemento é do tipo String. 
EXERCÍCIO 1 
1. Abra o arquivo Exercício 4.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Abra o módulo chamado Módulo1. 
Com isso, irá aparecer uma macro chamada arrayuni. 
 
Dentro desta macro, digite o seguinte código: 
 
4. Depois de digitado o código aperte a tecla de atalho F5, para 
executar a macro. 
Será exibida uma caixa de mensagem: 
 
5. Clique em OK. 
Será exibida uma caixa de mensagem: 
 
6. Clique em OK. 
Será exibida uma caixa de mensagem: 
 
7. Clique em OK. 
Será exibida uma caixa de mensagem: 
 
Neste exercício, utilizamos um array unidimensional de 4 
elementos para armazenar nomes dos alunos e mostra-los na tela 
através da função msgbox. 
EXERCÍCIO 1 
1. Abra o arquivo Exercício 4.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Abra o módulo chamado Módulo2. 
Com isso, irá aparecer uma macro chamada arraybi. 
 
Dentro desta macro, digite o seguinte código: 
 
4. Depois de digitado o código aperte a tecla de atalho F5, para 
executar a macro. 
Será exibida uma caixa de mensagem: 
 
5. Clique em OK. 
Será exibida uma caixa de mensagem: 
 
 
Neste exercício, utilizamos um array bidimensional com 2 linhas e 
2 colunas totalizando assim 4 elementos para armazenar nomes e 
médias dos alunos e mostra-los na tela através da função msgbox. 
Além disso, fizemos uso no código de uma função chamada 
Chr(número). Esta função envia como resultado para a função msgbox o 
caractere correspondente ao número digitado entre parênteses. Este 
número, é o número do caractere no padrão ASCll (American Standard 
Caracter Interchange Information). 
No código ASCII, cada caractere possui um número associado, no 
caso do número 13, este se encontra associado ao <ENTER>, o que 
equivale a uma troca de linha. Assim utilizamos o Chr(13) para simular 
um <ENTER>, de tal maneira que os dados não apareçam todos 
“grudados” na mesma linha. 
ESCOPO OU DOMÍNIO DAS VARIÁVEIS 
O Escopo ou domínio de uma variável define a área de aplicação na 
qual a variável pode ser utilizada, ou seja, em qual área ela pode ser 
acessada. 
Existem 3 níveis de escopo para as variáveis: 
• Escopo de Procedimento/Função 
• Escopo de Módulo 
• Escopo de Projeto 
ESCOPO DE PROCEDIMENTO/FUNÇÃO 
É uma variável que foi inicialmente declarada dentro de um 
procedimento ou função, sendo que esta variável somente pode ser 
utilizada dentro deste procedimento ou função. São variáveis criadas no 
momento da execução do procedimento ou função e destruídas 
automaticamente ao término da execução do procedimento ou função. 
Assim sendo, qualquer tentativa de se acessar uma variável dentro de 
um procedimento que foi declarada no corpo de um outro procedimento, 
esta não terá êxito. 
Para melhor entendermos a utilização das variáveis com escopo de 
procedimento/função, proceda da seguinte maneira: 
1. Abra uma nova pasta de trabalho. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a 
seguir: 
 
4. Execute a sub-rotina proc1. 
Com isso irá surgir uma caixa de mensagem com o valor da variável 
var. 
 
5. Clique o botão OK. 
Em seguida, surgirá uma nova caixa de mensagem em branco. 
 
Neste exemplo, dentro do procedimento proc1, declaramos uma 
variável do tipo Integer chamada var, e atribuímos a ela o valor 5. Logo 
em seguida mostramos o valor desta variável na tela usando a função 
msgbox. Depois, ainda no procedimento proc1, chamamos o 
procedimento proc2 que também mostra o valor da variável var1 na tela 
através da função msgbox, mas perceba que na segunda caixa de 
mensagem o valor da variável não aparece, ou seja, a variável não 
contém valor. Isso acontece pelo fato da variável esta declarada dentro 
do procedimento proc1. 
ESCOPO DE MÓDULO 
É uma variável que foi inicialmente declarada na seção de 
declarações do módulo, fora de qualquer procedimento. Com isso a 
variável pode ser utilizada dentro de todos os procedimentos e funções 
existentes dentro do módulo. 
Para melhor entendermos a utilização das variáveis com escopo de 
módulo, proceda da seguinte maneira: 
1. Abra uma nova pasta de trabalho. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a 
seguir: 
 
 
 
 
4. Execute a sub-rotina proc1. 
Com isso irá surgir uma caixa de mensagem com o valor da variável 
var. 
 
5. Clique o botão OK. 
Em seguida, surgirá uma nova caixa de mensagem novamente com 
o valor da variável var. 
 
Neste exemplo, dentro seção de declaração do módulo, declaramos 
uma variável do tipo Integer chamada var. Dentro do procedimento 
proc1 atribuímos a variável o valor 5. Logo em seguida mostramos o 
valor desta variável na tela usando a função msgbox. Depois, ainda no 
procedimento proc1, chamamoso procedimento proc2 que também 
mostra o valor da variável var1 na tela através da função msgbox. 
Perceba com isso que tanto no proc1 quanto no proc2, conseguimos ter 
acesso ao valor da variável var, justamente pelo fato de esta ser de 
escopo modular. 
ESCOPO DE PROJETO 
É uma variável que foi inicialmente declarada na seção de 
declarações do módulo, fora de qualquer procedimento, muito parecido 
com a declaração das variáveis de escopo modular com a diferença que 
antes do nome da variável deve-se utilizar a palavra chave Public. Com 
isso a variável pode ser utilizada dentro de qualquer módulo da pasta de 
trabalho, ou seja, do projeto. 
Para melhor entendermos a utilização das variáveis com escopo de 
projeto, proceda da seguinte maneira: 
1. Abra uma nova pasta de trabalho. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a seguir: 
 
 
4. Em seguida, insira um novo módulo, digitando o seguinte código: 
 
5. Retorne ao módulo anterior e execute o procedimento proc1. 
Com isso irá surgir uma caixa de mensagem com o valor da variável 
var. 
 
6. Clique o botão OK. 
Em seguida, surgirá uma nova caixa de mensagem com o novo 
valor da variável var. 
 
Pronto! Com isso aprendemos sobre a declaração, utilização e 
escopo de variáveis. 
 
 
MÓDULO 4 – SUB-ROTINAS E FUNÇÕES 
Como visto em módulos anteriores, quando se grava uma macro no 
Excel, este tem um comportamento em background que realiza a 
respectiva codificação para Visual Basic for Applications, onde cada 
macro criada dá origem a um procedimento ou rotina. 
Existem dois tipos de rotinas: 
1. Sub-rotinas ou rotinas Sub. 
2. Funções. 
SUB-ROTINAS 
Um grupo de comandos que podem ser executados, através da 
chamada do nome da sub-rotina, cuja definição é delimitada pelas 
palavras-chave Sub e End Sub. 
As sub-rotinas podem possuir ou não argumentos, que são valores 
passados para a sub-rotina, os quais serão utilizados internamente para 
a realização de cálculos, por exemplo, se você vai criar um sub-rotina 
para cálculo do desconto do cliente com base no seu valor de compra, 
você poderia definir um argumento para esta sub-rotina que irá informá-la 
o salário do cliente. 
Para criação de uma sub-rotina, devemos seguir a seguinte sintaxe: 
Sub <nome_da_sub-rotina> (<lista_de_argumentos>) 
 <bloco_de_comandos> 
End Sub 
Na <lista_de_argumentos>, cada argumento que 
compor esta sub-rotina, deve estar associado a um tipo de 
dados, caso essa informação seja omitida, será considerado 
o tipo default para o argumento, no caso Variant. 
As sub-rotinas são designadas pelo nome que lhe atribuímos, onde 
este nome pode ser qualquer, desde que não contenham espaços, nem 
comecem por caracteres numéricos. 
Como visto anteriormente, as sub-rotinas podem ou não conter 
argumentos. Caso sejam necessários, estes devem ser passados 
quando a sub-rotina for chamada e devem estar na mesma ordem em 
que foram definidos. 
Para ter a noção do que são parâmetros lembre-se do 
funcionamento das funções do Excel, que para executarem 
determinada função necessitam de receber parâmetros que 
colocamos entre parênteses separados por vírgulas. 
Quando criar sub-rotinas, procure utilizar nomes que 
descrevem a função da sub-rotina. Com isso tornamos o 
código mais fácil de ser entendido. 
 
Uma vez criada a sub-rotina, sempre que fomos chamá-la dentro de 
um código, devemos digitar o nome da sub-rotina precedido da palavra 
Call. 
Para melhor entendermos o funcionamento de uma sub-rotina, 
vamos ao um exemplo prático: 
1. Abra uma nova pasta de trabalho. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a seguir: 
 
4. Execute o procedimento proc1. 
Com isso, surgirá na tela a seguinte caixa de mensagem: 
 
No exemplo anterior, temos dois procedimentos, o primeiro 
chamado de proc1, onde temos duas variáveis declaradas. Em seguida, 
atribuímos valores a estas variáveis e as passamos como argumentos 
para o procedimento concatena, que esta declarada logo abaixo. No 
procedimento concatena, pegamos os valores das duas variáveis e 
mostramos na tela usando a função msgbox, 
EXERCICIO 
1. Em uma nova pasta de trabalho, abra o Editor do VBA e 
crie dois procedimentos: 
Calcula_Desc: Este procedimento deverá receber como parâmetro, 
duas variáveis do tipo Currency chamadas respectivamente de Salario 
e Desconto. Dentro do procedimento devera ser declarada uma variável 
local do tipo Currency chamada Sal_Final, esta variável devera receber 
o valor do salário com desconto. Em seguida o valor da variável 
Sal_final deve ser mostrado na tela. 
Proc1: Neste procedimento deve-se declarar duas variáveis locais 
do tipo Currency chamadas respectivamente de Salario e Desconto. 
Em seguida, atribua um valor qualquer a variável Salario, exemplo 
(2000), e outro valor a variável Desconto, exemplo (0.1) e passe estas 
duas variáveis como parâmetro para a função Calcula_Desc. 
2. Por fim execute a função Proc1. 
Com isso deverá ser exibida na tela uma caixa de 
mensagem informando o salário já descontado. 
 
 
FUNÇÕES 
Um grupo de comandos que podem ser executados, através da 
chamada do nome da função, cuja definição é delimitada pelas palavras-
chave Function e End Function. 
Toda função é identificada pelo nome, pelo número e tipo de 
parâmetros recebidos, e tem como objetivo executar um conjunto de 
instruções e produzir um valor final. Isto é, toda vez que se executar uma 
função, esta sempre produzirá um valor. Recorde-se como exemplo a 
função SUM, esta recebe por parâmetro um conjunto de valores que se 
pretende somar e sabe-se que o resultado da aplicação dessa função ao 
conjunto de valores será o respectivo somatório. 
As funções podem ou não conter argumentos. Caso sejam 
necessários, estes devem ser passados quando a função for chamada e 
devem estar na mesma ordem em que foram definidos. 
Para definir o valor produzido por uma função basta no seu interior, 
atribuir ao nome da função um determinado valor ou expressão. 
Quando criar funções, procure utilizar nomes que 
descrevem a função da sub-rotina. Com isso tornamos o 
código mais fácil de ser entendido. 
 
CUIDADO! Não confundir Sub-rotina com função. 
Apesar de suas sintaxes serem parecidas, uma função 
sempre retorna um ou mais valores para o comando que a 
chamou. 
Para criação de uma função, devemos seguir a seguinte sintaxe: 
Sub <nome_da_função> (<lista_de_argumentos>) As <Tipo> 
 <bloco_de_comandos> 
End Function 
Observe que além da <lista_de_argumentos>, onde 
cada argumento que compor esta função deve estar 
associado a um tipo de dados, temos também um <tipo>. 
Este <tipo> esta associado à função e serve para especificar 
o tipo de dados que a função irá retornar, caso esteja omitido, será 
considerado o tipo default, no caso Variant. 
Considere o exemplo a seguir: 
 
No exemplo anterior, declaramos uma função chamada 
converte_dolar, que espera receber dois argumentos do tipo Currency 
(valor_real, cotação_dolar) e definimos também que a função irá 
retornar um valor do mesmo tipo Currency. 
No momento em que formos chamar esta função em algum código, 
devemos utilizar o operador de atribuição, isto é, o valor que a função irá 
retornar, deve ser atribuído a uma variável, ou exibido na tela através da 
função msgbox. 
No próximo exemplo, estamos atribuindo a variável valor_dolar, o 
valor retornado pela função converte_dolar. 
 
Ao invés de atribuir o valor de retorno da função a uma variável, 
poderíamos exibi-lo na tela usando a função msgbox. 
 
Para melhor entendermos o funcionamento de uma função, vamos 
ao um exemplo prático: 
1. Abra o arquivo Exercício 6.xls localizado na pasta da turma.2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a 
seguir: 
 
4. Salve e feche o Editor do VBA. 
Com isso, sua função já esta pronta. Vamos agora 
testá-la em uma célula dentro do Excel. 
 
EXECUTANDO A FUNÇÃO CRIADA, NO EXCEL 
Para utilizar a função criada no VBA, dentro de uma célula em uma 
das planilhas do Excel, proceda da seguinte maneira: 
1. Selecione a célula D4. 
2. Clique o menu Inserir. 
3. Clique a sub-opção Função. 
Com isso, surgirá à janela Inserir Função. 
 
 
4. Selecione a categoria Definida pelo usuário. 
5. Selecione o nome da função calcula_desconto. 
6. Clique o botão OK. 
Com isso, surgirá a tela Argumentos da função. 
 
7. No campo Salário, digite B4. 
8. No campo Desconto, digite C4. 
9. Clique o botão OK. 
10. Copie a fórmula no intervalo de células D4:D10. 
A planilha deverá ser exibida conforme a figura abaixo. 
 
MÓDULO 5 – FUNÇÕES INTERNAS DO VBA 
Neste módulo apresentaremos algumas funções internas do VBA, 
funções estas que serão de extrema importância para a solução de 
algumas situações que encontraremos mais adiante no curso, pois 
diminuirão muito o tempo para solucionar tais problemas. 
Para isto, dividiremos estas funções por categorias para melhor 
entendimento. 
FUNÇÕES DE TIPO 
Aqui veremos algumas funções para determinar o tipo de dados de 
uma variável. 
FUNÇÃO ISDATE 
Esta função recebe uma variável como argumento e determina se 
esta contém uma data válida. Caso o argumento passado seja uma data 
válida, a função retornará Verdadeiro, caso contrário, retornará Falso. 
A sintaxe desta função é a seguinte: 
IsDate(<variável>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
FUNÇÃO ISNUMERIC 
Esta função recebe uma variável como argumento e determina se o 
valor atribuído a ela é um valor numérico. Caso o valor seja numérico, a 
função retornará Verdadeiro, caso contrário, retornará Falso. 
A sintaxe desta função é a seguinte: 
IsNumeric(<variável>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
FUNÇÕES PARA TRATAMENTO DE TEXTO 
Aqui veremos algumas funções para tratamento de texto, via 
programação VBA. 
FUNÇÃO LEN 
Esta função determina o tamanho da String que foi passada como 
parâmetro para a função. 
A sintaxe desta função é a seguinte: 
Len(<variável>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá, 
mostrando o número de caracteres existente na variável. 
 
Espaços em branco também contam para o tamanho da 
string. 
 
FUNÇÃO LCASE 
Esta função converte para minúsculas, a string que foi passada 
como parâmetro para a função. 
A sintaxe desta função é a seguinte: 
Lcase(<variável>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO UCASE 
Esta função converte para maiúsculas, a string que foi passada 
como parâmetro para a função. 
A sintaxe desta função é a seguinte: 
Ucase(<variável>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO MID 
Esta função retorna um número especificado de caracteres, a partir 
de uma posição especificada dentro de uma string.Lembre-se que 
espaços em branco também devem ser considerados. 
A sintaxe desta função é a seguinte: 
Mid(<string>, <pos_inicial>, <num_caract>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO STRING 
Esta função retorna um determinado caractere, um número 
especificado de vezes. 
A sintaxe desta função é a seguinte: 
String(<num_repet>, <caractere>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÕES DE DATA E HORA 
Aqui veremos algumas funções para tratamento de data e hora, via 
programação VBA. 
FUNÇÃO DATE 
Esta função retorna a data atual do sistema operacional. Esta é 
uma função que não possui argumentos. 
A sintaxe desta função é a seguinte: 
Date() 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO TIME 
Esta função retorna a hora atual do sistema operacional. Esta é 
uma função que não possui argumentos. 
A sintaxe desta função é a seguinte: 
Time() 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO DAY 
Esta função retorna o dia do mês de uma determinada data 
passada como parâmetro. 
A sintaxe desta função é a seguinte: 
Day(<data>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO MONTH 
Esta função retorna um número entre 1 e 12, indicando o mês de 
uma determinada data passada como parâmetro. 
A sintaxe desta função é a seguinte: 
Month(<data>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO YEAR 
Esta função retorna o ano de uma determinada data passada como 
parâmetro. 
A sintaxe desta função é a seguinte: 
Year(<data>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO MONTHNAME 
Esta função recebe como parâmetro um número, que indica o mês 
do ano (1-Janeiro 2-Fevereiro...). 
A sintaxe desta função é a seguinte: 
MonthName(<Num_mês>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO HOUR 
Esta função recebe como parâmetro uma hora e retorna um número 
entre 0 e 23, indicando a hora atual. 
 
A sintaxe desta função é a seguinte: 
Hour(<hora>) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
Ao clicar OK, uma nova caixa de mensagem surgirá. 
 
FUNÇÃO DATEDIFF 
Esta função é utilizada para determinar um intervalo entre duas 
datas, podendo este intervalo ser entre dias, trimestres, semestres, anos 
e etc. 
A sintaxe desta função é a seguinte: 
DateDiff(<intervalo>,<data1>,<data2>) 
O argumento <intervalo>, é uma string que indica o tipo 
de intervalo que iremos calcular. Para sabermos como 
calcular um intervalo entre duas datas devemos conhecer a 
tabela seguinte: 
<Intervalo> Descrição 
yyyy Anos 
q Trimestres 
m Meses 
d Dias 
w Semanas 
h Horas 
n Minutos 
s Segundos 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO DATEADD 
Esta função é utilizada para determinar uma data futura, com base 
em uma data fornecida, o tipo de intervalo a ser acrescentado e o 
número a ser acrescentado. Este intervalo pode ser entre dias, 
trimestres, semestres, anos e etc. 
A sintaxe desta função é a seguinte: 
DateAdd (<intervalo>,<acréscimo>,<data>) 
O argumento <acréscimo>, é a ser acrescentado a 
data para achar a nova data final. 
 
O argumento <intervalo>, é uma string que indica o tipo 
de intervalo que iremos calcular. Para sabermos como 
calcular um intervalo entre duas datas devemos conhecer a 
tabela seguinte: 
<Intervalo> Descrição 
yyyy Anos 
q Trimestres 
m Meses 
d Dias 
w Semanas 
h Horas 
n Minutos 
s Segundos 
Abaixo, segue um exemplo que ilustra o uso desta função:Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO WEEKDAY 
Esta função é utilizada para determinar o dia da semana 
correspondente a uma data. Esta função recebe como argumento uma 
data e um valor opcional que indica o primeiro dia da semana, sendo que 
se este valor for omitido, o primeiro dia da semana considerado será 
Domingo. O valor para indicar o primeiro dia da semana deve ser 
definido assim: 1 – Domingo, 2 – Segunda e assim por diante. 
A sintaxe desta função é a seguinte: 
WeekDay (<data>,[<1º_dia_semana>]) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
FUNÇÃO WEEKDAYNAME 
Esta função é utilizada para determinar o nome do dia da semana. 
Esta função recebe como argumento um número que indica o dia da 
semana e outro argumento opcional que pode ser Verdadeiro ou Falso. 
Se o segundo argumento for Verdadeiro, o nome do dia da semana será 
exibido abreviado. Caso seja omitido o valor Falso será considerado por 
padrão. 
A sintaxe desta função é a seguinte: 
WeekDayName (<num_dia_semana>,[<abreviar>]) 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Na execução deste procedimento, uma caixa de mensagem surgirá. 
 
OUTRAS FUNÇÕES ÚTEIS 
Aqui segue uma lista de algumas funções também importantes para 
programação VBA. 
 
Função Descrição 
Shell Roda um programa executável. 
Rnd Retornar um número aleatório entre 0 e 1. 
Sqr Retorna a raiz quadrada de um número. 
 
EXERCÍCIO 1 
1. Abra o arquivo, Exercício 12.xls, localizado na pasta da 
turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e digite o código abaixo: 
 
4. Execute o procedimento data. 
Pronto! Com isso, ficamos conhecendo algumas 
funções internas do VBA, que serão de extrema importância 
para a solução de alguns problemas. 
 
 
MÓDULO 6 – TRATAMENTO DE ERROS 
Nos códigos podemos nos deparar com determinados erros a 
depender de determinadas condições. Podemos nos deparar com um 
erro de sintaxe, quando um comando do código é digitado 
incorretamente, por exemplo, ao invés de uma vírgula, você digita ponto 
e vírgula. 
Podemos encontrar também erros de lógica, erros estes mais 
difíceis de serem identificados, pelo fato do usuário ter falhado no teste 
de alguma condição do código. 
Temos também os erros chamados de erros em tempo de 
execução, onde o erro somente será identificado durante a execução da 
rotina, como por exemplo, tentamos acessar um aplicativo em um 
diretório onde este foi movido para outro local. 
Por isso, devemos sempre utilizar o comando para tratamento de 
possíveis erros que podem acontecer durante a execução do código. 
A sintaxe para utilização deste comando é a seguinte: 
On Error Resume Next 
Neste comando caso um erro seja encontrado o código é deslocado 
para um bloco especifico onde ocorre o tratamento deste erro, logo em 
seguida ao término deste tratamento, o código retorna para a primeira 
instrução após a instrução que gerou o erro. 
Se não usarmos a instrução On Error, ou seja, caso não façamos os 
tratamentos dos possíveis erros que venham a acontecer, qualquer erro 
em tempo de execução que ocorrer, será fatal, isto é, será exibida uma 
mensagem de erro e a execução do procedimento será encerrada. 
Abaixo, segue um exemplo que ilustra o uso desta função: 
 
Neste exemplo, declaramos duas variáveis do tipo Double, logo 
em seguida definimos que em caso de erro, a execução será deslocada 
para o bloco de comandos para tratamento do erro chamado trata_erro. 
Logo após forçamos um erro, usando o número 0 (zero) como 
denominador de uma divisão, na qual resultará em um erro, daí então a 
execução é deslocada para o bloco do código chamado trata_erro. Lá 
uma caixa de mensagem surge informando que um erro foi encontrado. 
Ao finalizar o tratamento do erro, a execução do código retorna para 
a próxima instrução logo após a instrução que gerou o erro, no caso uma 
variável x recebe o valor 10 (dez), que é logo imprimido na tela. Isto 
acontece, pois logo após o tratamento do erro temos o Resume Next. 
Com isso encontra-se o End Sub, finalizando assim a execução do 
código. 
Caso após a instrução de tratamento do erro não tivéssemos o 
Resume Next, o tratamento seria feito e o código seria imediatamente 
encerrado, pois encontraria um End Sub. 
 
EXERCÍCIO 1 
1. Abra o arquivo, Exercício 13.xls, localizado na pasta da 
turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e digite o código abaixo: 
 
4. Execute o procedimento calc. 
Neste procedimento temos declarado uma variável RetVal, logo 
após definimos que em caso de erro a execução será deslocada para o 
bloco de comandos chamado tratar_erro. 
A depender do sistema operacional a primeira atribuição 
a variável RetVal pode ou não gerar um erro, na verdade 
esta atribuição faz com que a variável receba o caminho 
onde encontra-se a calculadora e logo em seguida a execute. 
Pronto! Com isso, ficamos conhecendo como tratar 
possíveis erros que venham a acontecer no código. 
 
MÓDULO 7 – ESTRUTURAS DE CONTROLE 
Além da declaração de variáveis e cálculos básicos, o VBA fornece 
uma serie de comandos conhecidos como estruturas de controle. Estas 
são utilizadas no código para a realização de testes, por exemplo, 
verificar se o valor de uma variável é maior que x, se for, execute estes 
comandos, caso contrário execute outros comandos. Estes testes são 
muito utilizados em programação, sendo praticamente impossível não 
utiliza-los no seu código. 
Controle VBA Objetivo 
IF... Then 
Testa uma condição e executa um 
determinado conjunto de instruções de 
acordo com o resultado dessa avaliação. 
For... Next Executa uma determinada tarefa um determinado número de vezes. 
Do... Loop 
Executa uma tarefa, enquanto que a 
avaliação de uma condição seja ou torne-se 
verdadeira. 
 
A ESTRUTURA IF... THEN 
Uma das estruturas de controle mais conhecidas. Praticamente toda 
linguagem de programação implementa esta estrutura, sendo utilizada 
para executar determinados comandos, caso uma condição seja 
verdadeira. 
A sintaxe desta estrutura é a seguinte: 
If <condição> Then 
 <bloco_de_comandos> 
End If 
Neste caso a <condição> é testada, caso esta seja verdadeira, o 
<bloco_de_comandos> é executado. 
Para melhor entendermos o funcionamento desta estrutura, vamos 
ao um exemplo prático: 
1. Abra o arquivo Exercício 7.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a 
seguir: 
 
4. Execute a rotina lógica. 
Com isso, a depender do valor das variáveis num1 e num2, uma 
caixa de mensagem poderá ou não surgir, definindo que o valor de num1 
é maior do que o de num2, logo em seguida será exibido uma outra 
caixa de mensagem informando o valor destas variáveis. 
Neste exemplo além dos recursos já conhecidos, 
fizemos uso da função Rnd (), esta função retorna como 
resultado um número aleatório. No nosso caso como fizemos 
Rnd * 50, estamos solicitando um número aleatório entre 0 e 
50. 
Utilizamos também a função Int (), que retorna apenas a 
parte inteira do valor obtido pela função Rnd * 50. 
 
A ESTRUTURA IF... THEN... ELSE 
Esta estrutura de controle é muito interessante, pois acrescenta a 
estrutura IF... THEN mais uma possibilidade. Muito utilizada para 
executar comandos, caso uma condição seja verdadeira, ou outros 
comandos, caso a condição seja falsa. 
A sintaxe desta estrutura é a seguinte: 
If <condição> Then 
 <bloco_de_comandos_1> 
Else 
 <bloco_de_comandos_2> 
End If 
Neste caso a <condição> é testada, caso esta seja verdadeira, o 
<bloco_de_comandos_1> é executado, senãoo 
<bloco_de_comandos_2> é que será executado. 
Para melhor entendermos o funcionamento desta estrutura, vamos 
ao um exemplo prático: 
1. Abra o arquivo Exercício 8.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a 
seguir: 
 
4. Execute a rotina pontuacao. 
Com isso, a depender do valor da variável pontos, uma caixa de 
mensagem irá surgir, definindo se o valor de pontos esta acima ou 
abaixo da média. 
Logo em seguida será mostrada uma nova caixa de mensagem que 
conterá o valor da variável pontos. 
A ESTRUTURA IF... THEN... ELSEIF 
Esta estrutura nos da um maior poder, para testarmos diversas 
possibilidades, isto é, podemos fazer vários testes e executar diferentes 
comandos com base no resultado destes testes. Muito utilizada sempre 
que necessitarmos realizar mais do que um teste lógico, onde em cada 
novo teste, utilizamos o ElseIf. 
A sintaxe desta estrutura é a seguinte: 
If <condição_1> Then 
 <bloco_de_comandos_1> 
ElseIf <condição_2> 
 <bloco_de_comandos_2> 
ElseIf <condição_3> 
 <bloco_de_comandos_3> 
ElseIf <condição_n> 
 <bloco_de_comandos_n> 
Else 
 <bloco_de_comandos_final> 
End If 
Neste caso a <condição_1> é testada, caso esta seja verdadeira, o 
<bloco_de_comandos_1> é executado, senão a <condição_2> é testada, 
caso esta seja verdadeira, o <bloco_de_comandos_2> será executado, 
senão a <condição_3> é testada, caso esta seja verdadeira, o 
<bloco_de_comandos_3> será executado, senão a <condição_n> é 
testada, caso seja verdadeira, o <bloco_de_comandos_n> será 
executado, senão o <bloco_de_comandos_final> é que será executado, 
pois todas as condições falharam. 
Somente um dos <bloco_de_comandos> é que será 
executado. Onde uma condição sendo verdadeira, o 
<bloco_de_comandos> associado a esta condição será 
executado, ao término a execução segue para o End If, isto é, as demais 
condições da estrutura não serão testadas. 
Para melhor entendermos o funcionamento desta estrutura, vamos 
ao um exemplo prático: 
1. Abra o arquivo Exercício 9.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a seguir: 
 
4. Execute a rotina idade. 
Com isso, a depender do valor armazenado na variável idade, uma 
caixa de mensagem surgirá informando a classe etária pertencente à 
idade. Ao término da estrutura If, aparecerá uma outra caixa de 
mensagem informando o valor da variável idade. 
 
Na instrução Elseif, sempre que uma condição for 
avaliada como falsa, uma outra condição é avaliada. Caso 
todas as condições sejam falsas, a condição da instrução 
Else, é que será executada. Já se uma condição for avaliada 
como verdadeira, as instruções pertencentes a esta condição 
será executada e a estrutura If, é finalizada. 
EXERCICIO 1 
1. Criar um procedimento chamado Aposta. 
1.1. No procedimento Aposta, declarar duas variáveis inteiras 
chamadas naposta e nsorteio. 
1.2. Naposta recebe o valor 30. 
1.3. Nsorteio recebe o resultado da função Sorteio. 
1.4. Comparar o valor de naposta com nsorteio, caso sejam 
iguais, surgirá uma mensagem informando que os números são 
iguais, senão, surgirá uma mensagem informando que os 
números são diferentes. 
2. Criar uma função chamada Sorteio. 
2.1. Esta função deverá retornar um número randômico inteiro 
entre 0 e 50. 
3. Execute o procedimento Aposta. 
 
Formatado: Fonte: Não
Negrito
A ESTRUTURA FOR... NEXT 
Um comando muito utilizado para repetir um determinado trecho do 
código um determinado número de vezes. 
Utilizamos esta estrutura, quando já conhecemos o número de 
vezes que devemos repetir determinado trecho de código. 
Nesta estrutura utiliza-se uma variável como contador, onde este 
varia de um valor inicial até um valor final. 
A sintaxe desta estrutura é a seguinte: 
For contador = <valor_inicial> To <valor_final> [ Step 
<incremento>] 
 <bloco_de_comandos> 
Next 
Nesta estrutura a variável contador, tem seu valor inicial definido. 
Em cada passagem do laço, o <bloco_de_comandos> será executado 
e esta variável é incrementada pelo valor definido em <incremento>, 
sendo que se este <incremento> tiver sido omitido, o valor será o 
padrão 1. 
Assim todo o <bloco_de_comandos> vai sendo executado toda 
vez que o laço for repetido até que o valor da variável contador seja 
igual ao <valor_final>. 
Para melhor entendermos o funcionamento desta estrutura, vamos 
ao um exemplo prático: 
1. Abra o arquivo Exercício 10.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a seguir: 
 
4. Execute a rotina somanum. 
Com isso, surgirá uma caixa de mensagem informando o valor da 
variável soma. 
 
Neste exemplo, a variável i inicia com o valor 1 e em 
cada passo, o valor de i é somado com o valor existente na 
variável soma. Note também que neste exemplo o 
incremento não foi definido, daí o valor será o padrão 1. Com 
isso, ao final de todos os laços do For... Next, a variável soma, conterá a 
soma dos dez primeiros números maiores que zero e este valor será 
mostrado em uma caixa de mensagem. 
 EXERCICIO 
1. Crie um procedimento que mostre na tela, a soma dos 
10 primeiros números ímpares. 
A ESTRUTURA DO... LOOP 
Esta estrutura deve ser utilizada para repetir um trecho do código, 
enquanto uma condição seja verdadeira, ou até que ela torne-se 
verdadeira. Para isto, podemos utilizar dois operadores condicionais 
diferentes: While ou Until. 
Estes operadores podem ser utilizados de duas maneiras 
diferentes: no inicio ou no final do laço. Com isso teremos quatro 
situações diferentes. 
DO WHILE <condição>... LOOP 
Neste método, estamos utilizando o operador While no inicio do 
laço. Para esta estrutura, devemos seguir a seguinte sintaxe: 
Do While <condição> 
 <bloco_de_comandos> 
Loop 
Neste tipo de estrutura, enquanto <condição> for 
verdadeira, o <bloco_de_comandos> será executado, caso 
esta seja falsa, o próximo comando após o laço será 
executado. Caso <condição> seja falsa na primeira análise, 
o <bloco_de_comandos> não será executado nenhuma vez. 
CUIDADO! Dentro do laço do While, deve existir algum 
código capaz de alterar a condição para que esta se torne 
falsa, em algum momento, pois caso contrário a condição 
sempre estará verdadeira e o <bloco_de_comandos> 
dentro do laço ficará em execução infinitamente ou até que o programa 
trave. A criação de laços infinitos é uma causa comum de erros e 
travamentos. 
Para melhor entendermos o funcionamento desta estrutura, vamos 
ao um exemplo prático: 
1. Abra o arquivo Exercício 11.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a seguir: 
 
4. Execute o procedimento soma. 
Com isso, irá aparecer uma caixa de mensagem informando o valor 
da variável. 
 
DO... LOOP WHILE <condição> 
Nesta estrutura, temos a condição do teste no final do laço, com 
isso, o código dentro do laço será executado pelo menos uma vez, pois a 
condição somente será testada no final do laço, voltando a ser 
executado, caso a condição seja verdadeira. 
 
 
 Para esta estrutura, devemos seguir a seguinte sintaxe: 
Do 
 <bloco_de_comandos> 
Loop While <condição> 
Neste tipo de estrutura, enquanto <condição> for 
verdadeira, o <bloco_de_comandos> será executado, caso 
esta seja falsa, o próximo comando após o laço será 
executado. Caso <condição> seja falsa na primeira análise, 
o <bloco_de_comandos> será executado uma única vez. 
CUIDADO! Dentro do laço do While, deve existir algum 
código capaz de alterar a condição para que esta se torne 
falsa, em algum momento, pois caso contrárioa condição 
sempre estará verdadeira e o <bloco_de_comandos> 
dentro do laço ficará em execução infinitamente ou até que o programa 
trave. A criação de laços infinitos é uma causa comum de erros e 
travamentos. 
Para melhor entendermos o funcionamento desta estrutura, vamos 
ao um exemplo prático: 
1. Abra o arquivo Exercício 11.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a seguir: 
 
4. Execute o procedimento soma. 
Com isso, irá surgir uma caixa de mensagem informando o valor da 
variável soma. 
 
Neste exemplo, a condição contador <= x é falsa logo 
no primeiro teste, pois contador = 12 e x = 10. Neste caso o 
laço será executado uma única vez, pois o teste da condição 
encontra-se no final do laço. 
DO UNTIL <condição>... LOOP 
Nesta estrutura, estamos utilizando o operador condicional Until, no 
ínicio do laço. 
Para esta estrutura, devemos seguir a seguinte sintaxe: 
Do Until <condição> 
 <bloco_de_comandos> 
Loop 
Neste tipo de estrutura, enquanto <condição> for falsa, 
o <bloco_de_comandos> será executado, caso esta seja 
verdadeira, o próximo comando após o laço será executado. 
Caso <condição> seja verdadeira na primeira análise, o 
<bloco_de_comandos> não será executado nenhuma vez. 
CUIDADO! Dentro do laço do Until, deve existir algum 
código capaz de alterar a condição para que esta se torne 
verdadeira, em algum momento, pois caso contrário a 
condição sempre estará falsa e o <bloco_de_comandos> 
dentro do laço ficará em execução infinitamente ou até que o programa 
trave. A criação de laços infinitos é uma causa comum de erros e 
travamentos. 
Para melhor entendermos o funcionamento desta estrutura, vamos 
ao um exemplo prático: 
1. Abra o arquivo Exercício 11.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a seguir: 
 
4. Execute o procedimento soma. 
Com isso, irá aparecer uma caixa de mensagem informando o valor 
da variável. 
 
DO... LOOP UNTIL <condição> 
Nesta estrutura, temos a condição do teste no final do laço, com 
isso, o código dentro do laço será executado pelo menos uma vez, pois a 
condição somente será testada no final do laço, voltando a ser 
executado, caso a condição seja falsa. 
Para esta estrutura, devemos seguir a seguinte sintaxe: 
Do 
 <bloco_de_comandos> 
Loop Until <condição> 
Neste tipo de estrutura, enquanto <condição> for falsa, 
o <bloco_de_comandos> será executado, caso esta seja 
verdadeira, o próximo comando após o laço será executado. 
Caso <condição> seja verdadeira na primeira análise, o 
<bloco_de_comandos> será executado uma única vez. 
CUIDADO! Dentro do laço do Until, deve existir algum 
código capaz de alterar a condição para que esta se torne 
verdadeira, em algum momento, pois caso contrário a 
condição sempre estará falsa e o <bloco_de_comandos> 
dentro do laço ficará em execução infinitamente ou até que o programa 
trave. A criação de laços infinitos é uma causa comum de erros e 
travamentos. 
Para melhor entendermos o funcionamento desta estrutura, vamos 
ao um exemplo prático: 
1. Abra o arquivo Exercício 11.xls localizado na pasta da turma. 
2. Abra o Editor do VBA. 
3. Insira um novo módulo e dentro dele, digite o código a seguir: 
 
4. Execute o procedimento soma. 
Com isso, irá aparecer uma caixa de mensagem informando o valor 
da variável. 
 
Neste exemplo, a condição contador >= x é verdadeira 
logo no primeiro teste, pois contador = 12 e x = 10. Neste 
caso o laço será executado uma única vez, pois o teste da 
condição encontra-se no final do laço. 
EXERCICIO 1 
1. Crie um procedimento chamado Loteria. Neste 
procedimento uma variável do tipo Integer, deverá receber 
um número randômico inteiro entre 0 e 15. Crie um laço de 
repetição que compara o valor da variável com o número 10, 
caso sejam iguais, devemos mostrar na tela uma mensagem 
informando que o número foi encontrado e informar também 
o número de tentativas até localizar o número. 
 
Pronto! Com isso, aprendemos a trabalhar com as 
estruturas de controle, que nos serão muito úteis na 
resolução de diversos problemas. 
REVISÃO 1 
1. Na pasta da turma, abra o arquivo chamado Revisão 1.xls, 
abra o Editor do VBA e insira um novo módulo. Dentro dele, 
crie uma função chamada de IRPF que deverá calcular o 
Imposto de renda pessoa física. Para isto a função deverá 
receber como parâmetro uma variável do tipo Currency, que 
será à base de cálculo para o cálculo do imposto. Esta 
função deverá retornar o valor do imposto a ser pago. O 
cálculo a ser feito, deverá seguir as condições da tabela 
oficial para o cálculo de imposto de renda no exercício de 
2008, conforme tabela a seguir: 
Base de cálculo anual 
em R$ 
Alíquota 
% 
Parcela a deduzir do imposto 
em R$ 
Até 15.764,28 - - 
De 15.764,29 até 
31.501,44 15,0 2.364,60 
Acima de 31.501,44 27,5 6.302,28 
2. Depois de criada a função IRPF, teste-a na planilha 
chamada IRPF, para calcular o imposto de cada pessoa. 
REVISÃO 2 
1. Na pasta da turma, abra o arquivo chamado Revisão 1.xls, 
abra o Editor do VBA e insira um novo módulo. Dentro dele, 
crie uma função chamada de CPF que deverá receber como 
parâmetro um valor de CPF no formato 111.111.111-11 ou a 
referência de uma célula que contém um CPF nesse 
formato. A função irá retornar a palavra Válido se este for 
válido, caso contrário retornar Inválido. 
A seguir, temos um exemplo de como se calcular o dígito verificador 
do CPF: 
Considere o seguinte CPF (sem o DV): 333.444.555 
Posição 1 2 3 4 5 6 7 8 9 
Número 3 3 3 4 4 4 5 5 5 
Deve-se multiplicar os dígitos do CPF, a partir da posição 9, ou 
seja, de trás para a frente, por 2,3,4 e assim por diante, conforme a 
tabela a seguir 
Posição 1 2 3 4 5 6 7 8 9 
Número 3 3 3 4 4 4 5 5 5 
Multiplica 
por: 
10 9 8 7 6 5 4 3 2 
Resultado 30 27 24 28 24 20 20 15 10 
Depois, devemos somar os resultados obtidos na quarta linha da 
tabela anterior: 
Soma 1 = 30+27+24+28+24+20+20+15+10 
Soma 1 = 198 
Faço a divisão desta soma por 11 e verifico o resto da divisão: 
Ex: 198/11 – Resulta em uma divisão exata, com resto 0. 
Agora, deve-se seguir a seguinte regra: 
• Quando o resto é zero ou um, o DV é zero 
• Quando o resto é diferente de zero ou um, o DV é obtido 
fazendo-se: 11-resto. 
Neste caso, como o resto foi zero, o primeiro DV é zero: 
DV1 = 0 
Este primeiro dígito verificador (DV1) passa a fazer parte do CPF, 
conforme a tabela a seguir: 
Posição 1 2 3 4 5 6 7 8 9 10 
Número 3 3 3 4 4 4 5 5 5 0 
Agora, devemos repetir o mesmo processo feito anteriormente, 
porém já considerando o DV1 como parte integrante do CPF, conforme 
mostrado na tabela a seguir: 
Posição 1 2 3 4 5 6 7 8 9 10 
Número 3 3 3 4 4 4 5 5 5 0 
Multiplica 
por: 
11 10 9 8 7 6 5 4 3 2 
Resultado 33 30 27 32 28 24 25 20 15 0 
Depois, devemos somar os resultados obtidos na quarta linha da 
tabela anterior: 
Soma 2 = 33+30+27+32+28+24+25+20+15+0 
Soma 2 = 234 
Faço a divisão desta soma por 11 e verifico o resto da divisão: 
Ex: 234/11 – Resulta em 21, com resto 3. 
Agora, deve-se seguir a seguinte regra: 
• Quando o resto é zero ou um, o DV é zero 
• Quando o resto é diferente de zero ou um, o DV é obtido 
fazendo-se: 11-resto. 
Neste caso, como o resto foi 3, o segundo DV é: 
DV2 = 11-3 
DV2 = 8 
Com isso, temos o CPF com os dois dígitos verificadores: 
Posição 1 2 3 4 5 6 7 8 9 10 11 
Número 3 3 3 4 4 4 5 5 5 0 8 
Ou seja: 33.444.555-08 
2. Depois de criada a função CPF, teste-a na planilha chamada 
CPF, para verificar se cada cpf da lista é válido ou não. 
REVISÃO 3 
1. Na pasta da turma, abra