apostila-sobre-visual-basic

Prévia do material em texto

Apostila sobre Visual basic
Atualidades
117 pag.
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
1)O que é programação ? ..................................................................................2
2)Apresentando o Visual Basic......................................................................... 3
3)Usando Forms, objetos e controles.............................................................. 5
4)Propridades...................................................................................................... 6
5)O que são Forms(Formulários)........................................................................7
5)Métodos.......................................................................................................... ..7
6)Eventos............................................................................................................. 7
7)Controles........................................................................................................ . 8
 Conhecendo melhor o formulário.................................................................. ..11
 Botão de Comando..........................................................................................14
 Label...............................................................................................................17
 TextBox...........................................................................................................18
 Option Button..................................................................................................22
 Frame..............................................................................................................22
 CheckBox........................................................................................................24
 ListBox.............................................................................................................25
 ComboBox.................................................................................................... ..30
 MaskedBox......................................................................................................32
8)Contruindo um Sistema.................................................................................35
19)Menus............................................................................................................37
10)Menus Dinâmicos.........................................................................................39
11)O Código........................................................................................................40
12)Variáveis........................................................................................................41
13)Modifcadores de Acesso.............................................................................48
14)Constantes....................................................................................................49
15)Operadores...................................................................................................50
16)Comandos Condicionais e Loops..............................................................52
17)Contadores...................................................................................................58
18)SubProcedimentos......................................................................................60
19)Funções........................................................................................................62
20)Matrizes........................................................................................................63
21)Lógica de programação..............................................................................67
22)As Bibliotecas..............................................................................................68
23)Comandos, Funções e Objetos Nativos....................................................69
24)Funções Internas.........................................................................................74
 Funções Numéricas........................................................................................74
 Funções de String.......................................................................................... 75
 Funções de Data e Hora.................................................................................78
 Funções de Conversão...................................................................................81
 Funções para Gerenciamento de Matrizes.....................................................83
 Funções Lógicas.............................................................................................84
 Funções de Disco.............................................................................................85
 Funções de Escolha..........................................................................................88
 Formatação de Dados.......................................................................................91
25)Banco de Dados
 Criando um Banco de Dados............................................................................99
 O que são tabelas?...........................................................................................100
 Criando uma Tabela......................................................................................101
 Criando Índices..............................................................................................106
 Definindo a Chave Primária..........................................................................107
 Acessando o Banco de Dados através do Visual Basic.................................108
26)Objetos de dados
 Data Control...................................................................................................118
 Data Grid........................................................................................................120
27)Impressão
 Printer.............................................................................................................122
 Crystal Reports...............................................................................................129
 Noções de Linguagem SQL............................................................................145
O que é Programação ?
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
 Se você nunca teve contato direto com programação na vida, talvez esteja se 
perguntando, o que é afinal, programação. Embora talvez, você nunca tenha programado, 
tudo que usamos, foi de alguma forma programado. Isso não acontece só no mundo da 
informática, mas acontece também no mundo real. Por exemplo:
- Nas indústrias, já faz muito tempo que as máquinas vem sendo programadas para fazer 
determinadas tarefas.
- Na sua casa, Você com certeza já programou o rádio-relógio para despertar de manhã, já 
deve ter programado o vídeo-cassete e agora o DVD.
- Um automóvel, por exemplo, pode ser programado para limitar a velocidade máxima 
através de um chip e para injetar mais gasolina depois que ele atingir uma velocidade X.
 Como você pode ver, quase tudo a nossa volta foi de uma certea forma programado e 
com a informática é assim também. OS famosos softwares que todo mundo usa (Windows, 
Word, Excel, etc..) só existem por que foram programados.
 
Como programamos um software?
 
Através de instruções em conjunto, que formarão o código fonte
dele.
Exempo de um código :
Public Sub Main()
 Msgbox “Hello, World”
 End
End sub 
 Claro, que neste exemplo estou usando comandos do Visual Basic, que talvez alguns de 
vocês não conheçam. Não se preocupe em entender esse código agora. Vamosagora usar 
comandos fictícios para ilustrar o que fizemos neste exempo:
Ao iniciar()
 Mostrarmensagem “Hello,World”
 Fim
FinalDoEvento
 Não é necessário ser nenhum gênio para entender o que “msgbox” e “end” do exemplo 
anterior faziam. Pois se olharmos o último exemplo , notamos que no lugar de “msgbox” 
colocamos “mostrarmensagem” e no lugar do “end” usamos “fim”. O Interpretador irá ler 
a primeira instrução(msgbox) e irá exibir uma mensagem dizendo:”Hello,World” e, logo 
após encerrará o programa com o “End”.
 O interpretador sempre segue uma ordem lógica para ler as intruções, então não podemos 
colocar tudo de forma desordenada no código do programa, devemos colocar uma a uma, 
na ordem que precisamos que ele leia primeiro. Mais tarde veremos comandos condicionais 
e de laço para manipular essa execução. 
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
 Um bom programador tem que ser curioso. Deve gostar de saber como as coisas 
funcionam debaixo da capô, não deve se preocupar em travar a máquina com “loops 
infinitos”(se você não sabe o que é loop, veremos mais tarde) ou de qualquer outra forma. 
Programação é uma arte. Envolve criatividade, análise , dedicação e muita paciência. 
 
Apresentando o ambiente do Visual Basic 6
Ao abrirmos o Visual Basic, ele abrirá uma janela nos perguntando o tipo de projeto a qual 
desejamos criar. 
 No momento nos limitaremos somente a usar o padrão “Standard Exe”, que é o que 
usualmente usamos na maioria dos casos. Ele abrirá um projeto vazio, com os controles 
nativos do Visual Basic á esquerda, um formulário e suas respectivas propriedades a direita.
 Vejamos na figura:
 Figura 1
 Form(Formulário) 
 
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
Usando Forms, Objetos e Controles
Objetos – Começaremos pelos Objetos já que os demais(Forms e Controles) Também se 
enquadram como objetos. Devemos nos acostumar com os objetos, pois estaremos sempre 
cercado deles. Qualquer Botão, Form, Relatório, Controles, entre outros se enquadram 
como objetos. 
Na figura abaixo temos exemplos de objetos :
Figura 1
Todos os objetos tem propriedades, eventos e métodos a eles associados. Veremos mais 
tarde o que são métodos, eventos e propriedades dos objetos. No entanto o que é necessário 
saber agora é o que são objetos. Vemos que objeto é tudo aquilo que contem métodos, 
eventos e propriedades.
O que são Forms (Formulários)?
 Na verdade, quase todas as janelas que vemos nos aplicativos são Forms(Formulários). 
Ele serve de base para colocarmos nossos controles. 
 Na figura 1 (Exemplo anterior), vemos que existe um formulário, no nosso caso(Form1), 
com controles dentro dele(Caixa de texto, Lista e Botão).
 Os forms(Formulários), como qualquer objeto, possuem métodos, eventos e propriedades 
a qual veremos mais tarde.
O que são Propriedades?
 Propriedades, como o próprio nome sugere, são os atributos que podemos definir para 
cada objeto, seja um formulário , controle, etc...
 Quando selecionamos um objeto, no Visual Basic, aparecerá no canto direito da tela uma 
janela onde poderemos definir as propriedades para esse objeto. Podemos definir a cor, o 
nome e muitas outras propriedades.
 Algumas propriedades de alguns objetos podem ser definidas em tempo de execução, 
outras porém são somente leitura, ou seja, podemos verificar os valores de tais 
propriedades, mas não podemos modicá-los. Para atribuir um valor de propriedade a um 
objeto em tempo de execução usamos o nome do objeto , seguido de ponto, o nome da 
propriedade, o sinal de igual e o valor que você quer atribuir. 
Exemplo :
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
ObjetoTal.Cor=”Azul”
Claro, que o “ObjetoTal” e a propriedade “Cor” desse objeto são fictícios. Um Exemplo 
real seria :
Text1.Text=”Exemplo”
 Não se preocupe em entender o que quer dizer a propriedade “Text”, mas sim em 
entender apenas como se faz para definir as propriedades em tempo de execução. 
 É importante ressaltar que cada objeto tem propriedades diferentes. Claro que todos tem 
propriedades em comum, mas um tipo de objeto sempre terá propriedades diferentes de 
outro tipo. 
Métodos
 Métodos são ações que agem sobre os objetos, por exempo, se temos um objeto carro, 
teríamos a propriedade “Cor” semdo como Azul. Poderámos ter um método chamado 
“Acelerar” e outro “Freiar”. Poderíamos também ter um método “abastecer”.
 Em exempo prático seria termos um formulário chamado “Form1”. Existe um método 
chamado “Show” que agem sobre formulário e outros objetos. Ele serve para exibir um 
formulário. Como faríamos para exibir o nosso formulário(Form1)?
Form1.Show
Será exibido o formulário. Este é o procedimento para se aplicar os métodos. Assim como 
as propriedades, cada objeto tem vários métodos diferentes. Podemos também passar 
parâmetros para esses métodos. Veremos isso mais tarde
Eventos
 
 Vamos tomar um exemplo prático. Voltaremos ao nosso exemplo do automóvel. Assim 
como podemos atribuir sua propriedade cor para Azul, executar um método “Acelerar”, 
podemos ter um evento 
“Ao Bater”.
 Um evento é gerado quando acontece algo com o objeto, por exemplo, se tivermos um 
Caixa De Texto e clicarmos em cima dela o Objeto TextBox(Caixa de Texto) vai gerar um 
evento chamado “Click()”. Dentro deste evento colocaríamos um bloco de código com as 
instruções que queremos que o programa faça cada vez eu o usuário clicar na Caixa de 
Texto. Assim como este , exitem muitos outros eventos e cada objeto tem seus eventos em 
comum, assim como tem eventos próprios de cada objeto. 
 Veremos mais tarde detalhadamente vários tipos de eventos.
 
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
 Os Controles
 
Ao abrirmos o ambiente do Visual Basic, podemos ver á esquerda a Caixa de Ferramentas. 
 
 Esses controles que você está vendo na figura são os controles nativos do Visual Basic. 
