AP Excel 2013 VBA+Alg

Algoritmos
Índice
ÍNDICE
APRESENTAÇÃO 3
PROGRAMANDO 7
VARIÁREIS9
OPERADORES 13
FUNÇÕES 20
ESTRUTURAS DE CONTROLE 22
ESTRUTURAS DE REPETIÇÃO 1
Treinamento em Algoritmo Copyright – NSI Training Tecnologia 2

Capítulo 1: Apresentação
C A P Í T U L O 1
A p r e s e n t a ç ã o
Tópicos deste capítulo
 Introdução
 O que é um programa?
 Entrada e Saída de Dados
Objetivos
Ao final deste módulo, você estará apto a:
 Definir o que é um algoritmo;
 Definir o que é um programa;
 Criar algoritmos simples;

Algoritmos
Um algoritmo é uma seqüência de instruções definidas para serem executadas mecanicamente.

Todos os dias realizamos algoritmos e não percebemos. Basicamente todas as manhãs nós nos
levantamos da cama, tomamos o café da manhã, nos arrumamos e vamos ao trabalho. Entre cada
uma dessas ações descritas, realizamos várias outras ações. Nosso próprio corpo realiza algoritmos o
tempo inteiro realizando decisões. Se nos machucamos, sentimos dor. Se o ambiente externo tem
temperatura baixa, o corpo treme para tentar aumentar a temperatura novamente.
Todo algoritmo segue uma seqüência lógica. Geralmente um algoritmo é lido de cima pra baixo e da
esquerda pra direita. Cada linha de código é lida e, caso não haja nenhum erro, executada e logo
depois é lida a próxima linha e assim sucessivamente até terminarem as linhas do algoritmo.
Como exemplo de algoritmo, podemos pensar em um ser humano andando. Observe:
1. Levantar a perna direita

2. Inclinar o corpo para frente
3. Baixar a perna direita
4. Apoiar o pé direito no chão
5. Levantar a perna esquerda
6. Baixar a perna esquerda
7. Apoiar o pé esquerdo no chão
8. Levantar a perna direita...
Outro exemplo de algoritmo seria fazer um calculo simples como a soma ou multiplicação de dois
números como no exemplo abaixo:
1. Ler primeiro número

2. Ler segundo número
3. Somar os dois números lidos
4. Exibir o resultado
O que é um programa?
Um programa é um ou mais algoritmos escritos numa linguagem de programação. Existem diversas

linguagens de programação atualmente. Grosso modo, as linguagens mais fáceis são chamadas de
“linguagens de alto nível” e as mais difíceis são chamadas de “linguagens de baixo nível”. As
Linguagens de Baixo nível são assim chamadas por que você precisa trabalhar mandando comandos e
recebendo respostas direto para o hardware. As Linguagens de Alto nível são assim chamadas por

que elas “escondem” as tarefas difíceis como trabalhar direto com hardware, o que facilita o
desenvolvimento do código e aumenta a velocidade de programação.
Exercícios:
1 - Escreva um algoritmo para pentear o cabelo. Tente ser bem especifico e detalhado em cada
ação realizada.

Entrada e saída de dados
Muitas vezes não percebemos, mas para haver processamento, é necessário ter informações. Um
programa precisa que dados sejam inseridos nele para que eles sejam processados e retorne algum
resultado daquele processamento. Esses dados podem ser inseridos pelo usuário do programa e
algumas vezes o usuário não sabe que está inserindo dados. Digitar texto em um formulário
eletrônico ou o simples ato de copiar um arquivo para o seu computador é considerado entrada de
dados.
Exercício: Escreva alguns modos de entrada e saída de dados. Ao lado de cada um, diga se é entrada
ou saída.

Capítulo 2: Programando
C A P Í T U L O 2
P r o g r a m a n d o
 Programando
 O que é Necessário Para Escrever em Português Estruturado?
 A Estrutura de Um Algoritmo
Objetivos
 Escrever um algoritmo na estrutura de um algoritmo estruturado

Capítulo 2: Programando
Programando
A partir de agora, utilizaremos uma linguagem conhecida como Português Estruturado para fazer
nossos algoritmos.
O que é necessário para escrever em Português Estruturado?

Apenas um lápis e um papel serão necessários para escrever código em Português Estruturado. Você
também pode utilizar o programa VisualG que executa seu código em Português Estruturado. O
VisualG tem algumas funções que não serão utilizadas aqui. Para mais informações, visite a página do
VisualG http://www.apoioinformatica.inf.br/visualg/objetivos.htm
A Estrutura De Um Algoritmo
A estrutura dos nossos algoritmos será do seguinte modo:
Algoritmo <Aqui inserimos o nome do algoritmo>

var
<Aqui declaramos as variáveis>
inicio
<Aqui iniciaremos nosso programa>
fim algoritmo
Como você pode ver, temos uma área para a declaração do nome do algoritmo, uma para a
declaração das variáveis e uma para o código. Iremos começar a aprender como escrever nossos
algoritmos.

Capítulo 3: Variáveis
C A P Í T U L O 3
V a r i á r e i s
 Variáveis
 Tipo de Variáveis
 Lendo e Escrevendo Dados
 Vetores
Objetivos
 Definir uma variável
 Utilizar Variáveis

Variáveis
Variáveis são espaços em memória onde podemos alocar algum valor temporariamente. Como o
nome diz, o valor de uma variável pode ser alterado. Para escrever o nome de uma vaiável, é
necessário seguir algumas regras:
1 – Os nomes das variáveis não podem ser iguais às palavras reservadas da linguagem. Algumas
linguagens de programação tem algumas palavras reservadas como begin e end. Elas são utilizadas
internamente pela linguagem, então é melhor não utilizá-las. Cada linguagem tem as suas próprias
palavras reservadas. Leia a documentação da sua linguagem preferida antes de começar a
programar.
2 – O primeiro caractere do nome da sua variável deve ser uma letra ou um “_” (underline ou
sublinhado).
3 – Os nomes das variáveis não podem ter espaço em branco.
Tipos de Variáveis
O tipo de uma variável define qual tipo de valor poderá ser armazenado nela. Usaremos quatro tipos
de variáveis citadas abaixo.
Tipo Descrição
INTEIRO Utilizada para armazenar todos os números inteiros como 10, 30, -12, 325, etc...
REAL São os números reais. Abrange os números Inteiros e os números com

separador decimal como 20, -30, 12.75, -225.12
CARACTERE Utilizada para armazenar texto. É necessário utilizar aspas duplas para delimitar
o início e o fim de um texto.
LOGICO Utiliza apenas dois valores: Verdadeiro e Falso
As variáveis devem ser atribuídas sempre antes do inicio do programa, sempre depois da palavra
“var”. Cada variável precisa de um nome e o seu tipo. O modo correto de declarar uma variável é
mostrado abaixo.
Algoritmo “Variáveis”
var
numero: INTEIRO
inicio
fim algoritmo

Acabamos de inicializar uma variável, mas a mesma ainda não tem valor algum. A seguir, um
exemplo de uma variável recebendo um valor.
Algoritmo “variaveis”
var
numero: INTEIRO
inicio
numero <- 10
fim algoritmo
O código acima cria a variável “numero”, atribui o número 10 como valor para ela. Para atribuir
valores a uma variável, é necessário utilizar o sinal “<-”.
Lendo e Escrevendo Dados

Utilizaremos dois comandos para ler e escrever dados. O comando “leia” irá ler um dado para ser
escrito ou para atribuir a uma variável. O comando “escreva” irá escrever texto, números ou valores
de variáveis.
algoritmo "variaveis"
var
numero: INTEIRO
inicio
escreva("Escreva um número: ")
leia(numero)
escreva("O número que você digitou é:")
escreva(numero)
fimalgoritmo
Vetores
Traduzir vetor de um modo fácil seria dizer que ele é uma “variável que tem o valor de várias
variáveis”. Dentro de um vetor é possível colocar vários valores diferentes.

algoritmo "vetores"
var
numeros: VETOR[1..5] DE INTEIRO
inicio
numeros[1] <- 10
numeros[2] <- 20
numeros[3] <- 30
numeros[4] <- 40
numeros[5] <- 50
escreva(numeros[3])
fimalgoritmo
Para utilizar um vetor é necessário que antes de atribuir valores aos seus índices (Um índice é um
espaço dentro do vetor onde podemos armazenar dados).

Capítulo 4: Macros
C A P Í T U L O 4
O p e r a d o r e s
 Operadores
 Operador de Atribuição
 Operadores Aritméticos
 Operadores Relacionais
 Operadores Lógicos
Objetivos


Capítulo 4: Macros
Operadores
Operador de Atribuição
Como já vimos anteriormente, para atribuir um valor a uma variável, é utilizado o sinal de “<-”. Você
pode atribuir valores numéricos, Strings e booleanos às suas variáveis.
Operadores Aritméticos
Operadores Aritméticos servem para calcular números e valores em variáveis. Em Portugues

Estruturado nós temos os seguintes Operadores Aritméticos:
Operador Sinal
Adição +
Subtração -
Multiplicação *
Divisão /
Divisão Inteira \
Exponenciação ^
Resto da Divisão %
Utilizaremos o sinal de % quando precisarmos ter o resto de uma divisão, diferente de / que retorna
o resultado de um número dividido pelo outro.

Capítulo 4: Macros
Exemplo:
algoritmo "Operadores Aritméticos"
var
numero1, numero2: INTEIRO
numero3: REAL
inicio
escreva("Digite o primeiro valor: ")
leia(numero1)
escreva("Digite o segundo valor: ")
leia(numero2)
numero3 <- numero1 + numero2
escreval(numero3)
numero3 <- numero1 - numero2
escreval(numero3)
numero3 <- numero1 * numero2
escreval(numero3)
numero3 <- numero1 / numero2
escreval(numero3)
numero3 <- numero1 \ numero2
escreval(numero3)
numero3 <- numero1 ^ numero2
escreval(numero3)
numero3 <- numero1 % numero2
escreval(numero3)
fimalgoritmo

Capítulo 4: Macros
Operadores Relacionais
Os operadores relacionais são utilizados quando você precisa descobrir a relação entre um valor e
outro. Os Operadores Relacionais são:
Operador Sinal
Maior que... >
Menor que... <
Maior ou igual que... >=
Menor ou igual que... <=
Igual =
Diferente <>
Os Operadores Relacionais retornam sempre um valor lógico, ou seja, verdadeiro ou falso. Podemos
testar os operadores do seguinte modo:

Capítulo 4: Macros
algoritmo "Operadores Relacionais"

var
retorno: LOGICO
inicio
retorno <- 10 > 20
escreval(retorno) //Falso
retorno <- 10 < 20

escreval(retorno) //Verdadeiro
retorno <- 10 >= 20

retorno <- 10 <= 20

retorno <- 10 = 20
retorno <- 10 <> 20

fimalgoritmo

Capítulo 4: Macros
Operadores Lógicos
Os operadores lógicos servem para se utilizar várias operações relacionais em uma mesma linha.
Operador Significado
E Retorna Verdadeiro se todos os testes forem

verdadeiros
Ou Retorna Verdadeiro se um dos testes for

verdadeiro
Nao Retorna o inverso de um lógico. Se for

Verdadeiro, retorna Falso. Se for falso,
retorna Verdadeiro.
Os Operadores Lógicos “E” e “Ou” seguem a lógica da tabela verdade, descrita abaixo:
A B AEB
Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Falso
Falso Verdadeiro Falso
Falso Falso Falso
A B A Ou B
Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Verdadeiro
Falso Verdadeiro Verdadeiro
Falso Falso Falso

Capítulo 4: Macros
A Não A
 Verdadeiro  Falso
 Falso  Verdadeiro

Capítulo 5: Funções
C A P Í T U L O 5
F u n ç õ e s
 Funções
Objetivos
 Definir funções
 Utilizar funções..

Capítulo 5: Funções
Funções
Algumas vezes será necessário que você execute uma mesma rotina várias vezes. Para que você não
precise reescrever o mesmo código várias vezes, existem as funções. Uma função permite que você
passe parâmetros para ela. A função irá realizar o bloco de código definido nela com ou sem os
parâmetros passados, mas tome cuidado. Caso você defina uma função que receba parâmetros, será
necessário passar os parâmetros para a mesma.
Exemplo:
algoritmo "Funcoes"
var
num1,num2,resultado:REAL
funcao somar(valor1,valor2:REAL):REAL
var
total:REAL
inicio
total <- valor1 + valor2
retorne total
fim funcao
inicio
escreva("Digite o primeiro número: ")
leia(num1)
escreva("Digite o segundo número: ")
leia(num2)
resultado <- somar(num1,num2)
escreva("A soma das variáveis é ", resultado)
fim algoritmo
No exemplo anterior nós temos a função “somar” que recebe dois números. Ela soma esses dois
números e retorna o resultado da soma.
O comando “retorne” utilizado no final da função retorna a soma das duas variáveis que pode ser
utilizado do lado de fora da função como mostra o exemplo acima.

Capítulo 6: Estruturas de Controle
C A P Í T U L O 6
E s t r u t u r a s d e C o n t r o l e
 Estrutura de Controle
Objetivos
 Utilizar uma estrutura de controle para que seu algoritmo tome decisões

Capítulo 6: Estruturas de Controle
Estrutura de Controle
As estruturas de controles servem para, como o nome diz, controlar a execução do programa.
Imagine que no sistema de uma loja virtual apenas maiores de 18 anos de idade podem realizar
compras. Para isso é necessário checar se a idade do comprador é maior ou igual a 18 anos.
Utilizaremos a estrutura de controle SE que serve para executar determinado código caso uma
expressão retorne true.
Exemplo:
algoritmo "SE"
var
idade:INTEIRO
inicio
idade <- 20
SE idade >= 18 ENTAO
escreva("O usuário pode comprar")
FIM SE
fim algoritmo
Nesse exemplo será testado se a idade do usuário é igual ou maior que 18 anos. Se o teste retornar
Verdadeiro, será executado o código. Esse exemplo é bastante limitado levando em consideração
que nada acontecerá se o usuário tiver idade menor que 18 anos. Sempre que houver a necessidade
de que um bloco de código seja executado se a expressão retornar Falso, basta adicionar a o bloco
do SENAO após o código do SE.
algoritmo "SE"
var
idade:INTEIRO
inicio
idade <- 20
SE idade >= 18 ENTAO
escreva("O usuário pode comprar")
SENAO
escreva(“O usuário não pode comprar”)
FIM SE
fim algoritmo
Cada linguagem de programação tem suas estruturas de controle. Leia a documentação para a sua
linguagem preferida sobre suas estruturas de controle e utilize a melhor para cada caso.

C A P Í T U L O 7
E s t r u t u r a s d e R e p e t i ç ã o
 Estruturas de Repetição
 Enquanto... Faça
 Para... Faça
 Repita... Até
Objetivos
 Utilizar estruturas de repetição para executar o mesmo código várias vezes

Estruturas de Repetição
As estruturas de Repetição são utilizadas quando você precisa repetir um código várias vezes
enquanto uma determinada condição não for satisfeita. Vamos a elas.
Enquanto... Faca
O Enquanto... Faca irá executar um bloco de código até que sua condição seja satisfeita. Veja o
exemplo:
algoritmo "Enquanto"
var
num:INTEIRO
inicio
num <- 10
ENQUANTO num < 20 FACA
escreva("O número é menor que 20")
FIM ENQUANTO
fim algoritmo
Acima temos um problema. O valor de num nunca será igual ou maior que 20, então o
programa entrará no que chamamos de loop infinito. Ele entrará nesse bloco de código e
executará infinitamente, geralmente travando a o seu programa. Para que isso não aconteça, é
necessário que você faça com que a variável num receba um valor que não satisfaça a
condição do while. Um exemplo simples seria incrementar a variável a cada loop.
algoritmo "Enquanto"
var
num:INTEIRO
inicio
num <- 10
ENQUANTO num < 20 FACA
escreva("O número é menor que 20")
num <- num + 1
FIM ENQUANTO
fim algoritmo
Pronto. Agora o Enquanto executará o código um número limitado de vezes e sairá logo assim
que a condição não mais o satisfizer.

Para... Faca
O Para... Faca funciona do mesmo modo que o Enquanto... Faca, mas utilizando ele fica mais
fácil não esquecer declarar uma variável ou incrementá-la. O Para... Faca apresenta uma
sintaxe mais definida.
algoritmo "Para"
var
num:INTEIRO
inicio
num <- 0
PARA num DE 1 ATE 10 FACA
escreva("A variável agora vale: ")
escreval(num)
FIM PARA
fim algoritmo
Podemos ver que o Para... Faca recebe uma variável inteira para poder incrementar. Na parte
“DE 1 ATE 10”, o Para... Faca irá dar um valor de 1 até 10, sempre acrescentando 1 e para cada
vez que a variável receber esse valor, o código entre “PARA...” e “FIMPARA” será executado.

