Você está na página 1de 43

Sintaxe do VBA

Publicado em 8 de agosto de 2015 por Felipe Gualberto


Esta página explica a sintaxe do VBA de forma compreensiva, incluindo procedimentos, caixas de mensagem,
variáveis, palavras chaves, expressões, instruções, comentários, operadores, laços e sua interação com o VBE.
Sumário
Sintaxe do VBA ..............................................................1 Instruções ................................................................. 21
Introdução ..................................................................2 Representar Mais de uma Instrução numa Linha
............................................................................... 21
Subprocedimentos ..................................................2
Indentação ............................................................ 21
Procedimentos ................................................................3
Instruções de Declaração .................................... 22
Introdução ..................................................................3
Instruções de Atribuição ..................................... 22
Como Nomeio meus Procedimentos .....................4
Instruções Executáveis ........................................ 22
A Posição de um Procedimento num Módulo..........5
Comentários ............................................................. 22
Subprocedimentos ..........................................................5
Ganhe Tempo com Comentários ........................ 23
Introdução ..................................................................5
Comentar ou Remover Comentários de Várias
Executar um Subprocedimento ................................6
Linhas ................................................................... 23
VBE .........................................................................6
Operadores Aritméticos .......................................... 25
Janela do Excel .......................................................6
Operadores de Concatenação ................................. 26
Depurar um Subprocedimento .................................9
Operadores de Comparação ................................... 27
Atribuir uma Tecla de Atalho a um
Operadores Comuns ............................................ 27
Subprocedimento .....................................................10
Operador Is .......................................................... 30
Barra de Ferramentas de Acesso Rápido...............11
Operador Like...................................................... 31
Procedimento Chamando Outro Procedimento ....12
Operadores Lógicos ................................................. 34
Pilha de Chamadas...............................................13
Blocos de Decisão ..................................................... 35
Escopo de um Procedimento ...................................13
If…Then…Else .................................................... 35
Procedimentos Públicos .......................................14
Select Case ............................................................ 36
Procedimentos Locais ..........................................15
Laços ......................................................................... 38
Funções..........................................................................16
For…Next ............................................................. 38
Especificar Tipo de Dados de Valor Retornado ....17
Do…Loop ............................................................. 40
Retornar Mais de um Valor ....................................17
While…Wend ....................................................... 41
Boas Práticas ............................................................18
For…Each ............................................................ 41
Caixas de Mensagem............................................19
Interação do VBE com Sintaxe do Código ............ 42
Variáveis ...............................................................20
Autoverificação de Sintaxe.................................. 42
Caixas de Diálogo InputBox ................................20
Palavras Chave e Expressões ..................................20
Introdução
Assim como qualquer outra linguagem de programação, o VBA deve ser escrito na sintaxe correta para que
os programas sejam compilados e executados. Um programa em VBA é formado por um conjunto de
procedimentos. Um procedimento é composto por um conjunto de instruções, que podem conter expressões
e/ou palavras chaves. Normalmente, utilizam-se operadores para avaliar expressões. Esses conceitos são
tratados nesta página.

Não é possível falar da sintaxe do VBA antes de falar sobre alguns elementos básicos de programação. Se não
estiver usando esta página como uma referência, siga o roteiro de estudo do site para ter introdução de alguns
termos utilizados nesta página. Todos os conceitos definidos nesta seção são vistos com mais profundidade
em outras páginas do site.

Para seguir adiante, você deverá criar um módulo no projeto de um documento, copiar os exemplos das seções
e colar na Janela de Código do VBE do seu aplicativo.

Subprocedimentos

Subprocedimentos são blocos de código que executam instruções. Um subprocedimento inicia na linha Sub
<nome_do_procedimento> e termina em End Sub. Veja um exemplo de um subprocedimento:

Sub MeuPrimeiroPrograma
Debug.Print "Olá Mundo!"
Debug.Print (25 + 10) / 7
End Sub

Para executar esse subprocedimento, copie o código acima, cole na Janela de Código de um módulo,
posicione o cursor de inserção de texto entre a primeira e última linha do subprocedimento e pressione a tecla
F5.

A instrução Debug.Print é uma forma simples de imprimir o resultado de um programa. Se quiser exibir um
texto, coloque-o entre aspas duplas. Se quiser exibir um número ou o resultado de uma operação matemática,
dispense as aspas. O resultado do programa é exibido na Janela de Verificação Imediata (pressione Ctrl+G
para exibi-la):

Escrever somente Debug irá gerar um erro de compilação. Escreva sempre Debug.Print!
O termo imprimir um resultado não se refere à impressão numa folha de papel física apenas. Uma impressão
pode ser também uma exibição na tela a um usuário.
Procedimentos
Publicado em 20 de setembro de 2015 por Felipe Gualberto

Explicação sobre procedimentos em VBA e dicas em como usá-los.

Introdução
Procedimentos são blocos de código que tem o objetivo de realizar alguma tarefa. Essencialmente, o VBA
possui 3 tipos de procedimentos: subprocedimentos, funções e propriedades.

Procedimentos têm início e fim. O nome de sua primeira linha é declaração. Na declaração de um
procedimento, devemos obrigatoriamente especificar seu tipo e nome.

O exemplo a seguir mostra dois procedimentos: um chamado MostrarIdade e outro ObterIdade:

O tipo de um procedimento é determinado por uma palavra chave:

 Sub: Subprocedimento;
 Function: Função;
 Property: Propriedade (não mostrado aqui).

As regras para dar nome a um procedimento são:

 Iniciar com uma letra;


 Ter de 1 até um máximo de 255 caracteres;
 Não ter espaços (no entanto, é permitido o uso de sublinhado, exemplo: Gerar_Relatório);
 Não ter nome igual a uma das palavras chaves do VBA, como If, End, Next, String, etc;
 Não estar repetido no módulo em que está contido.

Você pode ter vários procedimentos no mesmo módulo, desde que sejam respeitadas as regras acima. Se
quiser ver a lista de todos os procedimentos de um módulo em ordem alfabética, abra sua Janela de Código
do módulo desejado, selecione (Geral) na caixa de combinação à esquerda e expanda a caixa de combinação
à direita:
Se você clicar em algum dos procedimentos dessa lista, o VBE posicionará o cursor de inserção de texto
dentro dele.

Como Nomeio meus Procedimentos

Procedimentos devem ter um nome descritivo que corresponda exatamente ao seu papel desempenhado.
Invariavelmente, o VBA tem laços estreitos com o inglês, então, é muito comum eu misturar palavras em
português com inglês. A regra básica é: use o inglês o máximo que puder, desde que não traduza termos do
modelo de negócios do seu projeto.

Exemplo: você pretende criar uma função que te mostre a quantidade de cavalos que há numa fazenda. Um
nome ruim seria ObterQuantidadeDeCavalos. Em boas práticas de programação, use algo como
GetCavalosCount. Com o tempo, você ganhará uma boa noção que na programação, que no geral, Get é
uma palavra chave que indica que você quer obter um valor, e Count seria a quantidade. Traduzir Cavalo
para Horse seria demais, porque Cavalo é uma entidade do projeto que você está desenvolvendo.

Analogamente, o nome de um procedimento que exiba um relatório dos Cavalos poderia ser algo como
ShowCavaloReport.

Vale a pena relembrar que, para ser um bom programador, seu inglês tem que estar afiado.

Não use abreviações para poupar a quantidade de teclas que você digita. Dessa forma, você irá prejudicar a
leitura do seu código. Se você já tem um procedimento que se chama ShowCavaloReport, basta digitar
ShowC e pressionar Ctrl+Barra de Espaços para que o editor do VBE mostre uma janela suspensa
Intellisense com termos sugeridos para você completar o que está querendo digitar.

O primeiro exemplo dado nesta página (MostrarIdade e ObterIdade) contradiz minhas “boas práticas” de
nomenclatura de procedimentos. Desculpe-me, mas isso acontecerá mais vezes. E mais: não seja obcecado
por nomenclaturas e formato de código. Estou brincando, seja sim.
Lembre-se desta frase: “Always code as if the person who ends up maintaining your code is a violent
psychopath who knows where you live.“
A Posição de um Procedimento num Módulo
Um módulo pode ter uma região chamada de Seção de Declaração. Se essa região existir, ela sempre deverá
estar no topo. Os procedimentos devem ser posicionados sempre depois da seção de declaração. O exemplo
abaixo mostra o esquema de um módulo com sua seção de declaração e três procedimentos:

Como podem ver, o VBE separa a seção de declaração e procedimentos com uma linha clara cinza (isso
pode ser alterado nas configurações do editor).

Costumo chamar de Main o procedimento inicial dos meus códigos.

Subprocedimentos
Publicado em 22 de setembro de 2015 por Felipe Gualberto

Introdução
É recomendável ler a página procedimentos antes de continuar.

