Conectando-se a um banco de dados Access através do ASP – Parte 2

Iran Rodrigues — Wed, 20 Feb 2008 22:28:35 +0000

Aprenda a realizar operações básicas envolvendo bancos de dados com o ASP.

Continuando o post anterior, veremos como listar os registros existentes em uma tabela no banco. Antes de qualquer coisa, verifique se você baixou o banco de dados de exemplo citado no post anterior, pois ele será necessário agora.

A última coisa que fizemos foi a criação de um novo arquivo “ASP VBScript” no Dreamweaver, o qual acrescentamos as seguintes linhas no topo (a primeira já existe):

<%@LANGUAGE="VBSCRIPT" CODEPAGE="1252"%>
<%
set conexao = Server.CreateObject("ADODB.Connection")
conexao.Open "Provider=Microsoft.Jet.OLEDB.4.0;DataSource="&Server.MapPath("banco.mdb")&";"
Set registros = Server.CreateObject ("ADODB.Recordset")
registros.Open "usuarios",conexao,3,3
%>

Com a utilização do método “Open” do objeto “registros”, este passa a se comportar como um array, ou seja, pode ter seus valores acessados através de índices. Mas que índices são esses? E quais seriam os valores? Resposta: os índices correspondem aos nomes dos campos existentes na tabela de nome “usuarios”. E os valores armazenados no array são os valores do registro para cada campo. Veja na prática, acrescentando as seguintes linhas ao body do documento:


<%=registros("codigo") & " "%>
<%=registros("nome") & " "%>
<%=registros("email") & " "%>
<%=registros("datanasc")%>

O que fizemos foi escrever o conteúdo de cada um dos campos especificados. Perceba que os valores exibidos correspondem a apenas um registro. Na verdade, o primeiro registro da tabela. Podemos exibir os demais utilizando um método existente para o objeto “registros”: o MoveNext. Vejamos seu funcionamento:


<%=registros("codigo") & " "%>
<%=registros("nome") & " "%>
<%=registros("email") & " "%>
<%=registros("datanasc")%>
<% registros.MoveNext %>
<%="
"%>
<%=registros("codigo") & " "%>
<%=registros("nome") & " "%>
<%=registros("email") & " "%>
<%=registros("datanasc")%>
<% registros.MoveNext %>
<%="
"%>
<%=registros("codigo") & " "%>
<%=registros("nome") & " "%>
<%=registros("email") & " "%>
<%=registros("datanasc")%>

Perceba que a cada uso do MoveNext, passamos a trabalhar com o próximo registro. Logo, apesar de estarmos apenas repetindo os mesmos comandos, a cada repetição exibimos os valores de um registro diferente.

É claro que nem de longe este código está prático. Da forma como foi criado, seria necessário copiar e colar os blocos de código repetidos tantas vezes quantos fossem os registros – portanto o código poderia crescer indefinidamente. Bom, é para isso que servem as estruturas de repetição. Podemos repetir os blocos de código até que atinjamos o fim dos registros. Como isso é possível? Através da propriedade EOF, também presente no objeto “registros”. Esta é um propriedade booleana: é verdadeira quando se chega ao fim da tabela e falsa em caso contrário. Logo, o código final poderia ficar assim:


<%
' Até chegarmos ao fim da tabela...
Do Until registros.EOF
' ...escreveremos os dados do registro atual
%>
<%=registros("codigo") & " "%>
<%=registros("nome") & " "%>
<%=registros("email") & " "%>
<%=registros("datanasc")%>
<%="
"%>
<% registros.MoveNext %>
<% Loop %>

Exercício: organize os dados dos registros exibindo-os dentro de uma tabela (

). Dica: substitua os espaços em branco e a quebra de linha pelas tags (abra-as e feche-as corretamente).

Por hoje é só, pessoal. Em breve continuarei este artigo demonstrando como inserir novos registros em uma tabela.

Conectando-se a um banco de dados Access através do ASP – Parte 1

Iran Rodrigues — Mon, 18 Feb 2008 22:48:16 +0000

Aprenda a realizar as operações básicas envolvendo bancos de dados com o ASP.

Ao pensarmos em sites que acessam bancos de dados, a primeira coisa que vem à cabeça são grandes sites, como um site de comércio eletrônico, com cadastros de produtos, clientes, fornecedores e etc. Apesar destes grandes sites utilizarem (grandes) bancos de dados, existem muitos outros pequenos sites que também os utilizam (ou poderiam utilizá-los).

Hoje em dia, sites que acessam bancos de dados são cada vez mais comuns. Um exemplo: suponha um simples site institucional. Este site possui uma página descrevendo a empresa, seus serviços, um formulário de contato, etc. Para tanto, digamos que ao total existam cinco diferentes páginas. Até aí, tudo bem. Mas vamos além: imagine ainda que o responsável pelo conteúdo do site na empresa não entenda de HTML (que dirá de ASP). Como ele fará para atualizar informações em seu site sem precisar contatar um profissional? A resposta: atráves de um sistema de administração de conteúdo. O site poderia conter uma área, protegida por senha, onde a pessoa responsável possa alterar o conteúdo de cada uma das páginas, como por exemplo, atualizar um telefone, ou acrescentar uma informação, sem ver nenhuma tag HTML ou comando de ASP. Para que isso seja possível, tais informações (o conteúdo de cada página) devem estar em um banco de dados.