Repita... Ate
O Repita... Ate é parecido com o Enquanto... Faca, porém ao invés de ele fazer o teste antes da
execução do bloco, seu teste é feito apenas depois.
algoritmo "Para"
var
num:INTEIRO
inicio
num <- 10
REPITA
escreval("O valor de num é menor que 10")
num <- num + 1
ATE num > 10
fim algoritmo
A grande diferença entre o Enquanto... Faca e o Repita... Ate é que no Repita... Ate o código
será executado pelo menos uma vez, mesmo se a condição não for satisfeita. Faça o teste
como no código acima.

VBA com Excel

VBA com EXCEL
Índice
C A P Í T U L O 1 ...................................................................................................................1
Introdução ................................................................................................................................. 2
Macros....................................................................................................................................... 3
Gravando uma Macro ........................................................................................................... 3
Executando a Macro.............................................................................................................. 5
Atribuindo Macros a Botões ................................................................................................. 6
Editando uma Macro ............................................................................................................. 9
Excluindo uma Macro .......................................................................................................... 11
A Pasta de Trabalho Pessoal de Macros.............................................................................. 11
C A P Í T U L O 2 ................................................................................................................. 15
Explorando o Visual Basic Editor – VBE ................................................................................... 16
A Janela de Código .............................................................................................................. 16
O Project Explorer (VBAProject) .......................................................................................... 16
A Janela de Propriedades .................................................................................................... 17
O Pesquisador de Objetos ................................................................................................... 17
As Ferramentas de Depuração ............................................................................................ 17
Definindo Padrões das Janelas de Códigos e Módulos ....................................................... 18
C A P Í T U L O 3 ................................................................................................................. 20
Trabalhando com Módulos ..................................................................................................... 21
Módulos Padrão .................................................................................................................. 21
Módulos de Classe............................................................................................................... 21
Como Criar um Módulo ....................................................................................................... 22
Salvando Módulos ............................................................................................................... 23
Exportando Modulos ........................................................................................................... 23
Trabalhando com Procedimentos ........................................................................................... 24
Procedimento SUB .............................................................................................................. 25
Procedimento FUNCTION .................................................................................................... 26
C A P Í T U L O 4 ................................................................................................................. 29
Trabalhando com Variáveis ..................................................................................................... 30
Treinamento em MS Excel 2013 com VBA – NSI Training

Tipos de Dados ........................................................................................................................ 30
Variáveis .................................................................................................................................. 32
Declarando uma Variável .................................................................................................... 32
Constantes........................................................................................................................... 34
Trabalhando com Matrizes ................................................................................................. 35
Trabalhando com Operadores ................................................................................................ 36
Operadores Lógicos ............................................................................................................. 36
Operadores Aritméticos ...................................................................................................... 36
Operadores de Comparação ............................................................................................... 38
Operadores de Concatenação ............................................................................................. 38
C A P Í T U L O 5 ................................................................................................................. 40
Funções do VBA....................................................................................................................... 41
Funções de Manipulação de Strings.................................................................................... 41
Funções de Planilha ............................................................................................................. 46
Caixa de Mensagem (MsgBox) ............................................................................................ 47
Caixa de Entrada (InputBox) ................................................................................................ 48
Os Principais Objetos do Excel 2013 ....................................................................................... 50
O que são Objetos, Propriedades, Métodos e Eventos ...................................................... 50
A Hierarquia de Objetos no Excel 2013 ............................................................................... 51
O objeto Application ............................................................................................................... 52
Propriedades ....................................................................................................................... 52
Métodos .............................................................................................................................. 52
O objeto WorkBooks ............................................................................................................... 53
Propriedades ....................................................................................................................... 53
Métodos .............................................................................................................................. 53
O objeto WorkSheet................................................................................................................ 54
Propriedades ....................................................................................................................... 54
Métodos .............................................................................................................................. 54
O objeto Range........................................................................................................................ 55
Propriedades ....................................................................................................................... 55
Métodos .............................................................................................................................. 56
C A P Í T U L O 6 ................................................................................................................. 57
Trabalhando com Controles de Fluxo ..................................................................................... 58
If...Then...Else ...................................................................................................................... 58
Select Case...End Select ....................................................................................................... 58

Trabalhando com Loops para Repetir o Código ...................................................................... 59
Do...Loop ............................................................................................................................. 59
For…Next ............................................................................................................................. 60
For Each…Next..................................................................................................................... 60
With...End With ................................................................................................................... 61
C A P Í T U L O 7 ................................................................................................................. 62
Depuração de Erros ................................................................................................................. 63
Adicionando Inspeção de Variáveis..................................................................................... 63
Inspeção de Variáveis Rápida .............................................................................................. 63
Janela de Verificação Imediata............................................................................................ 64
Depurando o Código do seu Programa Passo a Passo ........................................................ 64
Tratamento de Erros ............................................................................................................... 65
O que é tratamento de erros .............................................................................................. 65
A Instrução “On Error” ........................................................................................................ 65
C A P Í T U L O 8 ................................................................................................................. 66
Trabalhando com Controles no Excel...................................................................................... 67
Controles da Caixa de Ferramentas .................................................................................... 68
C A P Í T U L O 9 ................................................................................................................. 70
Trabalhando com Formulários no VBA ................................................................................... 71
Criando Formulários ............................................................................................................ 71
Construindo o Código do Formulário .................................................................................. 73
Exercício 6 ............................................................................................................................... 75

CAPÍTULO 1
Introdução
 Introdução
 Macros
 Gravando Macros
 Executando a Macro
 Atribuindo Macros a botões
 Editando uma Macro
 Excluindo uma Macro
 A pasta de trabalho pessoal de Macros
Treinamento em MS Excel 2013 com VBA – Copyright © 2010 NSI Training 1

Introdução
Este curso tem o objetivo de ensinar ao usuário a manipular a linguagem de

programação Visual Basic for Applications – VBA, no ambiente do Microsoft Excel
2013.
O VBA é uma linguagem de programação que possibilita adicionar, a todos os

programas da linha Office, recursos personalizados, fazendo com que os programas
possam atender a situações específicas de sua rotina de trabalho.
Você poderá utilizar o VBA para criar novas funcionalidades ao Excel 2013,
como formulários personalizados, botões para automatizar tarefas, criar novas funções
para utilizá-las em sua planilha.
Esta apostila ensinará, passo a passo, como dominar todos os conceitos

fundamentais para você poder aumentar, e muito, a sua produtividade no trabalho,
conseguindo utilizar o Excel 2013 em toda a sua plenitude.
Para utilizar bem o VBA no Excel 2013, você não precisa ser um programador
experiente, mas deve conhecer as estruturas básicas de lógica de programação, como
operadores aritméticos, operadores de comparação, estruturas de desvio condicional
e controles de repetição de código. Também é necessário, para realmente poder
aproveitar toda a potencialidade da dobradinha “VBA + Excel 2013”, que você deve
domine os conhecimentos de nosso curso de Excel 2013 avançado. Quanto mais você
conhece os recursos do Excel, melhor e mais fácil de serem criados, serão os seus
procedimentos em VBA.
Em geral, para facilitar a criação de um procedimento em VBA, utilizamos o

gravador de macros para gravar os comandos desejados na solução do problema e, em
seguida, editamos o código-fonte gravado e o adaptamos, através do VBA, para
atender a um caso específico, inserindo, por exemplo, variáveis, caixas de diálogo, etc.
Por isto, vamos começar esta apostila pelo assunto Macro.

Macros
As macros são rotinas criadas para automatizar uma determinada sequência de

ações, reduzindo assim o tempo gasto para repetir estas ações cotidianamente. No
Excel 2013, as macros podem ser gravadas ou escritas por você. Mesmo quando
gravadas, elas são convertidas para a linguagem de programação Visual Basic for
Applications, que chamamos resumidamente de VBA.
Você também pode escrever o código de uma determinada macro diretamente,

usando o Editor do Visual Basic (VBE). Neste caso, torna-se necessário,
evidentemente, que você já esteja familiarizado com os comandos da linguagem.
Gravando uma Macro
No Excel 2013, podemos gravar uma Macro através da Guia Exibição, clicando no
botão Macros, que fica do lado direito da guia. Porem é bem mais fácil trabalhar com a
guia Desenvolvedor, a qual possui várias funcionalidades para facilitar nosso trabalho.
Para exibir a guia Desenvolvedor, execute os seguintes passos:
1. Dê um clique na Guia Arquivo.
2. A seguir, utilize o botão Opções.
3. Na lista de categorias existente na lateral esquerda da tela, dê um clique em

Personalizar faixa de Opções.

4. A seguir, habilite a opção Desenvolvedor , e clique em OK.
Com a guia desenvolvedor habilitada, siga os passos abaixo, para começar a gravar a
macro:
1. Na guia Desenvolvedor utilize o botão Gravar Macro.
2. Forneça um nome para a macro.
3. Forneça uma descrição, a qual servirá para você descrever, resumidamente, o

finalidade da macro. Isto irá facilitar, no futuro, a identificação da utilidade
desta macro, por qualquer usuário que esteja utilizando as macros que você
gravou.
4. Para executar a macro através de um atalho de teclado, você poderá utilizar o

campo Tecla de atalho, definindo a combinação de teclas que ativará a macro.
5. Após definir as descrições iniciais, clique em OK para iniciar a gravação.
OBSERVAÇÕES:
 Na caixa Nome da macro, dê um nome para a macro que você está criando.
São aceitos até 64 caracteres. Não é permitido espaços e não se aconselha o
uso de acentos (embora permitido). O nome deve começar por uma letra e não
pode ser igual ao de uma macro já existente no sistema.
 Na caixa Tecla de Atalho, Vale lembrar que, caso a combinação gerada seja um
dos atalhos default do Excel, a mesma passará a executar a macro, anulando o
atalho do Excel. Como uma segunda opção, pode-se digitar uma letra em
maiúscula. Assim, será gravado Ctrl +Shift + LETRA. Ou ainda, deixar a macro
sem uma tecla de atalho.
 Na caixa Armazenar Macro em, clique na seta à direita e escolha onde você
deseja armazenar a macro:
- Pasta de trabalho pessoal de macros: Use esta opção se você desejar que a
macro esteja disponível para qualquer arquivo do Excel, quando você logar com
seu usuário, no computador que foi utilizado para gravar a macro.

O código-fonte da macro é salvo no num arquivo denominado Pessoal.xlsb, que
é aberto automaticamente, de forma oculta, toda vez que você iniciar o Excel.
Esta pasta de trabalho: O código-fonte da macro é salvo dentro próprio arquivo onde
ela foi originada. Esta é a opção mais usual quando as ações da macro dependem da
planilha em questão ou não fazem sentido serem executadas em outra planilha
qualquer. Dessa forma, se você desejar que outra pessoa possa executar sua macro,
bastará copiar seu arquivo de planilha normalmente.
- Nova pasta de trabalho: Caso você prefira que o Excel crie um novo arquivo
vazio para salvar exclusivamente o código da macro, selecione esta opção.
Deste modo, este novo arquivo criado deverá ser transportado e aberto junto
com o arquivo da planilha desejada para que a macro funcione.
6. Agora, preste atenção, pois tudo o que você fizer a partir deste momento no
Excel estará sendo gravado na macro. Execute, no Excel, os comandos
desejados para salvar na macro.
7. Ao final, clique no botão Parar Gravação, ele estará localizado na guia

desenvolvedor, no mesmo local onde antes estava o botão Gravar Macro.
Executando a Macro
Existem várias formas de se executar uma macro, as quais descrevemos abaixo:
1. Podemos executar uma macro rapidamente pressionando as teclas de

atalho que definimos ao criar a macro;
2. Podemos executá-las através da Guia Desenvolvedor, a opção Macro.
Basta Selecionar a macro desejada e, em seguida, clique no botão Executar

3. Por fim, pode-se ainda atribuir a macro a um botão na planilha ou em
alguma Guia do Excel, conforme ensinamos a seguir.
Atribuindo Macros a Botões
Podemos criar macros no Excel e atribuir as mesmas a botões - posicionados no

interior da planilha ou nas barras de ferramentas do Excel. Para tal, execute os
seguintes passos.
Botões na Planilha
1. Na guia Desenvolvedor, clique no botão Inserir. Será exibida a barra logo

abaixo.
2. Selecione, na seção Controles de Formulário, a ferramenta botão e , dentro da

planilha, clique na posição em que você deseja criar o botão de comando. Será
desenhado um botão, no tamanho padrão, e imediatamente será exibida a
caixa de diálogo abaixo.
3. Selecione a macro que você deseja atribuir ao botão criado e, em seguida,

clique sobre o botão OK.
4. Edite o nome do botão clicando dentro do mesmo.

NOTA: A partir de agora, ao posicionar o ponteiro do mouse sobre o botão criado,
você irá reparar que o mesmo se transforma para o formato de uma mão e, ao clicar,
sua macro será executada automaticamente. Para reeditar o botão ou atribuir uma
outra macro, clique com o botão direito do mouse sobre o mesmo.
Botões na Barra de Ferramentas de Acesso Rápido
Quando uma macro é armazenada na Pasta de trabalho pessoal de macros,

convém criar o botão para a mesma, em uma das barras de ferramentas do Excel, já
que sua ação independe do arquivo em aberto.
Antes de inserirmos o botão, é necessário saber que o Excel 2013 abandonou o

conceito de menus, por isso o botão a ser criado será, na realidade, inserido na Barra
de Ferramentas de Acesso Rápido, que se localiza a direita do botão do Microsoft
Office. Para efetuar esta tarefa, devemos efetuar os procedimentos abaixo:
1. Na Barra de Ferramentas de Acesso Rápido, clique no botão Mais Comandos.
2. Escolha a opção Mais comandos.
3. Clique em Barra de Ferramentas de Acesso Rápido.

4. Selecione a macro para qual você deseja criar o botão e clique em Adicionar.
5. Você pode utilizar o botão modificar para alterar o ícone do botão a ser criado
e adicionar um nome de exibição para esta macro.

6. No final, clique em OK.
NOTA: Para excluir o botão criado ou alterar qualquer uma das opções descritas acima,
será necessário abrir novamente a janela Personalize a Barra de Ferramentas de
Acesso Rápido. Para excluir o botão, por exemplo, basta seleciona-lo e clicar em
Remover. A exclusão do botão não irá apagar a macro.
Editando uma Macro
Editar uma macro significa modificá-la, isto é, acrescentar ou até mesmo excluir
comandos que constam nela. Esta tarefa somente pode ser efetuada através do editor
do Visual Basic, o chamado VBE. Você pode acessar o VBE de duas maneiras:
A primeira é através da Guia Desenvolvedor, clicando no botão Visual Basic,

conforme a figura abaixo:
Ao clicar botão, você será levado para o ambiente de programação do Visual

Basic for Application, também chamado de VBE (Visual Basic Editor).

A outra forma de ir para o VBE é através do botão Macros, conforme os passos
abaixo:
1. Na guia Desenvolvedor, selecione a opção Macros. Será exibida a caixa de

diálogo abaixo.
2. Selecione o nome da macro que você deseja editar e clique sobre o botão
Editar. O editor do Visual Basic (VBE) se abre, com o módulo que contém a
macro selecionada, para que você, através do VBA, possa editar a macro, como
estudaremos adiante.

Excluindo uma Macro
Para Excluir uma Macro, também possuímos duas opções:
A primeira é selecionar, dentro do VBE, todo o código da macro, a qual você

deseja excluir, e pressionar a tecla DELETE.
A segunda é através do botão Macro, conforme abaixo:
1. Na guia Desenvolvedor, selecione a opção Macros. Será exibida a caixa de

diálogo abaixo.
2. Selecione o nome da macro que você deseja excluir e clique sobre o botão
Excluir.
3. Uma mensagem aparecerá na tela, perguntando se você realmente deseja

excluir a macro. Clique no botão Sim, para excluir definitivamente; Clique no
botão Não, para cancelar a operação.
A Pasta de Trabalho Pessoal de Macros
A Pasta de Trabalho Pessoal de Macros é, em princípio, como qualquer outra

pasta de trabalho (arquivo) dentro do Microsoft Excel. Porém ela é carregada
automaticamente quando entramos no aplicativo, de forma oculta.
Ela é criada quando você grava sua primeira macro, direcionando-a para “Pasta
de trabalho pessoal de macros” e esta pasta, normalmente, contém apenas uma
planilha em branco e módulos (rotinas) contendo macros. Você pode inserir outras
planilhas se desejar – embora isso não seja aconselhável, já que a função desta pasta é
servir apenas como uma biblioteca local de macros.