Subprocedimentos (ou macros, subrotinas, rotinas, sub) são procedimentos que executam alguma
ação. Subprocedimentos são procedimentos que podem ser executados explicitamente por um
usuário ou por outro procedimento. Eles podem ser chamados (isto é, executados) explicitamente por
uma ação direta do usuário, por um botão do aplicativo, pela interface da Faixa de Opções do
aplicativo, por outro procedimento e várias outras formas.

O prefixo de declaração que você deve usar num subprocedimento é a palavra-chave Sub.

Suponha que você queira criar dois procedimentos: um que preencha dados em células numa planilha
e outro que formate as células. Você poderia, nesse caso, criar um subprocedimento para fazer cada
uma dessas ações. Um nome adequado ao primeiro seria FillData e ao segundo, FormatData:

Sub FillData()
Range("A1").Value = "Olá"
Range("A2").Value = "Mundo!"
End Sub

Sub FormatData()
Range("A1").Font.Bold = True
Range("A2").Interior.ColorIndex = 27
End Sub

Executar um Subprocedimento
VBE

Para executar um subprocedimento, posicione o cursor de inserção de texto entre o início e o fim do
subprocedimento desejado e pressione a tecla F5 (ou clique no ícone verde Play, que pode ser visto
na Barra de Ferramentas do VBE). Então, execute primeiramente o procedimento FillData e depois
FormatData e veja o resultado numa planilha a seguir (saia do VBE):

Janela do Excel

Você pode executar macros fora do VBE. Para tal, vá à janela inicial do seu aplicativo e então
pressione Alt+F8. Será mostrada uma janela de todos os subprocedimentos que você pode executar
de todos os projetos abertos no seu aplicativo. Se na sessão do seu aplicativo tiver muitos
documentos abertos e seus projetos apresentarem grande número de subprocedimentos de forma a
encher a caixa de listagem, você pode filtrar quais subprocedimentos quer listar alterando a caixa de
combinação Macros em.

Para executar um subprocedimento, clique sobre ele e, em seguida, Executar:


Volte ao VBE e, na janela de código, clique sobre uma linha que esteja fora de ambos os
procedimentos e, então, pressione F5. Você verá novamente a janela mostrada acima. Isso aconteceu
porque nesse caso o VBE não sabe qual subprocedimento você quer executar e então ele usa essa
janela para você decidir qual ação tomar.

O botão Editar é bastante útil quando você tem muitos módulos e muitos subprocedimentos: basta
clicar nele que o VBE abrirá a janela de código com o cursor de inserção de texto dentro do
subprocedimento escolhido.

Se você tiver subprocedimentos com o mesmo nome, mas em módulos diferentes no mesmo projeto,
essa mesma janela acrescenta o nome do módulo antes do nome de cada subprocedimento repetido,
na sintaxe módulo.subprocedimento. No exemplo abaixo, temos dois subprocedimentos chamados
GerarRelatório: um no módulo mdlDespesas e outro no módulo mdlProventos:

Vale lembrar que apenas procedimentos do tipo subprocedimento são mostrados nessa lista. Além
disso, os subprocedimentos não podem possuir argumentos e devem ser públicos. Esses conceitos
serão discutidos nas seções posteriores.

O termo técnico da representação de um item mostrando seus precursores é qualificação. No


exemplo, podemos dizer que os procedimentos GerarRelatório estão qualificados pelos seus
respectivos módulos.

Se você tiver vários projetos abertos e o nome de alguns módulos e/ou subprocedimentos repetir,
essa qualificação poderá ser mais específica, mostrando também de qual documento um
subprocedimento faz parte:
Observe que o nome do documento (Diretoria.xlsm ou Contabilidade.xlsm), sempre são o nível
mais alto e se separam do nome de um subprocedimento ou módulo com um ponto de exclamação. O
VBE qualifica os subprocedimentos na forma arquivo!subprocedimento se o módulo desses
subprocedimentos possuírem nomes diferentes ou arquivo!modulo.subprocedimento, se o nome dos
módulos for igual. A lista é classificada pelo nome dos subprocedimentos, não importando o nome
dos módulos e nem dos documentos.

A forma da janela de macros qualificar os subprocedimentos depende de qual documento está ativo
no aplicativo. Por exemplo, se você ativar a pasta de trabalho Contabilidade.xlsm e exibir a janela
de macros, o VBE ocultará os qualificadores Contabilidade.xlsm! de seus subprocedimentos pois
assume que você sabe que esses subprocedimentos são parte do documento ativo:

Voltando ao VBE, se nesse ambiente você exibir a janela de macros, perceberá que duas diferenças
do comportamento da janela de macros do aplicativo:
o Quando necessário, o qualificador de documento dos subprocedimentos são substituídos pelo
nome do projeto do documento, assumindo a forma projeto.módulo.subprocedimento;
o No filtro Macros em não é possível listar os subprocedimentos de todos os projetos de uma
vez.

A figura abaixo mostra essas diferenças:

Depurar um Subprocedimento
Muitas vezes, enquanto estamos em modo de design, fazemos vários testes e estudos antes de termos
segurança que a execução do programa seja satisfatória. A depuração é um tipo de execução parcial
ou passo a passo de um programa com o objetivo de reduzir defeitos e/ou consertar resultados
inesperados.

Para depurar um subprocedimento, pressione a tecla F8 dentro dele. Você também pode depurar
usando o guia Depurar >> Depuração total ou clicar em Depurar na Janela de Macros do
aplicativo.

Nesse modo, você visualizará passo a passo a execução de seu programa, já que o VBE indica a
próxima linha que executará colorindo seu fundo de amarelo:

Para executar a próxima linha de sua rotina, basta pressionar F8 novamente. Faça isso até alcançar a
última linha do procedimento, até não haver mais nenhuma linha amarela, caracterizando o término
do programa e voltando o VBE ao modo de design.
Atribuir uma Tecla de Atalho a um Subprocedimento
Uma forma prática de executar um subprocedimento é atribuir uma tecla de atalho a ele. Para
exemplificar essa funcionalidade, crie o subprocedimento a seguir para Excel:

Sub pFormataçãoLegal()
Selection.Interior.ColorIndex = 24
Selection.Font.Italic = True
Selection.BorderAround LineStyle:=xlContinuous
End Sub

Na Janela de Macros clique no botão Opções:

Você verá a janela abaixo:

Nesse exemplo, atribuí Ctrl+q para um subprocedimento chamado Main. A caixa de texto Descrição
é opcional, mas você pode preenchê-la se quiser criar um breve descritivo de suas macros. Isso pode
ser útil se outras pessoas utilizam suas macros e seu projeto está protegido.
Barra de Ferramentas de Acesso Rápido
Você pode também criar um botão para executar uma macro pela Barra de Ferramentas de Acesso
Rápido. Para tal, primeiro clique no ícone para personalizar a Barra de Ferramentas de Acesso
Rápido >> Mais Comandos:

Em seguida, na caixa de combinação Escolher comandos em, selecione Macros:


A lista de subprocedimentos públicos será mostrada. Dê dois cliques no item que deseja acrescentar e
verá que ele será acrescentado à lista da direita. Em seguida, clique em OK:

Veja como deverá ficar o layout do seu aplicativo. Com um clique, você poderá executar a macro:

Procedimento Chamando Outro Procedimento


Um procedimento pode chamar outro procedimento. Veja o código abaixo:

Sub Main()
Introdução
Formatar
Despedir
End Sub

Sub Introdução()
MsgBox "Programa de teste de chamada de subprocedimentos."
MsgBox "Pressione OK para iniciar a formatação."
End Sub

Sub Formatar()
PovoaDados
FormataDados
End Sub

Sub Despedir()
MsgBox "Tchau!"
End Sub

Sub PovoaDados()
Range("A1").Value = "Olá"
Range("A2").Value = "Mundo!"
End Sub

Sub FormataDados()
Range("A1").Font.Bold = True
Range("A2").Interior.ColorIndex = 27
End Sub

Veja que é fácil de deduzir que Main é um programa piloto que chama outros procedimentos. A
sequência de chamadas dos subprocedimentos é Main >> Introdução >> Formatar >> PovoaDados
>> FormataDados >> Despedir.

Para testar esse exemplo, execute Main. Sugiro que depure (F8) Main, dessa forma, você poderá ver
os saltos de procedimentos na execução do código.

Note os saltos que o cursor de depuração sofre. A execução do programa só termina quando se
alcança a última linha do procedimento chamado no primeiro nível. Perceba que quando as
instruções de End Sub dos subprocedimentos filhos são alcançadas, a instrução seguinte a ser
executada é a próxima linha do procedimento que o chamou.

Você pode usar também a palavra-chave opcional Call antes do nome de um procedimento para
chamá-lo. O subprocedimento abaixo é equivalente ao exemplo anterior:

Sub Main()
Call Introdução
Call Formatar
Call Despedir
End Sub

Call pode ser usado para lembrar o programador que o procedimento a ser chamado é de VBA, e
não um comando interno do VBA. Não use Call. É uma palavra chave obsoleta que dificulta a
leitura do código.

