Linguagem de programação
Sumário Sumário ................................................................................................................... 1 Introdução ............................................................................................................... 5 O que é o Visual Basic ?...................................................................................... 5 Linguagem Baseada em Eventos ........................................................................ 5 Linguagem Baseada em Objetos......................................................................... 5 Ambiente de Desenvolvimento ............................................................................ 6 Ambiente do Visual Basic........................................................................................ 6 Janela Principal ................................................................................................... 6 Linguagem Visual Basic .......................................................................................... 6 Barra de Título ..................................................................................................... 7 Barra de Objetos (controles)................................................................................ 7 Janela de Propriedades ....................................................................................... 8 Janela de Projetos ............................................................................................... 9 Janela de Código............................................................................................... 10 Funções e Sub-Rotinas ..................................................................................... 10 Formulário.......................................................................................................... 11 Menus ................................................................................................................ 11 Menu File ....................................................................................................... 11 Menu Edit ....................................................................................................... 12 Menu Project .................................................................................................. 13 Menu Format .................................................................................................. 15 Menu Debug................................................................................................... 15 Menu Run....................................................................................................... 16 Menu Tools .................................................................................................... 16 Menu Add-Ins................................................................................................. 16 Menu Window ................................................................................................ 17 Menu Help...................................................................................................... 17 Barra de Ferramentas........................................................................................ 17 Janelas .................................................................................................................. 18 Janela de Projetos ............................................................................................. 18 Janela de Propriedades ..................................................................................... 19 Janela de Posicionamento do Formulário.......................................................... 20 Linguagem Visual Basic ........................................................................................ 20 Variáveis ............................................................................................................ 20
Página 1 de 69
Linguagem de programação
O que são Variáveis ? .................................................................................... 20 Declaração de Variáveis ................................................................................ 21 Abrangência e Tempo de Vida de uma Variável................................................ 23 Tipos de Variáveis ............................................................................................. 24 Tipos Integer e Long ...................................................................................... 25 Tipos Single e Double .................................................................................... 26 Tipo Currency................................................................................................. 26 Tipo String...................................................................................................... 26 Tipo Byte ........................................................................................................ 27 Tipo Boolean .................................................................................................. 27 Tipo Date........................................................................................................ 27 Tipo Object..................................................................................................... 27 Tipo Variant.................................................................................................... 27 Constantes......................................................................................................... 28 Operadores........................................................................................................ 29 Operadores Aritméticos.................................................................................. 29 Operadores Relacionais................................................................................. 30 Operadores Lógicos ....................................................................................... 30 Operadores de Strings ................................................................................... 31 Estruturas de programação ................................................................................... 31 Estruturas de desvio condicional ....................................................................... 32 Instrução If...Then...Else ................................................................................ 32 Instrução Select Case........................................................................................ 34 Estruturas de repetição...................................................................................... 35 Instrução While...Wend .................................................................................. 35 Instrução Do...Loop ........................................................................................ 36 Instrução For...Next........................................................................................ 37 Instrução For Each...Next............................................................................... 38 Instrução Exit ................................................................................................. 39 Funções e Procedimentos..................................................................................... 41 O que é uma Função ? ...................................................................................... 41 O que é um Procedimento ? .............................................................................. 43 Passando Parâmetros ....................................................................................... 43 Passagem de Parâmetros por Valor ou por Referência..................................... 45 Parâmetros Opcionais ....................................................................................... 46
Página 2 de 69
Linguagem de programação
Número Indefinido de Parâmetros ..................................................................... 46 Funções Internas do Visual Basic ......................................................................... 47 Mais utilizadas ................................................................................................... 47 Funções Alfa-numéricas .................................................................................... 48 Funções de data e hora ..................................................................................... 48 Comandos mais utilizados..................................................................................... 49 Função MsgBox................................................................................................. 49 Função InputBox................................................................................................ 52 Instrução Unload................................................................................................ 53 Objetos .................................................................................................................. 54 A Terminologia do Visual Basic ......................................................................... 54 Propriedade, Método e Evento....................................................................... 54 Formulários........................................................................................................ 55 Controles ........................................................................................................... 56 Módulos ............................................................................................................. 57 Projeto ............................................................................................................... 57 Propriedades e Eventos mais Utilizados............................................................ 57 Propriedades.................................................................................................. 57 Eventos .......................................................................................................... 58 Controles ........................................................................................................... 58 As Propriedades Principais do CheckBox ...................................................... 59 As Propriedades Principais do ComboBox..................................................... 59 As Propriedades Principais do CommandButton ........................................... 60 As Propriedades Principais do Data............................................................... 60 As Propriedades Principais do Form.............................................................. 60 As Propriedades Principais do Frame ............................................................ 62 As Propriedades Principais do HScrollBar ..................................................... 62 As Propriedades Principais do Image ............................................................ 62 As Propriedades Principais do Label.............................................................. 62 As Propriedades Principais do ListBox........................................................... 63 As Propriedades Principais do OptionButton ................................................. 63 As Propriedades Principais do PictureBox ..................................................... 63 As Propriedades Principais do TextBox ......................................................... 63 As Propriedades Principais do Timer ............................................................. 64 As Propriedades Principais do VScrollBar ..................................................... 64
Página 3 de 69
Linguagem de programação
CommandButton ................................................................................................ 64 Label .............................................................................................................. 65 TextBox .......................................................................................................... 65 Frame............................................................................................................. 65 Adicionando um Frame em um Formulário .................................................... 66 Desenhando controles dentro do Frame ........................................................ 66 Check Box...................................................................................................... 66 OptionButton .................................................................................................. 66 ListBox ........................................................................................................... 67 ComboBox ..................................................................................................... 67 ScrollBar......................................................................................................... 67 Timer .............................................................................................................. 68 Image ............................................................................................................. 68
Página 4 de 69
Linguagem de programação
Introdução O que é o Visual Basic ? O Visual Basic é um compilador do tipo QuickBasic para criação de aplicativos para Windows, ele é na realidade, uma aplicação do próprio Windows. É dessa forma que os programas em Visual Basic podem ser criados, rodados, depurados e compilados diretamente no Windows. O Visual Basic possibilita aos usuários a programação baseada em eventos e objetos. Isto quer dizer que o programador coloca na janela todas as opções (menus, botões, ícones, controles, etc...) para que o usuário selecione uma delas com o mouse ou com o teclado. Antes do Visual Basic uma aplicação era desenvolvida em linguagem C, juntamente com o Kit de Desenvolvimento de Software do Windows, o que demandava muito tempo de aprendizagem.
Linguagem Baseada em Eventos Ao darmos um clique com o mouse em um determinado objeto de um aplicativo Visual Basic, por exemplo um botão, estamos gerando um evento dentro do Windows o qual fará com que um determinado pedaço de código seja executado. Podemos, também, colocar da seguinte maneira: um determinado pedaço de código foi executado em decorrência de um evento gerado com o clique do mouse. Se o tal botão nunca for apertado aquele código poderá jamais ser executado. Programadores de linguagens voltadas para DOS, estão acostumados a escrever códigos que são executados de maneira sequencial, ou seja, o programa é orientado por sequência, isto quer dizer que as linhas de código são executadas uma após a outra durante todo o programa. Enquanto o programa não chega na última linha de código ele não para a não ser que o usuário intervenha finalizando o programa antes que ele termine. No Windows é diferente. Não existe um corpo de programa com início, meio e fim. O programa é orientado por eventos. Normalmente, um programa para Windows apresenta várias opções possíveis na tela para que o usuário as selecione conforme sua necessidade, representando, assim, um modo completamente novo de se programar. O Visual Basic é uma linguagem baseada em eventos. Isso quer dizer que o responsável pelo fluxo do programa é o usuário e não mais o programador. Devemos ter isso em mente quando estivermos projetando um aplicativo. Na programação orientada por sequência, normalemente o usuário entra com os dados na sequência determinada pelo programador. O Visual Basic permite que o usuário entre com os dados na ordem que preferir.
Linguagem Baseada em Objetos Outra característica importante do Visual Basic é a de ser uma linguagem baseada em objetos. As linguagens como o C++ e o Pascal por exemplo, também baseadas em objetos, possuem classe e herança. No Visual Basic, os objetos são pré-definidos, isto é, já existe uma coleção de objetos que acompanham o
Página 5 de 69
Linguagem de programação
software. Para criar novos objetos, o programador deverá utilizar a opção User Control como sendo o tipo de projeto a ser realizado. Os novos objetos só poderão ser criados a partir de um outro objeto já existente, portanto basicamente esse novo objeto terá as mesmas características do objeto que serviu de base. Para criar objetos capazes de realizar funções diferentes dos objetos existentes, você deverá criá-los em linguagem C. Dentro do Visual Basic, os objetos são, por exemplo, menus, janelas, botões, quadros de texto, etc... Melhor especificados no capítulo sobre objetos. Cada um dos objetos possui várias propriedades, métodos e eventos associados à eles.
Ambiente de Desenvolvimento O ambiente de programação do Visual Basic é composto pelas seguintes janelas: Janela Principal, Caixa de Ferramentas, Janela de Propriedades, Janela de Projeto, Janela de Código e Formulário. É através dessas janelas que podemos escolher os objetos que farão parte do nosso programa, configurar suas propriedades conforme a especificação do programa, escolher os eventos que serão utilizados, etc.
Ambiente do Visual Basic Janela Principal Essa janela é a responsável pelo controle geral do ambiente de programação do Visual Basic e contém uma barra de ferramentas e de menus. O menu Help, fornece informações sobre todos os objetos e características do Visual Basic. Está também disponível, através da tecla "F1" um Help On-Line, no qual podemos obter informações detalhadas de um objeto previamente selecionado. Através desses recursos, também podemos obter informações sobre a linguagem QuickBasic utilizada no Visual Basic. Com a barra de ferramentas, temos um acesso mais rápido das funções do menu mais utilizadas.
Linguagem Visual Basic
Página 6 de 69
Linguagem de programação
Barra de Título A barra de título é a barra horizontal localizada no topo da tela; ela informa o nome do aplicativo e é comum a todos os aplicativos Windows da Microsoft. Interações entre o usuário e a barra de título são manipuladas pelo Windows e não pelo aplicativo. Tudo o que está abaixo da barra de título e da barra de menu, em um aplicativo Windows, é chamado de área do cliente. Seu aplicativo é totalmente responsável pela aparência, conteúdo e resposta dos objetos que você alojou nessa área.
Barra de Objetos (controles) Essa barra está localizada à esquerda da tela do Visual Basic, logo abaixo da barra de ferramentas e possui os objetos gráficos (botões, caixas de texto, caixa de figura, etc...) disponíveis para serem utilizados dentro do projeto. O Visual Basic chama esses objetos de controles. O ambiente que você está utilizando pode apresentar mais figuras do que o mostrado abaixo. Isso deve-se ao fato de o Visual Basic ser um ambiente de programação aberto e extensível, ou seja, além dos controles disponíveis no Visual Basic, podemos adquirir outros controles fornecidos por outras empresas ou construir o nosso próprio controle.
Página 7 de 69
Linguagem de programação
Janela de Propriedades As propriedades definem as características de cada objeto - controle da aplicação. O conjunto de propriedades depende do controle selecionado. Por exemplo, um formulário tem propriedades diferentes de uma figura. As propriedades podem ser alteradas em tempo de projeto ou de execução, sendo que algumas delas somente em tempo de execução. Para alterar o valor de uma propriedade em tempo de execução só por meio de programação a ser carregada através de um objeto, por exemplo um botão ou assim que o programa for carregado, já em tempo de projeto, devemos: 1. Selecionar o controle cuja propriedade deseja alterar; 2. Rolar pela lista de propriedades até encontrar a propriedade desejada; 3. Digitar o novo valor; 4. Pressionar ENTER para confirmar a alteração efetuada.
Página 8 de 69
Linguagem de programação
Janela de Projetos Esssa janela possui uma lista dos arquivos que estão sendo utilizados dentro do programa que estamos desenvolvendo. Podemos ter arquivos com extensões "BAS" , "FRM" ,"VBP" e outros dentro dessa janela. O Visual Basic organiza os trabalhos por projeto, permitindo que cada projeto possa ter vários módulos.
Página 9 de 69
Linguagem de programação
Janela de Código Essa janela con- tém a declaração de variáveis, constantes e rotinas. Na figura ao lado, po- demos ver dois quadros combo, um contendo a lista de objetos dentro do nosso programa e o outro uma lista de eventos disponíveis para cada um dos objetos. Podemos observar na figura que o evento selecionado é o "Click" e o objeto é o formulário. O comando Beep na linguagem do Visual Basic gera um aviso originário do alto-falante do PC. Portanto cada vez que o usuário der um clique com o mouse no formulário o procedimento "Form_Click( )" será executado e gerará um "beep".
Funções e Sub-Rotinas As funções (functions) e sub-rotinas (subs) são chamadas de procedimentos (procedures). Existem três tipos de procedimentos: 1.) do Visual Basic; 2.) associados aos eventos; 3.) criados pelo programador. Os procedimentos do Visual Basic são, por exemplo, os métodos, as funções matemáticas, as funções manipuladoras de "Strings", etc. Os procedimentos associados aos eventos são aqueles procedimentos que são chamados em resposta a um evento. Adicionamos códigos a eles através da Janela de Código do formulário. Os procedimentos criados pelo programador são aquelas subrotinas e funções utilizadas para melhorar a estruturação do código. Podemos ter, por exemplo, uma função que abre um arquivo. Essa função trataria os possíveis erros e retornaria o número do arquivo aberto. Esse procedimento estaria declarado dentro do objeto "General" da Janela de Código de um formulário ou de um módulo. Dentro do Visual Basic, a diferença entre uma função e uma subrotina é que a função retorna um valor e a sub-rotina não.
Página 10 de 69
Linguagem de programação
Formulário Essa é a janela do nosso aplicativo. Quando o usuário iniciar o programa, a mesma aparecerá. A janela possui os quadros minimizar, maximizar, fechar e menu de controle. É nessa janela que colocaremos os controles gráficos (botões, quadros de texto, etc) e também o código associado a esses objetos. Para abrir uma janela de código, basta dar um duplo clique em cima do objeto do qual um evento deve ser tratado.
Menus Menu File Você precisará do menu principal File para trabalhar com os arquivos que compõem seu projeto. Esse menu inclui comandos para salvar, abrir e imprimir arquivos. O menu File também permite que você saia do Visual Basic através de um item para isso, a outra maneira é utilizando as teclas de combinação do Windows ALT + F4 quando estiver posiconado na barra de menu principal. Como em qualquer aplicativo Windows, você também poderá abrir a caixa de controle na barra de menu e escolher Exit ou dar um duplo clique nessa caixa. A maioria dos itens do menu principal File é útil apenas quando você inicia o desenvolvimento de seu próprio aplicativo. Abaixo segue um breve resumo sobre os itens para orientá-lo melhor:
Página 11 de 69
Linguagem de programação
Menu Edit Abaixo segue um breve resumo sobre os itens para orientá-lo melhor:
Página 12 de 69
Linguagem de programação
Menu Project O menu Project comtém itens que possibilitam a inserção de vários procedimentos, janelas, códigos, módulos, etc. em seus projetos. Abaixo segue um breve resumo sobre os itens para orientá-lo melhor:
Página 13 de 69
Linguagem de programação
Página 14 de 69
Linguagem de programação
Menu Format
Menu Debug
Página 15 de 69
Linguagem de programação
Menu Run
Menu Tools
Menu Add-Ins O menu Add-Ins lhe permite acessar ferramentas separadas que podem ser incorporadas ao Visual Basic. Existem dois Add-Ins fornecidos com várias versões do Visual Basic. O Report Manager, que é representado pelo software da empresa Seagate Crystal Reports, atualmente na versão 7.0, é uma ferramenta completa para modificar e criar relatórios que você poderá utilizar em seu programa. A outra ferramenta inclusa é o Visual Data Manager, que é usado para gerenciamento de Banco de Dados. Utilize o Add-In Manager para adicionar e remover Add-Ins do menu.
Abaixo segue um breve resumo sobre os itens para orientá-lo melhor:
Página 16 de 69
Linguagem de programação
Menu Window
Menu Help
Barra de Ferramentas
Página 17 de 69
Linguagem de programação
Janelas Janela de Projetos Esta janela comtém informações sobre o projeto em uso. É nela que serão exibidos todos os projetos utilizados ao mesmo tempo, caso existam, ou o único projeto aberto. Abaixo do projeto, estarão definidos os nomes dos formulários em uso no projeto.
Você notará que existem dois nomes independentemente do que estiver sendo exibido nesta janela. O primeiro nome é o nome lógico (nome dado ao objeto) e o segundo nome é o nome físico (nome dado ao arquivo), este estará sendo exibido sempre entre parênteses.
Página 18 de 69
Linguagem de programação
Ainda nesta janela através das ícones, temos a possibilidade de ir até a janela de código, (janela em que se programa as atividades para os objetos), voltar para o modo de exibição do formulário e também exibir os formulários em formato de pastas de um projeto.
Janela de Propriedades É nesta janela que o programador altera as características originais dos objetos utilizados no(s) formulário(s) do programa. Quando se cria um objeto dentro do formulário, devemos selecioná-lo clicando apenas uma vez nele mesmo no formulário e depois clicar na janela de propriedades, onde serão isoladas apenas as propriedades do objeto selecionado. Então o programador irá alterar algumas das propriedades adequando assim o objeto a ficar com as características e aparência desejada.
Esta mesma janela, possui uma caixa combo situada ao topo. Esta caixa contém o nome de todos os objetos utilizados no formulário em desenvolvimento. Esta é a outra forma do programador localizar e selecionar o objeto para trabalhar com suas propriedades sem ter que selecioná-lo no formulário.
Página 19 de 69
Linguagem de programação
Obs: As propriedades dos objetos também podem ser alteradas através de programação na janela de código, para que os objetos sofram as alterarações no decorrer do programa, devido aos eventos em que foram programados.
Janela de Posicionamento do Formulário É através desta janela que o programador posiciona o local em que o formulário aparecerá assim que o programa for executado. Outra maneira de fazer isto, é acessando a propriedade do formulário Startup Position e escolher a opção CenterScreen, mas não será possível acessar esta propriedade, caso esteja sendo usado um formulário do tipo MDI. Então o posicionamento deverá ser feito através de programação ou por esta janela.
Linguagem Visual Basic Variáveis O que são Variáveis ? Toda linguagem de programação precisa de algum lugar para armazenar o resultado de seus cálculos ou simplesmente para controlar o fluxo do programa. Assim como acontece na álgebracotidiana, as linguagens de programação se valem de variáveis para armazenar dados na memória do computador.Uma variável de memória nada mais é do que uma posição da memória do computador reservada exclusivamente para que sejam guardadas informações e dados. A essa posição de memória damos um nome para referência dentro do nosso programa, como por exemplo, NomeCliente. Quem controla qual posição de memória do computador será reservada é a própria linguagem e o sistema operacional, ou seja, devemos apenas nos preocupar em nomear e declarar as
Página 20 de 69
Linguagem de programação
variáveis. E já que estamos falando de variáveis, quando formos nomeá-las, deveremos seguir algumas regras básicas:
O nome precisa iniciar com uma letra.
Somente são permitidas letras, números e o caractere de sublinhado. Qualquer sinal de pontuação e espaço em branco será inválido.
No Visual Basic 6.0, os nomes podem ter até 255 caracteres de comprimento. Isso significa que podemos ter nomes de variáveis bem descritivos, como por exemplo, PrimeiroNomeDoCliente.
Não podem coincidir com uma palavra reservada do Visual Basic, como nomes de funções ou procedimentos.
Precisam ser únicos dentro do escopo atual, ou seja, não podemos ter duas variáveis com o mesmo nome dentro de uma rotina, porém, entre rotinas diferentes, isso é perfeitamente possível.
Escolha nomes sugestivos para as variáveis, de tal forma que descrevam sua função ou conteúdo que será armazenado nelas. Por exemplo, para uma variável onde seria armazenado o resultado do cálculo do salário de um funcionário, poderíamos escrever nSalarioFunc, em vez de X, Y ou Z. Acostume-se a iniciar o nome de uma variável com uma combinação de até três letras em minúsculo que identifica o seu tipo de dado. Por exemplo, para uma variável do tipo string, utilize a combinação "str", para uma variável numérica inteira utilize "int", e assim por diante. Veja os seguintes exemplos: strNomePrograma = "Controle de Despesas Domésticas" lngSaldoInicial = 125080
Declaração de Variáveis Embora você possa ir criando variáveis a medida que for precisando, é aconselhável que declare todas as variáveis que irá utilizar em seu programa. Isso torna o programa mais estruturado e menos propenso a erros, como por exemplo, ocorrências de alterações indevidas do valor de uma variável entre chamadas de rotinas. Quando declaramos uma variável, um escopo é atribuído a ela, ou seja, é determinada sua abrangência (visibilidade) e tempo de vida (existência). No Visual Basic 6.0, utilizamos o comando de declaração Dim para declararmos uma variável, dando-lhe assim um nome e definindo o seu tipo de dado e escopo. A sintaxe completa é: Dim NomeVariável [ As TipoDado ] NomeVariável representa um nome válido para variáveis. Já a cláusula opcional As permite que seja definido o tipo de dado que a variável armazenará. Os tipos de dados disponíveis serão vistos mais à frente. Você pode deixar para o Visual Basic declarar implicitamente as variáveis. Assim você simplesmente cria as
Página 21 de 69
Linguagem de programação
variáveis à medida que for precisando. Por exemplo, suponhamos que você tenha a seguinte função que calcula a média entre dois números:
Function Media ( PrimeiroNumero , SegundoNumero ) intSoma = PrimeiroNumero + SegundoNumero Media = intSoma / 2 End Function Neste caso, a variável Soma não fora declarada. Agora imagine que por questão de descuido, você tenha digitado o seguinte:
Function Media ( PrimeiroNumero , SegundoNumero ) intSomar = PrimeiroNumero + SegundoNumero Media = intSoma / 2 End Function A função não seria executada, uma vez que está tentando utilizar uma variável, no caso intSoma, que não possui qualquer valor, já que o mesmo fora atribuído à variável intSomar. Para evitar esse tipo de problema (apenas um entre vários possíveis), é aconselhável declarar-se todas as variáveis que serão utilizadas pela rotina (procedimento ou função). Portanto, o correto seria escrever a função da seguinte forma:
Function Media ( PrimeiroNumero , SegundoNumero ) Dim intSoma intSoma = PrimeiroNumero + SegundoNumero Media = intSoma / 2 End Function Você pode forçar o Visual Basic a verificar se todas as variáveis foram declaradas previamente e, em caso negativo, apresentar uma mensagem de advertência. Isso é possível através da inclusão do comando Option Explicit na seção Declarations da classe, formulárioou módulo. Podemos também selecionar a opção Options, do menu Tools, e ativar a caixa de seleção Require Variable Declaration, na página Editor. Isso fará com que em todo módulo novo, porém não em módulos existentes, seja incluído o comando Option Explicit.
Página 22 de 69
Linguagem de programação
Abrangência e Tempo de Vida de uma Variável Dois termos muito utilizados na programação são abrangência e tempo de vida das variáveis. Esses termos definem o limite da visibilidade de uma variável e o tempo em que ela poderá reter seu valor. A isso chamamos de escopo. Abrangência refere-se à(s) parte(s) do código do programa onde uma determinada variável é visível, ou seja, onde ela pode ser acessada. Isso significa que podemos ter variáveis cujos valores somente poderão ser acessados e/ou alterados pelo procedimento/função que as declarou e em nenhuma outra parte do programa. Isso evita que outras rotinas do programa possam alterar inadvertidamente os valores dessas variáveis. Essas variáveis são ditas locais à rotina. Para declarar uma variável local à rotina, seja ela um procedimento (Sub) ou função (Function), utilize o comando de declaração Dim ou Staticdentro da mema, como no fragmento de código a seguir:
Function CalculaSaldo ( dSaldoAntes , dSaldoDebito ) Dim dblNovoSaldo as Double End Function Podemos ter também variáveis que são visíveis apenas pelas rotinas existentes num módulo e não pelas rotinas de outros módulos da aplicação. Essas variáveis possuem escopo local ao módulo inteiro. Você declara variáveis locais a nível de módulo através dos comandos de declaração Dim ou Private, colocados na seção Declarations do módulo. Veja o seguinte exemplo:
Private strSenha as String Para tornar uma variável disponível a todos os módulos e a todas as rotinas, você deverá declará-la na seção Declarations de qualquer um dos módulos com o comando Public, como mostra o exemplo:
Public strSenha as String A esse tipo chamamos de variável de escopo global, ou seja, qualquer rotina de qualquer módulo tem acesso a ela. O tempo de vida de uma variável diz respeito ao tempo em que ela poderá reter seu valor entre as diversas chamadas do procedimento/função. Quando uma variável é declarada e a ela é atribuído um valor, esse valor se perde quando a rotina encerra sua execução. Em outras palavras, a variável é criada quando se entra na rotina e destruída quando se sai da mesma. Há, porém, situações onde devemos manter o valor da variável entre as chamadas. Suponhamos por exemplo, que você esteja programando um pequeno jogo e que tenha criado uma rotina para controle dos pontos acumulados. Você precisará de uma maneira de preservar os pontos já marcados entre as chamdas da rotina. Desse modo, a variável, embora não seja global, não
Página 23 de 69
Linguagem de programação
perde seu valor após o retorno da rotina ao código que a invocou. A esse tipo, damos o nome de variável estática. Para declarar uma variável estática, utilize o comando de declaração Static, conforme mostrado no exemplo:
Function Pontos ( intMarcados ) Static lngPontosAcumulados as Long lngPontosAcumulados = lngPontosAcumulados + intMarcados Pontos = lngPontosAcumulados End Function Se você precisar, por um motivo ou outro, declarar todas as variáveis de uma rotina como sendo estáticas, coloque a palavra reservada Static à frente do nome do procedimento/função, da seguinte forma:
Static Function Pontos ( intMarcados ) Dim lngPontosAcumulados as Long lngPontosAcumulados = lngPontosAcumulados + intMarcados Pontos = lngPontosAcumulados End Function Devemos lembrar que você deverá utilizar variáveis com o escopo mais local possível, para assim evitar conflitos de nomes de variáveis e alterações de valores indesejáveis.
Tipos de Variáveis Como toda linguagem de programação, o Visual Basic também possui vários tipos de dados aplicáveis às variáveis, que definem quais os valores que essas poderão armazenar. O Visual Basic 6.0 define 11 tipos de dados básicos, cada qual com suas características peculiares, como largura da faixa de dados, tamanho em bytes, etc. A tabela a seguir, relaciona todos esses tipos: Tipo de
Página 24 de 69
Linguagem de programação
Os tipos de dados determinam o que você pode armazenar numa variável. Por exemplo, você não pode entrar com uma expressão caractere numa variável do tipo numérico, nem digitar um número numa variável lógica. Vejamos os detalhes dos tipos de dados mais comumente utilizados.
Tipos Integer e Long Esses dois tipos de dados permitem o armazenamento de valores numéricos inteiros, com os quais podemos efetuar cálculos e operações matemáticas. A faixa de valores permitida para o tipo Integer vai de -32.768 à 32.767, sendo portanto limitada para alguns tipos de operações. Variáveis desse tipo são muito úteis como contadores de loops For...Next, por serem de manipulação muito rápida pelo processador, pois necessitam de poucas instruções de máquina. O tipo Long, por outro lado, abrange uma faixa muito maior de valores, da ordem de 2 milhões, conforme pode ser constatado na tabela anterior.
Página 25 de 69
Linguagem de programação
Tipos Single e Double Single e Double também são tipos de dados numéricos, porém permitem a manipulação de valores decimais, como pesos, unidades de medidas, etc. Como os tipos anteriores, podemos efetuar qualquer operação matemática com eles. O que diferencia o tipo Single do tipo Double é a precisão nas casas decimais e a faiza de valores abrnagida por cada um. Veja a tabela anterior para comparação. Variáveis do tipo Single são ditas de precisão simples, comumente chamadas apenas de variáveis de ponto-flutuante. Variáveis do tipo Double são denominadas variáveis de dupla precisão.
Tipo Currency O Visual Basic possui um tipo de dado especial para tratamento de valores monetários, evitando-se assim erros de arredondamento durante cálculos matemáticos. Esse tipo de dado é chamado de Currency. Deve-se utilizá-lo apenas para armazenamento de valores monetários. Se num determinado cálculo, o valor resultante tiver mais de quatro casas decimais, as casas decimais extras (a partir da quinta casa) serão truncadas. Assim, o número 5402,105782 por exemplo, será armazenado como 5402,1057 numa variável do tipo Currency.
Tipo String O tipo de dado String é certamente o mais utilizado. Ele possibilita que uma sequência de caracteres seja armazenada numa variável. Essa sequência de caracteres pode conter desde letras do alfabeto até símbolos gráficos e números, muito embora não possamos efetuar cálculos com os números armazenados numa sequência. Devemos envolver a cadeia de caracteres com aspas ("). Com variáveis do tipo caractere, é possível efetuarmos algumas operações de comparação, concatenação (junção) de duas ou mais sequências de caracteres ou extração de uma parte da sequência. Não é possível, porém efetuar cálculos matemáticos e aritméticos, já que qualquer número armazenado numa variável desse tipo será considerado como uma sequência de texto e não um valor numérico. Podemos determinar um tamanho máximo para uma variável do tipo String, simplesmente adicionando um asterisco (*) seguido por um número que define o tamanho máximo em caracteres. Por exemplo, para declarar uma variável strNomeCliente com um tamanho máximo de 50 caracteres, você escreveria: Dim strNomeCliente As String * 50 Se for armazenado uma cadeia de caracteres menor que o tamanho máximo especificado, a variável será preenchida com espaços em branco à direita para completá-la. Se por outro lado, você tentar armazenar mais caracteres do que o permitido, os excedentes serão descartados.
Página 26 de 69
Linguagem de programação
Tipo Byte Variáveis do tipo Byte são também numéricas, mas somente podem armazenar números na faixa de 0 à 255. Esse tipo de variável também é útil em contador de loops For...Next pequenos, cujo ciclo de repetição não ultrapasse 255.
Tipo Boolean Uma variável do tipo Boolean pode conter apenas dois tipos de valores: True (verdadeiro) ou False (falso). São muito utilizadas como sinalizadores, ou seja, variáveis que indicam se uma determinada condição lógica retornou ou resultou num desses dois valores.
Tipo Date Variáveis do tipo Date permitem o armazenamento de valores que representam uma data do calendário ou um horário. Para armazenar uma data numa variável, especifique-a entre "#", como no seguinte exemplo:
dtDataVencimento = #05/06/99# dtHora = #05:25:00# Com valores do tipo Date é possível executarmos adição ou subtração, para assim calcularmos uma nova data. Por exemplo:
dtDataHoje = Now dtDataAmanha = dtDataHoje + 1 dtDataOntem = dtDataHoje - 1
Tipo Object Variáveis do tipo Object podem fazer referência a objetos definidos pelo Visual Basic ou mesmo campos de uma base de dados, como dados OLE ou binários. Elas são armazenadas em endereços de 32 bits. Para esse tipo de variável, precisamos utilizar o comando de atribuição Set para assinalar valores a ela, em não apenas o sinal de igualdade. O exemplo a seguir, ilustra sua utilização:
Dim objDataBase As Object Set objDataBase = OpenDataBase ("C:\VIDEO\VIDEO.MDB")
Tipo Variant O dado Variant é um tipo especial, já que ele permite que qualquer valor seja armazenado. Se você declara uma variável mas não especifica seu tipo de dado,
Página 27 de 69
Linguagem de programação
o Visual Basic automaticamente atribui a ela o tipo Variant. Assim, o dado que você armazenar na variável é que definirá o seu tipo naquele momento. Podemos atribuir também um valor nulo a variáveis Variant, especificando a palavra-chave Null à direita do sinal de igual. Diversas funções podem ser utilizadas para determinarmos qual o tipo de dado armazenado numa variável Variant.
Constantes As constantes, diferentemente das variáveis, não podem ter seus valores alterados durante a execução da aplicação. Elas são utilizadas principalmente para fornecer maior legibilidade ao código fonte, substituindo expressões numéricas ou caracteres mais complexos e de difícil entendimento. Suponhamos como exemplo, que você tenha o seguinte código:
Dim intNumeros ( 30 ), intContador As Integer For intContador = 1 to 30 intNumeros ( intContador) = intContador * 10
Next Se amanhã você precisasse modificar sua aplicação, aumentando o número máximo de elementos da matriz intNumeros, teria de percorrer toda a listagem do programa e alterar as ocorrências do número 30 para a quantidade desejada de elementos. Utilizando uma constante, esse problema seria facilmente resolvido. Você poderia incluir a seguinte linha na seção Declarations do módulo principal do programa:
Const Num_Elementos= 30 E no código do programa, escreveria: Dim intNumeros ( Num_Elementos ), intContador As Integer For intContador = 1 to Num_Elementos intNumeros ( intContador) = intContador * 10
Next No caso de modificações futuras, será necessário apenas alteração na definição da constante e uma nova compilação.
Página 28 de 69
Linguagem de programação
O resto ficará por conta do Visual Basic. Um dos tipos de constantes mais famoso é o valor de PI (3,14159265358979...)
Operadores De nada adiantaria termos dados e mais dados armazenados em nossas variáveis de memória ou em nosso banco de dados, se não pudéssemos trabalhar com eles, ou seja, se não fosse possível fazer cálculos, comparações ou qualquer outra operação. Para efetuarmos essas operações é que existem os operadores. Eles podem ser divididos em quatro categorias básicas:
Operadores Aritméticos;
Operadores Relacionais;
Operadores Lógicos;
Operadores de Strings.
Operadores Aritméticos Como ocorre na matemática comum, os operadores aritméticos permitem que sejam feitos cálculos com os dados armazenados em variáveis ou em campos de bases de dados. Eles somente podem ser utilizados com dados numéricos. A tabela a seguir, relaciona todos os operadores aritméticos disponíveis no Visual Basic. Operadores
Descrição
+
Adição
-
Subtração
*
Multiplicação
\
Divisão
/
Divisão com retorno apenas do valor inteiro
Mod
Resto da divisão
Estes operadores respeitam uma ordem de precedência universal: 1ª. Exponenciação 2ª. Multiplicação e Divisão 3ª. Adição e Subtração O operador Mod é utilizado para se encontrar o resto de uma divisão não exata. Por exemplo, na divisão de 19 por 3, o resultado seria 6,333333 e mesmo assim
Página 29 de 69
Linguagem de programação
não seria um resultado preciso, já que se trata de uma dízima periódica. Assim se multiplicássemos 6,333333 por 3, obteríamos 18,999999. Com o operador Mod na expressão 19 Mod 3, teremos como resultado o número 1, ou seja, o resto da divisão de 19 por 3. Isso significa que se você multiplicar a parte inteira de 6,333333, que é 6, e somar o resultado ao resto obtido, no caso o número 1, terá novamente o valor 19.
Operadores Relacionais Os operadores relacionais, também chamados de operadores de comparação, permitem que relacionemos (comparemos) dois valores entre si. Por exemplo, para saber se o valor de uma determinada variável X é maior que o de uma variável Y, poderíamos escrever:
X>Y Isso nada mais é que uma comparação entre as duas variáveis. A seguinte tabela, lista todos os operadores relacionais do Visual Basic. O funcionamento de cada um deles não difere daquele empregado na matemática comum.
Operadores Lógicos Os operadores Lógicos como o próprio noem já diz, avaliam uma expressão numérica ou caractere e retornam valores lógicos, ou seja, verdadeiro ou falso. Por exemplo, se uma variável, digamos X, possui o valor 100 e uma outra variável Y , possui o valor 500, então a expressão a seguir avaliará verdadeiro. X = 100 And Y = 500 A tabela a seguir, apresenta todos os operadores lógicos do Visual Basic: Operadores
Descrição
Página 30 de 69
Linguagem de programação
And
Efetua a operação lógica E. Se ambas as expressões forem verdadeiras, então o resultado será verdadeiro.
Or
Efetua a operação lógica OU. Se uma das expressões (ou ambas) for verdadeira, então o resultado será verdadeiro.
Not
Efetua a operação lógica NÃO. Inverte o estado lógico de uma expressão, se ela for verdadeira, torna-a falsa e viceversa.
Xor
Efetua a operação lógica OU EXCLUSIVO. Se uma das expressões for verdadeira, o resultado será verdadeiro,porém se ambas forem verdadeiras, o resultado será falso.
Eqv
Efetua a operação de equivalência de expressões. Oresultado será verdadeiro somente se ambas as expressões forem equivalentes.
Imp
Efetua a operação de implicação lógica. Retorna verdadeira se uma expressão implica em outra.
Operadores de Strings No Visual Basic, somente é permitido dois tipos de operadores para se trabalhar com strings, muito embora ambos possuam o mesmo efeito. São os operadores "&" e "+". Esses operadores servem para concatenar duas ou mais strings de caracteres. Por exemplo, suponhamos que você tenha definido duas variáveis strings Rua e Bairro. Para agrupar os seus valores numa única variável Endereço, você poderia utilizar um dos seguintes métodos:
Endereco = Rua & " " & Bairro Endereco = Rua + " " + Bairro
Estruturas de programação O Visual Basic é considerado uma linguagem de programação por possuir estruturas de controle bem definidas. Basicamente temos duas classes de estruturas: As estruturas de repetição e estruturas de desvio condicional. Estas estruturas são representadas por instruções de comando do Visual Basic.
Página 31 de 69
Linguagem de programação
Estruturas de desvio condicional Instrução If...Then...Else Executa condicionalmente um grupo de instruções, dependendo do valor de uma expressão. Sintaxe:
If condition Then [statements] [Else elsestatements] Ou você pode usar a sintaxe em forma de bloco:
If condition Then [statements]
[ElseIf condition-n Then [elseifstatements] ...
[Else [elsestatements]] End If A instrução If...Then...Else possui as seguintes partes: Condition: Obrigatória Um ou mais dos dois tipos de expressão a seguir: Uma expressão numérica ou expressão de seqüência que avalia como True ou False. Se condition for Null, ela será tratada como False. Uma expressão do formato TypeOf objectname Is objecttype. O objectname é qualquer referência de objeto e objecttype é qualquer tipo de objeto válido. A expressão será True se objectname for o tipo de objeto especificado por objecttype; caso contrário, será False. Statements: Opcional na forma de bloco; obrigatória na forma de uma linha que não possua cláusula Else. Uma ou mais instruções separadas por dois-pontos; executadas se condition for True. Condition-n :Opcional. Igual a condition. Elseifstatements: Opcional. Uma ou mais instruções executadas se condition-n associada for True.
Página 32 de 69
Linguagem de programação
Elsestatements: Opcional. Uma ou mais instruções executadas se nenhuma expressão condition ou condition-n anterior for True. Comentários Você pode usar a forma de uma linha (primeira sintaxe) para testes simples e curtos. Entretanto, a forma de bloco (segunda sintaxe) proporciona mais estrutura e flexibilidade do que a forma de uma linha e normalmente é mais fácil de ler, manter e depurar. Observação: Com a forma de uma linha, é possível ter múltiplas instruções executadas como resultado de uma decisão If...Then. Todas as instruções devem estar na mesma linha e separadas por dois-pontos, como na seguinte instrução:
If A > 10 Then A = A + 1 : B = B + A : C = C + B
Uma instrução If em forma de bloco deve ser a primeira em uma linha. As partes Else, ElseIf e End If da instrução podem ter somente um número de linha ou rótulo de linha precedendo-as. O bloco If deve ser encerrado com uma instrução End If. Para determinar se uma instrução é ou não um bloco If, examine o que segue a palavra-chave Then. Se qualquer coisa exceto um comentário aparecer depois de Then na mesma linha, a instrução será tratada como instrução If de uma linha. A cláusulas Else e ElseIf são opcionais. Você pode ter quantas cláusulas ElseIf desejar em um bloco If, mas nenhuma pode aparecer depois de uma cláusula Else. As instruções do bloco If podem ser aninhadas, isto é, contidas uma dentro da outra. Executando um bloco If (segunda sintaxe), condition é testada. Se condition for True, as instruções seguintes a Then são executadas. Se condition for False, cada condição ElseIf (se houver) será avaliada alternadamente. Quando uma condição True for localizada, as instruções imediatamente seguintes à Then associada serão executadas. Se nenhuma das condições ElseIf for True (ou se não houver cláusulas ElseIf), as instruções seguintes a Else serão executadas. Depois da execução das instruções seguintes a Then ou Else, a execução continua com a instrução seguinte a End If. Dica: Select Case pode ser mais útil na avaliação de uma expressão única com diversas ações possíveis. No entanto, a claúsula TypeOf objectname Is objecttype não pode ser usada com a instrução Select Case. Observação: TypeOf não pode ser usada com tipos de dados incondicionais, como Long, Integer e outros diferentes de Object.
Página 33 de 69
Linguagem de programação
Instrução Select Case Executa um dos diversos grupos de instruções, dependendo do valor de uma expressão. Sintaxe
Select Case testexpression [Case expressionlist-n [statements-n]] ... [Case Else [elsestatements]] End Select
A sintaxe da instrução Select Case possui as seguintes partes: Testexpression Obrigatória. Qualquer expressão numérica ou expressão de seqüência. expressionlist-n Obrigatória se aparecer Case. Lista delimitada de uma ou mais das seguintes formas: expression, expression To expression, Is comparisonoperator expression. A palavra-chave To especifica um intervalo de valores. Se você usar a palavra-chave To, o valor menor deve aparecer antes de To. Use a palavra-chave Is com operadores de comparação (exceto Is e Like) para especificar um intervalo de valores. Se não for fornecida, a palavra-chave Is será inserida automaticamente. statements-n Opcional. Uma ou mais instruções são testexpression coincidir com qualquer parte de expressionlist-n.
executadas
se
elsestatements Opcional. Uma ou mais instruções são executadas se testexpression não coincidir com qualquer das cláusulas Case. Comentários Se testexpression coincidir com qualquer expressão Case expressionlist, as statements seguintes àquela cláusula Case serão executadas até a próxima cláusula Case, ou, para a última cláusula, até End Select. Então o controle passa para a instrução seguinte a End Select. Se testexpression coincidir com uma
Página 34 de 69
Linguagem de programação
expressão expressionlist em mais de uma cláusula Case, somente as instruções seguintes à primeira coincidência serão executadas. A cláusula Case Else é usada para indicar as elsestatements a serem executadas se não for encontrada coincidência entre testexpression e uma expressionlist em qualquer das outras seleções Case. Embora não seja necessário, é uma boa idéia ter uma instrução Case Else no seu bloco Select Case para tratar valores testexpression não previstos. Se nenhuma Case expressionlist corresponder a testexpression e não houver instrução Case Else, a execução continua na instrução seguinte a End Select. Você pode usar múltiplas expressões ou intervalos em cada cláusula Case. Por exemplo, a linha a seguir é válida:
Case 1 To 4, 7 To 9, 11, 13, Is > MaxNumber Observação O operador de comparação Is não é igual à palavra-chave Is usada na instrução Select Case. Você também pode especificar intervalos e múltiplas expressões para seqüências de caracteres. No exemplo a seguir, Case corresponde a seqüências que são exatamente iguais a tudo, seqüências que ficam entre nozes e sopa em ordem alfabética e o valor atual de TestItem:
Case "tudo", "nozes" To "sopa", TestItem As instruções Select Case podem ser aninhadas. Cada instrução Select Case aninhada deve ter uma instrução End Select correspondente.
Estruturas de repetição Instrução While...Wend Executa uma série de instruções desde que uma determinada condição seja True. Sintaxe
While condition [statements] Wend A sintaxe da instrução While...Wend possui as seguintes partes: Condition Obrigatória. Expressão numérica ou expressão de seqüência que avalia como True ou False. Se condition for Null, ela será tratada como False.
Página 35 de 69
Linguagem de programação
statements Opcional. Uma ou mais instruções executadas enquanto a condição for True. Comentários Se condition for True, todas as statements serão executadas até que a instrução Wend seja encontrada. Então o controle retorna para a instrução While e condition é novamente verificada. Se condition ainda for True, o processo é repetido. Se não for True, a execução continua com a instrução seguinte à instrução Wend. Os loops While...Wend podem ser aninhados a qualquer nível. Cada Wend corresponde ao mais recente While. Dica A instrução Do...Loop fornece um meio mais estruturado e flexível para executar um loop.
Instrução Do...Loop Repete um bloco de instruções enquanto uma condição é True ou até que ela se torne True. Sintaxe
Do [{While | Until} condition] [statements] [Exit Do] [statements] Loop Ou você pode usar a sintaxe a seguir:
Do [statements] [Exit Do] [statements] Loop [{While | Until} condition] A sintaxe da instrução Do Loop possui as seguintes partes: Condition Opcional. Expressão numérica ou expressão de seqüência que seja True ou False. Se condition for Null, ela será tratada como False. Statements Uma ou mais instruções que são repetidas enquanto, ou até que, condition seja True.
Página 36 de 69
Linguagem de programação
Comentários Qualquer número de instruções Exit Do pode ser posicionado em qualquer lugar em Do…Loop como alternativa para sair de um Do…Loop. Exit Do é freqüentemente usada após a avaliação de alguma condição, por exemplo, If…Then, caso em que a instrução Exit Do transfere o controle para a instrução imediatamente após o Loop. Quando usada dentro de instruções Do…Loop aninhadas, Exit Do transfere o controle para o loop que está aninhado em um nível acima do loop onde ocorre Exit Do.
Instrução For...Next Repete um grupo de instruções um número específico de vezes. Sintaxe
For counter = start To end [Step step] [statements] [Exit For] [statements] Next [counter] A sintaxe da instrução For…Next possui as seguintes partes: Counter Obrigatória. Variável numérica usada como um contador de loops. A variável não pode ser um Boolean ou um elemento da matriz. Start Obrigatória. Valor inicial de counter. End Obrigatória. Valor final de counter. Step Opcional. A quantidade em que counter é alterado sempre que passa pelo loop. Se step não for especificado, o padrão será um. Statements Opcional. Uma ou mais instruções entre For e Next que são executadas conforme o número de vezes especificado. Comentários O argumento step pode ser positivo ou negativo. O valor do argumento step determina o processamento do loop como a seguir: Valor O loop é executado se Positivo ou 0 counter <= end
Página 37 de 69
Linguagem de programação
Negativo counter >= end Depois que todas as instruções do loop foram executadas, step é adicionado a counter. Neste ponto, as instruções do loop são executadas novamente (baseadas no mesmo teste que causou a execução inicial do loop) ou o loop sai e a execução continua com a instrução seguinte à instrução Next. Dica A alteração do valor de counter enquanto dentro de um loop pode dificultar a leitura e depuração do código. Qualquer número de instruções Exit For pode ser posicionado em qualquer lugar do loop como meio alternativo de sair. Muitas vezes, Exit For é usada depois da avaliação de alguma condição, por exemplo, If...Then, e transfere o controle para a instrução imediatamente seguinte a Next. Você pode aninhar loops For...Next posicionando um dentro do outro. Dê um nome de variável exclusivo como seu counter a cada loop. A construção a seguir é correta:
For I = 1 To 10 For J = 1 To 10 For K = 1 To 10 ... Next K Next J Next I Observação Se você omitir counter em uma instrução Next, a execução continua como se counter estivesse incluído. Se uma instrução Next for encontrada antes de sua instrução For correspondente, ocorrerá um erro.
Instrução For Each...Next Repete um grupo de instruções para cada elemento em uma matriz ou coleção. Sintaxe
For Each element In group [statements] [Exit For] [statements]
Página 38 de 69
Linguagem de programação
Next [element]
A sintaxe da instrução For...Each...Next possui as seguintes partes: Element Obrigatória. Variável usada para iterar através dos elementos da coleção ou matriz. Para coleções, element pode ser somente uma variável Variant, uma variável de objeto genérica ou qualquer variável de objeto específica. Para matrizes, element somente pode ser uma variável Variant. Group Obrigatória. Nome de uma coleção ou matriz de objetos (exceto uma matriz de tipos definidos pelo usuário). Statements Opcional. Uma ou mais instruções que são executadas em cada item de group. Comentários O bloco For...Each é inserido se houver pelo menos um elemento em group. Uma vez inserido o loop, todas as suas instruções são executadas para o primeiro elemento em group. Se houver mais elementos em group, as instruções do loop continuam a ser executadas para cada elemento. Quando não houver mais elementos em group, o loop sai e a execução continua com a instrução seguinte à instrução Next. Qualquer número de instruções Exit For pode ser posicionado em qualquer lugar do loop como um meio alternativo para sair. Muitas vezes, Exit For é usada depois de se avaliar alguma condição, por exemplo, If...Then, e transfere o controle para a instrução imediatamente seguinte a Next. Você pode aninhar loops For...Each...Next posicionando um dentro do outro. Entretanto, cada element do loop deve ser exclusivo. Observação Se você omitir element em uma instrução Next, a execução continua como se element estivesse incluído. Se uma instrução Next for encontrada antes de sua instrução For correspondente, ocorrerá um erro. Você não pode usar a instrução For...Each...Next com uma matriz de tipos definidos pelo usuário porque uma Variant não pode conter um tipo definido pelo usuário.
Instrução Exit Sai de um bloco de código Do…Loop, For...Next, Function, Sub ou Property. Sintaxe
Página 39 de 69
Linguagem de programação
Exit Do
Exit For
Exit Function
Exit Property
Exit Sub
A sintaxe da instrução Exit possui as seguintes formas: Exit Do Fornece um meio de sair de uma instrução Do...Loop. Pode ser usada somente dentro de uma instrução Do...Loop. Exit Do transfere o controle para a instrução seguinte à instrução Loop. Quando usada dentro de instruções Do...Loop aninhadas, Exit Do transfere o controle para o loop que está aninhado em um nível acima do loop onde ocorre Exit Do. Exit For Fornece um meio de sair de um loop For. Pode ser usada somente em um loop For...Next ou For Each...Next. Exit For transfere o controle para a instrução seguinte à instrução Next. Quando usada dentro de loops For aninhados, Exit For transfere o controle para o loop que está aninhado em um nível acima do loop onde ocorre Exit For. Exit Function Sai imediatamente do procedimento Function em que aparece. A execução continua com a instrução seguinte à instrução que chamou Function. Exit Property Sai imediatamente do procedimento Property em que aparece. A execução continua com a instrução seguinte à instrução que chamou o procedimento Property. Exit Sub Sai imediatamente do procedimento Sub em que aparece. A execução continua com a instrução seguinte à instrução que chamou o procedimento Sub. Comentários Não confunda instruções Exit com instruções End. Exit não define o fim de uma estrutura.
Página 40 de 69
Linguagem de programação
Funções e Procedimentos Além dos formulários, que compõem a interface com o usuário, temos por trás desses, diversas rotinas (funções e procedimentos) que executam as tarefas para as quais a aplicação fora desenhada. São essas rotinas que fazem todo o trabalho árduo de cálculos, chamadas dos formulários e execução ordenada da aplicação. É nesta etapa do desenvolvimento do aplicativo que o programador entrará com sua parte, definindo os algorítmos e a lógica geral das rotinas. Podemos concluir, portanto, que uma aplicação em Visual Basic é uma união entre os formulários e as rotinas, trabalhando amigavelmente.
O que é uma Função ? Uma função em Visual Basic, seja ela interna à própria linguagem ou desenvolvida pelo programador, é como sua similar na matemática: ela opera nos valores passados como parâmetros (se houver algum) e devolve um outro valor. Para declararmos uma função devemos utilizar a palavra-chave Function. Seguindo essa palavra-chave vem o nome da função e, opcionalmente, uma lista de eventuais parâmetros dentro de parênteses. A sintaxe completa é a seguinte:
Function NomeFunção ( [ Parâmetros ] ) Bloco de Instruções End Function Os nomes dos argumentos devem seguir as mesmas regras de nomeação de variáveis já vistas anteriormente. Eles deverão vir também separados por vírgula. Para retornarmos um valor à rotina que chamou a função, devemos atribuir esse valor ao nome da própria função. No exemplo a seguir, temos uma função que recebe como parâmetros dois números, sendo que o primeiro se refere à base e o segundo à potência à qual o número será elevado. Então ele calcula a potência do número (o próprio número multiplicado por ele mesmo) e devolve o valor à rotina chamadora. Exemplo:
Function Potencia ( intNumeroBase, intPotencia) Dim LngResultado, intContador lngResultado = 1 For intContador = 1 to intPotencia lngResultado = lgnResultado * intNumeroBase
Página 41 de 69
Linguagem de programação
Next Potencia = lngResultado End Function Na rotina chamadora, tudo que devemos fazer é atribuir o valor da função a uma variável de memória, como no exemplo:
NumElev = Potencia ( 5 , 3 ) Da mesma forma que você dá um escopo às variáveis de memória, você pode também ocultar funções no Visual Basic, criando assim, funções que somente podem ser acessadas pelos procedimentos e funções declarados no mesmo módulo. São verdadeiras caixas-pretas, uma vez que estão escondidas do resto do programa. Elas são chamadas de funções privadas. Para declarar uma função privada ao módulo, coloque a palavra-chave Private antes da declaração Function, assim:
Private Function MinhaFunc ( ) End Function Você pode especificar também o tipo de dado retornado pela função. Por exemplo, podemos alterar nossa função Potencia, vista anteriormente, para que ela retorne um número de ponto flutuante:
Function Potencia ( intNumeroBase, intPotencia ) as Single Dim LngResultado, intContador lngResultado = 1 For intContador = 1 to intPotencia lngResultado = lgnResultado * intNumeroBase Next Potencia = lngResultado End Function A variável que receberá o valor da função deve obrigatoriamente ser do mesmo tipo dessa.
Página 42 de 69
Linguagem de programação
O que é um Procedimento ? Um procedimento nada mais é do que uma rotina desenvolvida especificamente para executar uma determinada tarefa, como ocorre com as funções. Essa tarefa pode inclusive ser genérica, ou seja, servir para aplicações. Por exemplo, podemos desenvolver um procedimento para abrir um formulário e maximizá-lo na tela, independente do formulário (ou mesmo aplicativo) atualmente sendo utilizado. Podemos criar procedimentos dos mais simples até os mais sofisticados. Dependerá apenas da sua criatividade. Um procedimento, diferentemente das funções, não retorna qualquer valor à rotina chamadora. Ele pode ser encarado mais como um comando definido pelo programador/usuário, no sentido de que apenas executa a tarefa para a qual fora concebido. Você declara um procedimento através da palavra-chave Sub, seguida pelo nome do procedimento. Para finalizar o corpo do procedimento, utilize a palavra-chave End Sub. A sintaxe correta para declaração de procedimentos é:
Sub NomeProc ( [ parâmetros] ) Bloco de Instruções End Sub Veja um exemplo de procedimento:
Sub TestePot( ) Dim NumElev as Long NumElev = Potencia ( 5,4 ) Debug.Print NumElev End Sub
Passando Parâmetros Embora já tenhamos utilizado a passagem de parâmetros a procedimentos e funções, veremos neste tópico, maiores detalhes sobre esse assunto. Primeiro, você deverá especificar os parâmetros a serem recebidos através de uma lista de parâmetros colocada entre parênteses após o nome do procedimento/função. Esses parâmetros, dentro do procedimento ou função, irão comportar-se como variáveis comuns, podendo ser manipulados como tais. Vamos tomar como exemplo nossa função que calcula a potência de um dado número:
Function Potencia ( intNumeroBase, intPotencia )
Página 43 de 69
Linguagem de programação
Dim LngResultado, intContador lngResultado = 1 For intContador = 1 to intPotencia lngResultado = lgnResultado * intNumeroBase Next Potencia = lngResultado End Function Você deverá prestar bastante atenção quanto ao número de parênteses a serem passados a uma função ou procedimento, isso para evitar, por exemplo, que você passe quatro parâmetros quando na verdade a função/procedimento espera por cinco ou mais. Para invocar uma função com parâmetros, você os especifica entre os parênteses. No entanto, como veremos mais adiante, há uma maneira de se contornar esse tipo de problema. Já com procedimentos, isso muda um pouco. Se o procedimento espera apenas um parâmetro, você poderá utilizar duas formas de chamada: colocando os parâmetros entre parênteses ou diretamente após o nome do procedimento, separando-os por um espaço. Se o procedimento possuir mais de um parâmetro, então você poderá especificá-los utilizando o formato direto (sem parênteses), sendo que os parâmetros deverão ser separados por vírgulas. Você pode também chamar um procedimento passando mais de um parâmetro entre parênteses, porém deverá fazer a a chamada com a palavra-chave Call:
Sub ChamaCall ( ) Call MinhaFuncao ( "Um Texto" , "Outro Texto" , 200, 40 ) End Sub Caso deseje, poderá especificar os tipos dos parâmetros logo após a declaração dos mesmos, como mostrado a seguir:
Function Potencia ( intNumeroBase as Integer, intPotencia as Integer) Dim LngResultado, intContador lngResultado = 1 For intContador = 1 to intPotencia lngResultado = lgnResultado * intNumeroBase
Página 44 de 69
Linguagem de programação
Next Potencia = lngResultado End Function
Passagem de Parâmetros por Valor ou por Referência Procedimentos e Funções no Visual Basic podem ter ou não a capacidade de alterar o valor dos parâmetros recebidos. Para isso, podemos especificar os parâmetros por valor ou por referência. No primeiro caso, o procedimento ou função recebe uma cópia dos valores passados como parâmetros, assim qualquer alteração nesses valores não será refletida na rotina chamadora, já que as alterações afetam apenas a cópia. Para especificar uma passagem de parâmetros por valor, utilize apenas a palavra-chave ByVal Antes de cada um deles, conforme mostrado a seguir:
Sub PassaValor ( ByVal strNome as String , ByVal intIdade as Integer ) ' ' End Sub No segundo caso, o padrão do Visual Basic, o procedimento ou função pode alterar livremente os valores dos parâmetros. Essas alterações são refletidas nas variáveis da rotina chamadora após o retorno da função/procedimento. É como se passássemos o endereço da variável de memória. Não é preciso nenhuma palavra-chave para se passar um parâmetro por referência, simplesmente especifique-os na declaração da função/procedimento:
Sub PassaReferencia ( strNome as String, intIdade as Integer) ' ' End Sub Utilizando essa habilidade de alteração dos valores de parâmetros, podemos criar funções que retornam mais de um valor à rotina chamadora, ou mesmo ter procedimentos que retornam valores indiretamente. Por exemplo, no seguinte código, a função Incr( ) atualiza os valores dos dois parâmetros e os retorna.
Function Incr ( intParam1 as Integer, intParam2 as Integer) intParam1 = intParam1 + 1 intParam2 = intParam2 + 1 End Function Página 45 de 69
Linguagem de programação
Parâmetros Opcionais Popemos criar rotinas que recebem parâmetros opcionalmente, ou seja, sua passagem não é obrigatória. Para fazer isso, declare todos os parâmetros com a palavra-chave Optional à frente, como no seguinte exemplo:
Sub ParamOpcional ( Optional strNome as Variant , Optional strSobreNome as Variant ) Dim strNomeCompleto as String strNomeCompleto = strNome + " " + strSobreNome End Sub Note que os parâmetros opcionais deverão obrigatoriamente ser do tipo Variant e que se você especificar um parâmetro opcional, todos os parâmetros subsequentes a esse também precisarão ser declarados como opcionais. Isso é demonstrado no seguinte código:
Sub ParamOpcional2 ( Optional strNome as String , strSobreNome as String , Optional intIdade as Variant, Optional sngAltura as Variant ) Dim strNomeCompleto as String strNomeCompleto = strNome + " " + strSobreNome End Sub
Número Indefinido de Parâmetros Como dissemos anteriormente, você precisa especificar o número de parâmetros na chamada da rotina de acordo com a sua declaração, ou seja, se a rotina espera por cinco parâmetros, então você precisa passar cinco parâmetros na sua chamada. No entanto, o Visual Basic possibilita que, através da palavra-chave ParamArray, especifiquemos um número indefinido de parâmetros. A quantidade real de parâmetros recebidos somente será estabelecida no momento da chamada da rotina. O exemplo a seguir, demonstra como utilizar um procedimento com número indefinido de parâmetros:
Function CalcTotal ( ParamArray intQuantos( ) ) as Long Dim varElementos as Variant, lngTotal as Long
Página 46 de 69
Linguagem de programação
lngTotal = 0 For Each varElementos In intQuantos lngTotal = lngTotal + varElementos Next varElementos CalcTotal = lngTotal End Function
Funções Internas do Visual Basic Existem centenas de funções desenvolvidas internamente no Visual Basic. Abaixo encontra-se uma pequena relação das funções mais comuns:
Mais utilizadas Abs
Encontra o valor absoluto de um número.
Atn
Encontra o arco tangente.
Cos
Encontra o co-seno.
Exp
Eleva e (2,718u2) a uma potência dada.
Fix
Retorna a parte inteira de um número.
FV
Valor futuro.
Hex
Fornece o hexadecimal equivalente.
Int
Encontra o maior valor inteiro.
Ipmt Juros pagos por tempo. IRR
Taxa interna de retorno.
Log
Logarítmo comum.
Mirr
Taxa interna de retorno modificada.
Nper Tempo de acúmulo de uma anuidade. Npv
Valor presente líquido.
Pmt
Gastos com anuidade.
PV
Valor presente.
Rate Taxa de juros por período por uma anuidade. Rnd
Chama o gerar de número aleatório.
Sgn
Retorna o sinal de um número.
Sin
Retorna o seno.
Página 47 de 69
Linguagem de programação
Sln
Depreciação linear.
Sqr
Raiz quadrada.
Syd
Soma da depreciação do ano.
Tan
A tangente de um ângulo em radianos.
Timer Retorna o número de segundos desde meia-noite.
Funções Alfa-numéricas Asc
Retorna o código do caractere correspondente a primeira letra.
InStr outra.
Retorna a posição da primeira ocorrência de uma cadeia dentro de
LCase
Converte a cadeia de caracteres em minúscula.
Left Encontra ou remove um número específico de caracteres do início de uma cadeia. Len Fornece o comprimento de uma cadeia de caracteres. Ltrim Remove os espaços do início de uma cadeia de caracteres. Mid
Encontra ou remove caracteres de uma cadeia.
Right Encontra ou remove um número específico de caracteres do final de uma cadeia. Rtrim
Remove os espaços do final de uma cadeia de caracteres.
Str
Retorna a cadeia de caracteres equivalente ao número.
StrComp
Compara cadeia de caracteres.
StrConv
Converte uma cadeia de caracteres de um formulário para outro.
String
Retorna a repetição de uma cadeia de caracteres idênticos.
Trim
Remove os espaços do início e do fim de uma cadeia de caracteres.
Ucase
Converte uma cadeia de caracteres em maiúscula.
Funções de data e hora Date
Retorna a data corrente.
DateAdd
Permite que você adicione um intervalo específico a uma data.
DateDiff
Calcula diferenças entre datas.
DateSerial
Retorna uma data correspondente a um dia, mê e ano específicos.
DateValue
Transforma uma cadeia de caracteres em data.
Day Informa qual dia em uma cadeia de caracteres alfa-numéricos ou números representa.
Página 48 de 69
Linguagem de programação
Hour Informa qual hora uma cadeia de caracteres alfa-numéricos ou números representa. Minute Informa quantos minutos uma cadeia de caracteres alfanuméricos ou números representa. Month Informa qual mês uma cadeia de caracteres alfa-numéricos ou números representa. Now
Retorna a data e horário correntes.
Second Informa quantos segundos uma cadeia de caracteres alfanuméricos ou números representa. Time
Informa o horário corrente.
TimeSerial
Retorna uma variável do tipo data para o horário fornecido.
Weekday
Informa o dia da semana correspondente à data.
Year
Informa a qual ano uma data corresponde.
Comandos mais utilizados Vamos estudar os comandos mais utilizados no Visual Basic.
Função MsgBox Exibe uma mensagem em uma caixa de diálogo, aguarda que o usuário clique em um botão e retorna um Integer que indica qual botão o usuário clicou. Sintaxe
MsgBox(prompt[, buttons] [, title] [, helpfile, context]) A sintaxe da função MsgBox tem os seguintes argumentos nomeados:
Página 49 de 69
Linguagem de programação
Definições
Página 50 de 69
Linguagem de programação
O primeiro grupo de valores (0 a 5) descreve o número e o tipo de botões exibidos na caixa de diálogo; o segundo grupo (16, 32, 48, 64) descreve o estilo de ícone; o terceiro grupo (0, 256, 512) determina qual botão é o padrão e o quarto grupo (0, 4.096) determina a modalidade da caixa de mensagem. Quando estiver somando números para criar um valor final para o argumento buttons, utilize somente um número de cada grupo. Observação Essas constantes são especificadas pelo Visual Basic for Applications. Como resultado, os nomes podem ser utilizados em qualquer lugar do seu código em vez dos valores reais. Valores retornados
Página 51 de 69
Linguagem de programação
Comentários Quando helpfile e context são fornecidos, o usuário pode pressionar F1 (Windows) ou AJUDA (Macintosh) para visualizar o tópico de Ajuda que corresponde ao context. Alguns aplicativos host, por exemplo, o Microsoft Excel, também adicionam automaticamente um botão Ajuda à caixa de diálogo. Se a caixa de diálogo exibir um botão Cancelar, pressionar a tecla ESC terá o mesmo efeito que clicar em Cancelar. Se a caixa de diálogo contiver um botão Ajuda, será fornecida a ajuda sensível ao contexto relativa à caixa de diálogo. Entretanto, nenhum valor será retornado até que um dos outros botões seja clicado. Observação Para especificar mais do que o primeiro argumento nomeado, você deve utilizar MsgBox em uma expressão. Para omitir alguns argumentos posicionais, você deve incluir o delimitador de vírgula correspondente.
Função InputBox Exibe um aviso em uma caixa de diálogo, aguarda até que o usuário insira texto ou clique em um botão e retorna uma String com o conteúdo da caixa de texto. Sintaxe
InputBox(prompt[, title] [, default] [, xpos] [, ypos] [, helpfile, context]) A sintaxe da função InputBox tem os seguintes argumentos nomeados:
Página 52 de 69
Linguagem de programação
Comentários Quando helpfile e context são fornecidos, o usuário pode pressionar F1 (Windows) ou AJUDA (Macintosh) para visualizar o tópico de Ajuda que corresponde ao context. Alguns aplicativos host, por exemplo, o Microsoft Excel, também adicionam automaticamente um botão Ajuda à caixa de diálogo. Se o usuário clicar em OK ou pressionar , a função InputBox retornará o que estiver na caixa de texto. Se o usuário clicar em Cancelar, a função retornará uma seqüência de caracteres de comprimento zero (""). Observação Para especificar mais que o primeiro argumento nomeado, você deve utilizar InputBox em uma expressão. Para omitir alguns argumentos posicionais, você deve incluir o delimitador de vírgula correspondente.
Instrução Unload Remove um objeto da memória. Sintaxe
Unload object O espaço reservado object necessário representa uma expressão de objeto que é avaliada para um objeto na lista Aplica-se a. Comentários
Página 53 de 69
Linguagem de programação
Quando um objeto é descarregado, ele é removido da memória e toda a memória associada com o objeto é recuperada. Até ser substituído na memória novamente, utilizando a instrução Load, um usuário não pode interagir com um objeto e o objeto não pode ser manipulado de modo programado.
Objetos A Terminologia do Visual Basic Propriedade, Método e Evento O Visual Basic é composto de formulários e controles genericamente chamados de objetos. Cada um dos objetos possui várias propriedades listadas na Janela de Propriedades. As propriedades dos objetos nos permitem saber e modificar as características desses objetos. Por exemplo, o nome, a cor, o tamanho, a legenda, o tipo e o tamanho da fonte com que o texto aparece e sua posição, são propriedades associadas aos quadros de texto, "Labels" (legendas) e botões de controle, opção e de seleção. Ao selecionarmos um determinado objeto, dando um clique com o mouse sobre ele, a Janela de Propriedades automaticamente listará as propriedades disponíveis para aquele objeto e então poderemos modificá-las. Cada objeto reconhece as seguintes ações, tais como um clique do mouse, abertura de formulário, digitação em um quadro de texto, etc. Essas ações são chamadas de eventos. Para uma aplicação responder às ações do usuário e aos eventos do sistema, são utilizados os procedimentos associados a cada evento. Por exemplo, um botão de controle reconhece os seguintes eventos: Click
Um botão é acionado com o mouse ou com o teclado.
DragDrop
Um controle é solto em cima do botão.
DragOver
Um controle está sendo arrastado sobre o botão.
GotFocus O botão recebe a atenção do sistema, ou seja, qualquer ação do usuárioatravés do mouse ou teclado será recebida pelo botão. KeyDown sistema.
Uma tecla é pressionada enquanto o botão tem a atenção do
KeyPress
Uma tecla é pressionada e um valor AscII é retornado.
LostFocus O botão perde a atenção do sistema para outro objeto.
Página 54 de 69
Linguagem de programação
Quando um evento ocorre em uma aplicação, o sistema automaticamente reconhece o evento e executa o código associado a esse evento escrito pelo programador. Esse código é chamado de procedimento do evento ("Event Procedure"). Esse procedimento aparece na Janela de Código. O nome do procedimento associado ao evento é composto pelo nome do objeto e pelo nome do evento. O nome do objeto para todos os formulários é "Form" e para os controles é o que aparece na propriedade "Name" do controle. Devemos escrever código somente para os eventos que serão utilizados em nossa aplicação. O método é um procedimento ("Function ou Sub") que atua nos objetos. Por exemplo, um quadro de lista é um controle que possui os seguintes métodos: AddItem
Adicionar um novo item no quadro de lista durante o tempo de
execução, ou seja, quando o programa está sendo executado. Clear
Limpar o conteúdo do quadro de lista.
Move formulário.
Movimentar o quadro de lista para uma nova posição no
Refresh
Forçar uma atualização imediata o quadro de lista.
RemoveItem
Remover um item do quadro de lista.
SetFocus delista.
Fazer com que o sistema transfira sua atenção para o quadro
Formulários Os formulários são utilizados como interface com o usuário dentro de uma aplicação. Cada formulário é uma janela que pode conter controles, gráficos e outros formulários. Podemos utilizar os formulários como uma tela de ilustração, um quadro de diálogo ou como um formulário que contém outro. Podemos modificar o tamanho e localização na tela do formulário, clicando e arrastando o mouse na borda e na barra de título desse formulário, respectivamente. Além dos controles, os formulários podem conter código e variáveis. Na verdade, cada formulário possui a própria janela de código. Dentro do objeto "General" da janela de código, podemos declarar variáveis, constantes e procedimentos criados por nós. Na janela de projeto, os arquivos com extensão ".FRM" contém, cada um, um formulário, os controles contidos nele, uma lista das propriedades do formulário e dos controles, as variáveis e constantes utilizadas e o código associado. Um projeto pode conter vários formulários e podemos adicionar um novo formulário selecionando o item "Add Form" dentro do menu "Project". Podemos ter ainda outro tipo de formulário: o do tipo "MDI" (Multiple Document Interface). Esse
Página 55 de 69
Linguagem de programação
tipo de formulário pode conter outros formulários dentro dele. Cada projeto pode conter apenas um formulário do tipo "MDI". Os formulários que estão dentro do formulário "MDI" possuem a propriedade "MDIChild" como "True" e são chamados de formulários Filho. Adicionamos um formulário "MDI" ao projeto selecionando o item "Add MDI Form" dentro do menu "Project".
Controles Sao ferramentas utilizadas nos formulários para receber e mostrar informações. Os quadros de texto, botões, rótulos,quadros de figuras, etc., são exemplos de controles. Os controles disponíveis em um projeto são mostrados na Caixa de Ferramentas ("ToolBox") e possuem a extensão de arquivo "OCX". Para inserir uma ferramenta de controle em seu projeto em Visual Basic, você deve selecionar o item "Components..." dentro do menu "Project", normalmente os arquivos ".OCX", encontram-se no diretório "WINDOWS\SYSTEM", mas você pode importálos de outros diretórios normalmente. Podemos inserir um controle no formulário de trabalho de duas maneiras: 1. Dando um duplo clique com o mouse no controle localizado na caixa deferramentas; 2. Selecionar o controle na Caixa de Ferramentas. Dar um clique com o botãodo mouse na posição desejada do formulário (ponto inicial) e arrastar atéconseguir o tamanho desejado, soltando em seguida o botão (ponto final). Para os controles já localizados no formulário, podemos modificar o seu tamanho da seguinte maneira: 1. Selecionar o controle do formulário dando um clique com o mouse; 2. Apertar o botão da esquerda do mouse sobre um dos quadrados localizados na borda do controle; 3. Arrastar o mouse até o tamanho desejado; 4. Soltar o botão. Podemos mudar a posição dos controles localizados no formulário da seguinte maneira: 1. Posicionar o apontador do mouse no meio do controle; 2. Apertar o botão da esquerda do mouse e arrastar até a posição desejada; 3. Soltar o botão. Para modificar a propriedade dos controles, devemos: 1. Selecionar o controle; 2. Selecionar a propriedade desejada da Janela de Propriedades; 3. Modificar a propriedade.
Página 56 de 69
Linguagem de programação
Módulos São arquivos de extensão ".BAS" que contém declarações (variáveis e constantes) e procedimentos (funções e subrotinas). Podemos criar um módulo selecionando o item "Module" dentro do menu "Project". O Visual Basic mostra uma janela de código com o título "Module". Podemos também ver, na janela de projeto, o arquivo criado. É aconselhável trocarmos o nome padrão dado pelo Visual Basic, pois os arquivos ".BAS" são uma maneira de reaproveitarmos as mesmas funções e subrotinas para várias aplicações. Selecionando o item "Save File As..." dentro do menu "File", podemos fazer essa alteração.
Projeto É um arquivo ".VBP" que contém a lista dos fornulários, módulos e controles que compõem uma aplicação. Repetindo, a Janela de Projeto lista todos os arquivos da aplicação. Cada projeto contém pelo menos um formulário. Podemos inserir quantos formulários desejarmos dentro de um projeto. Selecionamos o item "New Project" dentro do menu "File" para criarmos um novo projeto. O Visual Basic abre esse novo arquivo com o nome padrão de "Project1.vbp" É aconselhável modificarmos esse nome, selecionando o item "Save Project As..." dentro do menu "File".
Propriedades e Eventos mais Utilizados Propriedades BackColor
Determinar a cor de fundo de um objeto.
Enabled
Determinar se o formulário ou controle podem responder aos
eventos gerados pelo usuário. Font Determinar a fonte, o estilo e tamanho a ser usada para mostrarum texto em um controle; é usada também em tempo de execução para desenhar e imprimir. ForeColor
Determiar a cor do texto impresso.
Height
Determinar a dimensão vertical externa de um objeto.
Left Determinar a distância entre a borda esquerda de um objeto e aborda esquerda do objeto que a contém. MousePointer Determinar o tipo do ponteiro do mouse mostrado quando ele estásobre uma parte específica de um formulário ou controle. Name Especificar o nome usado no código para identicar um fomulário,controle ou objeto de acesso a dados. Não está disponível emtempo de execução.
Página 57 de 69
Linguagem de programação
ToolTipText
Exibir uma janela de assistência junto ao ponteiro do mouse,
movendo-o sobre um formulário ou controle. Top Determinar a distância entre a borda interna superior de um objeto e a borda superior do objeto que o contém. Visible
Determinar se o objeto está visível ou não.
Width
Determinar a dimensão horizontal de um objeto.
Eventos Activate
Ocorre quando um formulário se tornar uma janela ativa.
Change Ocorre quando o conteúdo de uma caixa de combinação (caixa combo), barra de paginação (barra de rolagem), etiqueta, caixa de figura ou caixa de texto mudar. Click Ocorre quando o usuário pressiona e solta o botão do mouse sobre um objeto. Pode também ocorrer quando o valor do controle é modificado. DblClick
Ocorre quando o usuário dá um duplo clique com o mouse.
DragDrop Ocorre quando uma operação de " arrastar e soltar" é completada como resultado do arrastamento sobre um formulário ou controle e soltura do botão do mouse. DragOver Ocorre quando uma operação de "arrastar e soltar" está em progresso. Pode ser utilizado para monitorar se o ponteiro do mouse entra, deixa ou está diretamente sobre um alvo válido. O ponteiro do mouse determina que o objeto recebe o evento. GotFocus Ocorre quando um objeto recebe a atenção do sistema (focus). Iremos notar que um formulário recebe a atenção somente quando todos os controles visíveis estão desabilitados. KeyDown
Ocorre quando o usuário pressiona uma tecla.
KeyPress
Ocorre quando o usuário pressiona e solta uma tecla.
KeyUp
Ocorre quando o usuário solta a tecla previamente pressionada.
LostFocus Ocorre quando um objeto perde a atenção do sistema (focus). MouseDownOcorre quando o usuário pressiona o botão do mouse. MouseMove Ocorre quando o usuário movimenta o mouse. MouseUp Ocorre quando o usuário solta o botão do mouse previamente pressionado.
Controles Todos os controles possuem abreviações para facilitar a programação. Assim caso, o programador esteja lendo um artigo ou desenvolvendo um programa que
Página 58 de 69
Linguagem de programação
esteja em um livro (ou outra) fonte) e não exista uma foto ao menos da tela deste programa, ele facilmente poderá identificar os controles existentes dentro deste programa apenas acompanhando suas abreviações. Abaixo seguem as Abreviações dos Controles básicos utilizados pelo Visual Basic.
As Propriedades Principais do CheckBox Alignment
Especifica se o texto ficará do lado esquerdo da caixa.
Caption
O texto anexado ao objeto checkbox.
Enabled Habilita ou não este objeto. Estando desabilitado, não aceitará que o usuário faça evento com a caixa de checagem. Font
Escolhe uma fonte para o texto digitado no caption.
Name "chk".
Nomeia o objeto. A inicial abreviada para este tipo de controle é
Value
Determina o estado do objeto: unchecked, checked ou grayed.
As Propriedades Principais do ComboBox Style Escolhe o tipo de caixa de combinação que será utilizada: dropdown combo, simple combo, dropdownlist. 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.
Página 59 de 69
Linguagem de programação
As Propriedades Principais do CommandButton Cancel Se esta opção for ajustada como verdadeira, o botão será associado a tecla ESC e sempre que pressionarmos essa 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 desta janela e sempre que apertarmos a tecla ENTER, será como se tivéssemos clicado sobre 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 estiverem execução.
As Propriedades Principais do Data DataBaseName
Localização da base de dados a ser utilizada pelo programa.
RecordSource Associa a tabela da base de dados a ser utilizada pelos campos contidos no formulário.
As Propriedades Principais do Form Apperance
Define se o modo de exibição será 3D ou normal.
BackColor
Muda a cor de fundo do formulário.
BorderStyle Muda o tipo de borda do formulário. None: Sem borda, sem barra de título, sem menu de controle, sem botão maximizar e sem botão minimizar e não pode redimensionar a janela. FixedSingle: Borda Fixa. Aceita o menu de controle, maximizar, minimizar, barra de título e pode ser redimensionada. 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 diálogo 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, esse tipo de formulário não aparece na barra de tarefas do windows.
Página 60 de 69
Linguagem de programação
Sizable ToolWindow: Não possui o menu 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,esse tipo de formulário não aparece na barra de tarefas do windows. Caption janela).
Será o texto mostrado na barra de título do formulário (da
ControlBox Retira ou coloca o menu de controle, botão maximizar, minimizar e fechar a janela. Enabled Se esta opção estiver com False, indica que nenhum objeto desta janela, e nem a própria janela, poderão responder a eventos gerados pelo usuário, como clicar do mouse, pressionamento de teclas, etc. Font Escolhe a fonte padrão que será usada para todos os objetos inseridos neste formulário. Icon Nesta propriedade escolhemos um arquivo de ícone que irá representar o programa. 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 mestra incorporando-a. MinButton
Habilita ou não o botão de minimização.
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, ou seja, personalizada).
MousePointer Nesta propriedade especificamos o tipo de ponteiro que o mouse terá quando se mover sobre o formulário. Os tipos de ponteiro de mouse estão abaixo da tabela. Name
Nome definido para o objeto formulário.
Picture
Insere uma figura em nosso formulário.
ShowInTaskbar Habilita ou não a possibilidade da janela aparecer na barra de tarefas do windows. Visible Determina se, ao executarmos o programa, essa janela ficará visível ou invisível. WindowState Determina se, ao executarmos o programa, a janela aparecerá na tela do computador normal, maximizada ou minimizada.
Página 61 de 69
Linguagem de programação
As Propriedades Principais do Frame Caption
Coloca um texto no canto superior esquerdo da moldura.
Enabled Determina se todos os objetos colocados no interior da moldura estarão disponíveis ou não para o usuário. Name
Nome dado ao objeto.
As Propriedades Principais do HScrollBar Max
Valor máximo a ser utilizado pela barra de rolagem, geralmente 100.
Min
Valor mínimo a ser utilizado pela barra de rolagem, geralmente 0.
As Propriedades Principais do Image Picture Figura a ser exibida pelo objeto. Pode ser qualquer arquivo de imagem suportado pelo Visual Basic ou até mesmo um arquivo de ícone. Strech Possibilita que a imagem seja esticada mantendo toda a visualização possível dentro da área do objeto.
As Propriedades Principais do Label AutoSize Com esta propriedade habilitada, indicamos ao controle para redimensionar automaticamente seu tamanho do texto no label. 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. Caption A propriedade principal do label. Determina o texto que será exibido dentro do objeto. Enabled Habilita ou desabilita o objeto. Quando está em False, a cor de seu conteúdo fica acinzentada. Font
Escolhe a fonte que terá o texto digitado na propriedade caption.
ForeColor
Escolhe a cor da fonte do label.
Name Nomeia o objeto label. Como já foi dito, é importante que todos os objetos sejam nomeados. A inicial do label é "lbl". Visible
Indica se o objeto será visível ou não para o usuário.
WordWrap Quando o autosize está 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.
Página 62 de 69
Linguagem de programação
As Propriedades Principais do ListBox Propriedades Ações Columns Determina a quantidade de colunas que a caixa de listagem terá. 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 listagem serem exibidos de maneira parcial. ItemData Nesta propriedade existe uma caixa onde colocamos números relacionados com os itens existentes dentro do listbox. List Éo local onde digitamos os itens que estarão dentro do listbox. MultiSelect Quando esta propriedade estiver habilitada, significa que a caixa de listagem aceitará múltiplas seleções, ou seja, poderá ser selecionado mais de um item: none, simple e extended. Name Nome que o objeto listbox terá. A abreviação para este objeto é "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.
As Propriedades Principais do OptionButton 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 este objeto. Estando desabilitado, o usuário não poderá selecionar a opção e a cor do texto será acinzentada. Name Nomeia o objeto. A inicial abreviada para este tipo de controle é "opt". Value True para opção selecionada e False quando não está selecionada.
As Propriedades Principais do PictureBox Picture Figura a ser exibida pelo objeto. Pode ser qualquer arquivo de imagem suportado pelo Visual Basic ou até mesmo um arquivo de ícone.
As Propriedades Principais do TextBox BackColor Escolhe a cor de fundo da caixa de texto. Geralmente é branca. BorderStyle
Tipo da borda: Fixa e simples ou sem borda.
Enabled usuário.
Estando em False, o objeto não estará habilitado para interagir com o
Font
Escolhe a fonte que será mostrada dentro da caixa de texto.
Página 63 de 69
Linguagem de programação
ForeColor
Escolhe a cor da fonte.
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. A inicial do textbox é "txt".
PasswordChar Se durante a digitação de qualquer dado na caixa de texto, quisermos que o Visual Basic mostre outro caracter no lugar do caracter digitado, é só especificarmos aqui qual queremos que seja mostrado. Muito usado para digitação de senhas. ScrollBars Estando a propriedade multiline habilitada, é interessante colocarmos uma scrollbar na caixa de texto, pois ela acrescentará uma barra de rolagem que poderá ser: horizontal, vertical, ambas. Text A propriedade text é a mais importante deste objeto. Todo texto digitado pelo usuário dentro da caixa de texto é incorporado nesta propriedade.
As Propriedades Principais do Timer Interval Associa o intervalo de tempo em que a programação contida no objeto ocorrerá.
As Propriedades Principais do VScrollBar Max
Valor máximo a ser utilizado pela barra de rolagem, geralmente 100.
Min
Valor mínimo a ser utilizado pela barra de rolagem, geralmente 0.
CommandButton
Um botão de comando é tipicamente usado para iniciar um evento que retorna uma ação com fechar um formulário, movimentação para um registro diferente, imprimir u relatório, etc. Use a propriedade Caption para especificar o texto que aparece no botão de comando. Use a propriedade Picture para especificar uma figura para um botão de comando, só não esqueça de habilitar a propriedade Style para Graphical, caso contrário a figura não aparecerá. Você pode escolher um botão de comando para clicá-lo e se a propriedade Default está selecionada para true (.T.), pelo pressionamento da tecla ENTER o botão de comando é selecionado. Se a propriedade Cancel do botão de comando está selecionada para true (.T.), você pode escolher o botão de comando pelo pressionamento da tecla ESC.
Página 64 de 69
Linguagem de programação
Label Labels são usados para exibir texto e não podem ser editados pelo usuário. Eles são usados para identificar objetos em um formulário providenciando um descrição do que um certo controle fará se clicado, por exemplo em tempo de execução, Eles podem exibir informação em resposta a um evento ou processo em sua aplicação. Labels são usados em muitas instâncias nas mais diferentes situações. Muito comumente, eles são usados com controles que não tem a propriedade Caption. Por exemplo, você pode usar o controle label para adicionar descrições para TextBoxes, ListBoxes, ComboBoxes e outros. Eles também podem ser usados para descrever textos em um formulário, por exemplo, para auxiliar o usuário com informação de ajuda. Você pode também escrever um código que altere o texto exibido por um label em resposta à eventos em tempo de execução. Por exemplo, se sua aplicação leva alguns minutos para processar uma alteração, você pode exibir uma barra de status processando uma mensagem através de um label. Obs: Este controle não pode receber foco.
TextBox Obs: Para exibir múltiplas linhas de texto em um controle TextBox, altere a propriedade MultiLine para True. Se um TextBox com MultiLine não tem uma barra de rolagem horizontal, o texto é automaticamente ajustado quando o TextBox é redimensionado. Para personalizar a barra de rolagem de um TextBox, selecione a propriedade ScrollBars. Barras de rolagem sempre aparecerão em um TextBox quando a propriedade MultiLine dele é alterada para True, e a propriedade ScrollBars dele é alterada para qualquer coisa exceto None (0). Se você alterar a propriedade MultiLine para True, você pode usar a propriedade Alignment para alterar o alinhamento do texto dentro do TextBox. O texto padrão é justificado à esquerda. Se a propriedade MultiLine é False, alterar a propriedade Alignment não porporcionará efeito.
Frame Frames são usados para criar grupos de controles com identidades. Por exemplo, você pode usar um frame para subdividir um formulário funcionalmente, separarando grupos de botões de opções (OptionButton). Em muitos casos, você usará o frame passivamente para agrupar outros controles e não terá a necessidade de responder por ele nos eventos. Você irá, com tudo, alterar o Name, Caption, ou a propriedade Font.
Página 65 de 69
Linguagem de programação
Adicionando um Frame em um Formulário Quando usamos um frame para agrupar outros controles, primeiro desenhamos um frame, e então desenhamos os controles dentro dele. Isto habilita você a movimentar o frame e os controles contidos nele junto.
Desenhando controles dentro do Frame Para adicionar outros controles no frame, desenhe eles dentro do frame. Se Você desenhar um controle do lado de fora do frame, ou usar o método do duplo-clique para adicionar um controle em um formulário, e então tentar movimentar ele para dentro do frame, o controle será posto no topo do frame e você terá que movimentar o frame e os controles separadamente.
Check Box O controle checkbox exibe uma marca de checagem quando ele é selecionado. Ele é comumente utilizado para presenciar uma seleção Sim/Não ou Verdadeiro/Falso para o usuário. você pode utilizar este controle em grupos para exibir múltiplas escolhas das quais o usuário pode selecionar uma ou mais. Este controle é similar ao controle optionbutton, mas neste cada opção é usada para indicar uma seleção que é feita pelo usuário. Eles diferem somente porque um optionbutton em um grupo pode ser selecionado por vez. Com o controle check box, porém, qualquer número de caixas de checagem pode ser selecionado.
OptionButton Usualmente, os controles OptionButton são usados em um grupo de opções para exibir opções das quais o usuário seleciona somente uma. Você agrupa os controles OptionButton desenhando-os dentro de uma controle que os contêm como um Frame, um PictureBox, ou um formulário. Para agrupar os controles
Página 66 de 69
Linguagem de programação
OptionButton em um Frame ou PictureBox, desenhe o Frame ou o PictureBox primeiro, e então desenhe os controles OptionButton dentro. Todos os controles OptionButton com the same container act as a single group. Enquanto o controle OptionButton e o controle CheckBox parecem funcionar similarmente, há uma importante diferença: Quando um usuário seleciona um OptionButton, o outro controle OptionButton do mesmo grupo está automaticamente não disponível. Em contraste, qualquer número de controles CheckBox poderá ser selecionado.
ListBox Um ListBox exibe uma lista de ítens da qual o usuário pode selecionar um ou mais ítens. Se o number de ítens excede o número que pode ser exibido, uma barra de rolagem é automaticamente adicionada para o ListBox. Se não há item selecionado, o valor da propriedade ListIndex é -1. O primeiro item da lista é ListIndex 0, e o valor da propriedade ListCount é sempre um valor maior do que o contido em ListIndex. Obs: Para adicionar ou deletar ítens em um ListBox, use o método AddItem ou RemoveItem. Marque as propriedades List, ListCount, e ListIndex para habilitar um usuário para acessar ítens no ListBox. Alternativamente, você pode adicionar ítens para a lista usando a propriedade List em tempo de projeto.
ComboBox O ComboBox é um controle, similar a uma combinação entre um ListBox e um TextBox, em que você entra com um valor ou seleciona um item de uma lista.
ScrollBar Com as barras de rolagem, você pode utilizar as setas que estão posicionadas nas extremidades para aumentar ou diminuir valores, tamanho de objetos,
Página 67 de 69
Linguagem de programação
controlar o posionamento e o direcionamento de objetos baseado em outros fatores contidos no programa. Este objeto possui duas aparências, disponibilizando ao programador uma barra na posição horizontal ou uma barra na posição vertical. Dependendo da situação do programa, o programador saberá qual das barras ele precisará em seu programa.
Timer O controle Timer realiza ações atribuídas à ele de acordo com a passagem do tempo. Eles são independentes do usuário, e você pode programá-los para ter ações em intervalos de tempo regulares. Uma típica ação realizada com ele é a checagem do relógio do sistema para visualizar as horas em alguma barra de tarefas. Timers também são muito usados para outros tipos de processamento. Cada controle timer tem uma propriedade chamada Interval que especifica o número de milisegundos que passam entre um evento de tempo para o próximo. Mesmo desabilitado, um timer continua a receber um evento (apropriadamente nomeado de evento Timer) em um estado inacabado igual ao intervalo de tempo. A propriedade Interval tem poucas limitações para considerar quando você está programando em um controle timer: · Se sua aplicação ou outra aplicação é feita exigindo uma demanda maior do sistema tal como longos retornos, cálculos intensivos, ou leitura de drives, redes, ou portas de acesso sua aplicação não permite rodar no evento timer com frequência como especificado na propriedade Interval. · O intervalo poderá ser entre 0 e 64.767, o que significa que um intervalo muito longo não poderá ser mais longo do que um minuto (cerca de 64.8 segundos). · O intervalo não é garantido exatamente com o decorrer do tempo. Para assegurar exatidão, o timer exibe a checagem do relógio do sistema quando necessário, melhor do que tentar incrementar valores acumulados internamente como se fosse tempo. Todo controle timer deverá ser associado com um form. Contudo, para criar uma aplicação com tempo, você deverá criar no mínimo um form.
Image Um Image pode exibir um gráfico de um arquivo bitmap. Um bitmap define uma imagem como uma coleção de pontos (pixels). Um bitmap tem as extensões de
Página 68 de 69
Linguagem de programação
seus arquivos como: .bmp, .dib, ou .2bp. Você pode usar bitmaps de várias definições de cores, incluindo 2, 4, 8, 16, 24, e 32-bits, mas um bitmap somente exibirá corretamente se o dispositivo de exibição suporta a definição de cores usadas pelo bitmap. Por exemplo, um bitmap de resolução 8-bit-por-pixel (256 cores) somente exibe em 16 cores quando exibido em um dispositivo 4-bitsporpixel (16 cores). O image usa menos recursos do sistema e remonta as figuras mais rápido do que um picture box, mas ele só suporta parte das propriedades de um picture box, eventos e methods. Ambos os controles suportam formatos de figuras bitmap. Contudo, você pode esticar as figuras em um controle image ajustando elas ao tamanho do controle. Você não pode fazer isto com o controle picture box. A propriedade Stretch determina o quanto a figura será esticada quando o controle image é redimensionado. Se a opção é True, a figura lida dentro do controle image é esticada. Esticando uma figura bitmap podemos produzir uma imagem de menor qualidade.
Página 69 de 69