Você deve armazenar uma macro na pasta pessoal de macros, quando desejar
que a mesma possa ser usada a partir de qualquer outro arquivo (planilha) do Excel,
que seja aberto pelo seu usuário. Caso você não utilize perfil móvel em sua rede, a
macro também só funcionará, com seu usuário, no micro onde você a gravou.
Uma vez armazenada sua macro na pasta de trabalho pessoal de macros, e

desejando editá-la ou excluí-la, você perceberá que, seguindo os passos descritos
anteriormente, será apresentada a seguinte mensagem de erro:
Esta mensagem se deve ao fato do arquivo Pessoal.xlsb ser aberto de forma

oculta, ou seja, você não o vê enquanto trabalha em seu arquivo de planilha normal,
dentro do Excel.
Para visualizar a pasta pessoal de macros e, consequentemente, poder alterar

ou excluir as macros que estão nessa pasta, execute os seguinte comando:
1. Na guia Exibição, clique na opção Botão Reexibir (Este botão só está disponível
quando existe uma pasta de trabalho do Excel oculta).
2. Na caixa de diálogo Reexibir que será exibida, selecione a opção Pessoal.xlsb e

clique sobre o botão OK.

A pasta Pessoal.xlsb se abre, contendo apenas uma planilha normal, porém seu
módulo contém todas as macros que foram gravadas nesta pasta.
 Para visualizar o módulo, na guia Desenvolvedor, selecione a opção Macros.

Selecione agora o nome de qualquer uma das macros que você salvou na pasta
pessoal de macros e clique no botão Editar. O VBE se abre mostrando o código-
fonte da macro selecionada.

 Ainda com o arquivo Pessoal.xls visível, para excluir qualquer uma das macros
armazenadas no mesmo, na guia Desenvolvedor, selecione a opção Macros.
Selecione o nome da macro indesejada e clique no botão Excluir.
NOTA:
 Após editar ou excluir a macro desejada no arquivo Pessoal.xlsb deve-se
novamente ocultá-lo. Caso contrário, da próxima vez que o Microsoft Excel for
iniciado, a pasta Pessoal será aberta de forma visível e acabará sendo
sobrescrita por usuários desavisados. Isso acabará gerando “confusões” entre
diferentes usuários de seu micro. Para tanto, estando ainda com o arquivo
Pessoal.xlsb visível, na guia Exibição, clique na opção Ocultar. Em seguida, saia
do Excel e inicie-o novamente.
 Nas versões anteriores do Excel as macros são salvas juntamente com as

planilhas na mesma pasta de trabalho .xls, afim de melhorar a segurança e
transparência na utilização de macros, o Excel 2013 adota um formato
diferente para salvar macros, o formato padrão .xlsx somente é utilizado para
pastas de trabalho com planilhas comuns e o formato .xlsm é o formato
utilizado para salvar pastas de trabalho que possuem macros.

EXERCÍCIOS DE FIXAÇÃO
Exercício 1
Observe a planilha abaixo:
Utilizando o gravador de macros e os ícones da opção Inserir da Guia

Desenvolvedor, construa macros para:
1.1. Gerar subtotais na planilha por "Vendedor", calculando a soma do valor total
vendido por cada um. Associar a macro a um botão de comando acima da
planilha.
1.2. Remover os subtotais gerados pela macro anterior e retornar a classificação da
planilha por ordem crescente de Data / Item / Vendedor. Associar a macro a um
segundo botão de comando na planilha.
1.3. Ativar / Desativar o AutoFiltro na lista apresentada. Associar a macro a uma caixa
de seleção acima da planilha.
1.4. Classificar as vendas por:
1.4.1. Data / Item / Vendedor
1.4.2. Vendedor / Item / Data
1.4.3. Val Total / Data / Item
1.5. Associar cada uma das 3 macros gravadas a um botão de opção envolvendo-os
com uma caixa de grupo.

CAPÍTULO 2
Explorando o Visual Basic Editor - VBE
 A janela de código
 O Project Explorer
 A janela de propriedades
 O pesquisador de objetos
 As ferramentas de depuração
 Definindo padrões das janelas de códigos e módulos

Explorando o Visual Basic Editor – VBE
Como já foi citado anteriormente o Editor do Visual Basic é chamado,

normalmente, pelo acrônimo VBE. O VBE é o ambiente onde você pode editar macros
já gravadas e criar novas macros, funções e até formulários personalizados, através da
linguagem de programação Visual Basic for Applications, ou VBA. Entre os recursos
mais importantes do VBE podemos citar o Project Explorer, a Janela propriedades, o
Pesquisador de Objetos, a Janela de Código e as Ferramentas de Depuração.
A Janela de Código
É nesta janela que você escreve, exibe e edita o código do Visual Basic. Cada
módulo é aberto em uma janela de código separada.
A Janela de Código e os módulos serão vistos com mais detalhes no próximo capítulo.
O Project Explorer (VBAProject)
A janela do Project Explorer exibe uma lista, em

hierarquia, de todos os projetos carregados e os itens
incluídos em cada um. Porém, o Project Explorer é
somente uma ferramenta de navegação e
gerenciamento. Logo, você não pode criar um
aplicativo a partir dele. Caso esta janela não esteja
visível, clique em Exibir / Project Explorer (ou tecle
CTRL + R)

A Janela de Propriedades
Através desta janela são listadas todas as

propriedades do objeto selecionado, e você pode
alterá-las sempre que necessário. Quando
selecionamos vários controles, esta janela mostra
apenas as propriedades comuns entre os controles
selecionados. Caso esta janela não esteja visível, clique
em Exibir / Janela ‘Propriedades’ (ou tecle F4)
O Pesquisador de Objetos
O Pesquisador de Objetos exibe

informações sobre objetos,
propriedades, métodos e constantes no
projeto atual e em bibliotecas de
objetos referenciados. Você deve
utilizar o Pesquisador de objetos para
pesquisar um elemento específico, para
visualizar suas definições, para obter
uma ajuda etc. Para acessá-lo, clique
sobre a opção Pesquisador de objeto,
no menu Exibir, no Visual Basic Editor.
As Ferramentas de Depuração
Os botões desta barra são atalhos para alguns comandos que você também
encontra nos menus. Estes botões são usados na depuração de códigos, ou seja, para
encontrar erros de lógica no seu código. Cada um deles realiza uma determinada ação,
entre elas estão: Executar Sub/UserForm, Interromper, Redefinir, etc.
A parte de depuração de código será vista, em nosso curso, mais adiante.

Definindo Padrões das Janelas de Códigos e Módulos
Através do menu Ferramentas, no Visual Basic Editor, podemos acessar o item

Opções. Através da caixa de diálogo que aparecerá na tela, você poderá modificar
Vários padrões das janelas de códigos e módulos. Veja abaixo:
Através da guia Editor, você pode modificar as configurações do código e da

janela, como mostrar informações rápidas automáticas, autolistar as propriedades e
métodos de cada objeto, etc..
Na guia Formato do Editor, você pode alterar os padrões de formatação de

fonte e cores de código, personalizando o ambiente. Normalmente não alteramos os
padrões desta guia, a não ser em casos bem específicos.
Com a guia Geral, você pode alterar as configurações outras pções de

personalização, dentro das quais destacamos a “Configurações da grade do
formulário”, que é muito útil quando queremos fazer ajustes mais finos, nos controles
dos formulários.
Através da guia Encaixe, você pode alterar a maneira como as diversas janelas
de trabalho podem ser fixadas dentro do ambiente do VBE.
A seguir vamos destacar algumas opções interessantes da guia Editor, as quais

podem interferir na sua produtividade ao escrever código em VBA, caso sejam
desabilitadas:

• Na guia Editor, a opção Autolistar Membros. Se esta opção estiver marcada, será
oferecida uma lista de objetos, propriedades e métodos relevantes. É simples: ao
digitar o nome de um objeto, o Excel automaticamente apresentará uma lista de
objetos, propriedades e métodos que poderiam seguir ao nome do objeto. Se você
desejar inserir um item desta lista, basta clicar sobre ele.
• Outra opção bem interessante, também da guia Editor, são Informações Rápidas
Automaticas. Se esta opção estiver marcada, serão oferecidos a você, conforme for
escrevendo, os códigos, informações sobre a sintaxe e também argumentos que você
precisa utilizar. Veja um exemplo:
• Na guia Editor, também interessante, é Dicas Automáticas de Dados. Se esta opção

estiver marcada, será fornecido a você o valor de uma variável ou expressão enquanto
o código estiver no modo Interrupção. Para visualizar estes valores, selecione a
variável ou expressão que deseja verificar e mova o mouse sobre ela para exibir o valor
atual.
• A opção “Requerer declaração de variável”, da Guia Editor, também é muito útil, e

será comentada na parte de depuração de código, mais adiante nesta apostila.

CAPÍTULO 3
Trabalhando com módulos e procedimentos
 Trabalhando com módulos
 Módulos padrão
 Módulos classe
 Como criar um módulo
 Salvando módulos
 Exportando módulos
 Procedimento SUB
 Procedimentos Function

Trabalhando com Módulos
Para programar com o Excel usando o Visual Basic for Applications, é necessário
compreender inicialmente os módulos, o que são e para que servem. Vamos, então,
dar uma visão geral sobre módulos.
Os módulos são espaços onde ficarão declarações e procedimentos do VBA.

Cada módulo pode conter diversos procedimentos, do tipo SUB e FUNCTION, os quais
serão vistos em nosso curso, ou PROPERTY, cujo estudo foge dos objetivos deste curso
de VBA.
Quando usamos o gravador de macros no Excel, o mesmo tende a armazenar

todas as macros gravadas, dentro de uma mesma seção do Excel 2013, em um mesmo
módulo. Entretanto, se fecharmos o arquivo em uso e o reabrirmos, o gravador de
macros irá gerar um novo módulo para guardar as novas macros gravadas. Em todo
caso, podemos reorganizar as macros de uma pasta de trabalho diretamente pelo
editor do Visual Basic (VBE), recortando o código de uma macro gravada num módulo
e colando-o no módulo desejado, exatamente como fazemos com arquivos e textos.
Existem dois tipos básicos de módulos, os Módulos de Classe e os Módulos

Padrão. Vamos entender suas utilidades e a diferença entre eles.
Módulos Padrão
São módulos nos quais você pode colocar os procedimentos Sub e Function que
deseja que estejam disponíveis a outros procedimentos, por todo o seu projeto ativo.
As macros gravadas são armazenadas neste tipo de módulo.
Eles contêm procedimentos de uso geral que não estão associados a nenhum
outro objeto, como planilhas, pasta de trabalho ou formulário, e que podem ser
executados dentro de qualquer outro módulo pertencente ao projeto. Por este
motivo, as definições num Módulo Padrão são, por default, do tipo Public. Ao serem
criados, estes módulos aparecem abaixo das planilhas, na janela Project Explorer do
VBE.
Módulos de Classe
Estes módulos contêm um código local para uma determinada classe ou objeto,
ou seja, para uma planilha, a pasta de trabalho ou um formulário no Excel. Quando
você cria o primeiro procedimento de um formulário, o Excel cria automaticamente
um módulo associado a este. Este módulo é chamado de Módulo de Classe, e é nele
que criamos os procedimento em VBA para o formulário.
As planilhas e a pasta de trabalho, já possuem um módulo de classe associado,

bastando dar um clique duplo em cima do ícone da planilha ou pasta de trabalho, no
Project Explorer, para que seja aberto o módulo de classe.

Os módulos são criados em uma janela especial, no VBE. Toda vez que você
inserir um módulo, seja ele de Classe ou Padrão, será exibida uma janela de código, tal
com descrito abaixo:
Caixa de Objetos
É uma caixa onde são listados todos os objetos existentes, que
originam o código implementado na janela Módulo. Clique na seta à
direita para escolher um dos objetos a lista.
Caixa de Procedimentos
É uma caixa que lista todas as funções e procedimentos
implementados na janela Módulo. Clique na seta à direita para escolher
algum procedimento ou função da lista.
Área de Código
Área onde é escrito o código, ou seja os procedimentos em VBA.
Como Criar um Módulo
Os módulos podem ser criados de duas formas:
1. Quando você grava uma macro, sem que você perceba, os códigos desta são
gravados em um módulo. Esta é a maneira mais simples de se criar um módulo.
2. Você também pode criar um módulo, seja ele Padrão ou de Classe, através do
menu Inserir do VBE. Quando você criar um módulo através do menu Inserir,
este abrirá automaticamente um Módulo Padrão ou de Classe, dependendo da
opção escolhida, para que você possa inserir as linhas de códigos desejadas.
Pode-se ainda clicar com o botão direito do mouse no Project Explorer, que um
menu pop-up aparecerá. Selecione, então, a opção Inserir, e você verá uma
lista de opções, dentre elas, escolha Módulo Padrão ou de Classe.

Salvando Módulos
Os módulos criados no VBA são salvos juntos com o arquivo .xlsx. Assim sendo,
para salvar um Módulo Padrão ou Módulo Classe ou ainda um UserForm (formulário
do usuário, conforme veremos adiante), basta salvar o arquivo do Excel.
Portanto, quando você estiver salvando um determinado arquivo do Excel,

estará também salvando todos os módulos e procedimentos que o arquivo contém. E
reciprocamente, quando você estiver salvando um determinado módulo no VBE,
estará também salvando todas as alterações feitas na planilha do Excel.
Exportando Modulos
Outra forma que existe para salvarmos um módulo ou um formulário

personalizado é exportarmos o conteúdo do módulo ou do formulário para um
arquivo; que recebe uma das três extensões a seguir: .bas (módulos padrão), .cls
(módulos classe) ou .frm (formulários personalizados). Estas extensões de arquivo são
geradas pelo Visual Basic Editor (VBE) durante o processo de exportação.
O processo de Exportação nos permite gravar somente os módulos e

formulários em arquivos de pequeno tamanho que podem ser mantidos como
“backup” de soluções criadas. Logo, esta opção torna-se extremamente útil – por
exemplo – quando queremos criar uma cópia de macros criadas a partir de um certo
arquivo, mas que poderão servir de solução para problemas semelhantes, dentro de
outros arquivos.
Para exportar o conteúdo de um Módulo Padrão, Módulo Classe ou de um

UserForm, basta clicar com o botão direito do mouse sobre o nome do módulo ou do
formulário na janela VBAProject e selecionar a opção Exportar Arquivo... Será
apresentada a caixa de diálogo abaixo para confirmar o local da gravação e o nome do
módulo desejados.

Quando desejar importar um arquivo de módulo, para dentro de uma outra
pasta do Microsoft Excel (.xlsx,) proceda da seguinte forma:
1. Abra o arquivo .xlsx normalmente dentro do Excel;
2. Acesse o editor do Visual Basic (VBE), clicando na guia Desenvolvedor,

selecione a opção Visual Basic;
3. Clique com o botão direito sobre o nome da pasta de trabalho na janela

VBAProject e selecione Importar Arquivo...;
4. Informe o caminho e o nome do arquivo (.bas / .cls / .frm) a importar para a

pasta atual, conforme ilustra a imagem abaixo.
5. Clique no botão Abrir.
Trabalhando com Procedimentos

Procedimentos são sequências nomeadas de instruções executadas como uma
unidade. Todo o procedimento é definido em um Nível de Módulo e todo código
executável tem de necessariamente estar contido em um procedimento. Usando a
linguagem de programação VBA, você pode criar três tipos de diferentes de
procedimentos:
• Procedimento SUB;
• Procedimento FUNCTION;
• Procedimento PROPERTY.

Procedimento SUB
As macros gravadas no Microsoft Excel são os exemplos mais claros do que

significa um procedimento SUB no VBA. O procedimento SUB executa uma sequência
lógica de instruções que, em conjunto, realizam uma tarefa, automatizando ações
repetitivas no seu trabalho dentro do aplicativo.
Você também pode utilizar argumentos em um procedimento SUB, como

constantes, variáveis ou expressões. Se um procedimento SUB não contiver um
argumento, a instrução SUB deve incluir um conjunto de parênteses vazios, após o
nome.
Para declarar um procedimento SUB diretamente no VBE, abra um módulo e

use a seguinte sintaxe:
[Public ou Private] Sub <nome da procedure>([argumentos])
<bloco de comandos>
[Exit Sub]
End Sub
Analise o exemplo abaixo, para que você possa entender melhor:

Public Sub Erro()
Msgbox “Ocorreu um erro muito estranho!”, vbcritical
Exit Sub
End Sub
Quanto à sua disponibilidade em ser chamado, por outro procedimento, um