Um procedimento pode chamar a si mesmo numa técnica chamada Recursão. Se quiser saber mais
sobre recursão, veja recursao (em breve).

Pilha de Chamadas

Uma forma interessante de visualizar a sequência de chamadas de procedimentos é através da Pilha


de Chamadas. Clique aqui para saber mais sobre pilha de chamadas.

Escopo de um Procedimento
O escopo de um procedimento diz respeito sobre sua acessibilidade num projeto. Existem procedimentos
locais e procedimentos públicos.

Ele é especificado em sua declaração através de uma palavra chave colocada antes de seu tipo. As palavras
chaves são:

 Private: Procedimentos locais;


 Public: Procedimentos públicos.

O exemplo a seguir mostra o subprocedimento público Main e a função local IsValid:

Public Sub Main()


End Sub

Private Function IsValid()


End Function

Se você não especificar nenhuma palavra chave para definir o escopo de um procedimento, o VBA assume
que ele é público. Logo, as declarações abaixo são equivalentes:

Sub Main()

'é equivalente a:

Public Sub Main()

Procedimentos Públicos

Procedimentos Públicos tem esse nome porque podem ser chamados por qualquer outro procedimento de
qualquer módulo de um projeto.

Como já visto, subprocedimentos que são públicos são mostrados na Janela de Macros do aplicativo
(Alt+F8), desde que não possuam argumentos (argumentos serão vistos posteriormente).

Se seu projeto possuir dois procedimentos públicos de nome repetido e você chamar de um terceiro
procedimento um procedimento com esse nome, o VBA acessará o procedimento local:

No entanto, se o terceiro procedimento estiver num módulo separado, você obterá um erro de compilação,
pois o VBA não saberá qual dos procedimentos acessar:
Para contornar essa situação, qualifique o nome do procedimento a chamar utilizando a forma
módulo.procedimento. O exemplo a seguir executa o subprocedimento Calcular do módulo
mdlDespesas:

Public Sub Main()


mdlDespesas.Calcular
End Sub

Procedimentos Locais

Procedimentos locais são acessíveis somente a procedimentos que estão no mesmo módulo.

Se você tentar acessar um procedimento local a partir de outro módulo, obterá um erro de compilação como
mostrado a seguir:
Um procedimento local pode chamar procedimentos públicos normalmente. No entanto, se existir um
procedimento local com o mesmo nome do procedimento público, o VBA executará o procedimento local.

Funções
Publicado em 9 de outubro de 2015 por Felipe Gualberto

Introdução
É recomendável ler a página procedimentos antes de continuar.

O exemplo a seguir mostra como obter a hipotenusa de um triângulo retângulo:

Sub TriânguloRetângulo()
Dim a As Double
Dim b As Double
Dim c As Double

a = 3
b = 4

c = GetHipotenusa(a, b)

MsgBox "O valor da hipotenusa de um triângulo retângulo " _


& "com catetos " & a & " e " & b & " é " & c & "."
End Sub

Private Function GetHipotenusa(ByVal c1 As Double, _


ByVal c2 As Double)
GetHipotenusa = ((c1 ^ 2) + (c2 ^ 2)) ^ (1 / 2)
End Function

Alternativamente, você poderia chamar a função GetHipotenusa como a seguir, como faço muitas vezes:

c = GetHipotenusa(c1:=a, c2:=b)

A terminologia adotada é que a função GetHipotenusa retornou uma valor à variável c. Se você não
atribuir nenhum valor a essa variável, o valor retornado pela função será Empty.

Funções também podem retornar qualquer tipo de dados, como também objetos e vetores/matrizes.

Tenho certeza que, assim como eu, você achou ridículo utilizar uma palavra em inglês junto com uma em
português na função GetHipotenusa. Pelo fato de várias linguagens de programação ser em inglês e Get
remeter à ideia de que se está obtendo um valor, ela é entendida como uma palavra chave universal para
qualquer programador de que analise o código e entenda que a entendida em questão retorna um valor. Mais
sobre esse assunto aqui..

Especificar Tipo de Dados de Valor Retornado


Segundo as boas práticas de programação, recomenda-se declarar qual o tipo de dados que uma função
retorna. No exemplo utilizado até agora, isso não foi especificado, sendo que:

Private Function GetHipotenusa(ByVal c1 As Double, _


ByVal c2 As Double)

É equivalente a:

Private Function GetHipotenusa(ByVal c1 As Double, _


ByVal c2 As Double) As Variant

Como em nosso exemplo estamos passando um valor a um parâmetro Double, seria uma boa ideia qualificar
o retorno da função também como Double:

Private Function GetHipotenusa(ByVal c1 As Double, _


ByVal c2 As Double) As Double

Como agora o valor retornado está com seu tipo de dados especificado, se você sair da função sem atribuir
um valor a sua variável homônima, o valor retornado será igual ao valor inicial de seu tipo de dados.

Retornar Mais de um Valor


Pode ser que você queira que sua função retorne mais de um valor. Por exemplo, suponha que você use
muitas vezes funções que transformem duplas de números em seus valores ao quadrado e ao cubo, como
mostra o exemplo a seguir:

Sub Main()
Dim Num1 As Long
Dim Num2 As Long

Num1 = 6
Num2 = 5

Debug.Print "Valor inicial de Num1: " & Num1


Debug.Print "Valor inicial de Num2: " & Num2

Num1 = GetQuadrado(Num1)
Num2 = GetCubo(Num2)

Debug.Print "Valor final de Num1: " & Num1


Debug.Print "Valor final de Num2: " & Num2
End Sub

Private Function GetQuadrado(ByVal pNum As Long) As Long


GetQuadrado = pNum ^ 2
End Function

Private Function GetCubo(ByVal pNum As Long) As Long


GetCubo = pNum ^ 3
End Function

Você poderia eliminar a função e em seu lugar criar um subprocedimento, passando valores como
referência:

Sub Main()
Dim Num1 As Long
Dim Num2 As Long

Num1 = 6
Num2 = 5

Debug.Print "Valor inicial de Num1: " & Num1


Debug.Print "Valor inicial de Num2: " & Num2

Transformar Num1, Num2

Debug.Print "Valor final de Num1: " & Num1


Debug.Print "Valor final de Num2: " & Num2
End Sub

Private Sub Transformar(ByRef pQuadrado As Long, _


ByRef pCubo As Long)
pQuadrado = pQuadrado ^ 2
pCubo = pCubo ^ 3
End Sub

Boas Práticas
Suponha que você tenha uma função que transforme toda as letras em maiúsculas, substitua _ por espaços e
insira um pronome de tratamento. É uma típica função que faz transformações por etapas de a partir de um
valor inicial:

Sub Main()
Debug.Print GetFixedText("fELipe_COSta_gualBertO")
End Sub

Function GetFixedText(pText As String) As String


GetFixedText = Replace(pText, "_", " ")
GetFixedText = UCase(GetFixedText)
GetFixedText = "Sr. " & GetFixedText
End Function

Na pequena função FixText, estou usando sua variável homônima três vezes. Numa função maior, essa
repetição também pode se tornar maior, e então você terá que trocar o nome da variável várias vezes na
função.
Claro que existem ferramentas de substituir texto no VBE, mas se sua função tiver um nome pequeno e
comum, poderá alterar partes indesejadas do seu código. Além disso, como em funções seu nome pode se
referir tanto ao nome da função como o valor de retorno, você pode ter dificuldades de interpretação ao ler o
código, e a situação piora quando se utiliza a técnica de recursão.

A forma que trabalho com funções que não retornam um valor diretamente é usando uma variável
temporária que possua um tipo de dados igual ao da função. Reescrevendo o exemplo anterior nesse
embasamento:

Sub Main()
Debug.Print GetFixedText("fELipe_COSta_gualBertO")
End Sub

Function GetFixedText(pText As String) As String


Dim FixedText As String

FixedText = pText
FixedText = Replace(FixedText, "_", " ")
FixedText = UCase(FixedText)
FixedText = "Sr. " & FixedText

GetFixedText = FixedText
End Function

Veja que nesse caso utilizei a variável de apoio FixedText. Por questão de lógica, essa variável de apoio
tem o mesmo tipo de dados do retorno da função (String) e ela possui esse nome pois é o nome da função
GetFixedText sem o prefixo Get.

Caixas de Mensagem

Alternativamente, você também pode imprimir resultados do seu programa numa caixa de mensagem, usando
a instrução MsgBox:

Sub CaixaDeMensagem
MsgBox "Olá Mundo!"
End Sub

A interface e título de caixas de mensagem podem ser modificadas. Sua sintaxe é MsgBox <mensagem>,
<modificação>, <título>. Cada uma dessas expressões separadas por vírgulas para modificar a caixa de
mensagem são chamadas de argumentos.

Você deve usar no argumento <modificação> valores especiais que no VBA chamamos de constantes pré-
definidas. Alguns desses valores que você pode usar são vbInformation, vbCritical e vbExclamation.

