Módulo Básico

Desenvolvido por: Marcelo Suzuki

SDD – Desenvolvimento Digital do Produto
1. INTRODUÇÃO.................................................................................................................4

2. CONHECENDO O VISUAL BASIC..............................................................................5

2.1. INICIANDO O VISUAL BASIC........................................................................................5

2.2. FORMULÁRIOS.............................................................................................................8
2.3. CAIXA DE FERRAMENTAS............................................................................................8
2.4. PROPRIEDADES..........................................................................................................10
2.5. MÉTODOS..................................................................................................................11
2.6. EVENTOS...................................................................................................................12
2.7. MENUS......................................................................................................................12

3. MÓDULOS DE CÓDIGOS...........................................................................................15

3.1. FORMULÁRIOS E MÓDULOS......................................................................................15

3.2. VARIÁVEIS................................................................................................................15
3.2.1. Declaração de variáveis...................................................................................15
3.2.2. Tipos de variáveis.............................................................................................16
3.2.3. Tipos de variáveis definidas pelo usuário........................................................16
3.3. CONSTANTES.............................................................................................................17
3.4. ARRAYS.....................................................................................................................17
3.4.1. Arrays estáticos................................................................................................17
3.4.2. Arrays dinâmicos..............................................................................................18
3.5. PROCEDIMENTOS.......................................................................................................18

4. OPERADORES...............................................................................................................21

4.1. OPERADORES MATEMÁTICOS....................................................................................21

4.2. OPERADORES RELACIONAIS......................................................................................21
4.3. OPERADORES LÓGICOS..............................................................................................21
4.4. OPERADORES DE STRINGS.........................................................................................22

5. ESTRUTURA DE CONTROLE...................................................................................23

5.1. ESTRUTURA DE DECISÃO...........................................................................................23

5.1.1. If...Then...End If................................................................................................23
5.1.2. If...Then...Else…End If......................................................................................23
5.1.3. If...Then...ElseIf…Else…End if.........................................................................23
5.1.4. Select...Case......................................................................................................24
5.2. ESTRUTURAS DE REPETIÇÃO.....................................................................................24
5.2.1. Do While <condição> Loop.............................................................................24
5.2.2. Do ... Loop While <condição>.........................................................................24
5.2.3. Do Until <condição> Loop..............................................................................25
5.2.4. Do ... Loop Until <condição>..........................................................................25
5.2.5. For <intervalo> ... Next...................................................................................25

6. FUNÇÕES.......................................................................................................................26

6.1. FUNÇÕES MATEMÁTICAS..........................................................................................26

6.2. FUNÇÕES DE ESCOLHA..............................................................................................26
6.3. FUNÇÕES DE CONVERSÃO.........................................................................................28
6.4. FUNÇÕES DE TESTES.................................................................................................28
6.5. FUNÇÕES DE MANIPULAÇÃO DE MATRIZES..............................................................30
6.6. FUNÇÕES LÓGICAS....................................................................................................30
6.7. FUNÇÕES DE DISCO...................................................................................................30
6.8. FUNÇÕES DE STRINGS...............................................................................................31
6.9. FUNÇÕES DE DATA E HORA......................................................................................33
6.10. FUNÇÕES DE FORMATAÇÃO..................................................................................36

2
 6.10.1. Formatação de Expressões Numéricas............................................................36
6.10.2. Formatação de Expressões Lógicas.................................................................38
6.10.3. Formatação de Expressões Data e Hora..........................................................38
6.10.4. Formatação de Expressões String....................................................................40

7. TRATAMENTO DE ERROS........................................................................................41

8. ARQUIVOS.....................................................................................................................43

9. PROGRAMAS EXTERNOS E BIBLIOTECAS.........................................................45

9.1. MANIPULAÇÃO DE PROGRAMAS EXTERNOS..............................................................45

9.2. MANIPULAÇÃO DE BIBLIOTECAS EXTERNAS.............................................................45

10. UTILIZANDO A ÁREA DE TRANSFERÊNCIA..................................................46

11. ALGUNS COMPONENTES ACTIVEX..................................................................47

11.1. COMMONDIALOG..................................................................................................47
11.2. MASKEDBOX........................................................................................................47
11.3. MSFLEXGRID........................................................................................................48
11.4. SSTAB...................................................................................................................48

12. UTILIZANDO WIN32 API COM VB......................................................................49

13. ACESSANDO BANCO DE DADOS.........................................................................50

14. “DEBUGANDO” Um programa..................................................................................51

3
1. INTRODUÇÃO
O Visual Basic é uma ótima ferramenta para desenvolvimento de programas Windows. Por ser
uma ferramenta completa e simples, você pode ganhar bastante tempo no desenvolvimento das
suas aplicações.
Além de aplicações, você também pode desenvolver componente (ocx e dll) para outras aplicações,
facilitando a reutilização do código.
Neste módulo conheceremos esta ferramenta e veremos como desenvolver um aplicativo no Visual
Basic.

4
2. CONHECENDO O VISUAL BASIC
2.1. Iniciando o Visual Basic

Para iniciar o Visual Basic, clique no botão Iniciar na barra de tarefas do Windows, selecione o
item Programas e em seguida selecione a pasta Microsoft Visual Basic e clique no ícone
Microsoft Visual Basic 6.
Ao ser executado, aparecerá uma janela igual a Figura 1.

Figura 1

Nesta janela, existem três pastas: New, Existing e Recent.

 A pasta New nos mostra as opções de um novo projeto (Standard EXE, ActiveX EXE, ActiveX
DLL, etc.).
 A pasta Existing mostra uma caixa de diálogo, onde você pode localizar e selecionar o
projeto que você quer abrir.
 A pasta Recent mostra uma lista com os últimos projetos abertos e sua localização.

Neste módulo, vamos trabalhar com o projeto Standard EXE. Esta é a aplicação padrão, onde a
saída é um arquivo executável. Ao clicar no botão Open aparecerá um ambiente semelhante à
Figura 2.

5
 Barra de menus Formulário Gerenciador de projetos

Figura 2

Propriedades Form Layout

Caixa de ferramentas

Abaixo, temos as descrições de cada um desses itens:

Barra de menus: Exibe os comandos disponíveis que podem ser acessados para a elaboração do
projeto. Junto dos menus, temos os botões de atalho para acesso rápido aos comandos mais
utilizados durante o trabalho de desenvolvimento com o Visual Basic.

Gerenciador de projetos: Relaciona os formulários, módulos de código e demais arquivos que

compõem o projeto. Quando é criado um projeto novo, o gerenciador exibe apenas um
formulário com o nome padrão Form1.

Janela de propriedades: Apresenta as propriedades disponíveis para o controle selecionado no

projeto e um espaço de ajuda relativo à propriedade selecionada. Para selecionar um controle,
basta dar um clique com o mouse sobre o controle desejado selecionar no ComboBox.

Form layout: Indica a posição que a nossa janela vai estar posicionada quando executarmos o
sistema. Também nesta janela é mostrado como a janela se apresentará, caso seja executada em
uma outra configuração de monitor (linhas tracejadas).

6
Caixa de ferramentas: Esta caixa apresenta os controles básicos que podem ser inseridos nos
formulários para o desenho das janelas do aplicativo.

Formulário: É a janela onde serão inseridos os controles para a construção do projeto. Quando é
feito um duplo clique na janela ou em qualquer controle que esteja nesta janela, aparecerá um
editor de código, mostrado na Figura 3. Esta janela também pode ser visualizada clicando no
botão View Code, no gerenciador de projetos, ou no menu View, clique em Code.

Editor de código: Você escreve os comandos de código para um projeto nesta janela. O código
do Visual Basic pode estar associado a um formulário em seu projeto ou contido em um módulo
de código separado.

Lista de Eventos
Lista de objetos

Figura 3 - Editor de código

A lista de objetos contém uma lista de todos os controles contidos no formulário (inclusive o
próprio formulário). Na lista de eventos é mostrado todo o objeto relacionado ao objeto
selecionado.

7
2.2. Formulários

Os formulários são as janelas do nosso programa. Eles são os blocos de criação de aplicativos
escritos em Visual Basic. O usuário interage com o aplicativo por meio de formulários e dos
controles. A Figura 4 mostra um formulário vazio, ou seja, sem controles.

Figura 4 – Formulário

Através das propriedades, eventos e métodos do formulário, podemos usar para controlar sua
aparência e comportamento.

2.3. Caixa de ferramentas

É aqui que encontramos todos os controles utilizados para criar o aplicativo. Quando um
controle é adicionado ao formulário, podemos acessar suas propriedades, ter acesso aos seus
métodos e eventos.
Abaixo veremos os componentes padrões do que estão na caixa de ferramentas do Visual Basic,
uma pequena descrição de cada um deles e sobre suas propriedades, métodos e eventos:

Este é o único item da caixa de ferramentas que não desenha

Pointer nenhum controle. Quando selecionado, pode-se mover ou
redimensionar um controle que já esteja desenhado na janela.
Mostra graficamente uma imagem, que pode ser carregada
PictureBox de um arquivo ou mesmo desenhada. Também pode ser
utilizada como uma “caixa” para conter outros controles.
Exibe um texto na janela que não pode ser modificado pelo
Label
usuário.
Este é um controle de texto em que o usuário pode entrar
TextBox
com os dados e modificá-los.
Este controle é utilizado para fazer o agrupamento de outros
Frame
controles.
CommandButton Botão inserido na tela para que se execute um comando.
Com este controle o usuário pode facilmente escolher um item ou
CheckBox
mais, indicando se cada um será ou não selecionado.