procedimento SUB poderá ser do tipo Público ou Privado. Para alterar o tipo padrão de
um procedimento SUB, basta utilizar as declarações Public ou Private, antes da
declaração do procedimento SUB.
Quando ele é escrito em um módulo padrão, o procedimento é, por default, do

tipo público, ou seja, poderá ser chamado por qualquer outro procedimento dentro do
Projeto.
Se ele for criado dentro de um módulo de Classe, por padrão, o procedimento

será Privado, ou seja, ele somente poderá ser chamado por um outro procedimento
dentro do mesmo módulo em que ele foi escrito.
O comando Exit Sub provoca a saída imediata do procedimento SUB, e é

utilizado quando queremos “forçar” a saída da rotina, por alguma questão particular
de nosso código.
Chamando uma Procedimento SUB
No VBA, assim como em outras linguagens de programação, podemos fazer

recorrências entre procedimentos. Isto é, chamar um procedimento dentro de outro
procedimento. Para chamar uma procedimento SUB, dentro de outro procedimento,
basta digitar seu nome, seguido dos parâmetros, caso existam.

Exemplo: Na rotina abaixo declarada, caso um erro ocorra durante seu
processamento, chamamos o procedimento SUB denominado TratarErro, o qual foi
definido anteriormente.
Private Sub Exemplo_Recorrencia()

...
If ValorDigitado = 0 then
TratarErro
End If
...
End Sub
Chamando Sub Procedures com Parâmetros
Um argumento, ou parâmetro, não é obrigatório num procedimento SUB. No

entanto, quando o utilizamos, dizemos que estamos chamando essa rotina e
passando-lhe um parâmetro, que será utilizado por ela para o processamento de suas
ações. Veja o exemplo abaixo:
Public Sub Resultado(saldo As Integer)

If saldo > 0 then
Msgbox “OK! Saldo Positivo.”
ElseIF saldo < 0 then
Msgbox “Atenção! Saldo Negativo.”
Else
Msgbox “Saldo Zero.”
End If
End Sub
Veja como poderíamos chamar esta procedure dentro de outra Sub, passando
um valor como parâmetro.
Sub Imposto()
...
Resultado(totcred – totdeb)
...
End Sub
Procedimento FUNCTION
Os procedimentos FUNCTIONS podem retornar um valor para quem o chamar,

esta é a diferença em relação aos procedimentos SUB, que não retorna um valor,
apenas executam ações. Você pode utilizar em um procedimento FUNCTION
argumentos, como constantes, variáveis ou expressões. Se por acaso, um
procedimento FUNCTION não tiver um argumento, sua instrução FUNCTION deve ter
um conjunto de parênteses vazio.
Para declarar um procedimento FUNCTION, use a seguinte sintaxe:

[Public,Private ou Static] Function <nome da função>([argumentos]) [As <tipo>]
<bloco de comandos>
[Exit Function]
End Function

Note que pela sintaxe do procedimento FUNCTION que este pode ser tanto
Público quanto Privado. Todas as observações que fizemos anteriormente, para os
tipos de procedimentos SUB, valem para os procedimentos FUNCTION.
A expressão As tipo irá especificar um tipo de dados que à função retornará. O

retorno da função deve ser atribuído a uma variável com o nome da função.
Uma função definida em um módulo padrão, estará disponível para ser

utilizada dentro de sua planilha no Excel. Esta é uma das grandes utilidades de criar
funções no VBA.
O comando Exit Function provoca a saída imediata da Function Procedure.
NOTA: Sugerimos que você use o procedimento Sub quando não for necessário
retornar um valor, e que seja usado o procedimento Function quando for necessário
retornar um valor.
Procedimento Property
O procedimento Property é uma série de instruções do VBA que permite a
criação de propriedades personalizadas. Ao criar um procedimento Property, este irá
tornar-se uma propriedade do módulo que contém o procedimento.
O procedimento Property deve ser utilizado quando se está programando com

Módulos Classe, definindo-se objetos e suas propriedades. Um Módulo Classe define
toda a estrutura de um objeto
A criação de procedimentos Property está além do escopo do nosso curso, pois

sua utilização efetiva requer um conhecimento mais aprofundado de Programação
Orientada a Objeto. Porém, caso você deseje maiores informações, encontrará na
Internet diversos sites com tutorias a respeito deste assunto.
Outra forma de inserirmos um procedimento dentro de um módulo, a partir da

janela do VBE, é através do menu Inserir, opção Procedimento. Aparecerá o quadro
abaixo:

1. Na caixa Nome, digite um nome para a função;
2. Na caixa Tipo, escolha a opção Sub;
3. Na caixa Escopo, escolha se a função que está sendo criada será Pública ou
Particular;
4. Se você desejar que as variáveis locais sejam estáticas, marque a opção Todas
as variáveis locais como estáticas;
5. Clique no botão OK e automaticamente a Sub procedure que você acabou de

criar será declarada dentro do módulo corrente;
6. Insira então os códigos desejados.

CAPÍTULO 4
Variáveis, Tipos de Dados e Operadores
Tópicos deste capitulo
 Trabalhando com Variáveis
 Tipos de Dados
 Variáveis
 Constantes
 Arrays e Matrizes
 Operadores
 Precedência de Operadores

Trabalhando com Variáveis
Variáveis são “depósitos temporários de informações” que uma rotina pode

necessitar e devem ser declaradas de acordo com o tipo de dados que elas podem
conter. Os tipos de dados no VBA incluem: Byte, Boolean, Integer, Long, Currency,
Single, Double, Date, String, Variant, Decimal e os tipos definidos pelo usuário.
As Variáveis são criadas na memória do computador, no momento da execução

do procedimento e, normalmente, são apagadas da memória ao fim deste. Cada
variável, dependendo do tipo de dados com que ela é criada, ocupa um determinado
espaço na memória do computador. Devemos ser parcimoniosos quanto à criação e
criteriosos quanto ao tipo de dados escolhido para cada variável, para não gastarmos
mais memória que o necessário e não tornarmos lenta a execução de nossos
procedimentos.
Tipos de Dados
Veja abaixo para que servem cada um desses tipos e quanto espaço ocupam na
memória do computador:
• Byte: É usado para armazenar números inteiros e positivos, que variam no intervalo
de 0 a 255. As variáveis de tipo Byte são armazenadas como números de 8 bits simples
(ocupa 1 byte) e sem sinal.
• Boolean: Este tipo de dado é armazenado como número de 16 bits (ocupa de

memória 2 bytes) e assume somente o valor de True e False. Por exemplo, se uma
variável numérica se converte para booleana, esta se torna Falsa se for 0 e Verdadeira
para quaisquer outros valores. Mas se a variável booleana se converter para outro tipo
de dado, o valor False se tornará 0 e o valor True -1. Use as palavras True ou False para
atribuir um valor às variáveis Boolean (booleanas).
• Integer Este tipo de dado é armazenado como número de 16 bits (ocupa de memória
2 bytes), cujo valor de intervalo é de -32.768 a 32.767.
• Long: Este tipo de dado é armazenado como número de 32 bits (ocupa de memória 4
bytes), cujo valor de intervalo é de -2.147.483.648 a 2.147.483.647.
• Currency: Este tipo de dado é muito útil para cálculos que envolvem dinheiro, pois
sua precisão é de 15 dígitos à esquerda da vírgula decimal e 4 dígitos à direita,
representando assim um intervalo de -922.337.203.685.477,5808 a
922.337.203.685.477,5807. Este dado é armazenado como número de 64 bits (ocupa
de memória 8 bytes).