<título>deve ser um texto, e se refere ao título da caixa de mensagem. Veja um exemplo de uma caixa de
mensagem modificada:
Sub ExibirErro()
MsgBox "Erro ao salvar informações do cliente.", vbCritical, "Cadastro de Clientes"
End Sub

Variáveis

Você pode armazenar um valor num elemento nomeado que chamamos de variável para depois utiliza-lo no
VBA. O exemplo a seguir armazena numa variável chamada x o valor de uma operação matemática, e em y
uma sequência de texto, depois exibe seus valores:

Sub ArmazenarUsarVariáveis()
x = (25 - 15) * 4
y = "Felipe Costa Gualberto."

Debug.Print x
Debug.Print y
End Sub

Caixas de Diálogo InputBox

O VBA pode solicitar ao usuário que seja entrado um valor numa caixa de diálogo e utilizar esse valor no
programa. Para fazer isso, utilize a instrução InputBox:

Sub ObterMostrarNome()
Nome = InputBox("Qual é o seu nome?")

Debug.Print Nome
End Sub
Palavras Chave e Expressões
Palavras chave são palavras ou símbolos que fazem parte da linguagem de programação do VBA, como If,
End, +, Sub, (, =, etc.

MsgBox, InputBox, etc. não são palavras chave do VBA, mas sim uma função de uma biblioteca que,
infelizmente, também chama-se VBA.

Uma forma simples diferenciar membros da biblioteca do VBA de palavras chaves do VBA é usar o
qualificador VBA. Por exemplo, VBA.MsgBox produz uma sintaxe válida, mas VBA.If, não. Dessa forma,
chegamos à conclusão que MsgBox é um membro da biblioteca VBA e If é uma palavra chave do VBA.

Uma expressão é uma combinação de palavras-chave, operadores, variáveis e constantes que produz uma
sequência de caracteres, número ou objeto. Uma expressão pode ser utilizada para efetuar um cálculo,
manipular caracteres ou testar dados.

O VBA avalia expressões. Avaliar significa calcular e/ou processar uma expressão até reduzi-la num tipo de
dados. 5 + 8 é uma expressão numérica porque ao ser avaliada, produz um número. "Felipe" & " " &
"Costa" é uma expressão de sequência de texto porque ao ser avaliada, produz um texto (você entenderá essa
expressão de texto logo em diante). ActiveDocument.Range.Style é uma expressão que ao ser avaliada
produz um objeto do tipo Style, e assim por diante.

Teoricamente, uma expressão pode ser de qualquer tamanho, e pode-se ter uma expressão dentro de uma
expressão. Assim como 5 + 8 é uma expressão numérica, os números 5 e 8, separadamente, também são
expressões.

Numa terminologia mais técnica, diz-se que avaliar uma expressão retorna um tipo de dados, sendo que
retorna, nesse caso, é sinônimo de resulta.

Instruções
O código VBA é interpretado através de instruções. Uma instrução pode conter palavras-chave, operadores,
variáveis, constantes e expressões, desde que seja válida. Existem instruções de declaração, de atribuição e
executáveis.

O exemplo abaixo mostra os três tipos de instrução, respectivamente:

Sub ExemploInstruções()
Dim var 'Declaração

var = "Olá Mundo!" 'Atribuição

MsgBox var _
, vbInformation _
, "Tutorial Ambiente Office" 'Executável
End Sub

Embora a instrução executável que exibe a caixa de mensagem esteja quebrada fisicamente em três linhas,
logicamente ainda conta somente como uma instrução.

Para quebrar uma instrução em mais de uma linha, dê um espaço onde deseja realizar a quebra e insira o
símbolo _ (sublinhado). Tente dar valor estético ou lógico a quebras físicas. Veja que no exemplo que
apresentei, decidi colocar cada argumento da caixa de mensagem numa linha física diferente.

Genericamente, dizemos que um bloco de código contém um conjunto de instruções.

Representar Mais de uma Instrução numa Linha

Você pode representar mais de uma instrução numa linha física se usar o sinal de : como separador de
instruções:

Sub UmaLinha()
Dim var: var = "Felipe": MsgBox var, vbInformation, "Tutorial Ambiente Office"
End Sub

Como pode perceber, separar instruções com o símbolo de : pode complicar a leitura humana do código.

Indentação

A indentação de um código melhora sua aparência estética baseado em recuos de margem. É uma prática que
quase todos os programadores de VBA seguem. Pendente: vou colocar um link sobre indentação aqui.
Instruções de Declaração

As instruções de declaração nomeiam uma variável, constante ou procedimento e também podem especificar
um tipo de dados:

Dim var 'Declaração

O assunto desta seção é abordado com mais detalhes nas páginas a seguir:

Se estiver seguindo o roteiro de estudo do site, deixe para ler essas páginas depois de terminar esta.

Pendente: os links ainda não funcionam. Em breve estarão disponíveis.

Declaração de Procedimentos

Declaração de Variáveis e Constantes

Enumerações

Instruções de Atribuição

As instruções de atribuição atribuem um valor ou expressão a uma variável ou constante, e são feitas através
do sinal de igualdade =

O exemplo a seguir atribui a variável Altura o valor da altura de uma pessoa:

Altura = 1.77

Para fazer uma atribuição a um tipo de dados de objeto (discutido com mais detalhes em outras páginas deste
site), você deve obrigatoriamente utilizar a palavra chave Set. Veja um exemplo para o Word:

Set stl = ActiveDocument.Range(5, 10).Style

Instruções Executáveis

As instruções executáveis iniciam ações. Essas instruções podem executar um método ou função e podem
executar laços ou desviar-se pelos blocos de código. É comum instruções executáveis conter operadores
matemáticos ou condicionais.

O exemplo a seguir mostra três instruções: uma que inicia um laço do tipo For...Next, outra que imprime
um resultado na Janela de Verificação Imediata e outra que desvia a execução do código para o início do
laço:

Sub InstruçõesExecutáveis()
For lng = 1 To 5
Debug.Print "Teste " & lng
Next lng
End Sub
Comentários
Comentários são textos que não são compilados nem executados pelo VBA.

A presença de comentários num código é opcional. Eles podem ser usados para explicar um bloco de código,
prover documentação de um programa ou servir como anotações. Por padrão, expressões de texto comentadas
são exibidas na Janela de Código na cor verde.
Para inserir um comentário, insira o caractere ' (aspas simples) e em seguida escreva o comentário desejado.
Você pode inserir comentários no início de uma linha ou após uma instrução, como mostra o exemplo a seguir:

Sub ExemploComentários()
'O código abaixo exibe uma caixa de texto:
MsgBox "Olá!!"

Debug.Print 33 'você pode também comentar ao final de uma linha de código válida.
End Sub

Se você possuir uma instrução que ocupe mais de uma linha física, basta adicionar o símbolo ' no início da
linha em que a instrução começa para torna-la um comentário:

'MsgBox var _
, vbInformation _
, "Tutorial Ambiente Office" 'Executável

Ganhe Tempo com Comentários

Você pode usar comentários para testar eficientemente seus programas. Por exemplo, suponha que você esteja
testando um programa de cadastro como mostrado a seguir:

Sub ExemploPrograma()
Nome = InputBox("Digite o nome completo do paciente:")
Telefone = InputBox("Digite o telefone do paciente na forma (XX) XXXX-XXXX:")
Idade = InputBox("Digite a idade do paciente:")

'(...mais instruções do programa...)

Em seus testes, quando você coloca uma determinada combinação de nome, telefone e endereço de cadastro,
obtém um erro. Então, após corrigir o erro, deverá executar o programa de novo para verificar se o erro está
realmente corrigido.

Se você tiver que fazer vários testes desse tipo, gastará mais tempo inserindo informações caixas de diálogo
que efetivamente corrigir problemas do programa. Nesse caso, sugiro comentar as instruções de entrada do
programa e fazer atribuições diretas às variáveis:

Sub ExemploPrograma()
' Nome = InputBox("Digite o nome completo do paciente:")
' Telefone = InputBox("Digite o telefone do paciente na forma (XX) XXXX-XXXX:")
' Idade = InputBox("Digite a idade do paciente:")

Nome = "Felipe Costa Gualberto"


Telefone = "(31) 9115-1234"
Idade = 30

'(...mais instruções do programa...)


Não se esqueça de comentar as atribuições diretas e remover os comentários das instruções corretas antes de
distribuir seu programa.

Comentar ou Remover Comentários de Várias Linhas

Você não precisa adicionar o símbolo de aspas simples manualmente em várias linhas para comentar um bloco
de código, nem mesmo removê-los um a um se quiser voltá-los ao normal.

O VBE oferece um comando disponível na barra de ferramentas para fazer essa operação. Para habilitá-lo,
clique com o botão direito na barra de ferramentas do VBE >> controle Editar:
O grupo de controles Editar aparecerá em sua barra de ferramentas:

Para comentar várias linhas de uma vez, selecione o bloco de código desejado e clique no controle mostrado
a seguir:

O resultado é mostra a seguir:

Para remover todos os comentários, basta selecionar o bloco de código desejado e clicar no controle mostrado
abaixo:
Operadores Aritméticos
O VBA pode ser considerado uma calculadora muito eficiente, e consegue processar operações matemáticas
em velocidades incríveis. O exemplo a seguir mostra todas as operações aritméticas que o VBA suporta:

Sub OperaçõesAritméticas()
'Soma, subtração e parênteses:
Debug.Print 30 - (25 - (8 + 3))

'Multiplicação (*) e divisão (/):


Debug.Print 0.5 * (12 / 2)
'Note que separador decimal do VBA é um ponto, e não uma vírgula!

'Potência:
Debug.Print 5 ^ 3

'Raiz enésima de um número. Exemplo: raiz quadrada de 25 e raiz cúbica de 8:


Debug.Print 25 ^ (1 / 2) + 8 ^ (1 / 3)

'Divisão arrendondando-se ao inteiro mais próximo:


Debug.Print 20 \ 3
'Note que foi utilizada a contrabarra ao invés da barra.

'Mostrar resto de uma divisão:


Debug.Print 33 Mod 10
End Sub

O VBA avalia operações matemáticas da mesma forma que a matemática nos ensina: primeiro as raízes e
potências, depois as multiplicações e divisões e depois as somas e subtrações. Claro, essa ordem respeita a
precedência dos parênteses. Em caso de dúvida na ordem de cálculo de operações aritméticas, coloque
expressões que deseja avaliar primeiro entre parênteses.

O único operador aritmético que não é um símbolo é o Mod, mas seu comportamento e modo de usar é igual a
qualquer outro operador aritmético.

O VBA suporta números hexadecimais e octadecimais. Para representa-los, basta inserir &H e &O antes de seus
valores, respectivamente:

Sub HexadecimalOctadecimal()
'Hexadecimal
Debug.Print &H10

'Octadecimal
Debug.Print &O10
End Sub

O resultado desse programa será 16 e 8, já que 10 em hexadecimal representa 10 no sistema decimal e 10 no


sistema octadecimal representa 8 no sistema decimal.

Você pode, inclusive, misturar bases decimais que o VBA avaliará todas as expressões para decimal:

Sub SomarMistura()
'Equivalente a 10 + 8 + 16
Debug.Print 10 + &O10 + &H10
End Sub

O VBA suporta a notação científica (base 10). Se você escrever a expressão Debug.Print 2.5E2 (equivalente
a 2.5 * (10 ^ 2)) o VBE transformará o número automaticamente em 250. No entanto, se você especificar uma
base maior que 14 (ou menor que -14), ele manterá a notação científica, como no caso de 3E-150. , que
equivale a 3 * (10 ^ (-150)).
Operadores de Concatenação
Um operador de concatenação opera entre duas expressões e retorna uma expressão de texto que é uma
sequência de texto que junta as duas expressões, na ordem que foram escritas. Sua forma é expressão1 &
expressão2, e o símbolo & é chamado de operador de concatenação.

Veja alguns exemplos:

Sub Concatenação()
'Retorna Olá mundo!
Debug.Print "Olá mu" & "ndo!"

Nome = "Felipe"
Sobrenome = "Costa"
'Retorna Felipe Costa.
Debug.Print "Seu nome é " & Nome & " " & Sobrenome & "."

End Sub

Atente-se ao fato de que expressões literais de texto devem estar entre aspas duplas e variáveis fora das aspas
duplas. Todos esses conjuntos são ligados através de operadores de concatenação. Na expressão "Seu nome
é " & Nome & " " & Sobrenome & "." há 5 expressões concatenadas, a saber:

 1a. expressão: A expressão literal "Seu nome";


 2a. expressão: variável Nome;
 3a. expressão: A expressão literal "Seu nome";
 4a. expressão: A variável Sobrenome;
 5a. expressão: A expressão literal ".".

Não se esqueça de inserir espaços nas expressões literais ao criar as sequências de texto!

Você pode utilizar o operador de concatenação também em números, mas nesse caso, eles não vão somar, e
sim concatenar. Veja o exemplo abaixo:

Sub ConcatenarNúmeros()
'Retorna 2526
Debug.Print 25 & 26
End Sub
O símbolo + pode ser usado também para concatenar um texto. No entanto, evite seu uso porque se o VBA
avaliar as duas expressões a ser concatenadas como números, a operação que ele fará será uma soma, e não
concatenação.
Operadores de Comparação
Um operador de comparação é usado para comparar expressões.

O resultado de uma operação de comparação resulta em True se a comparação for verdadeira ou False se for
falsa. Existem vários tipos de operadores de comparação.

Operadores Comuns

Os operadores comuns são representados pelos símbolos <, <=, >, >=, = e <>, e sua função é comparar duas
expressões na forma expressão1 <símbolo de comparação> expressão2. As expressões comparadas
podem ser números ou texto.

Veja alguns exemplos a seguir:

Sub Comparações()
Dim var As Variant

'Retorna Falso
Debug.Print 25 < 23

'Retorna Falso, equivalente à expressão anterior


Debug.Print 35 - 10 < 23

var = "Felipe"
'Retorna Verdadeiro
Debug.Print var <> "Felipe"
End Sub

Se você misturar tipos de dados numéricos com textos, poderá obter um erro de execução:

Sub TiposDiferentes()
Debug.Print "Benzadeus" = 1000
End Sub

No entanto, se o VBA conseguir avaliar uma expressão de texto num número, ele conseguirá fazer uma
comparação:

Sub TiposDiferentes2()
'Retorna Verdadeiro
Debug.Print "0010" = 10
End Sub

O operador = retorna True se duas expressões de texto forem iguais e para o mesmo caso, o operador <>
retorna False. Você pode usar também os operadores <, <=, > e >= para comparar texto. O VBA avalia quem
é maior ou menor de acordo com a ordem alfabética das expressões:

Sub CompararTexto()
'Retorna Verdadeiro, porque m está depois de b no alfabeto
Debug.Print "maçã" > "banana"
End Sub

Na verdade, o VBA avalia o código do primeiro caractere para fazer a comparação. Se o primeiro caractere
das expressões forem iguais, ele parte para o próximo caractere e assim por diante:
Para representar qualquer um dos caracteres acima pelo seu respectivo código, experimente digitar
Alt+<código> utilizando números do seu teclado numérico.

Palavras menores tem preferência: por exemplo, "casa" < "casarão" retorna True.

Por padrão, o VBA diferencia letras maiúsculas de minúsculas ao fazer comparações:

Sub MaiúsculasEMinúsculas()
'Retorna Falso
Debug.Print "Banana" = "banana"
End Sub

Nesse caso, ele considera que letras maiúsculas vem antes de letras minúsculas, então a expressão "Banana"
< "banana" retorna True.

Se você quiser que o VBA não diferencie maiúsculas de minúsculas, insira a instrução Option Compare Text
na seção de declaração do seu módulo:

Option Compare Text

Sub MaiúsculasEMinúsculas()
'Retorna Verdadeiro
Debug.Print "Banana" = "banana"
End Sub

Por padrão, se você não especificar uma instrução de comparação de texto, o VBA considerará que a forma
de comparação é binária, isto é, equivalente à declaração Option Compare Binary. A comparação é binária
porque o código ASCII de uma letra maiúscula é diferente do seu equivalente maiúsculo (experimente digitar
Alt+66 e Alt+98 usando números do seu teclado numérico).

Não confunda o símbolo de igualdade de atribuição com o de comparação! Infelizmente, o símbolo =


pode ter uma função diferente do operador =, que é uma atribuição. Isso costuma confundir programadores
iniciantes. Por exemplo, veja a expressão a seguir:

Sub Igualdade()
Dim var As Variant

var = 1 = 2
Debug.Print var
End Sub

O sinal de igualdade da esquerda é de atribuição, e o da direita, de comparação. Uma atribuição é feita


somente após toda expressão à direita da igualdade ser avaliada. A avaliação da expressão 1 = 2 resulta em
False, e então a atribuição de False é feita a var, e o programa exibe False na janela de verificação imediata
na próxima instrução. Um modo diferente de escrever essa instrução de uma forma mais clara seria var = (1
= 2).

Operador Is

Operadores Is se aplicam a objetos.

Enquanto os operadores da subseção anterior comparam valores de tipos de dados numéricos, o operador Is
verifica se duas expressões se referem ao mesmo objeto na forma expressão1 Is expressão2 e retorna True
ou False.

Um exemplo de objeto é uma planilha do Excel, que pode ser representada pela expressão
Worksheets("Plan1"). O exemplo a seguir
Sub Objetos()
Set obj1 = Worksheets("Plan1")
Set obj2 = Worksheets("Plan1")

'Retorna Verdadeiro
Debug.Print obj1 Is Worksheets("Plan1")

'Retorna Verdadeiro
Debug.Print obj1 Is obj2

'Retorna Falso
Debug.Print obj1 Is Worksheets("Plan5")

End Sub

Se uma expressão não se referir a um objeto, então seu valor será igual à palavra chave Nothing. No exemplo
a seguir, a variável obj é declarada como um tipo de dados de um objeto, mas como ela não se refere a nenhum
objeto, a instrução Debug.Print obj Is Nothing retorna True:

Sub ExemploNothing()
Dim obj As Object

Debug.Print obj Is Nothing


End Sub

Operador Like

O operador Like compara duas sequências de caracteres na forma <texto> Like <padrão>. <texto> é a
sequência de texto que você quer comparar, e <padrão> é sua referência, chamado também de padrão. Like
aceita o uso dos caracteres curingas ?, * e #, além de aceitar listas de caracteres entre colchetes.

Um caractere curinga é utilizado para fazer correspondência a mais de um caractere diferente numa busca ou
comparação.

Muitas vezes, ao preencher dados, as pessoas omitem algumas acentuações de palavras. Se você criar uma
rotina que verifique todos os dados que possuam a palavra iluminação, poderá ter problemas se as entradas
não estiverem validadas e você encontrar variações da palavra como Iluminacao, Iluminaçao e iluminacão.

Essa é uma situação em que o operador Like é útil porque ao utilizar o caractere ? nos caracteres duvidosos
do padrão, ele considerará qualquer caractere:

Sub CaractereÚnico()
'Retorna Verdadeiro
Debug.Print "Iluminação" Like "Ilumina??o"

'Retorna Verdadeiro
Debug.Print "Iluminacão" Like "Ilumina??o"

'Retorna Verdadeiro
Debug.Print "Iluminaçao" Like "Ilumina??o"

'Retorna Verdadeiro
Debug.Print "Iluminacao" Like "Ilumina??o"

'Retorna Falso
Debug.Print "Decoração" Like "Ilumina??o"
End Sub

Como pôde perceber, o caractere curinga ? corresponde a exatamente um caractere qualquer. Fique atento
porque ? deve representar obrigatoriamente um caractere, então "Felie" Like "Feli?e" retorna False
porque o padrão exige que haja um caractere entre as letras i e e, nem que esse caractere seja um espaço,
pontuação ou até mesmo outro e.

No entanto, como ? aceita qualquer caractere, ele irá considerar válido alguns absurdos também:

'Retorna Verdadeiro
Debug.Print "IluminaWHo" Like "Ilumina??o"

Para restringir os caracteres que correspondem ao padrão, coloque-os entre colchetes:

'Retorna Verdadeiro
Debug.Print "Iluminacao" Like "Ilumina[cç][aã]o"

'Retorna Falso
Debug.Print "IluminaXXo" Like "Ilumina[cç][aã]o"

Sobre a questão de diferenciação de letras maiúsculas de minúsculas, Like se comporta de acordo com a
instrução Option Compare em seu módulo. Como por padrão é feita uma comparação binária, "iLuMiNaçãO"
Like "Iluminação" retorna Falso. Para contornar essa situação, você tem duas opções:

Usar a função LCase na sequência de texto a ser comparada para transformar todos seus caracteres em
minúsculos, e então escrever o padrão em letras minúsculas:

'Retorna Verdadeiro
Debug.Print LCase("iLuMiNaçãO") Like "iluminação"

Ou inserir a instrução Option Compare Text na seção de declaração do seu módulo:

Option Compare Text

Sub SeçãoDeclaração()
'Retorna Verdadeiro
Debug.Print "iLuMiNaçãO" Like "iluminação"
End Sub

Particularmente, prefiro utilizar a função LCase para tratar essa situação.

Poderão aparecer textos como Grupo Iluminação, Grupo de Iluminação nos seus registros. Nesse caso, utilize
o caractere, utilize o caractere curinga * para tratar esses casos:

Sub Asterisco()
'Retorna Falso
Debug.Print "Grupo de Iluminação" Like "Iluminação"

'Retorna Verdadeiro
Debug.Print "Grupo de Iluminação" Like "*Iluminação"

'Retorna Verdadeiro
Debug.Print "Iluminação" Like "*Iluminação"
End Sub

O caractere * representa zero ou mais caracteres.

Pode ser também que você tenha textos como Grupo de Iluminação. (observe o ponto final ao fim da sequência
de texto) ou então variações da palavra Iluminação com espaços extras desnecessários antes e depois da
palavra. Nesse caso, represente o * antes e depois no padrão:

'Retorna Verdadeiro
Debug.Print "Grupo de Iluminação. " Like "*Iluminação*"
Por fim, o padrão que eu recomendaria nesse exemplo da palavra Iluminação seria "*ilumina[cç][aã]o*",
aplicando a função LCase no texto a ser comparado para transforma-la antes em letras minúsculas.

Você pode utilizar o caractere curinga # para verificar representar um número qualquer:

Sub Dígitos()
'Retorna Verdadeiro
Debug.Print "061.221.954-48" Like "###.###.###-##"

'Retorna Falso
Debug.Print "061.2Ab.954-48" Like "###.###.###-##"
End Sub

Se quiser permitir apenas um intervalo de caracteres, utiliza colchetes e separe o caractere inicial do final com
um hífen:

Sub Faixa()
'Retornam Verdadeiro
Debug.Print "Setor A" Like "Setor [A-C]"
Debug.Print "Setor B" Like "Setor [A-C]"
Debug.Print "Setor C" Like "Setor [A-C]"

'Retorna Falso
Debug.Print "Setor D" Like "Setor [A-C]"
End Sub

Podemos chegar à conclusão que o caractere curinga # é equivalente ao padrão [0-9].

O padrão [a-cf-mv-z] corresponde caracteres de a até c, de f até m e de v até z. Se quiser corresponder apenas
caracteres num texto, utilize o padrão [A-Za-z]. O padrão do exemplo abaixo verifica se alguns dos textos
possuem palavras com 6 ou mais letras consecutivas:

Sub SeisLetras()
'Retorna Falso
Debug.Print "O rato roeu a roupa do rei de Roma." Like "*[A-Za-z][A-Za-z][A-Za-z][A-
Za-z][A-Za-z][A-Za-z]*"

