Baixe Microsoft Visual Basic - Apostilas - Ciência da Computação Parte1 e outras Notas de estudo em PDF para Informática, somente na Docsity!
Introdução
Quando se pensa em Windows, algumas palavras nos vêm à cabeça, tais como: interface gráfica, objetos, ícones, janelas, mouse, botões, etc., e, como o próprio nome diz, janelas. Aliás, uma verdadeira confusão de janelas: maximizadas, restauradas ou minimizadas; pop-up’s, modais ou não-modais; caixas de mensagem ou de diálogo; janelas mães e janelas filhas. Logicamente, então, o ponto de partida para a programação em ambiente Windows só poderia ser uma janela, pois é através dela que o usuário vai interagir com um sistema.
O Microsoft Visual Basic é um pacote para desenvolvimento de aplicações visuais para ambiente Windows baseado na linguagem de programação Basic. É orientado a eventos, o que quer dizer que trata ocorrências que dão início a alguma rotina de trabalho: o programa fica parado até que algo aconteça. Quer dizer também que ele permite o uso de objetos, mas não a sua criação, pois não é uma linguagem orientada a objetos.
Objetos são estruturas que combinam propriedades e métodos. As propriedades são características dos objetos, que podem ser acessadas e/ou alteradas pelo programador tanto em tempo de projeto (quando o projeto está sendo desenvolvido) quanto em tempo de execução (quando o aplicativo está sendo executado). Já os métodos são rotinas internas ao objeto que servem para executar determinadas ações. Para exemplificar, pense em uma bicicleta azul. A cor azul é uma característica da bicicleta, ou uma propriedade dela. Já um método seria o ato de pedalar, que é a rotina necessária para fazer a bicicleta andar.
Para programação em VB, usamos uma versão da linguagem Basic estruturada para a construção de procedimentos e funções que podem estar associados aos eventos dos objetos de sua aplicação. O VB também faz uma verificação automática de sintaxe dos comandos, e possui recursos avançados de compilação e rastreamento de erros.
Iniciando o VB
Clique no botão Iniciar do Windows, depois em Programas, e procure uma opção chamada Microsoft Visual Basic 6.0. Clique nela, e será exibida durante alguns segundos uma tela de apresentação do VB, enquanto o software está sendo carregado. Depois disso, aparecerá uma janela onde você deve indicar o tipo de projeto que deverá ser iniciado:
Para iniciar um novo projeto, escolha a opção Standard EXE na aba New. As demais opções dessa aba iniciam outros tipos de projetos, que não serão abordados nesse curso por tratarem-se de programação avançada, como a criação de controles ActiveX ;
A aba Existing serve para abrir um projeto já existente; Finalmente, a aba Recent contém os projetos mais recentemente utilizados, e pode ser usada para abrir um deles de maneira mais rápida que na aba Existing.
A tela do VB
Ao se utilizar o VB, tem-se a impressão que estamos “esculpindo” nossa aplicação diretamente no Windows. Isto se deve ao fato de que ele não possui uma janela que ao ser maximizada ocupe toda a área de trabalho. Na verdade, o VB é constituído apenas por uma barra de títulos, uma barra de menus e uma barra de ferramentas (veja a figura na próxima página). Dessa forma, quando construímos os nossos formulários estamos vendo exatamente como eles aparecerão no Windows. As janelas auxiliares, que podem ser a caixa de ferramentas, a janela de propriedades, a janela imediata, etc., aparecem “flutuando” na área de trabalho do Windows. Os principais componentes da interface do VB são os seguintes:
A janela Projeto ( Project )
No VB, sempre que pensamos em uma aplicação, pensamos em um projeto, que é o conjunto dos arquivos que compõem a aplicação. Esses arquivos podem ser formulários ou módulos. Existem outros arquivos que compõem um projeto, tais como controles customizados ( Custom Controls ), bibliotecas de funções, etc. Entretanto, estes não são parte integrante do arquivo que o VB gera. No VB, cada componente de um projeto está em um arquivo separado, que pode ser visualizado e acessado através da janela Projeto.
Formulários ( Forms )
No VB, as janelas são chamadas de formulários. Sempre que se começa a desenvolver uma nova aplicação, o VB nos fornece um formulário vazio como ponto de partida, e atribui a ele o nome provisório de Form1. Podemos inserir diversos tipos de controles neste formulário, controles estes que estão representados por botões na caixa de ferramentas.
A caixa de ferramentas ( Toolbox )
Procure na figura a caixa de ferramentas do VB. Ela geralmente está à esquerda do formulário, e contém os botões correspondentes aos controles que podem ser adicionados a ele.
Controles
Os controles são arquivos com extensão OCX e constituem a base da programação visual do VB, além de poderem ser utilizados em qualquer outro aplicativo ou linguagem que aceite objetos com esse padrão. Existem dois tipos básicos de controles: internos ou padronizados e personalizados ou customizados. Basicamente, os controles padronizados fazem parte do “corpo” do VB e são disponibilizados na caixa de ferramentas quando se inicia um novo projeto. Já os customizados podem ou não ser fornecidos junto com o VB, dependendo da versão utilizada, e precisam ser incluídos no projeto pelo programador - quando se inclui um controle customizado em um projeto, aparece um novo botão na caixa de ferramentas. Aliás, qualquer pessoa pode criar um controle OCX (o próprio VB permite isso), existindo inclusive vários deles que são comerciais, desenvolvidos por software-houses especializadas.
A utilização dos dois tipos de controles é rigorosamente a mesma: ambos possuem propriedades e métodos, respondem a eventos, aparecem na caixa de ferramentas, e são manipulados da mesma forma. A diferença é que os customizados não estão disponíveis enquanto não forem explicitamente incorporados à caixa de ferramentas do VB pelo programador. Mas, depois que isso acontece, tudo fica transparente.
A propriedade Name
A propriedade Name determina o nome de um objeto. Todos os objetos dentro de um projeto, incluindo formulários e controles, precisam ter um nome, pois é através desse nome que nos referimos a eles quando estamos escrevendo o código. Quando você inicia o VB, o formulário apresentado recebe o nome genérico de Form1; da mesma maneira, os controles recebem nomes genéricos: Command1, Command2, CommandN
Objeto..........................................................................................................Prefixo..............................Exemplo
Caixa de Combinação ( ComboBox )................................................................cbo.............................cboCidades
Caixa de Listagem ( ListBox )...........................................................................lst................................lstClientes
Barra de Rolagem Horizontal ( HScrollBar )...................................................hsb..................................hsbIdade
Barra de Rolagem Vertical ( VScrollBar )........................................................vsb...................................vsbTaxa
Temporizador ( Timer ).....................................................................................tmr...............................tmrAlarme
Caixa de Listagem de Unidades ( DriveListBox ).............................................drv............................drvUnidades
Caixa de Listagem de Diretórios ( DirListBox )................................................dir................................dirDestino
Caixa de Listagem de Arquivos ( FileListBox )................................................fil...............................filArquivos
Forma ( Shape ).................................................................................................shp...........................shpQuadrado
Linha ( Line ).....................................................................................................lin................................linDivisão
Caixa de Imagem ( Image )..............................................................................img.................................imgCarro
Controle de Dados ( DataControl )...................................................................dat................................datBancos
Grid.................................................................................................................grd.............................grdConsulta
Menu..............................................................................................................mnu...............................mnuEditar
Banco de Dados ( DataBase )............................................................................db.......................dbContabilidade
Conjunto de Registros ( RecordSet )..................................................................rs................................rsDespesas
Conexão com provedor de dados ( Connection )..............................................cnn................................cnnDados
Lição 1: Primeiros Passos
Nessa lição vamos criar nossa primeira aplicação no VB. Precisaremos seguir os seguintes passos:
- Criação da interface com o usuário : para isso, você vai usar os controles da caixa de ferramentas, que serão inseridos nos formulários de modo à “desenhar” a interface;
- Definição das propriedades dos objetos : após a inserção dos controles, você deve definir as propriedades com as quais eles devem ser iniciados quando o programa for executado;
- Codificação dos eventos : escrever a programação Basic necessária para que o programa responda corretamente aos eventos que vão ocorrer durante sua execução.
Criação da interface com o usuário
Vamos então para a primeira etapa do processo de criação do nosso programa: criar a interface com o usuário. Para isso você vai precisar dos seguintes controles:
Apontador ( Pointer ) : esse não é bem um controle, e sim uma ferramenta usada para inserir, movimentar e/ou dimensionar os diversos objetos de uma aplicação.
Botão de comando ( CommandButton ) : sua função principal é executar comandos quando clicado. É, provavelmente, o controle mais usado em programação visual.
Botão de opção ( OptionButton ) : usado para determinar se uma informação é verdadeira ou falsa, somente um botão pode estar ligado, num dado momento, para cada conjunto desses controles.
Legenda ( Label ) : serve para exibir um texto que não pode ser editado pelo usuário, como uma mensagem ou o rótulo de um campo a ser digitado. Caixa de figura ( PictureBox ) : permite a exibição de figuras e o agrupamento controles, tais como botões de comando, em formulários do tipo MDI (que serão estudados mais adiante).
Bem, mãos à obra:
- Inicie o Windows e o VB, se ainda não o fez. Na janela New Project , escolha a opção Standard EXE da aba New : será exibida a tela do VB com um formulário em branco;
- Insira um botão de comando nesse formulário. Para isso, você pode agir de duas maneiras: dar um click no ícone CommandButtom da caixa de ferramentas e arrastar o mouse sobre o formulário de modo a definir o tamanho desejado para o botão, ou então dar um duplo click no ícone (nesse caso o botão será inserido no centro do formulário com um tamanho padronizado):
- Usando o mesmo procedimento, insira três botões de opção ( OptionButtom ) e posicione-os um abaixo do outro do lado esquerdo do formulário, de modo a ficar parecido com o exemplo a seguir:
- Digite o novo valor para a propriedade. Algumas propriedades possuem uma caixa de combinação em que você pode indicar sua opção. Outras abrem uma caixa de diálogo, como a propriedade Picture de uma caixa de figura – quando isso acontecer, será indicado por um botão com reticências “...” ao lado do valor da propriedade.
Seguindo os passos acima, altere as propriedades dos objetos do nosso formulário, de acordo com a tabela:
Objeto Nome (propriedade Name)
Outras Propriedades = Valor
Formulário frmHello Caption = Hello, World! Icon = FACE05.ICO (obs.: os ícones do VB normalmente são encontrados na pasta C:\Arquivos de Programas\Microsoft Visual Studio\Commom\Graphics\Icons, e o arquivo citado está na subpasta Misc) Botão de opção optHappy Caption = I’m Happy! Botão de opção optOk Caption = I’m Ok Botão de opção optSad Caption = I’m Sad Caixa de figura picHappy Picture = FACE03.ICO Visible = False Appearance = 0 – Flat BorderStyle = 0 – None Caixa de figura picOk Picture = FACE02.ICO Visible = False Appearance = 0 – Flat BorderStyle = 0 – None Caixa de figura picSad Picture = FACE04.ICO Visible = False Appearance = 0 – Flat BorderStyle = 0 – None Label lblHappy Caption = “” (em branco) Font = Times New Roman, Negrito, tamanho 12 Label lblOk Caption = “” Font = Times New Roman, Negrito, tamanho 12 Label lblSad Caption = “” Font = Times New Roman, Negrito, tamanho 12 Botão de comando cmdExit Caption = &Exit Style = 1 – Graphical Picture = TRFFC14.ICO (procure na subpasta Traffic do diretório de ícones do VB)
Note que usamos o caracter “&” na definição da propriedade Caption do botão cmdExit. Fazemos isso quando queremos habilitar o acionamento de um controle pela tecla ALT. No formulário, o rótulo do botão é “Exit” – com a letra E sublinhada, indicando que podemos acioná-lo através da combinação de teclas ALT+E. Verifique se você fez tudo corretamente, comparando seu formulário com o exemplo abaixo:
Bem, vamos conhecer melhor as propriedades que usamos nesses controles, e algumas outras interessantes:
Propriedade Caption
Uma boa tradução para Caption é rótulo: para um formulário, Caption determina o texto que será exibido na barra de título, e também abaixo do ícone do aplicativo, se ele for minimizado. Para um controle, determina o texto exibido dentro ou próximo a ele. Quando um objeto é criado o conteúdo de Caption é igual ao nome padrão atribuído pelo VB ao controle.
Propriedade Picture
A propriedade Picture determina o nome de um arquivo gráfico para ser exibido pelo controle. Como você já viu, podemos escolher o arquivo gráfico desejado em uma janela de diálogo que é aberta quando clicamos no botão com “...” (reticências) exibido por Picture. Os formatos gráficos suportados pelo VB 4 são: ícones (arquivos de extensão ICO), Windows Metafile (extensão WMF – o formato dos cliparts do Word), Bitmap (extensão BMP – o formato dos arquivos criados pelo Paint do Windows), e arquivos JPG e GIF (muito usados em páginas da Internet). No caso do botão de comando, Picture só tem efeito se a propriedade Style for igual a 1 – Graphical.
Propriedade Style
Essa propriedade indica o estilo da aparência do controle. No caso dos botões de comando, os valores possíveis são 0 – Standard e 1 – Graphical. Na prática, a diferença é que, alterando o estilo do CommandButton para Graphical, será permitida a exibição de ícones, enquanto que em Standard somente texto poderá ser exibido por ele. Vários controles possuem a propriedade Style, sendo que os valores possíveis variam de um tipo para outro.
Propriedade Visible
Como o próprio nome indica, essa propriedade define se um controle deve ou não estar visível em um determinado momento. Ela só pode assumir os valores True (verdadeiro) ou False (falso);
Propriedade Enabled
Não usamos essa propriedade em nosso projeto, mas vamos citá-la agora para evitar confusões com Visible. Você já reparou quando abre uma janela qualquer do Windows e aparece um botão ou uma opção de menu cujo rótulo está com uma cor mais “apagada”, indicando que aquele controle não está acessível no momento? A propriedade Enabled é quem faz isso: ela habilita (quando True) ou não (quando False) o acesso ao controle em um determinado momento. Um exemplo: você cria um botão “Ok” para ser utilizado quando forem fornecidos alguns valores necessários para se realizar um cálculo. Você pode usar Enabled para desabilitar o botão Ok até que o usuário tenha fornecido esses valores, pois só depois disso ele poderá usá-lo.
Propriedade Appearance
A propriedade Appearance define a aparência do controle no formulário. Ela só pode ser modificada em tempo de projeto, e normalmente só pode assumir dois valores: 0 – Flat (o controle terá a mesma aparência do formulário, não haverá destaque) ou 1 – 3D (o controle será exibido em perspectiva 3D).
Propriedade BorderStyle
Essa propriedade normalmente é aplicada ao formulário, e, como o próprio nome indica, define o estilo de sua borda. Existem seis tipos de bordas, sendo que alguns controles também possuem a propriedade BorderStyle, mas não todos os tipos. Os tipos de bordas são os seguintes:
0 – None (Nenhuma) ;
1 - Fixed Single (Fixa Simples) : indica que o formulário não será dimensionável, ou seja, o usuário não poderá alterar o tamanho no formulário em tempo de execução.
2 – Sizable (Dimensionável) ; 3 - Fixed Dialog (Diálogo Fixo) : o formulário não possuirá os botões Maximizar e Minimizar, e, além disso, não será dimensionável. É o estilo da borda das caixas de diálogo do Windows;
Mas vamos fazer a codificação do nosso projeto. Comecemos pelo botão cmdExit: para escrever o código necessário ao seu funcionamento, siga os seguintes passos:
- Dê um duplo click sobre o botão cmdExit: a janela Código se abre no evento Click:
- Escreva o seguinte código:
Private Sub cmdExit_Click() End End Sub
A primeira linha da procedure indica seu nome – cmdExit_Click – e sua classe – Private (privada). A última linha indica o fim da procedure, através do comando End Sub. Entre o nome da procedure e o comando End Sub é que escrevemos a codificação necessária, que nesse caso resumiu-se ao comando End (que nome sugestivo, não?), cuja função é encerrar a execução do programa.
Vamos agora testar nosso programa. Para isso, basta clicar no botão Start da barra de ferramentas ou então pressionar a tecla F5. Teste o funcionamento de seu aplicativo: se tudo foi feito corretamente, quando você clicar no botão “Exit” o programa será encerrado e você retornará ao VB.
Uma observação: quando estamos criando um formulário ou escrevendo código dizemos que estamos em tempo de projeto ; quando estamos executando um programa dizemos que estamos em tempo de execução. Essa diferenciação é importante, pois existem algumas propriedades que não podem ter seu valor alterado em tempo de execução.
Planejando a codificação
Planejamento é a palavra chave para nós, programadores, quando chegamos na fase de escrever a programação do aplicativo. Antes de começar a codificação de um programa você precisa saber o que ele deve fazer e quando: identificar quais os eventos que podem ser acionados pelo usuário e como eles vão influenciar a execução do aplicativo, para poder assim programá-los de maneira a chegar ao resultado desejado. Vamos então planejar nosso primeiro aplicativo:
Temos em nosso formulário três botões de opção, que servirão para indicar nosso “humor matinal”;
Temos também três caixas de figura, inicialmente invisíveis, cada uma delas contendo uma “carinha” diferente, e três Labels que não contém texto nenhum; Quando clicarmos em um botão qualquer, a figura e o texto correspondente a ele deverão aparecer, e a figura e o texto dos outros botões não deverão mais ser exibidos;
Você já deve ter percebido que o evento que vamos trabalhar é o Click dos botões de opção, pois é ele que vai gerar as ações necessárias para cumprirmos nosso planejamento. Agora que já sabemos o que fazer, vamos escrever a codificação para isso:
- Dê um duplo-click no botão de opção optHappy. A janela Código será aberta e a procedure optHappy_Click exibida;
- Digite os comandos indicado:
Private Sub optHappy_Click() picHappy.Visible = True picOk.Visible = False picSad.Visible = False lblHappy.Caption = "I'm going to Disneyworld!" lblOk.Caption = Empty lblSad.Caption = Empty End Sub
Obs.: Empty é uma função do VB que retorna uma string vazia (nula).
- Dê um click na lista Object e escolha o objeto optOk. Se a procedure exibida pela janela Código não for a optOk_Click, selecione-a na lista Proc;
- Digite a procedure:
Private Sub optOk_Click() picHappy.Visible = False picOk.Visible = True picSad.Visible = False lblHappy.Caption = Empty lblOk.Caption = "I'm Ok today." lblSad.Caption = Empty End Sub
- Selecione agora o objeto optSad e a procedure optSad_Click, e escreva o código para ela (você pode usar os recursos de copiar e colar do Windows):
Private Sub optSad_Click() picHappy.Visible = False picOk.Visible = False picSad.Visible = True lblHappy.Caption = Empty lblOk.Caption = Empty lblSad.Caption = "Goodbye, cruel world..." End Sub
- Pressione F5 para executar o programa. Se você digitou tudo corretamente, o VB exibirá seu formulário na tela, como no exemplo a seguir:
- Dê um click no botão com o rótulo “I’m Happy” e veja se o resultado é o esperado:
- Na caixa Select Project , selecione o projeto para o qual deve ser criado o programa de instalação;
- Clique no botão Package para iniciar o assistente;
- Você deverá responder algumas perguntas (por exemplo, o nome da opção que será criada no menu Iniciar do Windows) sendo que para a maioria delas não é necessário fazer qualquer alteração. Devemos porém destacar uma delas na qual deve-se indicar, se for o caso, o nome dos arquivos externos ao projeto que também precisam ser copiados. O caso mais comum é o de arquivos de banco de dados, quando da primeira instalação do aplicativo;
- Depois que você responder essas perguntas, deverá indicar em que unidade e (se for o caso) em que pasta onde devem ser gravados os arquivos da instalação. Se você indicar uma unidade de disquetes, o Wizard criará os disquetes de instalação automaticamente;
- Pronto, o Wizard resolve todas as dependências e cria o programa de instalação para você.
Lição 2: Entrada e Saída de Dados
Entrada e saída são dois conceitos importantíssimos em Processamento de Dados, pois envolvem a interação do usuário com a máquina: por entrada, entende-se toda solicitação ou fornecimento de dados ao computador pelo operador, e por saída, o retorno pelo computador do resultado obtido. Nessa lição você vai aprender a implementar esses dois conceitos em seus programas.
Caixas de Texto
Em programação visual, existem várias maneiras de se permitir a entrada de dados, mas a principal é o uso das caixas de texto ( TextBox ). Seu evento padrão é o Change , que ocorre sempre que acontece uma digitação, e a propriedade principal é a Text. Vejamos então algumas propriedades importantes:
Propriedade Text
A propriedade Text de uma caixa de texto armazena o texto contido na área de edição. Ela pode ser alterada pelo usuário em tempo de execução, o que permite então a digitação de dados no programa. Como a propriedade Text armazena textos, quando houver a necessidade do dado a ser digitado ser numérico teremos que converter seu conteúdo usando funções específicas para esse fim.
Propriedade MaxLength
Essa propriedade serve para determinar o tamanho máximo em caracteres do dado digitado em uma caixa de texto. Por exemplo: sabendo que a digitação em uma caixa de texto chamada txtNome não pode ter mais de 30 caracteres, determinamos para a MaxLength de txtNome o valor 30. Se MaxLength não for definida, o valor padrão é zero, e não haverá limite para a digitação no campo.
Propriedade Multiline
A função dessa propriedade é permitir ou não a digitação de mais de uma linha em uma caixa de texto. Os valores possíveis são True (Multiline habilitada) ou False. Com MuliLine = True, quando Enter for pressionada, a digitação passa para a próximo linha. Além disso, a propriedade Alignment de uma caixa de texto só funciona de Multiline estiver habilitada.
Propriedade PasswordChar
Eis uma propriedade muito interessante: você já digitou uma senha em um programa qualquer em que aparece na caixa um caractere especial (normalmente é um “*”) ao invés daquele digitado? Quem faz isso é PasswordChar: basta informar em seu valor o caracter desejado, e o efeito será exatamente esse.
Propriedades ForeColor e BackColor
A propriedade ForeColor define a cor da fonte usada no texto exibido pelo controle, e BackColor indica a cor do fundo de um objeto. Essas propriedades recebem como valor um código numérico ou hexadecimal que representa a cor desejada. Em tempo de projeto, para alterá-las a maneira mais simples é clicar sobre a propriedade que deve ser modificada e depois no botão com as reticências que aparece ao lado do código da cor atual. Uma janela com as opções de cores disponíveis se abre e basta escolher a que mais lhe agrade. Para alterar seus valores em tempo de execução, são usadas as funções RGB e QBColor, que estudaremos mais adiante.
Para exemplificar o uso das TextBoxes , vamos elaborar o projeto de uma calculadora simples:
- Inicie um novo projeto;
- Dimensione o formulário e insira os controles necessários de modo a ficar parecido com o modelo da próxima página;
o programa Calc, faça um cálculo qualquer e clique com o mouse sobre a caixa de texto txtResultado. Agora escreva alguma coisa: a digitação é aceita, o que, convenhamos, não é lá muito recomendável para a exibição de dados. Já um label não permite digitação, resolvendo esse problema. Vamos então alterar nosso programa:
- Apague do formulário a caixa txtResultado;
- Inclua um label em seu lugar, e altere suas propriedades para: Name = lblResultado Caption = “” (em branco) Alignment = 2 – Center BorderStyle = 0 – None BackStyle = 1 – Opaque BackColor = (clique nas reticências e escolha a cor branca)
- Altere a última linha da procedure cmdIgual_Click para:
lblResultado.Caption = vValor1 * vValor
- Altere a primeira linha da procedure cmdLimpar_Click para:
lblResultado.Caption = Empty
- Execute o programa, faça um cálculo qualquer e tente alterar o resultado: como o label não permite digitação, isso não é mais possível.
Saída Formatada
É muito comum a necessidade de se aplicar máscaras para a exibição dos dados. Isso fica claro quando, em nossa calculadora, um cálculo resulta em um valor alto, pois não existem separadores de milhar ou decimal. O VB possui algumas funções específicas para a formatação de dados de saída:
Função Format
A função Format é usada na aplicação de máscaras em dados numéricos ou datas. Sua sintaxe é a seguinte:
Format(<expressão>,)
Onde Expressão é o dado a ser formatado e Formato é a máscara que será aplicada a ele, e o resultado será uma string correspondente à expressão formatada com a máscara. Veja alguns exemplos:
Formato 5 positivo 5 negativo 5 decimal 0 5 -5 1 0,00 5,00 -5,00 0, #,##0 5 -5 1 #,##0.0 5,0 -5,0 0, $#,##0;($#,##0) $5 ($5) $ $#,##0.00;($#,##0.00) $5,00 ($5,00) $0, 0% 500% -500% 50% 0.00E+00 5,00E+00 -5,00E+00 5,00E-
Em “formato” o número 0 será mostrado ou trocado pelo caractere em sua posição, já o sustenido (#) não será mostrado. Podemos usar símbolos na máscara, como no exemplo: $ , % e E (que representa exponenciação). Note que a separação de milhares e decimais na máscara deve ser feita no padrão americano, ou seja, “,” para separação de milhares e “.” para decimais, mas o resultado vai seguir as configurações feitas na opção Internacional do Painel de Controle do Windows. Format também pode ser usada para formatação de data e hora:
Formato Exibição Formato Exibição d/m/yy 10/7/96 General Date 06/09/96 9:40: dd-mm-yyyy 01-Jun-1996 Long Date Sexta, 9 de setembro de 1996 dd-ddd 02-Dom Medium Date 09-set- hh:mm AM/PM 08:50 AM Short Date 09/09/ h:mm:ss a/p 8:50:20 a Long Time 9:40: d/m/yy h:mm 03/12/95 9:30 Medium Time (12 horas) 09:40 AM Short Time (24 horas) 09:
Funções UCase e LCase
Essas funções são usadas na conversão de textos em letras maiúsculas (UCase) ou minúsculas (LCase).
Função StrConv
A função StrConv também é usada na formatação de strings, mas é mais flexível que UCase e LCase, pois recebe um parâmetro que indica como deve ser feita a conversão de maiúsculas para minúsculas e vice- versa. Esse parâmetro pode ser:
1 – vbUpperCase : converte a string em caracteres maiúsculos. O mesmo que UCase;
2 – vbLowerCase : converte a string em caracteres minúsculos. O mesmo que LCase; 3 – vbProperCase : converte em letra maiúscula a primeira letra de cada palavra na seqüência de caracteres, e as demais em minúsculas.
Por exemplo:
Função Exibição UCase(“MICROSOFT Visual basic”) ou StrConv(“MICROSOFT Visual basic”, vbUpperCase)
MICROSOFT VISUAL BASIC
LCase(“MICROSOFT Visual basic”) ou StrConv(“MICROSOFT Visual basic”, vbLowerCase)
microsoft visual basic
StrConv(“MICROSOFT Visual basic”, vbProperCase) Microsoft Visual Basic
Vamos alterar a exibição do resultado na calculadora:
- Abra a janela Código no evento Click do botão cmdIgual;
- Altere a última linha da procedure como segue:
lblResultado.Caption = Format(vValor1 * vValor2, “###,##0.00”)
- Execute o programa e teste a alteração;
- Grave seu trabalho. Guarde-o com cuidado, pois esse projeto será usado novamente na próxima lição.
Escopo das Variáveis
Escopo são os pontos da aplicação de onde podemos acessar a variável. O escopo de uma variável é determinado pelo comando usado em sua declaração (Dim, Static, Private ou Public):
Variáveis Locais : são reconhecidas apenas pela procedure na qual foram declaradas. Diferentes procedures podem ter variáveis locais com o mesmo nome sem que isso cause conflitos, pois quando uma procedure é encerrada o conteúdo de suas variáveis locais será perdido. A declaração de variáveis locais é feita com os comandos Dim ou Private. Importante: variáveis com declaração implícita serão sempre locais; Variáveis Estáticas : são variáveis locais cujo conteúdo será retido ao término da procedure. Nesse caso, quando a procedure que contém uma variável estática for executada novamente, a variável não será reinicializada e seu conteúdo será o mesmo que ela continha quando a procedure foi encerrada da última vez. Para declarar uma variável como estática usa-se o comando Static;
Variáveis Privadas : compartilham informações entre todas as procedures em um módulo de programação ou formulário, mas não para outros módulos ou formulários. A declaração de variáveis privadas é feita com os comandos Dim ou Private na seção Declarations de um formulário ou módulo de programação; Variáveis Públicas : estão disponíveis para todos os módulos de programação e formulários do aplicativo. Para a declaração de variáveis públicas usamos o comando Public.
Obs.: por uma questão de compatibilidade com versões anteriores do VB, também pode ser usado o comando Global para declaração de variáveis públicas.
Inicialização de Variáveis
De modo geral, para inicializar uma variável basta atribuir um conteúdo a ela. Obviamente, esse conteúdo deve ser compatível com o tipo usado na declaração da variável.
Para dados numéricos basta indicar o valor desejado:
vSalárioBase = 1200
Valores reais devem usar o ponto para separação da parte decimal, jamais a vírgula , mesmo que a configuração do Painel de Controle do Windows indique o contrário:
vPi = 3.
Dados tipo String devem vir entre aspas:
vNomeEscola = “CEMEP”
Dados tipo Date são identificados pelo caracter “#” (sustenido) no seu início e fim. Por exemplo: para armazenar a data 15/07/1998 em uma variável, podemos usar o comando:
vDataCurso = #15/07/1998#
Constantes
Constantes também são posições de memória que têm as mesmas características das variáveis e podem ser dos mesmos tipos, mas, como o próprio nome indica, não podem ter seu valor alterado durante a execução do programa. São úteis para guardar parâmetros e valores que serão usados em várias procedures do sistema, pois com elas podemos centralizar a atribuição desses valores em alguns poucos locais, o que facilita muito a programação. Por exemplo: quando um cliente compra um sistema, obviamente pretende que o nome de sua empresa apareça nos relatórios emitidos por ele. Se você incluir o nome da empresa em cada programa de relatório, e depois vender esse sistema para outro cliente, terá que rastreá-lo todo a procura dessas ocorrências e fazer as alterações necessárias. Mas, se você definir uma constante pública no início do sistema contendo o nome da empresa, só terá que fazer uma alteração. Constantes só podem ser declaradas com os comandos Public (constantes públicas) ou Private (constantes privadas ou locais). A sintaxe usada na sua criação é:
Const NomeDaConstante As =
Por exemplo:
Public Const Pi As Single = 3.
Constantes de Sistema
O VB possui diversas constantes pré-definidas, chamadas de Constantes de Sistema, que podem ser usadas a qualquer momento pelo programador. A principal vantagem de seu uso é a clareza da codificação e a conseqüente facilidade de manutenção. Um bom exemplo do uso desse tipo de constante é o de uma aplicação que trate com dias da semana. Se a comparação do número do dia da semana de uma data com 1 for verdadeira, saberemos que esse dia é um domingo, pois o VB identifica um domingo pelo valor 1. Existe uma constante de sistema, de nome vbSunday, cujo valor é 1, que foi criada justamente para ser usada em casos como esse: ao invés do programador comparar o dia da semana com 1 e ter que se lembrar a toda hora que 1 é domingo, pode comparar com vbSunday, e seu código ficará muito mais legível. A lista completa das constantes de dias da semana é a seguinte:
Constante Valor Dia da semana vbSunday 1 Domingo vbMonday 2 Segunda vbTuesday 3 Terça vbWednesday 4 Quarta vbThursday 5 Quinta vbFriday 6 Sexta vbSaturday 7 Sábado
Um observação importante é que uma constante de sistema é facilmente identificável, pois seu nome geralmente começa com “vb” – repare na tabela acima. Você também já viu algumas delas na lição anterior, quando estudamos a função StrConv: os valores vbUpperCase, vbLowerCase e vbProperCase são constantes de sistema cujos valores são, respectivamente, 1, 2 e 3. Estudaremos mais algumas delas durante o curso.
Funções de Conversão
Como já vimos anteriormente, a entrada de dados é feita pelas caixas de texto, obrigando o uso de conversores quando houver necessidade do dado ser numérico ou data. Os conversores são funções que recebem dados de um tipo e os convertem em outro. Cada tipo de conversão tem uma função correspondente. Por exemplo: não podemos usar um conversor de string para Byte se sabemos que o texto representa um valor maior que 255, pois esse é o valor limite do tipo Byte: o tamanho do dado não será suportado na conversão.
A tabela a seguir mostra as funções para conversão de dados tipo String em numéricos. Considere que a
variá-vel vPi contém um texto correspondente ao valor de (“3.1415926535”):
Função/Sintaxe Exemplo Tipo Resultante Resultado da conversão Val() Val(vPi) Long 3 CInt() Cint(vPi) Integer 3 CLng() CLng(vPi) Long 3 CSng() CSng(vPi) Single 3. CDbl() CDbl(vPi) Double 3. CCur() Ccur(vPi) Currency 3.
Observação: as funções Val e CLng diferem-se na conversão de um dado não numérico: Val é a única função que consegue tratar um dado String que não represente um valor. Nesse caso, ela retornará zero. As outras funções, inclusive CLng, geram um erro de execução se forem usadas para esse tipo de conversão.
A conversão de um dado tipo String em uma data é feita pela função CDate. Essa função também gera um erro de execução se o texto a ser convertido não representar uma data válida. Veja sua sintaxe e um exemplo de utilização:
CDate()
' Define a data: vDia = "12/02/1969" ' Converte vDia para vDataNasc, do tipo Date. vDataNasc = CDate(vDia)
Obs.: as linhas iniciadas com o apóstrofo (') são comentários.