• Single: Este tipo de dado é armazenado como números de 32 bits (ocupa de
memória 4 bytes), com valor no intervalo de -3,402823E38 a -1,401298E-45 para
valores negativos e de 1,401298E-45 a 3,402823E38 para valores positivos
• Double: Este tipo de dado é armazenado como números de 64 bits (ocupa de

memória 8 bytes), com valor no intervalo de -1,79769313486232E308 a -
4,94065645841247E-324 para valores negativos e de 4,94065645841247E-324 a
1,79769313486232E308 para valores positivos.
• Date: Este tipo de dado é armazenado como números de 64 bits (ocupa de memória
8 bytes) que representam as datas que variam de 1 de janeiro de 100 a 31 de
dezembro de 9999 e as horas de 0:00:00 a 23:59:59. Qualquer valor literal de data
reconhecível pode ser atribuído às variáveis Date (data). Os literais Date devem estar
entre sinais (#), por exemplo, #1 de janeiro de 1993# ou #1 jan 93#. Importante: As
variáveis Date exibem as datas de acordo com o formato abreviado de data
reconhecido por seu computador. As horas são exibidas de acordo com o formato de
hora (12 ou 24 horas) reconhecido por seu computador.
• String: Existem dois tipos de seqüências: seqüências de comprimento variável e de

comprimento fixo. A seqüência de comprimento variável pode conter até
aproximadamente 2 bilhões (2^31) de caracteres. Já a seqüência de comprimento fixo
pode conter de 1 até aproximadamente 64K (2^16) de caracteres. O tamanho ocupado
de memória para uma String variável é de 16 bytes mais o tamanho da String e para a
String fixa apenas o tamanho da String.
• Object: Este tipo de dado é armazenado como endereço de 32 bits (ocupa de

memória 4 bytes) que se referem a objetos. Uma variável declarada como um Object
poderá referir-se a qualquer objeto criado pela aplicação.
• Variant: Este tipo de dado é automaticamente especificado caso você não

especifique um tipo de dado quando declara uma constante, variável ou argumento.
As variáveis do tipo Variant podem adquirir qualquer valor numérico no intervalo de
Double, ou qualquer caractere. O tamanho ocupado de memória para uma Variant de
números é de 16 bytes e para uma Variant com caracteres é de 22 bytes mais o
tamanho da String.

Variáveis
Simplificando, é um local de armazenamento nomeado, podendo conter dados
que podem ser modificados durante a execução do programa. Cada variável deve ter
um nome que irá identificá-la de maneira exclusiva dentro do seu nível de escopo. Já
um tipo de dados pode ou não ser especificado.
Todos os nomes de variáveis devem começar com um caractere alfabético e

devem ser exclusivos dentro do mesmo escopo. Uma variável não pode ter mais de
255 caracteres e não pode conter caracteres especiais, como por exemplo, os
seguintes: # $ % & ! . ) } ] / \ | @ e outros.
Existem alguns nomes reservados, os quais não podem ser usados, como: DIM-
SUB-WITH-END e outras. Caso você utilize uma palavra reservada, o VBA emitirá um
erro ao executar o programa. O VBA não faz distinção entre maiúsculas e minúsculas,
nos nomes das variáveis.
Assim que você determinar um nome para a variável, poderá então declarar
seu tipo de dados como: Integer, Boolean, Byte, Long, Currency, Single, Date, String,
Object ou Variant (quando não declarada).
Declarando uma Variável
O primeiro passo para se declarar uma variável, é determinar onde ela será
declarada, e isto depende muito de cada sistema. Geralmente as variáveis são
declaradas usando-se a instrução Dim. Uma instrução de declaração pode ser inserida
dentro de um procedimento, e isto criaria uma variável que chamamos de Nível de
Procedimento. Ou ela poderia ser inserida na parte superior de um módulo, na seção
Declarações, então neste caso estaríamos criando uma variável de Nível de Módulo.
Ao criar uma variável de Nível de Procedimento, está estará disponível apenas

ao Nível de Procedimento. Os Níveis de Procedimentos são instruções que se localizam
dentro de um procedimento Function, Property ou Sub. Ao criar uma variável de Nível
de Módulo, esta estará disponível para todas as funções do módulo onde ela foi
declarada. Abaixo estamos mostrando uma variável Soma, especificando o tipo de
dado Double. Ficaria assim:
Dim soma As Double
Observe, a sintaxe é esta:
Dim <nome da variável> As <tipo da variável>
Usando a Instrução Public
Você deve utilizar uma instrução Public, em Nível de Módulo, quando desejar
que a variável esteja disponível para todos os procedimentos no projeto. Se a variável
Pública for declarada num Módulo Padrão ou num Módulo Classe, ela também poderá
ser utilizada em qualquer projeto que faça referência ao projeto onde a variável
Pública foi declarada.

Veja abaixo uma variável Pública chamada Soma, do tipo Double:
Public soma As Double
A sintaxe é a mesma:
Public <nome da variável> As <tipo da variável>
Usando a Instrução Private
Você utiliza a instrução Private para declarar as variáveis privadas em Nível de

Módulo. Estas variáveis podem ser utilizadas somente por procedimento no mesmo
módulo. A instrução Dim é equivalente à instrução Private, se esta for utilizada em
Nível de Módulo. Mas mesmo assim, sugerimos que seja usada a instrução Private
para facilitar a interpretação do código.
A seguir, mostramos uma variável Private chamada Soma, do tipo Double:
Private soma as Double
Sua sintaxe:
Private <nome da variável> As <tipo da variável>
Usando a Instrução Option Explicit
Utilizando a instrução Option Explicit, você estará forçando a declaração

explícita de todas as variáveis do módulo onde esta se encontra. Se esta instrução for
usada, ela deve parecer em um módulo antes de qualquer procedimento. Caso você
optar em não usar a instrução Option Explicit, todas as variáveis não declaradas serão
do tipo Variant, exigindo assim mais recursos de memória que a maioria das outras
variáveis.
Sugerimos usar esta instrução em todos os módulos para evitar a digitação
incorreta do nome de uma variável existente ou até mesmo para evitar confusão no
código em que o escopo da variável não esteja claro. Você pode fazer com que o Visual
Basic for Applications inclua automaticamente a instrução Option Explicit em todos os
módulos novos. Para isso:
1. No VBE, clique no menu Ferramentas e escolha Opções.
2. Na guia Editor, marque a opção Requerer declaração de variável e clique

em 0K.
Note que somente será inserida a instrução Option Explicit nos novos módulos
inseridos, os módulos existentes não serão alterados. Se você desejar, você mesmo
poderá inserir a instrução. Basta digitar Option Explicit no cabeçalho do módulo
desejado.

Atribuindo Valores às Variáveis
Agora que você aprendeu a declarar variáveis, o próximo passo é atribuir

valores às variáveis já declaradas. É simples, para atribuir um valor utilizamos o sinal de
igualdade (=). Para um melhor entendimento, veja o exemplo abaixo:
Dim Soma As Integer

Soma = 0
Veja outro exemplo:
Dim Soma, Var1, Var2 As Integer (Somente Var2 é Integer, as demais são Variant)
Soma = Var1 + Var2
Constantes
Constantes são itens nomeados que mantêm um valor constante por toda a
execução de um programa. Uma constante é um nome significativo que assume o local
de um número ou uma sequência de caracteres que não serão alterados durante a
execução de um procedimento.
Assim, uma constante não pode ser modificada no decorrer de uma rotina e
nem atribuir um novo valor, assim como pode com uma variável. Sugerimos o uso de
constantes para facilitar a leitura e a manutenção do código do seu programa.
Declarando Constantes
Ao declarar uma constante, você pode atribuir a ela um nome significativo e um

valor. Você deve usar a instrução Const para declarar a constante e definir seu valor.
Você pode declarar uma constante tanto em Nível de Procedimento, quanto em Nível
de Módulo. Se você declarar uma constante em Nível de Módulo, por padrão ela será
privada (Private).
Para declarar constante Pública você deverá usar a palavra-chave Public antes
da instrução Const. Você não pode declarar uma constante Public dentro de um
procedimento. Já para explicitar uma constante Privada, use a palavra-chave Private
antes da instrução Const. Neste caso, você também não pode declarar uma Private
Const em um procedimento. Se você seguir estes procedimentos, você estará
facilitando a interpretação do seu código.
Abaixo, mostramos um exemplo de uma constante Public de nome Idade, do

tipo Integer, e de valor 23:
Public Const idade As integer = 23
Sua sintaxe:
[Public/Private] Const <nome const> As <tipo const> = <valor>

Trabalhando com Matrizes
Matriz é um conjunto de elementos seqüencialmente indexados que possui o

mesmo tipo de dados intrínseco. Cada elemento de uma matriz possui um número de
índice identificador exclusivo. As alterações feitas em um elemento de uma matriz não
afetam os outros elementos.
Declarando Matrizes
As matrizes são declaradas da mesma maneira que as outras variáveis,

utilizando instruções Dim, Private ou Public. A diferença entre as variáveis escalares
(que não são matrizes) e variáveis de matriz é que geralmente você deve especificar o
tamanho da matriz. Uma matriz cujo tamanho é especificado é uma matriz de
tamanho fixo, uma matriz cujo tamanho pode ser alterado durante a execução de um
programa é uma matriz dinâmica. A indexação de uma matriz a partir de 0 ou 1
depende da definição da instrução Option Base. Se Option Base 1 não for especificada,
todos os índices de matriz iniciarão em zero.
Declarando uma matriz fixa
Na linha de código a seguir, uma matriz de tamanho fixo é declarada como uma
matriz Integer com 11 linhas e 11 colunas:
Dim MyArray (10, 10) As Integer
Sua sintaxe:
[Public/Private] <nome Matriz> (Quantidade de elementos) As <tipo de dados>
Declarando uma matriz dinâmica
Ao declarar uma matriz dinâmica, você pode dimensionar a matriz durante a

execução do código. Utilize uma instrução Static, Dim, Private ou Public para declarar
uma matriz, deixando vazios os parênteses, como mostra o exemplo a seguir.
Dim sngArray() As Single
Você pode utilizar a instrução ReDim para declarar uma matriz implicitamente
dentro de um procedimento. Tome cuidado para não digitar errado o nome da matriz
quando utilizar a instrução ReDim. Mesmo que haja uma instrução Option Explicit
incluída no módulo, será criada uma segunda matriz. Por exemplo, a instrução a seguir
acrescenta 10 elementos à matriz varArray sem perder os valores atuais dos
elementos originais.
ReDim Preserve varArray(UBound(varArray) + 10)
Em um procedimento dentro do escopo da matriz, utilize a instrução ReDim

para alterar o número de dimensões, definir o número de elementos e definir os
limites superior e inferior de cada dimensão. Utilize ReDim Preserve para expandir
uma matriz enquanto preserva os valores existentes na matriz.

Trabalhando com Operadores
Existem quatro tipos de operadores: os aritméticos, os de comparação, os
lógicos e os de concatenação. Abaixo vamos listá-los e aprender como usá-los e para
que servem.
Operadores Lógicos
Os operadores lógicos servem para efetuar apenas operações lógicas. Veja a

lista de operadores lógicos abaixo:
And – Not – Or
A sintaxe destes operadores é a seguinte:

Result = expression1 <operador> expression2
Onde:
Result qualquer variável numérica.
Expression1 qualquer expressão.
Operador de sua escolha.
Expression qualquer expressão.
Observe que somente o operador Not tem uma sintaxe diferente. Veja abaixo:
Result = Not expression
Operador Comentário
And Efetua uma conjunção lógica em duas expressões.
Not Efetua uma negação lógica em uma expressão.
Or Efetua uma disjunção lógica em 2 expressões
Operadores Aritméticos
Usamos estes operadores para realizar cálculos matemáticos. Veja a lista de

operadores aritméticos:
^ * / \ Mod + -
Exponenciação ( ^ )
Result = number ^ exponent
Este operador é usado para elevar um número à potência de um expoente. Exemplo:

Dim Valor
Valor = 6 ^ 2 “retorna 36”

Multiplicação ( * )
Result = number1 * number2
Este operador é usado para multiplicar dois números. Exemplo:

Dim valor
Valor = 5 * 5 “retorna 25”
Divisão ( / )
Result = number1 / number2
Este operador é usado para dividir dois números e retornar um resultado de ponto
flutuante. Exemplo:
Dim valor
Valor = 5 / 2 “retorna 7,5”
Divisor de Inteiros ( \ )
Result = number1 \ number2
Este operador é usado para dividir dois números e retornar um resultado inteiro.
Exemplo:
Dim valor
Valor = 11 \ 2 “retorna 5”
Módulo Aritmético ( Mod )

Result = number1 Mod number2
Este operador é usado para dividir dois números e retornar apenas o resto da divisão.
Exemplo:
Dim valor
Valor = 7 Mod 2 “retorna 1”
Adição ( + )
Result = expression1 + expression2
Este operador é usado para somar dois números. Exemplo:

Dim soma
Soma = 15 + 15 “retorna 30”
Subtração ( - )
Result = number1 - number2
Este operador é usado para calcular a diferença entre dois números. Exemplo:
Dim resultado
Resultado = 10 – 3 “retorna 7”

Operadores de Comparação
Estes operadores servem para indicar uma relação entre dois ou mais valores
numa expressão. Veja a lista destes operadores abaixo:
< <= > >= <> =
A sintaxe destes operadores é:

Result = expression1 <operador> expression2
Onde:
Result qualquer variável numérica.
Expression1 qualquer expressão.
Operador de sua escolha.
Expression 2 qualquer expressão.
Operador Comentário
< Menor que
<= Menor ou igual a
> Maior que
>= Maior ou igual a
<> Diferente
= Igual
Operadores de Concatenação
Muitos programadores usam o sinal de (+) para concatenar Strings. Sugerimos

que não seja usado este sinal para uma concatenação, pois o resultado final pode ser
uma soma e não uma concatenação. Veja um exemplo abaixo:
Dim var1
Var1 = 2 + 5 este processo retornaria “7”
Na verdade, não desejávamos somar, nossa intenção era concatenar. Para

obter uma concatenação correta, devemos fazer uso do E comercial (&), conforme
abaixo:
Dim var1
Var1 = 2 & 5 este processo retornaria “25”
Veja um outro exemplo de concatenação:
Dim exemplo
exemplo = “concatenação” & “correta” (Isto retornaria “concatenação correta”)

Precedência de Operadores
Precedência de operadores são as diversas operações que podem ocorrer em
uma expressão, onde cada parte é avaliada e resolvida em uma ordem
predeterminada. Quando usamos em uma expressão várias categorias de operadores,
primeiro serão avaliadas os operadores aritméticos; em segundo lugar, os de
comparação; e por último, os operadores lógicos.
É importante saber que os operadores de comparação usam uma mesma

precedência e por este motivo, são avaliados da esquerda para a direita, na mesma
ordem que é apresentada na expressão. Já os operadores lógicos e aritméticos são
avaliados na ordem de precedência abaixo. Veja a tabela:
Ordem Aritméticos Lógicos

1º. Exponenciação ( ^ ) Not
2º. Multiplicação e Divisão ( * / ) And
3º. Divisão de Inteiros ( \ ) Or
4º. Módulo aritmético ( Mod ) Xor (exclusão lógica)
5º. Adição e Subtração ( + - ) Eqv (Equivalência Lógica)
6º. Concatenação de seqüência de caracteres (&) Imp (Implicancia Lógica)

CAPÍTULO 5
Elementos Essenciais do VBA para Excel 2013
 Funções do VBA
 Funções de Planilha
 Caixas de Mensagens
 Os Principais Objetos do Excel 2013
 O objeto Application
 O objeto WorkBook
 O objeto WorkSheet
 O objeto Range

Funções do VBA
Assim como a maioria das linguagens de programação, o VBA oferece várias
funções internas, que podem ser utilizadas na construção de macros para o Microsoft
Excel.
Além das funções internas, também podemos desenvolver funções

personalizadas através da declaração de um procedimento Function. A seguir Fazemos
um rápido resumo, de algumas funções do VBA. Para maiores detalhes sobre elas e
para a relação completa das funções disponíveis, você pode consultar o Help do VBA.
Funções de Manipulação de Strings
Format
Esta função irá formatar valores numéricos, indicando o número de casas decimais, o
número de zeros iniciais ou finais, bem como formatar os valores de moeda. Sintaxe:
Format(expression [,format [,firstdayofweek[, firstweekofyear]]])
Onde:
• Expression é qualquer expressão válida (obrigatória);
• Format é uma expressão de formato válida ou nomeada pelo usuário;
• Firstdayofweek é uma constante que indica o primeiro dia da semana;
• Firstweekyear é uma constante que indica a primeira semana do ano;
Lcase
Esta função retorna uma String convertida em letras minúsculas. Mas note que todas
as letras minúsculas e caracteres diferentes de letras não serão alterados. Sintaxe:
Lcase(string)
Onde: String é obrigatória e pode ser qualquer tipo de expressão de seqüência válida.
Ucase
Esta é uma função que retorna uma seqüência de caracteres convertida em
maiúsculas. Sintaxe:
Ucase(string)
Onde: String é obrigatória e você pode usar qualquer expressão de seqüência válida.
Left / Right
Estas funções retornam uma Variant (String) que contém um número específico de
caracteres, a partir do lado esquerdo/direito de uma seqüência de caracteres. Sintaxe:
Left ou Right (string, lenght)
Onde:
• String é uma expressão de seqüência obrigatória, a partir do qual são
retornados os caracteres mais à esquerda/direita.
• Length é uma expressão numérica Variant (Long) obrigatória que indica
a quantidade de caracteres a ser retornada.

Len
Esta função retorna o número de caracteres de uma String. Sintaxe:
Len(string)
Onde: String é um texto ou uma variável válida, da qual se deseja saber o nº de
caracteres.
Ltrim / Rtrim
Esta função retorna uma sequência de caracteres específicos, sem espaços à esquerda
ou Direita. Sintaxe:
Ltrim ou Rtrim(string)
Onde: String é uma expressão de seqüência válida obrigatória.
Mid
Esta função retorna uma String que contém um número especificado de caracteres de
uma seqüência de caracteres. Sintaxe:
Mid(string, start[,length])
Onde:
• String é uma expressão de seqüência obrigatória da qual são retornados
os caracteres.
• Start é um Long obrigatório que determina a posição do caractere em
String onde a parte a ser considerada começa.
• Length é um Long opcional que determina o número de caracteres a ser
retornado.
String
Retorna um caractere, determinado número de vezes. Sintaxe:
String(number, character)
Onde:
• Number é um Long obrigatório que determina o comprimento da
seqüência de caracteres retornado.
• Character é uma Variant obrigatória que funciona da seguinte forma: ao
se usar um código de caracteres, especifica-se caractere ou a expressão
de seqüência, cujo primeiro caractere será usado para formar a
seqüência de caracteres de retorno.
Funções de Manipulação de Data e Hora
Date
Esta função é usada para retornar a data atual do sistema. Sintaxe:
Date()
Time
Esta função retorna uma Variant Date que indica a hora atual do sistema. Sintaxe:
Time()
DateAdd
Esta função irá retornar uma data à qual foi adicionado um intervalo de tempo
especificado.

Sintaxe:
DateAdd(interval, number, date)
Onde:
• Interval é uma expressão de seqüência que representa o intervalo de
tempo que você deseja adicionar, é obrigatório.
• Number é uma expressão numérica obrigatória, que representa o
número de intervalos que você deseja adicionar; pode ser positivo, para
obter datas do futuro ou negativo, para obter datas do passado.
• Date é uma Variant obrigatória que representa a data à qual o intervalo
é adicionado.
DateDiff
Esta função retorna uma Variant Long que especifica o número de intervalo de tempo
entre duas datas especificadas. Sintaxe:
DateDiff(interval,date1,date2,[,firstdayweek[,firstweekyear]])
Onde:
• Interval é uma expressão de seqüência obrigatória que serve para
calcular a diferença de tempo entre a date1 e date2.
• Date1, Date2 são as duas datas que você deseja usar no cálculo, é
obrigatória.
• Firstdayweek é uma constante opcional que especifica o primeiro dia da
semana, se você não usá-la, será considerado o domingo como o
primeiro dia.
• Firstweekyear é uma constante opcional que especifica a primeira
semana do ano, se você não usá-la, será considerada aquela que ocorre
o dia primeiro de janeiro.
DateSerial
É uma função que retorna uma Variant Date para um ano, mês e dia especificados.
Sintaxe:
DateSerial(year,month,day)
Onde:
• Year é uma expressão numérica obrigatória entre 100 a 9999, para
especificar o ano.
• Month é qualquer expressão numérica obrigatória, serve para
especificar o mês.
• Day é qualquer expressão numérica obrigatória, serve para especificar o
dia.
DateValue
É uma função que retorna uma data. Sintaxe:
DateValue(date)
Onde:
• Date é qualquer expressão de seqüência que represente uma data de 1º
de Janeiro de 100 a 31 de dezembro de 9999. Pode ser também
qualquer expressão que represente uma data, uma hora ou ambas
neste intervalo.

Day
Esta função retorna um número inteiro entre 1 a 31, que representa o dia de uma
datacompleta. Sintaxe:
Day(date)
Onde: Date poderá ser uma expressão numérica, de seqüência ou qualquer
combinação que possa representar uma data.
Hour
Esta função retorna um número inteiro entre 0 e 23, que representa o valor das horas
de uma determinada hora completa. Sintaxe:
Hour(time)
Onde: Time é um argumento obrigatório. Você pode usar qualquer tipo de
combinação que possa representar uma hora, seja essa uma expressão numérica ou
uma expressão de seqüência.
Minute
Esta função retorna um número inteiro entre 0 e 59, que representa os minutos de
uma hora completa. Sintaxe:
Minute(time)
Month
Esta função retorna um número inteiro entre 1 a 12, que representa o mês de uma
data completa. Sintaxe:
Month(date)
Second
Esta função retorna um número inteiro entre 0 e 59, que representa os segundos de
uma hora completa. Sintaxe:
Second(time)
Year
Esta função retorna um número inteiro entre 100 a 9999, que representa o ano de
uma data completa. Sintaxe:
Year(date)

Funções de Conversão
Cbool - Converte uma expressão numérica ou String em um valor booleano.

Cbool(expression)
Onde: Expression é um argumento obrigatório que pode ser qualquer seqüência ou
expressão numérica válida.
Cbyte - Converte uma expressão numérica ou String em um valor do tipo Byte.

Sintaxe:
Cbyte(expression)
Onde: Expression é um argumento obrigatório, deve ser um número inteiro ue varie
entre 0 a 255.
Ccur - Converte uma expressão numérica ou String em um valor do tipo Currency.

Ccur(expression)
Onde: Expression é um argumento obrigatório. Você deve usar um tipo de dados com
intervalo entre -922.337.203.685.477,5808 a 922.337.203.685.477,5807.
Cdate - Converte uma expressão numérica ou String em um valor do tipo Date.

Cdate(expression)
Onde: Expression é um argumento obrigatório, que pode ser qualquer expressão de
data válida.
Cdbl - Converte uma expressão numérica ou String em um valo tipo Double.

CDbl(expression)
Onde: Expression é um argumento obrigatório que deve conter tipos de dados num
intervalo de -1,79769313486231E308 a 4,94065645841247E-324 para valores
negativos; 4,94065645841247E-324 a 1,19769313486232E308 para valores positivos.
Cint - Converte uma expressão numérica ou String em um valor Inteiro.

Cint(expression)
Onde: Expression é um argumento obrigatório, você deve usar um número inteiro no
intervalo de –32.768 a 32.767.
Clng - Converte uma expressão numérica ou String em um valor do tipo Long.

CLng(expression)
Onde: Expression é um argumento obrigatório, que deve ser um número inteiro no
intervalo de –2.147.483.648 a 2.147.483.647.
CSng(expression) - Converte uma expressão numérica ou String em valor Single.

Cdec (expression) - Converte uma expressão numérica ou String em valor Decimal.
CStr(expression) - Converte uma expressão numérica em um valor String.
Cvar (expression) - Converte uma expressão numérica ou String em um valor Variant.

Funções para Cálculos Matemáticos
Abs
Esta é uma função que retorna um valor do mesmo tipo que é passado para ele
especificando o valor absoluto de um número. Sintaxe:
Abs(number)
Onde: Number é obrigatório e pode ser qualquer expressão numérica válida.
Rnd
Esta é uma função que retorna um Single que contém um número aleatório. Sintaxe:
Rnd([number])
Onde: Number é um Single opcional ou qualquer expressão numérica válida.
Sng
Esta é uma função que retorna um Variant Integer que indica o sinal de um Número.
Sgn(number)
Onde: Number é um argumento obrigatório que pode ser qualquer expressão
numérica válida.
Sqr
Esta é uma função que retorna um Double que especifica a raiz quadrada de um
número. Sintaxe:
Sqr(number)
Onde: Number é um Double obrigatório ou qualquer expressão numérica válida maior
ou igual a zero.
Funções de Planilha
Várias funções que você utiliza em suas planilhas no Excel 2013 possuem
correspondentes no VBA, porém, isto nem sempre acontece. Você pode utilizar as
funções de planilha do Excel 2013, dentro do VBA. Para isto basta seguir o exemplo
abaixo, modificando a funções para a que você deseja utilizar:
Sub SomarNumeros()
Dim TotalSoma as Double
TotalSoma = WorksheetFunction.Sum(Range(“A1:A10”))
MsgBox TotalSoma
End Sub
Como você pode notar o nome da função, depois do objeto WorkSheetFunction, deve
aparecer em inglês.

Quadros de Diálogo
Para facilitar a criação de programas que interagem com o usuário, solicitando
a inserção de informações ou simplesmente confirmar ou cancelar uma determinada
operação, o VBA coloca a sua disposição algumas opções.
Uma delas é através da criação de formulários, como veremos mais adiante,

nesta apostila. Os formulários permitem a criação de interface mais sofisticada e
personalizada, porém exigem mais tempo de trabalho para sua confecção e
programação.
Neste capítulo, iremos apresentar uma alternativa mais simples para este tipo
de interação, que são os Quadros de Diálogo. O VBA possui dois tipos de quadro de
diálogo: a Caixa de Mensagem (MsgBox) e Caixa de Entrada (InputBox).
Caixa de Mensagem (MsgBox)
É uma caixa predefinida que exibe uma mensagem de aviso ao usuário. Você
pode exibir esta caixa de mensagem utilizando a função MsgBox. Através desta função
o usuário poderá se comunicar por meio de botões. É simples uma mensagem
aparecerá na tela e o usuário poderá confirmar ou cancelar uma determinada
operação.
Sintaxe da função:
MsgBox(prompt [,buttons] [,title])
Onde:
• Prompt é uma expressão de seqüência obrigatória, exibida como
mensagem na caixa.
• Buttons é uma expressão numérica opcional, que é a soma de valores
que irá determinar: o tipo do botão, o estilo do ícone, a identidade do
botão padrão e a modalidade da caixa de mensagem. Se este
argumento for omitido, o parâmetro para Buttons será 0. (Veja a seguir,
nas tabelas, algumas definições para este argumento).
• Title é uma expressão de seqüência opcional exibida na barra de título
da caixa de diálogo.
Tabela 1 - Tipo do botão

Valor do Parâmetro / Constante do VBA Descrição
0 (VbOKOnly) Exibe somente o botão OK
1 (VbOKCancel) Exibe os botões OK e Cancelar
2 (VbAbortRetryIgnore) Exibe os botões Abortar, Repetir e Ignorar
3 (VbYesNoCancel) Exibe os botões Sim, Não e Cancelar
4 (VbYesNo) Exibe os botões Sim ou Não
5 (VbRetryCancel) Exibe os botões Repetir e Cancelar

Tabela 2 – Estilo do ícone
Valor do Parâmetro / Constante do VBA Descrição
16 (vbCritical) Exibe o ícone Mensagem crítica
32 (vbQuestion) Exibe o ícone Consulta de aviso
48 (vbExclamation) Exibe o ícone Mensagem de aviso
64 (vbInformation) Exibe o ícone Mensagem de informação
Tabela 3 – Identidade do botão padrão

Valor do Parâmetro / Constante do VBA Padrão
0 (vbDefaultButton1) O primeiro botão é o padrão
256 (vbDefaultButton2) O Segundo botão é o padrão
512 (vbDefaultButton3) O terceiro botão é o padrão
768 (vbDefaultButton4) O quarto botão é o padrão
Se você deseja uma caixa de mensagem contendo os botões Sim e Não, o ícone de
interrogação e com o primeiro botão como padrão, o valor do argumento seria:
4 + 32 + 0 = 36 ou VbYesNo + VbQuestion + VbDefaultButton1
O primeiro grupo de valores (0 a 5) descreve o número e o tipo de botões exibidos na

caixa de diálogo, o Segundo grupo (16,32,48,64) define o estilo do ícone, o terceiro
grupo (0,256,512,768) define qual o botão é o padrão.
Por fim, como MsgBox é uma função, você deve associá-la a uma variável de retorno.
Os valores de retorno desta função são:
Tabela 4 – Valores de retorno da função MsgBox

Valor do Retorno / Constante do VBA Ação
1 (VbOK) Botão OK foi pressionado
2 (VbCancel Botão Cancel foi pressionado
3 (VbAbort) Botão Abort foi pressionado
4 (VbRetry) Botão Retry foi pressionado
5 (VbIgnore) Botão Ignore foi pressionado
6 (VbYes) Botão Yes foi pressionado
7 (VbNo) Botão No foi pressionado
Caixa de Entrada (InputBox)
Esta função se diferencia da função anterior porque ela não serve somente
como uma caixa de mensagem e sim como uma caixa de entrada. Com esta função, o
usuário pode inserir um dado na caixa, que retornará uma String com o conteúdo dela.
Sintaxe:
InputBox(Prompt[,title][,default][,xpos][,ypos][,helplife ,context])

Onde:
• Prompt é uma expressão de seqüência exibida como aviso na caixa de
diálogo;
• Title é uma expressão de seqüência opcional, que exibe o título da caixa
de diálogo;
• Default é uma expressão de seqüência opcional, que é exibida na caixa
de texto como resposta padrão se nenhuma entrada for oferecida;
• Xpos é uma expressão numérica opcional que determina, em Twips, a
distância horizontal da borda esquerda da caixa de diálogo em relação à
borda esquerda da tela. Se for omitida, a caixa de diálogo é centralizada
horizontalmente;
• Ypos é uma expressão numérica opcional que determina, em Twips, a
distância vertical da borda superior da caixa de diálogo em relação ao
alto da tela. Se Ypos for omitida, a caixa de diálogo será verticalmente
centralizada na tela.
• Helpfile é uma expressão de seqüência opcional que identifica um
arquivo de ajuda.
• Context é uma expressão numérica atribuída ao tópico da Ajuda
apropriado por seu autor. Se o Context for fornecido, o argumento
Helpfile também deverá sê-lo.
Exemplo
Abaixo um exemplo da utilização dos dois Quadro de Diálogo, em uma rotina

que solicita ao usuário o valor do salário, testa se o usuário cancelou a operação (o
comando IF será visto no próximo capítulo), depois efetua os cálculos através de uma
função personalizada, chamada CalcINSS, e por fim exibe uma caixa de mensagem com
o resultado.
Sub RodaINSS()
Dim curSalario As Currency

Dim txtSalario As String
Dim curDescINSS As Currency
txtSalario = InputBox("Digite o Salário desejado", "Informação Solicitada")
'.......................... Verifica se usuário cancelou

If txtSalario = "" Then
MsgBox "Operação cancelada pelo usuário", _
vbInformation, "Informação do Sistema"
Exit Sub
End If
curDescINSS = CalcINSS(curSalario, 3000)

MsgBox "O salário digitado é: " & curSalario & Chr(13) & _
"O desconto de INSS e: " & curDescINSS
End Sub

Os Principais Objetos do Excel 2013
O Excel 2013 tem uma abordagem, para programação em VBA, onde seus
elementos, como pastas de trabalhos, planilhas, células e outros elementos do Excel,
são organizados em uma estrutura de elementos hierarquizada, o Modelo de Objetos
do Excel, onde existem os elementos de mais alto nível dentro e, partindo destes,
chegamos aos outros elementos.
Para podermos trabalhar de maneira eficiente com o VBA dentro do Excel 2013,
devemos ter uma noção desta organização, assim como uma pequena noção de alguns
termos utilizados em Programação Orientada a Objetos(OOP).
Para este nosso curso, iremos fazer algumas simplificações dos conceitos de
OOP, para que possamos, sem aprofundamento em detalhes teóricos, obtermos os
conhecimentos necessários para desenvolvermos nossos procedimentos.
O que são Objetos, Propriedades, Métodos e Eventos
Objetos
No dia a dia, todos já estamos acostumados com o termo objeto, porém, dento
do VBA, este termo ganha importância e um conceito um pouco mais amplo, em
relação ao que já estamos acostumados.
Dentro do Modelo de Objetos do Excel, tudo é um objeto, o próprio Excel, a sua

pasta de trabalho, as planilhas desta pasta de trabalho, cada célula, de cada uma das
planilhas, etc. Na programação em VBA, estarmos, quase sempre manipulando um
destes objetos acima, criando códigos que alteram estes objetos.
Propriedades
Todos os Objetos de programação, assim como os da vida real, possuem
características. Estas características dos objetos, no VBA, serão chamadas de
Propriedades.
O objetos do Excel 2013, como as planilhas e células, possuem Propriedades

(características), que podem ser alteradas e outras que somente podemos consultar e
utilizar o valor. Por exemplo, podemos alterar o valor de uma célula ( que é a
propriedade Value, do objeto Range), ou utilizar um comando MsgBox, para exibir seu
valor em uma caixa de mensagem. Dizemos que a Propriedade Value, do Objeto
Range, é uma propriedade do tipo leitura e gravação, pois podemos alterá-la.
Toda célula, também possuem um endereço, com A1, F10, G150, etc. Nós
podemos, através do VBA, exibir uma caixa de mensagem, onde apareça o endereço
da célula que está atualmente selecianada, porém não podemos trocar ó endereço de
uma célula, fazendo com que a célula A1, passe a ter o endereço B1. Dizemos que a
propriedade Address, do objeto Range, é somente leitura, pois podemos consultá-la,
para descobrir seu valor, mas não podemos alterá-la.

Métodos
Todos os objetos que iremos estudar possuem métodos. Os métodos podem
ser entendidos como comandos, que executam alguma ação com o objeto a que ele
pertence. Os métodos são, na verdade, procedimentos que foram pré-escritos na
linguagem, para tornar mais fácil a programação. Por exemplo, você pode usar o
método Clear, do Objeto Range, para limpar o conteúdo e a formatação de uma célula.
Eventos
Os eventos dos objetos são uma parte muito importante dentro do VBA, pois é
nestes eventos que iremos escrever boa parte do código em VBA para automatizar
suas pastas de trabalho.
Podemos entender os eventos como ações que ocorrem com os objetos,

resultantes do trabalho do usuário com estes. Por exemplo, quando um usuário
seleciona uma planilha, é imediatamente disparado o evento “Ao Selecionar”, desta
planilha. Caso tenhamos escrito algum código em VBA, para este evento, da planilha
selecionada, ele será executado neste instante. Também podemos programar o
evento “Ao Abrir”, do objeto Pasta de trabalho (que representa o próprio arquivo do
Excel). Caso isto seja feito, toda vez em que este arquivo do Excel for aberto, o código
escrito será executado.
A Hierarquia de Objetos no Excel 2013
Como citamos, no início deste capítulo, o Excel organiza seus objetos de

maneira hierárquica, dentro do que é chamado de Modelo de Objetos do Excel. Abaixo
um pequeno resumo desta estrutura:
Objeto Application Representa o próprio aplicativo Excel
Objeto WorkBooks Representa os arquivo, ou seja, as Pastas de Trabalho
Objeto WorkSheets Representa as Planilhas da Pasta de Trabalho.
Objeto Range Representa uma célula ou um grupo de células
Na representação acima temos, no topo o objeto Application, que representa o

próprio aplicativo Excel, ele contem todos os outros objetos, ou seja, cada pasta de
trabalho que você abre, é um objeto WorkBook, dento do objeto Application. Cada
pasta de trabalho aberta tem suas planilhas, que são objetos WorkSheets. Cada Célula
é um Objeto Range, que está dentro de um objeto WorkSheet, dentro de um Objeto
WorkBook, que pertence ao Application. A instrução abaixo altera o valor de A1:
Application.Workbooks("Orçamento.xlsm").Worksheets("Dados").Range("A1").Value = 20
Normalmente não utilizamos está expressão completa, preferindo, tomados os

devidos cuidados, utilizar a forma abreviada, que teria o mesmo efeito:
Range("A1").Value = 20
As duas expressões geram o mesmo resultado.

O objeto Application
Como dito anteriormente, este objeto representa o próprio Excel, está no topo
da hierarquia do Modelo de Objetos do Excel. Utilizando este objeto podemos alterar
diversos recursos, que tornam o nosso código bem mais eficiente a profissional.
Propriedades
ActiveCell
Retorna um objeto Range que representa a célula ativa na janela ativa (a janela visível)
ou na janela especificada. Se a janela não estiver exibindo uma planilha, esta
propriedade falhará. Somente leitura.
ActiveSheet
Retorna um objeto que representa a planilha ativa (a planilha visível) na pasta de
trabalho ativa ou na janela ou pasta de trabalho especificada. Retorna Nothing se não
houver planilha ativa. Somente leitura.
ActiveWorkbook
Retorna um objeto Workbook representando a pasta de trabalho da janela ativa (a
janela visível). Somente leitura. Retorna Nothing se não houver janelas abertas.
DisplayAlerts
O valor padrão é True. Defina essa propriedade como False se não quiser ser
perturbado por solicitações e mensagens de alertas enquanto uma macro está em
execução; sempre que uma mensagem exige uma resposta, o Microsoft Excel escolhe
a reposta padrão.
Visible
Esta propriedade, quando é definida como FALSE, oculta a tela principal do Excel. Isto
pode ser útil quando você quer exibir um formulário personalizado.
Métodos
Calculate
Calcula todas as pastas de trabalho abertas, uma planilha específica em uma pasta de
trabalho ou um intervalo especificado de células em uma planilha.
GetOpenFileName
Exibe a caixa de diálogo Abrir padrão e obtém um nome de arquivo do usuário sem
realmente abrir nenhum arquivo.
Sintaxe: expressão.GetOpenFilename(FileFilter, FilterIndex, Title, ButtonText, MultiSelect)
GetSaveAsFilename
Exibe a caixa de diálogo Salvar como padrão e obtém um nome de arquivo do usuário
sem realmente salvar nenhum arquivo.
Sintaxe: expressão.GetSaveAsFilename(InitialFilename, FileFilter, FilterIndex, Title, ButtonText)

O objeto WorkBooks
Propriedades
ActiveCell
Retorna um objeto Range que representa a célula ativa na janela ativa (a janela visível)
ou na janela especificada. Se a janela não estiver exibindo uma planilha, esta
propriedade falhará. Somente leitura.
Password
Retorna ou define a senha que deve ser fornecida para abrir a pasta de trabalho
especificada. String de leitura/gravação
Saved
True se nenhuma alteração tiver sido feita na pasta de trabalho especificada desde a
última vez em que foi salva. Boolean de leitura/gravação.
Path
Retorna um valor String que representa o caminho completo para a pasta de trabalho,
excluindo o separador final e o nome do arquivo
Count
Retorna um valor Long que representa o número de objetos na coleção
Métodos
Calculate
Calcula todas as pastas de trabalho abertas, uma planilha específica em uma pasta de
trabalho ou um intervalo especificado de células em uma planilha.
Close
Fecha o objeto
Save
Salva alterações na pasta de trabalho especificada.
SaveAs
Salva alterações feitas no gráfico ou na planilha em um arquivo diferente.
Sintaxe:
expressão.SaveAs(FileName, FileFormat, Password, WriteResPassword, ReadOnlyRecommended,
CreateBackup, AddToMru, TextCodepage, TextVisualLayout, Local)

O objeto WorkSheet
Propriedades
Count
Retorna um valor Long que representa o número de planilhas na coleção.
Name
Retorna ou define um valor String que representa o nome da planilha.
Visible
Retorna ou define um valor XlSheetVisibility que determina se a planilha será visível.
xlSheetVisible -1 Exibe a planilha
xlSheetHidden 0 Oculta a planilha que o usuário pode reexibir através do menu.
xlSheetVeryHidden 2 Oculta o objeto para que a única maneira de torná-lo novamente
visível seja definindo esta propriedade como True (o usuário
não pode tornar o objeto visível).
Exemplo
Sub EscondePlanilha()
ActiveSheet.Visible = xlSheetHidden
End Sub
Métodos
Add
Cria uma nova planilha. A nova planilha se torna a ativa.
Sintaxe: expressão.Add(Before, After, Count)
Nome Obrigatório/Opcional Tipo de Descrição

dados
Before Opcional Variant Um objeto que especifica a planilha antes da qual a nova
planilha será adicionada.
After Opcional Variant Um objeto que especifica a planilha depois da qual a
nova planilha será adicionada.
Count Opcional Variant O número de planilhas a serem adicionadas. O valor
padrão é um.
Exemplo
Sub CriaPlanilha()
Worksheets.Add After:=Worksheets(Worksheets.Count)
ActiveSheet.Name = MonthName(InputBox(“Informe o nome da planilha”))
End Sub
Delete
Exclui o objeto.

O objeto Range
Propriedades
Address
Retorna um valor String que representa a referência de intervalo no idioma da macro.
Exemplo
Set mc = Worksheets("Sheet1").Cells(1, 1)
MsgBox mc.Address() ' Retorna $A$1
MsgBox mc.Address(RowAbsolute:=False) ' Retorna $A1
MsgBox mc.Address(ReferenceStyle:=xlR1C1) ' Retorna R1C1
Cells
Retorna um objeto Range que representa as células no intervalo especificado.
Exemplo
Este exemplo define como itálico o estilo da fonte para as células A1:C5
Range(Cells(1, 1), Cells(5, 3)).Font.Italic = True
End
Retorna um objeto Range representando a célula no fim da região que contém o
intervalo de origem. Equivalente a pressionar END+SETA PARA CIMA, END+SETA PARA
BAIXO, END+SETA PARA A ESQUERDA ou END+SETA PARA A DIREITA.
Exemplo
Este exemplo seleciona a célula no topo da coluna B na região que contém a célula B4.
Range("B4").End(xlUp).Select
Este exemplo seleciona a célula no topo da coluna B na região que contém a célula B4.
Range("B4").End(xlUp).Select
Outras opções:
(xltoRight) Para a direita
(xltoLeft) Para a esquerda
Font
Altera os atributos de fonte (nome, tamanho, cor, etc) de uma célula.
Bold True se a fonte estiver em negrito. Variant de leitura/gravação

Retorna ou define a cor principal do objeto, como mostra a tabela da seção de
Color
comentários. Use a função RGB para criar um valor de cor. Variant de leitura/gravação
ColorIndex Retorna ou define um valor Variant que representa a cor da borda.
FontStyle Retorna ou define o estilo da fonte. String de leitura/gravação
Italic True se o estilo da fonte for itálico. Boolean de leitura/gravação
Name Retorna ou define um valor Variant que representa o nome do objeto.
Size Leitura/gravação
TintAndShade Leitura/gravação
Retorna ou define o tipo de sublinhado aplicado à fonte. Pode ser uma das constantes
Underline
XlUnderlineStyle a seguir. Variant de leitura/gravação.

Exemplo
Activecell.font.Bold = True 'Coloca Negrito
Activecell.font.Italic = False ‘Retira o Itálico
Activecell.font.ColorIndex = 5 ‘Altera o cor da fonte
Activecell.font. Name = "Arial" ‘Altera o tipo da fonte
Value Retorna ou define um valor Variant que representa o valor do intervalo especificado
Métodos
Clear
Limpa o intervalo inteiro.
Copy
Copia o intervalo para o intervalo especificado ou para a Área de Transferência.
Cut
Recorta o intervalo para a Área de Transferência ou o cola em um local especificado
Delete
Exclui o intevalo.
Insert
Insere uma célula ou um intervalo de células na planilha ou folha de macro e desloca
as outras células para liberar espaço.

CAPÍTULO 6
Controles de Fluxo e de Repetição
 IF...Then...Else...
 Select Case...End Select
 Trabalhando com Loops para repetir o Código
 Do...Loop...
 For...Next...
 For Each...Next...
 With...End Whit

Trabalhando com Controles de Fluxo
Para que você possa entender melhor o funcionamento dos controles de fluxo,
os analise da seguinte forma: eles são instruções executáveis que iniciam uma ação.
Essas instruções ou esses controles de fluxos podem executar um método ou

uma função. Além de executar Loops ou Desvios pelos blocos de códigos, geralmente
os controles de fluxo ou instruções podem conter operadores matemáticos ou
operadores condicionais. Vamos aprender os controles de fluxos existentes na
linguagem VBA e como utilizá-los.
If...Then...Else
Este controle de fluxo executa condicionalmente um grupo de instruções
dependendo do valor de uma expressão. A sintaxe deste controle:
If <condição1> Then
<bloco de comandos>
ElseIf <condição2> Then
<bloco de comandos>
Else
<bloco de comandos>
End If
Este controle faz com que as <condições> sejam avaliadas como True ou False, para
que o fluxo do programa siga um caminho ou outro.
Simplificando, se a <condição1> for verdadeira, o bloco de comandos após o

primeiro Then será executado; mas, caso a <condição1> não seja verdadeira e uma
<condição2> for verdadeira, os códigos após a instrução ElseIf serão executados e, se
esta novamente não for verdadeira, por exclusão, o bloco de comandos após o Else
será executado. Note que é necessário finalizar uma estrutura If…Then…Else sempre
com uma instrução End If, ou um erro ocorrerá.
Select Case...End Select
Este controle, analogamente ao comando If, também é um comando

condicional, porém as instruções podem ser organizadas em grupos, dependendo do
valor de uma expressão, tornando – para muitos – a leitura do código mais “limpa”.
Veja, a seguir, a sintaxe deste controle:
Select Case <expressão>

Case <valor1>
<Bloco de comandos>
Case <valor2>
<Bloco de comandos>
Case Else
<Bloco de comandos>
End Select

Neste caso, o <valor> também poderá ser:
expressão To expressão
ou
IS operador expressão
E você ainda poderá separá-las por vírgula. Exemplos:
Case 2 To 5, 8 To 10, 12, 14

Case IS >= 0
Simplificando, a instrução Select Case funciona da seguinte forma: a instrução

Select Case avalia um determinado argumento, que é passado para o procedimento. É
importante frisar que cada instrução Case pode conter mais de um valor, um intervalo
de valores ou até mesmo uma combinação de valores e operadores de comparação
(conforme mostrado acima). Já a instrução Case Else, que é opcional, somente será
executada caso a instrução Select Case não combine com nenhum valor das instruções
Case.
Trabalhando com Loops para Repetir o Código

As instruções de Loop permitem a execução de um grupo de instruções que vão
se repetindo. Alguns Loops vão repetindo suas instruções até achar uma condição que
seja True, outros repetem até achar uma condição que seja False, e temos também
aqueles que repetem suas instruções um determinado número de vezes.
Veja a seguir os comandos de repetição que o VBA nos oferece:
Do...Loop
Este comando repete suas instruções até achar uma condição que seja True. Em
uma instrução Do...Loop você pode usar duas palavras-chaves: While ou Until, e cada
uma destas palavras você pode utilizar de duas formas:
• Você pode usar a palavra-chave While para verificar uma condição em
uma instrução Do...Loop, antes de entrar no Loop ou depois do Loop ser
executado pelo menos uma vez;
• Do mesmo modo, você pode usar a palavra-chave Until para verificar
uma condição em uma instrução Do...Loop, antes de entrar no Loop ou
pode verificá-la depois do Loop ser executado pelo menos uma vez.
A pergunta que você deve estar se fazendo agora é: então qual a diferença
entre elas? Nós respondemos: o funcionamento entre estas duas palavras-chaves é
semelhante, mas a diferença básica é que a instrução Do Until, repete o Loop
enquanto a condição for Falsa, já o Do While repete o Loop enquanto a condição for
Verdadeira. (Loop quer dizer Laço).

Observe a sintaxe deste controle para verificar a condição antes da entrada do Loop:
Do [While ou Until] <expressão>

<Bloco de comandos>
[Exit Do]
Loop
Veja agora a sintaxe deste controle para verificar a condição depois do Loop, se
executado pelo menos uma vez:
Do
<Bloco de comandos>
[Exit Do]
Loop [While ou Until] <expressão>
O comando Exit Do, em ambos os casos, força a saída da estrutura.
For…Next
Esta instrução repete um bloco de instruções um número específico de vezes. A
sintaxe deste comando:
For <variável> = <expressão> TO <expressão> [Step expressão]

<Bloco de comandos>
[Exit For]
Next [variável]
O parâmetro Step é opcional e significa o intervalo (ou passo) com o qual a

“contagem” da variável será feito. O valor padrão de Step é 1, caso você não
especifique nenhum valor. Poderá ser usado qualquer valor, seja ele negativo ou
positivo. Assim, no exemplo abaixo, o bloco de instruções acontecerá 5 vezes:
For I = 1 to 5
<comandos...>
Next I
Já neste outro exemplo, será feita uma contagem “regressiva” de 2 em 2:
For I = 10 to 0 Step -2
<comandos...>
Next I
O comando Exit For força a saída desta estrutura, semelhante ao Exit Do.
For Each…Next
Esta instrução repete um grupo de instruções para cada objeto em uma coleção. A
sintaxe deste comando é:
For Each <elemento> in <objeto>

<Bloco de comandos>
[Exit For]
Next
O comando Exit For nesta instrução também força a saída de uma estrutura.

With...End With
Esta instrução permite-nos manipular uma série de parâmetros do mesmo objeto. As
instruções With fazem seus procedimentos ser executados com mais rapidez e ajudam
a evitar digitação repetitiva. A sintaxe deste comando é:
With <objeto>
.<parâmetro 1>
.<parâmetro 2>
.<parâmetro 3>
End With
Antes de cada parâmetro ou método é obrigatório o uso do ponto.
With Selection.Font
.Name = "Arial Black"
.Size = 16
.Italic = True
.ColorIndex = 5
End With
Observe o exemplo acima, que formata as células selecionadas com o a fonte Arial
Black, tamanho 16, em itálico e na cor Azul.

CAPÍTULO 7
Depuração e Tratamento de Erros
 Depuração de erros
 Adicionando Inspeção de variável
 Inspeção de verificação imediata
 Depurando o código do seu programa passo a passo

Depuração de Erros
Depuração é um processo que se utiliza para procurar e resolver erros no
código do Visual Basic. Existem três tipos de erros na programação:
• Erros em Tempo de Compilação: Ocorre quando o resultado de um
código é construído incorretamente;
• Erros em Tempo de Execução: Ocorre depois que você executa o
aplicativo;
• Erros Lógicos: Ocorre quando o aplicativo não é executado e apresenta
resultado diferente do esperado.
Para que você possa corrigir esses erros, o VBE oferece:

• Checagem Automática de Sintaxe: Quando você escreve um comando
errado, o VBE o alerta, destacando a linha, na janela Módulo;
• Ferramentas de Depuração: Você pode analisar passo-a-passo seu
código, até descobrir o erro.
Adicionando Inspeção de Variáveis

Através do menu Depurar, opção Adicionar Inspeção de Variáveis, você poderá
inspecionar variáveis através de uma expressão de inspeção de variáveis.
• Digite, na caixa Expressão, o nome da variável a ser observada;

• No quadro Contexto, defina, durante a execução, de qual Procedure e
Módulo você deseja observar a variável;
• No quadro Tipo de inspeção de variáveis, você pode definir se deseja
observar a variável até o fim do programa ou interromper a execução
do programa quando esta atingir um determinado valor;
• Clique no botão OK e a variável é inserida na janela de Inspeção de
Variáveis.
Inspeção de Variáveis Rápida

Para visualizar o valor momentâneo de uma variável, você também pode
utilizar a opção Inspeção de variável rápida do menu Depurar. Para isso:
1. Destaque o nome da variável, na janela Módulo;
2. No menu Depurar, dique na opção Inspeção de variáveis rápida;

3. Aparece o quadro Inspeção de variáveis rápida, que mostra o valor da variável
naquele momento:
Janela de Verificação Imediata

Nesta janela você pode digitar ou colar uma determinada linha de código e
pressionar a tecla Enter. Com isto você estará executando a linha de código nesta
própria janela e automaticamente você poderá verificar seu valor. Para acessá-la,
selecione a opção Janela Verificação Imediata no menu Exibir do VBE. Veja abaixo a
janela de Verificação Imediata.
Depurando o Código do seu Programa Passo a Passo

Você pode depurar o código do seu programa passo a passo para identificar
onde está ocorrendo um erro. Com isto, você vai poder ter certeza se cada tinha do
código está produzindo os resultados esperados.
Para realizar a depuração:
1. Escolha a linha de código que terá um break point, ou seja, uma interrupção, a
partir do qual o programa será visto passo a passo;
2. Clique sobre esta linha e depois selecione, no menu Depurar, o comando
Ativar/Desativar pontos de interrupção;
3. A linha que contém a interrupção ficará selecionada em vermelho escuro.
4. Execute o programa.
5. Quando o programa encontrar a interrupção, automaticamente irá interromper
a execução e mostrar a janela de Módulo que contém a interrupção (break
point)
6. Continue passo a passo, clicando no ícone Depuração total ou teclando F8.Esta
operação irá verificar inclusive cada linha de código das rotinas chamadas pela
procedure estudada. Se desejar, clique no ícone Depuração Parcial ou tecle
Shift + F8 para verificar somente as linhas da procedure estudada, sem entrar
em nenhuma rotina chamada por esta procedure;
NOTA: Para depurar passo a passo todo o programa, basta, sem definir nenhum ponto
de interrupção, posicionar o cursor dentro da rotina desejada e pressionar F8. A cada
vez que esta tecla for pressionada será executada cada linha do seu código, cujo
resultado poderá ser observado através da janela do Microsoft Excel. Neste caso,

aconselha-se que tanto a janela do Microsoft Excel quanto a janela do VBE estejam
visíveis na tela. Para isto, disponha as mesmas sob forma “lado a lado”.
Tratamento de Erros
Mesmo depois de depurar todo o seu código, ainda sim podem ocorrer erros
em suas aplicações em VBA. Veja, por exemplo, o código abaixo:
Sub CalcularRaiz2
Dim varValor1 As Variant
varValor1 = InputBox(“Digite um Valor”)
ActiveCell.Value = Sqr(varValor1)
End Sub
Não existe erro de sintaxe no código acima. Se você executá-lo em uma planilha e
digitar 25 na caixa de diálogo, a macro colocará o número 5 na célula ativa.
Porém, se você digitar -5, a macro retornará um erro. Existe uma série de situações em
que esta macro irá gerar um erro.
O que é tratamento de erros

Para evitar que suas macros gerem erro você poderia colocar um série de
testes, dentro de seu código, para tentar evitar todas as situações possíveis. Além de
trabalhoso, este procedimento não garante a execução perfeita de sua macro, pois
sempre pode ter uma situação que não foi prevista em seu código.
A Instrução “On Error”
Para prevenir erros inesperados, existe a instrução “On Error”, que executa
uma ação quando um erro inesperado acontece. Esta instrução pode ser utilizada de
duas formas:
1) Quando se quer escrever códigos para serem executados em caso de erro.

Sub Teste()
On Error GoTo Label
.
.
Exit Sub
Label:
Comandos a serem executados
End Sub()
2) Quando você deseja que o código continue a ser executado apesar do erro.
Sub Teste()
.
On Error Resume Next
.
.
.
End Sub()