'Retorna Verdadeiro
Debug.Print "Felipe Costa Gualberto." Like "*[A-Za-z][A-Za-z][A-Za-z][A-Za-z][A-Za-
z][A-Za-z]*"
End Sub

Não utilize [A-z] para corresponder uma letra, porque de acordo com a tabela de código de caracteres, de Z
até a há vários caracteres que não são letras.

[A-Za-z] não corresponde espaços e sublinhado, por exemplo. Se quiser que sejam considerados, use [A-Za-
z_ ] (note que há um espaço após o sublinhado).

Em relação à acentuações, se quiser considerar todos os caracteres de A a Z e suas variações acentuadas, use
[A-Za-zÀ-ÅÈ-ÏÒ-ÖÙ-ÜÇà-åè-ïò-öù-üç]. Claro, se quiser fazer correspondência de três caracteres, por
exemplo, você pode evitar escrever essa expressão três vezes e fazer algo como mostrado abaixo usando como
auxílio da função Replace:

Sub LikeSubstituição()
Letra = "[A-Za-zÀ-ÅÈ-ÏÒ-ÖÙ-ÜÇà-åè-ïò-öù-üç]"

Padrão = "Iniciais: @@@#."


'Substitui caractere @ por [A-Za-zÀ-ÅÈ-ÏÒ-ÖÙ-ÜÇà-åè-ïò-öù-üç]
Padrão = Replace(Padrão, "@", Letra)