8
 Permite que seja mostrado várias opções ao usuário, porém ele
OptionButton
poderá selecionar somente uma opção.
Este controle contém uma lista com vários itens, mostrando
somente o item selecionado, porém, quando o usuário precisa
ComboBox
selecionar algum item, é mostrada para ele uma lista contendo
todos os outros itens.
Este controle contém uma lista com vários itens, mostrando vários
ou todos os itens da lista. Caso todos os itens não caibam no
ListBox controle para ser mostrado, irá aparecer junto uma barra de
rolagem. A ListBox pode permitir que o usuário selecione mais de
um item.
Fornece uma ferramenta gráfica para facilitar a navegação
HscrollBar horizontal em uma lista com uma quantidade de itens muito
grande.
Fornece uma ferramenta gráfica para facilitar a navegação vertical
VScrollBar
em uma lista com uma quantidade de itens muito grande.
Gera um evento Timer em um intervalo de tempo. Este controle é
Timer
invisível durante a execução do programa.

DriveListBox Mostra os drives de disco válido.

DirListBox Mostra os diretórios de um drive.

FileListBox Mostra uma lista de arquivos de um diretório.

Permite desenhar várias formas sobre a janela durante o
Shape desenvolvimento do projeto. Pode ser um retângulo, retângulo
arredondado, quadrado, quadrado arredondado, oval ou círculo.
Utilizado para desenhar uma variedade de tipos de linhas sobre a
Line
janela durante o desenvolvimento do projeto.
Mostra a figura de um arquivo bitmap, ícone ou metafile sobre a
Image sua janela. As imagens mostradas com este controle são apenas
para exibição.
Data Fornece o acesso à um banco de dados.
É utilizado como container para objetos de outros aplicativos no
OLE
Visual Basic.

Podemos também inserir outros controles na barra de ferramentas, clicando com o botão direito
do mouse sobre ela, e selecionando o menu Components, ou através do menu Project, clicando
em Componets aparecerá uma janela como na Figura 5 com os componentes já registrados. Caso
o componente não esteja na lista, clique no botão Browse e selecione o componente para ser
utilizado no Visual Basic.

9
 Figura 5

2.4. Propriedades

Através das propriedades podemos ler ou alterar os atributos dos objetos dentro do Visual Basic.
Elas podem ser manipuladas durante o desenvolvimento (design time) ou durante a execução
(run time). Algumas só podem ser lidas, mas quase todas podem ser alteradas. Podemos
manipular as propriedades do objeto através da janela de propriedades, mostrado na Figura 6, ou
através do código.

Figura 6

10
 Abaixo vemos, como exemplo, as propriedades que são mais utilizadas durante o
desenvolvimento de um aplicativo Visual Basic. Nem todas as propriedades descritas abaixo são
aplicáveis a todos os componentes.

Alignment Alinhamento do conteúdo do controle (à esquerda, à direita, ao centro).

Aparence Aparência do controle (3d, normal, outras).
AutoSize Ajusta automaticamente seu tamanho ao conteúdo.
BackColor Cor de fundo do controle.
BorderColor Cor da borda do controle.
BorderStyle Estilo da borda do controle (simples, sem borda, entre outras).
BorderWidth Largura da borda do controle.
Quando pressionado a tecla "Esc" no formulário, executa o evento clik
Cancel
(CommandButton).
Caption Texto mostrado no controle.
Quando pressionado a tecla "Enter" no formulário, executa o evento clik
Default
(CommandButton).
Enabled Habilita ou desabilita o controle.
Font Fonte do controle.
Fore Color Cor frontal do controle.
Height Altura do controle.
Icon Arquivo de ícone que será utilizado pelo controle.
Index Índice do controle, quando este for um array.
Distância do controle em relação à borda esquerda do formulário. Se for formulário,
Left
em relação à tela.
List A lista de elementos armazenada pelo controle (ListBox, ComboBox).
ListCount Quantidade de elementos armazenados pelo controle (ListBox, ComboBox).
ListIndex O índice do elemento no controle (ListBox, ComboBox).
Locked "Trava" o controle para escrita.
Mask Máscara de como os dados são exibidos no controle.
MaxLength Quantidade máxima de caracteres que pode ser inserido no controle.
MultiLine Permite várias "linhas" no controle.
MultiSelect Permite a seleção de mais de um elemento da lista (ListBox, ComboBox).
Name Nome do controle.
O caracter exibido pelo controle quando utilizado para senhas (geralmente é
PasswordChar
utilizado "*").
Picture Imagem exibida pelo controle.
Configuração de Barra de Rolagem no controle (sem barra, horizontal, vertical,
ScrollBars
ambas).
Stretch Ajusta automaticamente conteúdo do controle ao seu tamanho.
TabIndex Ordem em que o controle se encontra, quando é acessado via "Tab"
Text Texto mostrado no controle
Distância do controle em relação à borda superior do formulário. Se for formulário,
Top
em relação à tela.
Value Valor do controle como selecionado, não selecionado ou outros.
Visible Deixa o controle visível ou invisível para o usuário

2.5. Métodos

Os métodos são funções ou sub-rotinas que estão relacionados a um objeto.

Abaixo vemos, como exemplo, os métodos que são mais utilizadas durante o desenvolvimento
de um aplicativo Visual Basic. Nem todas os métodos descritos abaixo são aplicáveis a todos os
componentes.

11
 AddItem Adiciona um item ao controle (ListBox ou ComboBox)
Arrange Organiza janelas ou ícones em um formulário próprio(MDIForm)
Circle Desenha um círculo, elipse ou arco no controle
Clear Limpa o conteúdo do controle
Cls Limpa formas gráficas geradas em tempo de execução de um controle
EndDoc Finaliza um documento para impressão
Hide Oculta um controle da tela, sem descarregá-lo da memória(oposto: método show)
KillDoc Finaliza o trabalho de impressão atual
Line Desenha linhas e retângulos no controle
Move Modifica as coordenadas de posicionamento do controle
PopupMenu Exibe um determinado menu popup junto ao ponteiro do mouse
Refresh Força uma atualização gráfica completa no controle
RemoveItem Remove um item do controle (ListBox ou ComboBox)
Setfocus Habilita o foco para o controle
Show Exibe o controle na tela

2.6. Eventos
Um evento ocorre quando uma ação é executada, ou pelo usuário ou através de algo programado
no aplicativo.
Abaixo vemos, como exemplo, os eventos que são mais utilizados durante o desenvolvimento de
um aplicativo Visual Basic. Nem todas os eventos descritos abaixo são aplicáveis a todos os
componentes.

Activate Quando o controle passa a ser ativo (Form)

Change Quando o conteúdo do controle sofre alguma alteração
Click Ao clicar do mouse sobre o controle
DblClick Ao dar um duplo clique com o mouse sobre o controle
Deactivate Quando o controle é desativado (Form)
GotFocus Momento em que um controle recebe o foco
KeyDown Quando é pressionada uma tecla sobre o controle
KeyPress Quando é pressionada e liberada uma tecla do controle
KeyUp Quando é liberada uma tecla do controle
Load Ao carregar o controle
LostFocus Momento em que um controle perde o foco
MouseDown Quando é pressionado o botão do mouse sobre o controle
MouseMove Ao mover o mouse sobre o controle
MouseUp Quando é liberado o botão do mouse do controle
Paint Quando o controle é desenhado parcialmente ou totalmente
Resize Quando o controle é redimensionado
Scroll Quando é movimentada uma barra de rolagem
Unload Ao descarregar o controle

2.7. Menus
Nas janelas dos nossos aplicativos, podemos ter também uma barra de menu. Este componente
deixa o sistema mais amigável com o usuário, pois apresentam-se na forma de texto as opções
que estão disponíveis dentro do software.
O Menu Editor é a ferramenta utilizada para criar o menu dentro do Visual Basic. Para acessa-lo,
selecione o Menu Editor dentro do menu Tools ou clicando com o botão direito sobre o
formulário, ou através do ícone . . O Menu Editor é mostrado na Figura 7.

12
 Figura 7

Através dele também podemos configurar o menu e definir suas propriedades.

A seguir estão as descrições dos campos do Menu Editor.

Caption - É neste campo que definiremos definido o que aparecerá escrito para o usuário no
menu. Caso você queira criar uma barra para separar os itens do menu, coloque um hífen (-)
neste campo.
Para que o usuário tenha acesso ao menu através do teclado, coloque um “&” antes da letra assim
como nos botões. Se você precisar que apareça um “&” no menu, coloque dois “&” seguidos.

Name - Este campo é o nome do controle para este item do menu.

Index - Permito você associar valores numéricos que determina a posição dentro de um vetor de
controles. Este posição não é ser relacionada com sua posição na tela.

Shortcut - Permite você selecionar um “shortcut” para acessar aquele item do menu.

Checked - Permite você marcar se o menu irá aparecer com um tique a esquerda do item do
menu. Ele é geralmente utilizado para indicar se aquele item está selecionado ou não.