CAPÍTULO 8
Controles e Formulários no Excel 2013
 Trabalhando com controles no Excel
 Controle de caixa de ferramentas
 Caixa de seleção
 Caixa de combinação
 Botão de comando
 Rótulo
 Botão de opção
 Caixa de Texto
 Botão de alternância
 Imagem
 Mais controles

Trabalhando com Controles no Excel
O Excel fornece a você vários tipos de controles gráficos, que podem ser
utilizados como links, apontando normalmente para rotinas desenvolvidas com o VBA.
Estes controles servem para conter todo o tipo de informações de um determinado
formulário, relatório ou planilha e podem ser manipulados através de código feito no
VBA. Você tem acesso a esses controles através da Sessão Controles da Aba
Desenvolvedor.
Através dos códigos do VBA, você pode alterar propriedades, chamar métodos
ou responder a algum evento. Para determinar as propriedades de cada controle que
você está usando, selecione o controle e clique no botão Propriedades da Sessão
Controles .
Nesta caixa você encontra duas fichas que dizem respeito às propriedades do
controle selecionado:
• Alfabético - Propriedades em Ordem Alfabética: São todas as
propriedades do controle, apresentadas em ordem alfabética.
• Categorizado – Propriedades por Categoria: São todas as propriedades
do controle, apresentadas por categorias, para facilitar a procura. Por