'Retorna Verdadeiro
Debug.Print "Iniciais: Fáb6." Like Padrão
End Sub

Se quiser corresponder os caracteres especiais [, ], ?, # ou *, basta coloca-los entre colchetes:

'Retorna Verdadeiro
Debug.Print "Ela disse [Como? Ela não estava lá!] que..." _
Like "*[[]*[?]*[!][]]*"
Cuidado para não confundir-se com as correspondências [[] e []].

Like possui uma grande limitação. Não é possível usa-lo diretamente para comparações de quantidades
variáveis de caracteres sem o uso do *, que generaliza muito a comparação. Por exemplo: você não pode
corresponder nomes de 6 a 8 caracteres sem criar uma comparação com 6 caracteres, depois outra com 7 e
depois outra com 8 e verificar se uma delas é verdadeira.

Existe uma ferramenta muito mais poderosa que o Like, conhecida como Expressões Regulares. Peça-me
para disponibilizar o link que postarei aqui.

Operadores Lógicos
Operadores lógicos são usados normalmente para modificar a lógica de uma expressão e/ou adicionar mais
condições em comparações. O VBA suporta os operadores lógicos And, Egv, Imp, Not, Or e Xor. Com exceção
do Not, que se aplica apenas a uma expressão, todos os outros operadores lógicos comparam duas expressões.