Enabled - Permite você habilitar ou desabilitar o item do menu selecionado.

Visible - Permite você deixar o menu visível ou invisível.

WindowList - Determina se o controle de menu terá a lista de janelas filhas abertas, dentro uma
aplicação com janela MDI. Veremos mais adiante as janelas MDI.

Right Arrow - Move o menu selecionado para um nível abaixo, ficando como submenu.
Você pode criar até quatro níveis de submenus.

Left Arrow - Move o menu selecionado para um nível acima.

13
 Up Arrow - Move o menu selecionado para uma posição anterior.

Down Arrow - Move o menu selecionado para a próxima posição.

Menu List - Mostra a hierarquia dos menus e submenus. Os submenus são endentados para
indicar sua posição e nível hierárquico.

Next - Move a seleção para a próxima linha.

Insert - Insere uma nova linha na lista sobre o item selecionado.

Delete - Apaga o item selecionado.

14
3. MÓDULOS DE CÓDIGOS
Até agora vimos como fazer a interface de um programa e mudar algumas características. A partir
daqui, começaremos a aprender escrever o código para estes programas.

3.1. Formulários e Módulos

Como já vimos anteriormente, os formulários serão as nossas janelas. Nos formulários, também
poderemos inserir código do programa, porém, variáveis, procedimentos estarão relacionados
somente a estes formulários. Para que possamos criar variáveis e procedimentos globais para
todos os programas, utilizaremos os módulos.

3.2. Variáveis
As variáveis são utilizadas para o armazenamento de dados. Você pode utilizar uma ou mais
variáveis no seu programa e elas podem guardar palavras, números, datas. As variáveis são úteis
porque permitem que você atribua um nome curto e fácil de lembrar a cada fragmento de dados
com que pretende trabalhar.

Podemos ter três formas diferentes de variáveis:

1) As locais, que são válidas somente na função ou sub-rotina em que foi declarada;
2) As globais, que são válidas no formulário ou módulo em que foi declarada;
3) As públicas, que são válidas para todo o projeto.

As regras para nomes de variáveis no Visual Basic são:

1) Não podem mais de 255 caracteres.
2) Devem necessariamente começar com uma letra.
3) Não podem ser palavras reservadas

3.2.1. Declaração de variáveis

Para declarar explicitamente uma variável antes de utilizá-la, você deve digitar o nome da
variável após a instrução Dim. Essa declaração reserva o espaço na memória para a
variável quando o programa é executado, e permite que o Visual Basic saiba que tipos de
dados devem esperar, pois após os nomes das variáveis, devemos especificar o tipo de
dados que ela irá receber.

A sintaxe para a declaração de variáveis é:

Dim nome_da_variável [As Tipo]

Onde:
1) nome_da_variável é o nome da variável segundo as regras do Visual Basic;
2) Tipo é um tipo de variável que pode ser um dos tipos pré-definidos do Visual Basic
ou um tipo criado pelo usuário.

Para as variáveis públicas, elas deverão ser declaradas em General dentro de um módulo
ou formulário, utilizando a instrução Public no lugar da instrução Dim.
Podemos também ter variáveis estáticas, ou seja, que após sair do procedimento onde ela
foi declarada, ela não perde o valor. Para isso utilizamos a instrução Static.

15
3.2.2. Tipos de variáveis
Abaixo temos uma tabela com o tipo de variáveis, quanto que ela ocupa na memória, e o
intervalo que podemos trabalhar.

Tipo Tamanho Intervalo

Byte 1 byte 0 a 255
Boolean 2 bytes True ou False
Integer 2 bytes -32.768 a 32.767
Long
4 bytes -2.147.483.648 a 2.147.483.647

Single Negativos: -3,402823 E38 a -1,401298 E-45

4 bytes
Positivos: 1,401298 E-45 a 3,402823 E38
Negativos:
Double -1,79769313486232 E308 a -4,94065645841247 E-324
8 bytes
Positivos:
4,94065645841247 E-324 a 1,79769313486232 E308
Currency
8 bytes -922.337.203.685.477,5808 a 922.337.203.685.477,5807

+/-79.228.162.514.264.337.593.543.950.335 sem vírgula

decimal;
Decimal 14 bytes +/-7,9228162514264337593543950335 com 28 casas
decimais à direita; o menor número diferente de zero é
+/-0,0000000000000000000000000001.
Date 8 bytes De 1º de janeiro de 100 a 31 de dezembro de 9999
10 bytes +
String comprimento
De 0 a aproximadamente 2 bilhões
(variável) da seqüência de
caracteres
Comprimento
String
da seqüência de De 1 a aproximadamente 65.400
(fixo)
caracteres
Variant Qualquer valor numérico até o intervalo de um Double
16 bytes
(números)
22 bytes +
Variant comprimento
O mesmo intervalo de String de comprimento variável
(caracteres) da seqüência de
caracteres

Nota: Quando omitimos o tipo da variável, o Visual Basic assumirá sempre como
Variant.

3.2.3. Tipos de variáveis definidas pelo usuário

Também é possível no Visual Basic criar “tipos” de variáveis (estruturas).
A sintaxe é:
Type nome_tipo

16
 campos
.
.
.
End Type

Ex.:
Type Registro
Nome as string
Idade as Integer
End Type

Forma de utilização:
Dim Reg As Registro

Reg.Nome = “Marcelo”
Reg.Idade = 25

3.3. Constantes
As constantes são utilizadas para armazenar valores que nunca serão modificados. As constantes
operam de uma forma muito parecida com as variáveis, só que não podemos alterar o seu valor
durante a execução do programa. Para declarar um valor como constante, utilize a palavra Const.

A sua sintaxe é:
Const nome_da_constante [As Tipo] = valor

Onde:
1) nome_da_constante é o nome dado a constane;
2) Tipo é o tipo definido;
3) valor é o valor da constante.

3.4. Arrays

Os arrays de variáveis, ou simplesmente arrays como são mais conhecidos, são muito úteis, pois
permite que você se refira a todo um grupo de valores utilizando somente um nome e
processando os valores individualmente, utilizando uma estrutura de repetição. O array é criado no
nosso programa da mesma maneira como declaramos uma variável, colocando também a sua dimensão.
Temos dois tipos de arrays. Os estáticos e os dinâmicos.

3.4.1. Arrays estáticos

As dimensões dos arrays estáticos são definidas na sua declaração, não sendo possível
mudar depois. Sua sintaxe é:
Dim nome_do_array (dimensão) [As Tipo]

Exemplos:

17
 Dim valores (4) As String => Array de strings unidimensional, com 5 posições (0-4).

Dim numeros (1 to 7) As Integer => Array de inteiros unidimensional, com 7 posições (1-7).

Dim matriz (3, 3) As Integer => Array de inteiros bidimensional, de 4 x 4 (0-3, 0-3)

valores (2) = “Brasil” => Atribuição de “Brasil” à posição 2 do array.

3.4.2. Arrays dinâmicos

Os arrays dinâmicos são redimensionados durante a execução do programa, quando for

necessário. Para que seja feito isso utilizamos a instrução ReDim, cuja sua sintaxe é:
ReDim [Preserve] nome_do_array (dimensão) [As Tipo]

Toda vez que o array é redimensionado, ele perde todo o conteúdo. Para que isso não
ocorra, utilizamos o Preserve, porém, com esta palavra só conseguimos redimensionar o
último elemento, no caso de matriz, por exemplo.

Exemplo:

Dim Valores () As String

ReDim Valores (2)

Valores (0) = “Teste1”

Valores (1) = “Teste2”
Valores (2) = “Teste3”

Redim Valores (5) => Com esta instrução, todos os elementos anteriores
foram eliminados
Valores (0) = “Teste1”
Valores (1) = “Teste2”

Redim Preserve Valores (3) => Mantém os elementos anteriores.

Nota: Por default, todos os arrays irão começar com 0, a não ser que no início do módulo tenha a
definição Option Base 1. Com isso, os arrays passarão a começar do 1, e não mais do 0.

3.5. Procedimentos

Os procedimentos são códigos que podem ser acessados de diversos pontos do programa. Estes
módulos podem ser funções ou sub-rotinas.
A diferença entre elas é que a função retorna um valor quando executado, e a sub-rotina não.

Para a declaração de uma sub-rotina, utilize a seguinte sintaxe:

[Private | Public] [Static] Sub Nome [(Arglist)]

Para a declaração de uma função, utilize a seguinte sintaxe:

[Private | Public] [Static] Function Nome [(Arglist)] [As Tipo]

18
Part Description
Public Opcional. Indica que a sub-rotina/função está acessível para todos os outros
procedimentos em todos os módulos.
Private Opcional. Indica que a sub-rotina/função está acessível somente para os
procedimentos no módulo onde ele está declarado.
Static Opcional. Indica que as variáveis locais da sub-rotina/função serão preservadas
entre as chamadas.
Nome Obrigatório. Nome da sub-rotina/função.
Arglist Opcional. Lista de variáveis representando os argumentos que serão passados
para a sub-rotina/função quando ela for chamada. Múltiplas variáveis são
separadas por vírgulas.
Tipo (somente para Opcional. Tipo de dado do valor retornado pela função; pode ser Byte, Boolean,
função) Ineger, Long, Currency, Single, Double, Decimal, Date, String, Object, Variant
ou qualquer tipo definido pelo usuário.