O ASP permite trabalhar com qualquer banco de dados popular, como o SQL Server, Oracle, MySQL, PostgreSQL, Access, MSQL… peraí? Access? Isso mesmo!

O Access é conhecido por ser um banco de dados limitado, voltado ao uso doméstico ou em pequenas empresas; mas isso não impede de ser utilizado em um site. De fato, se o site não fizer operações complexas envolvendo o banco de dados e nem tiver muitos acessos simultâneos, é possível usar o Access normalmente. Se for necessário um banco robusto, é melhor esquecê-lo. Nesta página (em inglês) vocês podem encontrar uma relação das limitações do Access como banco de dados para a web.

De qualquer forma, veremos o uso do Access apenas para fins didáticos, pois uma de suas vantagens é a simplicidade na criação de um banco de dados e a facilidade para carregá-lo para qualquer lugar, pois ocupa um único arquivo (de extensão .mdb).

Antes de qualquer coisa, baixem o banco de dados usado como exemplo: aqui.

Começando…

Assim como fizemos no módulo de PHP, qualquer tarefa envolvendo o uso de um banco de dados requer alguns comandos essenciais: a conexão com o banco e a definição da tabela a ser usada.

Para tanto, criem um novo arquivo ASP VBScript no Dreamweaver e acrescentem as linhas a seguir (percebam que a primeira linha já existe no código da nova página):

<%@LANGUAGE="VBSCRIPT" CODEPAGE="1252"%>
<%
set conexao = Server.CreateObject("ADODB.Connection")
conexao.Open "Provider=Microsoft.Jet.OLEDB.4.0;DataSource="&Server.MapPath("banco.mdb")&";"
Set registros = Server.CreateObject ("ADODB.Recordset")
registros.Open "usuarios",conexao,3,3
%>

Complicado? Nem tanto. À primeira vista assusta, mas com o uso você decora…

Veja que uma palavra se repete: ADODB. “DB” sabemos que vem de “database” (banco de dados), já o ADO é uma tecnologia proprietária da Microsoft que provê uma interface para o acesso aos dados armazenados em um banco de dados. Ele é instalado junto com o IIS.

Voltando a analisar o código: a linha que inicia com “set conexao” cria uma instância chamada de “conexao” a partir do objeto “ADODB.Connection”. Lembram-se de que vimos por alto o uso do método CreateObject do objeto Server? Olha ele aí instanciando um objeto…

O objeto ADODB.Connection estabelece uma conexão a um banco de dados. Seu uso é fundamental para que realizemos qualquer operação com o banco.

Após a criação do objeto “conexao”, utilizamos o seu método “Open” para inicializar a conexão com o banco. Nesta etapa, qual é o banco de dados que iremos utilizar e onde ele se localiza. O parâmetro passado à função é chamado de string de conexão. No exemplo acima, a string de conexão contém o “provider” e o “data source” a serem usados. O primeiro é o provedor, que indica o mecanismo que lidará com o banco (este em questão é o provedor que lida com o Access e o Excel). O data source (fonte de dados) especifica o local do arquivo do banco de dados. O método “Server.MapPath” foi usado para obter o caminho completo do arquivo (que poderia ser, por exemplo, “C:\Inetpub\wwwroot\site\banco.mdb”).

Após o uso do método “Open” do objeto “conexao”, instanciamos um objeto a que chamamos “registros” (do tipo ADODB.Recordset). Este objeto armazenará os dados do banco, normalmente de uma tabela por vez.

O método “Open” para o objeto “registros” tem a função de associar o objeto a um conjunto de registros (ex.: uma tabela). No exemplo acima, “abrimos” a tabela chamada “usuarios” através da conexão definida no objeto “conexao”. O “3,3″ no final indica o tipo de cursor e o modo de travamento. O primeiro, com valor “3″, indica que a movimentação por entre os registros será feita apenas para a frente, o que aumenta a performance. O segundo “3″ indica que o registro ficará travado para não permitir alterações por outros usuários enquanto estiver sendo usado. Estes parâmetros são opcionais, podendo ser omitidos. Mais detalhes sobre o tipo de cursor e o modo de travamento no site da W3 Schools (em inglês).

Até aqui o que fizemos foi apenas nos conectar a um banco e selecionar uma tabela. Portanto, nenhuma informação do banco estará ainda visível. Em breve continuarei este artigo, colocando um exemplo prático, onde poderemos listar os registros já armazenados no banco. Até.

O objeto Server

Iran Rodrigues — Sat, 09 Feb 2008 13:24:13 +0000

Continuando a sequência de artigos sobre os objetos do ASP, veremos aqui como utilizar o objeto Server.

Olá. Agora que ~~o ano começou~~ o carnaval acabou, vou correr para atualizar o conteúdo das aulas – que estão quase todas atrasadas. Devido a este atraso, o conteúdo deste e dos próximos posts serão levemente resumidos (volto a lembrar que o objetivo é reforçar/relembrar o que foi visto em aula).