Os operadores lógicos mais comuns são o And (E) e o Or (Ou):

Sub LógicosComuns()
'Retorna Verdadeiro
'2 é maior que 1 e as expressões de texto são iguais.
Debug.Print 2 > 1 And "João" = "João"

'Retorna Verdadeiro
'Embora 10 seja maior que 20, 10 + 5 é igual a 15.
Debug.Print 10 > 20 Or 10 + 5 = 15
End Sub

Você pode usar vários operadores lógicos numa expressão:

Debug.Print exp1 = exp2 And exp3 = exp4 Or exp5 = exp6 And exp7 = exp8

No entanto, quando uso mais de um operador lógico numa expressão, adiciono parênteses para dar ênfase na
precedência das operações para não haver qualquer ambiguidade:

Debug.Print exp1 = exp2 And (exp3 = exp4 Or exp5 = exp6) And exp7 = exp8

Quando as expressões ficam muito grandes, quebro linhas fisicamente mantando o operador em questão na
próxima linha:

Debug.Print (ExpressãoDemasiadamenteGrande1 = ExpressãoDemasiadamenteGrande2 _


And ExpressãoDemasiadamenteGrande3 = ExpressãoDemasiadamenteGrande4) _
Or (ExpressãoDemasiadamenteGrande5 = ExpressãoDemasiadamenteGrande6 _
And ExpressãoDemasiadamenteGrande7 = ExpressãoDemasiadamenteGrande8)

Use o operador Not para inverter o valor lógico de uma expressão:

Sub OperadorNot()
'Retorna Falso
Debug.Print Not 5 = 5
End Sub
Particularmente, gosto de adicionar parênteses para melhorar a leitura do código:

Debug.Print Not (5 = 5)

Os outros operadores lógicos são empregados com pouca frequência. Se tiver dúvida, consulte a ajuda do
VBA do seu aplicativo.

Blocos de Decisão
Um bloco de decisão é formado por uma instrução que desvia a execução de código para uma instrução ou
bloco de instruções de acordo com uma condição (também chamado de teste condicional). No VBA, existem
as estruturas If…Then…Else e Select Case…End Select.

If…Then…Else

A instrução If…Then…Else executa condicionalmente um grupo de instruções dependendo do valor de uma


comparação.

Veja o exemplo a seguir:

Sub ValidarSenha()
Senha = InputBox("Qual é a senha do projeto?")

If Senha <> "benzadeus" Then Exit Sub

'<instruções>...
End Sub
A instrução Exit Sub sai imediatamente de um procedimento.

Se a comparação Senha <> "benzadeus" for True, a instrução Exit Sub será executada. Caso contrário, o
código prossegue normalmente.

Se você quiser executar mais de uma instrução, pode fazer algo como:

If Senha <> "benzadeus" Then


Debug.Print "Senha incorreta!"
Exit Sub
End If

No entanto, nesse caso, você terá que usar a instrução End If para delimitar o fim do bloco de instruções.

Obviamente, você poderia separar as instruções usando :, mas a legibilidade do código ficaria ruim:

If Senha <> "benzadeus" Then Debug.Print "Senha incorreta!": Exit Sub

Você pode também executar um bloco de código específico se o teste condicional falhar:

If Senha = "benzadeus" Then


Debug.Print "Senha correta."
Else
Debug.Print "Senha incorreta!"
Exit Sub
End If

'<instruções>...

Numa linha só (mas não recomendado):


If Senha = "benzadeus" Then Debug.Print "Senha correta." Else Debug.Print "Senha
incorreta!": Exit Sub

Você pode adicionar múltiplas condições se quiser, usando a instrução ElseIf...Then:

If Senha = "benzadeus" Then


Debug.Print "Senha correta."
ElseIf Senha = "BENZADEUS" Then
Debug.Print "Acho que você esqueceu o Caps Lock habilitado!"
Exit Sub
ElseIf Senha = "" Then
Debug.Print "Você não especificou uma senha!"
Exit Sub
Else
Debug.Print "Senha incorreta!"
Exit Sub
End If

Na prática, não costumo utilizar muito estruturas ElseIf, prefiro usar a instrução Select Case, mostrada na
subseção a seguir.

Vale ressaltar que mesmo quando mais de uma comparação da estrutura de decisão for verdadeira, apenas a
primeira delas será executada.

Select Case

O bloco de decisão Select Case é uma alternativa ao If...Then...Else. O bloco se inicia com a instrução
Select Case <expressão> e termina com End Select. Entre essas instruções, você lista casos diferentes
com suas respectivas instruções em sequência. No primeiro caso verdadeiro, uma .

Para números, ele é muito útil, como já foi mostrado no início desta página:

Sub Conceito()
Nota = InputBox("Qual nota você tirou no semestre?")

Select Case Nota


Case Is < 50: Conceito = "F"
Case Is < 60: Conceito = "E"
Case Is < 70: Conceito = "D"
Case Is < 80: Conceito = "C"
Case Is < 90: Conceito = "B"
Case 100: Conceito = "A"
Case Else
Debug.Print "Valor inválido!"
Exit Sub
End Select

Debug.Print "Seu conceito foi " & Conceito & "."


End Sub
Esse é um típico exemplo em que utilizar o símbolo : para representar mais de uma instrução numa linha
melhora a leitura do código.

Se nenhum caso for verdadeiro, sempre serão executadas as instruções do bloco Case Else, que é uma
instrução opcional.

Outro exemplo: numa competição de natação, considere que há 9 nadadores disputando, cada um numa raia.
Como é sabido, por alguns motivos físicos, as raias centrais são as preferidas pelos nadadores. Por
consequência, quanto mais próxima da borda da piscina, pior a raia é. O exemplo a seguir diz respeito à raia
escolhida por um nadador:
Sub Raia()
Dim lRaia As Long
Dim sMensagem As String

lRaia = InputBox("Qual raia você quer escolher?")

Select Case lRaia


Case 1, 9
sMensagem = "Péssima escolha de raias!"
Case 2 To 4, 6 To 8
sMensagem = "Escolha razoável de raia."
Case 5
sMensagem = "Você escolheu a melhor raia, parabéns!"
Case Else
sMensagem = "Número de raia inválido!"
End Select

MsgBox sMensagem
End Sub

Veja que você pode especificar múltiplos casos, separando-os por vírgula, e pode também varrer toda uma
faixa como 6 To 8. O bloco Case Else é executado se nenhuma das condições forem satisfeitas, e esse bloco
é opcional.

Veja um exemplo de Select Case com sequências de texto:

Sub Permissões()
Select Case InputBox("Digite seu login:")
Case "felipe.costa"
Mensagem = "Você tem permissões de administrador"

Case "joao.gualberto"
Mensagem = "Você pode visualizar as tabelas do sistema."

Case "daniel.pereira", "renata.costa"


Mensagem = "Você está com problemas no cadastro. Contate o administrador."

Case "rodrigo.jose", "maria.socorro", "jose.horacio"


Mensagem = "Autorização padrão de acesso"

Case Else
Mensagem = "Usuário não autorizado."
End Select

Debug.Print Mensagem
End Sub
Repare que nesse exemplo não passei o valor da caixa de diálogo a uma variável para depois avaliar a variável
na instrução Select Case, mas coloquei a função InputBox diretamente na instrução.

Você pode usar também a palavra chave To para considerar uma faixa de caracteres:

Sub ExemploCaractere()

Caractere = InputBox("Digite um caractere:")


'Verifica se o tamanho de Caractere é de um caractere:
If Len(Caractere) <> 1 Then
Debug.Print "Você não digitou um e somente um caractere!"
Exit Sub
End If

Select Case Caractere


Case "a" To "z", "A" To "Z"
Mensagem = "Você digitou uma letra."

Case "0" To "9"


Mensagem = "Você digitou um número."

Case ".", "!", "?", "..."


Mensagem = "Você digitou um símbolo de pontuação."
End Select

If Mensagem <> "" Then Debug.Print Mensagem


End Sub

Nesse caso, as comparações de letras são feitas de acordo com as regras de comparação de texto.

Laços
Laço é uma instrução que repete um bloco de código um número específico de vezes. No VBA, os laços
disponíveis são o For...Next, Do...Loop, While...Wend e ForEach...Next.

For…Next

O exemplo abaixo imprime na Janela de Verificação Imediata o texto Olá Mundo! 8 vezes:

Sub ForNext()
For cont = 3 To 10
Debug.Print "Olá mundo!"
Debug.Print "Essa é a iteração número " & cont & "."
Next cont
End Sub
Depure esse exemplo pressionando a tecla F8 ao invés de pressionar F5 para estudar como os desvios de
execução ocorrem.

Um laço For...Next depende de uma variável de controle, que nesse exemplo é representado pela variável
cont. A variável de controle inicia com o valor 3. Quando o programa chega em Next cont, incrementa-se
cont em uma unidade e a execução desvia para a primeira instrução após For.