A arglist tem a seguinte sintaxe e partes:

[Optional] [ByVal | ByRef] [ParamArray] varname [()] [As Type] [=defaultvalue]

Part Description
Optional Opcional. Indica que um argumento não é obrigatório. Se for utilizado, todos os
argumentos seguintes na arglist deverão ser opcionais declarados com Optional.
Optional não pode ser usado por qualquer argumento se ParamArray for usado.
ByVal Opcional. Indica que os argumentos são passados por valor.
ByRef Opcional. Indica que os argumentos são passados por referência. Default no Visual
Basic.
ParamArray Opcional. Utilizado somente como o ultimo argumento na arglist para indicar que o
último argumento é um array opcional de elementos de Variant.
varname Obrigatório. Nome da variável representando o argumento, seguindo o padrão de
nomes de variáveis.
Type Opcional. Tipo de dados do argumento passado para o procedimento; pode ser Byte,
Boolean, Integer, Long, Currency, Single, Double, Decimal, Date, String (tamanho
variável somente), Object, Variant, ou um tipo defindo.
defaultvalue Opcional. Qualquer valor constante. Válido somente para parâmetro Optional. Se o
tipo é um Object, o valor default poderá ser somente Nothing.

Para retornar um valor de uma função, atribua o valor ao nome da função, como no exemplo:

Function soma(a As Integer, b As Integer) As Integer

Dim c as integer
c=a+b
soma = c
End Function

19
Para executar uma sub-rotina, durante a codificação, coloque a instrução Call e o nome, ou
simplesmente o nome, como no exemplo:

Call Mensagem (“Olá”)

ou
Mensagem “Olá”

Nota: Se você utilizar o Call, deverá passar os parâmetros entre parênteses “( )”, caso contrário,
deverá ser passado os parâmetros sem parênteses.

Para executar uma função, durante a codificação, coloque uma variável recebendo o retorno da
função, ou simplesmente o nome da função, como no exemplo:

Valor = Soma (2, 3)

ou
Soma 2, 3

Nota: Se você utilizar uma variável recebendo o retorno, os parâmetros deverão ser passado
entre parênteses “( )”, caso contrário, deverá ser passado os parâmetros sem parênteses.

20
4. OPERADORES
A finalidade básica dos operadores é comparar, calcular, igualar, concatenar... enfim, fazer
operações envolvendo variáveis e/ou constantes.

4.1. Operadores matemáticos

Estes tipos de operadores possuem a finalidade de efetuar cálculos, como mostra a tabela abaixo:

Operador Descrição
+ Soma
- Subtração
* Multiplicação
/ Divisão
\ Divisão. Resultado será um número inteiro
^ Exponenciação
Mod Resto da Divisão

Esses operadores respeitam uma ordem de precedência universal:

1ª. Exponenciação
2ª. Multiplicação e Divisão
3ª. Adição e Subtração
Para mudar a ordem de precedência, utilize os parênteses “()”.

4.2. Operadores relacionais

Estes operadores fazem comparações entre variáveis ou expressões. O retorno desta comparação
será sempre True (Verdadeiro) ou False (Falso).

Operador Descrição
< Menor
> Maior
<= Menor ou Igual
>= Maior ou Igual
= Igual
<> Diferente

4.3. Operadores lógicos

Enquanto que os operadores matemáticos retornam o resultado de um cálculo, os operadores
lógicos sempre retornam True quando a lógica é exata, ou False quando a lógica não é exata.

Operador Descrição
And Usamos quando precisamos comparar duas relações e ambas tem que ser
verdadeira.
Or Usamos quando precisamos comparar dois relacionamentos e pelo menos
um deve ser verdadeiro (ou um ou outro).
Not É um operador que inverte o resultado, passando algo que seria verdadeiro
para falso e vice-versa.
Xor Este operador exige precisão. Não admite confusão na comparação dos
relacionamentos. Ou é uma coisa ou outra. Nunca as duas.
Eqv Abreviatura de Equivalente. Faz uma equivalência lógica entre duas
expressões.

21
 Imp Abreviatura de Implicação (uma coisa implica em outra). O resultado será
False somente se a primeira comparação for True e a segunda for False. Nos
outros casos o resultado será sempre True. Este operador é o único onde a
ordem dos operando faz a diferença.

4.4. Operadores de strings

O mais simples de todos. É o símbolo “&” que serve para juntar duas expressões ou variáveis
texto. O operador “+” também pode ser usado, mas não é aconselhado, uma vez que o “&”
possui uma abrangência maior, convertendo expressões de outros formatos para o string para
forçar a concatenação.

22
5. ESTRUTURA DE CONTROLE
5.1. Estrutura de decisão
Estes comandos executam determinadas ações desde que algumas condições sejam favoráveis
(verdadeiras).

5.1.1. If...Then...End If
Utilizado para executar um bloco de comandos, caso a condição seja favorável.

Sintaxe:
If Condição Then
Commandos
End If

1) Condição: pode ser uma variável ou uma expressão.

2) Comandos: comandos a serem executados.

5.1.2. If...Then...Else…End If
Utilizado para executar um bloco de comandos, caso a condição seja favorável, caso a
condição não seja favorável, executa outro bloco de comandos.

Sintaxe:
If Condição Then
Commandos 1
Else
Commandos 2
End If

1) Condição: pode ser uma variável ou uma expressão.

2) Comandos 1: comandos a serem executados se a condição for favorável.
3) Comandos 2: comandos a serem executados se a condição não for favorável.

5.1.3. If...Then...ElseIf…Else…End if

Utilizado para executar um bloco de comandos, caso a condição seja favorável, caso a
condição não seja favorável, faz uma nova verificação, executa outro bloco de comandos.

Sintaxe:
If Condição Then
Commandos 1
ElseIf
Commandos 2
Else
Commandos 3
End If

1) Condição: pode ser uma variável ou uma expressão.

23
 2) Comandos 1: comandos a serem executados se a primeira condição for favorável.
3) Comandos 2: comandos a serem executados se a primeira condição não for favorável,
mas a segunda sim.
4) Comandos 2: comandos a serem executados caso nenhuma das condições sejam
favoráveis.

Obs: Esta estrutura não está limitado ao número de blocos, podendo ter mais de um
“ElseIf” no código.

5.1.4. Select...Case
Executa um bloco de comandos, dependendo do resultado da expressão.

Sintaxe:
Select Case Expressão
Case Condição
.
.
.
Case Else
End Select

1) Expressão: pode ser uma variável ou uma expressão.

2) Condição: pode ser o resultado da expressão ou uma comparação indicando que a
expressão é favorável.

5.2. Estruturas de repetição

Estes comandos ficam repetindo os comandos que se encontram dentro dele, dependendo da
condição.

5.2.1. Do While <condição> Loop

Sintaxe:
Do While Condição
Comandos
Loop

1) Condição: pode ser uma variável ou uma expressão.

2) Comandos: bloco de comandos a ser executado enquanto a condição for verdadeira.

Esta estrutura executa todos os comandos que existem entre Do While e o Loop, enquanto
a condição for verdadeira. Nesta estrutura, a condição é verificada antes de executar o
bloco de comandos.

5.2.2. Do ... Loop While <condição>

Sintaxe:
Do
Comandos
Loop While Condição

1) Condição: pode ser uma variável ou uma expressão.

2) Comandos: bloco de comandos a ser executado enquanto a condição for verdadeira.

24
 Esta estrutura executa todos os comandos que existem entre Do e o Loop While, enquanto
a condição for verdadeira. Nesta estrutura, a condição é verificada depois de executar o
bloco de comandos.

5.2.3. Do Until <condição> Loop

Sintaxe:
Do Until condição
Comandos
Loop

1) Condição: pode ser uma variável ou uma expressão.

2) Comandos: bloco de comandos a ser executado até que a condição seja verdadeira.

Esta estrutura executa todos os comandos que existem entre Do Until e o Loop, até que a
condição for verdadeira. Nesta estrutura, a condição é verificada antes de executar o bloco
de comandos.

5.2.4. Do ... Loop Until <condição>

Sintaxe:
Do
Comandos
Loop Until Condição

1) Condição: pode ser uma variável ou uma expressão.

2) Comandos: bloco de comandos a ser executado até que a condição seja verdadeira.

Esta estrutura executa todos os comandos que existem entre Do e o Loop Until, enquanto
a condição for verdadeira. Nesta estrutura, a condição é verificada depois de executar o
bloco de comandos.

5.2.5. For <intervalo> ... Next

O comando For faz uma contagem de um determinado intervalo de números.

Sintaxe:
For Contador = Inicio To Fim [Step Valor_Step]

1) Contador: variável contador.

2) Inicio: valor inicial do contador.
3) Fim: valor final do contador
4) Valor_Step: valor que indicará de quanto o contador será modificado. Se o parâmetro
Step for omitido, o valor default é 1.

25
6. FUNÇÕES
Funções nada mais são que rotinas prontas para executar determinadas ações.
Existem no Visual Basic diversos tipos de funções que nos auxiliam na programação em todos os
aspectos. São funções que fazem cálculos, funções que exibem resultados, etc. Vamos começar a
ver algumas dessas funções e com isto descobriremos o poder que elas exercem dentro da
linguagem e sua utilidade.