Continuando a falar dos objetos do ASP, chega a vez do Server. Este objeto serve basicamente para acessar funções gerais no servidor web. O Server possui uma propriedade e sete métodos, a saber:

ScriptTimeout (propriedade)
CreateObject* (método)
Execute (método)
GetLastError** (método)
MapPath* (método)
HTMLEncode (método)
Transfer (método)
URLEncode (método)

* Seu uso será exemplificado em aulas posteriores;
** Não será visto em aula.

ScriptTimeout

Propriedade que define o tempo máximo de espera para o processamento de um script no servidor. O valor padrão é 90 (segundos), o que quer dizer que uma página que contenha um código que leve a um looping infinito, por exemplo, será executada por no máximo 90 segundos, para então resultar em erro.

Setando um novo valor para ScriptTimeout:

Server.ScriptTimeout = 45
' Exibição do valor
Response.Write(Server.ScriptTimeout)

CreateObject

Instancia um objeto. Em outras palavras, cria um objeto do tipo especificado. Veremos mais detalhes ao trabalharmos com bancos de dados.

Execute

Executa um script contido em um arquivo ASP externo. Equivale ao include do PHP.

Exemplo:

arquivo1.asp

Response.Write("Comando 1 do arquivo1.asp
")
Server.Execute("arquivo2.asp")
Response.Write("Comando 2 do arquivo1.asp
")

arquivo2.asp

Response.Write("Comando 1 do arquivo2.asp
")
Response.Write("Comando 2 do arquivo2.asp
")
Response.Write("Comando 3 do arquivo2.asp
")

Resultado da execução do arquivo1.asp:

Comando 1 do arquivo1.asp
Comando 1 do arquivo2.asp
Comando 2 do arquivo2.asp
Comando 3 do arquivo2.asp
Comando 2 do arquivo1.asp

Percebam que após a execução dos comandos no arquivo2.asp, os comandos restantes do arquivo1.asp são executados.

GetLastError

Este método é usado na personalização de páginas que exibem mensagens de erro no servidor. Um exemplo no uso deste método pode ser encontrado aqui (em português).

MapPath

Obtém o caminho absoluto para um arquivo ou pasta no servidor a partir de seu caminho relativo. Utilizaremos este método quando trabalharmos com bancos de dados.

HTMLEncode

Este é um método bem util. Sua função é converter caracteres especiais contidos em uma string em seus respectivos “códigos” oriundos do HTML (HTMLEncode significa codificar em HTML).

Experimentem exibir o texto “
” numa página web. Se vocês digitarem no body, por exemplo, ao invés do texto “
” o que aparece é uma quebra de linha. Isso acontece porque o browser processa o texto “
” como um comando da linguagem HTML. Para simplesmente exibirmos como texto, precisamos substituir os “<” e “>” pelos seus respectivos códigos em HTML: “<” e “>”, respectivamente. Então teríamos que escrever:

Como ninguém costuma decorar esses códigos, e mesmo que decore, não quer perder tempo digitando-os, vamos utilizar o método HTMLEncode. Analisem o código fonte gerado pela execução do código abaixo e tirem suas conclusões:

'Sem HTMLEncode
Response.Write("O elemento do HTML que quebra linhas é o 
")
'Com HTMLEncode
Response.Write(Server.HTMLEncode("O elemento do HTML que quebra linhas é o 
"))

Transfer

Faz quase o mesmo que o método Execute. A diferença é que o Transfer não inclui a página externa, mas sim redireciona a execução para ela. Ou seja, ao transferir a execução de uma página chamada arquivo1.asp para uma outra chamada arquivo2.asp, ao fim da execução desta última, o servidor não retorna para a primeira.

Observação: o objetivo deste método não é simplesmente redirecionar (como o Response.Redirect). O redirecionamento ocorre de forma transparente para o usuário – ele não sabe que está sendo redirecionado, pois o browser não irá recarregar – e, principalmente, este redirecionamento conserva o estado atual do servidor. Assim, as variáveis definidas continuam existindo ao chegar na página de destino.

Exemplo (baseado no exemplo do Execute – vejam as diferenças no resultado):

arquivo1.asp

Response.Write("Comando 1 do arquivo1.asp
")
Server.Transfer("arquivo2.asp")
Response.Write("Comando 2 do arquivo1.asp
")

arquivo2.asp

Response.Write("Comando 1 do arquivo2.asp
")
Response.Write("Comando 2 do arquivo2.asp
")
Response.Write("Comando 3 do arquivo2.asp
")

Resultado da execução do arquivo1.asp:

Comando 1 do arquivo1.asp
Comando 1 do arquivo2.asp
Comando 2 do arquivo2.asp
Comando 3 do arquivo2.asp

Qual a diferença? Ao terminar de executar os comandos do arquivo2.asp, ele não volta para o arquivo1.asp. A execução termina.

URLEncode

Mais uma função de codificação, como a HTMLEncode. A diferença é que o URLEncode codifica um texto para que ele possa ser inserido numa URL. Para ver um exemplo, acesse o Google, digite uma frase como: receita de suflê de abóbora (eu chutei essa receita, mas pelo jeito, ela existe de verdade). Ao pesquisar, não cliquem em nenhum resultado. Ao invés disso, observem a URL. Como o formulário de busca do Google é enviado via GET, as informações ficam expostas na URL. Fiz a pesquisa e a URL atual é: http://www.google.com.br/search?q=receita+de+sufl%C3%AA+de+ab%C3%B3bora&ie=utf-8&oe=utf-8&rls=org.mozilla:pt-BR:official&client=firefox-a

O texto que digitei fica depois do “?q=” e vai até antes do “&ie=”, ou seja:

receita+de+sufl%C3%AA+de+ab%C3%B3bora

Portanto, a frase “receita de suflê de abóbora”, codificada na URL vira “receita+de+sufl%C3%AA+de+ab%C3%B3bora”. É fácil perceber que o que muda são os espaços (trocados por “+”) e as letras acentuadas (na verdade, os caracteres especiais em geral), que são trocadas por dois caracteres entre porcentagens (exemplo: %C3%).

Qual a utilidade? Inserir informações diretamente na URL. Por exemplo, acessando este endereço…

http://www.google.com.br/search?q=dicion%C3%A1rio+bil%C3%ADng%C3%BCe+portugu%C3%AAs+ingl%C3%AAs

…vocês já caem automaticamente na página de resultados do Google para “dicionário bilíngüe português inglês”. Para gerar um link destes automaticamente é preciso usar este método.

Exemplo:

Response.Write("Pesquise por 'pôneis siamêses' clicando aqui")

Um outro exemplo de utilização é criar um formulário de busca que encaminhe para a página de resultados do Google para o termo pesquisado.

Obtendo dados submetidos por formulários (POST) em ASP

Iran Rodrigues — Tue, 15 Jan 2008 22:26:31 +0000

Este post contém um exercício resolvido em sala, cujo objetivo é calcular o fatorial de um número fornecido por um usuário mediante um formulário.

O código abaixo ilustra a utilização de funções definidas pelo programador (“fatorial2″, neste caso) e da coleção Form do objeto Request.

Copiem este código e executem-no, analisando seu funcionamento:

<%@LANGUAGE="VBSCRIPT" CODEPAGE="1252"%>
<%
Function fatorial2(valor)
Dim i, mult
mult = valor
For i = valor-1 To 1 Step -1
mult = mult * i
Next
fatorial2 = mult
End Function

Dim valor, fatorial
valor = Request.Form("valor")
If (valor <> "") Then
fatorial = fatorial2(valor)
End If
%>




Untitled Document



<%
If (valor <> "") Then
Response.Write("Resultado: " & fatorial)
End If
%>

Fatorial de:

<%@LANGUAGE="VBSCRIPT" CODEPAGE="1252"%>
<%
Dim endereco
' Obtendo o endereço especificado no formulário
endereco = Request.Form("endereco")
' Se o endereço não estiver em branco, redirecionar o usuário
If (endereco <> "") Then
Response.Redirect(endereco)
End If
%>




Untitled Document




URL:

O Objeto Request

Iran Rodrigues — Mon, 14 Jan 2008 22:45:54 +0000

Continuando a série de posts sobre os objetos do ASP, veremos a estrutura do objeto Request.

O objeto Request tem por função acessar as requisições enviadas pelo cliente para o servidor.

Embora este objeto também possua propriedades e métodos, que podem ser vistos aqui (em inglês), o foco deste artigo será o que foi visto em aula, que compreende apenas as coleções do objeto Request.

As coleções são:

ClientCertificate
Cookies
Form
QueryString
ServerVariables

ClientCertificate

Esta coleção contém chaves e valores correspondentes a um certificado de segurança que o browser do cliente envia para o servidor. Somente é utilizado em sites que utilizam o protocolo HTTPS (HTTP Seguro), como sites de comércio eletrônico e bancos.

Em razão de sua utilização específica para HTTPS não executaremos o exemplo abaixo, envolvendo esta coleção, que permanecerá apenas na teoria.

<%
' Retorna a data inicial da validade do certificado:
Response.Write Request.ClientCertificate("validfrom")
%>

Cookies

O Request.Cookies é uma coleção que permite recuperar informações sobre o usuário e sua navegação que já tenham sido armazenadas através do Response.Cookie (reveja aqui).

Por exemplo, para recuperar o login de um usuário que tenha sido gravado em um cookie de nome “login”:

Response.Write("Usuário: " & Request.Cookies("login"))

Form

Esta é uma das coleções do Request mais úteis. Permite obter os dados que tenham sido enviados por um formulário utilizando o método post.

Por exemplo, para obter o nome de um usuário que o preencheu em um campo chamado “nome” de um formulário:

Response.Write("O nome informado foi: " & Request.Form("nome"))

QueryString

A coleção QueryString tem a mesma aplicação da Form. A diferença é que a QueryString aplica-se a dados submetidos via get ou variáveis inseridas diretamente na URL.

Exemplo:

Imagine um link que aponte para “excluir.asp?codigo=20″. O link indica que a página é “excluir.asp” e inclui ainda uma variável chamada “codigo” com valor 20. Para recuperarmos este valor no ASP, utilizamos:

Response.Write("Excluindo registro de código " & Request.QueryString("codigo") & "...")

ServerVariables

Esta coleção guarda diversas informações sobre o cliente e o servidor. Para acessarmos tais informações, utilizamos:

Request.ServerVariables("variavel")

Onde em “variavel” colocamos uma das variáveis predefinidas para esta coleção. Uma lista das variáveis pode ser encontrada no livro ou aqui (em inglês).

Alguns exemplos:

' Exibindo o IP do cliente:
Response.Write(Request.ServerVariables("REMOTE_ADDR"))
' Exibindo o IP do servidor:
Response.Write(Request.ServerVariables("LOCAL_ADDR"))
' Exibindo a página de onde o usuário veio:
Response.Write(Request.ServerVariables("HTTP_REFERER"))
' Exibindo informações sobre o browser do usuário:
Response.Write(Request.ServerVariables("HTTP_USER_AGENT"))

No próximo post, veremos o objeto Server.

O objeto Response

Iran Rodrigues — Thu, 13 Dec 2007 23:07:03 +0000

A partir deste post explicarei resumidamente como utilizar os principais objetos do ASP. Iniciaremos com o objeto Response.

O Response é o primeiro objeto do ASP que utilizamos ao começar a programar. Ao utilizarmos o comando Response.Write para escrever algo, estamos na verdade fazendo uso do método Write do objeto Response.

O objeto Response, no entanto, tem outros usos. Em outras palavras, este objeto possui outros métodos, além de algumas propriedades e uma coleção. Para quem não lembra, um método é como uma função, enquanto que uma propriedade assemelha-se a uma variável. A coleção é uma espécie de array.

Não vamos estudar todos os métodos e propriedades, apenas os principais. Quem desejar conhecer o objeto mais a fundo, comece clicando aqui (em inglês).

A função geral do objeto Response é acessar informações que são enviadas do servidor para o browser do cliente.

Response.Write

O Write é o já famoso método que escreve texto (podendo incluir código HTML e/ou Javascript) na página gerada. Equivale ao echo do PHP ou ao document.write do Javascript.

Ex.:

Response.Write("Linha de cima...
")
Response.Write("Linha de baixo!")
Dim numero
numero = 15
Response.Write(numero)

Response.Redirect

O Redirect é um método que permite encaminhar o usuário para uma URL. Equivale ao header(“Location: “) do PHP e ao location.href do Javascript (embora esta última seja uma propriedade, não um método).

Ex.:

Dim opcao
opcao =3
' A depender do valor da variável "opcao" o usuário vai para uma página diferente
Select Case opcao
Case 1
Response.Redirect("http://www.google.com.br")
Case 2
Response.Redirect("http://www.microcamp.com.br")
Case 3
Response.Redirect("http://www.iranrodrigues.com")
End Select

Response.Buffer

O Buffer é uma propriedade lógica – seu valor pode ser True ou False. Sua função é determinar se a saída produzida pelo processamento do script no servidor será enviada aos poucos (quando o valor é False) ou será enviada somente ao término de todo o processamento (quando o valor é True).

O valor padrão desta propriedade é False. Ou seja, se não a alterarmos, o comportamento padrão do servidor será enviar o fluxo HTML à medida em que o código é processado.

Response.Cookies

O “Cookies” é uma coleção que permite a criação (e alteração) de cookies na máquina do cliente. Os cookies servem para armazenar informações sobre a visita do usuário a uma página, como por exemplo o nome de usuário utilizado para efetuar login no site.

Para criarmos um cookie chamado “usuario” com o valor “maria”, utilizamos:

Response.Cookies("usuario")  = "maria"

Além de simplesmente definir um valor para o cookie, podemos alterar algumas propriedades extras:

Response.Cookies("usuario")  = "maria"
' Definindo uma data de expiração (daqui a 30 dias). Após essa data, o cookie não é mais utilizado.
Response.Cookies("usuario").Expires = Now + 30
' Definindo o domínio que pode acessar o cookie:
Response.Cookies("usuario").Domain = "microcamp.com.br"
' Definindo o caminho das páginas que podem acessar o cookie:
Response.Cookies("usuario").Path = "/www/home/pagina"
' Definindo se o cookie é seguro:
Response.Cookies("usuario").Secure = True

Para acessar as informações gravadas em um cookie, teremos de utilizar um outro objeto – o Request. Falarei sobre ele no próximo post.

Subrotinas e funções em VBScript

Iran Rodrigues — Tue, 04 Dec 2007 21:40:07 +0000

O VBScript possibilita a segmentação do código – tornando-o mais objetivo e reutilizável – com a criação de subrotinas e funções. Veja como utilizá-las e quais suas diferenças.

Nesta aula trabalhamos com subrotinas e funções no VBScript. O conceito de função na programação já foi visto em aulas anteriores. Uma explicação breve pode ser vista nesta aula, sobre funções no Javascript.

A grande diferença entre utilizar funções no Javascript, no PHP ou no VBScript é que, neste último, existe dois tipos de “função”: a função propriamente dita e a subrotina. Na verdade, ambas só diferem em uma questão: a função retorna um valor, enquanto que a subrotina não retorna nada.

Para ficar mais claro, vamos a um exemplo:

<%
' declaração de uma subrotina chamada mostraData
Sub mostraData ()
Dim hoje, dia, mes, ano
' array meses
Dim meses(11)
meses(0) = "janeiro"
meses(1) = "fevereiro"
meses(2) = "março"
meses(3) = "abril"
meses(4) = "maio"
meses(5) = "junho"
meses(6) = "julho"
meses(7) = "agosto"
meses(8) = "setembro"
meses(9) = "outubro"
meses(10) = "novembro"
meses(11) = "dezembro"
' obtém data atual
hoje = Date
' extrai o dia da data
dia = Day(hoje)
' extrai o mês da data
mes = Month(hoje)
' extrai o ano da data
ano = Year(hoje)
' exibe a data completa
Response.Write(dia & " de " & meses(mes-1) & " de " & ano)
' fim da subrotina
End Sub

Ao executar o código acima, vocês perceberão que nada acontece. Não há nada de errado. Apenas declaramos uma subrotina, mas não a utilizamos. Para utilizá-la, basta o seguinte:

' chamada à função
mostraData
' ou
Call mostraData
' com ou sem parênteses
mostraData()
Call mostraData()

Utilizamos quatro chamadas à função só para que ficasse claro que poderíamos fazê-lo de várias formas diferentes. Com ou sem a palavra “Call” e com ou sem parênteses.

Após a execução é possível compreender melhor o código da subrotina. O que ela faz é obter a data atual, extrair algumas informações desta data e exibí-la de uma forma específica. Após seu processamento, nenhuma informação produzida na subrotina é utilizada posteriormente no script, já que subrotinas não retornam valores.

Vamos conferir outro exemplo, desta vez utilizando parâmetros:

<%
Sub fatorial(numero)
Dim i, mult
mult = numero
For i = numero-1 To 1 Step -1
mult = mult * i
Next
Response.Write(mult)
End Sub

O parâmetro em questão é o que está entre os parênteses: o “numero”. Com a utilização de parâmetros (ou argumentos) é possível introduzir valores na subrotina ou função. No exemplo acima, a subrotina exibe o fatorial de um valor especificado. Como especificar esse valor? Vejamos:

' chamada à subrotina fatorial
Call fatorial(5)

O valor fornecido (5) entra na subrotina como sendo o valor para a variável de nome “numero”. Ou seja, os cálculos envolvendo a variável “numero” tomam por seu valor o parâmetro passado na chamada da subrotina. Desta forma podemos exibir o valor do fatorial de qualquer número, basta especificá-lo como parâmetro. Exemplos:

Call fatorial(9)
Call fatorial(8)
Call fatorial(7)
Call fatorial(6)

E se desejarmos fazer algo com o valor do fatorial, como armazená-lo em uma variável ou inserí-lo em um cálculo matemático? Isso só é possível se utilizarmos funções ao invés de subrotinas. Vejamos:

Function fatorial2(numero)
Dim i, mult
mult = numero
For i = valor-1 To 1 Step -1
mult = mult * i
Next
fatorial2 = mult
End Function

A declaração de uma função é bem similar à declaração de uma subrotina. A diferença é que em algum ponto da função é necessário atribuir um valor à função. Neste exemplo, isto acontece ao colocarmos “fatorial2 = mult”. Quando atribuímos um valor à função, estamos na verdade retornando um valor. Ou seja, é como se a função possuísse um valor, semelhante a uma variável.

Vejam também que não mostramos qual o resultado do fatorial. Não há nenhum Response.Write dentro da função. Na verdade, as funções tendem a ser tão genéricas quanto possível. Não exibindo o valor durante o processamento, a função permite que o façamos apenas quando for necessário (e se realmente for). Em uma determinada situação, poderemos exibir o resultado imediatamente, em outra, talvez não seja interessante exibí-lo. No exemplo acima, para mostrarmos esse valor ou armazenarmos em uma variável faríamos o seguinte:

' Chamando função
Dim valorFat
' Armazenando seu valor de retorno em uma variável
valorFat = fatorial2(4)
' Exibindo seu valor de retorno
Response.Write(valorFat)
' Inserindo a função dentro de uma expressão matemática e exibindo o resultado
Response.Write(fatorial2(5) + fatorial2(6))
%>

Dúvidas? Comentem…

Estruturas condicionais em VBScript

Iran Rodrigues — Tue, 27 Nov 2007 23:24:05 +0000

Veja como utilizar no VBScript as estruturas fundamentais de qualquer linguagem de programação: as estruturas condicionais.

As estruturas condicionais são conhecidas também como estruturas de decisão ou de seleção e, de forma geral, são uma das estruturas mais básicas de uma linguagem de programação. Caracterizam-se por permitir a execução de determinados códigos de programação dependendo da veracidade de uma condição.

O VBScript, assim como o PHP e o Javascript, possui estruturas do tipo “Se” e do tipo “Faça caso”, sendo o primeiro tipo recomendado para comparações únicas e o segundo para comparações seqüenciais envolvendo uma mesma variável ou valor.

Vamos a um exemplo simples: queremos exibir uma mensagem informando se um número armazenado em uma variável é par ou ímpar. Para tal, basta uma única comparação: é só compararmos o resto da divisão do número dado por 2. Se esse resto for zero, o número é par. Senão, é ímpar.

Dim a
a = 13
' Se o resto da divisão de "a" por 2 for zero, então...
If (a mod 2 = 0) Then
Response.Write(a & " é par!")
End If

Simples, não é mesmo? Tem duas coisas que diferem este “if” do “if” do PHP ou Javascript. A primeira é a palavra Then, que significa “então”. Não usamos nada parecido no PHP ou Javascript, mas quem programa em Pascal ou Delphi, vai achar o comando familiar. A segunda é a expressão End If, que finaliza o If. Em outras palavras, serve para delimitar o término das instruções que serão executadas a depender da condição. Lembrem-se de que no PHP e no Javascript utilizávamos as chaves com o mesmo objetivo.

Analisando o exemplo anterior, podemos perceber que não acontecerá nada ao ser executado. Isto é porque determinamos um comando a ser executado apenas para quando a condição seja verdadeira. Como o valor da variável é ímpar, nada acontece. Para tanto, utilizaremos o bom e velho Else (senão).

Dim a
a = 13
' Se o resto da divisão de "a" por 2 for zero, então...
If (a mod 2 = 0) Then
Response.Write(a & " é par!")
' Senão...
Else
Response.Write(a & " é ímpar!")
End If

Pronto. Problema resolvido. O código abaixo mostra, para todos os números de 1 a 100, quais são pares e quais são ímpares:

<%
Dim valor
For valor = 1 to 100
' Se o resto da divisão de "valor" por 2 for 0, então...
If (valor mod 2 = 0) Then
Response.Write(valor & " é par!
")
' Senão...
Else
Response.Write(valor & " é impar!
")
' Fim do If
End If
' Fim do For
Next
%>

Para um If mais complexo, utilizando mais de uma condição, é só utilizar os operadores relacionais, vistos nesta aula, além de utilizar adequadamente os parênteses. Exemplo:

Dim dia
' A função Date retorna a data atual
dia = Date
' A função WeekDay informa o dia da semana de uma data
' Se hoje for terça ou quinta...
If ((WeekDay(dia)=3) Or (WeekDay(dia)=5)) Then
Response.Write("Hoje teremos aula!")
End If

Para múltiplas comparações envolvendo uma mesma variável, torna-se mais interessante utilizar o comando Select. Confiram o exemplo abaixo:

Dim hoje, diaSemana
hoje = Date
diaSemana = WeekDay(hoje)
' A variável a ser comparada é a "diaSemana"
Select Case diaSemana
' Caso o valor dela seja 1...
Case 1
Response.Write("Hoje é domingo")
' Caso o valor dela seja 2...
Case 2
Response.Write("Hoje é segunda")
Case 3
Response.Write("Hoje é terça")
Case 4
Response.Write("Hoje é quarta")
Case 5
Response.Write("Hoje é quinta")
Case 6
Response.Write("Hoje é sexta")
' Para outro caso não listado acima...
Case Else
Response.Write("Hoje é sábado")
End Select

Esta é a estrutura padrão do Select. Ele realiza várias comparações a partir de uma mesma variável (ou valor), executando as instruções correspondentes assim que uma comparação é bem-sucedida. Percebam ainda a existencia de um “Case Else”. Seu uso é opcional, servindo para definir instruções que serão executadas apenas quando nenhuma condição anterior tiver sido verdadeira.

Bom, é isso. Quem quiser ler mais, pode ir neste link (em inglês).

Estrutura de repetição “Do… Loop”

Iran Rodrigues — Wed, 21 Nov 2007 23:00:08 +0000

O “Do… Loop” é a estrutura de repetição mais versátil do VBScript, podendo ser utilizada em diversas situações.

Além do for e do for each, ambos vistos na aula passada, o VBScript dispõe de mais algumas estruturas de repetição, das quais destaco o “Do… Loop”.

Utilizamos o “Do… Loop” quando pretendemos repetir uma ou mais instruções por um número indeterminado de vezes, ou seja, enquanto no for é necessário especificar quantas repetições queremos, no “Do… Loop” o que fazemos é estabelecer uma condição que determina quando a repetição irá parar, não importando o número de repetições.

O “Do… Loop”, na verdade, pode ser considerado não apenas uma, mas quatro estruturas diferentes. Ele pode ser utilizado para repetir algo enquanto uma condição for verdadeira (While) ou repetir algo até que uma condição seja verdadeira (Until). Para qualquer uma destas duas possibilidades, é possível comparar primeiro e então executar ou não as instruções (dependendo da condição) ou executar primeiro para depois comparar (e aí, repetir ou não, a depender da condição).

Vamos a exemplos práticos. O primeiro é um script que mostra o valor da variável “a” (inicialmente zero) e incrementa seu valor. Mostra o novo valor e incrementa novamente e assim por diante, enquanto o valor de “a” permanecer menor que 10.

Dim a
a = 0
' Faça enquanto "a" for menor que 10
Do While (a<10)
Response.Write(a & "
")
a = a + 1
' Volta ao "Do"
Loop
Response.Write("Fim 'Do While... Loop'
")

O “Do While” indica que a condição é testada primeiro, para que as instruções sejam ou não executadas. Se inicializássemos “a” com o valor 10, a condição “a<10″ seria falsa. Portanto, as instruções subseqüentes não seriam executadas, e o programa continuaria a partir da instrução Loop, que determina o fim do “Do While”.

O exemplo a seguir é similar, mas ilustra o uso do Until, fazendo com que as instruções sejam executadas até que a condição seja verdadeira. Logo, inicialmente esta deve ser falsa, senão nenhuma execução ocorreria. Inicialize “a” com o valor 10 e comprove.

a = 0
' Faça até que "a" seja igual a 10
Do Until (a=10)
Response.Write(a & "
")
a = a + 1
' Volta ao "Do"
Loop
Response.Write("Fim 'Do Until... Loop'
")

O próximo exemplo ilustra o uso do While após o Loop. Na prática, isso faz com que as instruções sejam executadas para, em seguida, a condição ser testada. Veja que a condição de repetição é “a>10″. “a” inicialmente vale 0, mas como a condição é testada só no final, o valor de “a” é mostrado, a variável é incrementada e, finalmente, a condição resulta em falso, de forma que nenhuma repetição acontece. Tente consertar o script para que ele exiba os números de 0 a 9.

a = 0
' Faça...
Do
Response.Write(a & "
")
a = a + 1
' Enquanto "a" for maior que 10, volte ao "Do"
Loop While (a>10)
Response.Write("Fim 'Do... Loop While'
")

Finalmente, o próximo exemplo mostra o uso do Until após o Loop. Da mesma forma que no exemplo anterior, a condição é testada após a execução do código dentro do “Do”.

a = 0
' Faça...
Do
Response.Write(a & "
")
a = a + 1
' Até que "a" seja maior que 10, volte ao "Do"
Loop Until (a>10)
Response.Write("Fim 'Do... Loop Until'
")

O exemplo a seguir, o último de hoje, ilustra o uso do “Do… Loop Until” para percorrer o array chamado “modulos” em busca do valor “ASP”. Ele compara o valor de cada um dos elementos do array, parando apenas quando encontra o elemento de valor “ASP”. Perceba que, da forma que foi construído, não importa a localização do valor “ASP” no array, ele sempre será encontrado.

' Declaração do array
Dim modulos(5)
' Inicialização
modulos(0) = "Javascript"
modulos(1) = "PHP/MySQL"
modulos(2) = "ASP"
modulos(3) = "Flash"
modulos(4) = "Projeto"
' Declaração da variável do índice
Dim i
i = 0
' Faça...
Do
' Mostra o elemento de índice "i"
Response.Write(modulos(i) & "
")
' Incremento do índice
i = i + 1
Loop Until (modulos(i-1) = "ASP")

Como exercício, modifique o código acima, trocando o “Do… Loop Until” por “Do While… Loop”.

Exercício – Arrays (valendo ponto)

Iran Rodrigues — Fri, 16 Nov 2007 01:54:27 +0000

Conforme prometido, aqui vai um exercício valendo um ponto para a nota de ASP. Enviem todo o codigo produzido para meu e-mail.

Crie um array unidimensional com 50 elementos;
Insira valores numéricos em cada uma de suas posições;
Exiba todos os valores armazenados no array;
Informe a soma de todos os elementos;
Informe a média dos mesmos;
Informe a mesma média, mas arrendondando-a para um inteiro;
Transfira todos os elementos do array para um outro array, invertendo as posições (ex.: o último elemento do array original vai para a primeira posição do novo array, o penúltimo para a segunda, etc.).

iranrodrigues.com - desenvolvimento web » ASP + VBScript

Conectando-se a um banco de dados Access através do ASP – Parte 2

Aprenda a realizar operações básicas envolvendo bancos de dados com o ASP.

Conectando-se a um banco de dados Access através do ASP – Parte 1

Aprenda a realizar as operações básicas envolvendo bancos de dados com o ASP.

O objeto Server

Continuando a sequência de artigos sobre os objetos do ASP, veremos aqui como utilizar o objeto Server.

Obtendo dados submetidos por formulários (POST) em ASP

Este post contém um exercício resolvido em sala, cujo objetivo é calcular o fatorial de um número fornecido por um usuário mediante um formulário.

O Objeto Request

Continuando a série de posts sobre os objetos do ASP, veremos a estrutura do objeto Request.

O objeto Response

A partir deste post explicarei resumidamente como utilizar os principais objetos do ASP. Iniciaremos com o objeto Response.

Subrotinas e funções em VBScript

O VBScript possibilita a segmentação do código – tornando-o mais objetivo e reutilizável – com a criação de subrotinas e funções. Veja como utilizá-las e quais suas diferenças.

Estruturas condicionais em VBScript

Veja como utilizar no VBScript as estruturas fundamentais de qualquer linguagem de programação: as estruturas condicionais.

Estrutura de repetição “Do… Loop”

O “Do… Loop” é a estrutura de repetição mais versátil do VBScript, podendo ser utilizada em diversas situações.

Exercício – Arrays (valendo ponto)