Embed Size (px)
Citation preview
VISUAL BASIC FOR APPLICATIONS - VBA
APLICADO AO MICROSOFT EXCEL
POR BRENDON A. RAMOS
1
MOTIVAÇÃO
Essa apostila foi produzida com o intuito de apresentar o leitor ao básico da programação em
Visual Basic for Applications, que chamaremos apenas por VBA, de modo que ele possa a não
somente entender códigos escritos por terceiros, mas também construir mecanismos que
possibilitem automatizar suas rotinas.
O VBA deve ser encarado não como uma ferramenta para análise de dados, mas sim para
organização e apresentação dos mesmos. Imagine que você acabou de mudar de casa, acabada
a mudança seu lar se encontrará completamente desorganizado, e você gastará horas
dedicadas para organizar as mesas, estantes, cozinha, etc. E quando você for mudar novamente
terá que refazer todo esse trabalho! Não seria fácil se você apertasse um botão e tudo fosse
para o seu devido lugar?
Diferente da vida, no MS Excel podemos sim apertar um botão e esperar a tarefa ser concluída.
O VBA está presente nas aplicações do Microsoft Office desde a versão, possibilitando,
portanto, a automatização de tarefas repetitivas. Enfim, aprender VBA não torna apenas as
tarefas mais seguras frente ao risco operacional, mas também torna o seu usuário um
profissional mais produtivo.
Esta apostila se resguarda a apresentar o VBA aplicado somente ao Microsoft Excel.
2
SUMÁRIO
Introdução ..................................................................................................................................................... 5
Conhecendo o VBA ....................................................................................................................................... 6
Fundamentos ................................................................................................................................................ 9
Afinal, o que é uma Macro? ........................................................................................................ 9
Estrutura Básica ........................................................................................................................... 9
Primeiros Passos ........................................................................................................................ 10
Variáveis e Constantes ............................................................................................................... 10
Domínio das Variáveis ............................................................................................................... 11
Domínios das Contantes ............................................................................................................ 12
Domínio de Rotinas ................................................................................................................... 13
Operadores ................................................................................................................................ 14
Comentar ................................................................................................................................... 15
Entrada de Dados: InputBox ...................................................................................................... 16
Saída de Dados: MsgBox ........................................................................................................... 17
Pontos de Acesso ....................................................................................................................... 17
Propriedades doS ObjetoS ......................................................................................................... 18
Métodos do Objeto ................................................................................................................... 19
Referências ................................................................................................................................ 21
Funções do VBA ......................................................................................................................... 22
Atribuindo uma Sub ................................................................................................................... 24
Utilizando o Gravador de Macros .............................................................................................. 24
Exercícios ................................................................................................................................... 24
Estruturas de Controle ................................................................................................................................ 26
Conhecendo as Estruturas ......................................................................................................... 26
Estrutura If... Then ..................................................................................................................... 27
Estrutura If… Then… Else ........................................................................................................... 27
Estrutura If... Then... ElseIf ........................................................................................................ 27
3
Estrutura Select Case ................................................................................................................. 28
Instrução With ........................................................................................................................... 28
Instrução Set .............................................................................................................................. 29
Instrução On Error ..................................................................................................................... 30
Estrutura While Loop ................................................................................................................. 31
Estrutura Until... Loop ............................................................................................................... 31
Estrutura Do... Loop While ........................................................................................................ 31
Estrutura Do... Loop Until .......................................................................................................... 32
Estrutura For... To... Next .......................................................................................................... 32
Estrutura For... Each .................................................................................................................. 32
Estrutura While... Wend ............................................................................................................ 33
Saindo de Loops e Procedimentos ............................................................................................ 33
Exercícios ................................................................................................................................... 33
Arrays .......................................................................................................................................................... 36
O que são Arrays? ...................................................................................................................... 36
Vetores ....................................................................................................................................... 36
Indexação ................................................................................................................................... 37
Matriz Fixa ................................................................................................................................. 38
Matriz Dinâmica ......................................................................................................................... 39
Janela de Verificação Imediata .................................................................................................. 39
Execícios ..................................................................................................................................... 40
UserForm .................................................................................................................................................... 42
Quando usar UserForm ............................................................................................................. 42
Introdução ao UserForm ........................................................................................................... 42
Criando uma UserForm ............................................................................................................. 42
Propriedades .............................................................................................................................. 43
Inserindo Objetos ...................................................................................................................... 44
Tabulação ................................................................................................................................... 45
Exercícios ................................................................................................................................... 45
4
VBA Aplicado ............................................................................................................................................... 47
Metodologia .............................................................................................................................. 47
Formação de Banco de Dados ................................................................................................... 47
Automatização de Relatórios .................................................................................................... 48
VBA Aplicado a Finanças ............................................................................................................ 49
Exercícios ................................................................................................................................... 51
Bibliografia .................................................................................................................................................. 53
Considerações Finais ................................................................................................................................... 54
5
INTRODUÇÃO
O Basic é uma linguagem de programação criada nos inícios dos anos 60 e que foi lançada nos
anos 90 pela Microsoft como Visual Basic. Em 1995 as aplicações do Office incluem o Visual
Basic for Applications, conhecido como VBA, que é na realidade uma linguagem script comum
para todas as aplicações da Microsoft.
O MS Excel em si é um programa muito eficiente sem concorrentes, contudo, o uso
principalmente de Loops (Iterações), de Funções Aninhadas (Múltiplas funções como
argumento de outras) e de Movimentos Repetitivos se demonstram ineficientes. Para resolver
isto, o uso da programação em VBA é ideal.
Com VBA podemos criar Rotinas e Funções em Macros que facilitarão a realização destes
trabalhos no MS Excel.
Esta apostila contém 50 questões divididas em quatro capítulos. No penúltimo capítulo será
apresentado a construção de três projetos em VBA. Termina-se a apostila com algumas
considerações finais sobre o tema. Além disto a apostila também possui um material que será
chamado apenas por Templates. Estes são nada mais que alguns arquivos Excel contendo
códigos em VBA que realizam alguma simples tarefa.
6
CONHECENDO O VBA
Primeiramente devemos habilitar a ferramenta VBA para o MS Excel. Fazemos isto na guia
Arquivo, no botão Opções, a janela Opções do Excel deve ser apresentada, isto feito, clique na
opção Add-ins, em seguida, na parte de baixo da janela, clique no botão Ir. Isto feito, selecione
as opções Ferramentas de Análises, Ferramentas de Análises - VBA e Solver Add-in.
Em seguida vamos apresentar a Guia Desenvolvedor do Microsoft Excel que, por padrão, vêm
desabilitada. Para isto, clique na guia Arquivo, em seguida no botão Oções, clique na guia
Personalizar Faixa de Opções. Por fim, no lado direito da janela, selecione a opção
Desenvolvedor. Termine clicando em OK.
Em uma explicação concisa, a aba Desenvolvedor é composta por cinco grupos:
1. Grupo Código, que é composto pelos botões: a) Visual Basic, que abre o Editor do Visual
Basic, o que pode ser feito através do atalho de teclado Alt + F11; b) Macros, que exibe
a lista de macros, podendo portanto executar, criar ou excluir uma macro; c) Gravar
Macro, que serve para gravar uma macro onde cada comando que você executar será
salvo, de tal forma que poderão ser reproduzidos outra vez; d) Usar Referências
Relativas, que permite que a macro seja gravado com ações relativas à célula inicial
selecionada; e e) Segurança da Macro, que personaliza as configurações de segurança
da macro.
2. Grupo Suplementes, que é composto pelos botões: a) Suplementos, que gerencia os
suplementos disponíveis para uso com o arquivo final; e b) Suplementos COM, que
gerência os suplementos COM disponíveis.
3. Grupo Controles, que é composto pelos botões: a) Inserir, que insere controles de
formulário no documento; b) Modelo de Design, que ativa ou desativa o Modo de
Design para edição dos controles de formulário; c) Propriedades, que exibe ou modifica
as propriedades do controle modificado; d) Exibir Código, que permite a edição do
código VBA para um controle; e e) Executar Caixa de Diálogo, que executa uma caixa de
diálogo personalizada.
4. Grupo XML, que é composto pelos botões: a) Código Fonte, que abre o painel de tarefas
do Código-fonte XML para gerenciar mapas XML na pasta de trabalho anual; b)
Propriedades do Mapa, que exibe ou modifica as propriedades dos mapas XML. Pacotes
de Expansão, que gerencia os pacotes de expansão para XML anexados a este
documento ou anexa um novo pacote de expansão; d) Atualizar Dados, que atualiza os
dados XML da pasta de trabalho atual; e) Importar, que importa um arquivo de dados
XML; e f) Exportar, que exporta um arquivo de dados XML.
7
5. Grupo Modificar, que é composto pelo botão: a) Painel de Comandos, que específica o
tipo de modelo do Painel de Informações do Documento para exibir em programas
compatíveis com o Office.
Apresentada a Guia Desenvolvedor, vamos tratar brevemente dos botões Gravar Macro e Usar
Referência Relativas, ambos do Grupo Código. Primeiramente, o segundo botão mencionado é
uma ferramenta para o primeiro. Quando ativamos o uso das referências relativas, dizemos ao
MS Excel para percorrer uma determinada direção, sem definirmos um ponto de partida.
Quando não usamos referências relativas, ordenamos ao Excel que use um determinado ponto
de partida.
Quando gravamos uma macro, quase todas as ordens que fizermos ao MS Excel serão gravadas
em um módulo VBA, que pode ser facilmente alterado. Se, por exemplo, gravamos uma macro
onde pegamos uma certa região e trocamos a cor da fonte de preta para vermelho, ao usarmos
referências absolutas, sempre que executarmos essa macro, aquela exata mesma região irá ter
a cor de sua fonte alterada para vermelho. Se usarmos a referência relativa, a região alterada
será aquela respectiva ao posicionamento da célula ativada no momento em que se executar a
macro, indiferente da região que fora usada para gravar a macro.
Contudo, não é interessante utilizar o gravador de macros para automatizar suas tarefas,
simplesmente porque muitas condições mudam e esta ferramenta não foi criada para ser
executada em condições, nem que ligeiramente diferentes, daquela ao qual a macro foi criada.
Todavia, não devemos abandonar uma ferramenta tão importante! Por exemplo, imagine que
você quer deixar uma célula em negrito automaticamente, mas esqueceu-se da fórmula para
fazer isto. Muito simples, inicie a gravação de uma macro, transforme uma célula qualquer em
negrito, termine a gravação da macro, abra o Editor do Visual Basic, procure pelo Módulo em
que a Macro está, olhe o código e utilize seus fundamentos no decorrer do código para
automatizar suas planilhas.
Portanto, no decorrer desta planilha, o objetivo será trabalhar apenas com o editor do VBA,
acessado pelo botão Visual Basic da guia Desenvolvedor. Assim que for aberto, clique no menu
Inserir, e em seguida no botão Módulo. Pronto, podemos iniciar nosso estudo em VBA.
Antes de iniciarmos o estudo desta apostila há uma condição relevante a ser informada. É
muito desejarmos realizar determinada tarefa, e não sabermos o caminho certo. Neste caso
buscamos a informação em sites de pesquisa, como o Google ou Bing.
Buscando pela dúvida irá encontrar diversos outros usuários que provavelmente passaram pela
mesma dúvida e já conseguiram a solução. Diferentes de outros mercados, o campo da
informática é muito solícito e a participação em fóruns e comunidades contam enquanto capital
intelectual.
8
Isto posto, torna-se fácil buscar soluções de problemas, inclusive obter planilhas completas. O
campo do VBA é extenso demais para ser resumido em uma única apostila. Contudo, sem o
conhecimento básico é impossível entender as informações fornecidas pela comunidade online.
Exatamente por isto o estudo desta apostila é essencial.
9
FUNDAMENTOS
AFINAL, O QUE É UMA MACRO?
Uma Macro é um conjunto ou sequência de rotinas e funções armazenados em um módulo do
VBA, possuindo, portanto, capacidade de executar comandos e realizar cálculos. Uma Macro
pode ser utilizada sempre que você precisar executar uma determinada tarefa, funcionando,
portanto, como um método de aumento de produtividade, pois representa um atalho,
poupando tempo e trabalho.
Para entender de fato, devemos antes conhecer Rotinas e Funções. O primeiro se refere a um
conjunto de comandos que são executados automaticamente, enquanto que o segundo a um
conjunto de cálculos que são executados e relacionados. Todavia, tanto Rotinas quanto
Funções possuem a mesma estrutura básica.
ESTRUTURA BÁSICA
Objetos são dados ou códigos que representa um elemento específico do MS Excel. O VBA
manipula elementos do MS Excel e nisto ele realiza uma determinada tarefa retornando um
objeto.
Procedimentos são unidades de códigos localizados dentro de uma Rotina ou Função que
realizam diversas tarefas, sendo que cada procedimento desempenha apenas uma tarefa
específica. Deixemos bem claro que um procedimento de função é o único que pode retornar
valor.
Um Módulo é um conjunto de procedimentos que realiza tarefas específicas.
Variáveis são nada menos que uma parte da memória do sistema que está sendo referenciada
por um identificador. Uma variável pode armazenar um valor e altera-lo a qualquer momento.
Constantes são valores que não se alteram durante a execução de uma rotina.
O Domínio (ou Scope) de um elemento refere-se à área na aplicação na qual esse elemento
pode ser acessado e utilizado, ou seja, é onde ambiente em que o elemento é reconhecido.
Operadores são ferramentas para realização de cálculos e tarefas.
10
Funções de Entrada/Saída permitem obter dados do ambiente exterior ao MS Excel e leva-los
para a memória do sistema e também fornecer dados do sistema ao meio externo.
As Estruturas de Controle são uma base de programação que determina o curso de ações de
um algoritmo.
Vetores e Matrizes são conjuntos de elementos de mesma natureza, que se distinguem por
índices inteiros. Podem ser unidimensionais ou multidimensionais.
Um Formulário de Usuário é uma caixa de diálogo, personalizada, que possui capacidade para
conter diversos tipos de objetos.
PRIMEIROS PASSOS
Vejamos um exemplo, perceba que Function é para função e Sub é para rotina (sub-rotina):
Function (ou Sub) NomeDaFunção( Param1 As Tipo, ..., ParamN As Tipo ) As Tipo
Aqui vem o corpo da função (ou macro)
NomeDaFunção = Valor de Retorno
End Function (ou Sub)
VARIÁVEIS E CONSTANTES
Uma variável pode ser declarada, especificando o escopo ao qual ela poderá ser acessada ou
manipulada. Para impedir que o VBA faça declarações implícitas, insira a instrução Option
explicit em um módulo antes de todos os procedimentos. Deste modo é obrigado declarar as
variáveis. O tipo de uma variável determina a quantidade de memória que ela ocupará. Uma
variável é declarada utilizando a sintaxe abaixo:
Dim var_x As Tipo x, var_y As Tipo y, var_z As Tipo z, . . .
Mais de uma variável, sendo todas do mesmo tipo, são declaradas da seguinte forma:
Dim var_x, var_y, var_z As Tipo
Quando declaramos uma variável por meio do qualificador const dizemos que o conteúdo
inserido não será alterado durante o programa, i. e., que se trata de uma constante. No
momento de sua declaração a ela deve ser atribuído um valor. A sintaxe da declaração de
constante é dada abaixo.
Const constante As Tipo = Valor ou Expressão de cálculo
11
Quanto à denominação de variáveis e constantes, aqui cabem algumas dicas. Utilize apenas
letras minúsculas. Em caso de mais de uma palavra, utilize um traço rasteiro (também
conhecido como underline ou underscore) entre elas. Utilize nomes significativos, evitando
nomes sem significados ou abreviaturas não usuais. Lembre-se de outras pessoas vão ler o seu
código e é certo fazê-lo da forma mais intercambiável possível.
O VBA opera com os seguintes tipos básicos de objetos:
Nome Tamanho Intervalo
Integer 2 bytes -32768 a 32767
Long 4 bytes -2.147.483.648 a 2.147.483.467
Single 4 bytes -3,4 x 1038 a 3,4 x 1038
Double 8 bytes 1,7 x 10308 a 1,7 x 10308
Currency 8 bytes -9223372036854,5808 a 9223372036854,5807
String 1 byte por caractere 0 a aproximadamente 65.500
Boolean 2 bytes Verdadeiro ou Falso
Date 8 bytes 01/01/100 a 31/12/9999
Object 4 bytes Qualquer referência a objeto
Variant 16 bytes (+1 byte p/ caractere) Válido para qualquer tipo de dados.
Reforçamos aqui o esforço em declarar variáveis, quando trabalhamos com muitos dados ou
com códigos muito extensos a declaração faz diferença na performance e no entendimento
futuro do código, respectivamente. Claro que para códigos simples a declaração não é
essencial.
DOMÍNIO DAS VARIÁVEIS
O domínio das variáveis refere-se à área onde a variável permanece ativa, mantendo o valor
que lhe vai sendo atribuído. Existem três níveis de domínio para as variáveis. O âmbito do
procedimento, o âmbito do módulo e o âmbito do projeto. Por exemplo, as declarações de
tipos UserDefined que são escritas no Declarations do módulo têm domínio no âmbito do
projeto. Vejamos agora cada tipo de âmbito. O âmbito do procedimento contém variáveis que
são declaradas no corpo do procedimento com o recurso da palavra chave Dim. São variáveis
criadas quando o procedimento termina, sendo que só são reconhecidas no seio do
procedimento que as declarou. Isto posto, qualquer tentativa realizada por um procedimento
no sentido de trabalhar com variáveis definidos no corpo de um outro procedimento não terá
êxito.
12
Sub rotina()
Dim var_1 As Integer
End Sub
O âmbito do módulo contém variáveis aceitas por todas as rotinas existentes no módulo onde a
variável é declarada. Para declarar uma variável do nível modular, deverá declará-la com a
palavra Dim da seção Declarations do respectivo módulo VBA. Neste caso qualquer variável
declarada será considerada de nível modular por omissão, para tornar esse fato mais explicito
poder-se-á utilizar a palavra chave Private na declaração ao invés de Dim.
Sub rotina()
Private var_1 As Tipo
Sub End
O âmbito do projeto possui variáveis que têm o âmbito correspondente a todo o projeto, isto é,
podem ser acedidas e alteradas em todos e quaisquer módulos. Para declarar variáveis deste
tipo, deverá fazer na seção Declarations de qualquer módulo, para tal deverá utilizar a palavra
chave Public.
Public var_1 As Tipo
Sub rotina()
corpo da rotina
End Sub
DOMÍNIOS DAS CONTANTES
O domínio da constante refere-se à área onde a constante permanece ativa, mantendo o valor
que lhe vai sendo atribuído. Existem três níveis de domínio para as variáveis. O âmbito do
procedimento, o âmbito do modulo e o âmbito do projeto.
O âmbito do procedimento contém constantes que são declaradas no corpo do procedimento
com recurso à palavra chave Const. Assim como as variáveis, ela tem existência apenas dentro
do procedimento onde são declaradas.
Sub rotina()
Const constante As Tipo = valor
End Sub
13
O âmbito do módulo contém constantes que são utilizadas por todas as rotinas existentes no
módulo onde é definida. Para declarar uma constante a nível modular, deverá declará-la com a
palavra-chave Const na seção Declarations do respectivo módulo VBA. Neste caso, qualquer
constante aí declarada será considerada de nível modular por omissão, para tornar esse fato
mais explicito se pode utilizar a palavra-chave Private na declaração.
Sub rotina()
Private Const constante As Tipo
End Sub
O âmbito do projeto possui constantes que têm o âmbito correspondente a todo o projeto, isto
é, podem ser utilizadas em todos e qualquer módulo. Para definir constantes deste tipo deverá
fazê-lo na seção Declarations de qualquer módulo, para tal deverá utilizar a palavra chave
Public.
Sub rotina()
Public Const constante As Tipo
End Sub
DOMÍNIO DE ROTINAS
O domínio de sub-rotinas e funções possuem dois níveis, o nível do projeto e o nível do
módulo. Isto é, não existe o nível de procedimento, apenas projeto e módulo.
Por omissão, as rotinas são de âmbito do projeto sem qualquer indicação adicional. Contudo
poderá tornar este fato mais explicito pela introdução da palavra chave Public, que em termos
operacionais não adicionará qualquer funcionalidade, mas em termos de leitura uma maior
percepção.
Public Sub var_I()
corpo da rotina
End Sub
Para que uma rotina tenha o âmbito do módulo onde está definida, deverá ser antecedida pela
palavra-chave Private.
Private Sub var_I()
corpo da rotina
End Sub
14
OPERADORES
Um Operador de Atribuição é representado pelo sinal de igualdade (=) e atribui a uma variável
uma expressão à direita do sinal de igualdade.
Os Operadores Aritméticos operam dados quantitativos.
Os Operadores Lógicos fazem comparações e verificam relações de diferença entre dois
valores, indicando uma comparação a ser realizada através de uma expressão lógica.
Vejamos a ordem ao qual os operadores são executados. A ordem é de cima para baixo.
Aqueles entre parênteses possuem a mesma prioridade e são executados na ordem em que são
escritos, ou seja, da esquerda para direita.
1. Operadores Aritméticos:
Operação Operador Sintaxe
Multiplicação * r = n1 * n2
Divisão / r = n1 / n2
Adição + r = n1 + n2
Subtração – r = n1 – n2
Potenciação ^ r = b ^ e
Divisão (retorna o resto) Mod r = n1 Mod n2
Divisão (retorna o quoc. inteiro) \ r = n1 \ n2
Raiz quadrada sqr(9.0) 3
Parte inteira int(7.8) 7
Valor absoluto abs(-5) 5
Número aleatório rnd(12) ?
Seno sin(3.7) 0,53
Co-seno cos(4.1) 0,57
Tangente tan(6.8) 0,56
15
2. Operadores Lógicos:
Operação Operador
Igual a =
Maior que >
Menor que <
Diferente de <>
Maior ou igual a >=
Menor ou igual a <=
Expressão usual Operação Operador
E Conjunção And
OU Disjunção Or
NÃO Negação Not
Tabela Verdade
conjunção (and) disjunção (or) negação (not)
V e V = V V ou V = V não V = F
V e F = F V ou F = V não F = V
F e V = F F ou V = V
F e F = F F ou F = F
Lembre-se bem destes operadores aritméticos e lógicos, que serão muito usados na
organização de dados numéricos.
COMENTAR
É muito comum encontrar códigos comentados. Esta prática permite que não só o criador do
código reconhecer cada etapa, mas também para que um terceiro tenha mais facilidade no
entendimento.
O ato de comentar, também chamado de “tickar”, é apresentado abaixo.
16
Sub rotina()
ˈIsto é um comentário.
x = Sheets("Plan1").Range("A1").Value
'Na linha acima nós atribuímos à variável x o valor que existe na célula "A1"
da folha "Plan1".
End Sub
Enfim, basta acrescentar uma aspa em um ponto da linha que toda a parte à direita da aspa
será um comentário, e não será lida pelo VBA no momento de executar os códigos.
Reafirmamos que é uma boa prática comentar códigos, ainda mais no início do estudo de VBA.
ENTRADA DE DADOS: INPUTBOX
A função InputBox (caixa de entrada) permite que usuário introduza dados de entrada, exibindo
um aviso em uma caixa de diálogo, em que uma caixa de entrada aguarda até que usuário
introduza informação e a envie. Sintaxe:
InputBox(prompt[, title] [, default] [, xpos] [, ypos] [, helpfile, context])
Onde:
1. (Obrigatório) prompt: representa a mensagem que será exibida na caixa de diálogo.
2. (Opcional) title: texto a ser exibido na barra de título da caixa de diálogo.
3. (Opcional) default: dado padrão de entrada a ser exibido na caixa de texto.
4. (Opcionais) xpos e ypos: especificam as coordenadas para posicionamento da caixa de
diálogo na tela.
5. (Opcionais) helpfile e contexto: identifica o arquivo de ajuda do usuário e o número de
contexto atribuído ao tópico da ajuda.
Há uma observação a ser feita sobre a instrução InputBox. Quando ao invés de colocarmos um
valor na caixa de entrada, cancelamos a entrada de dados, a variável que recebe o valor da
InputBox passará a receber um valor não existente (conhecido no Excel como erro #N/D) e,
portanto, irá retornar um erro no decorrer do código do VBA.
Há, contudo, um método de resolver essa falha. Utilizamos a instrução On Error, que, em caso
de erro, ela executa um comando alternativo. Veremos mais sobre esta instrução no próximo
capítulo.
17
SAÍDA DE DADOS: MSGBOX
A função MsgBox mostra uma caixa de diálogo com uma mensagem contendo um botão. É uma
função de saída de dados. Sintaxe:
MsgBox(prompt[, buttons] [, title] [, helpfile, context])
Onde:
1. (Obrigatório) prompt: mensagem que será exibida na caixa de diálogo.
2. (Opcional) buttons: especifica o tipo de botão a ser exibido na caixa de diálogo.
3. (Opcional) title: texto a ser exibido na barra de título da caixa de diálogo.
4. (Opcionais) helpfile e contexto: identifica o arquivo de ajuda do usuário e o número de
contexto atribuído ao tópico da ajuda.
PONTOS DE ACESSO
Há diversas formas de fazer pontos de acesso para Macros. Podemos simplesmente associar
um conjunto de teclas de atalho para uma determinada Macro. Para isso entre exiba a caixa de
diálogo “Macros” utilizando a aba Desenvolvedor ou clicando Ctrl + F8. Selecione a Macro de
preferência, clique em Editar e em seguida digite o atalho do teclado desejado.
Uma forma mais visual seria associar objetos da planilha às Macros, de modo que clicando
sobre o objeto a Macro é executada. Neste caso, basta clicar com o botão direito do mouse
sobre o objeto, procure a opção “Atribuir Macro”. Os objetos mais utilizados são botões e
autoformas.
Objetos Básicos
Vejamos os objetos que são mais frequentemente utilizados:
1. Range se refere a uma única célula ou uma região de células específicas.
2. Worksheets se refere a uma folha de planilha em particular de um ficheiro.
3. Workbooks se refere a um ficheiro do MS Excel, i. e., um documento.
4. Application representa o próprio MS Excel.
Todo objeto possui Propriedades, Métodos e Eventos. As propriedades constituem o conjunto
de características que definem o objeto, como nome, cor, dimensão, etc.
18
Os Métodos traduzem o comportamento do objeto, representando procedimentos que
executam uma determinada tarefa, que pode ser complementada através da passagem de
argumentos ou parâmetros.
Os Eventos, por sua vez, representam todas as atividades que envolvam o objeto e que
normalmente são diretas ou indiretamente provocados pelo utilizador do sistema.
A seguir vejamos as propriedades de cada um destes objetos supracitados. Depois veremos os
métodos.
PROPRIEDADES DOS OBJETOS
Abaixo listamos as propriedades do objeto Range:
1. Count representa o número de Células em um Range (Read-Only).
2. Dependents retorna um Range, que contém todos os dependentes (valores
indexados pelas fórmulas) do range em questão (Read-Only).
3. Name é o nome de um Range (Read/Write).
4. Value é o valor constante de um range, i.e., célula ou conjunto de células
(Read/Write).
5. Formula traduz a fórmula contida num range como uma string (Read/Write).
6. Text busca o conteúdo de uma célula mas em formato de texto.
O termo Ready-only significa que aquela propriedade é somente leitura, i. e., não é alterável. O
termo Ready/Write significa que pode ocorrer alteração.
Abaixo listamos as propriedades do objeto Worksheet:
1. Index é o índice de uma WorkSheet em um WorkBook.
2. Name é o nome da WorkSheet.
3. UsedRange traduz o range na WorkSheet que contêm dados.
4. Visible quando TRUE deixa a planilha visível, quando FALSE deixa-a escondida,
nesse caso, contudo, o utilizador pode visualizá-la recorrendo ao Menu Format.
Quando ela está na condição XlVeryHidden, ela fica escondida e ninguém, nem
mesmo o utilizador, pode visualizar, a menos que volte a aplicar uma sub-rotina
que a coloque visível.
19
Abaixo listamos as propriedades do objeto Workbook:
1. Name é o nome do ficheiro. Não permite a alteração do nome, para isso é
necessário proceder ao Save/As.
2. Path é a diretoria onde o ficheiro se encontra.
3. Saved fica TRUE se não houver nenhuma alteração no ficheiro desde a última
gravação, fica FALSE caso contrário.
Abaixo listamos as propriedades do objeto Application:
1. Caption refere-se à menção exibida na barra de títulos do Excel.
2. DisplayAlerts quando TRUE significa que as mensagens de alerta são exibidas
durante a execução da sub-rotina. Para FALSE temos o caso contrário.
3. Path é o nome da diretoria onde o Excel está instalado.
4. ScreenUpdating quando TRUE vai alterar o écran consoante a sub-rotina que
executa. Caso contrário, o écran não é alterado durante a execução da subrotina.
5. WindoWorkSheetState refere-se ao estado da janela da aplicação, podendo ser
XlNormal (janela tamanho normal), XlMaximized (janela tamanho maximizado) e
XlMinimized (janela com tamanho minimizado).
6. DisplayStatusBar mostra ou esconde a StatusBar, quando TRUE ela exibe,
quando FALSE não exibe. A opção DisplayFormulaBar mostra ou esconde a Barra
de Formulas, quando TRUE ela exibe, caso contrário não exibe.
MÉTODOS DO OBJETO
Abaixamos listamos os métodos do objeto Range:
1. Calculate provoca o cálculo da fórmula constantes do range. Esse método não
tem argumentos.
2. ClearContents apaga o conteúdo (fórmulas e valores) de uma célula, deixando os
formatos. Esse método não tem argumentos.
3. Copy copia o conteúdo de um range para um outro de igual dimensão ou então
para o clipboard. Seu argumento é o Destination, que é a Range para o qual os
valores vão ser copiados. Em sua ausência a cópia é feita para o clipboard.
20
4. OffSet provoca um deslocamento de um determinado número de linhas e de
colunas, tendo como base o range ao qual este método está a ser aplicado. Seus
argumentos são o RowOffset, que é o número de linhas que se desloca e
ColumnOffset, que é o número de colunas que se desloca.
5. EntireRow faz referência à(s) linha(s) indicadas por um determinado range. Esse
método não tem argumentos.
6. Select selecciona o range em questão. Seu argumento é o Replace (Opcional).
7. Cell faz referência a uma célula, através dos seus índices numéricos. Seus
argumentos são o número da Linha e o número da Coluna, por exemplo, a Célula
C5 será representado por Cells( 5, 3).
Abaixamos listamos os métodos do objeto Worksheet:
1. Activate ativa uma determinada WorkSheet. É o equivalente a estarmos a
trabalhar num WorkBook e clicarmos nela para visualizarmos o seu conteúdo.
Este método não tem argumentos.
2. Calculate provoca o cálculo de todas as fórmulas constantes da WorkSheet. Esse
método não tem argumentos.
3. Delete apaga uma WorkSheet do WorkBook. Esse método também não tem
argumentos.
4. Protect protege uma WorkSheet contra qualquer tipo de alteração. Ele tem
alguns argumentos, como Password, que é a senha a utilizar na proteção,
DrawingObjects, que quando TRUE protege os objetos gráficos, Contents, que
quando TRUE protege as células e conteúdos, Scenarios, que quando TRUE
protege os cenários ligados à WorkSheet e UserInterfaceOnly, que quando TRUE
protege as interfaces contra alterações apesar de poder alterar as sub-rotinas)
5. Cell faz referência a uma célula, através dos seus índices numéricos. Seus
argumentos são o número da Linha e o número da Coluna , por exemplo, a célula
C5 será representado por Cells(5, 3).
Abaixamos listamos os métodos do objeto Workbook:
1. Activate ativa um documento aberto. É equivalente a ir ao Windows e selecionar
um documento aberto, trazendo-o para a janela principal do Excel. Esse método
não tem argumentos.
21
2. Close fecha um documento. Seus argumentos são SaveChanges, que se TRUE o
documento será gravado antes de ser fechado, FALSE caso contrário, FileName,
que se o argumento acima estiver TRUE, o WorkBook será gravado com o nome
aqui indicado e RoutWorkBook, que se TRUE e o WorkBook tiver endereços para
envio atribuídos, envia o ficheiro por e-mail antes de fechar, caso contrário não.
3. Protect protege um documento contra qualquer tipo de alteração. Seus
argumentos são Password, que é a senha a utilizar na proteção, Structure, que
quando TRUE protege também a estrutura e WindoWorkSheet, que quando
TRUE a estrutura do WorkBook na janela é protegida.
4. Save grava o WorkBook. Esse método não tem argumentos.
5. SaveCopyAs cria uma cópia do documento em questão. Seu argumento é o
FileName, que é o nome da cópia pretendida para o ficheiro.
Abaixamos listamos os métodos do objeto Application:
1. Calculate implica que o cálculo de todas as fórmulas de todas as WorkSheet e
WorkBookS estejam abertos. Esse método não tem argumentos.
2. Help exibe um tópico do Help de um determinado ficheiro de Help. Os
argumentos desse método são o Helpfile, que contém nome do ficheiro,
incluindo a path se necessário, e o Helpcontextid, que contém o número que faz
referência ao índice de help)
3. Quit fecha a aplicação Excel. Se a propriedade Display alerts estiver com o valor
False, o Excel não proporá a gravação de alterações nos ficheiros. Esse método
não tem argumentos.
4. Run é utilizado para correr uma sub-rotina de VBA ou uma Macro do XL
Argumentos. A macro é o nome da macro ou sub-rotina a executar. Os
argumentos que a sub-rotina necessita para ser executada são: arg1:=<valor 1>,
arg2:=<valor>,etc.
REFERÊNCIAS
Quando se faz referência, por exemplo, a uma célula da WorkSheet, pode-se fazê-lo de diversas
formas equivalente. Abaixo vamos apresentar a equivalência entre a expressão mais completa
na primeira linha e a mais reduzida na segunda linha, sendo que ambas têm a mesma função. O
exemplo será colocar na célula A1 o valor 1.
22
Vamos agora sintetizar o nível de referência em 7 diferentes níveis de codificação.
Aplication.Workbooks(1).Worksheets(1).Range("A1").Value = 1
Workbooks(1).Worksheets(1).Range("A1").Value = 1
ActiveWorkbook.Worksheets(1).Range("A1").Value = 1
Worksheets(1).Range("A1").Value = 1
Activesheet.Range("A1").Value = 1
Range("A1").Value = 1
Range("A1") = 1
Então, se existem tantas formas de referências uma célula, qual a forma a privilegiar? O ideal
seria escrever da forma mais completa, contudo existem algumas desvantagens, tais como: a)
código muito denso, apresentando dificuldades em escrever e ler; e b) maior probabilidade de
ocorrência de erros, já que quando não se sabe precisamente o contexto em que a aplicação vai
ser executada é perigoso descrever um caminho de modo completo.
FUNÇÕES DO VBA
Antes de prosseguirmos com o estudo mais aprofundado das estruturas do VBA, vejamos uma
tabela contendo todas as funções internamente aplicáveis.
Função Descrição
Abs Valor absoluto de um número.
CurDir Diretoria MS-DOS corrente.
Date Data do sistema.
Exit Do Interrompe a execução de uma ciclo Do – Loop.
Exit For Interrompe a execução de um ciclo For – Next ou For Each – Next.
Exit Function Provoca a interrupção da execução de uma função.
Exit Sub Provoca a interrupção da execução de uma subrotina.
Fix Arredonda um número decimal positivo para baixo, e um negativo para cima. Ex.: 3,9 ->3 e –3,9 -> -3
Int Arredonda para cima um número decimal positivo ou negativo. Ex.: 3,9 ->4 e –3,9 -> -4
Is Array True se a expressão é um array. False caso contrário.
IsDate True se a expressão é do tipo Date. False caso contrário.
23
Função Descrição
IsEmpty True se nenhum valor foi atribuído à variável.
IsError True se a expressão contiver um erro.
IsNull True se a expressão representar o valor NULL.
IsNumeric True se a expressão for numérica.
IsObject True se se tratar de um objecto.
Len Retorna a dimensão de uma String.
Now Retorna o valor da data e da hora atual.
Shell Corre um programa executável.
Sqr Retorna a raiz quadrada de um número.
Str Retorna a representação String de um número.
StrComp Realiza a comparação de strings, produzindo True ou False conforme sejam ou não iguais.
Time Produz a hora atual.
TypeName Retorna o tipo de dados de uma variável.
Cint Converte uma expressão de forma numérica ou textual para um valor de tipo inteiro.
Cbool Converte uma expressão de forma numérica ou textual para um valor de tipo booleano.
Cdate Converte uma expressão de forma numérica ou textual para um valor de tipo data.
CLng Converte uma expressão de forma numérica ou textual para um valor de tipo Long.
CStr Converte uma expressão de forma numérica ou textual para um valor de tipo String.
Além das funções próprias do VBA apresentadas acima, é possível utilizar dentro do VBA
funções características do MS Excel, para tal utilizamos a propriedade WorksheetFunction do
objeto Application. Por exemplo, suponhamos que desejamos conhecer o número total de
células preenchidas na coluna A, a partir do VBA, para isto utilizamos a fórmula:
Application.WorksheetFunction.CountA (Range("A:A"))
Que utiliza da função CountA, nada menos que a função CONT.VALORES do MS Excel. No anexo
desta apostila há uma tabela com as funções em português e sua respectiva tradução, assim
como uma breve apresentação do propósito da função.
24
ATRIBUINDO UMA SUB
Existem diversas modos de executar uma Macro. Listamos abaixo, em ordem decrescente de
acessibilidade, três dos principais métodos.
a. Estando com o Editor do Visual Basic aberto e com o cursor selecionado dentro do
código do VBA, isto é, entre as linhas “Sub” e “End Sub”, aperte com o símbolo de “Play”
na barra de ferramentas do editor ou aperte o botão F5.
b. Estando utilizando o MS Excel, na aba “Desenvolvedor”, no grupo “Código”, no botão
“Macros”, clique nele e, em seguida, selecione a Macro desejada e aperte o botão
“Executar”.
c. Atribua uma Macro a um objeto do MS Excel. Para isso existem dois métodos básicos:
a. Na aba “Desenvolvedor”, aperte o botão “Inserir” e escolha a opção “Botão”. Em
seguida clique na planilha para inserir um botão. Ao fazer isto aparecerá uma
opção com uma lista das Macros disponíveis. Escolha a desejada e aperte em
“Ok”. Para editar a Macro, clique com o botão direito do mouse no botão, clique
em “Atribuir Macro” e escolha a nova Macro.
b. Na aba “Inserir”, no grupo “Ilustrações”, no botão “Autoformas”, escolha a
forma desejada, como um retângulo ou um círculo, e o desenhe na Planilha. Em
seguida, clique com o botão direito sobre este objeto, escolha a opção “Atribuir
Macro”, escolha a Macro desejada e aperte o botão “Ok”.
UTILIZANDO O GRAVADOR DE MACROS
É corriqueiro esquecermos uma expressão ou uma linha de código. Inclusive, em alguns
momentos, queremos realizar tarefas ao quais simplesmente não conhecemos o código para
fazê-las. Nestas situações utilizamos o “Gravador de Macros”, botão que já foi apresentado no
início desta apostila.
Quando iniciamos a gravação de uma Macro, toda e qualquer ação será gravada em uma Sub
da planilha. Os códigos são gravados na mesma ordem das ações. É comum, portanto,
pegarmos o código e, em seguida, utiliza-lo para outras situações.
EXERCÍCIOS
1. Utilizando da instrução InputBox crie uma caixa de entrada para colocar o valor de sua idade
e em seguida utilizando a instrução MsgBox apresente este valor.
25
2. Crie uma caixa de entrada de valores para três valores e apresente a média dos mesmos em
uma caixa de diálogo. Na sua Macro coloque um código para que não ocorra o erro do
cancelamento da instrução InputBox.
3. Refaça a questão acima trocando a origem dos valores. Ao invés deles serem adicionados via
InputBox, faça com que eles sejam oriundos de células de uma planilha no MS Excel.
4. Crie uma ferramenta para calcular o tempo corrido entre duas datas. Os valores de entrada
devem ser oriundos de células de uma planilha.
5. Crie uma função que receba os valores dos catetos de um triângulo e calcule a hipotenusa.
26
ESTRUTURAS DE CONTROLE
CONHECENDO AS ESTRUTURAS
Existem basicamente dois tipos de estruturas de controles: Estruturas de Seleção e Estruturas
de Repetição.
As estruturas de seleção são formadas por instruções condicionais que avaliam a veracidade de
uma comparação, isto é, se esta é verdadeira ou falsa. Em seguida as instruções especificam
uma ou mais instruções a serem executadas para cada resultado da avaliação feita. As
principais estruturas são:
1. If... Then
2. If... Then... Else
3. If... Then... Elseif
4. Select... Case... Else
Além disto, instruções servem de auxiliares às estruturas de controle. Aqui veremos três das
principais instruções: With, Set e On Error.
As estruturas de repetição permitem a execução de um grupo ou bloco de instruções
repetidamente, isto é, uma quantidade de vezes seguidas. As instruções serão repetidas até
que uma condição seja verdadeira ou falsa. Também há loops, i. e., circuitos que repetem
instruções um número específico de vezes ou para cada objeto de uma determinada coleção.
1. Do While/Until... Loop
2. Do... Loop While/Until
3. For... Next
4. For Each... Next
5. While... Wend
27
ESTRUTURA IF... THEN
Ela testa uma condição única e executa uma ou mais instruções. Sua sintaxe é dada abaixo.
If condição Then
Instruções
End If
Em resumo, se a condição for verdadeira ele irá executar as instruções, caso contrário, ele nada
fará.
ESTRUTURA IF… THEN… ELSE
Esta testa uma condição única e executa um entre dois ou mais blocos de instruções. Segue a
sintaxe.
If condição Then
Instruções
Else
Instruções
End If
Em resumo, se a condição for verdadeira ele executará o primeiro bloco de instrução, caso
contrário, ele executará o segundo.
ESTRUTURA IF... THEN... ELSEIF
A estrutura testa mais de uma condição e executa um conjunto de instruções de acordo com a
satisfação das condições. Sua sintaxe é dada abaixo.
If condição Then
Instruções
ElseIf condição Then
Instruções
. . .
28
. . .
Else
Instruções
End If
Em resumo, se a primeira condição for satisfeita, ele executará o primeiro bloco de instruções.
Caso esta primeira condição seja falsa, ele irá testar uma segunda condição, que se for
verdadeira, ele irá executar o segundo bloco de instrução. Caso nenhuma condição seja
verdadeira, ele irá executar o último bloco de instruções.
ESTRUTURA SELECT CASE
Esta estrutura testa uma condição única e executa um conjunto de instruções de acordo com a
satisfação da condição testada. Segue abaixo sua sintaxe.
Select Case var(1)
Case expr(1): instruções(1)
. . .
Case expr(n): instruções(n)
Case Else: instruções(n+1)
End Select
Onde Var(i) significa variável e expr(i) significa expressão numérica ou de sequência de
caracteres. Se var(i) = expr(i) será executada a instrução(i). Caso não ocorra a igualdade, será
executada a instrução(n+1). Esta estrutura é recomendada quando temos várias condições,
substituindo, portanto, o uso excessivo da estrutura If... Then... ElseIf.
INSTRUÇÃO WITH
A estrutura ou instrução With permite abreviar referências a objetos. Ela só faz sentido e é
extremamente recomendada quando pretendemos utilizar bastantes propriedades e/ou
métodos de um mesmo objeto.
29
Sua sintaxe é dada por:
Sub rotina()
With objeto
.propriedade/método (1)
. . .
.propriedade/método (n)
End With
End Sub
Em resumo, a instrução With serve para economizarmos linhas e darmos mais simplicidade ao
código.
INSTRUÇÃO SET
Quando utilizados o operador de atribuição (o sinal de igual) para tentar atribuir um intervalo
de células de uma planilha (à direita do sinal) a uma variável x (à esquerda do sinal), nós não
atribuímos de fato o intervalo à variável x. O que ocorre na realidade é que a variável x se torna
apenas um “reflexo” do conteúdo do intervalo e não o próprio intervalo. Isto é, não podemos
alterar o intervalo alterando x. Para atribuir corretamente um objeto a uma variável temos que
adicionar a instrução Set à linha de comando.
Sub rotina()
Set x = Entrada de Dados
End Sub
Por que fazemos isso? Primeiro pela simplificação do código. Segundo que com as variáveis e
objetos carregados na memória, o processamento de dados se forma mais eficiente. Terceiro e
último pela flexibilidade do código. Sem o uso da instrução Set, se quisermos modificar a
planilha ou o intervalo, teremos que trocar todas as referências durante todo a linha de código
do Módulo. Todavia, quando utilizamos a instrução Set, para realizar a mesma alteração basta
alterar a linha de comando que contém a instrução.
30
INSTRUÇÃO ON ERROR
Quando nosso código está suscetível ao erro, mas desejamos simplesmente ignorar este erro,
utilizamos esta instrução. Quando, por exemplo, utilizamos centenas de vezes a função “ProcV”
através de uma estrutura For... Next (que veremos a seguir), é possível que em uma destas
vezes a função não encontre o valor desejado e, neste caso, a Macro seria interrompida dado o
erro em um momento. É comum não queremos interromper este processo e, neste caso,
utilizamos da instrução On Error.
A instrução On Error é feita da seguinte forma.
Sub rotina()
On Error atribuição
End Sub
Existem duas famosas atribuições: Resume Next e Go To. Vejamos cada caso.
Sub rotina()
On Error Resume Next
End Sub
Esta ordem irá fazer com que, em caso de erro, o código pule a linha que deu erro e continue
para a próxima.
Sub rotina()
On Error Go To Handler1
Códigos
Exit Sub
Handler1: Códigos Alternativos
End Sub
A escolha do nome Handler1 foi puramente arbitrária, podendo-se escolher qualquer nome. O
código irá executar, no caso, os códigos que estão após o sinal de “dois pontos” que está após a
variável Handler1.
Precisamos utilizar a saída Exit Sub para evitar repetição desnecessária de códigos, que podem
levar a Macro e produzir resultados inesperados.
31
ESTRUTURA WHILE LOOP
Ela testa uma condição no início do loop e executa o loop enquanto a condição for verdadeira.
Segue a sintaxe.
Do While condição
Instruções
Loop
Em resumo, enquanto a condição for verdadeira vamos executar as instruções. No momento
em que a condição se torna falsa não vamos mais executar a instrução
ESTRUTURA UNTIL... LOOP
Ela testa uma condição no início do loop e executa o loop enquanto a condição for falsa. Segue
sua sintaxe.
Do Until condição
Instruções
Loop
Em resumo, até que a condição seja verdadeira vamos executar as intruções. No momento em
que a condiçãor tornar-se verdadeira não vamos mais executar a instrução.
ESTRUTURA DO... LOOP WHILE
Esta testa uma condição no final do loop e continua a execução enquanto a condição for
verdadeira.
Do
Instruções
Loop While condição
Em resumo, vamos executar as instruções e quando percebemos que a condição se tornou falsa
iremos parar de executa-las.
32
ESTRUTURA DO... LOOP UNTIL
Esta testa uma condição no final do loop e continua a execução enquanto a condição for falsa.
Do
Instruções
Loop Until condição
Em resumo, vamos executar as intruções e quando percebemos que a condição se tornou
verdadeira iremos parar de executa-las.
ESTRUTURA FOR... TO... NEXT
Esta estrutura executa as instruções do loop enquanto a variável contadora não atingir o valor
especificado. Sua sintaxe é dada abaixo.
For var = inicial To final [Step passo]
Instruções
Next var
A instrução Step é opcional. Ele seria o valor incrementado a cada loop, mas caso não seja
especificado o valor 1 será assumido.
ESTRUTURA FOR... EACH
Esta estrutura executa as instruções do loop para cada objeto de uma coleção. Sua sintaxe é
dada abaixo.
For Each var in grupo
Instruções
Next var
Em resumo, para cada valor que existir em um conjunto de valores eu executarei uma
condição.
33
ESTRUTURA WHILE... WEND
Esta estrutura realiza loop até que uma determinada condição seja verdadeira. A sua sintaxe é
dada por:
While Condição
Instruções a realizar em cada iteração
Wend
Em resumo, enquanto uma condição for verdadeira eu executarei uma instrução. Esta estrutura
é similar ao Do... Loop... While.
SAINDO DE LOOPS E PROCEDIMENTOS
As instruções Exit Sub e Exit Function podem ser usadas para abandonar uma rotina e uma
função.
A instrução Exit permite abandonar uma estrutura de controle, seja ela qual for. Apesar dessa
instrução ser conveniente, deve-se evitar o uso, visto que o excesso de sua utilização pode
dificultar a depuração do sistema.
Devemos ter cuidado ao trabalhar com loops. Para sair diretamente de um repetição Do, use a
instrução Exit Do, e para sair diretamente de um loop For, utilize a instrução Exit For.
EXERCÍCIOS
1. Crie um procedimento que receba dois valores numéricos e verifica se a soma deles é maior
ou menor que 100.
2. Crie um procedimento que receba duas notas de um aluno e diga se ele foi reprovado ou
aprovado.
3. Crie um procedimento que receba o valor do seu salário e seu cargo e retorne o seu bônus.
4. Crie um procedimento que receba o seu salário desejado e seus anos de escolaridade e
retorne o seu bônus esperado.
5. Crie uma Macro sem o uso da instrução With para alterar a formatação de um conjunto de
células de uma planilha. Em seguida, crie uma Macro com a mesma finalidade só que desta vez
utilizando a instrução With.
34
6. Crie uma Macro sem o uso da instrução Set para alterar a formatação de um conjunto de
células de uma planilha. Em seguida, crie uma Macro com a mesma finalidade só que desta vez
utilizando a instrução Set.
7. Crie uma Macro utilizando da estrutura Do... While... Loop para receber dois valores,
multiplica-los, mostrar o resultado e em seguida perguntar se deseja-se fazer outra
multiplicação. Esta repetição deve ser repetida até o usuário não desejar realizar nova
multiplicação.
8. Utilizando da estrutura Do... Until... Loop crie um procedimento para contar a quantidade de
cliques que serão dados no botão “Sim”.
9. Crie um procedimento para receber e converter um valor decimal para binário utilizando da
estrutura Do... Loop... While.
10. Crie uma Macro para receber um valor e retornar seu fatorial utilizando da estrutura Do...
Loop... Until.
11. Crie um procedimento para calcular a soma dos números pares de 0 até um número que
deve ser especificado pelo usuário. Utilize a estrutura For... To... Next. Dica: use a opção Step.
12. Crie uma Macro para transformar valores negativos em uma região na palavra “Negativo”.
Utilize a estrutura For... Each... Next.
13. Faça uma Macro que retorne o número de lançamentos necessários, dada um número de
sua escolha, para que você vença em uma loteria, onde o número sorteado é determinado
aleatoriamente no intervalo de 1 a 10. Utilize a estrutura While... Wend.
14. Crie uma Macro que receba um número e calcule a quantidade de números naturais entre 1
e o número informado.
15. Crie uma Macro que calcule o maior, o menor, a média e o percentual específico de um
intervalo de valores em uma região da planilha e salve estes cálculos e células da própria
planilha. Utilize a estrutura Do... While... Loop.
16. Crie uma Macro que receba os catetos de um triângulo e forneça a classificação do mesmo.
Esta Macro deve ser pública.
17. Crie uma Macro que determine o valor máximo e mínimo de um intervalo, desconsiderando
o zero. Esta Macro deve ser pública.
18. Crie uma Macro que funcione como uma loteria. Esta Macro deve ser pública.
35
19. Crie uma calculadora de potenciação. Esta Macro deve ser pública.
20. Crie uma calculadora de fatorial. Esta Macro deve ser pública.
21. Crie uma Macro que classifique um indivíduo em função da sua idade. A classificação é
definida da seguinte maneira: a) Idade menor de 3 anos, é um bebé; b) entre 3 e 12 anos é uma
criança; c) entre 13 e 17 anos é um adolescente. Entre 18 e 25 anos é um jovem; d) entre 26 e
65 anos é um adulto e; e) maior que 65 anos é um idoso. Utilize a estrutura If... Then... ElseIf.
Em seguida, refaça a Macro utilizando a estrutura Select Case.
22. Crie uma calculadora que retorne a taxa de juros anual, dado um empréstimo, uma
quantidade de pagamentos, o valor de pagamentos e se estes são feitos no final do mês.
23. Crie uma calculadora de Pagamentos Mensais que receba o valor do empréstimo, a taxa de
juros anual, a quantidade de pagamentos que se deseja fazer e se estes serão feitos no final do
mês. Retorne o valor do pagamento.
24. Crie uma calculadora de Valor Futuro que receba o quanto se pretende economizar por
mês, a taxa de juros anual, o tempo que se deseja poupar, se os pagamentos são realizados no
final do mês e a poupança atual. Retorne o valor futuro da poupança.
25. Crie uma calculadora mensal similar à do exercício 23 e apresente uma tabela desdobrando
o pagamento do Principal e dos Juros apenas para o primeiro ano de pagamentos.
36
ARRAYS
O QUE SÃO ARRAYS?
Arrays são conjuntos de elementos de natureza homogêneas, onde cada elemento pode ser
distinguido dos outros por um ou mais Índices.
Os Arrays podem ser unidimensionais ou multidimensionais. Um Array unidimensional é
geralmente tratado como vetor, enquanto que os multidimensionais são tratados como
matrizes. No Visual Basic uma matriz pode conter até 60 dimensões.
O vetor é uma sequência linear de elementos que são armazenados em ordem na memória. Ele
possui variáveis do mesmo tipo declaradas com o mesmo identificador e referenciadas por um
índice para determinar sua localização dentro da estrutura.
A matriz é um conjunto de sequências lineares. Por exemplo, uma matriz bidimensional possui
uma quantidade de colunas e uma quantidade de linhas. Matrizes podem ser fixou ou
dinâmicas. Uma matriz fixa é declarada preenchendo-se os parênteses, ao passo que uma
matriz dinâmica é declarada deixando-os vazios.
Para processar matrizes multidimensionais é comum utilizar as instruções For... Next
aninhadas.
VETORES
Um vetor pode ser ilustrado da seguinte forma:
Valores Dom Seg Ter Qua Qui Sex Sáb
Índices 1 2 3 4 5 6 7
Um vetor pode ser declarado de uma das duas formas abaixo.
Dim nome(indice) As Tipo
Dim nome(indice_a To indice_b) As Tipo
Na primeira declaração o vetor possui apenas um elemento (indice), enquanto que na segunda
ele possui uma sequência que vai de indice_a até indice_b.
A inicialização de um vetor é dada da seguinte forma:
37
nome(indice_1) = valor_i : nome(indice_2) = valor_2 : nome(indice_3) =
valor_3 . . .
Para atribuir um valor para um elemento de um vetor devemos atribuir este valor pelo número
índice.
nome(indice_i) = valor_i
Por fim para trazermos um elemento de um vetor escrito em uma mensagem devemos usar o
comando:
MsgBox nome(indice_i)
O Índice inicial da indexação de um vetor depende da definição da instrução Option Base, que
fica na seção Declarations do módulo. Se o comando for especificado como:
Option Base I
Então todos os índices vão iniciar em 1. Caso não seja declarado, o início é feito em zero.
INDEXAÇÃO
Perante uma coleção de objetos é necessário identificar cada um dos diferentes itens que a
compõem para que a eles seja possível se manifestar. Por analogia poder-se-á mencionar o
exemplo do Array, este é uma variável plural, dado que é composto por um conjunto de
variáveis.
Quando se pretende manifestar a uma posição do Array utiliza-se o nome do Array e o índice da
posição requerida. Assim, a indexação de coleções pode ser realizada com base em número ou
em nomes.
A indexação com base em números prende-se com a ordem pela qual o objeto está inserido na
coleção (começa sempre em 1). Por exemplo:
WorkSheets(3).Name = "Terceiro"
A indexação com base no nome seleciona um objeto em uma coleção pelo nome que está
associado ao objeto. Por exemplo:
WorkSheet("Sheet3").Name = "Terceiro"
A vantagem na utilização da indexação por nome é que não é necessário saber a ordem pela
qual foi inserido na coleção, e a desvantagem é a alteração do nome da planilha (sheet), que
provocará erros. Em suma, não pode-se alterar o nome da planilha. Por exemplo:
38
WorkSheets("Sheet3").Name = "Terceiro"; WorkSheets("Sheet3").Visible = False
Neste caso o objeto não é reconhecido.
O objeto range é uma exceção, pois é referido da mesma forma para ser utilizado tanto como
um objeto singular quanto como uma coleção de objetos. Vejamos os tipos de tratamentos.
Para tratar uma Range como um objeto singular, temos:
Range ("A1").Value = 1
Isso foi equivalente a colocar na primeira célula da Sheet o valor 1. Agora tratemos o Range
como uma coleção de objetos:
Range("A1:F20").Name = "Conjunto"
Range("Conjunto").Value = 1
Na primeira instrução atribuímos ao Range "A1:F20" o nome "Conjunto", e na última instrução
se utiliza essa designação para referenciar o respectivo conjunto de células e atribuir-lhe o valor
escolhido, no caso o valor 1.
Trabalhar com vetores não chega a ser algo normal, todavia, ainda é mais comum do que
trabalhar com matrizes, que são nada menos que vetores multidimensionais.
MATRIZ FIXA
Trabalhemos aqui apenas com Matrizes Bidimensionais. Suponhamos que queiramos criar uma
matriz desta dimensão com i linhas e j colunas. Vamos utilizar a seguinte declaração. Vamos
supor que a opção Option Explicit I está ativada, isto é, os índices começam em 1.
Dim nome(1 To i, 1 To j) As Tipo
Vamos obter o mesmo resultado ao declararmos esta matriz da seguinte forma:
Dim nome(i, j) As Tipo
Caso a opção Option Explicit I não esteja ativada, a primeira matriz vai iniciar em um enquanto
que a segunda vai iniciar em zero.
Perceba que podemos alterar o Option Explicit para escolher um número inicial de acordo com
a situação o qual estamos trabalhando.
39
MATRIZ DINÂMICA
Quando trabalhamos com matrizes fixas nós colocamos uma fronteira dimensional com i linhas
e j colunas. Ao trabalhar com matriz dinâmicas não vamos definir esses valores. A declaração é
dada da seguinte forma:
Dim nome() As Tipo
O número de elementos é dado pela Instrução ReDim, que fará a alocação de uma determinada
quantidade de elementos.
JANELA DE VERIFICAÇÃO IMEDIATA
Quando executamos uma Macro obtemos apenas o resultado final do trabalho e não os
resultados parciais. Contudo, muitas vezes desejamos saber o decorrer do código, isto é, se o
código está gerando os resultados parciais esperados. Para isto utilizamos a Janela de
Verificação Imediata e o comando Debug.Print.
Para habilitar a Janela de Verificação Imediata façamos o seguinte. Podemos no Editor do Visual
Basic abri-la através do menu de Visualização ou utilizando o atalho Ctrl + G.
Esta janela irá apresentar todo o valor que se encontrar depois da comando Debug,Print. Com
isto, saberemos o valor do objeto no caso de não criarmos nenhuma variável para expor este
valor, como por exemplo, apresentar o valor em uma MsgBox.
Veja o exemplo abaixo:
Sub rotina()
x = 2
Debug.Print x
End Sub
Neste caso irá aparecer na janela de verificação imediata o número 2, pois este fora atribuído à
variável x que por sua vez se encontra sendo utilizada pelo comando Debug,Print. É muito
comum utilizar deste instrumental quando trabalhamos com a estrutura For... Next e com
Arrays.
40
EXECÍCIOS
1. Crie um Array com tamanho 5 em que cada elemento receba um valor aleatório.
2. Crie um Array com tamanho 10 em que cada elemento seja exatamente o número de sua
posição elevada ao quadrado. Apresente o último elemento em uma MsgBox.
3. Crie um Array com tamanho 15 em que cada elemento seja exatamente o número de sua
posição elevada ao quadrado. Apresente o último elemento em uma MsgBox.
4. Crie uma calculadora que receba o valor de 10 notas via InputBox e retorne o valor da média
via MsgBox.
5. Utilizando da Janela de Verificação Imediata do Editor do Visual Basic, acessada pelo atalho
de teclado Ctrl + G ou pelo menu “Visualizar”, avaliemos internamente as contas feitas pelo
VBA. Utilize do comando Debug.Print para ver os valores que um número inteiro e um vetor
assumem. O número inteiro deve receber qualquer valor de sua escolha enquanto que o vetor
deve ter tamanho 4 e receber valores aleatórios.
6. Crie uma matriz com 3 linhas e 5 colunas e utilizando da Janela de Verificação Imediata e o
comando Debug.Print analise os valores nesta janela. A Macro deve ser pública.
7. Crie uma matriz dinâmica com uma única coluna, redimensione o valor para 5 e, em seguida,
redimensione para 10 apagando seus elementos e, por fim, redimensione para 15 sem apagar
seus elementos. A Macro deve ser pública.
8. Crie um vetor que receba os dados através de uma InputBox e em seguida apresente os
dados na Janela de Verificação Imediata. A Macro deve ser pública.
9. Crie uma Macro que receba notas de cinco alunos para duas provas, calcule a média de cada
aluno e salve-as na planilha. Utilize Array. A Macro deve ser pública.
10. Crie uma Macro que receba o nome e a altura de um indivíduo. A quantidade de indivíduos
pode ser ilimitada e deve-se inserir o número zero para terminar a entrada destes dados. Salve
os dados em um Array e transfira para a planilha apenas os nomes e alturas dos indivíduos cuja
altura é acima da média.
11. Crie uma tabela na planilha com duas colunas. Na primeira um código numérico e na
segunda um nome. Crie uma Macro que vai procurar nesta tabela pelo código e retornar em
um MsgBox o nome.
41
12. Crie uma matriz na planilha e uma Macro que some todos os valores nesta matriz e retorne
o resultado em uma MsgBox.
13. Desenvolva uma Macro que irá criar uma matriz diagonal com 6 linhas e 6 colunas em
alguma região da planilha.
14. Crie uma Macro que funcione como um Quis. Ela irá informar a capital de três países e
pedirá o respectivo país. No final ela irá retornar o resultado dos acertos.
15. Desenvolva uma Macro que irá receber nome de cinco países via InputBox e em seguida
apresentar cada um destes via MsgBox.
42
USERFORM
QUANDO USAR USERFORM
Certas vezes as funções MsgBox e InputBox não são suficientes e é necessário, portanto,
utilizar um UserForm, isto é, um formulário feito segundo as especificações do usuário. Com
esta opção temos acessos a objetos como botões, caixas de texto, caixas de combinação, entre
outros. Estes objetos são conhecidos como objetos de controle.
Utilizamos formulários principalmente para efetuar registros de entradas, caixas de cadastros,
etc.
INTRODUÇÃO AO USERFORM
Quando abrimos o editor do Visual Basic, abrimos também a janela do Projeto, sobre a alcunha
de VBAProject. Este projeto contém elementos, dentre outros temos como exemplo módulos,
classes e formulários.
A Janela Propriedades é útil para alterar as características e propriedades dos objetos de um
projeto.
No estudo de Userform vamos utilizar arquivos de projetos.
CRIANDO UMA USERFORM
Vejamos como criar um formulário para usuário. Com o editor do Visual Basic aberto, clique no
menu Inserir e escolha UserForm.
Vai surgir na tela um formulário cujo tamanho pode ser alterado utilizando-se o mouse e uma
Caixa de Ferramentas que contém alguns objetos de controle que podem ser inseridos no
formulário.
Caso a Caixa de Ferramentas não apareça de modo automático, clique no menu Exibir e escolha
Caixa de Ferramentas.
Se não for fixada, a caixa de ferramentas só ficará visível quando estamos com o formulário
selecionado.
43
No gráfico abaixo temos o exemplo do Editor de Visual Basic aberto, com uma UserForm e a
Caixa de Ferramentas.
PROPRIEDADES
O próximo passo é exibir a janela Propriedades, que será sempre utilizada na formação de um
formulário de usuário.
Caso ela não apareça automaticamente, clique no menu Exibir e escolha Janela ‘Propriedades’
ou utilize o botão de atalho F4.
Nós podemos fixar esta janela no editor do Visual Basic. Para isso, clique e em seguida segure
na barra de título desta janela e arraste-a para um dos cantos do editor.
44
No gráfico abaixo temos o exemplo do Editor de Visual Basic aberto, com uma UserForm, a
Caixa de Ferramentas e a Caixa de Propriedades.
INSERINDO OBJETOS
Para alterar o título do formulário selecione-o e em seguida clique duas vezes na caixa ao lado
da propriedade Caption que está na janela de propriedades. Escolha o título de sua preferência
e clique em Enter para finalizar.
Para inserir um rótulo ou um texto utilize a ferramenta Rótulo. Para alterar o texto você pode
clicar uma vez sobre o rótulo quando ele já estiver selecionado ou alterar a propriedade
Caption.
Para inserir uma Caixa de Texto escolha esta opção na caixa de ferramentas e clique no
formulário na posição desejada para colocar o texto. Para alterar o nome do objeto altere a
propriedade Name da janela de propriedades e digite o texto de sua escolha. Caso queira
colocar um texto pré-definido dentro da caixa de texto altere a propriedade Text.
45
Para redimensionar o rótulo coloque o mouse sobre um dos oito quadrados que ficam no
perímetro da caixa e clique duas vezes. Este procedimento de redimensionamento é aplicável
para qualquer objeto do UserForm.
Para fazer formatações similares tanto para rótulos quanto para qualquer outro objeto
podemos proceder da seguinte forma. Primeiro deve-se selecionar todos os objetos que se
deseja formatar. Isto feito, clique no menu Formatar e escolha uma das opções. Pode-se alinhar
os objetos conforme o desejo do usuário, assim como pode-se alterar o tamanho para que o
este seja homogêneo. Enfim, há diversas opções de formatação muito interessantes.
As ações são executadas através de botões de comando. Para inserir um botão escolha a
ferramenta correspondente na caixa de ferramentas. Para alterar as propriedades do botão
procede-se da mesma forma já estudada.
Para abrir o editor onde os códigos serão incluídos basta clicar duas vezes sobre um botão
escolhido ou seleciona-lo, clicar no menu Exibir e escolher a opção Código.
Para retornar ao formulário, clique duas vezes com mouse em UserForm1 que se encontra no
painel à esquerda ou selecione o menu Exibir e escolha a opção objeto.
TABULAÇÃO
Uma questão importantíssima que devemos levar em conta é a Tabulação. Quando utilizamos o
teclado apertamos a tecla Tab para passar de um item para o outro, e é importante que os
itens estejam tabulados em ordem, isto é, de cima para baixo e da esquerda para a direita.
Para verificar a ordem clique no menu Exibir e em seguida na opção Ordem de Tabulação.
Surgirá uma janela com uma lista. O primeiro elemento da lista é aquele que já estará
selecionado quando abrirmos o formulário. Cada clique da tecla Tab levará para o elemento
seguinte.
O desenvolvedor do formulário deve observar a lista e garantir que a ordem seja lógica.
EXERCÍCIOS
1. Crie um arquivo Excel que contenha um botão que dê acesso a uma UserForm que converta
valores Binários para Decimais.
2. Crie um arquivo Excel que contenha um botão que dê acesso a uma UserForm que converta
valores Decimais para Binários para Hexadecimais.
46
3. Crie um arquivo Excel no qual contenha uma tabela com uma coluna para o Número de uma
Peça, outra com a Descrição da Peça e uma terceira com a Quantidade. Crie um botão na
planilha que irá abrir uma UserForm que irá inserir novos valores nesta tabela.
4. Crie um arquivo Excel no qual, na primeira linha da planilha esteja o mês e ano de exercício.
Abaixo desta linha devem existir três colunas formando uma tabela, a primeira com o Código de
um funcionário, a segunda com o Sexo do mesmo e uma terceira com o Salário. Crie uma
UserForm que adicione novos funcionários à tabela e, em seguida, assim que se for clicado em
“Fim” retorne a soma de salários de homens, mulheres e total. Esta UserForm deve ser
acessado através da planilha por um objeto.
5. Crie um arquivo Excel que contenha uma tabela com data e valores de três índices. Crie uma
Userform que será acessada diretamente da planilha por um objeto e que possibilite o cadastro
de novos índices e também a obtenção da média de cada índice.
47
VBA APLICADO
METODOLOGIA
Nos capítulos acima introduzimos o leitor aos fundamentos básicos do VBA. Com isto espera-se
que o mesmo seja capaz de pensar em solução para problemas de gestão de dados visando
realizar rotinas de maneiras mais produtivas e eficientes.
Isto posto, neste capítulo iremos apresentar “problemas” a serem resolvidos utilizando VBA e
uma proposta de solução. No VBA, assim como na Matemática, não há apenas um modo de
resolver problemas. Existem diversas soluções, umas mais simples, outras mais performáticas,
contudo, ambas funcionais.
Apresentaremos alguns problemas envolvendo Banco de Dados, Economia, Finanças e
Estatística. As planilhas acompanham o material do curso.
FORMAÇÃO DE BANCO DE DADOS
É comum recebermos planilhas de outros fornecedores e querermos utilizar destas
informações para gerar um relatório diário. Primeiramente iremos salvar estas planilhas que
recebemos em uma pasta padronizada. Por exemplo, em uma pasta com o dia do relatório que
está dentro de uma pasta de fornecedores.
A nossa planilha deve, portanto, abrir esta planilha do fornecedor e procurar por determinados
valores para atualizar um Banco de Dados. As informações mais relevantes sobre a criação
deste projeto devem ser analisadas na própria planilha que acompanha o material do curso.
Perceba que nesta planilha há um endereço que deve ser alterado para representar a pasta
com os arquivos do fornecedor hipotético.
MANIPULAÇÃO DE BANCO DE DADOS
Assim como formação de banco de dados, usualmente também devemos manipular os dados,
seja via criação de novos valores, seja exclusão de valores dispensáveis. Suponha que você
possua um banco de dados com informações de debêntures e títulos públicos.
48
Este projeto consiste em:
Desenvolver um código VBA que obtenha dados de NTN-B e debêntures indexadas em
IPCA diretamente da ANBIMA (Associação Brasileira das Entidades dos Mercados
Financeiro e de Capitais) e forme um banco de dados.
Manipule o banco de dados de modo a calcular o spread médio pago pelas debêntures
sobre a NTN-B referente.
AUTOMATIZAÇÃO DE RELATÓRIOS
Imagine que você queira pegar informações diretamente do site da ANBIMA (Associação
Brasileira das Entidades dos Mercados Financeiro e de Capitais). Neste caso precisamos de uma
Macro que busca valores diretamente no site da ANBIMA. Para termos maior controle sobre a
informação utilizada a Macro, iremos salvar estes valores na própria planilha.
Em seguida iremos copiar determinadas regiões desta planilha e colar na última linha de um
banco de dados. Em seguida, atualizemos colunas com fórmulas que utilizam destes novos
dados. Por último atualizamos uma tabela que irá ser o banco de dados de dois gráficos
diferentes.
OBTENÇÃO DE ÍNDICES ECONÔMICOS
O Banco Central do Brasil divulga em seu acervo eletrônico um conjunto amplo de indicadores
econômicos consolidados. Muitas vezes o analista avalia diferentes indicadores para poder
modelar situação de um mercado específico ou a conjuntura econômica de forma ampla.
O objetivo deste projeto é criar uma planilha em que o usuário escolhe o indicador e o VBA
entra no site do Banco Central e apresenta os resultados mais recentes na própria planilha.
Perceba que esta planilha não precisa salvar os resultados, apenas apresenta-los.
O sitio eletrônico do Banco Central referente a este projeto é encontrado em:
http://www.bcb.gov.br/pec/Indeco/Port/indeco.asp.
49
VBA APLICADO A FINANÇAS
Na realização da otimização de carteiras através da abordagem de Henry Markowitz precisamos
utilizar de um instrumental matemático de maximização (ou minimização) do MS Excel
conhecido como Solver. Esta ferramenta também pode ser utilizada através do VBA, tornando-
se, portanto, passível de ser automatizada.
Há diversas propriedades do uso do Solver no VBA que podem facilmente ser acessadas através
do sitio eletrônico do Microsoft Office, contudo, apresentemos duas das principais
propriedades: SolverOk e SolverAdd.
Apresentemos estas propriedades são apresentadas abaixo.
SolverOk SetCell:=DEST, MaxMinVal:=MET, ValueOf:=VAL, ByChange:=REG
SolverAdd CellRef=REST, Relation:=SIN, FormulaText:=IGUAL
SolverSolve
SolverSolve UserFinish:=True
Onde:
DEST é a célula de destino;
MET é o método de otimização;
VAL é o valor da igualdade;
REG é a região a ser alterada;
REST é a célula (ou células) de restrição;
SIN é o sinal da restrição;
IGUAL é o lado direito da igualdade da equação de restrição;
Vejamos um exemplo:
No exemplo acima a célula a ser alterada é a M4, que será maximizada, alterando a região
D3:D7. Adicionamos como restrição que as células da região D3:D7 sejam iguais ou maiores que
as da região J3:J7. E adicionamos uma última restrição o qual a célula D8 seja igual a J8. Perceba
que poderíamos utilizar um número no lado direito da restrição.
50
Agora estudemos as propriedades separadamente. Comecemos por SolverOk.
MaxMinVal
Valor Especificação
1 Máximizar
2 Minimizar
3 Coincidir com um valor específico
Estudemos então a propriedade SolverAdd.
CellRef
Valor Sinal
1 <= (Menor ou igual a)
2 = (Igual a)
3 >= (Maior ou igual a)
4 As células referenciadas por CellRef deverão ter valores finais inteiros.
5 As células referenciadas por CellRef deverão ter valores finais 0 (zero) ou 1.
6 As células referenciadas por CellRef deverão ter todos os valores diferentes e inteiros.
Existem outras propriedades, todavia, com estas já podemos maximizar uma carteira.
O problema então proposto é a partir de cotações de um conjunto de ativos desenvolvermos
um conjunto de carteiras ótimas.
A solução proposta é a seguinte:
1. A partir das cotações derivamos as séries de rentabilidades e volatilidades dos valores.
2. Criamos matrizes e Correlação e Covariância.
3. Determinamos um valor esperado para a rentabilidade de cada ativo.
4. Determinamos a rentabilidade esperada da carteira para uma dada alocação de ativos e
também a volatilidade esperada da carteira dada a covariância dos ativos.
5. Fazemos três otimizações sobre esta carteira:
a. Maximização do Retorno Esperado
b. Minimização da Volatilidade
c. Maximização do Sharpe
6. Em seguida montamos a Fronteira Eficiente.
Seguindo os passos acima descritos podemos concluir o problema proposto de maneira
extremamente simplória.
51
SISTEMA DE ANÁLISE ESTATÍSTICA
O objetivo desta última tarefa é criar uma planilha que obtenha on-line o histórico completo de
ações selecionadas e então realize um conjunto de cálculos estatísticos dentro do próprio
código do VBA e então apresente-os em uma aba da planilha.
Como exemplo de ações pode-se utilizar Petrobras, Vale, Apple, etc. Um bom site para
obtenção de informações é o Yahoo Finance. As métricas a serem analisadas são:
Retorno Esperado Anualizado
Parameterized Value at Risk
Parameterized Expected Shortfall
Sharpe Ratio
Maximum DrawDown
EXERCÍCIOS
1. Crie uma planilha com VBA que funcione como um auxiliar financeiro. Este deve calcular
valor futuro, TIR, pagamentos e juros.
2. Elabore uma macro que desenvolva gráficos utilizando VBA.
3. Desenvolva uma macro que delete gráficos com VBA.
4. Construa uma macro que execute outras macros.
5. Faça uma macro que abra uma planilha com nome "Gerar_Imagem.xlsm" que possua uma
macro com mesmo nome que salve uma imagem e então execute-a.
6. Desenvolva uma macro que mostre a fórmula de uma célula.
7. Construa uma macro que oculte ou mostre um gráfico de uma planilha.
8. Crie uma macro que oculte ou mostre uma folha de uma planilha.
9. Faça uma macro que apresente uma caixa de diálogo onde o usuário escolha uma pasta e
então o endereço da pasta seja gravado em uma célula da planilha.
10. Crie uma pasta que substitua valores de células.
11. Elabore uma função para validar o valor de um CPF.
52
12. Construa uma macro que oculte e/ou delete linhas vazias em uma dada região.
13. Crie uma macro que funcione como cadastro de banco de dados e formate a tabela sempre
que um novo dado é adicionado.
14. Desenvolva uma macro que receba o endereço de um arquivo de dados (CSV) e que importe
estes dados salvando-os em outra aba da planilha.
15. Elabore uma macro que calcule média, desvio-padrão, valor máximo e mínimo de uma
coluna.
16. Faça uma macro que faça um gráfico de dispersão com linha dos valores em uma coluna.
17. Construa uma macro que pesquisa um determinado valor e destaque de amarelo a célula
que possua este valor.
18. Desenvolva uma macro que pesquise os valores de uma coluna entre 500 e 1000 e cole-os
em uma coluna ao lado.
19. Crie uma macro que gere um arquivo PDF de uma determinada região de uma planilha.
20. Faça uma planilha que realize as tarefas descritas entre do exercício 13 ao 19, ou seja, que
faça banco de dados, formate-os, gere estatísticas e gráficos e imprima um arquivo PDF.
53
BIBLIOGRAFIA
Abaixo apresentamos uma bibliografia indicativa utilizada como base para a realização desta
apostila. Claro que o leitor não deve prender-se apenas às fontes listadas abaixo. Existem
outros autores com ótimos trabalhos sobre o tema, que possui vasta bibliografia.
Craig W. Holden: Excel modeling and estimation in the fundamentals of investments,
2011.
Sanne Wøhlk: VBA Programming in Business Economics, 2010.
Mary Jackson & Mike Staunton: Advanced modeling in finance using Excel and VBA,
2001.
William Preinitz: A Fast Track To Structured Finance Modeling, Monitoring and
Valuation, 2009.
54
CONSIDERAÇÕES FINAIS
Ao final desta apostila o autor espera ter contribuído para a disseminação da programação em
VBA. Vivemos em um mundo cada vez mais moderno e informatizado. Entender alguma
programação (nem que minimamente) já é não apenas um diferencial no Mercado de Trabalho
como também um aprendizado de vida.
Resolver problemas de programação é como resolver uma equação matemática, treinamos
nosso cérebro a pensar em soluções práticas e eficientes. E assim como aprender uma língua
estrangeira, aprendemos a nos comunicas em uma nova forma, a qual apenas nossos pares
serão capazes de entender.
Enfim, de todas as benéficas do VBA, a maior é, sem dúvida, sua facilidade de automatizar
rotinas e sua integração com um dos principais softwares de trabalho do mundo: Microsoft
Office. Não se engane pensando que o VBA é capaz de processar grandes quantidade de dados
ou realizar contas complicadas (pois ele não é), todavia, no dia-a-dia não há ferramenta melhor
para tornar o ambiente de trabalho mais produtivo.
O leitor pode assumir como um teste final a tarefa de criar uma rotina utilizando VBA que irá
automatizar alguma tarefa que este precise realizar periodicamente. Utilize de seus
conhecimentos no decorrer desta apostila, assim como os exercícios resolvidos e os projetos
que acompanham o material do curso.
Agradeço pelo interesse nesta apostila e todas as críticas construtivas serão bem-vindas1.
Brendon A. Ramos
Graduando em Ciências Econômicas pela UFRJ
1 Contato: [email protected]