6.1. Funções Matemáticas

Abs: Retorna sempre um valor positivo (absoluto).
Atn: Retorna o arco-tangente de um número.
Cos: Calcula o cosseno de um ângulo
Fix: Retorna a parte inteira de um número, ignorando as casas decimais, se houver. Não faz
arredondamento
Hex: Retorna a representação hexadecimal de um número decimal.
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.
Log: Calcula o logaritmo natural de um número (base e)
Sgn: Retorna -1 se o argumento for um número negativo, e 1 se for um número positivo.
Sin: Calcula o seno de um ângulo.
Sqr: Calcula a raiz quadrada de um número.
Tan: Calcula a tangente de um ângulo.

Todas as funções acima, a sintaxe é a mesma, passando um valor como parâmetro, e retornando
o resultado.
Ex: Result = Abs(-10) -> Result terá o valor 10.

Rnd: Retorna um número randômico, ou seja, escolhe um número aleatoriamente.

Sintaxe: Result = Rnd
Para o que a função Rnd inicie seu alguritmo, utilize a função Randomize antes de começar
a utilizar o Rnd. O Randomize só é necessário executar uma vez.

6.2. Funções de escolha

Choose: Seleciona um valor de uma lista de argumentos.
Sintaxe: Variável = Choose (<Índice>, <Escolha>[, <escolha>]...)
Índice: Expressão numérica ou campo que resulta num valor entre 1 e o número de opções
disponíveis.
Escolha: Expressão Variant que contém uma das possíveis opções.
Choose retorna um valor da lista de opções com base no valor de índice. Se índice for 1,
retorna a primeira opção da lista; se índice for 2, retorna a segunda opção e assim por
diante.
Se índice não for um número inteiro, ele será arredondado para o número inteiro mais
próximo antes de ser avaliado.

InputBox: Exibe um aviso numa caixa de diálogo, aguarda até que o usuário insira texto ou
escolha um botão e retorna o conteúdo da caixa de texto.
Sintaxe: Variável = Inputbox(<ExpressãoPrompt >,<BarraDeTítulo>,<EscolhaDefault>)

26
 ExpressãoPrompt: Expressão de seqüência de caracteres exibida como a mensagem numa
caixa de diálogo. O tamanho máximo de prompt é de aproximadamente 1024 caracteres,
dependendo da largura dos caracteres usados.
BarraDeTítulo: Expressão de seqüência de caracteres exibida na barra de títulos da caixa de
diálogo. Se você omitir este argumento, o nome do aplicativo será incluído na barra de
títulos.
EscolhaDefault: Expressão de seqüência de caracteres exibida na caixa de texto como a
resposta padrão se nenhuma outra entrada for fornecida. Se você omitir EscolhaDefault, a
caixa de texto será exibida vazia.
Se o usuário escolher "OK" ou pressionar ENTER, a função InputBox retorna o conteúdo
da caixa de texto, qualquer que seja ele. Se o usuário escolher "Cancelar", a função retorna
uma seqüência de caracteres de tamanho zero ("").

MsgBox: Exibe uma caixa de diálogo para exibir informações e obter respostas simples através
de botões de comando.
Sintaxe: VariávelNumérica = MsgBox (<ExpressãoPrompt>,<BotõesDisponíveis>,
<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.
BotõesDisponível: Expressão numérica que é a soma de valores que especificam o número
e tipo de botões a serem exibidos, o estilo de ícone a ser usado, a identidade do botão
padrão e a modalidade da caixa de mensagem. Se omitido, o valor padrão será 0. Veja
abaixo os tipos de botões disponível:

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.
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.

27
 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 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"

6.3. 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.
CByte: Converte uma expressão para um tipo Byte.
CCur: Converte uma expressão numérica para um tipo-moeda.
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.
CDbl: Converte uma expressão numérica em um número de ponto flutuante de precisão dupla.
CInt: converte uma expressão numérica em um número inteiro. Faz arredondamento.
CLng: Converte uma expressão numérica em um número inteiro longo.
Obs.: A diferença entre a função CInt e CLng é a abrangência da própria variável.
CSng: Converte uma expressão numérica em um número de ponto flutuante de precisão simples.
CStr: Converte uma expressão numérica, data ou outra em uma string (texto).
CVar: Converte uma expressão de qualquer tipo para o tipo variante.
Asc: Retorna o código ANSI do primeiro caractere de uma String.
Chr: Retorna o caractere correspondente ao código na tabela ASCII
Val: Converte uma String com caracteres numéricos em uma variável númerica.
Str: Converte um valor numérico para o tipo String (texto). Valido somente para argumentos
numéricos.

Todas as funções anteriores, a sintaxe é a mesma, passando um valor como parâmetro, e

retornando o resultado.
Ex: Result = Val(“10”) -> Result terá o valor 10.

6.4. Funções de Testes

IsArray: Testa se uma variável é uma matriz
IsDate: Testa se o argumento pode ser convertido para uma data. Esta data deve estar dentro dos
padrões de data.
IsEmpty: Verifica se uma variável foi inicializada. 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.
IsError: Testa se uma expressão é um valor de erro.
IsMissing: Testa se um argumento opcional foi passado como parâmetro para uma procedure ou
função.

28
 IsNull: Testa se uma variável possui valor inválido.
IsNumeric: Testa se o argumento pode ser convertido para um número.
IsObject: Testa se uma expressão referencia a um objeto OLE válido.

Todas as funções anteriores, a sintaxe é a mesma, passando um valor como parâmetro, e o

retorno é True ou False.

VarType: Retorna o tipo de variável especificada como argumento:

Sintaxe: VariávelNumérica = VarType(<Variável>)

Os valores de retorno são:

Valor Descrição
0 Não iniciada (Empty).
1 Nenhum dado válido (Null).
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).
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).

TypeName: Retorna o nome descritivo do tipo de uma variável.

Sintaxe: VariávelString = TypeName(<Variável>)

Eis os nomes de retorno da função:

Nome Descriçã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.

6.5. Funções de Manipulação de Matrizes

29
 Array: Retorna um Array do tipo Variant.
Sintaxe: ArrayVariant = Array (<NúmeroDeElemento>)

NúmeroDeElemento: consiste de uma lista delimitada por vírgula de um número arbitrário

de valores que são atribuídos aos elementos da matriz contidos em Variant. Se nenhum
argumento for especificado, será criada uma matriz de comprimento zero.
O limite inferior de uma matriz criada com a função Array é determinado pelo limite
inferior especificado com a instrução Option Base.

LBound: Retorna o menor índice de uma matriz.

Sintaxe: VariávelNumérica = Lbound(<NomeDaMatriz>)

UBound: Retorna o maior índice de uma matriz.

Sintaxe: VariávelMatriz = Ubound(<NomeDaMatriz>])

Split: Lê uma string com o certo separador, e cria um vetor com estes elementos
Sintaxe: VariávelMatriz = Split(expressão[, delimitador[, contador[, comparação]]])

Expressão: String a ser convertida em vetor

Delimitador: Separador dos elementos do vetor
Contador: Quantidade de substrings que será retornada. -1 Todas as substrings são
retornadas
Comparação: Forma de comparação.

6.6. Funções Lógicas

IIf: Analisa uma expressão lógica, e retorna valores para quando for falso ou verdadeiro.
Sintaxe: ExpressãoDeRetorno = IIF (<ExpressãoLógica>, <ExpressãoParaVerdadeiro>,
<ExpressãoParaFalso>)

Switch: Avalia uma lista de expressões e retorna o valor associado àquela primeira avaliada
como verdadeira.
Sintaxe: Retorno = Switch(<Expr1>, <Valor1>[, <Expr2>, <Valor2> , <Exprn>,
<Valorn>])
Expr: Expressão variant que você quer avaliar.
Valor: Valor ou expressão que é retornado se a expressão correspondente for True.

A lista de argumentos da função Switch consiste de pares de expressões e valores. As

expressões são avaliadas à medida que aparecem na lista da esquerda para a direita e é
retornado o valor associado à primeira expressão para avaliar True. Se as partes não forem
corretamente pareadas, ocorre um erro em tempo de execução. Por exemplo, se <Expr 1>
for True, Switch retornará <Valor 1>. Se <Expr 1> for False, mas <Expr 2> for True,
Switch retornará <Valor 2>, e assim por diante.
Switch retornará um valor Null se nenhuma das expressões for True.
Switch avalia todas as expressões, mesmo que retorne apenas uma delas. Por este motivo,
você deve ficar atento para efeitos colaterais indesejáveis.

6.7. Funções de Disco

CurDir: Retorna o diretório corrente.
Sintaxe: VariávelString = CurDir[(<drive>)]

30
 Dir: Retorna o nome de um arquivo, diretório ou pasta correspondente a um padrão especificado
ou atributo de arquivo, ou a etiqueta de volume de uma unidade de disco.
Sintaxe: VariávelString = Dir[(Nomedocaminho[, Atributos])]
Nomedocaminho: Expressão de seqüência de caracteres que especifica um nome de arquivo
e pode incluir diretório ou pasta e unidade de disco. Null é retornado se nomedocaminho
não for encontrado.
Atributos: Constante ou expressão numérica, cuja soma especifica atributos de arquivo. Se
forem omitidos, todos os arquivos normais que tiverem Nomedocaminho correspondente
são retornados.