Chama-se de iteração cada passo de execução de um laço. Nesse exemplo, foram executadas (10 – 3 + 1) =
8 iterações, já que a execução do programa sai do laço quando o valor da variável de controle supera o valor
final atribuído na instrução For.

A representação da variável de controle na instrução Next é opcional, isto é, você pode escrever Next ao invés
de Next cont. No entanto, prefiro representar a variável de controle na instrução para melhorar a leitura do
código, especialmente se eu aninhar dois laços:

Aninhamento é o nome que se dá quando usamos uma instrução dentro do bloco de instruções de outra
instrução.
Sub ForNext()
For cont1 = 1 To 3
Debug.Print "Iniciando a iteração " & cont1 & " do laço externo."
For cont2 = 1 To 3
Debug.Print "Iteração interna " & cont2 & " do laço externo " & cont1 & "."
Next cont2
Next cont1
End Sub

O laço externo é o que inicia primeiro e termina por último, o laço interno é o que está dentro do laço externo.

Se você especificar um valor inicial para a variável de controle maior que o valor final do laço, a execução do
código não executará nenhuma vez o bloco de instruções de laço, desviando o código para a instrução Next.
Exemplo: For x = 100 To 50.
O incremento que a instrução Next <variável_de_controle> faz o incremento de uma unidade a cada
execução. A esse incremento damos o nome de Passo. O valor padrão é de uma unidade, mas se quiser um
valor diferente, inclua a palavra chave Step na instrução e em seguida o valor do passo. O exemplo a seguir
mostra um For...Next com passo 10:

Sub PassoGrande()
For cont = -50 To 50 Step 10
Debug.Print cont
Next cont
End Sub

O passo pode ser um decimal:

Sub PassoDecimal()
For cont = 1 To 3 Step 0.5
Debug.Print cont
Next cont
End Sub

O passo também pode ser um número negativo. Esse tipo de laço é muito comum, e nesse caso, o laço finda
quando o valor da variável de controle se torna menor que sua meta na instrução For:

Sub PassoNegativo()
For cont = 6 To -9 Step -3
Debug.Print cont
Next cont
End Sub

Embora não seja recomendável, você pode alterar o valor da variável de controle durante o laço. Com isso,
pode, inclusive, um valor de passo igual a 0:

Sub NãoRecomendado()
For cont = 1 To 10 Step 0
Debug.Print cont
cont = cont + 2
Next cont
End Sub

Use a instrução Exit For para sair de um laço imediatamente:

Sub SairImediatamente()
'Descomente a instrução abaixo para ver o efeito do Exit For:
'registro = "Felipe"

For cont = 1 To 10
If registro = "Felipe" Then Exit For
Debug.Print "O registro atual não é do Felipe."
Next cont
End Sub

Se você tiver laços aninhados, a instrução Exit For sai somente do nível em questão, subindo para o próximo
nível.
Do…Loop

Do…Loop é um laço que repete um bloco de instruções enquanto uma condição seja verdadeira. Observe o
exemplo a seguir:

Sub Laço1()
i = 1
Do While i <= 10
Debug.Print i
i = i + 1
Loop
End Sub

Enquanto i for menor ou igual a 10, o laço se repetirá. Note que esse exemplo é equivalente à instrução For
i = 1 to 10. Vale ressaltar que laços Do...Loop não possuem uma variável de controle que autoincrementa
como no caso de For...Next. Nesse exemplo, foi utilizada a variável i como se ela fosse uma variável de
controle do laço.

Pus a condição de saída do laço na instrução Do. Alternativamente, você poderia ter colocado na instrução
Loop, ficando Loop While i <= 10, controlando, dessa forma, onde o teste de prosseguir no laço é realizado.

Além da palavra chave While (enquanto), você pode utilizar a palavra chave Until (até que) como um
condição de saída do laço:

Sub ObterSenha()
i = 0
Do
i = i + 1
If i > 3 Then
MsgBox "Desculpe, apenas três tentativas.", vbCritical
Exit Sub
End If
Senha = InputBox("Digite a senha:")
Loop Until Senha = "Benzadeus"

MsgBox "Bem Vindo!", vbInformation


End Sub

Você não pode criar blocos Do...Loop com condições de saída tanto em Do como Loop: deve escolher em
qual das extremidades colocará a condição de saída. Por outro lado, pode criar laços suprimindo condições de
ambas extremidades. Quando isso é feito, normalmente se insere uma instrução de saída Exit Do para evitar
laços infinitos:

Sub Laço2()
Do
i = i + 3
If i >= 10 Then Exit Do
Loop
End Sub
Cuidado com laços infinitos. Eles travam o VBA, de forma que você só conseguirá fechar o aplicativo no qual
o VBA está hospedado utilizando o Gerenciador de Tarefas do Windows (Ctrl+Shift+Esc). Nesse caso,
você perderá todas informações não salvas na aplicação. Essa é uma das situações em que a sequência
Ctrl+Break não interrompe a execução da macro.

No caso do laço Do...Loop estar aninhado em outro laço Do...Loop, a instrução Exit Do sairá sairá apenas
do nível do laço em que a instrução foi chamada.
While…Wend

A instrução While...Wend é antecessora de Do...Loop, e não recomendo utiliza-la. Ela ainda está presente
no VBA apenas para garantir compatibilidade com código VBA antigo.

Em laços While...Wend, você é obrigado a especificar uma condição de saída, e essa condição só pode estar
na instrução While. Além disso, não há uma instrução de saída do laço como o Exit Do do Do...Loop. Veja
um exemplo a seguir:

Sub WhileWend()
While i < 20
i = i + 1
Debug.Print i
Wend
End Sub

Utilize Do...Loop ao invés de While...Wend.

For…Each

Laços For...Each percorrem uma coleção ou vetor. A variável de controle de um laço

O exemplo a seguir, para Word, povoa uma coleção e depois efetua um laço nos itens da coleção:

Sub Coleção()
Set clc = New Collection

clc.Add 8
clc.Add ActiveDocument
clc.Add "Felipe Costa Gualberto"
clc.Add 0
clc.Add 8

For Each var In clc


Debug.Print var
Next var
End Sub

O exemplo abaixo, para PowerPoint, faz um laço em todos os slides e imprime o índice e a quantidade de
autoformas cada slide possui:

Sub ColeçãoPowerPoint()
For Each sld In ActivePresentation.Slides
Debug.Print "Índice do slide: " & sld.SlideIndex
Debug.Print "Quantidade de autoformas: " & sld.Shapes.Count
Next sld
End Sub

O exemplo abaixo povoa os elementos de um vetor e depois mostra seus valores através de um laço
For...Each:

Sub Vetor()
Dim alValores(0 To 4) As Long

alValores(0) = 8
alValores(1) = 14
alValores(2) = -5
alValores(3) = 22
alValores(4) = 9

For Each var In alValores


Debug.Print var
Next var
End Sub

Quando aplicado em coleções, a variável de controle pode ser uma Variant, Object, ou um tipo de objeto
específico de uma coleção (como é o caso do exemplo no PowerPoint). Para vetores, a variável de controle só
pode ser do tipo Variant.

Coleções e vetores são discutidos em outras páginas deste site.

Interação do VBE com Sintaxe do Código


Você deve ter percebido que o VBE altera algumas palavras do seu código automaticamente. Por exemplo, se
no exemplo abaixo você trocar uma variável Nome por nome e desviar o cursor de inserção de texto para outra
instrução, o VBE irá alterar automaticamente todas variáveis Nome por nome:

Além disso, ele reconhece palavras chaves, nomes de procedimentos e membros de bibliotecas referenciadas,
colorindo de azul palavras chaves e capitalizando palavras reconhecidas.

Essa verificação instantânea de sintaxe é feita quando se desvia o cursor de inserção de texto de uma instrução
que foi criada, excluída ou editada.

Autoverificação de Sintaxe

O VBE detecta erros de sintaxe quando você escreve seu código. Por exemplo, Se você escrever a expressão
abaixo na atribuição de lng e pressionar Enter, receberá o aviso indicado:

Alguns avisos são coerentes, mas outros não. Em alguns casos, mesmo se você clicar em Ajuda, não saberá
por que há erro de sintaxe e terá que tentar reescrever o código até entender por que a sintaxe está incorreta.

Pode ser desagradável receber notificações de erro de sintaxe do VBE para cada instrução escrita. É possível
remover esses avisos, no entanto, sugiro que faça isso somente quando que estiver dominando a sintaxe do
VBA.
Para desabilitar essas notificações, vá na guia Ferramentas >> controle Opções >> guia Editor e desmarque
Autoverificar sintaxe e clique em OK:

Mesmo com essa opção habilitada, se houver erro de sintaxe numa linha em que você escrever uma instrução
com erro de sintaxe, o VBE a colorirá em vermelho (cor padrão para erros) para que você saiba que cometeu
um erro de sintaxe.

Desabilite a autoverificação de sintaxe apenas se você já for um usuário experiente na sintaxe do VBA.