exemplo, na categoria Aparência estão listadas somente as
propriedades que dizem respeito à aparência do controle selecionado.
Existem algumas propriedades que são comuns a todos os controles. Por

exemplo:
• Legenda (Caption): Título do objeto;
• Cor do Fundo (Backcolor): Cor do fundo do objeto;
• Nome (Name): Identificador para uso na programação;
• Altura (Height): Altura do objeto;
• Largura (Width): Largura do objeto;
• Esquerda (Left): Coordenada esquerda do objeto;
• Visível (Visible): Define se o controle estará visível ou não para o
usuário.
Controles da Caixa de Ferramentas
Caixa de Seleção
Este controle é usado para exibir um valor Sim ou Não.
Entre as propriedades específicas deste objeto podemos citar:
• Visível: Se for igual a Sim, a caixa de seleção estará ativa na tela, se for
Não, estará desabilitada.
Caixa de Combinação
Este controle é uma caixa de texto e uma caixa de listagem combinados. Com
ele, o usuário pode digitar diretamente na caixa ou selecionar o valor da lista.
Entre as propriedades específicas deste controle podemos citar:
• Origem do Controle: Determina de onde os dados da caixa de
combinação se originarão.
• Linhas da Lista: Determina o número de linhas que a caixa de
combinação exibirá.
Botão de Comando
Os botões de comando são usados para iniciar uma ação ou um conjunto de
ações.
• Figura: Define uma imagem que será mostrada no botão;
• Padrão: Indica se o botão é o padrão. Se for igual a Sim, toda vez que o
usuário pressionar a tecla Enter, equivalerá a execução do evento Ao
Clicar.
Rótulo
Os rótulos servem para exibir textos, legendas ou instruções.
• Alinhamento do Texto: Modifica o alinhamento do texto inserido no
controle;
• Tamanho da Fonte: Determina o tamanho da fonte;
• Estilo da Borda: Determina o estilo da borda do controle.