As configurações do argumento Atributos são:

Constante Valor Descrição

vbNormal 0 Normal.
vbHidden 2 Oculto.
vbSystem 4 Arquivo de sistema,.
vbVolume 8 Etiqueta de volume. Se for especificado, todos os outros atributos
serão ignorados.
vbDirectory 16 Diretório ou pasta.

FileDateTime: Retorna a data e a hora da última atualização do arquivo.

Sintaxe: VariávelData = FileDateTime(<NomeArquivo>)

FileLen: Retorna o tamanho do arquivo em bytes.

Sintaxe: VariávelNumérica = FileLen(<NomeArquivo>)

GetAttr: Verifica os atributos de um arquivo ou diretório.

Sintaxe: VariávelNumérica = GetAttr(<NomeArquivo>)

Veja os valores de retorno desta função:

Constante Valor Descrição

vbNormal 0 Normal.
vbReadOnly 1 Somente Leitura.
vbHidden 2 Oculto.
vbSystem 4 Arquivo de sistema
vbDirectory 16 Diretório ou pasta.
vbArchive 32 O arquivo foi modificado desde o último backup.

6.8. Funções de Strings

InStr: Retorna a posição da primeira ocorrência de uma seqüência de caracteres dentro de outra
Sintaxe: Variável = InStr ([<PosiçãoInicial>,] <String>,
<SubStringAPesquisar>[,<MétodoDeComparação])

PosiçãoInicial: 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ção for 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

31
 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.

LCase: Converte uma expressão string para minúsculas.

Sintaxe: VariávelString = LCase(<string>)

Left: Retorna uma quantidade de caracteres que se encontra da esquerda para a direita.
Sintaxe: VariávelString = Left(<string>)

Len: Retorna o número de caracteres de uma expressão String ou número de bytes requerido
para armazenar uma variável.
Sintaxe: VariávelNumérica = Len (<ExpressãoCaractere>)

LTrim: Remove os espaços em branco à esquerda de uma String.

Sintaxe: VariávelString = Ltrim(<string>)

Mid: Retorna uma substring de uma String, ou seja, retorna um número especificado de
caracteres de uma seqüência de caracteres.
Sintaxe: 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.

Right: Retorna uma substring com os caracteres que se encontram da direita para a esquerda
dentro de uma expressão String.
Sintaxe: VariávelNumérica = Right([<ExpressãoString>, <QuantidadeDeCaracteres>)

RTrim: Remove os espaços à direita em uma String.

Sintaxe: VariávelString = Rtrim(<string>)

SPace: Retorna uma String com uma determinada quantidade de espaços vazios.
Sintaxe: VariávelString = Space(<quantidadeDeCaracteres>)

StrComp: Compara duas expressões Strings.

Sintaxe: VariávelNumérica = 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.

Os valores de retorno da função podem ser:

a) -1 quando a primeira String for menor que a Segunda
b) 0 quando forem iguais
c) 1 quando a primeira String for maior que a segunda.

String: Repete um determinado caractere a quantidade de vezes estabelecido na função.

Sintaxe: VariávelString = String (<QuantidadeDeCaracteres>, <caracteres>)

32
 Trim: Remove os espaços à esquerda e à direita de uma string.
Sintaxe: VariávelString = Trim(<String>)

UCase: Converte uma expressão String para maiúsculas.

Sintaxe: VariávelString = Ucase (<String>)

StrConv: Retorna uma string convertida de acordo com o tipo de conversão especificado.
Sintaxe: VariávelString = Strconv(<ExpressãoString>, <TipoDeConversão>)

ExpressãoString: String a ser convertida.

TipoDeConversão: Pode ser:
a. vbUpperCase: Converte toda a expressão em letras maiúsculas.
b. vbLowerCase: Converte toda a expressão em letras minúsculas.
c. vbProperCase: Converte somente a primeira letra em maiúscula e o restante em
minúsculo.

Join: Retorna uma string com os elementos de um vetor separado por um delimitador.
Sintaxe: VariávelString = Join(<array>, [<Delimitador>])

Array: Vetor a ser convertido.

Delimitador: Separador na string dos elementos do vetor
Se delimitador não for especificado, o espaço (“ “) será utilizado.

6.9. Funções de Data e Hora

Date: Retorna a data corrente do sistema operacional.
Sintaxe: VariávelData = Date

DateAdd: Incrementa uma data nos dias, meses ou anos especificados. Retorna uma Variant que
contém uma data à qual foi adicionado um determinado intervalo de tempo.
Sintaxe: VariávelVariant = DateAdd(<Intervalo>, <Incremento>,<ExpressãoData>)

Intervalo: String indicando o intervalo de tempo que você quer adicionar. Podem ser:

String Descrição
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.

33
 A função DateAdd pode ser usada para adicionar a uma data ou subtrair dela um intervalo
de tempo especificado. Por exemplo, você poderia usar DateAdd para calcular uma data 30
dias a partir de hoje ou uma hora que é 45 minutos a partir de agora.
Se quiser adicionar dias a data, você pode usar Dia do Ano ("y"), Dia ("d") ou Dia da
Semana ("w").

DateDiff: Calcula o intervalo entre duas datas.

Sintaxe: VariávelData = DateDiff(<intervalo>, <expressãoData1>, <expressãoData2>)

Intervalo: String que indica o intervalo de tempo que você usa para calcular a diferença
entre uma data e outra. O argumento intervalo tem estas configurações:

String Descrição
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ãoData 1 e 2: Duas datas que você quer usar no cálculo.