Podemos adicionar mais controles a esta Caixa de Ferramentas. Veja como :
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
Irá aparecer uma lista com todos os controles disponíveis. Para que eles apareçam na nossa 
Caixa de Ferramentas devemos selecion-alos nessa lista. Um controle, na verdade, é 
representado por um Arquivo com extensão “OCX”. Podemos ver nessa janela que o Visual 
Basic 
Mostra o local onde determinado componente, ou seja , o arquivo OCX, se encontra. Se o 
controle que você procura não se encontra nessa lista, basta você saber onde o arquivo 
OCX dele se encontra, podendo assim adicioná-lo a lista.
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
Conhecendo melhor o Form(Formulário)
Veremos agora as principais propriedades, métodos e eventos do Form. Começremos com 
as principais propriedades. São elas:
Name – Define o nome do formulário. Um nome de objeto deve começar obrigatoriamente 
com uma letra, mas também pode conter números . Espaços em branco e caracteres 
como(#$&+-^) não são permitidos.Caption – É a título do formulário que aparece no seu topo. Podemos colocar qualquer 
valor nessa propriedade.
Appearence – Define se o mode de exibião será 3D ou Normal.
BakColor- Muda a cor de fundo do formulário. 
Como você pode ver, você pode optar entre 2 sistemas de cores. 
O Palette e o System , sendo que o System mostra o sistema de cores do Windows, no caso 
de você querer fazer uma aplicação bem padrão Windows, enquanto o Palette irá lhe 
mostrar várias outras cores e você pode personalizar suas próprias cores também.
BorderStyle: Muda o tipo de borda do formulário. None: sem borda, sem barra de titulo, 
sem menu de controle, sem botão maximizar e sem botão minimizar, e não pode 
redimensionar a janela.
Fixed Single: Borda fixa. Aceita o Menu de Controle, Maximizar, Minimizar, barra de 
título, mas não pode ser redimensionado.
(Default) Sizable: Borda comum. Possui o Menu de Controle, Maximizar, Minimizar, 
barra de título e pode ser redimensionada.
Fixed Dialog: Muito usada para janelas que vão manter um dialogo com o usuário. Ela 
pode ter Menu de controle e a barra de título, mas não terá os botões de maximizar e 
Minimizar. Não pode ser redimensionada.
Fixed ToolWindow: Não possui o menu de controle, o botão Maximizar e o botão 
minimizar. Também não pode ser redimensionada. Aparecerá somente a barra de título e o 
botão Fechar próprio do Windows 95. Este tipo de formulário não aparece na barra de 
tarefas do Windows.
Sizable ToolWindow: Não possui o menu de controle, o botão Maximizar e o botão 
minimizar. Pode ser redimensionada. Aparecerá somente a barra de título e o botão Fechar 
próprio do Windows 95. Este tipo de formulário não aparece na barra de tarefas do 
Windows.
ControlBox: Retira ou coloca o menu de controle e os botões maximizar, minimizar e 
fechar da janela.
8
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
Enabled: Se esta opção estiver com False, ou seja, estando o Enabled desabilitado, isto 
indicará que nenhum objeto desta janela, e nem a própria
janela, poderá responder a eventos gerados pelo usuário, como clicar do mouse, 
pressionamento de teclas, etc. 
Font: Escolhe a fonte de letra padrão que será usada para todos objetos inseridos neste 
formulário.
Icon: Nesta propriedade escolhemos um arquivo de ícone para associar a esse formulário. 
Esse ícone é o que vai aparecer quando a janela for minimizada e no lado esquerda da barra 
de título ( Menu de Controle ).
KeyPreview: determina se os eventos do teclado no formulário serão executados antes dos 
eventos correspondentes aos Objetos inseridos no formulário.
MaxButton: Habilita ou não o botão de maximização.
MDIChild: Determina se a janela será uma janela filha. Ou seja, terá uma outra janela 
mestre que agrupara o Form que se esta criando.
MinButton: Habilita ou não o botão de minimizar.
MouseIcon: Sempre que o mouse for movido em cima do formulário, o ícone associado a 
esta propriedade aparecerá (desde que a propriedade MousePointer esteja customizada).
MousePointer: Nesta propriedade especificamos o tipo de ponteiro que o mouse terá 
quando se mover sobre o formulário. Veja os tipos existentes:
0 (Default) Ponteiro padrão. 
1 Ponteiro em forma de seta
2 Ponteiro de seleção exata
3 Seleção de escrita
4 Ícone 
5 Seleção de Mover Objetos
6 Redimensionamento na diagonal
7 Redimensionamento na vertical
8 Redimensionamento na diagonal
9 Redimensionamento na horizontal
10 Seleção alternada
11 Sinal de ocupado.
12 Não disponível ( Ocupado )
13 Trabalhando em segundo plano ( Somente 32-bit Visual Basic.)
14 Seleção de Ajuda. (Somente 32-bit Visual Basic.)
15 Todos os Tamanhos. (Somente 32-bit Visual Basic.)
99 Aparece o ícone escolhido na propriedade MouseIcon
Picture: Inseri uma figura em nosso formulário como papel de parede.
ShowInTaskbar: Habilita ou não a possibilidade da janela aparecer na barra de tarefas do 
Windows.
Visible: Determina se quando executarmos o programa essa janela irá ficar visivel ou 
invisível.
9
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&utm_medium=document&utm_campaign=watermark
WindowState: Determina se, quando executarmos o programa, a janela irá aparecer na 
tela do computador Normal, Maximizada ou Minimizada.
Bem, agora que você já conhece as principais propriedades do Form, vamos “Brincar um 
pouco”. 
Abra o Visual Basic e crie um projeto padrão. Você verá que por padrão o Visual Basic já 
coloca um Form no projeto. Então modificaremos este Form. Altera as seguintes 
propriedades:
Name = “FrmCadastro”
Caption=”Cadastro De Clientes”
BorderStyle = 1 – Fixed Single
 Altere a cor de fundo do formulário. Associe um ícone ao formulário e coloque uma 
imagem de fundo. 
 Feito isso, rode o programa teclando <F5>. Feito isso, veja o que acontece. Depois altere 
as propriedades, até mesmo as que não conhece. Procure conhecer todas, mude-as , execute 
o programa e veja o que acontece.
 
CommandButton ( Botão de Comando)
 O Botão de Comando é utilizado pelo usuário para executar determinadas ações. 
Quem determina essas ações é o programador através de instruções associadas aos eventos 
do CommandButton. Existe um padrão para se utilizar os botões de comando. Por exemplo. 
Em um Form(Formulário), com vários botões procure sempre deixá-los do mesmo 
tamanho, mesmo que o texto deles seja de tamanhos diferentes.
 
 
 Errado Certo 
Vamos as propriedades do CommandButton ou Botão de Comando:
Cancel: Se esta opção for ajustada como verdadeira, o botão será associado a tecla ESC, e 
sempre que pressionarmos esta tecla será como se tivéssemos apertado o botão.
Caption: O título que será exibido dentro do botão.
Default: Estando o botão com essa propriedade como True indica que este botão será o 
Padrão da janela, e sempre que apertarmos a tecla Enter será como se tivéssemos apertado 
o botão.
Enabled: Determina se o botão será habilitado para pressionamento por parte do usuário 
ou não.
Font: Escolhe a fonte de letra que o Caption terá.
Name: O nome que daremos para o Objeto botão de comando.
Visible: Determina se o botão será visível para o usuário quando o programa estiver em 
execução.
10
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Style: Escolhe se o botão terá elemento gráfico em seu interior. Se escolher Style do tipo 
"Graphical" o CommandButton aceitará figuras, e elas devem ser inseridas na propriedade 
Picture do objeto CommandButton.
TabStop: Quando temos um formulário com diversos controles, podemos nos mover 
através desses controles usando o teclado, através da tecla TAB ou através de outras teclas, 
como veremos mais tarde. Quando a propriedade TabStop está desabilitada, ou seja com o 
valor “False” então, ao nos movermos através dos controles o Botão será ignorado e o foco 
movido ao controle seguinte.
TabIndex: o Movimento de troca de foco, que vimos na propriedade TabStop tem uma 
ordem, e essa ordem é seguida pela propriedade TabIndex do botão, a qual devemos 
atribuir um numero, esse número será usado como a ordem que o foco é percorrido pelos 
controles, ou seja, se tivermos um controle com a propriedade TabIndex definido como 1, 
e outro com a propriedade TabIndex definido como 2, o que tem o número 1, receberá o 
foco primeiro do que tem o número 2 na propriedade TabIndex.
ToolTipText – A não muito usada, mas não menos importante propriedade ToolTipText, 
quando não está vazia exibe uma pequena ajuda sobre o controle, quando o usuário passa o 
mouse em cima do respectivo controle.O texto que aparecerá será o definido na 
propriedade ToolTipText.
Vamos agora á um exemplo prático envolvendo Botões de Comando:
- Crie um Form e com as seguintes propriedades:
Caption = “Exemplo do CommandButton”
Name = “FrmExemplo”
- Insira neste Form 3 botões de Comando com as seguintes propriedades:
Botão 1:
Name = “CmdOk”
Caption = “OK”
Botão 2:
Name = “CmdCancelar”
Caption = “Cancelar”
Botão 3:
Name = “CmdSair”
Caption = “Sair”
Feito isso, dê um duplo click no objeto CmdOk. Você verá que ao clicar nesse botão abrirá 
uma janela de código, correpondente ao evento Click() do botão. Esse evento é acionado 
toda vez que o usuário clicar no botão. 
Dentro deste evento vamos inserir a seguinte linha:
Msgbox “Você Clicou OK”
11
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Faça o mesmo processo com os demais botões. Apenas troque o texto que exiet dentro 
das aspas pelo texto de sua preferência. Ao fazer esse processo com o botão “CmdSair”, 
insira uma linha a mais:
Unload me
 Execute o projeto e veja o que acontece. Você viu que criar a interface e fazer com que as 
coisas “funcionem” não é nada difícil. Basta conhecer bem as propriedades, eventos e 
métodos dos objetos.
Vamos agora conhecer os principais eventos do objeto CommandButton. Devo lembrar que 
muitos desses eventos e até mesmo propriedades, dependo do caso até métodos, não são 
exclusivo do CommandButton , ou seja, outros objetos também tem as mesmas 
particularidades. 
Eventos do CommandButton
 A maioria dos eventos do CommandButton não são usados, por isso, vamos nos reter 
apenas nos mais importantes. São eles:
Click() – Esse é o mais importante de todos os eventos do CommandButton. Acontece 
sempre que o botão é clicado.
GotFocus() – Um evento que acontece sempre que o CommandButton recebe o foco.
LostFocus() – Esse evento é chamado sempre que o CommandButton perde o foco.
MouseMove() – É chamado toda vez que o usuário mover o mouse por cima do 
CommandButton. Na prática isso não é muito usado, sendo que na maioria das vezes, um 
evento desses seria útil apenas quando quiséssemos que o evento informasse a função do 
botão ao usuário, mas isso pode ser feito facilmente usando a propriedade “ToolTipText” 
do botão.
 
Métodos
 O CommandButton tem 7 métodos, mas na prática, dificilmente usamos todos. Na 
verdade, usamos quase sempre apenas um deles:
SetFocus - Este método que não só é usado por CommandButtons, mas na verdade, é 
usado por quase todos os controles, tem a função de passar o foco para o objeto que 
quisermos. Exemplo:
CmdOk.SetFocus
Irá passar o foco para o objeto CmdOk.
O Label 
 Não há muito segredo para se trabalhar com Labels. O Label na verdade, não passa de 
uma legenda que inserimos no Form. Sua finalidade é inserir um texto no formulário. Isto 
nos será útil quando precisarmos fazer um cadastro ou coisa parecida. Vamos as suas 
principais propriedades:
12
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Name – O nome que será usado pelo Label.
Caption – Essa é a propriedade principal do Label. A legenda que o Label terá.
Alignment: Determina o alinhamento que o texto terá dentro do label.
AutoSize: Com esta propriedade habilitada indicamos ao Controle para automaticamente 
dimensionar seu tamanho ao tamanho do texto do label.
Note na figura que, quando o AutoSize foi passado para True, as marcas de seleção do label 
foi ajustado para o tamanho do texto “label1”.
BackColor: Escolhe a cor de fundo que envolverá o label.
BackStyle: Escolhe entre o fundo Transparente ou Opaco para o label.
BorderStyle: Escolhe entre colocar uma moldura envolvendo o label ou não.
Enabled: Habilita ou desabilita o objeto. Quando esta em False fica com a cor de seu 
conteúdo acinzentada.
Font: Escolhe a fonte de letra que terá o texto digitado na propriedade Caption.
ForeColor: Escolhe a cor da fonte de letra
Name: Nomeia o Objeto label. Como já foi dito é importante que todos os objetos seja 
nomeado. A inicial do label é “lbl”.
Visible: Indica se o objeto será visível ou não para o usuário.
WordWrap: Quando o AutoSize esta em true, não é possível expandir o texto digitado na 
propriedade Caption em outras linhas. Mas se passarmos essa propriedade WordWrap para 
True isto poderá ser feito, bastando para isto dimensionarmos o label.
O TextBox 
 O TextBox é, com certeza, um dos controles mais importantes que você vai usar. 
Formulários de cadastro, entradas de dados e até mesmo consultas necessitam que você 
entre com os dados. Claro que temos outros controles disponíveis para isso, mas na maioria 
dois casos, usamos o TextBox. Vamos as suas principais propriedades:
BackColor: Escolhe a cor de fundo da Caixa de Texto. Geralmente é branco. 
BorderSytle: Tipo da borda: Fixa e simples, ou sem borda.
Enabled: Estando False o objeto não estará habilitado para interagir com o usuário.
Font: Escolhe a fonte de letra que será mostrada dentro da caixa de texto.
ForeColor: Escolhe a cor da fonte de letra.
Locked: Estando em false trava qualquer digitação na caixa de texto
MaxLength: Quantidade máxima de caracteres dentro da caixa de texto.
MultiLine: Habilita a possibilidade de se digitar mais de uma linha na caixa de texto.
Name: Nomeia o objeto TextBox. Geralmente com a inicial txt. Exemplo: Se formos usar 
essa caixa de texto para que o usuário digite o nome do paciente, poderíamos abreviar 
assim: txtNomePaciente.
PasswordChar: Se durante a digitação de qualquer dado na caixa de texto, quisermos que 
o Visual Basic mostre outro caractere no lugar do caractere digitado, é só especificarmos 
aqui qual queremos que seja mostrado. Muito usado para digitação de senhas.
13
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
ScrollBars: Estando a propriedade MultiLine habilitada, é interessante colocarmos um 
ScrollBars na caixa de texto, pois ele acrescentará uma barra de rolagem que poderá ser:
rolagem que poderá ser:
Text: A propriedade Text é a mais importante deste Objeto. Todo o texto digitado pelo 
usuário dentro da caixa de texto é incorporado nesta propriedade. 
Eventos do TextBox
Irei citar aqui alguns dos principais eventos relacionados a caixa de texto. 
Lembramos que todos os Eventos ocorre quando o usuário faz alguma ação. Por exemplo: 
se ele aperta um botão aciona o Evento Click, se ele digita algo numa caixa de texto, 
aciona o evento Change e KeyPress, se ele movimento o mouse sobre um objeto, aciona o 
evento MouseMove. 
Vamos explicar esses eventos aqui, mas antes é importante entendermos que cada 
movimento ou ação do usuário dispara um evento no programa. Mas esses eventos somente 
terão alguma reação se programarmos isto na janela de codificação.
Change: Ocorre sempre que o usuário altera o valor contido na caixa de texto.
Click: Ocorre quando o usuário pressiona o botão esquerdo do mouse sobre a caixa de 
texto.
DlbClick: Se o usuário apertar duas vezes o botão esquerdo do mouse sobre a caixa de 
texto
KeyDown: Ocorre quando o usuário aperta uma tecla no teclado.
KeyUp: Ocorre quando o usuário solta a tecla apertada.
KeyPress: Ocorre quando uma tecla é pressionada e solta. Como argumento possui uma 
variável cujo conteúdo é a tecla pressionada (código correspondente na tabela ASCII).
Cod. Cod. Cod. Cod.
0 · 32 Espaço 64 @ 96 `
 1 · 33 ! 65 A 97 a
 2 · 34 " 66 B 98 b
 3 · 35 # 67 C 99 c
 4 · 36 $ 68 D 100 d
 5 · 37 % 69 E 101 e
 6 · 38 & 70 F 102 f
 7 · 39 ' 71 G 103 g
 8 Backspa
ce
 40 ( 72 H 104 h
 9 Tab 41 ) 73 I 105 i
 10 42 * 74 J 106 j
 11 · 43 + 75 K 107 k
12 · 44 , 76 L 108 l
13 Enter 45 - 77 M109 m
 14 · 46 . 78 N 110 n
 15 · 47 / 79 O 111 o
14
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 16 · 48 0 80 P 112 p
 17 · 49 1 81 Q 113 q
 18 · 50 2 82 R 114 r
 19 · 51 3 83 S 115 s
 20 · 52 4 84 T 116 t
 21 · 53 5 85 U 117 u
 22 · 54 6 86 V 118 v
 23 · 55 7 87 W 119 w
 24 · 56 8 88 X 120 x
 25 · 57 9 89 Y 121 y
 26 · 58 : 90 Z 122 z
 27 Esc· 59 ; 91 [ 123 {
 28 · 60 < 92 \ 124 |
 29 · 61 = 93 ] 125 }
 30 · 62 > 94 ^ 126 ~
 31 · 63 ? 95 _ 127 ·
· Estes caracteres não são aceitos pelo Microsoft Windows.
MouseMove: Ocorre quando movemos o ponteiro do mouse sobre a caixa de texto.
MouseDown: Ocorre quando o usuário aperta o botão do mouse (seja da direita ou da 
esquerda) sobre a caixa de texto.
MouseUp: Ocorre quando o usuário solta o botão do mouse (seja da direita ou da esquerda) 
sobre a caixa de texto.,
 Bem, agora que você já conhece as propriedades do TextBox, assim como os seus 
eventos, vamos colocar em prática tudo isso. Que tal um exemplo envolvendo Labels, 
TextBoxs e CommandButtons ?
 Lembra-se daquele formulário que fizemos como exemplo do CommandButton ? 
 Vamos melhorá-lo:
 Quanto aos botões, você pode deixar todos. Apenas os arraste para o canto direito do 
formulário. Coloque 3 Labels. Você verá que ao colocar a Label dentro do formulário ela 
tem a propriedade Caption
Definida como o nome do Label. Você deve trocá-la. Coloque uma com o Caption = 
“Código”, outra =”Nome” outra = “Endereço”. O formulário deve ficar assim :
Agora coloque 3 TextBoxs na seguinte ordem, de cima pra baixo:
TxtCodigo
Text=””
TxtNome
Text=””
TxtEndereco
Text=””
15
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Defina para que a TxtCodigo aceita no máximo 5 caracteres e txtnome no máximo 20. 
Defina para que ao pressionarmos a tecla <TAB> o foco passe primeiro pelas caixas de 
texto, de cima para baixo, e depois pelos botões, novamente, de cima para baixo. Veremos 
mais tarde como fazer as TextBoxs aceitarem somente números, ou fazer o inverso(fazem 
com que elas não aceitem números) através do evento keypress ou keydown.
OptionButton 
 O OptionButton ou botão de opção serve para escolhermos entre várias opções dentro do 
formulário. Podemos ter vários dentro do formulário, mas apenas um poderá ser marcado, 
pois quando marcamos um, o outro é automaticamente desmarcado. Para usarmos vários 
grupos de opções dentro do mesmo formulário, teríamos que usar um Frame, Objeto que 
veremos mais tarde. 
Na figura acima você pode ver dos grupos de OptionButtons operando independentemente, 
fazendo uso dos Frames. Se eles estivessem soltos no formulário, só poderíamos marcar 
uma opção, ou seja, ou marcaríamos o Estado Civil ou marcaríamos o Sexo.
Vejamos agora as principais propriedades do Frame:
Alignment: Determina se o texto ficará do lado direito ou esquerdo do botão de opção.
Caption: O texto que será anexado ao Objeto.
Enabled: Habilita ou não o objeto. Estando desabilitado o usuário não poderá selecionar a 
opção, e a cor do texto será acinzentado.
Name: O nomeia o Objeto. A inicial abreviada que se usa é “opt”.
Value: True para quando a opção esta selecionada e False para quando a opção não esta 
selecionada.
Eventos do OptionButton
 Os eventos do OptionButton são praticamente os mesmo usados pelas TextBox, sendo 
que não há nenhum em especial.
 
O Frame 
 É claro que, depois do exemplo anterior não poderíamos deixar de conhecer o Frame. 
Esse controle, como você viu anteriormente serve para organizarmos melhor os controles 
dentro do formulário. Todos os controles existentes dentro do Frame podem ser 
desabilitados ou habilitados definindo a propriedade Enabled de Frame como True ou 
False. Além desses recursos de aninhar controles, o Frame também traz uma interface mais 
limpa para o usuário. Vamos conhecer algumas de suas propriedades:
Caption: Coloca um texto no topo da moldura. Não é obrigatório. 
16
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Enabled: Determina se todos todos os objetos colocados no interior da moldura estará ou 
não disponível para o usuário.
Name: Nome dado ao objeto. A inicial abreviada é “fra”. Cuidado para não colocar “frm” 
é a abreviatura do Objeto Form.
Um exemplo de Frame com a propriedade Enabled definida como False:
Como você pode ver o Frame da esquerda está com a propriedade Enabled definida como 
False. Estando assim não conseguiremos acessar nem mesmo os controles que estão dentro 
do Frame. 
 Esse recurso é muito útil quando queremos restringir ao usuário o acesso a certas opções.
 O frame, assim como o OptionButton, também não possui nenhum evento em especial, 
sendo a maioria idênticos aos do OptionButton.
CheckBox 
 A CheckBox ou Caixa de checagem é utilizado para marcar opções. Não funciona igual 
ao OptioButton, pois com a CheckBox podemos marcar várias opções, uma, ou nenhuma 
opção, sendo que com o OptionButton, podemos selecionar apenas uma.
Alignment: Especifica se o texto ficara do lado esquerdo da caixa.
 
Caption: O texto anexado ao Objeto CheckBox.
Enabled: Habilita ou não esse Objeto. Estando desabilitado não aceitará que o usuário faça 
evento com a caixa de checagem.
Font: Escolhe uma fonte de letra para o texto digitado no Caption
Name: Nomeia o Objeto. A inicial abreviada para este tipo de controle é “chk”.
Value: Determina o estado o objeto: 0 - Unchecked, 1 - Checked e 2 - Grayed.
Eventos
 O CheckBox tem praticamente os mesmo eventos do OptionButton.
Bem, agora que já conhecemos vários controles, assim como suas respectivas propriedades, 
métodos e eventos, vamos criar um Form utilizando vários desses objetos. Faremos o 
seguinte:
Primeiro – Crie um Form com as fontes, cores e ícones de sua preferência. Será um 
cadastro de clientes. Nesse cadastro será necessário:
Nome, endereço, bairro e cidade. Para isso serão necessárias 4 TextBoxs e 4 Labels, Certo ?
Nomeia-as e defina as suas propriedades de acordo com o que você acha necessário(Não 
esqueça que você vai se referir aos controles dentro do código através dos seus respectivos 
nomes, por isso siga a regra de nomenclatura adequada ou utilize um nome que você tem 
certeza de que não irá esquecer).
17
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Segundo – Insira 2 Frames: Um que terá um grupo de opções com OptionButtons e se 
referirá ao sexo do cliente, que obviamente terá 2 opções(Masculino ou Feminino). O outro 
Frame se referirá ao estado civil do cliente. Teremos as seguintes opções:
1- Solteiro
2- Casado
3- Divorciado
4- Viúvo
 Todas essas opções serão representadas pelos OptionButtons que você vai inserir dentro 
do respectivo Frame. Siga as regras de nomenclatura padrão para atribuir os nomes aos 
Frames e Optionbuttons.
Terceiro – Insira 3 botões no formulário, um botão de Ok, um botão de Cancelar e um 
botão de Sair. Defina as suas propriedades (nomes, fontes, legendas, ícones, etc...).
Quarto – Insira um CheckBox, que vai ser utilizado para saber se o cliente reside em 
Cachoeira do Sul. A legenda desse CheckBox poderia ser “Reside em Cachoeira do Sul” ou 
qualquer outra de sua preferência desde que pergunte se o cliente mora ou não em 
Cachoeira do Sul.
Quinto – Deixe todos os controles de modo que o foco passe primeiro pelas TextBoxs, de 
cima para baixo, depois pelas opções, da esquerda para direita, e depois pelos botões, de 
cima para baixo.
No eventoClick() do Botão OK coloque o seguinte código:
MsgBox “OK”
Prossiga com os demais da mesma forma, trocando apenas o “OK” pelo nome do botão. 
Sexto - Bem, agora que já criamos a interface vamos fazer com que as coisas funcionem. 
Se você observar no Form, poderemos ver que existe uma Caixa de Texto, onde é 
perguntado ao usuário a cidade do cliente. No entanto, existe um CheckBox ou caixa de 
checagem que pergunta ao usuário se o cliente reside em Cachoeira do Sul. Ora, se 
soubermos que o cliente reside em Cachoeira do Sul não seria necessário informar a 
cidade.Para isso, será necessário associar a um evento do CheckBox, uma instrução que 
limpasse a caixa de texto, para caso já tivéssemos digitado alguma valor como Cidade, e 
desabilitasse a mesma para que não colocássemos nenhum valor, sendo que o cliente reside 
em Cachoeira do Sul. Mãos a obra.
O ListBox 
 O ListBox ou caixa de listagem é uma caixa a qual podemos adicionar itens, removê-los 
ou selecioná-los.
 
 O ListBox cria um índice com o número do item selecionado. Este índice sempre inicia 
pelo zero, ou seja, se selecionarmos o primeiro item, o número dele será zero. Se 
18
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
selecionarmos o segundo, ele retornará um. Este índice é visível através de uma 
propriedade em tempo de execução que veremos mais tarde.
O ListBox é útil para selecionamos nomes ou outro tipos de dados, removê-los ou 
adicioná-los de acordo com a nossa necessidade.
 Vamos conhecer agora as suas propriedades:
Columns: Determina a quantidade de colunas que a caixa de lista terá. Quando esta com 0 
(zero) significa que terá somente uma coluna e a barra de rolagem será vertical. Se o valor 
desta propriedade for 1 será formado também somente uma coluna mas a barra de rolagem 
será horizontal. Valor 2 significa que os itens inseridos no ListBox serão ajustados em 2 
colunas, e assim por diante.
 
Enabled: Habilita ou não o ListBox para o usuário selecionar algum item no objeto.
IntegralHeight: Determina a possibilidade dos itens dentro da caixa de lista ser exibido de 
forma parcial. 
 
List: é o Local onde digitamos os itens que estarão dentro do ListBox.
 
MultiSelect: Quando esta propriedade esta habilitada significa que a caixa de lista aceitará 
múltiplas seleções, ou seja, poderá ser selecionado mais de um ítem. As opções são 0 - 
None para seleção somente de 1 ítem. 1 - Simple para seleção de vários itens usando 
apenas o clicar do mouse ou barra de espaço. 2 - Extended é o padrão do Windows para 
multiplas seleções. Para selecionar mais de 1 item usa-se a combinação de tecla CTRL + 
Click do mouse ou barra de espaço.
Name: Nome que o Objeto ListBox terá. A abreviação padrão é “lst”.
Sorted: Classifica os itens existentes dentro do ListBox em ordem alfabética ou numérica 
ascendente. Esta propriedade em tempo de execução tem a finalidade de informar o estado 
que se encontra o Sorted. 
Style: O Estilo Standard é o padrão, a partir do Visual Basic 5 acrescentou-se o Estilo 
CheckBox, onde os itens existentes no ListBox são acompanhados de um quadradinho do 
lado esquerdo para se fazer a seleção dos itens. Para multiplas seleções esse tipo de ListBox 
é mais intuitivo para o usuário. 
Vamos agora conhecer as propriedades em tempo de execução. Essas propriedades são de 
extrema importância para manipularmos os dados existentes no ListBox, pois nos permitem 
saber o texto do itemselecionado, número do índice do itemselecionado, número de itens 
existente no ListBox,etc...
São elas:
19
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
ListCount: Retorna a quantidade de itens existente dentro de um ListBox.
ListIndex: Retorna o número correspondente ao índice do item selecionado.
NewIndex: Retorna o número correspondente ao índice do ultimo item inserido no 
ListBox.
SelCount: Quando a propriedade MultiSelect esta ativada, possibilitando a seleção de 
vários itens dentro da caixa de lista, o SelCount retorna a quantidade de itens que foi 
selecionado.
Selected: Retorna True ou False sinalizando se algum item foi selecionado. É necessário 
informar o índice correspondente. Exemplo: Selected(2): Se o item que possui o índice 2 
for selecionado retornará True, se qualquer outro for selecionado retornará False.
Text: Retorna o texto do item selecionado. Não necessita de índice.
List: Retorna o texto do item especificado no índice. Exemplo: List(2) irá mostrar o texto 
existendo na lista referente ao índice 2.
Eventos do ListBox
 De novo aqui só temos o evento DblClick(), que é gerado toda vez que dermos um duplo 
clique sobre um item do ListBox. 
 Procure usar sempre o DblClick(), e não o evento Click(). Pois para o usuário é mais 
intuitivo dar dois cliques numa caixa de listagem para abrir um certo item do que apenas 
um.
Métodos do ListBox
AddItem – Usamos este método sempre que queremos adicionar um item ao ListBox. A 
sintaxe usada é a seguinte:
ListBoxTal.AddItem “Texto a ser adicionado”
RemoveItem – Este outro método é usado para removermos um item do ListBox. A sintaxe 
á seguinte:
ListBoxTal.RemoveItem <número do índice a ser removido>
Você pode notar que é necessário informar o índice do item que se deseja remover. 
Geralmente para remover um certo item que encontra-se selecionado pelo usuário usamos:
ListBoxTal.RemoveItem ListBoxTal.ListIndex
Usamos “ListBoxTal.ListIndex”. Usando a propriedade listindex da nossa ListBox 
conseguimos automaticamente o número do índice selecionado, necessário para podermos 
remover o item que precisamos.
Clear – O mais simples de todos os métodos do ListBox. Serve para limparmos 
completamente a nossa caixa de listagem. Sua sintaxe também é muito simples:
ListBoxTal.Clear
20
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Agora que já conhecemos as principais propriedades, métodos e eventos dos ListBox, 
vamos fazer algo que “funcione” usando-os. 
Crie um formulário, com uma caixa de listagem, uma caixa de texto e 3 botões. Altere as 
propriedades dessa caixa para que esteja vazia sempre que abrirmos o formulário. Agora 
selecione todas as propriedades necessárias para os botões(legenda,nome,etc...) e codifique 
os seus eventos, de forma que um botão servirá para adicionar item, outro para excluir item 
e outro para limpar a caixa de listagem. Ao clicarmos no botão de AdicionarItem este botão 
pegaria o texto existente na Caixa de Texto e o adicionaria na Caixa de Listagem. Quando 
isso fosse feito, a caixa de texto deveria ser limpa para que um novo texto pudesse ser 
digitado nessa caixa de texto. A interface do formulário poderia ficar assim:
Claro que você pode incrementar com algumas legendas para facilitar para o usuário.
 Por se tratar de um exemplo, vamos padronizar os nomes dos controles existentes no 
formulário:
O botão de AdicionarItem irá se chamar “CmdAdd”
O botão de RemoverItem irá se chamar “CmdRemove”
O botão de Limpar irá se chamar “CmdLimpa” 
A Caixa de Texto irá se chamar “TxtItem”
A Caixa de listagem simplesmente “Lista”
 Bem, vamos ao que interessa. Começaremos primeiramente codificando o botão de 
AdicionarItem. Para isso, demos um duplo clique no botão de AdicionarItem. Abrirá então 
a janela de código referente ao evento Click() do respectivo botão. O que precisamos fazer 
então?
Fazer com que cada vez que clicarmos neste botão ele limpe a caixa de texto.
Primeiro devemos adicionar o texto existente na caixa de texto, para depois limpá-lo. 
Faríamos assim:
 Vamos agora ao botão de “RemoverItem”,a qual usaremos o mesmo evento click() para 
usar as instruções que farão que o item selecionado seja excluído caixa de listagem ao 
clicarmos na mesma. Para isso usaremos o método “RemoveItem” do ListBox. Como você 
sabe, quando usamos o método “RemoveItem” é necessário que informemos o número do 
índice para isso usaríamos a propriedades ListIndex do ListBox, a qual retorna em tempo 
de execução o índice do item selecionado. Ficaria assim:
21
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Bem, já codificamos o botão de “AdicionarItem”, o de “RemoverItem”, resta apenas o de 
“Limpar” a caixa de listagem. O mais fácil de todos. Basta colocar no evento Click() do 
respectivo botão a linha que usa o método Clear do ListBox:
Você vai notar que ao tentarmos remover um item sem ter selecionado nada na lista o 
sistema vai gerar um erro, pois o valor da propriedade ListIndex, que deveria se referir ao 
índice do item selecionado estará como “-1”, isso por quê não há nenhum item selecionado. 
Logo mais veremos comandos condicionais, a qual poderemos manipulá-los para que não 
deixem esses tipos de erros acontecerem.
O objeto ComboBox 
 O ComboBox ou caixa de combinação é uma combinação de um TextBox(caixa de 
texto) com um ListBox(caixa de listagem). Podemos digitar caracteres dentro dela, além de 
podermos teclar na seta que existe á sua direita e selecionarmos dados previamente 
inseridos em sua lista.
 O ComboBox é de ampla utilização, pois poupa o tempo do usuário em precisar digitar 
dados, assim como pode evitar que o usuário digite dados incorretos também, além de 
ocupar pouco espaço no formulário. Imagine um formulário enorme com vários controles e 
tivéssemos que colocar uma lista de nomes para o usuário escolher, uma lista de cidades e 
uma lista de bairros, ao invés de colocarmos três ListBox que ocupariam um espaço maior 
poderíamos colocar três ComboBox . Vamos conhecer agora as suas propriedades:
O ComboBox usa as mesmas propriedades que aprendemos para o ListBox. A diferença 
esta somente em duas que veremos agora.
Style: Aqui escolhemos o tipo de Caixa de Combinação iremos colocar no formulário: 
0 - Dropdown Combo: é a opção padrão do Objeto. Aqui pode-se digitar qualquer nome na 
área de digitação, clicar a seta para baixo e escolher qualquer um dos itens que ele será 
automaticamente inserido na área de texto.
1 - Simple Combo: Caixa de Combinação simples. Aparece em destaque a área de edição 
de texto, onde podemos digitar algum item; ou selecionar qualquer um que esteja na caixa 
de lista, que será inserido na área de texto. O botão em forma de seta para baixo não existe 
neste tipo de ComboBox. Se aumentarmos o tamanho da Caixa de Combinação na vertical, 
aparecerá a lista e esta ficará fixa. Caso deixamos ela somente do tamanho da área de texto, 
então a lista não aparecerá, e se quisermos saber quais nomes existe teremos que apertar no 
teclado a seta para baixo ou para cima, para que os itens existentes dentro da Lista 
apareçam.
2 - Dropdown List: Neste tipo de Caixa de Combinação o usuário pode somente escolher 
um item relacionado na lista, não podendo digitar nada. A área de texto não aceitará 
digitação.
22
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Text: Nesta propriedade digita-se um texto que ficará, como padrão, fixo na área de texto 
na caixa de combinação. Geralmente deixa-se em branco. Podemos usar essa propriedade 
também, em tempo de execução, para saber qual texto o usuário digitou ou selecionou.
Métodos do ComboBox
 Os métodos usados pelo ComboBox são os mesmo usados pelo ListBox(AddItem, 
RemoveItem e Clear). 
MaskedBox 
 O MaskedBox aparenta ser uma caixa de texto. A diferença é que ele tem vários recursos 
adicionais. Ele tem recursos que possibilitam a colocação de uma máscara onde ele só vai 
aceitar caracteres digitados de acordo com a máscara. Por exemplo, se quisermos que ele 
aceite apenas números, basta colocar a máscara correspondente que todos os caracteres que 
não são números serão ignorados automaticamente. Vamos agora conhecer as propriedades:
Este objeto é semelhante a uma caixa de texto, entretanto ele possui alguns recursos 
adicionais, como a possibilidade de colocar uma máscara para o texto que irá ser digitado e 
validar a digitação automaticamente.
Veja as principais propriedades:
AllowPrompt : Determina se o caractere informado como prompt é válido durante 
a digitação.
AutoTab : Determina se quando o usuário terminar de preencher a mascara do 
objeto o foco é automaticamente passado para o objeto seguinte, sem necessidade do 
usuário apertar TAB ou o mouse.
ClipMode : Determina se, diante de um evento de copiar ou recortar dados do 
objeto Maskedit para a área de transferência, devem ser enviados os dados digitados com 
os caracteres que compõem a máscara ou não.
* ClipText : Retorna o texto digitado no objeto sem os caracteres que compõem a 
máscara.
Format : Determina o formato que os dados serão exibidos. 
Use a propriedade Format para exibir dados em um formato consistente, ou seja, os 
dados serão exibidos neste formato, mesmo que o usuário digite os dados diferentemente 
do formato. Por exemplo, se você definir a propriedade Format para “dd/mmm/yyyy”, 
todas as datas digitadas serão exibidas no formato 18/Set/1995. Se o usuário digitar a data 
como 18/09/95 (ou qualquer outro formato de data válido), o Visual Basic converterá a 
exibição para o formato estabelecido, que é dia / mês-por-extenso-abreviado / ano-com-4-
digitos.
A propriedade Format afeta apenas a maneira como um valor é exibido e não como 
ele é armazenado. Da mesma forma, um formato de exibição não é aplicado até que o 
usuário termine a digitação e o controle perca o foco. 
Nada é exibido no campo para sugerir ou controlar o formato no qual os dados são 
inseridos. 
23
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Se você precisar controlar a maneira como os dados são digitados, use uma máscara de 
entrada além de ou ao invés de um formato de exibição de dados. Se você quiser que os 
dados sejam exibidos exatamente como foram inseridos, não defina a propriedade Format.
* FormattedText : Retorna o texto digitado, incluindo os caracteres que compõem 
a máscara.
Mask : Máscara que moldará o controle.
O Visual Basic fornece duas propriedades que produzem resultados parecidos: a 
propriedade Format e o Mask.
Use a propriedade Mask para exibir caracteres de exibição literais no campo com 
espaços em branco a serem preenchidos. Por exemplo, se todos os números de telefones 
que inserir em um campo tiverem o mesmo formato, você poderá criar uma máscara de 
entrada: 
(###) ###-#### F 0D C (___) ___ -____ 
F 0
D C (062) 621-3862
Uma máscara de entrada garante que os dados se ajustem ao formato definido e 
você poderá especificar os tipos de valores que poderão ser inseridos em cada espaço em 
branco. Por exemplo, a máscara de entrada anterior solicita que todas as entradas 
contenham exatamente os dígitos necessários para completar um código de área e número 
de telefone, e que somente dígitos possam ser inseridos em cada espaço em branco.
Você pode definir uma máscara de entrada usando os seguintes caracteres.
0 Dígito (de 0 a 9, entrada requerida, sinais de mais (+) e menos (-) 
não permitidos).
9 Dígito ou espaço (entrada não requerida, sinais de (+) e menos (-) 
não permitidos).
# Dígito ou espaço (entrada não requerida, os espaços são exibidos 
como vazios enquanto os dados são editados, mas são removidos 
quando perde o foco, sinais de mais e menos permitidos).
L Letra(de A a Z, entrada requerida).
? Letra (de A a Z, entrada opcional).
A Letra ou dígito (entrada requerida).
a Letra ou dígito (entrada opcional).
& Qualquer caractere ou espaço (entrada requerida).
C Qualquer caractere ou um espaço (entrada opcional).
, . : ; - / Marcador de posição decimal e separadores de milhares, de data e 
de hora. (O caractere realmente usado depende das configurações 
do Painel de Controle do Windows).
< Faz com que todos os caracteres sejam convertidos para 
minúsculos.
> Faz com que todos os caracteres sejam convertidos para 
maiúsculos.
\ Faz com que o caractere seguinte seja exibido literalmente (por 
exemplo, \A é exibido simplesmente como A).
24
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Quando você define uma máscara de entrada e a propriedade Format para o mesmo objeto, 
a propriedade Format tem precedência quando os dados são exibidos. Isso significa que 
mesmo você tendo salvo uma máscara de entrada, ela é ignorada quando os dados são 
formatados. O dado original como foi digitado não é alterado; a propriedade Format só 
afeta a maneira como os dados são exibidos.
MaxLength : Determina a quantidade máxima de caracteres que o MaskEdBox 
pode ter.
Name: Nomeia o objeto. Geralmente inicia o nome com “msk”
PromptChar : Escolhe o caractere padrão que será exibido simbolizando o estado 
vazio. Por default possui o caractere “_”, e aconselho a substituir pelo caractere de espaço. 
Esta propriedade não aceita vazio.
PromptInclude : Determina se o caractere inserido na propriedade PromptChar 
será incluído na propriedade Text.
* Text : Contém o texto digitado pelo usuário no objeto.
Evento ValidationError : Este evento ocorre sempre que o usuário digita alguma 
entrada que não corresponde a máscara estabelecida.
 
Construindo um sistema
 Um sistema em VB é constituído por vários componentes e dividido em várias partes. 
Nós já conhecemos os formulários(Forms), mas num sistema podem conter vários outros 
componentes:
- MDI Forms
- Módulos(Módule)
- Módulos classe(Class Module)
- Relatórios (Data Report)
- User Controls
Estes são os principais componentes. Existem muitos outros que fogem ao objetivo do 
nosso curso. Alguns, como o Módulo Classe
E o User Control também não serão abordados neste curso, apenas você terá uma noção do 
que é e para que serve. 
MdiForms – O MdiForm na verdade é um Form que suporta vários outras Forms dentro 
dele. Ele tem a função de ser o formulário principal numa aplicação. Numa aplicação 
média ou grande, sempre vamos ter que adicioná-lo no projeto.
Módulos – Os módulos são usados a todo momento no Visual Basic. Qualquer projeto seja 
ele médio ou grande tem vários deles. Dentro desses módulos, existirá um código que 
poderá se dividir em subprocedimentos e funções de usuário. Veremos logo a seguir o que 
são subprocedimentos e funções.
Módulos Classe – Módulos classes são na verdade, blocos de código que agem como 
objetos. Nosso curso não vai abordar a construção de objetos, no entanto aprenderemos a 
usá-los.
25
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Relatórios – São relatórios gerados por uma ferramenta. Existem para facilitar o nosso 
trabalho de gerar relatórios. Tem várias funções úteis a quais veremos mais tarde. Há outros 
geradores de relatório além do Data Report. Trataremos disso na seção Impressão.
User Controls – São controles construídos pelo próprio programador de acordo com 
alguma necessidade específica a qual os controles normais não poderiam suprir.
DataEnvironment – Este componente é muito útil para tratarmos com banco de dados. 
Facilita muito o acesso aos dados e nos possibilita manipular o Banco de Dados com 
poucas linhas de código.
 Para adicionar um componente, acesse o menu Project e selecione qual componente você 
deseja adicionar.
Antes de nos aprofundarmos em alguns componentes, principalmente nos módulos, vamos 
aprender a manipular as propriedades do projeto. Quando você inicia um projeto, ele por 
padrão sempre coloca um objeto Form dentro do projeto. De nada for alterado nas 
propriedades do projeto, o interpretador sempre inicia por esse Form, o abrindo. Existem 
alguns eventos do Form que talvez você ainda não conheça e são de extrema importância 
quando começamos a trabalhar com o código. São eles:
Initialize – Este evento ocorre quando o Form é chamado, seja pelo Visual Basic, ou por 
um módulo onde definimos uma instrução para chamá-lo.
Load – Ocorre sempre que o Form é carregado na memória. Poderámos dizer que é o 
ponto de entrada em qualquer formulário. Quando o formulário é chamado, antes mesmo 
de podermos visualizar ele na tela, o evento Load já está ocorrendo.
Activate – Este evento ocorre logo após o evento Load. Quando este evento ocorre já 
podemos ver o Formulário.
Unload – Ocorre quando o formulário é descarregado da memória. È o oposto do evento 
Unload .
Terminate – Este evento ocorre após o evento Unload . Quando ele ocorre o formulário já 
não está mais na memória, e muito menos podemos visualizá-lo.
 Bem, é fácil deduzir que se criarmos um projeto, não alterarmos nada, e colocarmos esse 
projeto pra rodar, o interpretador primeiro percorreria o evento Initialize do formulário, 
depois o evento Load e depois o evento Activate. Ao fecharmos ele percorreria o evento 
Unload e depois o evento Terminate.
 No entanto, um projeto pode iniciar também por um módulo. Existe um evento chamado 
Main que o Visual basic sempre procura nos módulos do seu projeto, caso você defina para 
que ele procure. Podemos optar entre 2 pontos de entrada em sua aplicação:
- Um formulário que você mesmo define qual é
 OU
26
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
- Um módulo que tem um procedimento chamado “Main”. 
Vamos conhecer as propriedades de projeto onde podemos definir isso. Acesse o menu 
“Project” e selecione “Properties”. No caso de você ter um projeto com o nome de 
“Exemplo” aparecerá “Exemplo Properties”. Aparecerá a seguinte janela:
 Um projeto médio ou grande sempre começa em um módulo, através do 
subprocedimento Main .
 
Menus
 Até agora vimos como inserir botões e muitos outros controles em um formulário. Mas e 
se quiséssemos inserir menus.
 O Visual Basic oferece um editor de menus muito simples. Acessando o menu Tools, 
Menu Editor ou teclando <F2> você abrirá o Menu Editor.
 Agora que já conhecemos as propriedades, vamos aprender a criar os menus. 
Primeiramente, você define o Caption e o Name do item de menu. Devo lembrar que o 
Name é obrigatório.
 Note que podemos criar submenus dentro dos menus. Usando e , sendo que avança um 
nível e recua um nível.
 Menus que são antecipados com “....” representam submenus. Quanto mais “....” tiver na 
frente do submenu, mais avançado é o seu nível. 
27
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Menus dinâmicos
 Menus dinâmicos são aqueles menus que aparecem quando clicamos com o botão direito 
do mouse em cima de algum item.
 O comando que chama esses menus é o PopUpMenu e sua sintaxe é a seguinte:
PopUpMenu <Nome do menu a chamar>
 Claro que ainda temos que saber quando usar esse comando. Podemos usá-lo então no 
evento MouseUp do objeto que vai ter o menu. Como sabemos, o evento MouseUp 
acontece toda vez que clicamos o botão do mouse em cima do objeto. Vamos conhecer 
melhor o evento MouseUp :
MouseUp (Button asInteger, Shift As Integer, X as Single, Y as Single)
Como você pode ver, o evento MouseUp nos passa parâmetros dizendo que botão foi 
pressionado, que tecla estava pressionada no momento em que pressionamos o botão do 
mouse, a linha e a coluna onde foi pressionado o botão.
Button : retorna um número inteiro que informa qual dos botões foram apertados:
1 Botão esquerdo pressionado. vbLeftButton
2 Botão direito pressionado. vbRightButton
4 Botão do centro pressionado. vbMiddleButton
Shift : retorna um número inteiro que informa qual tecla estava pressionada no 
momento em que algum botão do mouse também foi pressionado.
1 SHIFT pressionado. vbShiftMask
2 CTRL pressionado. vbCtrlMask
4 ALT pressionado vbAltMask
X : Coordenada para linha
Y : Coordenada para Coluna
Exemplo:
Private Sub List1_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As 
Single)
 If Button = 2 then 
 PopUpMenu MenuLista
 End if
End Sub
No código acima usamos o evento MouseUp do objeto List1 e depois verificamos se o 
botão do mouse que foi pressionado é o direito. Caso seja, usamos o comando 
PopUpMenu para chamar o menu com o nome de MenuLista.
28
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
O código
 Já falamos várias vezes sobre código aqui, no entanto nosso código se resumiu a atribuir 
propriedades em tempo de execução a alguns objetos. Não iríamos muito longe apenas com 
isso. Precisaríamos de comandos, funções e muitos outros. 
 Antes de vermos cada um desses itens detalhadamente, seria necessário dividir o código 
em:
- SubProcedimentos
- Funções de Usuário
- Propriedades
- Eventos
 Nosso curso tratará apenas subprocedimentos e funções de usuário. Propriedades e 
eventos, na maioria dos casos não são muito usados. Antes de vermos esses itens 
detalhadamente, assim como o método de declará-los no código, vamos conhecer a nossa 
amiga “Janela de Código”. É nela que estaremos trabalhando a maior parte do tempo.
 
 Vamos tratar primeiramente sobre os subprocedimentos. Um subprocedimento são 
blocos de código com tarefas específicas. Tem uma série de instruções dentro dele que 
devem fazer alguma coisa. Dentro de um subprocedimento podemos ter comandos e 
funções. Além disso, um subprocedimento também pode receber parâmetros que 
especificam os valores que serão tratados pelo respectivo subprocedimento. Os 
subprocedimentos existem para facilitar a organização de nosso projeto. Imagine um 
projeto enorme com milhares de linhas de código. Seria difícil organizar tudo isso. Não é 
mesmo? Então foram criados os subprocedimentos para que cada tarefa em nosso projeto 
pudesse ser dividida, organizando assim o código. Veremos exemplo mais tarde e vamos 
aprender a declará-los também.
 Quanto as Funções de Usuário , serão vistas logo mais, sendo que vamos precisar 
conhecer primeiro o que faz uma função para que depois aprendemos a construí-la. 
 Devemos agora primeiramente ter uma noção boa sobre variáveis, comandos e funções 
de depois mergulharemos em subprocedimentos e funções de usuário.
Variáveis
 
 Você já deve conhecê-las da matemática, onde geralmente tínhamos a variável X ou 
variável Y.
 Em programação, ela tem a mesma função com vários recursos adicionais.
29
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Na matemática, só tínhamos a variável numérica. Na programação temos vários tipos de 
variáveis. Vamos conhecê-las:
Nome Descrição Abrangência
Integer Numérico Inteiro -32.768 a 32.767
Long Numérico Inteiro -2.147.483.648 a 2.147.483.648
Byte Numérico Inteiro 0 a 255
Single Numérico real -3,402823E38 a -1,401298E-45 
1,401298E-45 a 3,402823E38 
Double Numérico real -1,79769313486232E308 a 
4,94065645841247E-324
4,94065645841247E-324 a 
1,79769313486232E308
Currency Numérico -
Valores monetários
-922.337.203.685.477,5808 a 
922.337.203.685.477,5807
String Texto 2.147.483.648 de caracteres nos sistemas 32 
bits
65.536 de caracteres nos sistemas 16 bits 
Date Data e Hora entre 01/01/100 a 31/12/9999
Boolean True (verdadeiro) False (falso)
Object Contém um objeto
Variant Pode ser numérico, string, objeto ou valor nulo.
 Quando atribuímos um determinado valor a uma variável esse valor fica armazenado na 
memória e quando nos referenciamos a essa variável novamente esse valor é lido na 
memória. Portanto, devemos pensar bem antes de escolher qual variável usaremos 
para o nosso valor.
 Você viu que existem cinco tipos de variáveis apenas para tratar com números. A Integer 
abrange um certo valor, a Long outro, a Single outro, a Double outro e a Currency é a mais 
adequada para tratarmos com valores monetários .
 Devemos usar exatamente o tipo de variável que precisamos. No caso de você precisar 
colocar o número 100 numa variável, o tipo Integer se enquadra perfeitamente. Já se 
usarmos Long para um valor desse porte, estaríamos desperdiçando memória.
 O tipo Variant, por exemplo, permite-nos, de antemão, atribuí-lo com um valor a qual não 
sabemos qual é. No entanto, devemos usar o tipo Variant com muito cuidado, pois tem um 
consumo de memória bem superior aos outros tipos de variáveis. 
 O Visual Basic nos permite atribuir um valor a uma variável sem precisarmos declarar o 
seu tipo. No entanto essa prática apesar de facilitar o trabalho, não é recomendada. Você 
deve estar se perguntando por quê:
 Bem, em primeiro lugar, imagine você um sistema com milhares de linhas de código. E 
nessas linhas você tivesse a seguinte linha:
Nome = “Maria Da Silva”
Digamos que você se distraia e digite:
30
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Nomex = “Maria Da Silva”
 O que irá acontecer é que o compilador não vai dar nenhum aviso de erro, por quê assim 
como existe a variável “Nome” pode existir também a variável “Nomex”. Tudo bem, o 
programa irá compilar sem problema o seu código. Mas e, quando você precisasse desse 
valor dentro da variável “Nome”? 
Resposta: Ela não estaria lá!
E seu código?
Se quebraria. 
 Daria erro em um certo ponto. Talvez você demoraria para notar o erro, mas cedo ou 
tarde, em determinada parte, iria ver que o valor não estava sendo gravado ou qualquer 
outro tipo de erro. 
 Esse tipo de problema é comum se você não optar que o Visual Basic exija 
obrigatoriamente a Declaração de Variáveis. Para isso, acessamos o Tools, Options e 
selecionamos “Require Variable Declaration”, como mostra a figura.
 Podemos também usar a instrução Option Explicit na seção General-Declarations do 
módulo em que deverá ser forçada a declaração de variáveis.
 Com este procedimento, se uma variável não for declarada o Visual Basic vai gerar um 
erro dizendo que a variável não foi declarada.
 Você deve estar se perguntando onde, e, como se declara uma variável. Há várias 
palavras chave para se declarar uma variável. Trataremos primeiro do comando Dim. Sua 
sintaxe é a seguinte:
Dim VariávelTal as <TipodaVariável>
Exemplo:
Dim Nome as string
Declaramos a variável “Nome” como sendo do tipo “String”
Dim Numero as Integer
Declaramos a variável “Número” como sendo do tipo “Integer”
Dim Valor as Currency
Valor = “58,34”
Declaramos a variável “Valor” como sendo do tipo “Currency”, que é o tipo que usamos 
para valores monetários, e, logo após atribuímos a ela o valor de “58,34”
 Vamos tratar agora os diferentes tipos de variáveis que se dividem em numéricas, string, 
lógicas, datas , objects e variants.
31
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermarkVariáveis numéricas
 Uma variável numérica pode ser do tipo Integer, Long, Single ou Double como já vimos 
anteriormente. Você escolhe a variável de acordo com as suas necessidades. Procure 
sempre utilizar o tipo de variável de acordo com o que você precisa. Por exemplo, se você 
irá armazenar um número entre zero e 100 em uma variável numérica do tipo Long, você 
estaria utilizando mais recursos do que seu valor necessita. Pois numa caso destes, a 
variável Single seria totalmente cabível. É muito importante que o programador leve em 
consideração casos como este. Pois em um programa grande o gerenciamento de recursos 
é de extrema importância.
 Procure usar as variáveis numéricas apenas quando estas forem objetos de cálculos, ou 
seja, use-as apenas quando for realizar operações matemáticas com os seus valores. Por 
exemplo, você não precisa utilizar um tipo numérico para uma variável numérica que vai 
conter um “Cpf” ou um “número de identidade”.
Variáveis Lógicas(Boolean)
 Permitem somente dois valores: True or False. Ou seja, verdadeiro ou falso. 
 Este tipo de variável parece não nos prometer nada, mas são de extrema importância 
dentro de um programa. Quando declaramos uma variável do tipo Boolean, ele é definida 
automaticamente como False(Falso) e só passa a ser True(Verdadeiro) quando assim for 
definida. Exemplo:
Dim Nome as String
Dim NomeIgual as Boolean
Nome = “Maria da Silva”
NomeIgual = (Nome = “Maria”)
A variável lógica “NomeIgual” retornaria False
Declaramos duas variáveis, uma do tipo String, e outra do tipo lógica(Boolean). A variável 
lógica “NomeIgual” tem a função de analisar a comparação entre a variável nome e uma 
string qualquer. Se essa comparação for verdadeira, ele retornará true, e vice-versa. No 
nosso exemplo acima, temos a variável “Nome” com o conteúdo “Maria da Silva”. A 
comparamos com a string “Maria” e o resultado que a variável “NomeIgual” dará é False, 
por quê a comparação não é verdadeira. Vejamos agora como a variável “NomeIgual” 
poderia retornar True:
Dim Nome as String
Dim NomeIgual as Boolean
Nome = “Maria da Silva”
NomeIgual = (Nome = “Maria da Silva”)
“NomeIgual” retornaria True
Convém observar que se trocássemos uma letra que fosse, de maiúscula para minúscula a 
variável lógica “NomeIgual” já retornaria False.
32
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Dim Nome as String
Dim NomeIgual as Boolean
Nome = “Maria da Silva”
NomeIgual = (Nome = “Maria da silva”)
“NomeIgual” retornaria False Observe o “s” minúsculo
 
Variável String
 
 Ao tratarmos sobre as variáveis lógicas falamos sobre “String”. Uma string na verdade 
pode ser o conteúdo de uma variável do tipo “String” ou qualquer conteúdo delimitado por 
“” aspas. Uma string aceita caracteres alfanuméricos, símbolos, etc. Podemos fazer 
concatenação com essas strings, assim como extrair uma parte de seu conteúdo e até fazer 
comparações.
 Concatenação seria juntarmos duas strings em uma só. Podemos usar para isso o 
operador “+” ou o “&”. Exemplo:
 “Visual “ + “Basic” resultaria “Visual Basic”
 “13” + “12” resultaria “1312”
 “Visual ” & “Basic” resultaria “Visual Basic” 
 “13” & “12” resultaria “1312”
 Bem, olhando assim parece que o operador “+” e operador “&” são iguais, mas na 
verdade não. A diferença está que o operador “+” força a soma e operador “&” força a 
concatenação. Vejamos:
12 + ”13” resultaria 25
Note que ao tentarmos concatenar com o operador “+” uma string e um dado numérico ele 
somou e transformou o resultado em um valor numérico. 
12 & “13” resultaria “1213”
 Agora ficou bem claro que o operador “+” ao encontrar 2 tipos diferentes, ou seja, um 
valor numérico e uma string, ele os somará e irá transformá-los em um valor numérico, 
enquanto que o operador “&”, ao encontrar 2 tipos diferentes irá forçar a concatenação, 
pegando o valor numérico e concatenando com a string, transformando assim o resultado 
em uma string. 
 Resumindo, podemos usar tanto o operador “+” quanto o operador “&” para concatenar 
strings, apesar de que geralmente é mais usado o “&”.
 
Variável Date
 
 A variável Date nos possibilita o armazenamento de datas, porém, também podemos 
armazenar horas. Quando atribuímos uma data a uma variável devemos usar o operador #. 
Exemplo:
Data = #01/01/2001#
33
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Se tentarmos atribuir uma variável data assim:
Data = 01/01/2001
Ou assim:
Data = ”01/01/2001”
 Se a variável foi já foi declarada como Date, o programa retornará um erro dizendo que 
o que estamos tentando passar não é uma data. Se a variável ainda não foi declarada, no 
primeiro exemplo, ele pensará que estamos tentando dividir 01 por 01 por 2001 e colocará 
o resultado na variável. No segundo ele armazenará uma string na variável tornando assim 
uma variável do tipo String.
 A variável Date nos possibilita fazer alguns cálculos:
a = #15/07/96#
b = #30/07/96#
b - a = 15 (Uma data menos outra retorna o intervalo em dias)
a + 3 = #18/07/96# ( uma data mais um valor numérico soma a quantidade de dias na data)
a - 3 = #12/07/96# ( uma data menos um valor numérico subtrai a quantidade de dias na 
data.
Variável Variant
 A variável do tipo Variant como o próprio nome sugere é uma variável que se transforma 
em qualquer tipo, dependendo do conteúdo que lhe é atribuído. Por exemplo, se tivermos 
uma variável “A” e atribuímos A=”José”, A será do tipo String, já se atribuirmos A = 1, A 
será do tipo Integer.
 A uso desse tipo de variável só é aconselhado quando não temos a menor idéia do 
conteúdo que será atribuído a ela, pois uma variável do tipo VARIANT utiliza mais 
recursos do que os outros tipos.
Variável Object e instanciação
 A variável Object representa um objeto. Podemos atribuir objetos ás variáveis, caso 
precisarmos. Essa prática é chamada de instanciação. 
 Como o Visual Basic trabalha com objetos, é bom se acostumar a instanciar objetos a 
todo o momento. O que acontece, na verdade, no momento em que instanciamos o objeto é 
que a variável que contém a variável passará a se comportar como o objeto. Podemos 
definir um tipo de variável como sendo TextBox, ComboBox, Form ou qualquer outro 
objeto. O Tipo Object aceita qualquer um desses objetos. Seria como a variável Variant dos 
objetos.Podemos instanciar qualquer objeto existente em nosso projeto. Para instanciar um 
objeto, temos de usar a palavra chave SET antes da variável. Exemplo:
Dim Objeto as Object
Set Objeto = Text1
Objeto.text=”olá”
34
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Crie um projeto novo no VB. Insira um TextBox no formulário. Agora coloque o código 
acima no evento LOAD do Form e rode o projeto. Você verá que aparecerá a caixa de texto 
com o texto “olá” em seu interior. Bem, vejamos como isso aconteceu.
 Primeiro, criamos uma variável chamada Objeto, como sendo do tipo OBJECT. 
Dim Objeto as Object
Depois á instanciamos. Imagine o ato de instanciar como estar apontando para objeto. 
Como tornar a variável um espelho do objeto. 
 
Set Objeto = Text1
 
 Depois de instanciarmos a variável Objeto, fazendo que ela aponte para “Text1”(nossa 
TextBox), podemos modificar as suas propriedades através da variável:
Objeto.text=”olá”
 Simples, não é mesmo. Note que, ao declarar a variável, poderíamos usar diretamente o 
tipo TEXTBOX. Pois como já falamos anteriormente, o Tipo Object seria como o Tipo 
VARIANT, só que para objetos. Este exemplo usou um TextBox, mas poderíamos usarcom 
qualquer outro objeto existente no projeto. 
Veremos instanciação com maiores detalhes mais adiante.
Declaração de Variáveis
 O Visual Basic nos permite declarar variáveis em qualquer parte do código, no entanto, 
existem algumas observações a serem feitas:
- Para que uma variável seja vista por todo o módulo, formulário, ou qualquer outro objeto 
que a contém, a mesma deve ser declarada na seção General, Declarations do módulo.
 Se a declararmos dentro de um procedimento qualquer, ela será válida apenas dentro 
desse procedimento.
 
- Para que a variável seja vista pelo projeto inteiro, devemos declará-la como Public, no 
módulo principal. Veremos agora o que significa Public , assim como os demais 
modificadores de acesso.
Modificadores de acesso
 Os modificadores de acesso mudam a forma como o programa enxerga as variáveis. Se 
declararmos uma variável usando no lugar de DIM a palavra chave PUBLIC na seção 
General-Declarations do módulo principal, esta variável poderá ser usada em qualquer 
parte do projeto.
35
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Public Nome as String
Esta variável poderá ser usada dentro de qualquer formulário sem problemas. Já se 
declararmos uma variável pública dentro de um formnulário, também poderíamos usá-la 
em qualquer parte do projeto, no entanto devemos antecipá-la com o nome do formulário e 
um ponto. Exemplo:
FormularioTal.Nome
Além do modificador de acesso PUBLIC, temos o PRIVATE, que funciona exatamente o 
oposto do PUBLIC. O usamos para evitar que as variáveis internas de um módulo entre em 
conflitos com variáveis de mesmo nome de outros módulos. Sua sintaxe é a mesma usada 
no comando PUBLIC.
Constantes
 Uma constante é uma variável que terá um valor somente leitura, ou seja, poderemos 
apenas ler o seu valor, mas não poderemos modificá-la. É útil quando temos um 
determinado valor que é referenciado várias vezes dentro do projeto, e queremos uma 
variável para representar esse valor, de forma que não precisemos mais digitar toda vez 
esse valor.
 Para declararem constantes, usamos a instrução CONST. Exemplo:
Const Numero as Integer = 3
O tipo da constante não é obrigatório, de forma que a linha acima poderia ficar assim:
Const Numero = 3
 No lugar do número 3 poderíamos usar qualquer expressão, seja ela uma string, ou uma 
operação matemática, ou qualquer outra expressão válida envolvendo outras constantes.
 As constantes são declaradas como Private por padrão, no entanto podemos usar os 
modificadores de acesso Public antecipando a declaração. Exemplo:
Public Const Data = #20/09/1979#
Se colocarmos essa linha na seção General-Declarations de um módulo, esta constante 
poderá ser acessada por qualquer parte do projeto. Se a colocarmos na seção General-
Declarations de um formulário também, mas da mesma maneira que acessamos as 
variáveis, ou seja, antecipando com o nome do formulário:
FormularioTal.Data 
Operadores
36
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Agora que já aprendemos a trabalhar com variáveis, vamos conhecer os operadores, que 
serão essências para a manipulação dos valores de nossas variáveis. Com eles, poderemos 
realizar operações matemáticas, lógicas, etc. Os operadores se dividem em:
- Matemáticos
- Relacionais
- Lógicos
- String
Matemáticos – Os operadores matemáticos já são conhecido de todos. Com eles 
poderemos somar, dividir, subtrair,etc. São eles:
Operador Descrição Exemplo
+ Soma Var = 18+5
- Subtração Var = 18-5
* Multiplicação Var = 18*5
/ Divisão Var = 18/5
\ Divisão. Resultado será um número 
inteiro
Var = 18\5
^ Exponenciação Var = 18^5
Mod Resto da Divisão Var = 18 Mod 5
Assim como na matemática, esses operadores sempre respeitam uma ordem para realizar os 
cálculos:
1ª. Exponenciação
2ª. Multiplicação e Divisão
3ª. Adição e Subtração
Se tivermos o seguinte cálculo a ser feito:
7+3*2-4^2/2
Resultaria 5.
 O programa primeiro calcularia as operações de exponenciação, depois de multiplicação 
e divisão, e depois sim, irá realizar as operações de soma e subtração.
 Caso quiséssemos que ele primeiro somasse, bastaria colocarmos a soma entre 
parênteses:
(7+3)*2-4^2/2
Resultaria 12.
Operadores Relacionais – Realizam comparações entre valores ou variáveis e retornam o 
resultado da comparação, sendo True se a comparação for verdadeira, e False, se a 
comparação for falsa. São eles:
37
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Operador Descrição Exemplo
> Menor 3 < 5
< Maior 5 > 3
<= Menor ou Igual 3 <= 5
>= Maior ou Igual 5 >= 3
= Igual 5 = 5
<> Diferente 3 <> 5
Operadores Lógicos – Realizam operações lógicas usando operadores que representam a 
palavra NÃO, E, OU, EQUIVALENTE, IMPLICAÇÃO E PRECISÃO. Veremos os 
mais importantes. São eles:
And – O mais usado de todos os operadores. Representa a palavra “E” em uma expressão. 
Por exemplo:
A = 5 and b = 7
Significa a igual a 5 e b = 7
OR- Representa a palavra “OU” numa operação lógica.
A = 5 or B = 7
Significa a igual a 5 ou B = 7
NOT – Representa a expressão “NÃO É” numa expressão lógica. Por exemplo:
A = 5 AND NOT (A = B)
A igual a 5 e A não é igual a B
Para facilitar o entendimento, imagine o operador NOT antes da expressão como se fosse a 
palavra NÂO.
 
Operadores de String
 Como já vimos anteriormente, são representados pelo “+” e pelo “&”, sendo que o “+” 
força o cálculo, no caso de termos uma das expressões sendo numérica, enquanto o “&” 
força a concatenação, no caso de termos uma das partes sendo string e outra numérica. Para 
maiores detalhes, consulte a seção anterior.
Comandos condicionais e Loops
38
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 È chegada à hora de conhecermos alguns comandos, e vamos começar por alguns que já 
estão nos fazendo falta. Começaremos primeiro com os comandos condicionais.
 Os comandos condicionais, como o próprio nome diz são comandos que nos permitem 
executar blocos de código, apenas quando certas condições forem verdadeiras, ou falsas, 
dependendo do caso. Por exemplo, se tivermos um TextBox numa tela de cadastro. 
Digamos que esse TextBox servirá para o usuário entrar com o nome do cliente, e 
porventura o usuário esqueceu de digitar o nome do cliente no TextBox. Imagina-se que 
nesse cadastro tem um botão para que possamos gravar os dados. No momento que o 
usuário clicar no botão de Gravar, o nome seria gravado em branco. Para isso deveríamos, 
colocar, no evento Click do botão de gravar um código que exiba uma mensagem dizendo 
que o usuário esqueceu de digitar o nome do cliente, e após isso, mover o foco para o 
TextBox correspondente. 
 Mas o que acontecerá se fizermos isso? Toda vez que clicarmos no botão de gravar, 
mesmo que o usuário tenha preenchido a TextBox, a mensagem seria exibida. Para resolver 
esse problema, teríamos que usar os comandos condicionais. Vamos conhecê-los:
IF, Then, Elseif, Else, Endif
 Testa uma condição e executa determinado código se esta condição for verdadeira. Sua 
sintaxe é a seguinte:
If <Condição> then
< Código a ser executado se a condição for verdadeira>
Else
<Código a ser executado caso a condição de IF não for verdadeira>
Endif
O Endif encerra o bloco condicional IF.
Onde If representa a palavra SE
Then = ENTÂO
Else = SENÂO
Endif =Fim Do Comando SE
Vejamos um exemplo:
Dim Numero as integer
Numero = 3
39
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk(fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
If Numero > 2 then
 Msgbox “Número é maior que 2”
Else
 Msgbox “Número é menor que 2”
End if
 No caso da condição especificada no comando If, ou seja que 0o número seja maior que 
2, então o bloco de código entre If e Else será executado. No caso da condição ser falsa, 
será executado o bloco de código entre Else e Endif.
 Além do If, Then, Else e Endif, temos também o ElseIf. Vejamos a sua sintaxe:
If <Condição> then
< Código a ser executado se a condição for verdadeira>
Elseif <Condição> then
<Código a ser executado, caso a condição especificada no bloco If seja falsa e, a condição 
do comando ElseIf seja verdadeira>
Else
<Código a ser executado caso nenhuma das condições forem verdadeiras>
Endif
Como você pode ver, o comando ElseIf, nos permite inserirmos mais opções condicionais 
no comando IF. Quando a condição do comando If for falsa, o programa procura pelo 
comando ElseIf, se ele existir. Sendo a condição do bloco ElseIf verdadeira, ele executa o 
bloco do ElseIf. Podemos colocar quantos comandos ElseIf quisermos em um Bloco IF. 
No caso de nenhuma das condições forem verdadeiras, será executado o Bloco Else, se ele 
existir. É importante lembrar, que, por todo o bloco IF, o bloco de código que será lido 
será o primeiro que a condição for verdadeira, sendo as demais ignoradas, e o programa 
passando a executar a partir de Endif.
Dim Numero as Integer
Numero = 4
If Numero = 1 then
 Msgbox “Numero igual a 1”
Elseif Numero > 5 then 
 Msgbox “Numero maior que 5”
Else
 Msgbox “Numero não é igual a 1 e não é maior que 5”
End if
 No código acima, o comando If testa a variável Numero, que tem seu valor como 4. A 
condição do comando If é caso a variável Numero seja igual a 1. Como ela não é, o 
programa passa automaticamente para a próxima condição, ou seja, a do comando ElseIf, 
40
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
que testa a variável, pra ver se ela é maior do que 5. Como o valor da variável é 4, no caso, 
não é maior que 5, o programa passa novamente para a próxima condição. No nosso 
exemplo, não temos mais nenhuma condição. Como nenhuma das condições foi verdadeira, 
ele executará o bloco Else, que sempre é executado quando nenhumas das condições forem 
verdadeiras. 
 Note que podemos ter quantos ElseIf quisermos em um bloco If, mas apenas um Else, 
pois só ele será executado quando nenhuma das condições forem verdadeiras. 
 Lembram-se daquele nosso problema do cadastro com o nome do cliente em branco?
O nosso maior problema seria verificar se o TextBox estava vazio, e informar ao usuário 
somente quando tivermos certeza que o TextBox está vazio. Vejamos como fazer isso:
 Digamos que você tenha um TextBox chamado TxtCli e Um botão de comando chamado 
CmdGravar.
 Vamos usar o evento Click do botão. Ficaria assim:
Primeiro, verificamos se o TextBox está vazio, através da propriedade Text:
If TxtCli.Text = “” then
onde “” representa uma string vazia. Poderíamos usar a constante Empty do VB também:
 
If TxtCli.Text = Empty then
Se a condição for verdadeira, ou seja, se TxtCli estiver vazia, o bloco de código existente 
entre If e Else, no caso do nosso exemplo, será executado. 
MsgBox "Nome do cliente não foi informado"
TxtCli.SetFocus
Exibirá uma mensagem ao usuário dizendo que o código do cliente não foi informado, 
depois moverá o foco para o TextBox. 
 Em caso da condição de IF não ser verdadeira, executará o bloco ELSE.
 
 Msgbox “Cadastro Ok”
Informando ao usuário que o cadastro está ok. Por este exemplo podemos notar o quanto os 
comandos condicionais facilitam nossa vida. Em continuidade aos comandos condicionais, 
veremos mais um.
Select Case
 O Select Case funciona de forma semelhante ao IF, mas é uma alternativa mais usada no 
caso de termos um número de opções maiores.
Opção = 3
41
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Select Case Opcao
Case 1 
<Bloco de código a ser executado, no caso da variável opção ser igual a 1>
Case 2 
<Bloco de código a ser executado, no caso da variável opção ser igual a 1>
Case 3
<Bloco de código a ser executado, no caso da variável opção ser igual a 1>
Case Else
<Bloco de código a ser executado, no caso da variável opção não se enquadrar em nenhum 
dos casos>
End Select
Primeiro, escolhemos que condição iremos testar:
Select case Opção
No nosso caso, foi a variável Opção. Depois, testamos os casos:
Case 1
 Note que não é necessário usarmos o nome da variável no caso. Isso por quê quando 
iniciamos o SELECT CASE, já definimos que a expressão que iríamos testar seria a 
variável Opção. Então a linha Case 1 testa se a variável Opção é igual a 1.
 Se a variável Opção não for igual a 1, ela passará para o próximo caso:
Case 2
 Não sendo a variável Opção igual a 2, ela passará para o próximo caso, e assim 
sucessivamente até chegarmos no CASE ELSE, se ele existir. O CASE ELSE funciona 
como o ELSE, do comando IF. Ele será executado quando nenhum dos casos for 
verdadeiro.
 O comando END SELECT encerra o SELECT CASE.
Comandos de Laço(Loops)
 Os comandos de laço ou loopings são extremamente usados na programação. Fazem que 
determinado bloco de código se repita até que uma condição seja ou se torne verdadeira. 
Podem ser usados de várias maneiras. Veremos as formas mais usadas.
42
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Do While, Loop
 Este comando executa os comandos existentes entre Do While e Loop enquanto as 
condições estabelecidas no comando Do While forem verdadeiras. Sua sintaxe é a seguinte.
Do While <Condição>
<Comandos a serem executados no Looping
Loop
Quando o programa encontra o LOOP, ele retorna a linha de DO WHILE, que é 
reavaliado. No caso da condição não ser mais verdadeira, o programa passa 
automaticamente a linha após o comando LOOP. 
Dim Contador as Integer
Contador = 0
Do While Contador < 11
 Print Contador
 Contador=contador + 1
Loop
No código acima, temos uma variável Contador, que é igual a 0, o comando Do While 
pede que o Loop se execute até que a variável contador seja menor que 11. A cada Loop 
que se passa a variável Contador aumenta seu valor em 1. Quanto ela chegar a 11, O 
comando Do While avaliará a condição e no caso dela não ser mais menor que 11, o 
programa passará automaticamente a próxima linha após o comando Loop.
Do, Loop While
 Neste caso, o comando Do não testa nenhuma condição. Quem vai testar as condições 
neste caso é o comando Loop. O que quer dizer que após o comando DO e antes do 
comando LOOP, o código será executado pelo menos uma vez, sendo que somente o 
comando LOOP fará um teste de condição.
Do
<bloco de código a ser executado>
Loop <Condição>
Do Until, Loop
 O Do Until funciona da maneira inversa ao comando Do While. Enquanto o comando 
Do While repete o laço(looping) , enquanto determinada condição for verdadeira, o 
43
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
comando Do Until, repete o looping até que essa condição se torne verdadeira, ou seja, ele 
repete a condição enquanto ela não for verdadeira.
Dim Contador as Integer
Contador = 1
Do Until Contador > 11
 Print Contador
 Contador = Contador + 1
Loop
No exemplo acima, o laço se repetirá até que a variável Contador satisfaça a condição 
especificadaem Do Until. Ou seja, quando a variável Contador for maior que 11, ou seja, 
quando a variável 
Contador for 12, o ciclo se encerrará. 
Do, Loop Until
 Quanto a avaliação das condições, o comando Loop Until funciona da mesma maneira 
que o Do Until. A diferença está que a condição só é testada no comando Loop. Ou seja, o 
código existente entre DO e Loop Until é obrigatoriamente executado pelo menos uma 
vez.
Dim Contador as Integer
Contador = 1
Do 
 Print Contador
 Contador = Contador + 1
Loop Until Contador > 11
Contadores
 Agora que já vimos os comandos condicionais, passaremos aos contadores. Os 
contadores tem inúmeras aplicações em programação. Vamos ao principal comando usado 
como contador:
For, Next
 O comando For realiza uma contagem entre um intervalo de números especificados.
For <Variável> = <númeroinicial> to <numerofinal>
 <Bloco de código>
Next
Necessitamos de uma variável numérica para usarmos o comando For, Next
44
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Dim Contador as Integer
Contador=0
For Contador = 1 to 10
 Print Contador
Next
Podemos pedir ao comando FOR que conte de forma diferente através do comando STEP. 
O comando STEP modifica a forma com que o contador é incrementado. Por padrão, ele 
será incrementado de 1 em 1. Com o comando STEP podemos configurar do modo que 
quisermos.
Dim Contador as Integer
Contador=0
For Contador = 1 to 12 Step 3
 Print Contador
Next
No código acima, o contador irá contar até 12, de 3 em 3.
EXIT DO e EXIT FOR
 Os comandos EXIT DO e EXIT FOR, forçam a saída de um loop ou de um contador, 
respectivamente. 
 O comando EXIT DO nos permite forçarmos a saída de um loop criado através do 
comando DO.
Dim Numero as Integer
Numero=0
Do While Numero<10
 Print Numero
 Numero = Numero +1
 If Contador = 5 then 
 Exit Do
 End if
Loop
O código acima sem o comando Exit Do iria contar até 9. Entretanto, temos um desvio 
condicional que nos diz que se o número for igual a 5, o comando EXIT DO será 
executado, e no entanto, o loop será quebrado. 
 O comando EXIT FOR força a saída de um contador. Vejamos um exemplo com a 
mesma função do código anterior, porém usando um contador:
Dim Contador as Integer
Contador = 1
For Contador = 1 to 9
 Print Contador
 If Contador = 5 then 
 Exit For
 End if
Next
45
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Bem, já conhecemos o suficiente sobre contadores para podermos colocar tudo isso em 
prática. Então vamos fazer o seguinte:
- Crie um ListBox com 10 nomes diferentes
- Insira um Botão que servirá para procurar determinado nome na lista e dizer se ele 
existe ou não
- Sinalize através do programa se a pesquisa obteve sucesso ou não.
Atenção:
O exercício deve ser feito utilizando um contador.
Solução:
 Dim Contador As Integer
 Dim NaoEncontrado As Boolean
 For Contador = 0 To Lista.ListCount - 1
 If Lista.List(Contador) = "NomeTal" Then
 MsgBox "Encontrado"
 NaoEncontrado = False
 Exit For
 End If
 NaoEncontrado = True
 Next
 If NaoEncontrado = True Then
 MsgBox "Não Encontrado"
 End If
SubProcedimentos
 Também podem ser chamados de subrotinas, procedimentos ou simplesmente rotinas. 
Tem uma função específica dentro do projeto. Ou seja, em um projeto podemos ter uma 
rotina de cadastro, uma de consulta, impressão, etc.
 Um projeto médio ou grande que não fosse dividido em rotinas seria um verdadeiro 
inferno para o programador, e para o usuário também. Em vista dos problemas que 
acarretaria devido à demora na manutenção. 
 Além de organizar melhor o projeto, as subprocedimentos podem oferecer o 
reaproveitamento de código, muito importante nos dias atuais quando se está sempre 
correndo contra o relógio. Os subprocedimentos aceitam parâmetros, o que significa que 
podemos tratar diferentes valores usando apenas um subprocedimento. Vejamos um 
exemplo prático do que eu estou dizendo. 
46
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 No nosso exercício anterior, utilizamos um contador que verificava se determinado nome 
existia na lista. Digamos que quiséssemos mudar esse nome. Poderíamos criar um 
subprocedimento passando para ele toda vez que o chamarmos o nome que queremos 
procurar. Estaríamos passando um parâmetro para ele. Podemos colocar vários parâmetros 
em um procedimento. Sejam eles variáveis, valores ou objetos. 
 Na verdade, já estamos trabalhando com subprocedimentos desde o início. Ao codificar 
um evento Click de um botão de comando, você já está trabalhando em um 
subprocedimento. A diferença é que este já é um subprocedimento padrão do botão. 
 Para criarmos um subprocedimento usamos a seguinte sintaxe:
Private Sub <NomeDoProcedimento>(Parâmetros)
<Blocos de código do procedimento>
End Sub
 A palavra Private pode ser substituída por Public, caso precisarmos que o nosso 
subprocedimento possa ser acessado por um módulo externo.
 Quanto aos parâmetros podem ser passados da mesma forma que declaramos variáveis, 
com a diferença que não precisamos usar o comando DIM. Esses parâmetros funcionam 
como variáveis dentro do procedimento.
 Poderíamos criar um subprocedimento para resolver aquele nosso problema anterior:
Public Sub ProcuraNaLista(Nome as String)
 Dim Contador As Integer
 Dim NaoEncontrado As Boolean
 For Contador = 0 To Lista.ListCount - 1
 If Lista.List(Contador) = Nome Then
 MsgBox "Encontrado"
 NaoEncontrado = False
 Exit For
 End If
 NaoEncontrado = True
 Next
 If NaoEncontrado = True Then
 MsgBox "Não Encontrado"
 End If
End Sub 
Note que o único trabalho que tivemos na alteração do código foi trocar o nome que 
procuraríamos pela variável Nome, que ao chamarmos o subprocedimento, terá o nome a 
qual informamos no parâmetro.
 Para chamarmos um subprocedimento, bastar chamá-lo pelo nome, com os seus 
respectivos parâmetros:
ProcurarNaLista(“Maria da Silva”)
47
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
No caso de não existirem parâmetros, use apenas o nome do procedimento.
 Subprocedimentos criados com o comando Public dentro de um módulo podem ser 
acessados por todo o projeto. Se forem criados com a palavra Private podem ser acessados 
somente dentro do módulo que os criou. Quando me refiro a “módulo que os criou”, posso 
estar me referindo tanto a um módulo de código, quanto ao módulo classe, um formulário 
ou qualquer outro objeto a qual podemos codificar.
 Para sairmos de um subprocedimento sem executar os comandos restantes, usamos o 
comando Exit Sub:
Public Sub ProcuraNaLista(Nome as String)
 Dim Contador As Integer
 Dim NaoEncontrado As Boolean
 Exit Sub
 For Contador = 0 To Lista.ListCount - 1
 
 If Lista.List(Contador) = Nome Then
 MsgBox "Encontrado"
 NaoEncontrado = False
 Exit For
 End If
 NaoEncontrado = True
 Next
 If NaoEncontrado = True Then
 MsgBox "Não Encontrado"
 End If
End Sub 
 No código acima, o contador nem chega a ser inciado e o comando Exit Sub já termina 
a execução do subprocedimento, fazendo que todos os comandos do subprocedimento que 
estiverem após o Exit Sub sejam ignorados.
Funções
 Sua finalidade é retornar um valor, mas também podem executar operações. Temosvárias funções nativas do Visual Basic, a qual veremos logo mais, mas também podemos 
construir nossas próprias funções. As funções são declaradas da mesma maneira que os 
subprocedimentos, com a diferença que usaremos a palavra FUNCTION no lugar da 
palavra SUB. 
 
Private Function <NomeDaFunção>(Parâmetros)
48
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
<Blocos de código da Função>
End Function
 Assim como os subprocedimentos, podemos usar a palavra Public no lugar de Private 
da mesma forma que usamos com os subprocedimentos.
 Para facilitar o entendimento das funções, digamos que você precise de uma função que 
retorne a soma de dois números. Um exemplo muito simples, mas que permite entender 
como funcionam as funções de usuário. O código seria o seguinte:
Private Function Soma(Num1 as Integer, Num2 as Integer)
 Soma = Num1 + Num2
 End Function 
Primeiro, declaramos a função com duas variáveis(parâmetros) que representarão so 
números(Num1 e Num2):
Private Function Soma(Num1 as Integer, Num2 as Integer)
Depois, atribuímos que Soma será igual a soma de Num1 e Num2. 
Soma = Num1 + Num2
Ao Criarmos uma função, você pode automaticamente atribuir qualquer valor a ela, desde 
que seja dentro da função. O Tipo de valor que a Function Soma terá vai depender do 
valor que a ela for atribuído. Entretanto, podemos definir esse tipo na declaração da função:
Private Function Soma(Num1 as Integer, Num2 as Integer) as Integer
Isso fará com que a Function Soma aceite apenas valores numéricos. Caso seja a ela 
atribuído uma string, o Visual Basic gerará um erro em tempo de execução.
 O comando End Function encerra um bloco de função. O uso das funções em Visual 
Basic é extremamente útil e o limite para o uso de funções é a imaginação de cada um. Em 
breve, veremos aplicações práticas e funções mais sofisticadas.
Matrizes
 Uma matriz nos possibilita o armazenamento de vários valores em uma única variável. 
Isso porque ele possui níveis dentro dela. Para declararmos uma matriz usamos a seguinte 
sintaxe:
Dim <NomeMatriz>(<Número do maior nível que existirá na matriz>) as <tipo da 
variável
Por exemplo, se quisermos ter uma variável chamada Nome armazenarmos 3 nomes 
diferentes, faríamos o seguinte:
49
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Dim Nome(2) as String
Nome(0) = ”Maria Da Silva”
Nome(1) = ”José dos Santos”
Nome(2) = ”Roberto Carlos”
 É importante lembrar que o número que vai entre parênteses quando declaramos a matriz 
não é o número de níveis que existirá na matriz, pois a matriz por padrão sempre inicia com 
o número zero. Por padrão, o número de níveis que existirá na matriz será o número que 
colocarmos entre parênteses menos 1. Entretanto, podemos mudar isso definindo um nível 
inicial e um nível final dentro da matriz. Para isso fazemos o seguinte:
Dim Matriz(1 to 10) as Integer
 Como você pode ver, ao invés de usarmos somente um número que será o nível máximo 
dentro da matriz, especificamos que os níveis existentes serão entre 1 e 10. Ou seja, o 
primeiro nível será 1 e o último 10. Podemos especificar qualquer número inicial e a matriz 
sempre existirá a partir daquele número. Por exemplo, se você definir para que a matriz 
inicie por 2, se tentar usar a matriz como se o nível 1 existisse, o Visual Basic irá gerar um 
erro em tempo de execução. 
 No nosso exemplo anterior usamos Dim Nome(2) as String
para declararmos uma matriz de 3 níveis, que terá Nome(0) como primeiro nível e 
Nome(2) como o último nível. 
 Existe outra forma de fazer com que o primeiro nível de uma matriz não seja zero, que é 
usando o comando Option Base. Com ele podemos definir um valor para ser um valor 
inicial de todas as matrizes que forem criadas. O comando Option Base deve ser 
adicionado á seção General-Declarations:
Se quisermos que todas as matrizes no módulo que o Option Base for declarado, usaremos 
Option Base 1. Se quisermos que iniciem com 2, Option Base 2, e assim sucessivamente.
 Todos os níveis dentro da matriz deverão ter valores de acordo com o tipo que foi 
declarado, a menos que você declare uma matriz como sendo do tipo Variant.
 No lugar do número que define o nível da matriz podemos usar também variáveis. Essa 
prática é muito utilizada para iterar por todos os níveis da matriz, preenchendo-a com 
valores. Veja um exemplo:
Dim Matriz(10) as Integer
Dim Contador as Integer
For Contador = 0 to 10
 Matriz(Contador) = Contador
 Print Matriz(Contador)
Next
No código acima, usamos um contador para iterar pelos níveis da matriz. À medida que a 
variável Contador é incrementada, é atribuído um valor diferente ao próximo nível. O 
comando Print imprime o valor de Matriz(Contador) no formulário.
50
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 
 
 
Matrizes dinâmicas
 Eu disse aqui que existiam níveis dentro da matriz. Chamei de níveis para facilitar o 
entendimento. A partir de agora chamaremos de elementos. 
 Ás vezes nós precisamos de uma matriz, mas não sabemos o número exato de 
elemesntos que ela terá até determinado momento. O Visual Basic nos permite declarar a 
matriz omitindo o número de elementos que ela terá:
Dim Matriz() as Integer
 No entanto, na linha acima declaramos a matriz, mas não criamos nenhum elemesnto 
dentro dela. Para criarmos os elementos teríamos de usar o comando Redim:
Redim Matriz(10) 
O comando Redim funciona de forma semelhante ao comando Dim, porém ele não declara 
a variável, somente especifica o número de elementos que ela terá. 
 Podemos mudar o número de elementos quantas vezes quisermos através do comando 
Redim, entretanto, todos os valores dos elementos existentes serão perdidos:
Dim Matriz() as String
Redim Matriz(2)
Matriz(0) = ”Carlos”
Matriz(1) = ”Helena”
Matriz(2) = “José”
Redim Matriz(3)
Print Matriz(0)
Print Matriz(1)
Print Matriz(2)
O código seguinte primeiro declara a matriz através do comando Dim:
 
Dim Matriz() as String
 
 Depois especifica que a matriz deverá ter 2 elementos, através do comando Redim:
Redim Matriz(2)
Depois, definimos valores para esses elementos:
Matriz(0) = ”Carlos”
Matriz(1) = ”Helena”
Matriz(2) = “José”
Depois, redimensionamos a matriz novamente, para que tenha um elemento a mais:
51
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Redim Matriz(3)
E mandamos inprimir:
Print Matriz(0)
Print Matriz(1)
Print Matriz(2)
 Crie um projeto e coloque esse código no evento Activate do formulário e rode o 
projeto. Você verá que nada foi impresso. Você deve estar se perguntando por quê o 
programa não imprimiu nada sendo que definimos valores para esses elementos: 
Matriz(0) = ”Carlos”
Matriz(1) = ”Helena”
Matriz(2) = “José”
A resposta é:
O comando Redim redimensiona a matriz, mas apaga todos os valores existentes nos 
elementos:
Redim Matriz(3)
No nosso caso, nós definimos os valores e depois redimensionamos a matriz para que tenha 
mais um elemento. Foi aí que os valores existentes nos elementos se perderam. Porém, 
existe um meio de redimensionar a matriz preservando os valores dos elementos anteriores, 
e esse meio é usando a cláusula Preserve junto com o comando Redim:
Redim Preserve Matriz(3)
Troque a linha Redim Matriz(3) no projeto pela linha acima. Rode o projeto. Você verá 
que dessa vez os valores foram preservados, graças à cláusula Preserve. 
Matrizes Muldimensionais
 Matriz multidimensional é na verdadeuma matriz dentro de outra. 
Usaremos no exemplo a seguir o comando Option Base para forçar as matrizes a iniciarem 
com 1, facilitando assim o entendimento. 
Option Base 1
Dim Caixa(3,2) as String
Caixa(0,0)=”Segunda-Feira”
Caixa(1,0)=”Terça-Feira”
Caixa(2,0)=”Quarta Feira”
52
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Caixa(0,1)=”R$ 100,00”
Caixa(1,1)=”R$ 50,00” 
Caixa(2,1)=”R$ 200,00”
 
Á primeira vista, isso complica um pouco a cabeça, no entanto, pode ser bem mais simples 
se, ao criarmos a matriz imaginarmos uma tabela:
Coluna 1 Coluna 2
Linha 1 Segunda-Feira (1,1) R$ 100,00 (1,2)
Linha 2 Terça-Feira (2,1) R$ 50,00 (2,2)
Linha 3 Quarta-Feira (3,1) R$ 200,00 (3,2)
Essa é a representação gráfica da matriz Caixa. Como você pode ver, adicionamos 3 
elementos e esses elementos, que são representados pelas linhas, e esses elementos foram 
divididos em 2, representados pelas colunas. Entretanto, podemos ter muito mais 
subdivisões do que isso. Por exemplo:
Option Base 1
Dim Matriz(3,2,5) as String
No exemplo acima, temos 3 elementos, que se subdividem em 2, e cada um desses 2, se 
subdivide em 5 elementos.
Lógica de programação
 Eu diria que lógica de programação é a essência da programação. Um programador 
poderia conhecer inúmeros comandos, funções e objetos, mas se não tivesse lógica de 
programação nada adiantaria. Já usamos uma certa lógica de programação em vários 
exemplos anteriores, no entanto, agora vamos nos aprofundar mais nela.
 A lógica de programação é maneira que usamos os comandos, funções, variáveis, 
operadores e os demais recursos da linguagem visando resolver os problemas. Pois os 
comandos e funções não fazem nada sozinho. É você que vai criar toda estrutura. Cada 
programador desenvolve seu próprio estilo. Alguns fazem uma determinada tarefa de uma 
maneira mais fácil, outros fazem de uma maneira mais complicada. Isso depende da lógica 
de cada um. 
 São muitos os caminhos para realizar a mesma tarefa. Um professor uma vez me disse 
que, o programador deve sempre, escolher o caminho mais difícil. Eu diria o 
seguinte.Escolha o caminho que ofereça:
- Menor número de linhas de código
- Melhor desempenho na execução
- Melhor reaproveitamento do código
Porém, nenhum desses fatores deverá influenciar no perfeito funcionamento do programa.
53
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 O por quê do menor número de linhas possível como citei acima é que, quanto menos 
linhas tiverem o programa, menos linhas o programa terá de ler, e mais rápido ficará.
 O melhor desempenho também é uma conseqüência do número de linhas existentes no 
programa, mas também tem a ver com certos comandos, funções ou objetos que tem 
diferentes desempenhos.
 Por melhor reaproveitamento do código seria criar funções e subprocedimentos que 
possam ser usados por outros programas no futuro.
 Usar a lógica de programação é resolver problemas de forma rápida e eficaz, indo 
diretamente a raiz do problema.
As bibliotecas
 As bibliotecas, também chamadas de referências, são representadas por um arquivo de 
sistema(um arquivo com extensão dll,old,tlb,ocx,etc). Ao anexarmos uma biblioteca em 
nosso sistema teremos a nossa disposição o conjunto de objetos pertencentes a essa 
biblioteca. Vá no menu Projects e selecione References. Irá abrir a seguinte janela: 
Note que ao abrirmos essa janela, já existem quatro bibliotecas selecionadas:
- Visual Basic For Aplications
- Visual Basic Runtime and Procedures
- Visual Basic Objects ans Procedures
- Ole Automation
 Todas elas representam os comandos, funções e objetos nativos do Visual Basic e não 
devem ser retiradas do projeto.
 Com as bibliotecas podemos fazer quase tudo que imaginarmos. Existem bibliotecas que 
nos possibilitam a conexão com diferentes bancos de dados, bibliotecas que nos 
possibilitam executar vídeo, música, etc...
 Ao declarar uma variável ou objeto, você já deve ter notado que depois da palavra da 
palavra chave AS sempre abre uma lista com os tipos de variáveis e tipos de objetos 
acessíveis ao projeto. Quando adicionamos uma nova biblioteca, novos objetos serão 
adicionados a essa lista, e novos objetos poderão ser usados pelo projeto.
 
 Entretanto, também podemos visualizar todos os objetos acessíveis ao sistema usando o 
Object Browser. Tecle F2. 
 Abrirá uma janela como a da figura abaixo.
 O Object Browser exibe todos os objetos, módulos, e conjunto de constantes acessíveis 
ao projeto; assim como seus respectivos métodos, funções e constantes.
 Ele também exibe uma breve descrição (em inglês) sobre a função do item selecionado. 
54
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Podemos usar qualquer um desses itens que aparecem no Object Browser. Se algum 
item que quisermos não estiver aí, devemos adicionar a respectiva biblioteca como vimos 
anteriormente.
 
Comandos, funções e objetos nativos
 Seria impossível fazer uma apostila de um tamanho médio que contenha todos os 
comandos, métodos e objetos nativos do Visual Basic. Pois temos módulos financeiros, de 
sistema, gráficos e muitos outros com comandos e funções. Além disso, temos uma 
variedade de objetos para as mais diferentes funções. Tentarei aqui descrever as funções 
mais importantes que são usadas com freqüência em aplicativos comerciais.
 Quanto aos comandos, gostaria de abordar aqui apenas mais um, que se refere á abertura, 
leitura e gravação em arquivos e, embora este comando não seja usado com muita 
freqüência, pode nos fazer falta e, possivelmente poderemos fazer manutenção em um 
sistema que tenha esse comando. Além disso, em muitos aplicativos é usado um arquivo de 
registro (.INI” ) que deve ser lido com o comando Open.
Comando Open
 Com a evolução dos bancos de dados praticamente não se usa mais o comando Open 
para armazenar dados em arquivos. O comando Open serve para abrirmos um arquivo ou 
até mesmo criá-lo. Sua sintaxe é a seguinte:
Open <caminho e nome do arquivo.> For <Tipo> <tipo de bloqueio> <as <Número de 
arquivo>
Caminho e nome de arquivo - Obrigatório. É um caminho válido seguido do nome do 
arquivo. Exemplo:
C:\Arquivos\Teste.Txt 
Tipo – Palavra chave que definirá o tipo de abertura de arquivo que estamos fazendo: 
Append, Binary, Random, Input e OutPut. Se esta palavra chave for omitida o arquivo 
será aberto no modo randômico(Random).
Tipo de Bloqueio- Opcional. Determina o tipo de bloqueio em que será aberto o arquivo. 
Shared, Lock Read, Lock Write e Lock Read Write.
Número de arquivo - Um número de arquivo disponível no intervalo de 1 a 511. Podemos 
usar a função Freefile para obter o próximo número disponível.
Vamos agora ver alguns exemplos:
O código a seguir abre o arquivo TESTFILE no modo de entrada seqüencial.
Open "TESTFILE" For Input As #1
' Fecha antes de reabrir em outro modo.
Close #1
55
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Este exemplo abre o arquivo no modo Binary somente para operações de gravação.
Open "TESTFILE" For Binary Access Write As #1
' Fecha antes de reabrir em outro modo.
Close #1
O exemplo a seguir abre o arquivo no modo Random. O arquivo contém registros do tipo 
Record definido pelo usuário.
Type Record ' Define o tipo definido pelo usuário.
 ID As Integer
 Name As String * 20
End Type
Dim MyRecord As Record ' Declara a variável.
Open "TESTFILE" For Random As #1 Len = Len(MyRecord)
'Fecha antes de reabrir em outro modo.
Close #1
Este exemplo de código abre o arquivo para saída seqüencial; qualquer processo pode ler 
ou gravar no arquivo.
Open "TESTFILE" For Output Shared As #1
' Fecha antes de reabrir em outro modo.
Close #1
Este exemplo de código abre o arquivo no modo Binary para leitura; outros processos não 
conseguem ler o arquivo.
Open "TESTFILE" For Binary Access Read Lock Read As #1
Close #1
Este exemplo abre o arquivo para entrada seqüencial usando a função Freefile para retornar 
o próximo número de arquivo disponível
Open “Teste.txt” For Input as Freefile
Close Freefile
 Como você deve ter notado no código acima temos um comando que você não conhece: 
o Close. Usamos para fechar um arquivo informando apenas o número antecipado por um 
“#”.
 Até agora vimos apenas como abrir os arquivos e fechá-los. Vamos agora conhecer 
comandos que nos permitem gravar e ler dados de arquivos. Não vamos nos aprofundar 
muito nesta parte devido ao pouco uso que faremos desses recursos. No entanto vamos 
aprender o que precisamos: Gravar e ler dados de um arquivo.
Input – O comando Input nos possibilita ler dados de um arquivo aberto como seqüencial 
e jogar os dados em uma variável. Exemplo:
56
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Input #1, Nome
 A linha acima irá ler uma linha do arquivo de número 1 aberto como seqüencial e jogará 
o conteúdo da respectiva linha para a variável Nome. No caso de querermos que ele leia a 
próxima linha, devemos usar novamente a instrução Input. Se não existir próxima linha e 
a instrução Input for encontrada, o Visual Basic retornará um erro dizendo que foi 
encontrado o fim do arquivo.
 Vamos colocar um pouco do que aprendemos em prática. Primeiramente crie um arquivo 
no bloco de notas. Insira qualquer texto na primeira linha desse arquivo e o salve-o com o 
nome “Teste.Txt” no drive C.
 Depois crie um formulário e insira um TextBox com o nome de “TxtLinha”. No evento 
Load do formulário coloque o seguinte código:
 Dim A As String
 Open "c:\Teste.txt" For Input As #1
 Input #1, A
 TxtLinha.Text = A
 Close #1
 
Rode o projeto.
 Note que o TextBox do formulário obteve o conteúdo da primeira linha do arquivo texto 
que criamos. Analisando o código acima, vejamos o que fizemos:
Declaramos uma variável do tipo string denominada A.
Dim A As String
Abrirmos o arquivo “Teste.Txt” no modo seqüencial e usamos o número 1 para referenciá-
lo.
Open "c:\Teste.txt" For Input As #1
Lemos uma linha do nosso arquivo e jogamos seu conteúdo para a variável A. Como o 
arquivo recém foi aberto, ele vai ler a primeira linha.
Input #1, A
Atribuímos o valor da variável A á nossa TextBox.
Fechamos o arquivo.
Close #1
 Conseguimos o que precisamos. Lemos os dados de um arquivo e o bicho nem foi tão 
feio como parece. Devo lembrar que há várias outras maneiras de fazer isso que ilustrei 
aqui e maneiras bem mais complicadas inclusive. No entanto, essa resolve a maioria dos 
57
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
nossos problemas. No caso de termos que ler mais linhas de um arquivo basta repetir a 
instrução Input para que ele leia automaticamente a próxima linha desde que o arquivo 
ainda não tenha sido fechado.
 O exemplo a seguir ilustra um eficaz processo para lermos todas as linhas de forma 
seqüencial e jogar os dados para um TextBox.
 
Dim A As String
Dim Texto As String
Open "c:\teste.txt" For Input As #1 'Abre o arquivo para entrada.
 Do While Not EOF(1) ' Faz o loop até o fim do arquivo.
 Input #1, A
 Texto = Texto & A ‘ Concatena a variável Texto com a última linha lida
Loop
TxtLinha.Text = Texto ‘ Joga o conteúdo da variável Texto para o TextBox
Close #1 ' Fecha o arquivo.
 
Gravando dados em um arquivo
 Há vários modos de gravarmos dados em um arquivo. Veremos 2. O primeiro que 
veremos é abrindo o arquivo como OutPut, e usando o comando Print # para gravar os 
dados no arquivo. Esta prática é a mais usada quando o nosso arquivo tiver apenas uma 
linha e funciona assim:
Open "c:\teste.txt" For Output As #1
Print #1, "Dados a serem gravados"
Close #1
Simples, não?
Porém quando temos mais de uma linha em um arquivo e usamos o comando Print # todas 
as outras linhas são apagadas.
 No caso de termos mais de uma linha em um arquivo devemos abrir o arquivo como 
Random e usar o comando Put # para gravar os dados, como o exemplo a seguir:
 Open "c:\teste.txt" For Random As #1
 Put #1, 5, "Testando o comando Put"
 Close #1
 
get
58
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 A novidade no código acima é o comando Put #. A esse comando devemos fornecer 
primeiramente o número do arquivo, depois o número do registro, ou seja, a linha onde será 
inserido os dados, e depois os dados que serão inseridos.
 Bem, já sabemos como ler dados de um arquivo e gravar dados em um arquivo. O meu 
objetivo em abordar esses comandos era o de passar ao aluno, meios para isso ser feito. No 
entanto, não tratei aqui alguns comandos que julgo totalmente desnecessário e fogem do 
objetivo do nosso curso. Além disso, existem muitos objetos do Visual Basic que fazem 
essas tarefas com muito mais simplicidade e clareza.
 Caso o aluno ainda tenha curiosidade em saber mais sobre comandos de leitura e 
gravação de arquivos pode consultar o Help do Visual Basic.
Funções Internas
 Representam todas as funções nativas do Visual Basic. Temos funções de manipulação de 
strings, números, datas, objetos, tratamento de erros e muitas outras. Temos um número 
muito grande de funções internas.
 Tentarei aqui abordar as mais úteis e mais usadas.
Funções numéricas
 ABS: Retorna o valor absoluto de um número(positivo).
 Abs(Expressão numérica)
 Print Abs(-30)
 retornará 30 
 
ATN: Retorna o arco-tangente de um número.
Atn(Expressão numérica)
COS: Calcula o cosseno de um ângulo
Cos(<expressãoNumérica>)
FIX: Retorna a parte inteira de um número, ignorando as casas decimais, se houver. 
Não faz arredondamento
Fix(<expressãoNumérica>)
Print (10.2)
Retornará 10
HEX: Retorna a representação hexadecimal de um número decimal.
 Hex(<expressãoNumérica>)
INT: Retorna a parte inteira de um número, ignorando as casas decimais, se houver. 
Não faz arredondamento. Se o argumento for um número negativo será incrementado em 
um.
INT(<expressãoNumérica>)
Print Int(10.2)
59
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Retornará 10
Print Int(-10.2)
Retornará -11
LOG: Calcula o logaritmo natural de um número
LOG(<expressãoNumérica>)
RND: Retorna um número randômico, ou seja, escolhe um número aleatoriamente.
Rnd[(<expressãoNumérica>)]
SGN: Retorna -1 se o argumento for um número negativo, e 1 se for um número 
positivo.
Sgn(<expressãoNumérica>)
SIN: Calcula o seno de um ângulo.
Sin(<expressãoNumérica>)
SQR: Calcula a raiz quadrada de um número.
Sqr(<expressãoNumérica>)
TAN: Calcula a tangente de um ângulo.
Tan(<expressãoNumérica>)
Funções de String 
INSTR: Retorna a posição da primeira ocorrência de uma seqüência de caracteres 
dentro de outra
Variável = InStr ({<posiçãoInicial>,] <string>, 
<SubStringAPesquisar>[, <MétodoDeComparação])
Posição Inicial: Expressão numérica que define a posição inicial de cada 
pesquisa. Se omitido, a pesquisa começa na posição do primeiro caractere.. Este argumento 
é necessário se o Método de Comparaçãofor especificado.
String : Expressão de seqüência de caracteres que está sendo pesquisada.
SubStringAPesquisar : Expressão de seqüência de caracteres procurada.
MétodoDeComparação : Especifica o tipo comparação de seqüências de 
caracteres. Este argumento pode ser omitido, pode ser 0 ou 1. Especifique 0 (padrão) para 
realizar uma comparação binária. Especifique 1 para realizar uma comparação textual que 
desconsidere maiúsculas/minúsculas. Se este argumento for omitido, a configuração de 
Option Compare determinará o tipo de comparação.
Print InStr(1,”Visual Basic”,”a”)
Imprimirá 5
 Caso a função InStr não encontre nenhuma ocorrência da substring que estamos 
pesquisando ela retornará 0.
60
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
LCASE: Converte todas as letras maiúsculas de uma string para minúsculas.
Lcase (<string>)
Print Lcase(“VISUAL BASIC”)
Imprimirá “visual basic”
LEFT: Retorna uma quantidade de caracteres que se encontra da esquerda para a 
direita.
VariávelString = Left(<string>, <QuantidadeDeCaracteres>)
Print Left(“Visual Basic”,3)
Imprimirá “Vis”
LEN: Retorna o número de caracteres de uma expressão String ou número de bytes 
requerido para armazenar uma variável.
VariávelNumérica = Len (ExpressãoCaractere>)
Print Len(“Maria”)
Imprimirá 5
LTRIM: Remove os espaços em branco à esquerda de uma String.
VariávelString = Ltrim (<ExpressãoString>)
MID: Retorna uma Substring de uma String, ou seja, retorna um número 
especificado de caracteres de uma seqüência de caracteres.
SubString=Mid(<string>,<posiçãoInicial>[, <quantidadeDeCaracteres>])
String : Expressão de seqüência de caracteres a partir da qual os caracteres 
são retornados. 
PosiçãoInicial:Posição de caractere em String na qual a parte a ser considerada 
inicia. Se Posição Inicial for maior do que o número de caracteres em String, Mid retorna 
uma seqüência de caracteres de comprimento zero.
QuantidadeDeCaracteres: Número de caracteres a serem retornados. Se omitidos ou 
se o número de caracteres do texto for inferior ao QuantidadeDeCaracteres (inclusive o 
caractere em PosiçãoIncial), serão retornados todos os caracteres desde a PosiçãoInicial até 
o final da seqüência de caracteres.
Print Mid("José da Silva Santos",6,8)
Valor Impresso: da Silva
 Na string “José da Silva Santos” a partir da 6º posição com um comprimento de 8 
caracteres.
RIGHT: Retorna uma substring com os caracteres que se encontram da direita para 
a esquerda dentro de uma expressão String.
VariávelNumérica=Right([<ExpressãoString>, <QuantidadeDeCaracteres>)
Print Right(“José Da Silva”,5)
Valor Impresso:Silva
61
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
RTRIM: Remove os espaços à direita em uma String.
Rtrim(<string>)
SPACE: Retorna uma String com uma determinada quantidade de espaços vázios.
Space(<quantidadeDeCaracteres>)
STR: Retorna a representação de um número como uma String.
Str (<ExpressãoNumérica>)
STRCOMP: Compara duas expressões Strings como se fosse números.
StrComp(<string>,<string>[,Comparação>])
Comparação: Especifica o tipo de comparação de seqüências de caracteres. Este 
argumento pode ser omitido, pode ser 0 ou 1. Especifique 0 (padrão) para fazer uma 
comparação binária. Especifique 1 para fazer uma comparação de texto. 
Valores de retorno da função: -1 quando a primeira String for menor que a Segunda, 
0 quando forem iguais e 1 quando a primeira String for maior que a segunda.
 Print StrComp("1", "2")
 Retornará -1
 
Print StrComp("2", "1")
Retornará 1
Print StrComp("2", "2")
Retornará 0
STRING: Repete um determinado caractere a quantidade de vezes estabelecido na 
função.
String = String (<QuantidadeDeCaracteres>, <caracteres>)
Print String(30,"*")
Valor Impresso: ***************
TRIM: Remove os espaços à esquerda e à direita de uma string.
VariávelString = Trim(<String>)
UCASE: Converte uma expressão String para maiúsculas.
Ucase (<string>)
Print Ucase(“Visual Basic”)
Valor Impresso: VISUAL BASIC
Funções de Data e Hora
DATE: Retorna a data corrente do sistema operacional.
VariávelData = Date
DATEADD: Incrementa uma data nos dias, meses ou anos especificados.
62
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
DateAdd(<Intervalo>, <Incremento>,<ExpressãoData>)
Retorna uma Variant que contém uma data à qual foi adicionado um determinado 
intervalo de tempo.
<Intervalo> Expressão de seqüência de caracteres que é o intervalo de tempo que 
você quer adicionar. Tipos de caracteres usados:
yyyy Ano
q Trimestre
m Mês
y Dia do ano
d Dia
w Dia da semana
ww Semana
h Hora
n Minuto
s Segundo
<Incremento> Expressão numérica que é o número de intervalos que você 
quer adicionar. Pode ser positivo (para obter datas no futuro) ou negativo (para obter datas 
no passado).
<ExpressãoData> Data que está sendo adicionada.
 Print DateAdd("d", 2, "28/2/2006")
 Imprimirá 02/03/2006
DATEDIFF: Calcula o intervalo entre duas datas e retorna um número 
representando esse intervalo.
VariávelData=DateDiff(<intervalo>, <expressãoData1>, <expressãoData2>)
<Intervalo> Expressão de seqüência de caracteres, que é o intervalo de tempo que 
você usa para calcular a diferença entre uma data e outra.
O argumento intervalo tem estas configurações:
yyyy Ano
q Trimestre
m Mês
y Dia do ano
d Dia
w Dia da semana
ww Semana
h Hora
n Minuto
s Segundo
<ExpressãoData1 e 2> Duas datas que você quer usar no cálculo.
 Print DateDiff("d", "01/01/2001", "10/01/2001")
 Imprimirá 9
63
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 A função DateDiff sempre calcula o intervalo com base na configuração que você 
escolher em <Intervalo>. No exemplo acima, escolhemos “d”, o que fará que a função 
calcule a diferença com base nos dias. 
 Se a expressão Data1 for uma data posterior a Data2 a função retornará um 
número negativo.
DATEPART: extrai de uma determinada data uma parte dela relativo a dia, mês, 
semana, quinzena, etc.
DatePart(<intervalo>, <expressãoData>)
Intervalo pode ser:
yyyy Ano
q Trimestre
m Mês
y Dia do ano
d Dia
w Dia da semana
ww Semana
h Hora
n Minuto
s Segundo
Print DatePart("d", "24/02/2006")
Imprimirá 24
DATESERIAL: Retorna uma data para um dia, mês e ano especificados, ou seja, 
monta a data com base nos argumentos especificados.
VariavelData = DateSerial(<ano>, <mês>, <dia>)
Print DateSerial("06", "02", "24")
Valor Impresso: 24/02/2006
DATEVALUE: Retorna a data especificada numa string, ou seja, converte uma 
variável String para o tipo Data.
DateValue(<VariávelStringDeData>)
Print DateValue("01/01/2001")
Valor Impresso: 01/01/2001
DAY: Retorna o dia do mês referente a uma data.
Day(<expressãoData>)
Print Day("01/01/2001")
Valor Impresso: 1
HOUR: Retorna a hora de uma expressão de data e hora.
Hour(<ExpressãoHora>)
Print Hour("11:33:02")
Valor Impresso: 11
MINUTE: Retorna o minuto de uma expressão de data e hora.
64
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Minute(<ExpressãoHora>)
MONTH: Retorna o mês de uma data.
Month(<ExpressãoData>)
NOW: Retorna a data e a hora correntes do sistema operacional.
Now
Print Now
Imprimirá a date e hora corrente no momento em que foi executada a função.
SECOND: Retorna os segundos de uma expressão de data e hora.
VariávelNumérica = Second(<ExpressãoHora>)
TIME: Retorna a hora corrente dosistema operacional.
 Time
Print Time
Imprimirá a hora corrente no momento em que foi executada a função.
TIMER: Calcula a quantidade de segundos passados desde a meia noite.
Timer
TIMEVALUE: Retorna a hora especificada numa string, ou seja, converte uma 
String cujo conteúdo esta no formato de hora para uma variável tipo Data e Hora.
TimeValue(<ExpressãoStringDeHora>)
WEEKDAY: Retorna o dia da semana de uma data, ou seja, seu numero 
correspondente: 1 para Domingo até 7 para Sábado.
WeekDay(<ExpressãoData>)
YEAR: Retorna o ano de uma data.
 Year(<ExpressãoData>)
Funções de conversão
CBOOL: Converte uma expressão para um valor lógico (True ou false). Se o 
argumento for um zero, retornará False, caso contrário será True.
CBool(<expressão>)
Cbool(1)
Retornará True
 Cbool(0)
Retornará False
 Cbool(1 = 2)
Retornará False. Pois 1 não é igual a 2.
Dim A as Integer
Dim B as Integer
 A = 5
65
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 B = 5
 Print Cbool(A=B)
Imprimirá True. Pois o valor da variável A é igual o valor da variável B. Portanto, 
a comparação é verdadeira.
CBYTE: Converte uma expressão para um tipo Byte.
cbyte(<expressão>)
 Print CByte(100.32)
Valor Impresso: 100
Print Cbyte(450)
O Visual Basic retornará um erro porquê expressões byte não podem ser maiores 
que 255.
CCUR: Converte uma expressão numérica para um tipo-moeda.
Ccur(<expressão numérica>)
CDATE: Converte uma expressão para um tipo Data. Entretanto, esta conversão se 
concretizará desde que a expressão usada como argumento seja mesmo no formato de uma 
data, ou seja, dia/mês/Ano. Se pedirmos para fazer conversão da palavra “teste” para data 
será retornado um erro. 
Cdate(<expressão>)
Print Cdate(“01/01/2001”)
Valor Impresso: 01/01/2001
A função CDate retornará erro sempre que informarmos uma expressão que não 
resulte em uma data válida.
CDBL: Converte uma expressão numérica em um número de ponto flutuante de 
precisão dupla. Um número de ponto flutuante de precisão dupla é um dado do tipo 
Double.
Cdbl(<expressão numérica>)
CINT: converte uma expressão numérica em um número inteiro(Integer). Faz 
arredondamento.
CInt(<expressão numérica>)
Print CInt(32.30)
Valor Impresso: 32
CLNG: Converte uma expressão numérica em um número inteiro longo(Long).
CLng(<expressão numérica>)
Print CInt(32.30)
Valor Impresso: 32
66
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
CSNG: Converte uma expressão numérica em um número de ponto flutuante de 
precisão simples(Single).
CSng(<expressão >)
CSTR: Converte uma expressão numérica, data ou outra em uma string (texto).
CStr(<expressão>)
Cstr(33)
Retornará “33”
CVAR: Converte uma expressão de qualquer tipo para o tipo variante.
Cvar(<expressão>)
STR: Converte um valor numérico para o tipo String (texto). Valido somente para 
argumentos numéricos.
Str(<expressãoNumérica>)
Str(45)
Retornará “45”
STRCONV: Retorna uma string convertida de acordo com o tipo de conversão 
especificado.
Strconv(<ExpressãoString>, <TipoDeConversão>)
Tipos de conversão mais importantes que podemos usar:
vbUpperCase Converte toda a expressão em letras maiúsculas.
vbLowerCaseConverte toda a expressão em letras minúsculas.
vbProperCase Converte somente a primeira letra em maiúscula e o restante 
em minúsculo.
Print StrConv("visual basic", vbUpperCase)
Imprimirá VISUAL BASIC
Print StrConv("visual basic", vbLowerCase)
Imprimirá visual basic
Print StrConv("visual basic", vbProperCase)
Imprimirá Visual Basic
ASC: Retorna o código ANSI do primeiro caractere de uma String.
Asc(<string>)
Print Asc("A")
Valor Impresso: 65 (Numero correspondente na tabela ASCII da letra A.)
CHR: Retorna o caractere correspondente ao código na tabela ASCII
Chr(<códigoDoCaractere>)
Print Chr(65)
Valor Impresso: A
67
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
VAL: Converte uma String com caracteres numéricos em uma variável númerica.
Val(<stringNumérica>)
 
 Val(“33”)
 Retornará 33
Funções para gerenciamento de matrizes
ARRAY: Retorna um Array do tipo Variant.
ArrayVariant = Array (<ValoresDosElementos>)
Quando me refiro á Array, estou me referindo a uma matriz propriamente dita. O 
que podemos dizer sobre o comando Array é que ele transforma uma variável em uma 
matriz.
ValoresDosElementos: consiste de uma lista delimitada por vírgulas, separando 
assim os valores dos elementos. O número de elementos que a matriz terá é determinado 
pelo número de valores que ela terá.
Dim Dias as Variant
Dias = Array("Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sáb")
Print Dias(2)
Print Dias(4)
Valor Impresso: Ter
Valor Impresso: Qui
A função Array segue as mesmas regras de declaração de matrizes e obedece os 
argumentos selecionados em Option Base.
LBOUND: Retorna o menor índice de uma matriz.
Lbound(<NomeDaMatriz>)
Dim Dias As Variant
Dias = Array("Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sáb")
Print LBound(Array)
Imprimirá 0
UBOUND: Retorna o maior índice de uma matriz.
VariávelMatriz = Ubound(<NomeDaMatriz>])
Dim Dias As Variant
Dias = Array("Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sáb")
Print UBound(Dias)
Imprimirá 6
68
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Funções lógicas
IIF: Analisa uma expressão lógica, e retorna valores para quando for falso ou 
verdadeiro.
IIF (<ExpressãoLógica>,<ExpressãoParaVerdadeiro>, <ExpressãoParaFalso>)
Print IIf(2 > 1, "2 é maior que 1", "1 é maior que 2")
Imprimirá “2 é maior que 1”
A função Iff analisa a expressão lógica informada em <ExpressãoLógica> e caso a 
expressão seja verdadeira, retorna o valor contido em <ExpressãoParaVerdadeiro>, caso 
contrário retorna o valor contido em <ExpressãoParaFalso>.
SWITCH: Avalia uma lista de expressões e retorna o valor associado àquela 
primeira avaliada como verdadeira.
Switch(Expr1, Valor1[, Expr2, Valor2 , Expretc, Valoretc])
Expr : Expressão variant que você quer avaliar.
Valor : Valor ou expressão que é retornado se a expressão correspondente 
for True.
Print Switch(1 > 2, "1>2", 3 > 3, "3>3", 2 > 1, "2>1",5.3,”5>3”)
Imprimirá 2>1
A função Switch analisa cada uma das expressões e retorna o valor contido em 
<Valor> da primeira expressão correspondente que seja verdadeira . A função Switch deve 
ser composta por pares de expressões e valores de retorno. Portanto não podemos passar 
expressões sem informar os respectivos valores de retorno. Se isso for feito, o Visual Basic 
retornará um erro em tempo de execução.
Funções de Disco
 
 CURDIR: Retorna o diretório corrente.
CurDir[(<drive>)]
Print CurDir("C:")
Imprimirá o caminho completo do diretório corrente
DIR: Procura por um arquivo especificado e retorna seu nome caso o mesmo seja 
encontrado. Caso não encontre retorna Null(Nulo). Podemos procurar arquivos por 
atributos também.
Dir[(Nomedocaminho[, Atributos])]
Nomedocaminho(Obrigatório) :Expressão de seqüência de caracteres que 
especifica um nome de arquivo e pode incluir diretório ou pasta e unidade de disco. Se o 
nome do caminho ou o arquivo especificado não for encontrado é retornado uma string 
vazia “”(Empty).
69
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Atributos(Opcional) :Constante ou expressão numérica que especifica atributos de 
arquivo. Se omitido, todos os arquivos normais que tiveremNomedocaminho 
correspondente são retornados. 
As configurações do argumento Atributos são:
vbNormal 0 Normal.
vbHidden 2 Oculto.
vbSystem 4 Arquivo de sistema,.
vbVolume 8 Etiqueta de volume; se especificada, todos os outros atributos são 
ignorados.
vbDirectory 16 Diretório ou pasta.
Exemplo:
If Dir("c:\tesste.txt") = "" Then
 MsgBox "Arquivo não existe"
End If
O exemplo acima funcionaria da mesma forma se usássemos a palavra Empty, que 
representa vazio no lugar de “”:
If Dir("c:\teste.txt") = Empty Then
 MsgBox "Arquivo não existe"
End If
 
Use a função Dir para verificar se determinados arquivos, vitais para ao 
funcionamento do sistema, existem. 
FILEDATETIME: Retorna a data e a hora da última atualização do arquivo.
FileDateTime(<NomeArquivo>)
FILELEN: Retorna o tamanho do arquivo em bytes.
FileLen(<NomeArquivo>)
GETATTR: Verifica os atributos de um arquivo ou diretório.
GetAttr(<NomeArquivo>)
Veja os valores de retorno desta função:
0 vbNormal Normal.
1 vbReadOnly Somente Leitura.
2 vbHidden Oculto.
4 vbSystem Arquivo de sistema
16 vbDirectory Diretório ou pasta.
32 vbArchive O arquivo foi modificado desde o último backup.
Print GetAttr("C:\windows\system32\kernel32.dll")
Imprimirá 32
Funções de Teste
70
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
ISARRAY: Testa se uma variável é uma matriz
IsArray(<variável>)
ISDATE: Testa se o argumento pode ser convertido para uma data. Esta data deve 
estar dentro dos padrões de data. 
IsDate(<expressão>)
ISEMPTY: Verifica se uma variável string já foi iniciada.
IsEmpty retornará True se a variável estiver iniciada; caso contrário retornará 
False. Se a expressão contiver mais de uma variável, o retorno será sempre False.
IsEmpty(<expressão>)
ISERROR: Testa se uma expressão é um valor de erro.
IsError(<expressão>)
ISMISSING: Testa se um argumento opcional foi passado como parâmetro para 
uma procedure ou função.
IsMissing(<NomedoArgumento>)
ISNULL: Testa se uma variável possui valor nulo.
IsNull(<Expressão>)
ISNUMERIC: Testa se o argumento pode ser convertido para um número.
IsNumeric(<Expressão>)
Print IsNumeric(“AB”)
Imprimirá False
Print IsNumeric(“10”)
Imprimirá True
ISOBJECT: Testa se uma expressão referencia a um objeto válido.
 IsObject(<Expressão>)
VARTYPE: Retorna o tipo de variável especificada como argumento:
VarType(<Variável>)
Retorna os valores abaixo:
0 Empty (Não iniciada).
1 Null Nenhum dado válido.
2 Inteiro (Integer).
3 Inteiro por extenso (Long)
4 Número de ponto flutuante de precisão simples (Single).
5 Número de ponto flutuante de precisão dupla (Double).
6 Moeda (Currency).
7 Data (Date).
8 Seqüência de caracteres textos (String).
9 objeto de Automação OLE (Object).
10 Erro (Error).
71
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
11 Booleano Boolean).
12 Variant (usada somente com matrizes de Variantes).
13 Um objeto que não seja de Automação OLE (DataObject).
17 Byte 
8192 Matriz (Array).
Exemplo:
Dim A As Integer
A = 220
If VarType(A) = 2 Then
 MsgBox "Variável A é Do Tipo Integer"
Else
 MsgBox "Variável A não é do tipo Integer"
End If
TYPENAME: Retorna o nome descritivo do tipo de uma variável.
TypeName(<Variável>
Vamos aos nomes de retorno da função:
Byte Um byte.
Integer Um inteiro.
Long Um inteiro por extenso.
Single Um número de ponto flutuante de precisão simples.
Double Um número de ponto flutuante de precisão dupla.
Currency Um valor de moeda.
Date Uma data.
String Uma seqüência de caracteres.
Boolean Um valor Booleano.
Error Um valor de erro.
Empty Não iniciado.
Null Nenhum dado válido.
Object Um objeto que suporta Automação OLE.
 A função TypeName funciona da mesma maneira que a VarType. A diferença é que 
enquanto a VarType retorna números que representam os tipos das variáveis, a função 
TypeName retorna diretamente os nomes dos tipos da varáveis. 
Funções de Escolha
CHOOSE: Seleciona um valor de uma lista de argumentos.
Choose (<índice>, <Valor>[, <Valor>]...)
Índice : Expressão numérica ou campo que resulta num valor entre 1 e o 
número de opções disponíveis.
Valor : Expressão Variant que contém um dos possíveis valores a serem retornados.
72
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 A função Choose retorna um valor de uma lista de valores separada por vírgula, com 
base no número informado em <Índice>.
 
Print Choose(3,"Segunda-Feira","Terça-Feira","Quarta-Feira","Quinta-
Feira")
Imprimirá Quarta-Feira
MSGBOX: Exibe uma caixa de diálogo durante a execução do programa. Essa 
caixa de diálogo poderá informar algo ou perguntar algo ao usuário, dependendo da 
configuração especificada no comando. Pode ser usada como uma função para retornar 
valores de resposta ou como comando para enviar informações ao usuário.
 MsgBox (<ExpressãoPrompt>,<Estilo>, <BarraDeTítulo>)
ExpressãoPrompt : Expressão de seqüência de caracteres exibida como a 
mensagem numa caixa de diálogo. O tamanho máximo de ExpressãoPrompt é de 
aproximadamente 1024 caracteres, dependendo da largura dos caracteres usados. Se 
ExpressãoPrompt for composto por mais de uma linha, você poderá separar as linhas 
usando um caractere de retorno de carro (Chr(13)), um caractere de alimentação de linha 
(Chr(10)) ou uma combinação de caracteres de retorno de carro e alimentação de linha 
(Chr(13) & Chr(10)) entre cada linha.
Estilo: Um número ou uma soma de números que representará o estilo da caixa de 
diálogo. Por exemplo, se é uma caixa de diálogo de informação, de pergunta, exclamação, 
erro, etc...
Abaixo temos uma tabela com os estilos de caixa de diálogo que podemos usar:
Constante Valor Descrição
vbOKOnly 0 Exibe apenas o botão "OK".
VbOKCancel 1 Exibe os botões "OK" e "Cancelar".
VbAbortRetryIgnore 2 Exibe os botões "Anular", "Repetir" e 
"Ignorar".
VbYesNoCancel 3 Exibe os botões "Sim", "Não" e 
"Cancelar".
VbYesNo 4 Exibe os botões "Sim" e "Não".
VbRetryCancel 5 Exibe os botões "Repetir" e "Cancelar".
VbCritical 16 Exibe o ícone "Mensagem crítica". 
VbQuestion 32 Exibe o ícone "Consulta de advertência".
VbExclamation 48 Exibe o ícone "Mensagem de 
advertência".
VbInformation 64 Exibe o ícone "Mensagem de 
informação".
VbDefaultButton1 0 O botão "Primeiro" é o padrão.
VbDefaultButton2 256 O botão "Segundo" é o padrão.
VbDefaultButton3 512 O botão "Terceiro" é o padrão.
73
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
VbApplicationModal 0 Janela restrita do aplicativo; o usuário 
deve responder à caixa de mensagem 
antes de continuar seu trabalho no 
aplicativo atual.
VbSystemModal 4096 Janela restrita do sistema; todos os 
aplicativos são suspensos até que o 
usuário responda à caixa de mensagem.
O primeiro grupo de valores (05) descreve o número e tipo de botões exibidos na 
caixa de diálogo; o segundo grupo (16, 32, 48, 64) descreve o estilo de ícone; o terceiro 
grupo (0, 256, 512) determina qual botão é o padrão; e o quarto grupo (0, 4096) determina 
modalidade da caixa de mensagem. Quando adicionar números para criar um valor final 
para o argumento buttons, use somente um número de cada grupo. 
Durante a digitação da função, quando formos escolher o estilo da mensagem, o 
Visual Basic automaticamente apresenta uma lista com vários estilos:
 Podemos selecionar qualquer um item da lista, pois na verdade, cada um desses itens, 
são constantes que representam os números de estilos que vimos na tabela. Entretanto, 
podemos substituiresses itens por uma soma resultante de um estilo personalizado que 
possamos querer.
Observação Estas constantes são especificadas pelo Visual Basic para aplicativos. 
Assim, os nomes podem ser usados em qualquer lugar do código em lugar dos valores 
reais.
BarraDeTítulo : Expressão de seqüência exibida na barra de títulos da caixa 
de diálogo. Se você omitir BarraDeTítulo, o nome do aplicativo será incluído na barra de 
títulos.
Estes são os valores que esta função retorna, para informar qual foi à ação do 
usuário:
Constante Valor de Retorno Botão escolhido
vbOK 1 "OK"
vbCancel 2 "Cancelar"
vbAbort 3 "Anular"
vbRetry 4 "Repetir"
vbIgnore 5 "Ignorar"
vbYes 6 "Sim"
vbNo 7 "Não"
Se a caixa de diálogo exibir um botão "Cancelar", pressionar a tecla ESC terá o 
mesmo efeito que escolher "Cancelar". 
74
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Se quiser especificar mais do que o primeiro argumento nomeado, você deverá usar 
MsgBox em uma expressão. Se quiser omitir alguns argumentos de posição, você deverá 
incluir o delimitador de vírgula correspondente.
Já usamos bastante a função MsgBox como comando em vários exemplos do nosso 
curso.
Vejamos agora um modo de usá-la para retornar valores:
If MsgBox("Teste de Mensagem", vbOKCancel) = vbOK Then
MsgBox "Você clicou OK"
End If
 A função MsgBox retorna um número dizendo qual foi o botão que o usuário 
pressionou. No nosso exemplo acima, usamos a constante vbOK que representa o número 
correspondente ao botão OK, para verificar se ele foi pressionado ou clicado. Caso seja, 
usaremos novamente a função MsgBox como comando, apenas para informar ao usuário o 
botão que ele clicou.
 Note que ao usarmos a função MsgBox para retornar valores devemos colocar os seus 
argumentos entre parênteses. E quando usarmos a função MsgBox apenas para exibir 
mensagens, o uso dos parênteses não é necessário.
Formatação de Dados
Podemos formatar os dados a serem exibidos em caixas de texto, formulário, etc...
Para isso fazemos uso da função Format. A função Format tem vastos recursos 
para formatação de dados numéricos, string, moeda, data, etc.
 Sua sintaxe é a seguinte: 
Format(<expressão>[, <Formato>)
<Expressão>: Seria a nossa expressão a ser formatada. Os dados que queremos formatar. 
Pode ser uma string, uma expressão numérica, data, etc. ou qualquer variável dos tipos 
citados.
<Formato>: O formato pode ser determinado pelas máscaras de formatação, que 
veremos a seguir, ou ainda, por uma palavra-chave que determina para que tipo de dados 
estamos formatando a <Expressão>. 
Formatação de Expressões Numéricas
Para formatar qualquer expressão numérica usamos “#” para representar um digito 
de 0 a 9, “,” para representar os milhares e “.” para representar as casas decimais. Como o 
padrão brasileiro para milhares e casas decimais é exatamente o contrário, o Visual Basic 
automaticamente irá colocar no nosso padrão, pois irá verificar qual o formato usado para 
o pais de acordo com o que foi estabelecido no painel de controle. 
Print Format(12345.3,”##,###.##”)
Valor Impresso: 12.345,3
Usamos o simbolo “#” para representar a disposição dos números. Não há 
necessidade de colocar a mesma quantidade de números e “#”. Se tivessesmos colocado 
75
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Print Format(12345.3,”#,###,###.##”), ainda assim seria impresso somente “12.345,3”. 
Entretanto, se colocarmos: 
Print Format(12345.3, "###.##")
Valor Impresso: 12345,3
Perceba que não podemos colocar uma formatação menor que os números que serão 
impressos, pois senão a formatação não irá alcançar toda a extensão dos números.
O símbolo “#” é substituído por números quando existir número para ser 
substituído. Note que o número decimal é “.3” e apesar de termos usado uma formatação 
para casas decimais com dois símbolos “##”, não apareceu as duas casas decimais. Se 
quisermos forçar o aparecimento de zeros quando não tiver número para ser impresso, 
usados “0” no lugar de “#”. Veja:
Print Format(12345.3,”##,###.00”)
Valor Impresso: 12.345,30
Print Format(12345,”##,###.00”)
Valor Impresso: 12.345,00
Isto vale também para formatação de números sem casas decimais:
Print Format(45,”0000”)
Valor Impresso: 0045
Se quisermos uma formatação diferente para números negativos, basta colocar essa 
formatação após o ponto-e-virgula.
Print Format(12345,”##,###.00; (-)##,###.00”)
Valor Impresso: 12.345,00
Print Format(-12345,”##,###.00; (-)##,###.00”)
Valor Impresso: (-)12.345,00
Veja abaixo os caracteres que podem ser usados na formatação de valores 
numéricos:
0 Exibe um dígito ou um zero. Se a expressão tiver um dígito na posição em 
que o 0 aparece na seqüência de caracteres de formato, ele será exibido; caso contrário, é 
exibido um zero nessa posição.
Se o número possui um número de dígitos inferior ao de zeros (em qualquer lado da 
casa decimal) na expressão de formato, exibe zeros à esquerda ou à direita. Se o número 
tiver mais dígitos à direita do separador decimal do que zeros à direita do separador 
decimal na expressão de formato, arredonda o número para tantas casas decimais quantos 
forem os zeros existentes. Se o número tiver mais dígitos à esquerda do separador decimal 
do que zeros à esquerda do separador decimal na expressão de formato, exibe os dígitos a 
mais sem modificações.
# Exibe um dígito ou nada. Se a expressão tiver um dígito na posição em que 
o símbolo # aparece na seqüência de caracteres de formato, ele será exibido; caso contrário, 
nada será exibido nessa posição.
Este símbolo funciona como o espaço reservado para o dígito 0, mas os zeros à 
esquerda e à direita não são exibidos se o número tiver a mesma quantidade ou menos 
dígitos do que existem # caracteres em qualquer um dos lados do separador decimal na 
expressão de formato.
. Espaço reservado para decimal
76
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Para algumas localidades, é usada uma vírgula como separador decimal. O espaço 
reservado para decimal determina quantos dígitos são exibidos à esquerda e à direita do 
separador decimal. Se a expressão de formato contiver apenas sinais de números à esquerda 
deste símbolo, os números inferiores a 1 começam com um separador decimal. Se você 
quiser que um zero à esquerda seja sempre exibido com números fracionários, use 0 como 
o primeiro espaço reservado para dígito à esquerda do separador decimal. O caractere real 
utilizado como espaço reservado para decimal na saída formatada depende do Formato 
Numérico reconhecido pelo sistema.
% Espaço reservado para porcentagem
A expressão é multiplicada por 100. O caractere de porcentagem (%) é inserido na 
posição onde ele aparece na seqüência de caracteres de formato.
, Separador de milhar
Para algumas localidades, é utilizado um ponto como o separador de milhar. O 
separador de milhar separa milhar de centena dentro de um número que tenha quatro ou 
mais casas à esquerda do separador decimal. O uso padrão do separador de milhar é 
especificado no formato que contém um separador de milhar delimitado por espaços 
reservados de dígito (0 ou #). Dois separadores de milhar adjacentes ou um separador de 
milhar imediatamente à esquerda do separador decimal (sendo ou não especificado um 
decimal) significa "aplique uma escala ao número dividindo-o por 1000 e arredonde-o 
conforme necessário." Use essa técnica para aplicar escalas a números extensos. Por 
exemplo, a seqüência de caracteres de formato "##0,," pode ser usada para representar 100 
milhões como 100. Números inferiores a 1 milhão são exibidos como 0. Dois separadoresde milhar adjacentes em qualquer posição que não seja a imediatamente à esquerda do 
separador decimal serão considerados apenas como especificação do uso de um separador 
de milhar. O caractere real utilizado como o separador de milhar na saída formatada 
depende do Formato Numérico reconhecido pelo sistema.
E- E+ e- e+ Formato científico
Se a expressão de formato contiver pelo menos um espaço reservado para dígito (0 
ou #) à direita de E-, E+, e- ou e+, o número é exibido em formato científico, sendo E ou e 
inserido entre o número e seu expoente. O número de espaços reservados para dígito à 
direita determina o número de dígitos do expoente. Use E- ou e- para incluir um sinal de 
subtração (-) ao lado de expoentes negativos. Use E+ ou e+ para incluir um sinal de 
subtração ao lado de expoentes negativos e um sinal de adição (+) ao lado de expoentes 
positivos.
- + $ ( ) space Exibe um caractere literal
Para exibir uma caractere diferente dos listados, preceda-o com uma barra invertida 
(\) ou coloque-o entre aspas (" ").
\ Exibe o caractere seguinte da seqüência de caracteres de formato
Muitos caracteres da expressão de formato têm um significado especial e não 
podem ser exibidos como caracteres literais a menos que sejam precedidos por uma barra 
invertida. A barra propriamente não é exibida. Sua utilização equivale a colocar o caractere 
seguinte entre aspas. Para exibir uma barra invertida, use duas barras invertidas (\\).
Exemplos de caracteres que não podem ser exibidos como caracteres literais são 
caracteres de formatação de data e hora (a, c, d, h, m, n, p, q, s, t, w, y e /:), caracteres de 
77
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
formatação numérica (#, 0, %, E, e, vírgula e ponto) e os caracteres de formatação de 
seqüências de caracteres (@, &, <, >, e !).
"ABC" Exibe a seqüência de caracteres que está entre aspas.
Para incluir uma seqüência de caracteres em Format a partir do código, você deve 
usar Chr(34) para delimitar o texto (34 é código de caractere para aspas).
 Usamos também como argumento na formatação de expressões numéricas algumas 
palavras-chave que correspondem a algum tipo de formato padrão.
General Number : Exibe o número na forma em que se encontra, sem separadores 
de milhar.
Print Format(123456.7, "General Number")
Valor Impresso: 123456,7
Currency : Exibe o número com o separador de milhar, se apropriado; exibe dois 
dígitos à direita do separador de casa decimal. Note que a saída é baseada nas 
configurações do Painel de Controle.
Print Format(123456.7, "Currency")
Valor Impresso: R$123.456,70
Fixed : Exibe pelo menos um dígito à esquerda e dois dígitos à direita do 
separador de casa decimal. 
Print Format(123456.7, "Fixed")
Valor Impresso: 123456,70
Print Format(1, "Fixed")
Valor Impresso: 1,00
Standard : Exibe o número com o separador de milhar, pelo menos um dígito à 
esquerda e dois dígitos à direita do separador de casa decimal.
Print Format(123456.7, "Standard")
Valor Impresso: 123.456,70
Percent : Exibe o número multiplicado por 100 com um sinal de porcentagem (%) 
anexado à direita; sempre mostra dois dígitos à direita do separador de casa decimal.
Print Format(123456.7, "Percent")
Valor Impresso: 12345670,00%
Print Format(1, "Percent")
Valor Impresso: 100,00%
Scientific : Usa a notação científica padrão.
Print Format(123456.7, "Scientific")
Valor Impresso: 1,23E+05
Formatação de Expressões Lógicas
Yes/No : Exibe “No” se o número for 0; caso contrário, exibe “Yes”.
78
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
True/False : Exibe “False” se o número for 0; caso contrário, exibe “True”.
On/Off : Exibe “Off” se o número for 0; caso contrário, exibe “On”.
Print Format(1,”True/False”)
Valor Impresso: True
Formatação de Expressões Data e Hora
Usamos a função Format também para formatar uma data ou hora, configurando 
assim o formato que será impresso. Veja os caracteres que podemos usar: 
: Separador de hora. Em algumas localidades podem ser usados outros 
caracteres para representar o separador de hora. O separador de hora separa horas, minutos 
e segundos quando os valores de hora são formatados. O caractere real usado como o 
separador de hora na saída formatada é determinado pelas configurações de seu sistema.
/ Separador de data. Em algumas localidades podem ser usados outros 
caracteres para representar o separador de data. O separador de data separa o dia, mês e ano 
quando os valores de data são formatados. O caractere real usado como o separador de data 
na saída formatada é determinado pelas configurações de seu sistema.
c Exibe a data como ddddd e a hora como ttttt, nessa ordem. Exibe apenas 
informações de data se não houver parte fracionária para o número de série de data; exibe 
apenas informações de hora se não houver parte inteira.
Print Format("01/08/96","c")
Valor Impresso: 01/08/96
Print Format(now,"c")
Valor Impresso: 01/08/96 22:51:11
d Exibe o dia como um número sem zeros à esquerda.
Print Format("05/07/96","d")
Valor Impresso: 5
dd Exibe o dia como um número com zeros à esquerda.
Print Format("05/07/96","dd")
Valor Impresso: 05
ddd Exibe o dia da semana como uma abreviado em 3 letras.
Print Format("01/08/96","ddd")
Valor Impresso: Qui
dddd Exibe o dia da semana como um nome completo.
Print Format("01/08/96","dddd")
Valor Impresso: Quinta-feira
w Exibe o dia da semana como um número (1 para domingo até 7 para 
sábado).
ww Exibe a semana do ano como um número.
Print Format("01/08/96","ww")
Valor Impresso: 31
79
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
m Exibe o mês como um número sem zeros à esquerda. Se m vier 
imediatamente depois de h ou hh, é exibido o minuto em lugar do mês.
Print Format("01/08/96","m")
Valor Impresso: 8
mm Exibe o mês como um número com zeros à esquerda. Se m vier 
imediatamente depois de h ou hh, é exibido o minuto em lugar do mês.
Print Format("01/08/96","mm")
Valor Impresso: 08
mmm Exibe o mês como uma abreviado em três letras.
Print Format("01/08/96","mmm")
Valor Impresso: Ago
mmmm Exibe o mês como um nome completo.
Print Format("01/08/96","mmmm")
Valor Impresso: Agosto
q Exibe o trimestre do ano como um número.
Print Format("01/08/96","q")
Valor Impresso: 3
y Exibe o dia do ano como um número.
Print Format("01/08/96","y")
Valor Impresso: 214
yy Exibe o ano como um número de dois dígitos.
Print Format("01/08/96","yy")
Valor Impresso: 96
yyyy Exibe o ano como um número de quatro dígitos.
Print Format("01/08/96","yy")
Valor Impresso: 1996
h Exibe a hora como um número sem zeros à esquerda.
Print Format("09:13:55","h")
Valor Impresso: 9
hh Exibe a hora como um número com zeros à esquerda.
Print Format("09:13:55","h")
Valor Impresso: 09
n Exibe o minuto como um número sem zeros à esquerda.
nn Exibe o minuto como um número com zeros à esquerda.
s Exibe o segundo como um número sem zeros à esquerda.
ss Exibe o segundo como um número com zeros à esquerda.
80
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
t t t t t Exibe uma hora como uma hora completa (inclusive hora, minuto e 
segundo), formatada usando o separador de hora definido pelo formato de hora reconhecido 
pelo sistema.
Print Format(now,"ttttt")
Valor Impresso: 23:17:27
 Usando estes caracteres especiais podemos formatar uma data de várias maneiras, 
como por exemplo: 
Print Format(“01/08/96”,”dd/mmmm/yyyy”)
Valor Impresso: 01/Agosto/1996
Print Format(“01/08/96”,”dd/mmm/yy”)
Valor Impresso:01/Ago/96
 Veja abaixo a relação das palavras-chaves aceita pela função Format para 
expressões de data e hora:
General Date : Exibe a data e a hora nos formatos estabelecidos nas configurações 
do Windows. Caso a expressão seja somente uma data, será exibido 
Print Format(now,"general date")
Valor Impresso: 01/08/96 23:21:25
Print Format("01/08/96","general date")
Valor Impresso: 01/08/96
Print Format("09:24:11","general date")
Valor Impresso: 09:24:11
Long Date : Exibe uma data de acordo com o formato por extenso de data de seu 
sistema.
Print Format("01/08/96","Long Date")
Valor Impresso: Quinta-feira, 1 de Agosto de 1996
Medium Date : Exibe uma data usando o formato médio de data apropriado para a 
versão de idioma do aplicativo host.
Print Format("01/08/96","Medium Date")
Valor Impresso: 01-Ago-96
Short Date : Exibe uma data usando o formato abreviado de data de seu sistema.
Print Format("01/08/96","Short Date")
Valor Impresso: 01/08/96
Long Time : Exibe uma hora usando o formato por extenso de hora de seu sistema: 
inclui horas, minutos, segundos.
Print Format("09:24:11","Long Time")
Valor Impresso: 09:24:11
Medium Time : Exibe uma hora no formato 12 horas usando horas e minutos e a 
designação AM/PM.
Print Format("09:24:11","Medium Time")
Valor Impresso: 09:24 AM
81
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Short Time : Exibe uma hora usando o formato 24 horas.
Print Format("09:24:11","Short Time")
Valor Impresso: 09:24
Formatação de Expressões String
A manipulação de expressões String podem ser formatados usando os caracteres 
especiais abaixo:
@ Exibe um caractere ou um espaço. Se a seqüência de caracteres tem um 
caractere na posição em que @ aparece na seqüência de formato, ele será exibido; caso 
contrário, um espaço será apresentado nessa posição. Os espaços reservados são 
preenchidos da direita para a esquerda a menos que exista um caractere ! na seqüência de 
caracteres de formato. Veja abaixo.
& Exibe um caractere ou nada. Se a seqüência de caracteres tem um caractere 
na posição em que & aparece, ele será exibido; caso contrário, nada será exibido. Os 
espaços reservados são preenchidos da direita para a esquerda a menos que exista um 
caractere ! na seqüência de caracteres de formato. Veja abaixo.
! Força preenchimento da esquerda para a direita dos espaços reservados. O 
preenchimento padrão é feito da direita para a esquerda.
< Exibe todos os caracteres no formato de minúsculas.
> Exibe todos os caracteres no formato de maiúsculas.
Banco de Dados
 Abordarei aqui, o assunto Banco de Dados na forma mais simples possível. O que quero 
dizer é que não vamos nos prender a conhecer todos os recursos que um banco de dados 
pode nos fornecer. Até mesmo por que esse foge ao objetivo do nosso curso. No entanto, 
vamos aprender tudo o que precisamos para criar aplicativos comerciais usando um banco 
de dados de uma forma limpa, rápida e simples. 
 Porém, devo dizer ao aluno que nunca é demais se aprofundar no assunto Banco de 
Dados, tentando tirar o máximo de proveito que ele pode nos fornecer. Principalmente, 
com tantos tipos novos de bancos de dados surgindo por aí.
 A biblioteca de conexão, que contém os objetos que vamos usar para nos conectarmos 
com os bancos de dados que criaremos, é o Microsoft D.A.O. (Microsoft Data Access 
Objects) e nos permite nos conectarmos com banco de dados no formato Access, além de 
tipos de bancos de dados mais antigos como Dbase, FoxPro, Paradox, etc.
 Durante o nosso curso, trabalharemos com o Microsoft Access. Devo lembrar que a 
mudança de um tipo de banco de dados para o outro está na que um tem mais ou menos 
recursos que o outro, sendo que todos têm em comum, tabelas, campos, chave primária, etc.
82
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Sempre que for utilizar um banco de dados que você ainda não conheça, consulte a sua 
documentação.
O que é um banco de dados?
 Várias regras podem ser levadas em consideração no que diz respeito a julgar se temos 
um gerenciador banco de dados ou não. O que quero dizer é que o que uns poderão julgar 
como um gerenciador de banco de dados, outros considerarão apenas um gerenciador de 
arquivos. 
 No entanto, eu diria que um banco de dados se resume a um conjunto de tabelas, 
consultas, relatórios, e demais ferramentas de acesso a dados. 
 No nosso curso, não chegaremos a usar tudo o que um gerenciador de banco de dados 
pode nos oferecer. Mas novamente devo dizer ao aluno para que aprenda o máximo 
possível sobre banco de dados e o que eles podem oferecer para simplificar os sistemas que 
iremos construir. 
Criando um banco de dados
 Já citei anteriormente que o banco de dados que utilizaremos no nosso curso é o 
Microsoft Access. Poderemos optar entre 2 ferramentas para criar o banco de dados:
Temos o próprio editor do Microsoft Access, caso você tenha o Office instalado:
e também o Visual Data Manager, que é uma ferramenta do Visual Basic:
 O Visual Data Manager oferece uma interface mais básica e objetiva, porém tem a 
desvantagem de ser toda em inglês e não oferece alguns recursos como gerenciamento de 
relatórios e formulários. No entanto, como não vamos usar esses recursos de banco de 
dados nesse curso, poderíamos usá-lo sem problemas. 
 Devo dizer que bancos de dados criados com as últimas versões do Microsoft Access 
não são reconhecidas pelo Visual Data Manager, não podendo assim serem abertas.
O que são tabelas?
 As tabelas são bases de qualquer banco de dados. É delas que virão os dados a serem 
processados por consultas, relatórios, formulários e demais objetos de banco de dados. As 
tabelas são divididas em campos e registros.
 Os campos são definidos quando definimos a estrutura da tabela, já os registros são 
adicionados de acordo com a necessidade do usuário. Para ilustrar o que estou dizendo, 
veja a tabela a seguir:
Código Nome Endereço Telefone
1 Maria da Silva Rua Silvio Toigo, 432 887-7787
2 João dos Santos Rua das Tulipas, 920 7877-6545
3 José Carlos Av. Brasil, 5555 9877-4544
83
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Código, Nome, Endereço e Telefone representam os campos, enquanto os respectivos 
dados desses campos representam um registro.
 Um registro é um conjunto dos dados de cada campo.Poderíamos também entendê-lo 
como uma linha dentro da tabela.
Criando uma tabela
 Por razão de compatibilidade, vamos criar nossa tabela usando o Visual Data Manager, 
lembrando que poderemos abrir o Banco de Dados usando o Microsoft Access 
posteriormente, caso quisermos. Nas últimas versões do Access, talvez tenhamos que fazer 
uma conversão.
 Acesse, dentro do Visual Basic, o menu Add-Ins e selecione Visual Data Manager. 
Depois de aberto, selecione a opção New para criar um novo banco de dados, depois 
selecione o tipo, que no nosso caso é o Microsoft Access, e depois selecione Version 7.0 
MDB, que oferece maior compatibilidade com as últimas versões do Access, podendo 
assim ser aberto.
 Abrirão 2 janelas, uma para serem executados instruções SQL *, e outra com as 
propriedades do banco de dados.
* - Instruções SQL são instruções específicas de banco de dados como criar tabelas, 
fazer manutenção dos dados, etc. Como nosso curso irá tratar os bancos de dados na 
sua forma mais básica, as instruções SQL fogem do objetivo do nosso curso.
Já temos o banco de dados propriamente dito, agora precisamos criar tabelas. Para 
criar uma tabela, clique com o botão direito do mouse em cima das propriedades e 
selecione a opção New Table.Abrirá a seguinte janela:
Este é a janela de adicionar tabelas. Podemos aqui definir o nome da tabela, assim 
como adicionar campos, índices e selecionar as suas respectivas propriedades.
 Ao clicar no botão de Adicionar Campo, você verá que se abrirá uma janela. È 
nessa janela que selecionamos as propriedades do campo.
84
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 
Crie uma tabela com o nome de “Clientes” e adicione os seguintes campos: 
Código 
Nome
DataNasc
Telefone
Ao campo código, obviamente, você terá que escolher um tipo que aceite números. 
O ideal seria usar um campo do tipo Long autoincrementável, fazendo assim que 
cada cliente adicionado tenha um novo código automaticamente. 
 Para o campo Nome poderíamos usar um campo do tipo Text com um tamanho 
de 40 caracteres sem problemas.
 O campo DataNasc servirá para gravarmos datas de nascimento, portanto o tipo 
DateTime seria o apropriado.
 Quanto ao Telefone, deve ser do tipo Text por que usaremos sinais como - e * e 
se colocarmos números com sinais em um campo numérico o Visual Basic 
entenderá que estamos tentando calcular valores e retornará o resultado.
 Depois de adicionar todos os campos, feche a janela de adicionar campo e clique 
no botão Build the Table para confirmar a criação da tabela. Você vai notar que a 
tabela já vai aparecer na janela de banco de dados.
 Se você clicar 2 vezes com o botão esquerdo do mouse em cima dela, ela é aberta para 
inclusão, alteração e edição de dados.
 Se clicarmos com o botão direito em cima da tabela aparecem opções como Open, que 
abrirá a tabela do mesmo modo como se tivéssemos dado 2 cliques; Design, que serve para 
alterarmos a estrutura da tabela, Rename(renomear); Delete(deletar). Além disso, 
aparecem outras opções que não nos serão úteis no momento.
 Bem, vamos fazer uso da nossa tabela. Insira 5 registros com nomes, telefones e datas de 
nascimento diferentes.
 Você verá que, a cada novo registro que adicionarmos o campo Código é incrementado 
em 1. Notará também que se um valor atribuído á um campo não coincidir com o tipo que 
foi definido para o mesmo,a tabela não aceitará. Por exemplo, se você tiver um campo do 
tipo DateTime, só conseguirá inserir datas. Esse tipo de data obedece à formatação que 
você definir no Painel de Controle. 
 
Criando índices
85
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Um índice é usado para indexar registros. Por exemplo, se temos um campo Nome e 
quisermos que este campo seja ordenado por ordem alfabética. Devemos criar um índice e 
selecionar o campo Nome para que seja a base desse índice.
 Um campo do tipo numérico, seja ele Integer, Long ou qualquer outro tipo numérico, ao 
ser indexado ficará em ordem crescente. Um campo do tipo DateTime, por ordem 
cronológica. Resumindo, um índice organiza os dados da forma mais presumível possível. 
 Um índice, além de organizar os registros com base em um campo, também torna as 
pesquisas pelo campo que tem um índice, bem mais rápidas.
 Vamos agora criar alguns índices na nossa tabela de clientes. Clique na tabela com o 
botão direito e selecione a opção Design. Após, clique no botão Add Index para adicionar 
um novo índice. Abrirá a seguinte janela:
 
 
Vamos agora adicionar um índice chamado Nome a tabela que criamos. Esse índice terá 
como base o campo Nome. Não irá aceitar valores nulos nem valores iguais.
Definindo a chave primária
 Uma chave primária é útil quando queremos que uma tabela não aceite valores nulos e 
nem valores duplicados. Uma chave primária também é útil para se relacionar com outras 
tabelas.
 Podemos dizer que uma chave primária é um índice ou um conjunto de índices que não 
podem ter valores repetidos ou nulos. Por exemplo, digamos que você defina como chave 
primária 2 campos. Um referente ao campo Codigo e outro ao campo Nome. Poderíamos 
até ter 2 códigos iguais e 2 nomes iguais, mas uma combinação de nome e código igual não 
poderia existir. A chave primária nesse caso, seria um índice que definimos com a 
propriedade Primary e definimos que o mesmo teria como base o campo Nome e o campo 
Código.
 Devo admitir que na teoria isso parece um pouco confuso, mas na prática fica bem mais 
simples.
 Uma tabela pode ter apenas uma chave primária(também chamada de índice primário), 
mas pode ter vários índices. Se você tentar atribuir mais de um índice como Primary, irá 
receber uma mensagem de erro dizendo que o índice não pode ser criado.
86
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Como a tabela que criamos é bem mais simples e o índice que criamos(Nome), já dá 
conta de não permitir valores nulos e repetidos, uma chave primária é no 
momento,desnecessária.
Acessando o banco de dados através do Visual Basic
 O Visual Basic oferece objetos que nos permitem interagir de forma completa com o 
Banco de Dados. Podemos alterar a estrutura das tabelas, criar tabelas, campos, índices, 
inserir registros, alterar registros, excluir registros, etc...
 No nosso curso veremos como interagir com as tabelas que criamos no Visual Data 
Manager.
 Primeiramente, crie um novo projeto. Agora, você deve chamar uma biblioteca que 
disponha de objetos para manipulação de banco de dados. Temos várias. No nosso curso 
iremos usar o Microsoft DAO 3.6 Object Library.
Marque essa biblioteca e selecione OK.
 Agora já podemos usar os objetos que essa biblioteca nos oferece.
Abrindo um banco de dados
 Vamos agora, realizar algumas operações envolvendo bancos de dados. Primeiro crie 
uma pasta de trabalho no diretório c:\ com o nome de Trabalho. Depois crie um banco de 
dados com o nome DbCurso dentro dessa mesma pasta.
 Crie uma tabela nesse banco de dados chamada clientes com os seguintes campos e 
atributos:
Campo Tipo Tamanho
Codigo Long(Autoincrementável)
Nome Text 40
Cpf Text 15
Rg Text 11
DataNascimento DateTime
DataCadastro DateTime
Endereco Text 30
Bairro Text 3
Casado Boolean
 Alguns campos aparecem sem seus respectivos tamanhos por quê não são necessários 
devido ao tipo do campo selecionado.
 Adicione um índice para o nome chamado IndNome, outro para o Código chamado 
IndCodigo e uma chave primária com base no campo Nome e no campo Código e se 
chamará Chave.
 Através do Microsoft Access ou do Visual Data Manager, acrescente 5 registros a essa 
tabela e grave-a.
 Agora que já temos um banco de dados com uma tabela, vamos aprender como abrimos 
o banco de dados e lemos os dados da tabela.
87
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 O primeiro objeto de banco de dados que vamos conhecer é objeto Database. Um 
objeto Database contém propriedades, funções e métodos relativos á banco de dados. Para 
abrir um banco de dados usando o objeto Database, devemos usar a função 
OpenDatabase. Essa função só é disponível quando a biblioteca do Microsoft DAO foi 
selecionada.
 Primeiramente, devemos declarar um objeto Database. Vamos declarar uma variável 
chamada Banco como sendo um objeto Database:
Dim Banco as Database
 Depois, iremos instanciar o objeto Banco que criamos apontando para a função 
OpenDatabase que abrirá o banco de dados que desejarmos. A função OpenDatabase tem 
a seguinte sintaxe:
 
OpenDatabase(<Caminho e nome do banco de 
dados>,<Opções>,<TipoDeAcesso>,<Conexão>)
<Caminho e nome do banco de dados>- Uma string que representao caminho completo, 
incluindo o nome do banco de dados.
<Opções>(Opcional)- Determina se o banco de dados será aberto em modo exclusivo ou 
não. True para exclusivo e False para modo compartilhado. Este recurso é útil quando 
iremos criar um sistema que será usado em rede(Multiusuário). Se este argumento for 
omitido o padrão será False.
<TipoDeAcesso>(Opcional)- O tipo de acesso deve informar se o banco de dados será 
aberto como somente leitura(True) ou para leitura/gravação(False) . 
<Conexão>(Opcional)- Uma string que determina várias opções de configuração, 
incluindo senhas.
 A pergunta que talvez esteja na sua cabeça é “Onde devo declarar um objeto Database?”.
Bem, na verdade um objeto Database, assim como as variáveis no Visual Basic, podem ser 
declaradas em qualquer lugar. No entanto, se declararmos o objeto Database em um 
subprocedimento, ele será restrito somente ao subprocedimento em que foi declarado. O 
ideal é sempre usarmos declará-lo na seção General-Declarations do formulário ou 
módulo que formos usá-lo. Se usarmos em um módulo, esteve objeto será visível em todos 
os outros módulos e formulários. No nosso exemplo, usaremos na seção General-
Declarations do formulário onde ele será usado.
 Vamos voltar a declaração do objeto Database que começamos. 
 
Declaramos um objeto Database chamado Banco na seção General-Declarations do 
nosso formulário.
 Agora, para usarmos esse objeto, temos de instanciá-lo apontando para a função 
OpenDatabase, como vimos anteriormente. O local ideal para fazer essa instanciação é no 
evento Load do formulário. Teremos assim desta forma, o objeto instanciado durante todo 
o tempo que o código estiver sendo executado no formulário. 
88
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 A sintaxe da função OpenDataBase já vimos anteriormente. Veremos agora como 
ficaria se usássemos o banco de dados que criamos na nossa pasta de trabalho.
 Usamos apenas o primeiro argumento que representa o caminho e o nome do banco de 
dados. Como você pode ver, os banco de dados do tipo Access terminam com a extensão 
“.mdb”, sendo portanto, necessário que especifiquemos o nome completo do banco de 
dados. Os outros argumentos são opcionais. 
 Agora que já temos o objeto Database instanciado, podemos usar os seus recursos a 
qualquer momento.
 O primeiro recurso do objeto Database que iremos conhecer é o método 
OpenRecordset. Este método serve para abrirmos um RecordSet. Claro que antes de usá-
lo você precisa saber o que é um RecordSet e para o que serve.
 
O que é um Recordset?
 Recordset é um objeto que representa uma tabela. Assim como o objeto Database 
representa o banco de dados, o objeto Recordset representa uma tabela. Com ele, podemos 
efetuar todas as operações em tabelas que fazíamos via Access ou Visual Data Manager. 
 Agora que já sabemos pra que serve um Recordset vamos aprender a declará-lo e 
instanciá-lo. Primeiro, vá na seção General-Declarations, onde já declaramos um objeto 
Database, e declare lá também um objeto Recordset com o nome de Tabela.
 Depois de declarar o objeto Recordset, será necessário instanciá-lo. É aí que entra o 
método OpenRecordset do objeto Database. Veremos agora a sintaxe do método 
OpenRecordset:
OpenRecordset(<NomeDaTabela>,<Tipo>,<Opções>,<SomenteLeitura>)
<NomeDaTabela>- Uma string contendo o nome da tabela que desejamos abrir.Na 
verdade, esse argumento não precisa ser necessariamente um nome de tabela. Pode também 
ser uma consulta ou uma instrução SQL. No nosso curso usaremos somente atribuí-lo com 
o nome da tabela.
<Tipo>- Ao abrirmos um objeto recordset, poderemos escolher entre vários tipos de 
aberturas diferentes. Esse argumento pode ser um número ou uma constante interna que 
determina o tipo de abertura. Veremos agora os tipos mais usados:
DbOpenTable – Ao usar a contante DbOpenTable, estamos abrindo um objeto 
RecordSet do tipo Table como se ele fosse uma tabela normal. Podemos consultar 
registros, adicionar registros, excluir registros, atualizar registros e todas as operações que 
podemos fazer via Access ou Visual Data Manager.
 
DbOpenSnapShot – Esta outra contante nos permite abrir um objeto recordset como sendo 
do tipo SnapShot. Um recordset do tipo SnapShot pode ser visto como uma cópia virtual 
dos dados. Ou seja, é uma cópia da tabela no exato momento em que for criado o objeto 
recordset tipo SnapShot. Não podem ser atulizados. Seu uso se restringe a consultas.
89
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
DbOpenDynaset – Essa constante cria um objeto RecordSet tipo Dynaset. Um Dynaset é 
muito semelhante a um SnapShot. A diferença é que os Dynaset podem ser atualizados.
Devo lembrar que cada um desses tipos de RecordSet contem várias particularidades não 
mencionadas aqui, sendo estas que citei, portanto, as mais importantes.
 Voltando a abertura do nosso banco de dados, usaremos um objeto recordset do tipo 
Table, pelo fato desse tipo de recordset ter as mesmas características de uma tabela. Dessa 
forma, poderemos efetuar todas as operações que 
precisamos(Inclusão,Alteração,Consulta,Exclusão). 
 Já que temos o objeto Database instanciado e o objeto RecordSet declarado, vamos 
agora instanciar o objeto RecordSet, apontando para o método OpenRecordset do objeto 
Database. Ficaria assim:
 Instanciamos o objeto tipo Recordset apontando para o método OpenRecordset do 
objeto DataBase. Como usamos no argumento <Tipo> do método OpenRecordset ,a 
contante DbOpenTable, o objeto tipo RecordSet aberto, será do tipo Table. Ou seja, se 
comportará como se fosse uma tabela normal.
 Pronto! Agora a variável Tabela tem todas as características de um objeto recordset do 
tipo Table e têm também todos os registros existentes na tabela Clientes.
Consultando Registros
 Desde que já tenhamos um objeto Recordset aberto, poderemos facilmente consultar 
seus registros. Há dois tipos de sintaxes que podemos utilizar para retornar valores de 
registros:
<RecordSet>(<StringNomeCampo>) 
ou
<RecordSet>!<NomeCampo>
Exemplo:
TxtNome.Text = Tabela(“Nome”)
Ou
TxtNome.Text = Tabela!Nome
 No projeto que criamos, adicione um TextBox chamado TxtNome e utilize o exemplo 
anterior para preencher o TextBox com o valor do campo Nome. Você pode adicionar mais 
TextBoxs ao formulário e fazer com que os demais campos sejam exibidos. Rode o 
programa.
90
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Você deve ter notado que os dados exibidos no formulário são referentes ao primeiro 
registro. Isso por quê quando abrimos um recordset, ele aponta primeiramente para o 
primeiro registro. Como se tivéssemos aberto uma tabela no Access ou no Visual Data 
Manager. É como se existisse um ponteiro virtual que sempre está apontando para um 
registro X. 
 Na prática, consultar apenas o primeiro registro não nos adiantaria. È ai que entram os 
métodos de navegação que veremos agora.
Navegação através dos registros
MoveNext –Este método moverá o ponteiro para o próximo registro.
MovePrevious – Move o ponteiro para o registro anterior
MoveFirst – Move o ponteiro para o primeiro registro.
MoveLast – Move o ponteiro para o último registro.
Move – Move o ponteiro N registros á frente. 
Exemplo:
Tabela.Move 3
Moverá o ponteiro 3 registros á frente.
Exemplos:
Tabela.MoveNext
Tabela.MoveLast
Tabela.MovePrevious
Métodos de procura
 Um Recordset oferece alguns métodos para realizarmos operações de busca através das 
tabelas. Veremosagora os métodos de busca e as suas particularidades.
FindFirst- É o método de procura mais usado. Ele procura um registro com base em uma 
condição, a partir do primeiro registro. Sua sintaxe é a seguinte:
Recordset.FindFirst(StringComCondição)
O argumento StringComCondição representa uma string, onde deverá ser informada a 
condição. Por exemplo, se você desejar procurar um registro que contenha um campo 
Nome igual á “João”, então irá usar uma string assim:”Nome = ‘Joao’”. Vejamos como 
ficaria usando o método FindFirst:
91
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Tabela.FindFirst(“Nome = ‘Joao’”)
Note que quando procuramos um campo do tipo Texto(Text), o texto a procurar deve ser 
delimitados por aspas simples ‘’. Caso for um campo do tipo numérico(Integer,Long, etc...) 
as aspas não são necessárias:
Tabela.FindFirst(“Código = 3”)
FindNext – O método FindNext funciona de forma semelhante ao FindFisrt. A diferença é 
que enquanto o método FindFirst procura um registro a partir do primeiro, o FindNext 
procura a partir do registro corrente, sendo os anteriores ignorados. A sintaxe usada é a 
mesma nos dois métodos.
FindPrevious – A partir da atual posição do ponteiro no recordset, localiza o registro 
anterior que satisfaça o critério. Segue a mesma sintaxe dos métodos anteriores.
FindLast – A partir do primeiro registro, procura pelo último registro que satisfaça o 
critério estabelecido, no caso de termos mais de um registro encontrado. Segue a mesma 
sintaxe dos métodos anteriores.
O método Seek
 O método Seek oferece um meio de pesquisa mais rápido quando procuramos um 
registro com um campo indexado. O método Seek só pode ser usado em um RecordSet do 
tipo Table e é necessário que especifiquemos um índice corrente antes de fazermos a 
pesquisa. Para especificar um índice corrente, usamos a propriedade Index do RecordSet. 
Digamos que vamos usar o Recordset que já criamos q que se chama Tabela. Como você 
lembra, quando criamos a tabela “Clientes” adicionamos um índice chamado Nome e é 
este índice que iremos usar.
Tabela.Index =”Nome”
 Feito isso, já poderemos usar o método Seek que tem a seguinte sintaxe:
<RecordSet>.Seek <Método de Comparação>,<Chave1>,<Chave2>,<Chave3>,Etc...
<Método de Comparação> - Uma string que determina os métodos de comparação pra 
quando buscarmos pelo registro especificado em qualquer uma das <Chaves>. Os métodos 
de comparação são representados pelos operadores <, <=, =, >= ou >.
<Chave1>,<Chave2>,<Chave3>,Etc... – Um ou mais valores que representam os campos 
existentes no índice definido atrabés da propriedade Index. Podemos colocar até 13 chaves.
Exemplo:
Tabela.Index =”Nome”
Tabela.Seek “=”, “João”
92
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Após utilizarmos um método de procura, seja ele Seek ou qualquer um dos que vimos 
anteriormente, o ponteiro de moverá para o registro que satisfaça as condições 
estabelecidas nas opções de critério. Caso o registro não seja encontrado, o ponteiro 
continuará no registro atual.
 Quando uma operação de procura não obter sucesso, a propriedade NoMatch do objeto 
Recordset passar a ter o valor True. Essa propriedade é útil para sabermos se o registro 
que procuramos foi encontrado.
Exemplo:
Dim Banco as Database
Dim Tabela as Recordset
Set Banco = Opendatabase(“C:\Trabalho\Dbcurso.mdb”)
Set Tabela = Banco.OpenRecordset(“Clientes”,Dbopentable)
Tabela.FindFirst(“Nome = ‘Maria’”)
If Tabela.Nomatch = True Then
 MsgBox “Nome não foi encontrado”
Else
 MsgBox “Nome foi encontrado”
Endif
Adidionando Registros
 Para adicionarmos registros usamos o método AddNew de um objeto RecordSet. 
<Recordset>.AddNew
 Depois de usarmos AddNew, devemos atribuir os valores aos campos do Recordset:
<RecordSet>(<Campo>) = <Valor a ser atribuído ao campo>
 Feito isso, ainda precisamos usar o método Update do objeto Recordset para finalizar a 
adição do novo registro. Este método trabalha em conjunto com o método AddNew. 
Lembre-se de sempre usá-lo quando a adição do registro estiver OK.
<Recordset>.Update
 Vamos ao exemplo prático para ilustrar esse processo, partindo do RecordSet que 
criamos chamado Tabela
 Tabela.AddNew
 Tabela(“Nome”) = “Vanessa Martins Vargas”
93
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Tabela(“Endereço”) = “João Borges Fortes, 2000”
 Tabela(“DataNasc”) = # 15/09/1980 #
 Tabela.Update
 Na pratica, estes valores provavelmente viriam de TextBoxs. Mas no exemplo acima 
adicionamos os valores diretamente aos campos da tabela para ilustrar o processo. Note que 
ao nos referirmos aos campos da tabela usamos, por exemplo Tabela(“Nome”), mas 
também poderíamos usar Tabela!Nome. Cabe ao aluno avaliar qual é a sintaxe mais 
intuitiva.
Atualizando Registros
 A atualização de registros é bem semelhante á adição. A diferença é que no lugar de 
usarmos o método AddNew, usamos o método Edit. Retomando o exemplo anterior, 
digamos que foi gravado o endereço do cliente errado. Usaríamos o seguinte código para 
consertar isso:
 Tabela.MoveLast ‘ Move o ponteiro para o último registro
 Tabela.Edit ‘ Abre a edição do registro
 Tabela(“Endereço”)=”José Joaquim Da Mota,211” ‘Atribui o novo endereço
 Tabela.Update ‘Grava o novo endereço
 
Excluindo registros
 Esta é a mais simples das operações envolvendo manipulação de registros. Para excluir 
um registro, aponte para o registro que deseja excluir e use o método Delete do objeto 
RecordSet. Exemplo:
 Tabela.MoveLast
 Tabela.Delete
Fechando um RecordSet e um Database
 É muito importante se atentar para o fato de precisar fechar a conexão dos objetos com a 
tabela e o banco de dados quando não estivermos mais usando os dados provenientes deles. 
Pois isto evitará que o banco de dados possa estar corrompindo futuramente. Para fechar 
um Database, objeto que representa o banco de dados, devemos primeiramente fechar os 
RecordSets baseados nesse Database. Se tentarmos fechar o Database primeiro sem 
termos fechado o(s) Recordsets bseados nele, teremos um erro em tempo de execução. 
Para fechar um RecordSet ou um DataBase, usamos o método Close.
Tabela.Close
Banco.Close
94
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 O exemplo acima fecha primeiramente o RecordSet chamado Tabela e depois o 
Database chamado Banco. 
 
Conhecendo algumas propriedades úteis
 Vamos conhecer agora algumas propriedades úteis do objeto RecordSet :
 
AbsolutePosition : Indica o numero do registro corrente da tabela em uso. Não podemos 
consultar essa propriedade em um objeto Recordset do tipo Table. Somente SnapShot ou 
Dynaset.
BOF : Retorna True quando foi feita uma tentativa de ir para um registro anterior ao 
primeiro. Quando isto aontecer, om ponteiro não apontará para nenhum registro, tendo o 
programador ter que fazer com que ele aponte para um registro novamente.
DateCreated : Retorna a data de criação da tabela manipulada pelo Recordset.
EOF : Retorna True quando for feita uma tentativa de ir para um registro superior ao 
último. 
Index : Especificamos o nome do índice que será associado a tabela.
NoMatch : Retorna True se uma pesquisa efetuada dentro da tabela foi bem-sucedida. 
PercentPosition : Retorna um percentual referente a posição que a tabela se encontra com 
comparação com o total de registros da tabela.
RecordCount : Retorna a quantidade de registrosque uma tabela possui.
 Com base nos métodos, propriedades e funções aprendidas, crie um cadastro com base na 
tabela Clientes que criamos no banco de dados DbCurso. O cadastro deverá ter botões de 
adicionar registros, um botão para ir para o próximo registro, anterior, primeiro e último. 
Deverá ter também um botão de excluir registros e um para alterar.
Conhecendo alguns objetos de banco de dados
 Iremos conhecer agora alguns objetos que facilitam a nossa vida, quando precisamos 
manipular dados de um banco de dados. O primeiro dos objetos que conheceremos é um 
controle:
 Data – Este objeto automatiza tarefas como a do nosso exemplo anterior, economizando 
código. Vejamos como usá-lo. 
 Crie um formulário e seleciona na caixa de ferramentas um objeto Data. Nomei-o como 
Data. Agora insira 5 Labels e 5 Textboxs nesse formulário, como se fosse fazer um 
95
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
cadastro para a nossa tebela de clientes, como no exemplo anterior. Deixe o formulário 
semelhante ao formulário da figura abaixo:
Não é nexessário nomear os TextBoxs. Vamos agora configurar o objeto Data. Sem mais 
rodeios, vamos diretamente á propriedade que nos interessa e ela é a DatabaseName. Nela 
escolheremos o banco de dados que tém a tabela que iremos usar. 
Clicando no botão ao lado <...>, uma janela se abrirá para que possamos procurar pelo 
banco de dados.
Depois de selecionado o banco de dados, já podemos selecionar uma tabela, através da 
propriedade RecordSource do objeto Data.
Note também que na propriedade RecordsetType, podemos escolher entre os 3 tipos de 
recordsets que vimos anteriormente.
 Bem, agora vamos conhecer o que o objeto Data tem a nos oferece. Primeiramente, 
configure a opção DataSource dos TextBoxs. Note que quando adicionamos um objeto 
Data ao formulário, o mesmo irá aparecer na lista da propriedade RecordSource das 
TextBoxs existentes no formulário.
 Selecione este objeto para todas as TextBoxs. Agora que já selecionamos o objeto Data 
para a propriedade RecordSource de todos os TextBoxs, configure a propriedade DataField 
das mesmas, uma por vez.
 Note que se tudo estiver configurado de forma adequada, você pode escolher os campos 
em uma lista na propriedade DataField de cada TextBox.
 
Selecione um a um, os respectivos campos para cada TextBox. Depois disso feito, rode o 
projeto.
 Você vai ver que podemos navegar através dos registros. Como você notou, a economia 
de código foi de 100 %.
 Tudo o que for digitado ou trocado nas TextBoxs vai ser alterado diretamente no banco 
de dados, sem necessidade nenhuma de usar métodos Edit ou Update.
 Devo dizer que é um excelente recurso para consultar dados. Na prática, naum se usa 
muito esse tipo de controle. Pois na maioria dos aplicativos, temos que fazer validação do 
que o usuário digita nas caixas de texto, limitar algumas delas, validar dados, etc. Além 
disso, funções como excluir registros, adicionar registros, devem ser feitas manualmente.
 
O Controle DataGrid(DbGrid)
96
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 O controle DbGrid oferece um sofisticado meio de consultarmos dados. Para usar o 
DbGrid, você deve marcá-lo na caixa de componentes. Há mais de um tipo de DataGrid, no 
entanto o que vamos estudar é o “Microsoft Data Bound Grid Control 5.0(SP3)”.
Depois de feito isso e o controle já estar visível na caixa de ferramentas, clique nele e o 
arraste-o para o mesmo formulário onde criamos o nosso cadastro de clientes.
Vá na propriedade DataSource da DataGrid. Você verá que aparecerá o nosso objeto Data 
na lista. Selecione-o. De fato, para usarmos o objeto DataGrid, temos que ter um objeto 
Data já configurado, no mesmo formulário. 
 Feito isso, já preenchemos o DataGrid com os dados existentes no objeto Data. Rode o 
projeto e confira o resultado.
 Note que ao mudarmos de registro no DataGrid, o registro também troca no objeto Data 
e vice-versa.
 O Datagrid funciona de forma bem semelehante ao objeto Data. Quando alteramos um 
campo via DataGrid, estamos alterando diretamente no banco de dados, sem necessidade de 
algum comando adicional. No entanto existem propriedades que nos permitem bloquear 
esse tipo de alteração direta. Vejamos algumas propriedades do DataGrid:
AllowAddNew: Habilita a possibilidade de se poder acrescentar registros na tabela. 
Quando esta propriedade está habilitada. O DataGrid oferece um registro em branco no 
final para que possamos inserir um novo registro.
AllowDelete : Habilita a possibilidade de apagar registros. Quando habilitamos essa 
propriedade, podemos excluir registros selecionando toda uma linha e pressionando a tecla 
<Del>.
AllowUpdate : Habilita a possibilidade de alterar os registros existentes diretamente.
ColumnHeaders : Determina se o cabeçalho de cada coluna será exibido.
RecordSelectors : Determina se no DBGrid irá aparecer um seletor de registros
AllowRowSizing : Habilita a possibilidade do usuário mudar o tamanho das colunas.
Enabled : Habilita ou não a interação do DBGrid com o usuário.
Columns : Seleciona em qual coluna de dados do DBGrid que terá as propriedades abaixo 
disponível para serem configuradas.
Caption : Título da Coluna selecionada.
DataField : Campo da tabela que terá seus dados exibidos na coluna selecionada.
DefaultValue : Valor padrão para um determinado campo.
NumberFormat : Determina o formato com que os dados da coluna serão mostrados no 
vídeo. Usa as mesmas regras da função FORMAT.
Locked : Trava os dados contido nas colunas.
AllowSizing : Habilitada a possibilidade de mudar o tamanho da coluna
Visible : Indica se a coluna será visível ou não.
Alignment : Alinha dos dados na coluna na forma determinada nesta propriedade.
97
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Impressão
 Atualmente existem várias ferramentas para facilitar a impressão de relatórios. 
Estudaremos 2 delas:
 O objeto Printer, que é um objeto nativo do Visual Basic, e a ferramenta Crystal 
Reports, que é um programa separado, mas que gera relatórios que podem ser acessados 
através do Visual Basic. A versão do Crystal Reports que estudaremos é o “Crystal 
Reports Report Design Component”, que permite projetarmos relatórios dentro do nosso 
próprio projeto do Visual Basic.
O objeto Printer
 O objeto Printer nos permite obter um total controle sobre as tarefas de impressão. Tem 
propriedades que nos possibilitam alterar a fonte do que será impresso, alterar a impressora 
padrão, alternar para fonte em negrito, etc. Tem métodos que nos possibilitam saltar para a 
próxima página, terminar a impressão, imprimir na linha x, coluna x,etc. Veremos agora as 
principais propriedades do Printer:
ColorMode: Determina ou mostra a capacidade de impressão colorida do dispositivo.
Copies: Especifica a quantidade de cópias de uma página que deve ser impressa.
CurrentX: Determina a coordenada horizontal que a impressora irá imprimir.
CurrentY: Determina a coordenada vertical que a impressora irá imprimir.
DeviceName: Mostra o nome da impressora padrão suportada pelo dispositivo
FontName: Determina qual fonte de letra a impressora usará para impressão.
FontBold: Determina se a fonte será em negrito.
FontItalic: Determina se a fonte será em itálico.
Fonts: Fornece uma lista de todas as fontes disponíveis para impressão.
FontSize: Determina o tamanho que a fonte de letra escolhida usará.
FontUnderline: Determina se a fonte será sublinhada.
Orientation: Determina a orientação do papel: Retrato ou Paisagem. Usamos as constantes 
para definir o tipo escolhido:vbPRORPortrait 1 Retrato
vbPRORLandscape 2 Paisagem
Page : Retorna o número da página que esta sendo impressa.
PaperSize: Determinamos o tamanho do papel. Podemos usamos as seguintes constantes:
vbPRPSLetter 1 Letter, 8 1/2 x 11 in. 
VbPRPSLetterSmall 2 Letter Small, 8 1/2 x 11 in. 
VbPRPSTabloid 3 Tabloid, 11 x 17 in. 
VbPRPSLedger 4 Ledger, 17 x 11 in. 
VbPRPSLegal 5 Legal, 8 1/2 x 14 in. 
VbPRPSStatement 6 Statement, 5 1/2 x 8 1/2 in. 
VbPRPSExecutive 7 Executive, 7 1/2 x 10 1/2 in. 
vbPRPSA3 8 A3, 297 x 420 mm 
vbPRPSA4 9 A4, 210 x 297 mm 
vbPRPSA4Small 10 A4 Small, 210 x 297 mm 
vbPRPSA5 11 A5, 148 x 210 mm 
98
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
vbPRPSB4 12 B4, 250 x 354 mm 
vbPRPSB5 13 B5, 182 x 257 mm 
vbPRPSFolio 14 Folio, 8 1/2 x 13 in. 
VbPRPSQuarto 15 Quarto, 215 x 275 mm 
vbPRPS10x14 16 10 x 14 in. 
vbPRPS11x17 17 11 x 17 in. 
VbPRPSNote 18 Note, 8 1/2 x 11 in. 
vbPRPSEnv9 19 Envelope #9, 3 7/8 x 8 7/8 in. 
vbPRPSEnv10 20 Envelope #10, 4 1/8 x 9 1/2 in. 
vbPRPSEnv11 21 Envelope #11, 4 1/2 x 10 3/8 in. 
vbPRPSEnv12 22 Envelope #12, 4 1/2 x 11 in. 
vbPRPSEnv14 23 Envelope #14, 5 x 11 1/2 in. 
VbPRPSCSheet 24 C size sheet 
vbPRPSDSheet 25 D size sheet 
vbPRPSESheet 26 E size sheet 
vbPRPSEnvDL 27 Envelope DL, 110 x 220 mm 
vbPRPSEnvC3 29 Envelope C3, 324 x 458 mm 
vbPRPSEnvC4 30 Envelope C4, 229 x 324 mm 
vbPRPSEnvC5 28 Envelope C5, 162 x 229 mm 
vbPRPSEnvC6 31 Envelope C6, 114 x 162 mm 
vbPRPSEnvC65 32 Envelope C65, 114 x 229 mm 
vbPRPSEnvB4 33 Envelope B4, 250 x 353 mm 
vbPRPSEnvB5 34 Envelope B5, 176 x 250 mm 
vbPRPSEnvB6 35 Envelope B6, 176 x 125 mm 
vbPRPSEnvItaly 36 Envelope, 110 x 230 mm 
vbPRPSEnvMonarch 37 Envelope Monarch, 3 7/8 x 7 1/2 in. 
vbPRPSEnvPersonal 38 Envelope, 3 5/8 x 6 1/2 in. 
vbPRPSFanfoldUS 39 U.S. Standard Fanfold, 14 7/8 x 11 in. 
vbPRPSFanfoldStdGerman 40 German Standard Fanfold, 8 1/2 x 12 in. 
vbPRPSFanfoldLglGerman 41 German Legal Fanfold, 8 1/2 x 13 in. 
vbPRPSUser 256 User-defined
Port: Retorna o nome da porta de impressão que será usada pela impressora padrão.
PrintQuality: Determina ou seta a resolução que a impressora irá usar.
VbPRPQDraft -1 Resolução Draft
vbPRPQLow -2 Baixa Resolução
vbPRPQMedium -3 Média Resolução
vbPRPQHigh -4 Alta Resolução
 Vejamos agora, os principais métodos:
EndDoc: Finaliza a impressão de um relatório
99
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
KillDoc: Termina imediatamente a impressão
Line: Imprime uma linha horizontal, de acordo com as coordenadas especificadas.
NewPage: Força a impressão passar para a próxima página.
Print <expressão> : Imprime uma expressão ou variável especificada.
 Quando usamos o objeto Printer, será de extrema necessidade o uso de uma função 
auxiliar que só pode ser usado com o método Print ou com a instrução Print #. Esta função 
é a função Tab e é usada para posicinar a saída. Imagine que estamos imprimindo alguma 
coisa com o método Print. Queremos imprimir o título do relatório bem no centro da folha. 
Se usássemos o método Print assim:
Printer.Print “Título do Relatório”
 O título sairia no início da folha, agora usando a função Tab associada com o método 
Print, podemos definir em qual coluna irá começar a impressão feita pelo método Print.
Printer.Print Tab(35); “Título do Relatório”
 Deverá existir um ; (ponto e vírgula) entre a função Tab e o que queremos imprimir. 
Mas se você não digitar não tem problema, pois o editor do Visual Basic se encarrega de 
corrigir esse erro de sintaxe.
 Vejamos agora, um exemplo de como poderia ser feito um relatório dos clientes na tabela 
que criamos.
 Primeiramente, abre o último projeto que criamos. No formulário que criamos, adicione 
um botão de Imprimir e nomei-o como “CmdImprimir”. 
No evento Load do botão, adicione o seguinte código:
 
 Dim Banco As Database
 Dim Tabela As Recordset
 Dim Linha As Integer
 
 Set Banco = OpenDatabase("C:\trabalho\dbcurso.mdb")
 Set Tabela = Banco.OpenRecordset("Clientes", dbOpenTable)
 
 Linha = 1
 
 Do While Not Tabela.EOF
 If Linha = 1 Then
 Cabecalho
 End If
 Linha = Linha + 1
 Printer.Print Tab(5); Tabela!codigo;
 Printer.Print Tab(15); Tabela!nome;
 Printer.Print Tab(45); Tabela!endereco;
 Printer.Print Tab(65); Tabela!datanasc;
 Printer.Print Tab(93); Tabela!rg;
 Printer.Print
100
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 If Linha = 50 Then
 Printer.NewPage
 Linha = 1
 End If
 Tabela.MoveNext
 Loop
 
 Printer.EndDoc
 Agora, crie um subprocedimento denominado Cabeçalho, que terá a funçãop de 
imprimir o cabeçalho do relatório toda vez que uma nova página começar a ser impressa. 
Neste subprocedimento, insira o seguinte código:
 Printer.Font = "Arial"
 Printer.FontBold = True
 Printer.FontSize = 11
 
 Printer.Print Tab(35); "Relatório de Clientes"
 Printer.Print
 Printer.Print Tab(5); "Código";
 Printer.Print Tab(15); "Nome";
 Printer.Print Tab(40); "Endereço";
 Printer.Print Tab(60); "Data de Nascimento";
 Printer.Print Tab(85); "RG";
 Printer.FontBold = False 
 Bem, vamos começar pelo evento Load do botão CmdImprimir.Primeiramente, 
declaramos as variáveris:
 Dim Banco As Database
 Dim Tabela As Recordset
 Dim Linha As Integer
 Uma para o banco de dados, outra para a tabela, e outra é referente a um contador de 
linhas que criamos para limitarmos o número de linhas impressas por página em 50, 
quando exceder, o programa irá passar para uma nova página.
 Depois disto, instanciamos as variáveis do banco de dados e da tabela:
 Set Banco = OpenDatabase("C:\trabalho\dbcurso.mdb")
 Set Tabela = Banco.OpenRecordset("Clientes", dbOpenTable)
 
 E dizemos que a linha inicial será a 1, atribuindo o valor 1 a variável Linha.
 
 Linha = 1
 Feito isso, iniciará um ciclio, a qual imprimirá um registro da tabela por vez, enquando a 
tabela não chegar no final. Assim que tentarmos nos mover para um registro maior que o 
último, o ciclio é interrompido e a impressão encerrará:
101
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 
 Do While Not Tabela.EOF
 
 Na linha seguinte, verificamos se a variável Linha tem o valor 1, o que quer dizer que 
estamos começando uma nova página, se tiver ela irá chamar o subprocedimento 
Cabeçalho:
 
 If Linha = 1 Then
 Cabecalho
 End If
 
 Vejamos agora o código existente no subprocedimento chamado Cabeçalho.
 
 Printer.Font = "Arial"
 Printer.FontBold = True
 Printer.FontSize = 11
 
 Printer.Print Tab(35); "Relatório de Clientes"
 Printer.Print
 Printer.Print Tab(5); "Código";
 Printer.Print Tab(15); "Nome";
 Printer.Print Tab(40); "Endereço";
 Printer.Print Tab(60); "Data de Nascimento";
 Printer.Print Tab(85); "RG";
 Printer.FontBold = False 
 
 As 3 primeiras linhas se referem ao tipo, estilo e tamanho da fonte, Font, FontBold e 
FontSize; que se referem nessa ordem á Nome da Fonte, Fonte em negrito e tamanho da 
fonte. Sendo assim, escolhemos para o cabeçalho a fonte “Arial”, que será em negrito, já 
que estamos escolhendo a propriedade FontBold como True. O tamanho da fonte será 
igual a 11, já que definimos a propriedade FontSize com 11.
 As próximas linhas se referem a impressão do cabeçalho em si, onde usamos a funçãoauxiliar Tab para posicionar a impressão na coluna desejada.
 Uma observação que tenho que fazer aqui é quanto á linha que tem um Print.Print sem 
nada á imprimir. Isto seria um modo de deixar uma linha em branco após o título do 
relatório. Outra é o ;(Ponto e Vírgula) no final de todas as linhas de impressão. Colocando 
esse ; (Ponto e Vírgula) fazemos com que a impressão continue na mesma linha. Ou seja, 
a próxima instrução Print que usarmos após o ; (Ponto e Vírgula) será impressa na mesma 
linha. A impressão só passará para a linha seguinte, quando usarmos o método Print sem 
o ; (Ponto e Vírgula).
 Terminamos o subprocedimento do cabeçalho, fazendo com que a fonte passe do negrito 
para o normal, já que terminamos a impressão do relatório e precisamos que os registros 
não sejam impressos em negrito:
 Printer.FontBold = False 
 Retornando so evento Load do botão CmdImprimir, temos o restante do código:
102
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Linha = Linha + 1
 Printer.Print Tab(5); Tabela!codigo;
 Printer.Print Tab(15); Tabela!nome;
 Printer.Print Tab(45); Tabela!endereco;
 Printer.Print Tab(65); Tabela!datanasc;
 Printer.Print Tab(93); Tabela!rg;
 Printer.Print
 If Linha = 50 Then
 Printer.NewPage
 Linha = 1
 End If
 Tabela.MoveNext
 Incrementamos a variável Linha em 1, já que á cada ciclo será impressa uma linha:
 Linha = Linha + 1
 As próximas linhas se referm á impressão da linha(registro) em si:
 Printer.Print Tab(5); Tabela!codigo;
 Printer.Print Tab(15); Tabela!nome;
 Printer.Print Tab(45); Tabela!endereco;
 Printer.Print Tab(65); Tabela!datanasc;
 Printer.Print Tab(93); Tabela!rg;
 Printer.Print
 Depois delas, temos a seguinte verificação:
 If Linha = 50 Then
 Printer.NewPage
 Linha = 1
 End If
 Se a linha for igual á 50, então usamos o método NewPage para passarmos para uma 
nova página, e conseqüentemente, deveremos atribuir o Valor 1 a variável Linha. Pois 
começaremos novamente a contar as linhas a partir de 1.
 Depois de impresso o registro, passaremos para o próximo registro na tabela:
 Tabela.MoveNext
 O próximo comando é o Loop e encerra o ciclo Do While:
 Loop
 
 Após encerrado o ciclo, e todos os registros serem impressos, precisamos dizer a 
impressora que a impressão encerrou. Para isso, usamos o método EndDoc. 
 Printer.EndDoc
103
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 É necessário usar esse método para encerrar a impressão, pois se não usássemos o 
programa ficaria se comunicando com o Spool da impressora e os dados só seriam 
impressos quando o programa fosse encerrado.
Criando relatórios com o Crystal Reports
 A ferramenta Crystal Reports, da Seagate, é sem dúvida a ferramenta preferida pelos 
desenvolvedores da atualidade para desenvolver relatórios. Isso por quê ele automatiza 
várias tarefas que o programador teria de fazer manualmente, caso fosse usar o Printer. 
Você pode selecionar um banco de dados de forma interativa e escolher quais campos 
devem aparecer no relatório, que ele monta automaticamente o relatório pra você. 
 Possui ainda um assistente que faz todo o trabalho “pesado” pra você. Você terá apenas 
que arrumar alguns detalhes, se necessário, no relatório.
 
Criando um relatório no Crystal Reports usando o assistente
 
 Existem várias versões do Crystal Reports espalhadas por aí. A versão que iremos usar é 
o “Crystal Reports Report Design Component” . 
 Em outras versões do “Crystal Reports”, ele funciona como um programa separado onde 
criamos os relatórios dentro dele mesmo. Esses relatórios, contituem um arquivo separado, 
que terá de ser chamado pelo Visual Basic. 
 Com o “Crystal Reports Report Design Component” , você cria os relatórios dentro do 
próprio Visual Basic, e não há necessidade nenhuma de ter um arquivo separado para cada 
relatório. Esta é, na minha opinião, a granda vantagem de usar essa versão.
 Bem, deixando de rodeios e indo ao que interessa, o que primeiramente precisamos para 
criar um relatório usando o Crystal é ter ele instalado. Feito isso, ele já irá aparecer nos 
menus do Visual Basic.
 Para não termos problemas com o uso do assistente, devemos adicionar um componente 
ao projeto. Vá no menu Project, selecione Components e marque o controle “Crystal 
Report View Control”. Este controle é requerido pelo assistente quando ele cria o relatório 
e se você não adicioná-lo terá problemas sérios ao encerrar o assistente. Esses “problemas 
sérios” incluem o Visual Basic fechar e você perder tudo o que não foi salvo. Portanto, não 
esqueça de marcar tal componente.
 
 Para adicionarmos um novo relatório usando o Crystal Reports, acessamos o menu 
Project e escolhemos a opção Add Crystal Reports 8.5.
 Abrirá então uma janela perguntando se queremos criar o novo relatório usando o 
assintente, se queremos criar um relatório vazio ou criar um relatório a partie de outro 
existente.
 Além disso, existe uma lista abaixo com vários tipos de relatórios predefinidos para que 
possamos escolher.
 
 
104
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Como vamos criar nosso relatório usando o assistente, marque a primeira opção e clique 
em OK.
 Feito isso, o assistente iniciará o processo:
 Primeiramente, deveremos selecionar um banco de dados, de onde virão os dados do 
relatório. Para fazer isso, clicamos no botão Project. Após clicarmos nesse botão, irá abrir 
uma janela com várias opções para nos conectarmos com diferentes bancos de dados.
 
 Como estamos utilizando conexão com banco de dados via DAO, marque a opção DAO 
e clique no botão Browse para selecionar um banco de dados ou digite o caminho do banco 
de dados na caixa de texto.
Note ainda que existe uma caixa abaixo, onde podemos selecionar para abrir vários tipos de 
banco de dados diferentes. Como o banco de dados que iremos abrir é Access, então não 
precisamos alterar. 
 Estando o nome do banco de dados e o tipo selecionado, podemos clicar no botão OK 
para proseguirmos. Feito isso, abrirá uma janela onde podemos selecionar o objeto do 
banco de dados que desejamos, no nosso caso, a tabela “Clientes”. 
 Atenção: Neste exemplo selecionamos a tabela “Clientes”. No entanto, podemos 
selecionar mais de uma tabela sem problemas. O ato de adicionar mais de uma tabela ao 
relatório não obriga o relatório a ser baseado em todas as tabelas. Mas por sua vez, mantém 
essas tabelas disponíveis para usarmos no relatório.
 Estando esta tabela selecionada, já podemos clicar no botão OK. O assistente retornará 
novamente para a primeira tela.
 Para proseguir, clicamos no botão Next.
 
 O assistente então passará para o guia Fields, onde definimos quais campos aparecerão 
no relatório:
 
105
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Depois de adicionados os campos necessários para o nosso relatório e caso ele seja um 
relatório simples, já podemos finalizar, clicando no botão Finish. Veremos mais tarde ao 
que se destinam os próximos passos do assintente.
 Se você já adicionou os campos que precisa no relatório e não usará nenhum recurso 
especial no seu relatório, deverá clicar no botão Finish.Feito isso, aparecerá a seguinte 
janela:
 
 Depois que você selecionar as opções que você deseja, clique em OK.
 
 Veja que o assistente criou um Relatório(Report) com o nome “CrystalReports1”. 
Nomeio-o como “RptClientes”. Caso já tivéssemos um relatório com o nome de 
“CrystalReports1”, ele nomearia como “CrystalReports2”, e assim sucessivamente.
 Note também que ele criou um formulário como o nome “Form1”. Se já tivéssemos um 
formulário com esse nome, ele criaria um com o nome de “Form2” e assim sucessivamente. 
Nome-o para “FrmRelCli”. Veja que esse formulário funciona como visualização dos 
relatórios. Assim, quando precisarmos imprimir um relatório criado a partir do Crystal, 
basta chamar o formulário que o assistente criou para esse relatório através do método 
Show. O formulário fará toda a parte de imprimir o relatório para nós.
 A janela abaixo mostra uma pré-visualização que foi criada pelo assistente do “Crystal” 
em um formulário. Ela oferece recursos de Zoom, mudança de página, pesquisa e ainda 
oferece recursos para alternarmos entre os grupos, caso estejamos trabalhando com 
relatórios que contenham grupos. 
 Depois de renomear o nome do relatório e o do formulário que o assistente criou, você 
também deve renomear o nome no código do formulário que o assistente criou. Nesse 
código ele faz referência ao relatório que o assistente criou. Como modificamos o nome 
desse relatório, também temos de fazer o mesmo no código. A única linha que teremos de 
alterar é na declaração, onde é declarado um objeto do tipo Report(relatório). Altere o nome 
para o novo nome que você atribuiu ao relatório. 
 Essa é única linha que teremos de alterar nesse código para que ele funcione 
perfeitamente. Essa mudança só é necessária por que alteramos o nome do objeto Report.
 Feito essa modificação, talvez você queira fazer alguns ajustes no Layout do relatório.
 Um relatório é dividido em várias seções. Veremos agora a função de cada uma delas.
 
106
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 A seção Report Header é o cabeçalho do relatório. Não confunda cabeçalho do relatório 
com cabeçalho da página. Pois o cabeçalho da página é impresso sempre antes de uma 
página ser impressa. Já o cabeçalho do relatório será impresso somente uma vez, antes de 
qualquer página ser impressa.
 A seção Page Header é o cabeçalho de página e como já falamos anteriormente é impressa 
sempre que é iniciada uma nova página. Usamos esta seção para colocar os cabeçalhos para 
os campos, além de outras informações.
 A seção Details(detalhe) é a mais importante do relatório. É nela que irão os dados que 
compõem o relatório. Como por exemplo, os campos nome, endereço, etc.
 
 
 A seção Report Footer é o rodapé do relatório. Ou seja, é o que será impresso, no final do 
relatório, após todas as páginas serem impressas.
 A seção Page Footer é o rodapé da pagina. É o que será impresso no fim de cada página. 
Usamos esta seção para imprimir, por exemplo, os números de página. Ao criar um 
relatório pelo assistente, o Crystal automaticamente insere uma função, para retornar o 
número de página nesta seção.
 
 Na caixa de ferramentas a esquerda podemos ver os controles disponíveis para inserir 
nos relatórios criados pelo Crystal
Os controles mais importantes são:
 Text Objext – Um simples objeto de texto que tem a mesma função do objeto Label nos 
formulários.
 Line Object – Serve para traçarmos uma linha reta no relatório.
 Além desses recursos, o Crystal ainda nos oferece recursos de poder inserir campos 
especiais, como hora, data, etc. Vejamos alguns:
Trabalhando com filtros no Crystal Reports
 É comum as vezes o programador se deparar com um relatório em que a aplicação de um 
filtro é necessária. Com o objeto Printer, temos a liberdade de imprimir somente os dados 
que nos interessam. Digamos que você precise imprimir um relatório com nomes, em que 
107
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
a impressão do registro se baseará em um nome que será digitado em um TextBox. Serão 
aceitos nomes que iniciem com a string digitada na Textbox. Por exemplo, se você digitar 
a string “JO” na TextBox, poderão ser impressos no relatório nomes como “JOAO”, 
“JOSÉ”, “JOVANA” e todos outros nomes que comecem com “JO”. Crie um formulário 
com a aparência da figura abaixo:
 Nomeie a TextBox com o nome de “TxtFiltro”, o botão de impressão com o nome de 
“CmdImprimir”. Crie um subprocedimento denominado Cabeçalho e insira o seguinte 
código: 
 Printer.Font = "Arial"
 Printer.FontBold = True
 Printer.FontSize = 11
 
 Printer.Print Tab(35); "Relatório de Clientes"
 Printer.Print
 Printer.Print Tab(5); "Código";
 Printer.Print Tab(15); "Nome";
 Printer.Print Tab(40); "Endereço";
 Printer.Print Tab(60); "Data de Nascimento";
 Printer.Print Tab(85); "RG";
 Printer.FontBold = False
No evento Load do botão “CmdImprimir”, insira o seguinte código:
 Dim Banco As Database
 Dim Tabela As Recordset
 Dim Linha As Integer
 
 Set Banco = OpenDatabase("C:\trabalho\dbcurso.mdb")
 Set Tabela = Banco.OpenRecordset("Clientes", dbOpenTable)
 
 Linha = 1
 
 Do While Not Tabela.EOF
 If Mid(Tabela!nome, 1, Len(TxtFiltro.Text)) = TxtFiltro.Text Then
 
 
 If Linha = 1 Then
 cabecalho
 End If
 Linha = Linha + 1
 Printer.Print Tab(5); Tabela!codigo;
 Printer.Print Tab(15); Tabela!nome;
 Printer.Print Tab(45); Tabela!endereco;
108
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Printer.Print Tab(65); Tabela!datanasc;
 Printer.Print Tab(93); Tabela!rg;
 Printer.Print
 If Linha = 50 Then
 Printer.NewPage
 Linha = 1
 End If
 End If
 Tabela.MoveNext
 Loop
 
 Printer.EndDoc
 O código acima oferece um modo para filtrarmos alguma string com base no que for 
digitado na TextBox.. Antes de o registro ser impresso, verificamos se a string inicial do 
campo Nome do registro atual bate com o que foi digitado na Textbox.
If Mid(Tabela!nome, 1, Len(TxtFiltro.Text)) = TxtFiltro.Text Then
 
Através da função Mid, que retorna uma substring de uma string, pegamos uma substring 
inicial do campo Nome, com o tamanho da string que foi digitada em TxtFiltro. Se a 
condição for verdadeira, tudo o que estiver no bloco If será executado e o registro será 
impresso. Caso contrário, o programa passará ao próximo registro através do método 
MoveNext do objeto Recordset “Tabela”. Depois disso, é encontrado o comando Loop e o 
ciclo é reiniciado, passando o próximo registro agora pela verificação. Desta forma, só os 
registros que coincidirem serão impressos. Rode o projeto e veja o resultado.
 Como você pode confirmar, com o objeto Printer podemos controlar registro á registro 
o que está sendo impresso. A questão então é: Como podemos criar relatórios com filtros no 
Cystal? 
 Bem, na verdade existem muitas maneiras de se fazer isso. Algumas delas são até mesmo 
bem complexas. 
 Ao definir uma tabela para um relatório, quando você o cria, seja pelo assistente ou outro 
método, o relatório terá os dados da tabela naquele exato momento. Portanto, modificações 
feitas na tabela após termos definido os dados no relatório, não serão refletidas no relatório.
 Muitas pessoas usam uma tabela temporária (embora muita gente não aconselhe) para 
filtrar somente os dados que se desejaem uma tabela (tabela temporária) e atribuem essa 
tabela ao relatório. Alguns problemas com que você vai se deparar, são:
1º - A tabela deve ser atribuída dinamicamente, ou seja, em tempo de execução.
2º - Uma vez atribuído a tabela ao relatório, ela deverá ser atribuída novamente cada vez 
que o filtro for modificado. Caso contrário, ficará com os dados existentes da primeira vez 
que você atribuiu a tabela ao relatório.
3º - O uso de um relatório com uma tabela temporária pode tornar-se lento em relatórios 
com muitos registros.
 
 O uso de tabelas temporárias não é aconselhado por oferecer um desempenho baixo 
(baixa velocidade) em impressão de relatórios com muitos registros. No entanto, talvez 
você se depare com alguma situação em que você não vê outra saída. Por exemplo. Você 
109
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
quer criar uma planilha sobre o controle de vendas mensal, no Crystal. Uma solução seria 
criar uma tabela exatamente como seria a planilha com os dados que você que e jogar essa 
tabela para o Crystal. Vejamos como poderíamos fazer isso. Primeiramente, crie a tabela 
temporária que você irá usar para imprimir os dados da planilha. Depois, utilize o assistente 
do Crystal para adicionar essa tabela ao relatório. Supondo que você criou uma tabela com 
o nome TabTemp, e criou um relatório com o nome RptPlan, poderiámos usar o seguinte 
código:
Dim Banco as Database
Dim Tabela as RecordSet
Set Banco = OpenDatabase(“C:\Trabalho\Dbcurso.mdb”)
Set Tabela = Banco.OpenRecordset(“TabTemp”,Dbopentable)
<
 Aqui poderiam ser utilizados comandos 
 para efetuar o filtro na tabela. Mas isto 
 é você quem vai avaliar, e através do método 
 Delete do objeto RecordSet, deletar os registros 
 que não devem aparecer no relatório.
 > 
RptPlan.Database.SetDataSource Tabela
RptPlan.PrintOut
 Esse código tem dois métodos do objeto Crystal Report que ainda não conhecemos. Um 
deles é o método SetDataSource do objeto Database, que é membro do objeto Crystal 
Report, ou seja, do relatório que criamos . 
 O objeto SetDataSource tem a função de atribuir uma origem de dados ao Crystal 
Reports. Uma origem de dados pode ser uma tabela ou uma instrução SQL. Podemos, por 
exemplo, criar um objeto RecordSet, instanciá-lo e atribuir ao relatório. Foi o que fizemos 
no exemplo acima. Criamos um objeto Recordset chamado Tabela, instanciamos esse 
objeto com a tabela que queremos usar no relatório. Como essa tabela é temporária, 
efetuamos as possíveis operações de exclusão para deixar na tabela somente os dados que 
nos interessam. Após isso, utilizamos o método SetDataSource, que, como você pode ver, 
oferece uma sintaxe muito simples: 
RptPlan.Database.SetDataSource Tabela 
No nosso caso, Tabela é o objeto RecordSet que representa a tabela “TabTemp”.
110
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Depois disso, entra outro método que ainda não conhecemos, mas que também é muito 
simples. É o método PrintOut do objeto Crystal Report. Este método envia diretamente 
o relatório para a impressora. 
 Uma observação a ser feita e um problema bem comum é a de que quando você *chama 
um relatório , fica armazenado nele o que foi impresso pela primeira vez. Então se você 
voltar a imprimir esse relatório sem decarregá-lo da memória, e aplicar outro filtro, vai ver 
que os dados impressos são iguais ao que você imprimiu na primeira vez. 
 Claro que se você aplicar o filtro, chamar o relatório, imprimir, fechar a aplicação e 
voltar a imprimir o relatório, tudo funcionará perfeitamente. Mas, imagine que você tem 
um formulário com um TextBox de filtro e um botão de impressão. Então você cria uma 
rotina para visualizar a impressão. Provavelmente, você irá dar ao usuário a alternativa de 
digitar um filtro e clicar no botão de impressão para ver o resultado, para depois imprimir. 
Então o usuário poderia testar várias vezes o filtro selecionado que ele quer. O que acontece 
aqui é que assim que ele atribuir uma origem de dados ao relatório pela primeira vez, os 
dados do primeiro filtro que ele atribuir ao relatório, serão sempre os exibidos quando ele 
for acessar o relatório novamente. Para contornar esse problema, devemos sempre 
descarregar o relatório da memória, através do comando Unload, depois que ele foi usado. 
Exemplo:
 Unload RptCli
 Isso descarrega imediatamente o relatório da memória. Atenção: Você deve apenas 
decarregar o relatório da memória, após o termino de seu uso. Se o relatório estiver sendo 
exibido ou um objeto CRViewer, que é o objeto que o assistente cria para podermos 
visualizar os dados antes de imprimir, estiver exibindo dados do relatório e você 
descarregar o relatório da memória, não haverá visualização dos dados. Uma dica: No 
formulário de visualização (aquele que o assistente cria pra você e que possibilita visualizar 
os dados), descarregue o relatório da memória no evento Unload. Exemplo:
Private Sub Form_Unload(Cancel As Integer)
 Unload RptCli
End Sub
*chamar um relatório – O ato de chamar um relatório não está necessariamente ligado ao 
comando Load. Podemos também chamar um relatório através do comando Load, mas o 
que acontece na verdade é que todos os objetos do projeto são automaticamente carregados, 
quando o programa é iniciado. Assim, todo objeto fica na memória para um acesso mais 
rápido quando precisarmos desse objeto. No caso do relatório, temos a necessidade de 
descarregá-lo da memória para que os dados impressos da última vez sejam substituídos 
pelos novos. No entanto, ele é automaticamente carregado quando fizermos qualquer 
referência a ele, usando um método ou propriedade.
 Continuando, veremos como criar um relatório com filtro sem precisar utilizar uma 
tabela temporária. O que se torna mais simples, rápido e organizado. Primeiramente, crie 
um novo projeto e adicione um formulário como o que já criamos anteriormente com a 
aparência semelhante ao da figura abaixo.
 
 Nomeie a TextBox com o nome de “TxtFiltro”, o botão de impressão com o nome de 
“CmdImprimir”. 
111
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Depois, adicione o relatório “RptCli”, já criado anteriormente, ao projeto. Feito isso, 
codifique o evento Load do botão CmdImprimir da seguinte maneira:
Dim Banco as Database
Dim Tabela as RecordSet
Set Banco = OpenDatabase(“C:\Trabalho\Dbcurso.mdb”)
If TxtFiltro.Text<>”” then 
 Set Tabela = Banco.OpenRecordset(“Select * from Clientes Where Nome Like ‘ “ 
& TxtFiltro.Text & “*’” )
Else
 Set Tabela = Banco.OpenRecordset(“Clientes”) 
End if
RptPlan.Database.SetDataSource Tabela
RptPlan.PrintOut
 Primeiro, declaramos 2 variáveis. Um objeto Database e outro RecordSet.
 Dim Banco as Database
 Dim Tabela as RecordSet
 Abrimos o banco de dados:
 Set Banco = OpenDatabase(“C:\Trabalho\Dbcurso.mdb”)
 Depois disso, verificamos de a TextBox “TxtFiltro” não está vazia: 
 
 If TxtFiltro.Text<>”” then
 
 Se ela não estiver vazia, abrimos a tabela usando uma instrução SQL(Explicarei logo 
após) que abre a tabela já com o filtro aplicado. Este filtro é feito com base nos primeiros 
caracteres digitados em “TxtFiltro”:
 
 Set Tabela = Banco.OpenRecordset(“Select * from Clientes Where Nome Like ‘ “ 
& TxtFiltro.Text & “*’” )
 
 Caso contrário:
Else
 Set Tabela = Banco.OpenRecordset(“Clientes”) 
 Abrirá a tabela normalmente, sem nenhum filtro a aplicar, o que quer dizer que se não 
difitarmos nada na TextBox, todos os registros serão exibidos norelatório.
 Feito essa verificação, o bloco If é encerrado:
 End if 
112
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Depois disso, atribuímos a tabela com ou sem o filtro ao nosso relatório e jogamos tudo 
para a impressora:
 RptPlan.Database.SetDataSource Tabela
 RptPlan.PrintOut
 Como você pode ver é um código bem simples e a única parte do código desconhecida 
pelo aluno é o uso de uma instrução SQL para abrir e filtrar a tabela. Não é propósito do 
nosso curso abordar sobre instruções SQL, no entanto, irei abordar ela sobre a questão de 
filtros, sendo que é um recurso que não é complexo, mas ao mesmo tempo é um recurso 
muito poderoso.
 
Utilizando instruções SQL para aplicar filtros
 Para entender como funciona uma instrução SQL, primeiramente olhe para a linha a 
seguir:
Select * From Clientes Where Nome = ‘joao’
Veremos o que querem dizer cada uma dessas palavras:
Select – Quer dizer que estamos selecionando campos de uma tabela. O * existente depois 
da palavra Select quer dizer que todos os campos foram selecionados. Poderíamos escolher 
somente Nome e Código, caso quiséssemos. Neste caso, o farámos demilitando os campos 
por vírgula. Exemplo:
Select Código, Nome From Clientes 
No nosso curso utilizaremos apenas o *. 
From – Especifica a origem de dados. O que virá após From é o nome da tabela de onde 
virão os dados.
Where – Esta cláusula é o motivo pela qual fizemos esse superficial estudo sobre 
instruções SQL . A cláusula Where nos permite aplicar um filtro à tabela com base no 
critério especificado. O que irá após á cláusula Where é o critério de filtro. Olhamos 
novamente para esta linha:
 Select * From Clientes Where Nome = ‘joao’
O que podemos concluir é que: 
Selecionamos todos os campos da tabela “Clientes” e filtramos a tabela, de forma que só o 
registro com nome = ’joao’ será exibido. 
 Quando estamos especificando critérios para um campo do tipo String, o valor deve estar 
entre ‘’(aspas simples). No caso de um valor numérico, não são necessárias as 
aspas.Exemplo:
113
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Select * From Clientes Where Código = 2
 Um recurso muito útil que a linguagem SQL nos oferece é a possibilidade de procurar 
registros pelos seus caracteres iniciais ou finais, ou, até mesmo, por uma Substring dentro 
de uma string. Esse recurso é muito simples de usar. Utilizando o operador LIKE no lugar 
do sinal de igual, com um * no início ou no final da string a procurar, podemos pesquisar 
pelos caracteres iniciais ou finais, respectivamente. Podemos também, inserir um * no 
início e outro no final da string. Estaremos desta forma, pesquisando qualquer registro que 
contenha a string especificada. Para esclarecer um pouco sobre isso, dê uma olhada nos 
exemplo á seguir:
Select * From Clientes Where Nome Like ‘Jo*’
 Irá selecionar todos os registros que tiverem no campo nome nomes que comecem com 
“Jô”:”João”, “José”,”Jovana”, etc...
 O * no final da string indica que estamos ignorando os últimos caracteres.
Select * From Clientes Where Nome Like ‘*ão’
 
 O exemplo acima irá selecionar todos os registros em que o campo Nome termina com 
“ao”. “João”, “Estevão”, etc. Ignorando desta forma, os primeiros caracteres.
 Select * from Clientes Where Nome Like ‘*ar*’
 O exemplo acima procura um registro em que o campo Nome contenha a string “ar”, 
ignorando os primeiros e os últimos caracteres.
 Associar a linguagem SQL aos nossos programas para filtrar dados oferece economia de 
código e eficência. Nosso curso não se destina á abordar sobre a linguagem SQL, no 
entanto achei importante abordar sobre a questão de filtros. 
 Você também pode, ao usar uma instrução SQL, utilizar todos os outros operadores do 
Visual Basic para especificar opções de critério:
Select * from Clientes Where Codigo > 2 And Codigo < 4
O exemplo acima retornará o registro que tenha no campo Codigo um valor igual a 3.
 Além disso, Muitas funções do Visual Basic também funcionam dentro de uma instrução 
SQL. A única diferença será que o aluno deverá substituir as aspas duplas “” pelas aspas 
simples ‘’.
 A forma como usamos as instruções SQL dentro do Visual Basic é muito simples. Basta 
você a usar aonde colocaria o nome da tabela. Por exemplo:
 Set Tabela = Banco.OpenRecordset(“Select * From Clientes Where Nome = 
‘Maria’”)
 Agora que já temos uma noção sobre instruções SQL, iremos analisar, áquela linha do 
código que usamos para filtrar o relatório:
114
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Set Tabela = Banco.OpenRecordset(“Select * from Clientes Where Nome = ‘ “ & TxtFiltro.Text & 
“*’” )
 É uma instrução SQL simples. O único fato que merece um esclarecimento é a concatenação 
 g que usamos para a instrução SQL.
 Como temos um Textbox e o filtro será com base nesse Textbox, logo teremos que 
concatenar a instrução SQL com o conteúdo de “TxtFiltro”, através da propriedade Text. 
 (“Select * from Clientes Where Nome = ‘ “ & TxtFiltro.Text 
 Após o sinal de igual(=), usamos uma ‘ (aspas simples), pois o campo a qual estamos 
filtrando a tabela é Text, que funciona como se fosse uma variável String, por isso a 
necessidade das ‘’(aspas simples). Como ainda iremos concatenar a instrução SQL com o 
valor contido em “TxtFiltro”, apenas abrimos as aspas simples, deixando para fechar logo 
após a concatenação com a Textbox “TxtFiltro”. 
 Depois da ‘(aspas simples), utilizamos a aspas duplas para fechar a string, e, 
concatenamos, através do operador &, com o texto contido em “TxtFiltro”:
“ & TxtFiltro.Text 
 Para facilitar o entendimento, digamos que o usuário tenha digitado na Textbox, o string 
“ma”. Essa string será concatenada com a string á esquerda dela através do operador &. 
Isso resultará na seguinte String:
Select * from Clientes Where Nome Like ‘ma
 Como você viu, ainda faltam o * e uma aspa simples no final da expressão para que a 
instrução SQL funcione. É isto que faz o restante da expressão:
 & “*’ ” 
 Como resultado final, tudo o que for digitado na Textbox será pesquisado no campo 
nome da tabela “Clientes”. Se os primeiros caracteres coincidirem, o registro será aceito.
Visualizando os dados antes de imprimir
 Em um relatório mais profissional, temos a necessidade de visualizar os dados antes de 
imprimi-los. E o Crystal nos primite isso, através do objeto Crviewer. No nosso curso, 
iremos aprender a visualizar os dados, através do formulário que o assistente cria para 
podermos visualizar os dados. Desta forma, aplicaremos o filtro que precisamos no código 
desse formulário e, bastando apenas, a alteração de uma propriedade, conseguimos o 
resultado esperado. 
 Voltando áquele nosso exemplo do filtro anterior. Crie um novo projeto. Crie um novo 
relatório no Crystal(não se esqueça de adicionar o controle crviewer na caixa de 
componentes). Este formulário deve ter como base a tabela “Clientes”, existente no banco 
de dados “bCurso”. Quando o assistente perguntar se você quer criar um formulário de 
visualização, selecione a opção Yes.
115
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
Nomeie o relatório como “RptCli” e o formulário como “FrmRelCli”. Agora observe o 
código criado pelo assistente no formulário “FrmRelCli”:
 Bem, a primeira coisa que devemos fazer nesse código,é retirar a linha existente na 
seção General-Declarations do formulário, já que renomeamos o nome do formulário e 
agora essa declaração não aponta para lugar algum.
 Analisando o código, onde podemos nesse código aplicar o nosso filtro?
A resposta é: No evento Load. 
 Claro que colocar Um Textbox nesse formulário para digitar o filtro não seria o correto, 
já que esse é um formulário próprio para a visualização. Como esse é um exemplo prático, 
façamos o seguinte. 
 Criamos um novo formulário, como o que já criamos anteriormente para aplicar filtros, 
com a seguinte aparência:
Nomeie o formulário como FrmFiltro.O Textbox como “TxtFiltro” e o botão de 
visualização de impressão como “CmdVisualizar”.
 Usaremos esse formulário apenas para informar o filtro ao relatório. Sendo assim, a 
única coisa que teremos de fazer é codificar o evento Click do botão “CmdVisualizar” para 
que chame o formulário de visualização(“FrmRelCli”):
 Agora que já chamamos o formulário de visualização, vamos aplicar o filtro no evento 
Load desse formulário, com base no que foi digitado pelo usuário no objeto “TxtFiltro” do 
formulário “FrmFiltro”. Aplicamos o filtro da mesma maneira como já fizemos 
anteriormente, quando mandamos os dados direto para a impressora.(Não se esqueça de 
marcar a biblioteca do D.A.O., na caixa de referências). 
Dim Banco as Database
Dim Tabela as RecordSet
Set Banco = OpenDatabase(“C:\Trabalho\Dbcurso.mdb”)
If FrmFiltro.TxtFiltro.Text<>”” then 
 Set Tabela = Banco.OpenRecordset(“Select * from Clientes Where Nome like ‘ “ & 
FrmFiltro.TxtFiltro.Text & “*’” )
Else
 Set Tabela = Banco.OpenRecordset(“Clientes”) 
End if
RptCli.Database.SetDataSource Tabela
 A única diferença está em 2 linhas nesse código, onde fizemos referência ao objeto 
“TxtFiltro” do formulário “FrmFiltro”. O Visual Basic trata os objetos de um formulário 
como variáveis públicas. Então podemos acessa-los de qualquer parte do projeto, bastando 
anteceder seu nome pelo nome do formulário seguido de .(ponto).
FrmFiltro.TxtFiltro.Text
116
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark
 Enfim, com esse código acima, já conseguimos obter o filtro que precisamos. Com isso, 
já podemos jogar os dados para a impressora. Mas não é isso que queremos agora. O que 
queremos é visualizar os dados antes de imprimir. Olhando para o restante do código do 
evento, só temos que alterar uma propriedade:
Screen.MousePointer = vbHourglass
CRViewer1.ReportSource = Report 
CRViewer1.ViewReport
Screen.MousePointer = vbDefault
 Aqui você troca pelo nome do formulário que irá usar
 
Alterando, ficará:
Screen.MousePointer = vbHourglass
CRViewer1.ReportSource = RptCli
CRViewer1.ViewReport
Screen.MousePointer = vbDefault
 Agora altera a propriedade WindowsState do formulário atual para 2 - Maximized para 
dar uma aparência mais profissional á visualização de impressão.
 Não podemos nos esquecer de descarregar o relatório da memória. Podemos fazer isso, 
no evento Unload do relatório de visualização: 
 Rode o projeto e confira o resultado.
 
1
117
1utor:Dieimes Viana Corrêa
Email:dieimes_c@yahoo.com.br
Fone: (051) 91538814
Document shared on www.docsity.com
Downloaded by: fernando-soares-0bk (fefe_fengss@hotmail.com)
https://www.docsity.com/?utm_source=docsity&amp;utm_medium=document&amp;utm_campaign=watermark