Botão de Opção
Este controle é usado para exibir um valor Sim ou Não de um grupo de opções.
Entre as propriedades específicas deste botão podemos citar:
• Visível: Se for igual a Não, o controle é oculto no formulário até que o
usuário execute uma determinada tarefa especificada pelos códigos do
VBA, para que ele apareça.
Caixa de Texto
Este controle é usado para exibir valores de uma origem do registro, ou para
aceitar entradas de dados de um usuário.
• Origem do Controle: Determina a origem dos dados do controle;
• Alinhamento: Determina o alinhamento do texto inserido;
• Barras de Rolagem: Determina se o controle terá barras de rolagem ou
não.
Botão de Alternância
Estes botões são utilizados para exibir um valor Sim ou Não. Se ele estiver
pressionado, um determinado registro é verdadeiro, se não estiver pressionado é
falso.
• Legenda: Define o título do botão;
• Figura: Define uma figura para o botão.
Imagem
Com este controle você pode inserir imagens ou molduras de objetos.
• Largura da Borda: Define a largura da borda das molduras;
• Estilo da Borda: Define o estilo das bordas da moldura.
Mais Controles
Use este botão para ter acesso a mais de 100 controles diversos, melhorando
assim a interação do usuário com o aplicativo. Existem vários tipos de controles, e o
calendário é um exemplo destes controles.

CAPÍTULO 9
Formulários no VBA
 Trabalhando com formulários no VBA
 Criando formulários
 Construindo o código do formulário

Trabalhando com Formulários no VBA
Podemos dizer que formulários são como caixas de diálogo personalizadas, que
servem para interagir com o usuário, tornando mais fácil e dinâmico o uso do
aplicativo.
Criando Formulários
Para criar um formulário, siga os passos abaixo:
1. Entre no VBE;
2. No menu Inserir, dique na opção UserForm. Um formulário vazio, com um
tamanho padrão, aparece na tela:
3. Automaticamente, uma caixa de ferramentas também aparece na tela para que
você possa começar a construir o formulário.
Caixa de Ferramentas
Esta caixa é composta pelos mesmos controles exibidos no Excel e descritos
anteriormente nesta apostila.
Janela de Propriedades
Através da janela de Propriedades, você pode alterar a aparência e o
comportamento do formulário que você está criando e dos controles inseridos nele.

Note que os nomes das propriedades são mostrados na coluna da esquerda e
os valores das propriedades são mostrados na coluna da direita. Se você desejar,
poderá alterar o valor da propriedade, simplesmente inserindo o novo valor à direita
do nome da propriedade.
Adicionando Controles ao Formulário

Para inserir um controle no formulário, siga os passos a seguir:
1. Na Caixa de Ferramentas, clique no controle que você deseja inserir no
formulário;
2. Leve o cursor do mouse no local que você deseja inserir o controle;
3. Clique, mantenha o mouse pressionado e arraste até obter o tamanho
desejado para o controle.
Observe o modelo a seguir:

Após inserir qualquer tipo de controle, você pode mover ou redimensioná-lo no
formulário. Para isso, basta clicar sobre o controle e, com o botão do mouse
pressionado, arrastá-lo para a posição desejada ou arrastar uma das alças de ajuste do
controle para redimensioná-lo.
 Sugerimos que quando você estiver adicionado controles ao formulário e

sentir a necessidade de alterar espaçamentos ou o alinhamento dos
mesmos, use os comandos do menu Formatar; é mais prático e eficaz.
Construindo o Código do Formulário

Após desenhar seu formulário, inserir os controles apropriados e definir suas
propriedades, devemos criar os códigos que estarão por trás deste formulário.
Mostrando o Formulário
Para visualizar um formulário, você deve usar o método Show. Podemos
visualizar um formulário assim que uma determinada planilha for ativada ou quando
um botão de comando for clicado.
• Para visualizar o formulário assim que uma determinada planilha for ativada, siga
os passos abaixo:
1. Na janela do Project Explorer, dê um duplo clique na planilha em que você
deseja ativar o formulário. Um módulo referente a essa planilha se abre;
2. Na caixa de Objetos, selecione o objeto Worksheet;
3. Na caixa de Procedimento, selecione a opção Activate;
4. Entre as linhas de procedimento que apareceram, digite:
5. Volte para o Excel. Caso você já esteja na planilha em que o formulário deva ser
apresentado, saia dela e retorne à ela, para que a mesma seja ativada.
Automaticamente o formulário aparece na tela.
• Vamos agora visualizar o formulário ao clicar em um determinado botão de

comando na planilha. O procedimento é semelhante ao apresentado anteriormente:
1. Acesse a planilha onde o formulário deva ser chamado;
2. Abra a aba Desenvolvedor;
3. Clique na ferramenta Botão de Comando do botão Inserir;
4. Leve o mouse até a planilha, clique e arraste até obter o tamanho desejado
para o botão de comando;
5. Clique com o botão direito do mouse sobre o botão desenhado e selecione
Atribuir macro a partir do menu de atalho, ao ser exibida a janela Atribuir
macro, escolha o nome da macro referente ao botão e clique em Editar .

6. O Editor do VBA vai se abrir, entre as linhas de procedimento, digite a mesma
instrução citada anteriormente:
7. Volte para o Excel;

8. Clique no botão de comando desenhado e automaticamente o formulário
aparecerá na tela:
Programando as rotinas internas do formulário

Para se ter acesso ao módulo em que a programação dos controles do
formulário é feita, podemos agir de 2 maneiras:
1. Clicar com o botão direito sobre o nome do formulário na janela do Project
Explorer e, em seguida, usar a opção Exibir código. Será apresentado um
módulo vazio, onde poderemos escolher o objeto e o procedimento a ser
programado através das caixas de Objetos e de Procedimentos, na parte
superior do módulo, tal como ilustra a figura abaixo:
NOTA: Para retornar à imagem do formulário, basta clicar novamente com o botão
direito sobre o nome do formulário na janela do Project Explorer e, em seguida, usar a
opção Exibir objeto.
2. Pode-se também, a partir da imagem do formulário criado dar um duplo clique

sobre o objeto a ser programado, como, por exemplo, um botão de comando.
Da mesma forma descrita acima, será apresentado o módulo da programação
do formulário, porém já com a rotina referente ao objeto declarada.

Exercício 6
Com base na planilha apresentada abaixo e o formulário apresentado como
modelo na pág. 71, altere suas propriedades e programe suas rotinas conforme
descrito a seguir:
Planilha do exercício:

Propriedades a alterar:
OBJETO PROPRIEDADES
Formulário Name = FrmVendas
Caption = Cadastro de Vendas
Rótulo Name = lblData
Caption = Data da Venda:
Caixa de Texto Name = Data
Rótulo Name = lblVendedor
Caption = Vendedor:
Caixa de Combinação Name = Vendedor
Style = 2 - fmStyleDropDownList
Rótulo Name = lblItem
Caption = Item:
Caixa de Combinação Name = Item
Style = 2 - fmStyleDropDownList
Rótulo Name = lblValorUnitario
Caption = Valor Unitário:
Caixa de Texto Name = ValorUnitario
Rótulo Name = lblQuantidade
Caption = Quantidade Vendida:
Caixa de Texto Name = Quantidade
Rótulo Name = lblValorTotal
Caption = Valor Total:
Caixa de Texto Name = ValorTotal
Botão de Comando Name = btNovo
Caption = Novo
Accelerator = N
MousePointer = 99 - fmMousePointerCustom
MouseIcon = C:\windows\cursors\harrow.cur
Picture = a escolher
PicturePosition = 4
Botão de Comando Name = btAlterar
Caption = Alterar
Accelerator = A
PicturePosition = 4
Botão de Comando Name = btExcluir
Caption = Excluir
Accelerator = E
PicturePosition = 4
Botão de Comando Name = btConfirma
Caption = Confirma
Accelerator = C
PicturePosition = 4

OBJETO PROPRIEDADES
Botão de Comando Name = btCancela
Caption = Cancela
Accelerator = L
PicturePosition = 4
Botão de Comando Name = btPrimeiro
Caption = Primeiro
Accelerator = P
PicturePosition = 1
Botão de Comando Name = btAnterior
Caption = Anterior
Accelerator = T
PicturePosition = 1
Botão de Comando Name = btPróximo
Caption = Próximo
Accelerator = X
PicturePosition = 4
Botão de Comando Name = btUltimo
Caption = Último
Accelerator = M
PicturePosition = 4
Botão de Comando Name = btSair

Caption = Sair
Accelerator = S
PicturePosition = 4
Moldura Name = fraClassificacao
Caption = Classificação
Botão de Opção Name = optData
Accelerator = D
Caption = Data
Botão de Opção Name = optVendedor
Accelerator = V
Caption = Vendedor
Botão de Opção Name = optItem
Accelerator = I
Caption = Item
Botão de Opção Name = optValorTotal
Accelerator = R
Caption = Valor Total

Código-Fonte do formulário:
Sub MostraRegistro()
Data = ActiveCell.Value
ActiveCell.Offset(0, 1).Select
Item = ActiveCell.Value
Vendedor = ActiveCell.Value
ValorUnitario = ActiveCell.Value
Quantidade = ActiveCell.Value
ValorTotal = ActiveCell.Value
ActiveCell.Offset(0, -5).Select
'Retorna à Coluna Data
End Sub
Private Sub UserForm_Activate()

Vendedor.AddItem "Ana Paula"
Vendedor.AddItem "Claudio Lopes"
Vendedor.AddItem "Marcelo Freitas"
Vendedor.AddItem "Sergio Dantas"
Item.AddItem "Apontador"
Item.AddItem "Borracha"
Item.AddItem "Caneta Azul"
Item.AddItem "Caneta Vermelha"
Item.AddItem "Grampeador"
Item.AddItem "Lapis Preto"
Item.AddItem "Papel"
Range("A4").Select
MostraRegistro
End Sub
Private Sub ValorTotal_Enter()

ValorTotal = Quantidade * ValorUnitario
End Sub
Private Sub btPrimeiro_Click()

Range("A4").Select
MostraRegistro
End Sub
Private Sub btAnterior_Click()

ActiveCell.Offset(-1, 0).Select
If ActiveCell.Value = "Data" Then
MsgBox "Início do Arquivo!", 64, "Atenção"
Exit Sub
End If
MostraRegistro
End Sub

Private Sub btProximo_Click()
If ActiveCell.Value = "" Then
MsgBox "Fim do Arquivo!", 64, "Atenção"
ActiveCell.Offset(-1, 0).Select
Exit Sub
End If
MostraRegistro
End Sub
Private Sub btUltimo_Click()

Range("A4").Select
Selection.End(xlDown).Select
MostraRegistro
End Sub
Private Sub btNovo_Click()

Range("A4").Select
Selection.End(xlDown).Select
Data = ""
Vendedor = ""
Item = ""
ValorUnitario = 0
Quantidade = 0
ValorTotal = 0
Data.SetFocus 'posiciona o cursor no campo data
'Definição dos botões que estarão ou não ativos

btNovo.Enabled = False
btAlterar.Enabled = False
btExcluir.Enabled = False
btConfirma.Enabled = True
btCancela.Enabled = True
End Sub
Private Sub btCancela_Click()

'Definição dos botões que estarão ou não ativos
btNovo.Enabled = True
btAlterar.Enabled = True
btExcluir.Enabled = True
btConfirma.Enabled = False
btCancela.Enabled = False
Range("A4").Select
MostraRegistro
End Sub
Private Sub btConfirma_Click()

'Testa se algum campo do formulário foi deixado em branco
If Data = "" Or Vendedor = "" Or Item = "" Or ValorUnitario = 0 Or Quantidade = 0 _
Or ValorTotal = 0 Then
For x = 1 To 100
Beep 'Emite um alarme sonoro!
Next
MsgBox "Preencha todos os campos corretamente!",48,"Aviso"
Exit Sub

End If
'Armazena o conteúdo de cada campo nas devidas células da planilha.

ActiveCell.Value = frmVendas.Data.Value
ActiveCell.Value = frmVendas.Vendedor.Value
ActiveCell.Value = frmVendas.Item.Value
ActiveCell.Value = frmVendas.ValorUnitario.Value
ActiveCell.Value = frmVendas.Quantidade.Value
ActiveCell.Value = frmVendas.ValorTotal.Value
Data.SetFocus 'Posiciona o cursor no campo Data
btCancela_Click 'Repete as instruções do botão Cancela
End Sub
Private Sub btAlterar_Click()

Data.SetFocus
btNovo.Enabled = False
btAlterar.Enabled = False
btExcluir.Enabled = False
btConfirma.Enabled = True
btCancela.Enabled = True
'O registro estará livre para alterações.
'Após o usuário fazer as alterações desejadas, o que irá
'salvar o registro é, na verdade, o botão Confirma!
End Sub
Private Sub btExcluir_Click()

If MsgBox("Confirma Exclusão?",vbYesNo,"Exclusão de Registro") = vbYes Then
ActiveCell.Range("A1:F1").Select
'Seleciona a faixa que vai da coluna A
'até a coluna F a partir da célula ativa
Selection.Delete Shift:=xlUp
'Exclui a linha selecionada
MsgBox "Registro excluído com sucesso!", 64, "Confirmação"
Range("A4").Select
MostraRegistro
Else
MsgBox "Operação cancelada!", 64, "Confirmação"
btCancela_Click 'Chama a rotina do botão Cancela
End If
End Sub
Private Sub optData_Click()

Range("A4").Select
Selection.Sort Key1:=Range("A4"), Order1:=xlAscending, Header:=xlGuess, _
OrderCustom:=1, MatchCase:=False, Orientation:=xlTopToBottom
MostraRegistro
End Sub

Private Sub optVendedor_Click()
Range("B4").Select
Selection.Sort Key1:=Range("B4"), Order1:=xlAscending, Header:=xlGuess, _
Range("A4").Select
MostraRegistro
End Sub
Private Sub optItem_Click()

Range("C4").Select
Selection.Sort Key1:=Range("C4"), Order1:=xlAscending, Header:=xlGuess, _
Range("A4").Select
MostraRegistro
End Sub
Private Sub optValorTotal_Click()

Range("F4").Select
Selection.Sort Key1:=Range("F4"), Order1:=xlAscending, Header:=xlGuess, _
Range("A4").Select
MostraRegistro
End Sub
Private Sub btSair_Click()

Unload frmVendas
End Sub

AP Excel 2013 VBA+Alg

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

AP Excel 2013 VBA+Alg

Transféré par

Droits d'auteur :

Formats disponibles

Algoritmos

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 2

Tópicos deste capítulo

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 3

Um algoritmo é uma seqüência de instruções definidas para serem executadas mecanicamente.

Como exemplo de algoritmo, podemos pensar em um ser humano andando. Observe:

1. Levantar a perna direita

1. Ler primeiro número

Um programa é um ou mais algoritmos escritos numa linguagem de programação. Existem diversas

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 4

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 5

Entrada e saída de dados

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 6

Tópicos deste capítulo

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 7

O que é necessário para escrever em Português Estruturado?

A estrutura dos nossos algoritmos será do seguinte modo:

Algoritmo <Aqui inserimos o nome do algoritmo>

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 8

Tópicos deste capítulo

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 9

REAL São os números reais. Abrange os números Inteiros e os números com

LOGICO Utiliza apenas dois valores: Verdadeiro e Falso

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 10

Lendo e Escrevendo Dados

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 11

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 12

Tópicos deste capítulo

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 13

Operadores Aritméticos servem para calcular números e valores em variáveis. Em Portugues

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 14

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 15

Maior que... >

Menor que... <

Maior ou igual que... >=

Menor ou igual que... <=

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 16

algoritmo "Operadores Relacionais"

retorno <- 10 < 20

retorno <- 10 >= 20

retorno <- 10 <= 20

retorno <- 10 <> 20

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 17

E Retorna Verdadeiro se todos os testes forem

Ou Retorna Verdadeiro se um dos testes for

Nao Retorna o inverso de um lógico. Se for

Verdadeiro Verdadeiro Verdadeiro

Verdadeiro Falso Falso

Falso Verdadeiro Falso

Falso Falso Falso

Verdadeiro Verdadeiro Verdadeiro

Verdadeiro Falso Verdadeiro

Falso Verdadeiro Verdadeiro

Falso Falso Falso

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 18

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 19

Tópicos deste capítulo

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 20

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 21

Tópicos deste capítulo

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 22

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 23

Tópicos deste capítulo

Treinamento em Algoritmo Copyright – NSI Training Tecnologia 1