A função DateDiff pode ser usada para determinar quantos intervalos de tempo
especificados existem entre duas datas. Por exemplo, você poderia usar DateDiff para
calcular o número de dias entre duas datas ou o número de semanas entre o dia de hoje e o
final do ano.
Se quiser saber o número de dias entre date1 e date2, você pode usar tanto o Dia do Ano
("y") como o Dia ("d").
Quando interval é Dia da Semana ("w"), DateDiff retorna o número de semanas entre as
duas datas. Se date1 cair numa segunda-feira, DateDiff contará o número de segundas-
feiras até a date2. Ele conta date2, mas não date1. Se, contudo, interval for Semana ("ww"),
a função DateDiff retornará o número de semanas do calendário entre as duas datas. Ele
conta o número de domingos entre date1 e date2. DateDiff contará date2 se ela cair num
domingo; mas não contará a date1, mesmo que caia num domingo.
Se date1 se referir a um ponto no tempo posterior à date2, a função DateDiff retornará um
número negativo.
Se data for um literal de data (uma data entre sinais numéricos (#)), o ano, se especificado,
se tornará uma parte permanente dessa data. Contudo, se data estiver entre aspas ("") e você
omitir o ano, o ano atual será inserido no código sempre que a expressão data for avaliada.
Isto torna possível escrever um código que pode ser usado em anos diferentes.

DatePart: extrai de uma determinada data uma parte dela relativo a dia, mês, semana, quinzena,
etc.
Sintaxe: ParteDaData = DatePart(<intervalo>, <expressãoData>)

Intervalo pode ser:

String Descrição
yyyy Ano

34
 q Trimestre
m Mês
y Dia do ano
d Dia
w Dia da semana
ww Semana
h Hora
n Minuto
s Segundo

ExpressãoData: Datas que você quer usar na função.

DataSerial: Retorna uma data para um dia, mês e ano especificados, ou seja, informe cada item
separado que a função monta a data.
Sintaxe: VariavelData = DateSerial(<ano>, <mês>, <dia>)

DateValue: Retorna a data especificada numa string, ou seja, converte uma variável String para
o tipo Data.
Sintaxe: VariávelData = DateValue(<VariávelStringDeData>)

Day: Retorna o dia do mês referente a uma data.

Sintaxe: VariávelNumérica = Day(<expressãoData>)

Hour: Retorna a hora de uma expressão de data e hora.

Sintaxe: VariávelNumérica = Hour(<ExpressãoHora>)

Minute: Retorna o minuto de uma expressão de data e hora.

Sintaxe: VariávelNumérica = Minute(<ExpressãoHora>)

Month: Retorna o mês de uma data.

Sintaxe: VariávelNumérica = Month(<ExpressãoData>)

Now: Retorna a data e a hora correntes do sistema operacional.

Sintaxe: VariávelData = Now

Second: Retorna os segundos de uma expressão de data e hora.

Sintaxe: VariávelNumérica = Second(<ExpressãoHora>)

Time: Retorna a hora corrente do sistema operacional.

Sintaxe: VariávelData = Time

Timer: Calcula a quantidade de segundos passados desde a meia noite.

Sintaxe: VariávelNumérica = 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.
Sintaxe: VariávelData = 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.
Sintaxe: VariávelNumérica = WeekDay(<ExpressãoData>)

Year: Retorna o ano de uma data.

35
 Sintaxe: VariávelNumérica = Year(<ExpressãoData>)

6.10. Funções de Formatação

Formata uma expressão qualquer de acordo com a máscara estabelecida na função.
Sintaxe: ExpressãoFormatada = Format(<expressão>[, <Mascara de formatação>)

6.10.1. 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 país de acordo com o que foi estabelecido no painel de controle.
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.

Veja abaixo os caracteres que podem ser usados na máscara para formatação de valores
numéricos:

0 (zero): 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.

# (sustenido): 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, não será exibido nada 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.

. (ponto): Espaço reservado para decimal.

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.

% (porcentagem): 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.

36
, (vírgula): 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 separadores de
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 (" ").

\ (barra invertida): 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:
1) Caracteres de formatação de data e hora (a, c, d, h, m, n, p, q, s, t, w, y e /:);
2) Caracteres de formatação numérica (#, 0, %, E, e, vírgula e ponto);
3) Caracteres de formatação de seqüências de caracteres (@, &, <, >, e !).

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.

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.

Fixed: Exibe pelo menos um dígito à esquerda e dois dígitos à direita do separador de
casa decimal.

37
 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.

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.

Scientific: Usa a notação científica padrão.

6.10.2. Formatação de Expressões Lógicas

Yes/No: Exibe “No” se o número for 0; caso contrário, exibe “Yes”.

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”.

6.10.3. 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:

: (dois pontos): 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.

/ (barra): 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.

d Exibe o dia como um número sem zeros à esquerda.

dd Exibe o dia como um número com zeros à esquerda.

ddd Exibe o dia da semana como uma abreviado em 3 letras.

dddd Exibe o dia da semana como um nome completo.

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.

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.

38
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.

mmm Exibe o mês como um abreviado em três letras.

mmmm Exibe o mês como um nome completo.

q Exibe o trimestre do ano como um número.

y Exibe o dia do ano como um número.

yy Exibe o ano como um número de dois dígitos.

yyyy Exibe o ano como um número de quatro dígitos.

h Exibe a hora como um número sem zeros à esquerda.

hh Exibe a hora como um número com zeros à esquerda.

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.

ttttt 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

Também podemos formatar data e hora utilizando as palavras chaves.

General Date: Exibe a data e a hora nos formatos estabelecidos nas configurações do
Windows.

Long Date: Exibe uma data de acordo com o formato por extenso de data de seu sistema.

Medium Date: Exibe uma data usando o formato médio de data apropriado para a versão
de idioma do aplicativo host.

Short Date: Exibe uma data usando o formato abreviado de data de seu sistema.

Long Time: Exibe uma hora usando o formato por extenso de hora de seu sistema: inclui
horas, minutos, segundos.

Medium Time: Exibe uma hora no formato 12 horas usando horas e minutos e a
designação AM/PM.

Short Time: Exibe uma hora usando o formato 24 horas.

39
6.10.4. Formatação de Expressões String
As manipulações de expressões String podem ser formatadas usando os caracteres
especiais abaixo:

@ (arroba): 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.

& (“e” comercial): 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.

! (exclamação): Força preenchimento da esquerda para a direita dos espaços reservados.

O preenchimento padrão é feito da direita para a esquerda.

< (sinal de menor): Exibe todos os caracteres no formato de minúsculas.

> (sinal de maior): Exibe todos os caracteres no formato de maiúsculas.

40
7. TRATAMENTO DE ERROS
A coisa mais irritante para o usuário é quando ele executa alguns comandos dentro de um
programa e, de repente, o programa mostra uma mensagem de erro e finaliza, sem ao menos
permitir salvar ou coisa assim.
No Visual Basic não é diferente, quando ocorre um erro no programa, ele simplesmente mostra
uma mensagem, e finaliza o programa.
Para evitar isso, podemos tratar os erros dentro de um procedimento. Vejamos um exemplo:

Private Sub Command1_Click()

Dim Result As Single

Result = CSng(Text1.Text) / CSng(Text2.Text)

End Sub

Quando clicarmos em Command1, o programa simplesmente executa uma divisão. Aparentemente

não tem nenhum erro nesta sub-rotina, porém, se o valor de Text2 for 0 (zero)? Se isto acontecer,
aparecerá a mensagem que está na Figura 8:

Figura 8

É claro que, para este problema, nós já podemos prever o erro, e testar antes se o denominador é 0
ou não. Mas no caso de alguns códigos mais complexos, seria interessante colocarmos um
tratamento de erro nesta sub-rotina, através da instrução On Error.
A instrução On Error apresenta-se em 3 formas:

- On Error Goto label

Quando esta linha é executada, qualquer erro que ocorrer dentro da subrotina, será desviado
para o label definido. Depois que ocorreu o erro, existe dois comandos que nos auxiliam para tratar
o erro. O primeiro é o Resume, que volta para a linha que ocorreu o erro. O segundo é o Resume
Next, que executa a próxima linha de onde ocorreu o erro.

- On Error Resume Next

Quando esta linha é executada, qualquer erro que ocorrer dentro da subrotina, será ignorado, e
será executada a próxima linha.

- On Error Goto 0
Quando esta linha é executada, é desabilitado o tratamento de erro.

41
Quando ocorre um erro, podemos ter algumas informações, a partir das propriedades do objeto Err.
São elas:
Err.Number => Número do erro.
Err.Description => Descrição do erro.
Err.Source => Objeto que gerou o erro.

Exemplo:
Sub Divide (a as integer, b as integer)

Dim c as integer
On Error goto diverr
c=a/b
exit sub

diverr:
Msgbox Err.Description

End Sub

42
8. ARQUIVOS
No Visual Basic, temos vários comandos para manipulações de arquivos. Abaixo estão alguns
deles:

Abrir arquivos: Open

Fechar arquivos: Close
Cópias de arquivos: FileCopy
Obter informações sobre um arquivo: EOF, FileAttr, FileDateTime, FileLen, FreeFile, GetAttr,
Gerenciar arquivos: Dir, Kill, Name
Ler de um arquivo: Get, Input, Input #, Line Input #
Tamanho do arquivo: FileLen
Escrever em um arquivo: Print #, Put, Write #

Dentre os comandos acima, somente os mais importante serão comentados:

O comando Open é um deles. É com este comando que iremos abrir o arquivo, seja ele para leitura
ou escrita.
Sintaxe: Open pathname For mode [Access access] [lock] As [#]filenumber [Len=reclength]
Pathname: nome do arquivo
Mode: Append, Binary, Input, Output ou Random
Access: Read, Write ou Read Write
Lock: Shared, Lock Read, Lock Write ou Lock Read Write
Filenumber: Um número válido entre 1 e 511. Este número pode ser obtido através da função
Freefile.
Reclength: Tamanho em bytes do registro

Temos vários comandos que podemos ler ou escrever de um arquivo. Abaixo veremos alguns
exemplos deles:
Exemplo1: No exemplo abaixo é feita a leitura de um arquivo linha por linha, e escrito em um
outro arquivo.

FlIn = FreeFile
Open “c:\autoexec.bat” For Input As #FlIn

FlOut = FreeFile
Open “c:\autoexec.bck” For Output As #FlOut

Do While (Not EOF(FlIn))

Line Input #FlIn, Aux
Print #FlOut, Aux
Loop

Close

Exemplo2: No exemplo abaixo é feita a leitura do arquivo inteiro, e escrito em um outro arquivo.

FlIn = FreeFile
Open “c:\autoexec.bat” For Input As #FlIn

FlOut = FreeFile

43
 Open “c:\autoexec.bck” For Output As #FlOut

Aux = Input(LOF(FlIn), # FlIn )

Print #FlOut, Aux

Close

Exemplo3: No exemplo abaixo é feita a leitura de um arquivo caractere por caractere, e escrito em
um outro arquivo.

FlIn = FreeFile
Open “c:\autoexec.bat” For Input As #FlIn

FlOut = FreeFile
Open “c:\autoexec.bck” For Output As #FlOut

Do While (Not EOF(FlIn))

Aux = Input(1, # FlIn )
Print #FlOut, Aux
Loop

Close

44
9. PROGRAMAS EXTERNOS E BIBLIOTECAS
9.1. Manipulação de programas externos
Para a manipulação de programas externo (exe), utilizaremos a função Shell do Visual Basic.
Sua sintaxe é:
Retorno = Shell(nome_programa, modo_exibição)
Retorno – Número contendo o ID do processo
Nome_programa – Nome completo do arquivo a ser executado (exe)
Modo_exibição – Forma que será executado. Esta forma está descrita na tabela abaixo:

Constante Valo Descrição

r

vbHide 0 A janela é ocultada e o foco passa para a janela oculta.

vbNormalFocus 1 A janela tem foco e é restaurada a seu tamanho e

posição originais.

vbMinimizedFocus 2 A janela é exibida como um ícone com foco.

vbMaximizedFocus 3 A janela é maximizada com foco.

vbNormalNoFocus 4 A janela é restaurada a seu tamanho e posição mais

recentes. A janela ativa no momento permanece ativa.

vbMinimizedNoFocus 6 A janela é exibida como um ícone. A janela ativa no

momento permanece ativa.

9.2. Manipulação de bibliotecas externas

No Visual Basic, também é possível utilizar bibliotecas (dll) que foram criadas em outras
linguagens como, por exemplo, em C ou Fortran. Para isso, é necessário fazer a declaração da
função exportada da biblioteca dentro do código. Abaixo, segue a sintaxe de como é possível
fazer isso.

Sintaxe 1
Declare Sub name Lib "libname" [Alias "aliasname"] [([arglist])]

Sintaxe 2
Declare Function name Lib "libname" [Alias "aliasname"] [([arglist])] [As type]

Onde:
Libname – Nome do arquivo (dll). Caso o arquivo se encontre no diretório em que foi iniciado o
programa, ou dentro do System do Windows, só precisa colocar o nome do arquivo.
Aliasname – “Apelido” de como a função ou sub-rotina é chamada.

Name, arglist e type segue a mesma regra para Sub ou Function.

45
10. UTILIZANDO A ÁREA DE TRANSFERÊNCIA
O Visual Basic permite a utilização da área de transferência através do objeto Clipboard. Este
objeto tem métodos que permite a manipulação de dados na área de transferência.
Podemos obter o conteúdo da Área de Transferência através dos métodos GetData ou GetText.
Para colocar um dados na Área de Transferência, podemos utilizar os métodos SetData ou SetText.
O método Clear limpa o conteúdo da Área de Transferência.

46
11. ALGUNS COMPONENTES ACTIVEX
A partir de agora, veremos que nem sempre o que se encontra na barra de ferramentas é suficiente
para desenvolvermos nossos aplicativos. Para isso, contamos com outros componentes que não
estão na barra de ferramentas. Estes componentes são os famosos ActiveX (ocx).

11.1. CommonDialog

Este, com certeza, é o mais utilizado dos ActiveX. Este componente é responsável pelas
caixas de diálogos que aparece para seleção de arquivos na hora de abrir ou salvar, de fontes,
impressoras, cores e help. Este componente é invisível em Run time.
Cada uma dessas caixas se apresenta, de acordo com o método invocado.
- ShowOpen – Caixa de diálogo para seleção de um arquivo para ser aberto.
- ShowSave – Caixa de diálogo para seleção de um arquivo para ser salvo.
- ShowColor – Caixa de diálogo para seleção de uma cor.
- ShowFont – Caixa de diálogo para seleção de uma fonte.
- ShowHelp – Invoca o mecanismo de ajuda do Windows.

Abaixo, temos as propriedades mais utilizadas:

Flags: Nesta propriedade é que configuramos nossa caixa de diálogo como ela irá aparecer.
Exemplo: Para obrigar o usuário a entrar com um arquivo para ser salvo em que o caminho
deva existir, e que perguntar para ele se quer sobrescrever um arquivo já existente,
escreveríamos...
CommonDialog1.Flags = cdlOfnPathMustExist Or cdlOfnOverwritePrompt

Nota: Para colocarmos mais de um flag, utilizamos o operador Or.

Filter: Este flag contém o filtro que irá aparecer para o usuário dos arquivos que serão
selecionados. Para isso, colocamos sempre uma descrição e, separado por “|”, o filtro.
Exemplo: CommonDialog1.Filter = “Text file|*.txt|All files|*.*”

CancelError: Caso esta propriedade esteja com True, toda a vez que o botão Cancel for
pressionado, irá gerar um erro. Este erro gera o número 32755, que possui uma constante que é
a cdlCancel. Caso esta propriedade esteja com False, este erro não ocorre.

11.2. MaskEdBox

Este componente é semelhante ao TextBox, porém, ele tem uma propriedade

chamada Mask em que permite ser configurado uma máscara, para que o usuário preencha o
dado de acordo com a máscara. A figura acima, por exemplo, é uma máscara para telefone.
Cada “#” permite que o usuário entre com um número.

47
11.3. MsFlexGrid

Este componente é um grid, que permite que trabalhemos com linhas e colunas. Não permite a
edição do usuário, porém é de fácil manipulação. Pode ser configurado o alinhamento das
células, tamanho, cor, etc.

11.4. SSTab

Este componente agrupa outros componentes em cada um de seus “Tabs”. É bastante prático
para trabalhar com telas em que se têm diversos campos, podendo separar por categorias.

Existem muitos outros componentes que são bastante utilizados. Citei somente estes acima como
exemplo, porém, qualquer componente (ocx e dll) que se encontre em seu micro pode ser utilizado.
No Visual Basic, também é possível construir componentes, porém isso não será visto neste
módulo.

48
12. UTILIZANDO WIN32 API COM VB
Todos já ouviram falar de API, mas afinal o que significa isso.
A API são as siglas de Application Programming Interface.
Quando falamos que vamos trabalhar utilizando a API do Windows, não estamos fazendo nada
mais do que utilizar as funções que se encontram nas bibliotecas do Windows, como a win32.dll,
kernel32.dll, etc.
Mas, para que possamos trabalhar com as funções de uma biblioteca, precisamos saber o seu nome
e a sua estrutura. No Help do MSDN, temos as descrições de todas as funções. Por exemplo, a
função que lê o conteúdo de um arquivo .ini. Esta função, desenvolvida em C encontra-se dentro
da kernel32.dll.
DWORD GetPrivateProfileString(
LPCTSTR lpAppName, // points to section name
LPCTSTR lpKeyName, // points to key name
LPCTSTR lpDefault, // points to default string
LPTSTR lpReturnedString, // points to destination buffer
DWORD nSize, // size of destination buffer
LPCTSTR lpFileName // points to initialization filename
);

Para utilizarmos esta função dentro do Visual Basic, teríamos que fazer uma equivalência dos tipos
de dados que são utilizados no Visual C e no VB. A declaração no Visual Basic ficaria assim:
Public Declare Function GetPrivateProfileString Lib "kernel32" Alias "GetPrivateProfileStringA"
(ByVal lpApplicationName As String, ByVal lpKeyName As Any, ByVal lpDefault As String, ByVal
lpReturnedString As String, ByVal nSize As Long, ByVal lpFileName As String) As Long

Bom, na verdade, eu nem tentei verificar as equivalências entre as duas linguagens. Quando o
Visual Basic é instalado, ele traz um aplicativo chamado API Viewer. Para iniciar este aplicativo,
vá no botão Start => Program => Microsoft Visual Basic 6.0 => Microsoft Visual Basic Tools
=> API Text Viewer.
Com este aplicativo, é só selecionar o nome da função que ele já traz a declaração em Visual Basic
para utilizar, depois é só clicar no botão Copy e em seguida, colar o código dentro do seu
aplicativo.

Figura 9 – Interface do API Viewer

49
13. ACESSANDO BANCO DE DADOS
No Visual Basic, temos várias formas de acessar Banco de Dados.
A mais prática (e a forma que veremos neste curso) é através do componente Data. Este
componente economiza uma séria de linhas de programação, fazendo o intercâmbio entre os
controles de um formulário com a tabela do Banco de Dados.
As duas propriedades principais deste controle são: DatabaseName e RecordSource.
DatabaseName: Nesta propriedade selecionamos o nome do banco de dados que será manipulado.
RecordSource: Nesta propriedade deve ser selecionado o nome da tabela que será manipulada pelo
objeto Data.

Agora podemos manipular os campos através de TextBox, por exemplo. Para isso, temos que
alteras algumas propriedades:
DataSource: Origem dos dados. Aqui é informado o nome da controle data que possui a tabela que
vamos manipular.
DataField: Nome do Campo. Na caixa de combinação que aparece, esta o nome de todos os
campos da tabela existente no controle data. Escolha o campo que corresponda com a caixa de
texto selecionada.

Pronto. Não precisa digitar nada na codificação do programa. Com somente este passos já temos
pronto um programa que altera os dados da tabela, pois tudo que for digitado nas caixa de texto
será inserido automaticamente dentro dos registros da tabela. Use o controle data para avançar ou
voltar, ir para o primeiro registro ou o último.

Porém, se for necessário, pode ser utilizado as propriedades e os métodos para a manipulação dos
dados.

50
14. “DEBUGANDO” UM PROGRAMA
Depois que já vimos bastante coisa sobre como criar um programa, vamos ver agora como
podemos utilizar o ambiente do Visual Basic para poder depurar um programa.

Na figura acima, temos algumas linhas de códigos, e uma linha vermelha. Esta linha é um
Breakpoint. Para inseri-lo, ou retira-lo, pode ser através da tecla F9 ou clicando sobre a barra cinza
que se encontra à esquerda do código.

Durante a execução do programa, ao chegar nesta linha o programa para sua execução, e podemos
ver o conteúdo das variáveis parando o mouse em cima adicionando a variável para uma janela em
que possamos acompanhar o seu valor. Na figura abaixo, foi selecionado um Array, com os nomes
dos meses do ano.

Na janela seguinte, podemos editar a variável que estamos analisando. Nesta janela podemos ver
mais 2 outras opções em Watch Type:
- Break When Value Is True: Esta opção faz com que a execução do programa pare no momento
em que alguma condição seja verdadeira. É interessante para depurar Loops.

51
- Break When Value Change: Esta opção faz com que a execução do programa pare no momento
em que o valor da variável sofra alguma alteração.

52
ANEXO
Algumas sugestões para nome de componentes e de variáveis:

Componentes
ComboBox cbo
CheckBox chk
CommandButton cmd
DirListBox dir
DriveListBox drv
Data dta
FileListBox fil
Frame fme
Form frm
Image img
Label lbl
Line lin
ListBox lst
OLE ole
OptionButton opt
PictureBox pic
ScrollBar scr
Shape shp
Timer tim
TextBox txt

Variaveis
Byte bt
Boolean b
Integer i
Long l
Single sn
Double d
Currency c
Decimal dec
Date dt
Object obj
String s
Variant var

53