Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Proibida a reprodução,
mesmo parcial, por qualquer
processo mecânico,
eletrônico, reprográfico, etc.,
sem a autorização, por
escrito, do(s) autor(es) e da
editora.”
MACRO E VBA
PARA MS EXCEL
MACRO E VBA PARA EXCEL
SUMÁRIO
INTRODUÇÃO............................................................................................................................................................................ 4
MACROS ..................................................................................................................................................................................... 4
NÍVEIS DE SEGURANÇA DE MACROS ........................................................................................................................................... 4
GRAVANDO UMA MACRO ........................................................................................................................................................... 6
EXECUTANDO A GRAVAÇÃO DA MACRO .................................................................................................................................... 7
ABRINDO PASTAS DE TRABALHO COM MACROS ......................................................................................................................... 9
EXECUTANDO UMA MACRO...................................................................................................................................................... 10
CONHECENDO A JANELA MACRO.............................................................................................................................................. 11
EXECUTANDO A MACRO UTILIZANDO TECLA DE ATALHO E BOTÃO DA BARRA DE FERRAMENTAS.............................................. 11
O EDITOR DO VISUAL BASIC ............................................................................................................................................. 14
CONHECENDO O EDITOR DO VISUAL BASIC .............................................................................................................................. 14
OS COMPONENTES DA JANELA DO EDITOR ................................................................................................................................ 14
A BARRA DE FERRAMENTAS PADRÃO ....................................................................................................................................... 15
O PROJECT EXPLORER .............................................................................................................................................................. 16
A JANELA DE CÓDIGOS .............................................................................................................................................................. 16
ENTENDENDO UM POUCO OS CÓDIGOS ...................................................................................................................................... 17
A JANELA VERIFICAÇÃO IMEDIATA ........................................................................................................................................... 17
CRIANDO E EDITANDO MACROS...................................................................................................................................... 18
CRIANDO UMA MACRO ............................................................................................................................................................. 18
VISUALIZANDO O CÓDIGO DAS MACROS .................................................................................................................................... 18
VISUALIZANDO O CÓDIGO DAS MACROS .................................................................................................................................... 18
OBJETOS, MÉTODOS E PROPRIEDADES ...................................................................................................................................... 19
EDITANDO MACROS .................................................................................................................................................................. 20
CRIANDO UMA MACRO COM CÉLULAS SELECIONADAS .............................................................................................................. 20
TESTANDO A MACRO PARA FORMATAR TABELA........................................................................................................................ 21
EVITANDO ERROS COM MACROS ............................................................................................................................................... 23
TRATANDO O ERRO ................................................................................................................................................................... 23
CRIANDO MACROS COM VÁRIOS OBJETOS E FUNÇÕES DO EXCEL .............................................................................................. 24
CONHECENDO A PASTA DE TRABALHO ...................................................................................................................................... 25
CONSTRUINDO A CAIXA DE DIÁLOGO ........................................................................................................................................ 26
CRIANDO A MACRO FILTRAR .................................................................................................................................................... 29
CRIANDO A MACRO EXIBIR_TUDO ............................................................................................................................................ 29
CRIANDO A MACRO EXIBIR_CAIXA........................................................................................................................................... 29
VINCULANDO AS MACROS AOS CONTROLES .............................................................................................................................. 30
INTRODUÇÃO AO VBA ......................................................................................................................................................... 32
VBA - VISUAL BASIC FOR APPLICATION................................................................................................................................... 32
PROGRAMAÇÃO EM VBA ......................................................................................................................................................... 32
VARIÁVEIS ................................................................................................................................................................................ 33
TIPOS DE VARIÁVEIS................................................................................................................................................................. 33
DECLARAÇÃO DE VARIÁVEIS .................................................................................................................................................... 34
CONSTANTES ............................................................................................................................................................................ 35
OPERADORES ............................................................................................................................................................................ 36
A ESTRUTURA DO VBA ............................................................................................................................................................ 37
PROCEDIMENTOS ...................................................................................................................................................................... 38
SUBS E FUNCTIONS ................................................................................................................................................................... 38
ARGUMENTOS DE SUBS E FUNCTIONS....................................................................................................................................... 39
OS ARGUMENTOS DE UMA ROTINA ........................................................................................................................................... 39
CONSTRUINDO PROCEDIMENTOS............................................................................................................................................... 40
www.webaula.com.br Pág.: 2/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
TESTANDO PROCEDIMENTOS .................................................................................................................................................... 41
CONSTRUINDO FUNÇÕES ........................................................................................................................................................... 41
TESTANDO FUNÇÕES................................................................................................................................................................. 42
CAIXAS DE MENSAGEM ............................................................................................................................................................ 43
ESTRUTURAS CONDICIONAIS .................................................................................................................................................... 48
O COMANDO IF......................................................................................................................................................................... 48
O COMANDO SELECT ................................................................................................................................................................ 51
ESTRUTURAS DE REPETIÇÃO..................................................................................................................................................... 52
O COMANDO FOR ..................................................................................................................................................................... 52
O COMANDO WHILE ................................................................................................................................................................. 54
DEPURAÇÃO DE CÓDIGO.................................................................................................................................................... 56
DEPURANDO UM CÓDIGO.......................................................................................................................................................... 56
TRATAMENTO DE ERROS EM ROTINAS......................................................................................................................... 61
TRATANDO ERROS.................................................................................................................................................................... 61
GERANDO ERROS ..................................................................................................................................................................... 63
PROPRIEDADES E MÉTODOS DO OBJETO ERR ........................................................................................................................... 66
A HIERARQUIA DE OBJETOS DO EXCEL........................................................................................................................ 68
OBJETOS DO EXCEL .................................................................................................................................................................. 68
O OBJETO APPLICATION ........................................................................................................................................................... 68
O OBJETO WORKBOOKS ........................................................................................................................................................... 70
O OBJETO WORKSHEETS .......................................................................................................................................................... 71
O OBJETO RANGE ..................................................................................................................................................................... 73
WORKBOOKS E WORKSHEETS......................................................................................................................................... 75
O PROJECT EXPLORER .............................................................................................................................................................. 75
PROGRAMANDO COM EVENTOS ................................................................................................................................................ 76
O USERFORM .......................................................................................................................................................................... 79
CONHECENDO OS FORMULÁRIOS - USERFORMS ....................................................................................................................... 79
CRIANDO FORMULÁRIOS .......................................................................................................................................................... 81
PROGRAMANDO O FORMULÁRIO ............................................................................................................................................... 84
UTILIZANDO O FORMULÁRIO NA PLANILHA ............................................................................................................................... 87
SEGURANÇA DE MACROS................................................................................................................................................... 89
SEGURANÇA ............................................................................................................................................................................. 89
PROTEGENDO CÓDIGOS ............................................................................................................................................................. 90
CONCLUSÃO............................................................................................................................................................................ 92
INTRODUÇÃO
MACROS
Uma macro é um conjunto de instruções que é executada dentro de um aplicativo do
Microsoft Office. Caso execute uma tarefa várias vezes no Microsoft Excel, por exemplo, você pode
automatizá-la com uma macro. Uma macro é uma seqüência de comandos e funções armazenadas em um
módulo do Visual Basic e pode ser executada sempre que você precisar executar a tarefa.
Por exemplo, se você sempre faz a mesma formatação de títulos em suas planilhas como
fonte Arial, tamanho 14, negrito e sublinhado duplo, você pode criar uma macro com todas essas
formatações já definidas e, no momento de utilizar fica muito mais simples, ao invés de ter que selecionar a
fonte, selecionar o tamanho, selecionar o botão negrito e selecionar o sublinhado duplo, você simplesmente
seleciona a macro, que pode estar em forma de botão em alguma barra de ferramentas ou como opção em
algum menu.
Gravação de uma macro: Quando uma macro é gravada, o Microsoft Excel armazena
informações sobre cada ação que você faz ao executar um série de comandos. Quando você para a gravação
da macro, essa seqüência de ações realizadas formam a macro. O Visual Basic armazena cada macro em
um novo módulo anexado a uma pasta de trabalho.
Execução de uma macro: Você pode executar uma macro escolhendo-a na lista na caixa de
diálogo Macros, que se encontra no menu Ferramentas/Macro. Para que uma macro seja executada sempre
que clicar em um botão específico ou pressionar uma determinada combinação de teclas, você pode atribuir
a macro a um botão da barra de ferramentas, um atalho do teclado ou um objeto gráfico em uma planilha.
Em Ferramentas/Macro você encontra outras opções além de Macros. Macros traz a lista de
macros já existentes em sua pasta de trabalho. Gravar nova macro é usada quando você deseja criar uma
nova macro. Segurança define o nível de segurança de suas pastas de trabalho e Editor de Visual Basic que
exibe o código de suas macros.
Gerenciamento de suas macros: Após gravar uma macro, você pode exibir seu código com
o Editor do Visual Basic para corrigir erros ou alterar o que a macro faz. Por exemplo, caso deseje que a
macro de formatação de título também deixe o título em itálico, pode gravar outra macro para aplicar itálico
a uma célula e copiar as instruções dessa macro para a macro de formatação de título.
O Editor do Visual Basic é um programa criado para facilitar a gravação e edição de código
de macro para iniciantes. Com uma visão simples de como funciona o Visual Basic, você consegue fazer
alterações simples nas macros. Com o Editor do Visual Basic, é possível editar macros, copiar macros de um
módulo para outro, copiar macros entre pastas de trabalho diferentes, renomear os módulos que
armazenam as macros ou renomear as próprias macros.
Segurança de macros: O Microsoft Excel fornece proteção contra vírus que podem ser
transmitidos através das macros. Sempre que abrir uma pasta de trabalho que contenha macros, você
poderá ser avisado que aquela pasta de trabalho contém macros, podendo aceitar ou não que o arquivo seja
aberto com macros, para isso, você precisa ativar os níveis de segurança das macros.
As opções de nível de segurança definem o modo como o Excel trabalha a proteção contra os
vírus de macro. Na caixa de diálogo Segurança (menu Ferramentas/Macro), em diferentes condições, em
todas as configurações, se o software antivírus que funciona com o Microsoft Office estiver instalado e o
arquivo contiver macros, o arquivo será examinado para verificar a existência de vírus conhecidos antes de
ser aberto.
• Alto: neste nível de segurança as macros passam por um processo de segurança rigoroso
e, na maioria dos casos, as pastas de trabalho são abertas sem as macros, ou seja, as
macros não são ativadas.
• Médio: neste nível de segurança o usuário interage ao abrir uma pasta de trabalho que
contenha macros; ele é questionado se deseja abrir o arquivo com habilitando as macros
ou não.
• Baixo: quando o nível de segurança é definido como baixo, todas as macros são tratadas
da mesma forma, independentemente se o arquivo contém ou não macro, ele será
aberto da mesma forma, se contém macros, todas as macros são ativadas.
O nível de segurança mais utilizado é o Médio, pois, com a definição desse nível, sempre que
abrirmos uma pasta de trabalho (arquivo) que contenha macros, o Microsoft Excel nos perguntará se
desejamos habilitar ou desabilitar as macros existentes no arquivo. Dessa forma, podemos desabilitar as
macros, caso, não conheçamos a procedência do arquivo que desejamos abrir.
Na caixa Nome da macro, inserimos um nome para a macro que estamos criando.
Observações:
• O primeiro caractere do nome da macro deve ser uma letra. Os demais caracteres
podem ser letras, números ou caracteres sublinhados;
• Não utilize caracteres especiais como nome da macro, como, por exemplo, %, $, #,
&, entre outros.
• Não utilize como nome de macro que seja uma referência de célula, como, por
exemplo, A1, B6, entre outros.
A letra da tecla de atalho usada não pode ser um número ou caractere especial, como, por
exemplo, %, $, #, &, entre outros.
Observação:
Na caixa Armazenar macro em, escolhemos o local onde desejamos gravar a macro.
• Pasta de trabalho pessoal de macros: a macro fica disponível toda vez que você
utilizar o Excel, para qualquer pasta de trabalho;
• Esta pasta de trabalho: grava a macro na pasta de trabalho ativa, a macro fica
disponível nesta pasta de trabalho.
• Nome da macro;
• Tecla de atalho;
• Local de armazenamento, e;
• Descrição.
E, depois disso, clicamos no botão OK, aparecerá uma barra de ferramentas, conforme a
figura abaixo:
Esta barra de ferramentas é chamada de barra de ferramentas Parar gravação. Ela possui
exatamente a função que o nome dela diz, ela serve para parar a gravação da macro, ou seja, tudo o que
você fizer enquanto esta barra de ferramentas estiver ativa, estará sendo gravado, quando terminar de
executar as ações da macro, pare a gravação clicando no botão Parar gravação.
Além do botão Parar gravação, esta barra também possui o botão Referência relativa. Este
botão quando ativado faz a gravação dos endereços relativos das células e não endereços absolutos. Caso
você queira gravar endereços relativos de células, você pode selecionar esse botão. Se marcar este botão,
toda a macro a ser gravada será executada com referências relativas até que você desmarque o botão.
Suponhamos que queremos fazer uma macro para justificar o texto em alguma célula e
centralizá-lo verticalmente, conforme mostrado nas células a seguir:
Quando clicamos no botão Ok já sabemos que surge a barra de ferramentas Parar gravação.
Agora, iniciamos o processo de gravação da macro, ou seja, não clicamos no botão Para
gravação e, sim, na seqüência de comandos que a macro fará.
• Horizontal: Justificar;
Clicamos em Ok. A caixa de formatação de células será fechada e nossa macro está pronta.
Agora clicamos no botão Parar gravação e a gravação da macro será finalizada.
Sempre que abrimos esta pasta de trabalho (este arquivo), aparecerá a seguinte caixa de
mensagem:
Vemos que a macro FormatarCelula encontra-se listada nesta janela. Toda macro criada
nesta pasta de trabalho ou em alguma outra pasta de trabalho que esteja aberta ou ainda na pasta de
trabalho pessoal de macros apareceria nesta janela.
Você somente precisa selecionar a macro desejada, neste caso, a macro FormatarCelula e
depois clicar no botão Executar.
Macros, então, têm a função de simplificar nosso trabalho. Ao invés de sempre termos que
fazer tarefas repetidas, podemos gravá-las numa macro.
Observação:
• Vale lembrar que essa macro, utilizada no exemplo, somente serve para formatar a
célula A1 de cada planilha. Isso acontece porque quando gravamos a macro, a célula
A1 estava selecionada, então, independente da planilha que está selecionada,
sempre a célula A1 será formatada com seu texto alinhado justificado
horizontalmente e centralizado verticalmente. Mas, o que faremos, caso desejamos
formatar outras células? Veremos mais à frente como podemos deixar nossa macros
• Nome da Macro: nesta caixa de texto você informa qual a macro que você irá
trabalhar. Você pode digitar o nome da macro ou selecioná-lo da lista de macros
existentes.
• Executar: botão que serve para executar a macro selecionada. Todas as ações
encerradas na macro serão executadas.
• Entrar: exibe o código da macro no Editor do Visual Basic para que você possa
depurar a macro. Depurar uma macro significa testar linha a linha de código da
macro para procurar possíveis erros que possam ter. mais à frente iremos aprender
como se depura um código.
• Editar: abre o código da macro no Editor do Visual Basic para que você possa alterar
a macro criada.
• Criar: cria uma nova macro. Abre o Editor do Visual Basic para que você insira os
códigos referentes à criação desta nova macro. Este botão somente fica ativo quando
você digita um nome na caixa Nome da Macro que não está na lista de macros.
• Opções: abre uma nova janela com informações da macro selecionada: nome da
macro, tecla de atalho e descrição. Você pode alterar a tecla de atalho e a descrição.
• Macros em: aqui você decide se deseja mostrar todas as macros deste arquivo
somente – Esta pasta de trabalho ou de todos os arquivos abertos – Todas as pastas
de trabalho abertas.
Uma outra forma de executar esta macro em questão é selecionando as teclas CTRL + SHIFT
+ F, pois foi a tecla de atalho que definimos na criação da macro.
Podemos ainda criar um botão na barra de ferramentas Formatação para executar esta
macro. Para isso selecionamos o menu Exibir / Barra de ferramentas / Personalizar. Na janela que se abre,
escolha guia Comandos.
Esta guia se subdivide em: Categorias e Comandos. Escolheremos a categoria Macros. Logo
em seguida, selecionamos o comando Personalizar botão e o arrastamos para algum lugar da barra de
ferramentas Formatação.
Clicamos com o botão direito do mouse sobre este botão. Existem várias opções, como
mudar o nome do botão, editar a imagem que aparece, ente outros.
Selecionaremos a opção Atribuir macro. Ao clicarmos nesta opção surge a janela Atribuir
Macro, assim escolhemos a macro desejada e clicamos no botão Ok. O botão está configurado com a macro
desejada.
Quando fazemos isso, é aberta uma nova janela, ou seja, o editor do Visual Basic é
programado para trabalhar como um programa à parte do Excel, mas, na verdade, tudo que é feito nele é
interno ao Excel.
Na barra de título lemos Microsoft Visual Basic acrescido do nome do arquivo (pasta de
trabalho) do Excel aberto.
Na barra de menu, vemos algumas opções comuns e outras nem tanto. definiremos cada
uma delas:
• Editar – menu com as opções copiar, recortar, colar, localizar, substituir, entre
outras opções a que você já está acostumado, também possui algumas opções
específicas do editor como listar constantes, listar propriedades, entre outras;
• Exibir – neste menu você consegue exibir vários objetos próprios do editor, tais
como, o objeto Verificação imediata, o objeto Project Explorer, ente outros;
• Inserir – este menu será utilizado quando quisermos inserir novos módulos,
procedimentos ou formulários ;
• Depurar – as opções deste menu são utilizadas quando você deseja verificar o
funcionamento de um código feito, vamos estudar mais à frente como se depura um
procedimento ou função;
• Executar – neste menu você tem a opção de executar alguma rotina feita ou parar a
execução da mesma;
• Ferramentas – menu com opções próprias do editor também, por exemplo, você
consegue acessar a lista de macros que existem em sua pasta de trabalho;
2 – Inserir Procedimento, Módulo ou Form – insere uma área de trabalho para que possamos
programar;
4 – Recortar – move o trecho de código selecionado para que, mais tarde, seja colado;
5 – Copiar – copia o trecho de código selecionado para que, mais tarde, seja colado;
13 – Modo de criação;
O PROJECT EXPLORER
O Project Explorer é uma janela que exibe uma lista hierárquica de todos os itens contidos e
referenciados em cada projeto que está aberto no Editor do Visual Basic.
• Botão Exibir código: exibe a janela de código (área de trabalho do editor) para que
você possa gravar e editar código associado a algum item selecionado.
• Botão Exibir objeto: exibe a janela Objeto para o item selecionado, um documento
ou um form.
• Botão Alternar pastas: Oculta e mostra as pastas de objetos enquanto exibe os itens
individuais contidos nelas.
Além dos botões acima a janela do Project Explorer contém vários itens que podem ser:
• Projeto: sempre que trabalhamos no editor do Visual Basic estamos trabalhando com
um projeto (VBAProject);
• Módulos: todos os módulos existentes, cada macro que você cria é inserida em um
módulo diferente.
A JANELA DE CÓDIGOS
A janela de códigos é a área de trabalho do editor. É nela que você irá inserir o seu código,
seja uma função nova que estará criando, seja uma macro que esteja editando, ou outro tipo de código.
Por exemplo, o código a seguir pertence a uma macro criada para formatação de células:
Dentro da macro na primeira parte vem algumas linhas descritivas. Essas linhas são
precedidas pelo símbolo apóstrofe (‘). Toda linha precedida por apóstrofe significa que é um comentário e
não é executada, desta forma, você pode escrever qualquer coisa após o apóstrofe pois será considerado
um comentário.
Neste caso específico, temos na primeira linha de comentário o nome da macro, na segunda
linha temos a descrição que informamos na criação da macro e na terceira linha de comentário a tecla de
atalho que foi definida para a macro.
Observações:
Vamos trabalhar com duas macros. Uma será chamado Formatar. Esta macro terá como
tecla de atalho a letra f (CTRL + f). Ela será salva nesta pasta de trabalho e a descrição será: Macro para
formatar a célula com fonte Arial, tamanho 14, negrito e sublinhado.
O nome da outra macro será Formatar_2. Esta macro não terá tecla de atalho. Ela será
salva nesta pasta de trabalho também e a descrição será: Macro para formatar a célula com fonte Comic
Sans MS, tamanho 14 e cor azul.
Para visualizar o código de cada um dos módulos, damos um clique duplo sobre o módulo a
ser visualizado e o código aparecerá na janela ao lado ou ainda damos um clique com o botão direito do
mouse sobre um dos módulos e escolhemos a opção Exibir código.
Quando clicamos com o botão direito do mouse sobre algum módulo outras opções
aparecem além da opção Exibir código.
A opção Remover Módulo, serve para excluir o módulo selecionado, com isso sua macro
será removida também, caso o conteúdo do módulo seja uma macro. Ao remover um módulo o editor
pergunta se você antes deseja exportá-lo, caso opte por sim, você estará removendo este módulo deste
arquivo e enviando para outro.
Macro 1
Sub Formatar()
With Selection.Font
.Name = "Arial"
.FontStyle = "Negrito"
.Size = 14
.Strikethrough = False
.Superscript = False
.Subscript = False
.OutlineFont = False
.Shadow = False
.Underline = xlUnderlineStyleDouble
.ColorIndex = xlAutomatic
End With
www.webaula.com.br Pág.: 18/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
End Sub
Macro 2
Sub Formatar_2()
With Selection.Font
.Name = "Comic Sans MS"
.FontStyle = "Normal"
.Size = 14
.Strikethrough = False
.Superscript = False
.Subscript = False
.OutlineFont = False
.Shadow = False
.Underline = xlUnderlineStyleNone
.ColorIndex = 5
End With
End Sub
Note que alguns comandos são comuns nas duas macros. Vamos verificar esses comandos
em comum primeiramente.
Instrução With: executa uma série de instruções em um objeto. Neste caso, o objeto
selecionado é o Selection.Font, isto significa que todos os comandos entre o With Objeto e o End With serão
feitos com este objeto.
Observe que alguns comandos dentro da instrução With se repetem nas duas macros, alguns
com valores diferentes, outros com valores iguais.
Estes comandos, nada mais são, do que propriedades da formatação de fonte, por isso são
tidos como propriedades.
A grande vantagem é que, ao executarmos as ações que uma macro fará, o próprio Excel
grava todo o código para nós. Nós somente iremos trabalhar com os códigos de uma macro se quisermos
alterar alguma coisa no código sem ter que fazer todo o processo de gravação de uma macro novamente.
EDITANDO MACROS
Agora que você já identificou os principais comandos das duas macros, podemos editar
qualquer uma das macros, em nosso exemplo faremos isso com a macro Formatar.
Na linha de código onde está o nome da fonte a ser utilizada vamos trocar de Arial para
Comic Sans MS.
Na linha de código onde está o tamanho da fonte, vamos trocar de 14 para 16.
Na linha de código onde está o sublinhado, vamos trocar de duplo para simples.
Na linha de código onde está a cor, vamos trocar de automática para 3 (cor vermelha).
Depois disso, basta clicar no botão Salvar do editor e testar a macro no Excel.
Sub Formatar()
With Selection.Font
.Name = "Comic Sans MS"
.FontStyle = "Negrito"
.Size = 16
.Strikethrough = False
.Superscript = False
.Subscript = False
.OutlineFont = False
.Shadow = False
.Underline = xlUnderlineStyleSingle
.ColorIndex = 3
End With
End Sub
Para este exemplo, utilizaremos uma macro chamada Formatar_Tabela. Ela não terá tecla de
atalho. A macro será gravada nesta pasta de trabalho.
A descrição da macro será: Macro para formatar uma tabela com fontes, bordas e
sombreamentos.
www.webaula.com.br Pág.: 20/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
Para a gravação da macro, façamos o seguinte:
Nem precisamos selecionar a tabela a ser formatada, a própria macro faz isso e formata a
tabela da forma que havíamos definido.
Ao executarmos a macro novamente, observamos que não foi toda a tabela que ficou
formatada, somente uma parte dela. Mesmo se você selecionar toda a tabela, somente serão formatadas as
células do intervalo A3:D8.
Isso acontece porque ao gravar a macro, gravamos também a seleção de células que foi
feita, ou seja, a macro funciona em qualquer planilha da pasta de trabalho, porém somente formata a região
das células A3 até D8.
Para verificarmos isso vamos abrir a macro para edição. Lembrando-se que, para isso vamos
em Ferramentas / Macro / Macros. Selecionamos a macro Formatar_Tabela e clicamos no botão Editar. Esta
é outra forma de se abrir o editor do Visual Basic, abrindo-o na macro que deseja visualizar ou alterar.
Range("A3:D8").Select
Este comando define que a formatação da tabela será feita no intervalo das células A3 até
D8. teremos que mudar isso para que a formatação de nossa tabela fique genérica.
Selection.CurrentRegion.Select
Este comando indica que a formatação deverá ser feita no intervalo de células selecionadas.
Neste caso, para executar a macro daqui por diante será preciso selecionar as células que deseja formatar
antes de executar a macro.
Testando isso na planilha Turismo, antes de executar a macro, selecionamos da célula A3 até
D12. Veja que toda a tabela foi formatada.
Por exemplo, esta macro Formatar_Tabela, caso selecionemos uma célula vazia de alguma
planilha e executamos a macro, ocorre o seguinte erro:
Este erro ocorre porque não foi selecionado nenhum intervalo de células para ser formatado
e o comando AutoFormatação que está inserido na macro está esperando por um intervalo de seleção.
Observe que a janela do erro possui dois botões ativos Fim e Depurar.
Se você clicar no botão Depurar, você será levado para o código da macro que gerou o erro.
Veja também que existe um número inteiro indicando o erro ocorrido. Para cada erro
ocorrido existe um número diferente. Para esse erro o número inteiro que trata disso é o 1004.
TRATANDO O ERRO
Caso selecionamos no botão Depurar, somos levados para o editor do Visual Basic. A
segunda linha de código fica marcada de amarelo. É aí que está sendo gerado o erro, ou seja, logo quando
se utiliza a AutoFormatação.
Como já sabemos o que ocasionou o erro, não precisamos depurar o código, vamos então
parar a execução da macro. Para isso, clicamos no botão Redefinir que está na barra de ferramentas Padrão
do editor.
Para tratar este erro vamos utilizar o objeto de tratamento de erros – o objeto Err. Este
objeto contém informações sobre os erros gerados em tempo de execução, ou seja, erros que somente
acontecem quando as macros são executadas.
Como pode ocorrer qualquer tipo de erro e em qualquer lugar do código, vamos inserir a
seguinte instrução no início do código, antes de qualquer comando:
No final da macro, após o último comando da macro, vamos inserir o tratamento para este
erro específico.
Estes comandos testam se foi gerado o erro de número 1004. Se este erro foi gerado limpa
qualquer formatação feita na célula e emite uma mensagem de erro amigável para o usuário.
Sub Formatar_Tabela()
On Error Resume Next
( … ) – comandos da macro
If Err.Number = 1004 Then
Selection.Clear
MsgBox "Você precisa selecionar um intervalo de células."
End If
End Sub
Observação: MsgBox é uma instrução do Visual Basic que mostra uma caixa de mensagem
na tela para o usuário, mais à frente aprenderemos mais sobre MsgBox.
Para a realização desse exemplo, teremos que ter algumas noções avançadas de Excel.
• Filtro Avançado: recurso que se encontra no menu Dados, opção Filtrar. Tem a
função de filtrar, de maneira rápida, um subconjunto de dados em uma tabela,
dessa forma os dados ficam fáceis de serem localizados e trabalhados. O filtro
avançado é utilizado quando temos critérios avançados para o filtro.
• Inserir Caixa de Diálogo: este recurso é bastante utilizado quando desejamos que
apareça para o usuário uma caixa de diálogo para que ele escolha ente uma opção
ou outra, ou informe algum dado, ou seja, para que ele interaja com o Excel de
forma simples e rápida. Para inserir uma caixa de diálogo na pasta de trabalho, você
deverá clicar com o botão direito sobre qualquer guia da planilha e selecionar a
opção inserir, aparecerá uma janela para que você escolha a opção desejada.
• Planilha 1: Empresas – listagem com o código, nome e valores das empresas que
são usados na planilha principal. Esta planilha possui uma tabela com os dados das
empresas. Foi definido um nome para a tabela (região das células A3 até C9). O
nome desta tabela é “Empresas”.
Aparecerá uma nova planilha em sua pasta de trabalho, chamada Caixa de diálogo1.
Podemos formatar a caixa, para que ela possa ter um título e ainda podemos diminuir o
tamanho da mesma (altura e/ou largura), para que depois possamos inserir o controle a ser utilizado nela.
Agora que a caixa de diálogo está pronta temos que fazê-la funcionar. Primeiramente, vamos
fazer os nomes das empresas aparecerem na caixa de combinação.
Para isso, clicamos com o botão direito do mouse sobre a caixa de combinação desenhada
sobre a caixa de diálogo.
Selecionamos a opção Formatar controle. A janela formatar controle será utilizada para
informarmos ao Excel, quais os dados que aparecerão na caixa de diálogo (de onde eles virão) e para onde
irá o dado que for selecionado pelo usuário.
A figura abaixo, mostra a janela Formatar controle, com a guia Controle selecionada, é nesta
guia que iremos trabalhar.
• Vínculo da célula: este parâmetro servirá para armazenar o dados (no caso – o nome
da empresa) a ser escolhido pelo usuário.
• Linhas suspensas: este parâmetro informa quantas linhas a caixa de diálogo terá, o
padrão é o número 8.
Qualquer empresa que for escolhida na caixa de combinação de nossa caixa de diálogo terá
seu índice na célula escolhida para ser vínculo da célula, porém, para melhorarmos a performance de nosso
pequeno sistema, vamos fazer o seguinte: de acordo com o índice da célula da empresa escolhida iremos
buscar o nome da empresa na planilha Empresas e colocá-lo em outra célula.
www.webaula.com.br Pág.: 28/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
Então, selecionamos a célula vínculo. Vamos ao menu Inserir, opção Função. Na caixa de
diálogo Inserir função, selecionamos a categoria Procura e referência. Feito isso, selecionamos a função
Índice.
• Na caixa de diálogo que aparecerá, deixar selecionada a opção Filtrar a lista no local.
Criamos nossa primeira macro que executa a ação de filtrar os dados de acordo com uma
empresa.
Lembre-se de ficar com alguma célula da planilha Ações selecionada, alguma célula que
possua dado da tabela.
Vamos à opção Ferramentas / Macro / Gravar nova macro. Daremos nome à macro de
Exibir_Tudo. A descrição da mesma será: Macro para mostrar todos os dados da tabela de Ações. Clique em
Ok.
Vamos à opção Ferramentas / Macro / Gravar nova macro. Daremos nome à macro de
Exibir_Caixa. A descrição da mesma será: Macro para exibir na tela a caixa de diálogo para escolha da
empresa. Clique em Ok.
Simplesmente, fizemos uma macro que abre a caixa de diálogo para seleção de alguma
empresa.
Agora, falta atribuirmos a macro Filtrar a algum controle. Vá até a planilha onde está a caixa
de diálogo e clicando com o botão direito do mouse no botão Ok, da caixa de diálogo, selecionamos a opção
Atribuir macro e escolhemos a macro Filtrar.
• Estrutura do VBA
• Variáveis;
• Tipos de variáveis;
• Declaração de variáveis;
• Constantes;
• Módulos;
• Procedimentos;
• Funções;
PROGRAMAÇÃO EM VBA
Já vimos que, para programarmos qualquer coisa em VBA, no Excel, é necessário
acessarmos a opção Ferramentas / Macro / Editor do Visual Basic.
Acessando esta opção podemos estar criando e editando códigos da linguagem, sejam
códigos de uma macro ou de uma função definida pelo usuário.
VARIÁVEIS
Variáveis são espaços alocados na memória do computador específicos para cada programa
que podem ser modificadas durante a execução do código deste programa.
Cada variável tem um nome que a identifica unicamente no escopo a que ela está ligada. A
variável pode possuir um tipo ou não. Associar um tipo a uma variável seria dizer que a variável irá receber
durante a execução do programa valores inteiros, variável do tipo inteiro; ou senão valores de data e hora,
variável do tipo data; e, assim por diante.
A vantagem de se especificar um tipo a uma variável é que já fica definido que a variável irá
receber esse tipo de valor durante toda a execução do código daquele programa. Isso facilita na resolução
de erros que podem ocorrer com valores associados incorretamente a variáveis, como, por exemplo, uma
variável recebe um número decimal e depois recebe um valor texto.
Os nomes de uma variável precisam ser iniciados com algum caractere. Podem conter
dígitos, só não pode começar pro dígito. Não podem conter espaços em branco. Não podem conter
caracteres inválidos, como, +, &, ^, *, entre outros. Variáveis não podem receber nomes de palavras-
chaves da linguagem. O tamanho do nome de uma variável são 255 caracteres.
TIPOS DE VARIÁVEIS
Os tipos de variáveis encontrados no VBA são:
Variant – tipo genérico; quando você não define o tipo da variável na declaração da mesma,
ela recebe o tipo variant, ou seja, pode ser qualquer tipo no decorrer do programa.
www.webaula.com.br Pág.: 33/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
Boolean – tipo em que a variável somente recebe dois tipos de valores: verdadeiro (True) ou
falso (False ).
Byte – tipo inteiro onde o valor assumido pela variável varia no intervalo de 0 até 255.
Integer – tipo inteiro onde o valor assumido pela variável varia no intervalo de -32.768 até
32.767
Long – tipo inteiro onde o valor assumido pela variável varia no intervalo de -2.147.483.648
até 2.147.483.647
Single – tipo decimal onde o valor assumido pela variável varia no intervalo de -
3,402823E38 até -1,401298E-45 (para valores negativos) e 1,401298E-45 até 3,402823E38 (para valores
positivos).
Double – tipo decimal onde o valor assumido pela variável varia no intervalo de -
1,79769313486232E308 até -4,94065645841247E-324 (para valores negativos) e 4,94065645841247E-
324 até 1,79769313486232E308 (para valores positivos).
Currency – tipo decimal onde o valor assumido pela variável varia no intervalo de -
922.337.203.685.477,5808 até 922.337.203.685.477,5807 (utilizado para valores monetários).
Decimal – tipo decimal onde o valor assumido pela variável varia no intervalo de +/-
79.228.162.514.264.337.593.543.950.335 (sem casas decimais) e +/-7,9228162514264337593543950335
(com casas decimais)
Date – tipo data onde o valor assumido pela variável varia no intervalo de 01/01/100 até
31/12/9999
String – tipo texto onde o valor assumido pela variável varia no intervalo de 1 até
aproximadamente 2 bilhões de caracteres (65.400 se tamanho fixo)
DECLARAÇÃO DE VARIÁVEIS
A declaração de variável é importante para que você não cometa erros ao construir algum
código de programação, conforme já dito anteriormente, inserir um valor inteiro para uma variável e depois,
inserir, para esta mesma variável um valor string (texto).
Declarando variáveis fica mais fácil uma futura manutenção no código. Além de se declarar a
variável e definir seu tipo, você poderá indicar com um comentário à frente o que e para que servirá a
variável.
O Editor do Visual Basic possui duas formas de trabalhar no que diz respeito a variáveis.
Você pode definir se deseja que seja obrigatória a declaração de todas as variáveis ou não.
Para informar ao Editor do Visual Basic que a declaração de variáveis é obrigatória, você
precisa selecionar no menu Ferramentas / Opções e marcar a opção Requer declaração de variáveis.
Fazendo isso, toda vez que você criar um módulo para desenvolvimento de algum código,
para alguma rotina a ser executada aparecerá no alto da tela do módulo as palavras chaves:
Option Explicit
A declaração de variáveis depende da utilização que você fará das variáveis dentro de seu
código.
Caso você queira que a variável seja visível em todos os módulos e durante toda a execução
do programa, você deverá utilizar a instrução Public.
Caso você queira que a variável seja visível apenas no próprio módulo e durante toda a
execução do programa, você deverá utilizar a instrução Private. Usando essa instrução em algum módulo
você não conseguirá acessar essa mesma variável em outro módulo.
Caso você queira que a variável seja visível apenas no próprio procedimento e durante a sua
execução, você deverá utilizar a instrução Dim.
CONSTANTES
Constantes são valores fixos que podem ser utilizados no programa.
Suponhamos que você deseja fazer um programa onde será preciso algumas mensagens
pré-definidas em vários lugares do código.
Você pode declarar uma constante para cada constante e no momento que precisar, utilizar
a constante adequada.
www.webaula.com.br Pág.: 35/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
Você pode ainda querer definir constantes para valores pré-definidos, por exemplo, uma
constante Masculino com valor 1 e uma constante Feminino para valor 2, seriam constantes utilizadas para
alguma variável do tipo Sexo.
Para declarar uma constante no código, você utiliza a palavra chave Const.
Exemplo:
Como nas variáveis também, você pode definir que a constante será utilizada em todos os
módulos ou somente em um. Por padrão, a constante é Private.
Exemplo:
OPERADORES
Para realizarmos as diversas operações entre as variáveis precisamos utilizar os operadores
contidos no VBA. Os operadores são:
Aritméticos
+ Adição
- Subtração
* Multiplicação
^ Exponenciação
Texto
= Igual a
<> Diferente de
Lógicos
And E lógico
Or Ou lógico
Not Negação
Operador Operação
^ Exponenciação
\ Divisão inteira
& Concatenação
A ESTRUTURA DO VBA
O Editor do Visual Basic, como já deve ter percebido, é dividido em módulos. Podemos criar
nossas rotinas em módulos diversos ou todas em um único módulo.
PROCEDIMENTOS
Quando certa seqüência de instruções de um código (programa) é executada repetidamente
em diferentes partes do código, deve ser criado um procedimento que substitua e concentre num único local
a seqüência de instruções relativa à rotina a ser executada.
Imagine que sempre você precisa testar os erros em suas macros, como já fizemos em
tópicos anteriores. Ao invés de criarmos os códigos de tratamento de erros em cada macro, podemos criar
um procedimento genérico para tratamento de erros de macros e utilizar esse procedimento em cada código
da macro. Desta forma estaríamos racionando o trabalho.
Imagine que depois de tudo feito, uma regra de negócio é modificada, imagine o trabalho
que não daria se você tivesse que trocar essa regra de negócio em cada parte do código que escreveu, seria
muito mais trabalhoso e você poderia acabar esquecendo algum lugar.
• Sub;
• Function.
SUBS E FUNCTIONS
A diferença primordial de subs e functions é que um procedimento - sub não retorna nenhum
valor, já uma função – function retorna um valor definido.
• Como a function retorna algum valor é necessário (não obrigatório) que a mesma
seja tipada, isto é, seria interessante definirmos um tipo para o valor retornado pela
função;
• Uma function sempre deverá ser atribuída a alguma variável, um sub não é atribuído
a nada, ele simplesmente é utilizado no código;
A sintaxe de um sub é:
Comandos
End Sub
Comandos
End Function
Vamos começar nosso estudo de argumentos utilizando as funções que já são definidas no
próprio Excel e que utilizam parâmetros e outras não.
Você já usou a função Se? A função Se é uma função que se localiza na categoria lógica do
Excel e ela é utilizada quando temos um teste lógico a ser feito podendo retornar um valor verdadeiro ou
um valor falso.
Por exemplo, suponhamos que de acordo com as notas de cada aluno de uma turma em
determinada escola, se o aluno tirou nota maior ou igual a 70, ele foi aprovado, senão ele foi reprovado.
Se você utilizar a função Se do Excel par resolver esse problema, teremos o seguinte:
CONSTRUINDO PROCEDIMENTOS
Para construir um procedimentos, entramos no Editor do Visual Basic e inserimos um
módulo: Inserir / Módulo.
Alguns comandos utilizados neste procedimento ainda não foram estudados, serão vistos
mais à frente no curso, mas copie o código como acima para que possamos testar a utilização de
procedimentos.
Observe também que podemos colocar comentários em várias regiões de nosso código. O
Visual Basic considera que tudo que está pós um apóstrofe ‘ é um comentário, por esse motivo que podemos
ter comentários logo no início da linha ou na mesma linha de um código, após o código.
Para utilizarmos um procedimento do Excel, fazemos como para as macros, podemos criar
botões de comando para isso ou ainda podemos ir diretamente em Ferramentas / Macro / Macros e veremos
que o procedimento feito por nós encontra-se na listagem das macros.
CONSTRUINDO FUNÇÕES
A nossa função irá receber dois números e retornar como resultado a adição da multiplicação
ente os dois números e a divisão ente eles.
Para fazermos a função, podemos utilizar o mesmo módulo onde está o procedimento ou um
outro módulo.
Note que a função possui dois parâmetros inteiros. Isto é uma limitação para ela, pois os
valores do tipo integer têm um intervalo de variação pequeno. Se você passar um argumento com um valor
muito grande, a função dará um erro ao ser executada. Isso pode ser tratado da mesma forma que tratamos
erros de nossas macros no início do curso. Vermos novamente mais à frente.
www.webaula.com.br Pág.: 41/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
Observe também que a função é definida como do tipo single, pois mesmo entrando com 2
valores inteiros teremos ocasiões em que a divisão dará como resultado um número decimal e por isso ao
ser somada com a multiplicação o número é decimal.
Uma diferença entre procedimentos e funções que também pode ser vista aqui é: o resultado
da função é lançado pra ela mesma, observe que o cálculo feito é jogado para o próprio nome da função
Calculo.
TESTANDO FUNÇÕES
Para testar um procedimento vimos que basta utilizar a Janela “Verificação Imediata”. Pois
bem, para testarmos funções também, porém ao invés de utilizarmos a palavra-chave call, iremos utilizar o
sinal de interrogação ?.
Devemos digitar:
? NomedaFunção Argumentos
? Calculo 3 , 4
12,75
Quando criamos procedimentos vimos que os mesmo aparecem no Excel como se fossem
macros, ou seja, se você for em Ferramentas / Macro / Macros, os procedimentos criados estará listados lá.
Mas se formos em Macros agora veremos que a função criada não está lá.
Quando criamos uma função no Editor do Visual Basic, esta função recebe a denominação do
Excel de função Definida pelo Usuário.
Para verificar isso, vamos em Inserir / Função. Na caixa que se abre escolhemos a categoria
Definida pelo Usuário. Vemos que a função está lá.
Ao utilizar a função veremos que ela possui os dois argumentos definidos por nós na função:
Num1 e Num2.
CAIXAS DE MENSAGEM
Como já vimos no exemplo que fizemos de procedimento, algumas vezes precisamos que
apareça uma caixa de mensagem para o usuário.
Essa caixa de mensagem pode ser apenas para efeito de informação como também pode ser
uma forma do usuário interagir com a ação a ser executada, pois, se a caixa de mensagem traz uma
pergunta e dependendo da resposta que ele der, uma determinada ação é executada.
• MsgBox
• InputBox
Para utilizar a caixa de mensagem MsgBox temos que, primeiramente, aprender a sintaxe da
mesma:
Onde:
Mensagem – é o texto que irá aparecer na caixa de mensagem para o usuário, pode ser uma
informação, um alerta ou uma pergunta.
Tipo Explicação
Botões – são os botões a serem utilizados pela caixa de mensagem. O padrão, quando não
se informa qual(is) o(s) botão(ões) que irá(ao) aparecer é o botão Ok (vbOkOnly).
Botão Explicação
vbOkOnly Botão Ok
Para os tipos de botões mostrados acima, dependendo do botão clicado pelo usuário existirá
um tipo retornado para a ação referente a ele ser executada.
O código abaixo serve para testarmos as caixas de mensagem com componentes diferentes.
Ainda não estaremos testando o valor retornado pela caixa de mensagem.
No código anterior, no final de algumas linhas você verá que existe o símbolo _
(underscore). Este símbolo é utilizado quando o conteúdo de uma linha não terminou e continua na próxima
linha. Se você quiser, você poderá digitar sem o underscore, porém, terá que fazer cada comando numa
linha.
O comando select veremos nos próximos tópicos do nosso curso. Para testar os tipos de
caixa de mensagem retornados, utilizamos a Janela “Verificação Imediata”. Digitamos o nome do
procedimento seguido por um número, variando de 1 a 6, que são os tipos de exemplos inseridos no código.
Veremos que para cada número utilizado no teste será retornada uma caixa de mensagem
diferente com botões diferentes, como os dois exemplos que seguem:
A InputBox é uma caixa de mensagem onde o usuário pode informar um valor qualquer
numa caixa de texto.
Onde:
Valor Padrão – é algum valor que você já queira que venha preenchido na caixa de texto.
Ao testar o procedimento acima, veremos que aparecerá uma InputBox onde digitaremos
qualquer coisa.
Logo em seguida, ao clicarmos em Ok, aparecerá uma caixa de mensagem com o que você
digitou na InputBox.
ESTRUTURAS CONDICIONAIS
As estruturas condicionais no VBA servem para ser utilizadas quando precisamos analisar
determinada condição ou expressão e dependendo do caso, essa condição ou expressão testada retorna algo
diferente para cada situação.
• If
• Select
O COMANDO IF
O comando If é bastante similar à função Se do Excel.
A sintaxe do comando If é:
If condição Then
Comandos a serem executados caso condição seja verdadeira
End If
Na sintaxe acima o comando If é mostrado da forma mais simples, ou seja, se a condição for
verdadeira os comandos dento do If serão executadas.
If condição Then
Comandos a serem executados caso condição seja verdadeira
Else
Comandos a serem executados caso condição seja falsa
End If
Você pode fazer mais interações com o comando If, imagine que você possui várias
condições a serem testadas, você pode usar o comando If assim:
Observe que estamos utilizando o comando If ... ElseIf ... Else ... End If, pois temos várias
situações de intervalos de notas para os alunos.
A janela de argumentos da função contém o único argumento desta função que é a nota do
aluno.
Para finalizar temos que fazer alguns tratamentos na função, por exemplo, o que acontecerá
se a nota for maior do que 100 ou menor do que 0? Isso é um erro, pois as notas variam de 0 a 100.
Para isso vamos acrescentar ao código da função o seguinte: se a nota for menor do que 0
ou maior do que 100, o conceito do aluno será I (inválido). Desta forma termos mais uma estrutura if para
ser completada.
O COMANDO SELECT
O comando Select analisa uma expressão que pode retornar algum valor, e, para cada valor
retornado pode ser executado determinado comando ou comandos.
Verifique que o usuário poderá digitar qualquer valor do tipo byte, ou seja, algum valor
variando de 0 a 255. Se ele digitar 1, 2 ou 3 aparecerá uma mensagem para ele de Bom dia, Boa tarde ou
Boa noite.
Note que, a última instrução do comando Select é um Case Else, isto quer dizer que, se o
usuário digitar qualquer número diferente de 1, 2 ou 3 será executada a expressão que está dentro desta
cláusula.
ESTRUTURAS DE REPETIÇÃO
As estruturas de repetição no VBA servem para quando precisamos repetir um mesmo
comando ou uma mesma seqüência de comandos um número determinado de vezes.
• For
• While
O COMANDO FOR
O comando For faz com que determinadas instruções sejam executadas enquanto um
incrementador estiver variando de um número até outro.
For num = 1 To 3
MsgBox “Mensagem número: ” & num
Next
Serão mostradas três caixas de mensagens, ou seja, será mostrada a caixa de mensagem
com a mensagem “Mensagem número: 1”, depois será mostrada a caixa de mensagem com a mensagem
Façamos o seguinte:
Para cada conceito além da cor, definiremos também que a fonte será negrita. Para isso
utilize o comando Selection.Font.Bold = True em cada cláusula. Definiremos também que a cor de
preenchimento da célula terá os seguintes tons:
O COMANDO WHILE
Como o comando For, o comando While também é como estrutura de repetição. Ele funciona
da seguinte forma: enquanto uma condição for verdadeira as instruções no interior do While serão
executadas.
While Condição
Comandos a serem executados enquanto a condição for verdadeira
Wend
Como exemplo, faremos o seguinte se o valor contido na célula for menor do que 50.000 a
célula será preenchida da cor vermelha, agora, se o valor contido na célula for maior ou igual a 50.000 a
célula será preenchida da cor verde.
Para fazermos essa rotina precisaremos utilizar mais alguns conceitos do Excel e do VBA,
como, por exemplo, a função IsNumeric que testa se determinado valor é número ou não. Essa função é
bastante utilizada par evitarmos erros desnecessários.
Veremos em mais exemplos mais funções do VBA, algumas funções pré-definidas pelo VBA
tem características semelhantes à IsNumeric, tais como:
Todas essas funções sempre retornam um valor booleano (lógico) – verdadeiro ou falso.
Existem dois comandos While na rotina. O primeiro serve para controlar as linhas
selecionadas e o segundo as colunas. Observe que as variáveis i e j variam de acordo com as linhas e
colunas. Ambas iniciam com o valor 1.
Porém alguns desses erros podem ser mais difíceis de serem encontrados, pois, podem ser
os chamados erros de semântica, ou seja, sintaticamente está tudo correto, mas em algum lugar do código
pode estar errado o comando que usamos, por exemplo, ao invés de fazermos uma variável receber o valor
de 0, estamos fazendo com que ela receba o valor de 1, quando o correto seria o 0.
Para ficar mais simples acharmos os erros, torna-se interessante irmos executando cada
rotina linha a linha de código. Fazer isso é depurar o código ou com muitos chamam debugar o
código(porque em Inglês depurar = debug).
Com a depuração de código podemos encontrar facilmente os erros que estão ocorrendo no
código que estamos testando.
A depuração em si, é um teste que fazemos com o código que está sendo produzido. Por
este motivo é importante testarmos o código de todas as formas possíveis.
Por exemplo, imagine que temos uma rotina para um determinado cálculo entre dois valores
distintos, onde um dos valores só pode ser positivo e inteiro e o outro só pode ser negativo e inteiro.
Teríamos que testar de várias formas diferentes, ou seja, com parâmetros, ambos os números positivos,
ambos os números negativos, um positivo e outro negativo, valores incorretos – tipo texto, data, entre
outros testes.
Muitas vezes, esquecemos de inserir o tratamento de erro em alguma rotina, sendo que em
muitas ocasiões este tratamento é imprescindível. Isso fica claro quando executamos a depuração do
código, pois, na utilização de uma rotina existem várias situações que podem acontecer.
Na depuração do código, nada mais fazemos do que simularmos essas várias situações.
Muito bem, agora que você já sabe o que é e para que serve a depuração de código vamos
tratar de aprender como depurar um código.
Lembre-se, daqui para frente sempre que preciso vamos depurar os códigos feitos por nós,
para termos a certeza de que os mesmo funcionam corretamente.
No Editor do Visual Basic, existe uma opção no menu chamada Depurar. Dentro deste menu
temos várias opções que serão utilizadas por nós para depuração de código. Veremos as mais comuns delas.
Além do menu Depurar, temos também no Editor do Visual Basic uma barra de ferramentas
também chamada Depurar. Ela possui as mesmas opções que existem no menu Depurar. Para exibi-la
vamos em Exibir / Barra de Ferramentas e escolhemos a barra de ferramentas Depurar.
1 – Modo de criação
3 – Interromper
6 – Depuração Total
7 – Depuração parcial
8 – Depuração circular
10 – Janela “Verificação Imediata” – é a mesma janela que já utilizamos para testar nosso
códigos feitos
13 – Pilha de chamadas
Antes de depurar um código temos que definir os pontos de interrupção para que a
depuração comece a partir dali. Este ponto de interrupção nada mais é do que a marca onde daremos início
à depuração do código linha a linha. Muitas vezes este ponto não precisa ser na primeira linha do código da
rotina, mas sim, no lugar em que você acha que está o erro.
TotalLinha = Selection.Cells.Count
Observação: Você não consegue marcar como ponto de parada linhas de comentário e nem
linhas de declaração de variáveis e constantes, somente linhas de comando.
Você é levado para o código e a linha que marcou como ponto de interrupção fica marcada
de amarelo.
Antes de qualquer coisa, ao apontar o mouse para a variável TotalLinha o valor atual da
variável aparece.
O valor atual dela é 0 (zero). Pressionando a tecla F8 a linha amarela que marca a linha de
código que está sendo executada passa para a próxima linha de comando. Apontando o mouse novamente
para a variável TotalLinha o valor atual já mudou.
www.webaula.com.br Pág.: 59/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
O que aconteceu? Ao avançarmos para a próxima linha, pressionando a tecla F8, a variável
TotalLinha recebeu o total de linhas selecionadas.
Agora se apontamos o mouse para a variável Linha, veremos que ela está com o valor 0
(zero), se pressionar F8 novamente, ela receberá o valor 1 (um).
Uma outra forma de visualizar o conteúdo de uma variável no momento é utilizando a Janela
Variáveis locais. Acionamos esta opção na barra de ferramentas Depurar.
Esta janela traz todas as variáveis utilizadas na rotina e, à medida que você vai depurando o
código (pressionando a tecla F8) as variáveis vão trocando de valores.
Ao pressionarmos a tecla F8 várias vezes, observamos que a linha amarela vai trocando até
que retorna para a linha:
Você não precisa ficar depurando o código até o fim, você pode testá-lo até encontrar o
problema, caso tenha algum problema e depois parar a execução ou terminar a execução.
Sempre é aconselhável realizarmos o tratamento dos erros, pois, o usuário ao executar uma
rotina, ou seja, utilizar alguma planilha sua que contém macros ou funções não necessariamente pode saber
muito bem como utilizar essas rotinas e, com isso, gerar erros, que se não forem tratados por você ficaria
difícil para ele entender o que está acontecendo.
Utilizaremos alguns tratamentos de erro, melhorando para o usuário a utilização das rotinas
feitas por nós.
Usaremos uma rotina onde o usuário entrará com dois números inteiros e retornaremos em
duas células diferentes do Excel o resultado da divisão inteira e o resultado do resto da divisão inteira.
Executando a macro, se o usuário sempre inserir valores inteiros nas duas caixas de entrada,
a rotina sempre executará corretamente.
Observe que os dois números inteiros que digita em cada caixa de entrada aparecem,
respectivamente, nas células B3 e B4, conforme descrito no código da rotina e, logo em seguida, o resultado
da divisão e do resto da divisão aparecem nas células B6 e B7.
Digitamos o valor inteiro 10 nesta caixa e damos Ok. Ao fazermos isso, aparece a segunda
caixa de entrada “Digite o divisor”.
GERANDO ERROS
Experimentaremos agora executar a macro novamente e vamos começar a gerar alguns
erros propositadamente.
O erro aparece porque num1 ou num2 são variáveis do tipo inteiro e não admitem receber
valor texto.
Se você clicar no botão Depurar, aparecerá marcada de amarelo exatamente a linha que deu
erro, ou a linha do num1 recebendo o valor da caixa de entrada do dividendo ou a linha da variável num2
recebendo o valor da caixa de entrada do divisor. Como já sabemos qual é o erro, para parar a depuração
marque o botão Redefinir.
Observe que o número do erro gerado foi 13 – Tipos Incompatíveis. Para cada erro que pode
ocorrer existe um número de erro específico e uma descrição.
O erro acima ocorrerá caso digite um texto ou uma data ou qualquer outro valor que não
seja numérico.
Segundo: outro erro que poderá ocorrer é fácil de gerarmos também. Executando a macro,
inseriremos qualquer valor no dividendo e no divisor digitaremos 0. Aparecerá o erro abaixo:
Isto significa que é um erro a divisão por zero e este erro, no VBA é tratado como o erro de
código 11.
Terceiro: mais um erro que pode ocorrer é o seguinte: digitando tanto como dividendo ou
como divisor um número muito grande, maior que 32768. Lembre-se: os números inteiros variam num
intervalo de -32768 a +32767. O erro abaixo ocorrerá:
O erro de código 6, é o erro que informa estouro no limite aceito pela variável.
Vimos que muitos erros podem ocorrer numa rotina simples como esta que, simplesmente,
executa duas operações matemáticas: uma divisão inteira e um resto da divisão inteira.
Além destes três erros que testamos, pode até ser que outros erros possam ser gerados pelo
usuário.
Por este motivo teremos que aprender como tratar esses erros, ou seja, como não deixar
que o erro estoure na tela do usuário aparecendo uma mensagem para ele que ele não entenda.
Para realizarmos o tratamento de erro da rotina Divisao, logo abaixo dela criaremos a rotina
TrataErro.
Você observou que sempre o código do erro gerado pelo VBA é um valor numérico inteiro,
não é? Então desta forma, o parâmetro de entrada desta rotina será um parâmetro inteiro. Para não termos
problemas de estouro com este parâmetro, iremos declará-lo do tipo Long.
Uma outra forma de utilizarmos o tratamento de erro, é fazendo uso do comando a seguir:
... comandos ... ‘ comandos a serem executados caso ocorra algum erro
O código a seguir mostra a rotina Divisao com o tratamento de erro.
Somente um detalhe deste código ainda não foi explicado. Qual o porquê da linha de
comando Exit Sub?
Este comando será preciso por que toda vez que executarmos esta rotina, caso não dê
nenhum erro a execução normal será feita e logo após o comando Range("B7").FormulaR1C1 = resto, o
próximo comando a ser executado seria TrataErro Err.Number.
Observação: Note que na chamada da rotina TrataErro passamos como parâmetro o número
do erro gerado pelo VBA, ou seja, o Err.Number.
Quando ocorre qualquer erro em tempo de execução, as propriedades do objeto Err são
preenchidas com informações que identificam com exclusividade o erro e a informação que podem ser
usados para tratá-lo.
Além desta propriedade o objeto Err possui outras propriedades e métodos, a saber:
Objeto Err
Propriedades
Métodos
Observe que estamos gerando o erro 11 com a ajuda do método Raise. Para modificar o erro
gerado modifique o número 11 por outro.
Observação: na construção da mensagem de erro foi utilizada a constante vbCrLf que é uma
constante própria do VBA que significa quebra de linha.
1. Objeto Application
2. Objeto Workbooks
3. Objeto Worksheets
4. Objeto Range
Destes quatro objetos listados acima, já trabalhamos algumas vezes com o objeto Range.
Ele foi utilizado quando queríamos trabalhar com uma célula ou um intervalo de células.
O objeto Application é o próprio aplicativo Excel, ou seja, é a aplicação como um todo. Este
objeto contém um conjunto de Workbooks.
O objeto Workbook é cada arquivo aberto do Excel, ou seja, é cada pasta de trabalho. Este
objeto possui um conjunto de Worksheets.
O objeto Worksheet é cada planilha dentro de uma pasta de trabalho, desta forma quando
queremos trabalhar com planilhas utilizamos este objeto. Este objeto contém um conjunto de Ranges.
O OBJETO APPLICATION
O objeto Application é utilizado quando queremos de alguma forma trabalhar com a
aplicação do Excel como um todo.
O método Caption modifica o nome do aplicativo “Microsoft Excel” para o nome que
desejamos. Desta forma se escrevemos:
Na barra de títulos do Excel, ao invés de termos Microsoft Excel, estará Teste de Título.
O método Run executa uma determinada macro. Utilizando Application.Run podemos passar
como parâmetros a macro e seus parâmetros, caso tenha.
Para utilizarmos este método, vamos criar uma macro simples. Em um arquivo do Excel que
está aberto, criamos uma macro que formata uma célula com a fonte Courier New e cor vermelha.
Depois que você parar a gravação dessa macro, vamos ao Editor do Visual Basic e criamos a
que se encontra abaixo:
Observe a macro abaixo. São passados dois parâmetros para a macro FormataFonte2, o
nome da fonte e a cor da fonte e estes parâmetros são utilizados no código da macro:
A execução desta rotina na janela Verificação Imediata faz com que a macro FormataFonte2
seja executada com a fonte e a cor informadas. A célula selecionada ficará com a formatação escolhida.
Exemplo:
• ExecutaMacro2 "Times New Roman", 6 (fonte Times New Roman e cor amarela);
Este método encerra o Excel, ou seja, fecha todas as janelas do Excel que estejam abertas.
O OBJETO WORKBOOKS
O objeto Workbooks é utilizado quando queremos de alguma forma trabalhar com as pastas
de trabalho do Excel.
Vimos que no objeto Application o método Quit encerra a aplicação, ou seja, fecha o Excel.
Para fecharmos uma pasta de trabalho específica, utilizamos o método Close.
Para testarmos esta rotina, suponhamos que temos um arquivo aberto chamado
“Divisao.xls”. Podemos utilizar esta rotina FecharArquivo na janela verificação Imediata da seguinte forma:
www.webaula.com.br Pág.: 70/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
FecharArquivo "Divisao"
Como você pode fechar um arquivo que está aberto, você também pode abrir um arquivo.
Para isso, veja a rotina abaixo:
Ao realizar o teste desta rotina você terá que passar como parâmetro não somente o nome
do arquivo que será aberto, como foi feito no teste anterior da rotina para fechar o arquivo, mas também o
caminho completo que leva até o arquivo.
Por exemplo, para testar esta rotina utilizando a janela Verificação Imediata, faça da
seguinte forma:
AbrirArquivo "C:\Excel\Divisao.xls"
Onde:
O OBJETO WORKSHEETS
O objeto Worksheets é utilizado quando queremos de alguma forma trabalhar com as
planilhas contidas em uma pasta de trabalho do Excel.
Para testar esta rotina utilizando a janela Verificação Imediata fazemos da seguinte forma:
Isto porque você tentou acessar uma planilha inexistente em sua pasta de trabalho.
Para criamos uma nova planilha em uma pasta de trabalho vamos utilizar o seguinte código:
Com este código podemos criar uma planilha onde acharmos necessário. Por padrão, sempre
uma planilha é inserida na posição anterior à planilha que está selecionada.
Com este código você pode excluir uma planilha passando como parâmetro o número (índice
da mesma) ou o nome da planilha.
Observe que utilizamos antes do nome de cada parâmetro a palavra-chave Optional, ela tem
a finalidade de informar que o parâmetro não é obrigatório. Por isso existem duas forma para testar essa
rotina:
• ExcluirPlanilha ,"Plan3"
Veja que no primeiro teste, passamos somente o número da planilha que queremos apagar.
No segundo teste passamos virgula seguido do nome da planilha que queremos apagar. Em ambos os casos
omitimos um dos parâmetros.
O OBJETO RANGE
O objeto Range, com certeza, é o mais utilizado por nós, por este mesmo, até antes de
falarmos diretamente sobre ele já o utilizamos algumas vezes.
Por exemplo, podemos querer que determinada célula receba determinado valor, ou
podemos querer ler os valores contidos em várias células.
Podemos ainda querer formatar um determinado intervalo de células. Para tudo isso
utilizamos o objeto Range.
Clicando no botão veremos o resultado aparecendo nas células B10, B11 e B12.
Se dermos um clique duplo em qualquer uma das planilhas – Plan1, Plan2 ou Plan3, ou seja
lá qual for o nome que as mesmas possuam no arquivo que está aberto, na área de trabalho ao lado
aparecerá um espaço para trabalharmos com o objeto WorkSheets e seus eventos.
Para cada evento que você selecionar na caixa de combinação à direita surgirá um
procedimento para você construir o código do mesmo.
Para cada evento que você selecionar na caixa de combinação à direita surgirá um
procedimento para você construir o código do mesmo.
Para iniciar nosso trabalhos, no Project Explorer damos um clique duplo em Plan1 ou senão
clicamos com botão direito do mouse sobre Plan1 e escolhemos Exibir Código. Selecionamos o objeto
Worksheet.
MsgBox “Teste”
Voltando ao Excel e digitando qualquer coisa na célula A1, o que acontece? Aparece a caixa
de mensagem “Teste”.
O que você fizer nesta planilha fará com que a caixa de mensagem apareça.
É isto que o evento SelectionChange faz, para qualquer mudança na planilha, os comandos
em seu interior serão executados, como neste caso o único comando que ele possui é a exibição de uma
caixa de mensagem, ele está fazendo exatamente isto.
Se você trocar de planilha no Excel, o evento não funciona nesta outra planilha, pois ele foi
utilizado na Plan1. Para usá-lo nesta outra planilha teríamos que inseri-lo em seu código.
O evento BeforeDoubleClick ocorre quando você dá um clique duplo com o botão do mouse
em qualquer célula da planilha.
www.webaula.com.br Pág.: 76/92
Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material.
MACRO E VBA PARA EXCEL
Quando faz isso, antes mesmo de efetuar a ação do duplo clique, o evento é realizado.
Você pode testar este evento da mesma forma que testou o anterior.
Criaremos dentro dele um MsgBox com algum conteúdo. Você verá que ao clicar duas vezes
na planilha o evento será executado, ou seja, a caixa de mensagem aparecerá.
O evento BeforeRightClick ocorre quando você clica com o botão direito do mouse em
alguma célula de sua planilha.
Quando faz isso, antes de aparecerem as opções disponíveis ao clicar com o botão direito do
mouse, serão executados os comandos que estão dentro do evento BeforeRightClick.
Estes parâmetros, não necessariamente precisam ser utilizados no código que virá dentro do
procedimento.
Você vê que a variável Target é a mesma coisa de utilizarmos o objeto ActiveCell, ou seja, é
a célula ativa ou células ativas que foram selecionadas.
Para trabalharmos com formulários no Editor do Visual Basic acessamos a opção Inserir e
criamos um UserForm. Aparecerá um userform para que possamos trabalhar.
Faremos uma breve descrição sobre cada um dos componentes desta caixa de ferramentas:
5. Caixa de Listagem – é o controle que conterá uma listagem de itens onde o usuário
pode escolher um único item ou vários itens.
7. Botão de Opção – é utilizado quando o usuário somente pode escolher uma opção
dentre uma lista de opções.
13. Barra de Rolagem – ferramenta gráfica para navegação rápida em uma lista onde
cada posição assumida pela rolagem é uma valor.
16. RefEdit – exibe um controle parecido com uma caixa de texto , porém, contendo
uma alça ao final que ao ser acionada, o formulário se esconde e você pode
preencher a caixa de texto, visualizando a planilha abaixo do formulário. É parecido
com as caixas de texto das funções do Excel.
CRIANDO FORMULÁRIOS
Faremos um exemplo para aprendermos formulários.
Precisaremos de uma planilha conforme abaixo. O nome dessa planilha será Funcionarios.
O botão de comando Cadastrar Funcionários, por enquanto não acionará nenhuma macro.
Precisaremos de uma outra planilha conforme abaixo. O nome dessa planilha será Cargos.
Agora, iremos começar a inserir os controles no formulário. Para inserir cada controle, você
somente precisa selecionar o controle desejado na caixa de ferramentas e depois desenhá-lo no formulário.
Nós iremos inserir no formulário os seguintes controles: 3 rótulos, 2 caixas de texto, 1 caixa
de combinação e 3 botões de comando.
• TabIndex – índice de tabulação (caso o usuário queira usar a tecla TAB para mudar
entre campos): 1
• (Name): cboCargo
• TabIndex: 2
Para a segunda caixa de texto que vem abaixo da caixa de combinação, definiremos assim:
• (Name): txtSalario
• TabIndex: 3
Botão Salvar:
• (Name): cmdSalvar
• Caption: Salvar
Botão Limpar:
• (Name): cmdLimpar
• Caption: Limpar
• TabStop: False
Botão Fechar:
• (Name): cmdFechar
• Caption: Fechar
• TabStop: False
Para configurar cada propriedade do controle basta selecionar o controle com um único
clique do mouse e ir até as propriedades do mesmo.
PROGRAMANDO O FORMULÁRIO
Clicando com o botão direito do mouse sobre o fundo do Formulário, selecionaremos a opção
Exibir Código.
Vamos inserir um código para que, ao ativar o formulário a caixa de combinação cboCargo
seja preenchida com os nomes dos cargos que estão na planilha Cargos.
Para fazermos isso, verifique se na caixa de combinação Objeto está selecionado o objeto
UserForm. Caso não esteja, selecione-o. Agora, selecione o evento Activate.
Enquanto existem dados na coluna B, a partir da célula B4, vamos preenchendo a caixa de
combinação cboCargo com o comando cboCargo.AddItem ActiveCell.Value.
Agora criaremos um procedimento chamado Limpa. Ele será utilizado quando o botão Limpar
for executado e também quando o botão Salvar for executado, logo após gravar os valores contidos em
cada campo.
No formulário temos três campos: txtNome, txtSalario e cboCargo. Este procedimento faz
com que a propriedade Text de cada um destes campos receba o valor vazio (“” – abre e fecha aspas
duplas).
A propriedade Text dos campos é os valor que o campo recebe ou tem em determinado
momento.
Se o nosso formulário tivesse mais campos, bastaria colocarmos para cada campo, a sua
propriedade Text recebendo vazio. Assim, limparíamos todo o formulário.
Este procedimento será usado no botão Limpar, obviamente, e no botão Salvar, pois
limpando o formulário após o usuário clicar no botão Salvar, fica mais fácil para ele caso queira cadastrar
mais funcionários.
Além do procedimento Limpa que já criamos. Vamos, agora, criar a função ValidaCadastro.
Esta função será responsável por testar se todos os campos foram preenchidos e, somente se tiverem sido
preenchidos, é que a gravação dos dados será realizada.
Esta função não somente testará se os dados foram todos preenchidos, mas no caso do
salário, além de testar se foi preenchido, testará também se foi preenchido com um valor numérico. Para
este teste utilizaremos a função IsNumeric que retorna verdadeiro se o valor é numérico e falso, caso
contrário.
Esta função retornará, como resultado, um valor lógico (booleano). Se tudo foi preenchido
corretamente retornará o valor verdadeiro, caso contrário retornará o valor falso.
O código do mesmo é:
O comando Unload serve para fechar o formulário, neste caso, estamos informando que o
formulário frmFuncionario será fechado.
Feito isso, verificamos se é o primeiro registro que iremos inserir ou não. Veja que testamos
o valor que está contido na célula A4 - If Range("A4").Value = "" Then. Se este valor está vazio
selecionamos a célula A4, senão selecionamos a célula A3 e, a partir dela, iremos até a última célula
preenchida (Selection.End(xlDown).Select) e avançaremos para a próxima célula (ActiveCell.Offset(1,
0).Select).
É esta rotina que será utilizada ao clicarmos no botão Cadastra Funcionários que está na
planilha Funcionarios.
O valor 1 logo após este comando indica que enquanto este formulário estiver aberto, o
usuário não poderá clicar na planilha abaixo, se não colocar nada após o evento Show, isto será possível.
Com esta opção selecionada, sempre que abrimos qualquer arquivo que contém macros,
antes somos perguntados se desejamos ativar as macros ou não.
Desta forma, se sabemos a procedência do arquivo ativamos as macros nele contidas, senão
podemos desativá-las.
PROTEGENDO CÓDIGOS
Tudo o que você faz no Editor do Visual Basic pode ficar disponível somente para quem você
permitir o acesso.
Desta forma, seu código ficará protegido contra aqueles usuários que queiram abrir seus
códigos, podendo fazer alguma mudança e até mesmo estragando-os.
Nesta guia, marcamos a opção Bloquear projeto para exibição. Depois, digitamos uma
senha para exibir o código novamente e confirmamos a senha.
Feito isso, o código deste projeto está protegido. Somente quem possui a senha poderá
acessá-lo.
Para desproteger códigos, basta fazer o mesmo processo, porém, desmarcando a opção para
bloqueá-lo e retirando a senha e confirmação de senha.
CONCLUSÃO
Esperamos que o conteúdo desta apostila tenha servido de suporte para as suas aulas.
A informática sofre mudanças bruscas muito rapidamente, procure no futuro uma biblioteca
auxiliar e fique atento ao lançamento de novos aplicativos e versões.
A Zargon Computação estará sempre ao seu dispor para solucionar dúvidas quando
necessário.
Atenciosamente,
Diretoria de Treinamento
Zargon Tecnologia em Informática