sa110-06001 « WordPress.com Tag Feed

Cronograma para entrega de projeto - SA110-06001

Iran Rodrigues — Sat, 14 Jun 2008 15:06:05 +0000

Pessoal, abaixo estão listadas as datas para a realização de cada uma das atividades que integram a elaboração do projeto da turma SA110-06001, conforme combinado na aula do dia 14/06/2008:

Definição de metas e prazos: hoje;

[elaboração da proposta]

Entrega da proposta: 21/06/2008;

[mão na massa]

Plantão (inicial) de dúvidas: 12/07/2008;

[mais mão na massa]

Plantão (final) de dúvidas: 26/07/2008;

[conclusão do site]

Hospedagem do site: 09/08/2008;

Avaliação: 16/08/2008.

As aulas só ocorrerão nas datas supracitadas. Quaisquer dúvidas também poderão ser esclarecidas por e-mail (iran@microcamp.com.br).

Alunos faltantes, contatem-me por e-mail para maiores esclarecimentos.

Atenciosamente,

Iran Rodrigues

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 (<table>). Dica: substitua os espaços em branco e a quebra de linha pelas tags <td> e <tr> (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 “<br>” numa página web. Se vocês digitarem no body, por exemplo, ao invés do texto “<br>” o que aparece é uma quebra de linha. Isso acontece porque o browser processa o texto “<br>” 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: <br>

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.

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

Utilizando arrays no VBScript

Iran Rodrigues — Sat, 10 Nov 2007 16:31:26 +0000

Utilizar arrays no VBScript é uma tarefa simples, mas que pode confundir quem está acostumado com Javascript ou PHP.

Atualizado em: 15/11/2007.

Arrays, matrizes ou vetores são estruturas de dados capazes de armazenar grupos de elementos que são acessados através de um índice.

No VBScript, ao contrário das variáveis comuns, o array precisa ser declararado explicitamente, da seguinte forma:

'declarando array com seis elementos
Dim meuArray(5)

Perceberam algo de estranho no comentário do código acima? Como o array tem seis elementos se o número entre parênteses é “5″? A resposta é: o número entre parênteses indica o último índice utilizável do array. Assim como no Javascript, os arrays no VBScript começam sempre pelo índice zero. E de zero a cinco, existem seis índices disponíveis.

Uma característica dos arrays no VBScript que os tornam ligeiramente diferentes dos arrays das outras linguagens estudadas é o uso dos parênteses para especificar o índice. No Javascript e no PHP, sempre especificamos o índice dentro de colchetes.

A seguir, um exemplo do uso dos arrays:

'declarando array com quatro elementos
Dim cores(3)
'inicializando o array
cores(0) = "azul"
cores(1) = "vermelho"
cores(2) = "amarelo"
cores(3) = "verde"
'exibindo os valores armazenados
Response.Write("Elemento 0: " & cores(0) & "
")
Response.Write("Elemento 1: " & cores(1) & "
")
Response.Write("Elemento 2: " & cores(2) & "
")
Response.Write("Elemento 3: " & cores(3) & "
")

Experimentem agora inicializar e exibir o elemento da posição nº. 4 do array “cores”:

'continuando o código anterior...
cores(4) = "branco"
Response.Write("Elemento 4: " & cores(4) & "
")

Executando o código acima, podemos perceber que ele ~~mostra o branco~~ gera uma mensagem de erro! Mas não há o que temer. O erro aconteceu porque tentamos acessar uma posição inexistente. Lembrem-se de que declaramos o array com quatro posições. A posição de nº. 4 é, na verdade, a quinta.

Podemos ainda declarar um array e alterar seu tamanho posteriormente, para incluir mais elementos. Isso é possível com o uso do comando ReDim. Enquanto o Dim serve para declarar variáveis, o ReDim serve para redeclará-las. Confiram o exemplo:

'Para que o ReDim funcione, precisamos declarar inicialmente o array sem especificar o tamanho
Dim frutas()
'O ReDim vai inicialmente definir o tamanho do array
ReDim frutas(3)
frutas(0) = "Manga"
frutas(1) = "Melancia"
frutas(2) = "Maracujá"
'Para colocarmos mais elementos, precisaremos aumentar o array
ReDim frutas(5)
'Agora cabem mais dois elementos
frutas(3) = "Morango"
frutas(4) = "Melão"
'Vamos agora exibir todos os elementos
Response.Write("Elemento 0: " & frutas(0) & "
")
Response.Write("Elemento 1: " & frutas(1) & "
")
Response.Write("Elemento 2: " & frutas(2) & "
")
Response.Write("Elemento 3: " & frutas(3) & "
")
Response.Write("Elemento 4: " & frutas(4) & "
")

Executem o código acima e vejam se tudo saiu como planejado. A resposta é: não! Aparentemente os elementos declarados antes do redimensionamento do array sumiram. O comportamento padrão do ReDim é zerar o array ao redimensioná-lo. Para evitar que isso ocorra, basta utilizar a opção Preserve. Confiram:

'Para que o ReDim funcione, precisamos declarar inicialmente o array sem especificar o tamanho
Dim frutas()
'O ReDim vai inicialmente definir o tamanho do array
ReDim frutas(3)
frutas(0) = "Manga"
frutas(1) = "Melancia"
frutas(2) = "Maracujá"
'A partir daqui, o ReDim não vai mais apagar os elementos, pois estamos usando o Preserve
ReDim Preserve frutas(5)
'Agora cabem mais dois elementos
frutas(3) = "Morango"
frutas(4) = "Melão"
'Vamos agora exibir todos os elementos
Response.Write("Elemento 0: " & frutas(0) & "
")
Response.Write("Elemento 1: " & frutas(1) & "
")
Response.Write("Elemento 2: " & frutas(2) & "
")
Response.Write("Elemento 3: " & frutas(3) & "
")
Response.Write("Elemento 4: " & frutas(4) & "
")

Imaginem agora que seja necessário armazenar em um array o nome e o CTR (número de matrícula) de um conjunto de alunos. Como isto poderia ser feito? Caso desejássemos armazenar tais informações para 10 alunos, seria preciso um array com 20 elementos. Mas como organizar as informações para que ficasse claro qual CTR pertence a um aluno?

A solução é: utilizando um array bidimensional. Um array bidimensional assemelha-se a uma tabela. Para acessarmos um elemento qualquer deste array é necessário especificar a linha e a coluna onde este se encontra. Portanto, um array bidimensional tem não só um, mas dois índices. Confiram o exemplo a seguir:

<%
'Declarando array bidimensional (5x2)
Dim alunos(4,1)

'O primeiro dígito representa o aluno, o segundo é "0" para nome e "1" para CTR
alunos(0,0) = "Josy"
alunos(0,1) = 1682
alunos(1,0) = "Filipe"
alunos(1,1) = 2244
alunos(2,0) = "Anderson"
alunos(2,1) = 2341
alunos(3,0) = "Daniel"
alunos(3,1) = 2327
alunos(4,0) = "Clautevânio"
alunos(4,1) = 1709
%>

Podemos visualizar o array acima como uma tabela, onde as linhas representam o primeiro índice e as colunas o segundo.

Índice	0	1
0	Josy	1682
1	Filipe	2244
2	Anderson	2341
3	Daniel	2327
4	Clautevânio	1709

Teoricamente, o VBScript suporta a criação de arrays com até 60 dimensões (60 índices diferentes), mas na prática dificilmente utilizamos além de dois.

Bom, até o momento temos utilizado o Response.Write de forma ostensiva para exibir na tela o valor armazenado em cada índice do array. Obviamente esta não é a forma mais inteligente de percorrer um array. Assim como em qualquer outra linguagem de programação que vimos até o momento, no VBScript também encontramos estruturas de repetição. A estrutura mais adequada à tarefa de percorrer um array é a for each, cujo funcionamento pode ser visto no código a seguir:

' Para cada elemento no array alunos
for each elemento in alunos
' elemento é cada um dos elementos do array
Response.Write(elemento & "
")
' delimita o for each
next

Percebam que não foi especificada a quantidade de iterações (repetições) a serem realizadas. O for each é capaz de saber o tamanho do array, de forma a percorrê-lo até o fim, automaticamente.

A variável “elemento” é utilizada para referir-se aos elementos que compõem o array, um de cada vez. Ou seja, a cada ciclo, “elemento” corresponde a uma posição diferente do array. Fora do for each, a variável não possui valor nenhum.

Finalizando, o for each é recomendado para arrays unidimensionais. Para um array bidimensional, como no código acima, a maneira como o for each percorre-o pode não ser a mais conveniente. Neste mesmo exemplo, foi mostrado primeiro todos os nomes dos alunos para, em seguida, serem mostrados os CTRs. Para um maior controle na forma como o array é percorrido é necessário o uso de outras estruturas de repetição, como o for. Confiram o código abaixo:

' O for permite um controle maior sobre a exibição dos elementos de um array multidimensional.
' Seu funcionamento está associado a uma variável de controle, que "conta" as repetições efetuadas e indica a hora de parar.
for i=0 to 4
' O "i" é a tal variável de controle. O valor de "i" muda a cada ciclo. Neste exemplo, ele começa valendo "0" e segue aumentando, uma unidade de cada vez, até chegar a valer "4" e realizar seu último ciclo.
response.Write("Nome: " & alunos(i,0) & ". CTR: " & alunos(i,1) & ".
")
next
%>

Embora por padrão a variável de controle seja incrementada em uma unidade por vez, o valor a ser incrementado pode ser estabelecido através do uso do parâmetro step:

' Repete 10 vezes, com "i" variando de 1 a 10 (1,2,3,4,5,6,7,8,9,10).
for i=1 to 10
...
' Repete 5 vezes, com "i" variando de 1 a 9 (1,3,5,7,9). "i" não chega a valer 10, pois se passasse do 9, chegaria a 11, que está fora do intervalo.
for i=1 to 10 step 2
...
' Repete 6 vezes, com "i" variando de 10 a 0 (10,8,6,4,2,0).
for i=10 to 0 step 2
...

Na próxima aula continuaremos com mais estruturas de repetição. Até!

Elaborando uma proposta para produção de um website

Iran Rodrigues — Sat, 10 Nov 2007 12:59:10 +0000

A primeira etapa na construção do website para o módulo “Projeto” consiste na elaboração de uma proposta de trabalho. Confira como elaborá-la.

A proposta de trabalho é um documento de leitura mais agradável que um contrato de prestação de serviços. É na verdade, o documento que antecede o contrato, caso esta seja aprovada. A proposta contém basicamente as seguintes informações:

Apresentação (quem é você? Você está qualificado para fazer este projeto? Como poderemos contatá-lo posteriormente?);
Resumo do projeto (qual a finalidade do site? Quais são as características mais relevantes? Quais tecnologias farão a diferença em relação aos concorrentes?)
Metodologia utilizada (quais são as etapas envolvidas? Qual o prazo para conclusão destas?)
Investimento (qual o valor do projeto? Quais custos estão inclusos? Qual o valor da manutenção? Como estes valores poderão ser pagos?)

Ao ler o documento, o cliente aceitará ou não a proposta com base principalmente nos seguintes aspectos:

Suprimento de suas necessidades
Valor a ser investido
Prazo para conclusão

Necessidades do cliente

Ao idealizar um website, devemos pensar nas necessidades do nosso cliente, isso é óbvio! O que talvez não seja tão óbvio assim é que as necessidades dos clientes de nosso cliente também têm um peso muito grande. Mas como saber quais as necessidades? A resposta: através de um briefing, que são as especificações do que o cliente quer você faça. Aqui está uma ótima leitura sobre o briefing.

Mudando de assunto, lembram das três leis da robótica, de Isaac Asimov, vistas no livro e filme “Eu, Robô”?

1ª lei: um robô não pode fazer mal a um ser humano e nem, por omissão, permitir que algum mal lhe aconteça.
2ª lei: um robô deve obedecer às ordens dos seres humanos, exceto quando estas contrariarem a primeira lei.
3ª lei: um robô deve proteger a sua integridade física, desde que com isto não contrarie as duas primeiras leis.

Pois bem, deixem o filme de lado e prestem atenção nestas três leis aqui:

1ª lei: o site deve atender a todas as necessidades e expectativas do cliente.
2ª lei: o site deverá atender a todas as possíveis necessidades dos clientes do seu cliente, exceto quando isto contrariar a primeira lei.
3ª lei: o site deverá atender a todas as suas expectativas, exceto quando isto contrariar as duas primeiras leis.

A razão para isso é o seguinte: o seu pagamento sai do bolso do seu cliente. O dinheiro do cliente vem do bolso dos clientes dele. Logo, com clientes insatisfeitos seu cliente não prosperará, nem poderá lhe pagar…

Valor do projeto

Todo mundo, quando começa a construir seus primeiros websites, tem uma mesma dúvida: quanto cobrar pelo serviço?

Ao invés de responder a esta pergunta, indico dois ótimos artigos esclarecedores:

Qual o valor de um projeto online (Cezar Calligaris)
Quanto cobrar por um website (Daniel Santana)

Além do que foi dito nos links acima, acrescento apenas o seguinte: não fale em “preço” para o cliente, pois lembra “gastos”, “despesas”. Fale sempre “investimento”, que lembra “dinheiro bem aplicado”.

Prazo para conclusão

Um outro ponto que é quase sempre gera problemas é quanto ao prazo. Não estipule um prazo menor do que o necessário só para que o cliente aceite a proposta. Provavelmente você não conseguirá cumprí-lo. Pense direitinho no tempo que você tem disponível e na parcela deste tempo que você irá parar o que estiver fazendo para se dedicar ao site. Lembre-se também de que shit happens contratempos acontecem. Outra coisa: é melhor terminar uma semana antes do prazo definido em dois meses do que terminar uma semana depois do prazo definido em um mês e meio.

Concluindo, deixo vocês com um belo modelo de proposta, de autoria de Walmar Andrade, da Fator W:

Proposta para a produção do site do Café Colombo

Operadores do VBScript (lógicos e de comparação)

Iran Rodrigues — Wed, 07 Nov 2007 02:46:05 +0000

Continuando o post anterior sobre operadores…

Operadores Lógicos

Os operadores lógicos são utilizados em expressões booleanas (lógicas) e podem retornar verdadeiro (True) ou falso (False). Os mais comumente usados são:

And (E): o operador And analisa dois valores lógicos, retornando verdadeiro apenas quando ambos são verdadeiros. Ex.:

'Retorna True, pois 10 é maior que 5 E 4 é maior que 1.
Response.Write((10>5) And (4>1))

A tabela-verdade para o And é a seguinte:

A	B	A AND B
F	F	F
V	F	F
F	V	F
V	V	V

Analogia – imagine as seguintes proposições:

A: tem quatro patas;
B: mia;
C: é um gato.

Podemos então dizer que a proposição C é verdadeira se as proposições A e B forem verdadeiras. Se tem quatro patas mas não mia, ou mia mas não tem quatro patas, não podemos dizer que é um gato. Logo, “A And B” é verdadeiro apenas se A for verdadeiro e B for verdadeiro. Portanto, podemos dizer que “C = A And B”.

Or (Ou): o operador Or analisa dois valores lógicos, retornado falso apenas quando ambos são falsos. Ex.:

'Retorna True, pois 3 é maior que 0. Basta que uma das condições seja verdadeira para que o resultado seja verdadeiro.
Response.Write((0>2) Or (3>0))

A tabela-verdade para o Or é a seguinte:

A	B	A OR B
F	F	F
V	F	V
F	V	V
V	V	V

Analogia – imagine que Samuel é flamenguista e anti-corinthiano. Agora imagine as seguintes proposições:

A: Flamengo classificado para a Libertadores da América;
B: Corinthians rebaixado;
C: Samuel feliz.

Samuel ficaria feliz se A ou B fossem proposições verdadeiras. Ficaria ainda muito feliz se ambas fossem verdadeiras. Logo, “C = A Or B”, pois não é imprescindível que A e B sejam ambas verdadeiras para que C o seja.

Not (Não): o operador Not é um operador unário (ao contrário dos anteriores, que são binários), o que significa que ele age sobre um único valor. O Not retorna o contrário do valor analisado. Ex.:

'Retorna False, pois 3 é maior que 0.
Response.Write(Not(3>0))

A tabela-verdade para o Not é a seguinte:

A	NOT A
V	F
F	V

Não precisa nem de analogia, não é?

Os demais operadores lógicos não são tão óbvios:

Xor (Ou exclusivo): o operador Xor analisa dois valores lógicos, retornado falso apenas quando ambos são equivalentes. Ex.:

'Retorna False, pois ambas as condições são verdadeiras.
Response.Write((10>7) Xor (2>1))

A tabela-verdade para o Xor é a seguinte:

A	B	A XOR B
F	F	F
V	F	V
F	V	V
V	V	F

Analogia – imagine que Clautevânio possui duas namoradas (uma não sabe da outra). Vai haver uma grande festa em Coruripe e Clautevânio pretende ir, mas apenas se uma de suas namoradas for. Vamos analisar as proposições:

A: Namorada nº 1 vai à festa;
B: Namorada nº 2 vai à festa;
C: Clautevânio vai à festa.

Quando é que a proposição C vai ser verdadeira? Ora, quando A ou B forem verdadeiras… mas, espere! Se A e B forem verdadeiras, Clautevânio não irá à festa, para não haver confusão. Essa é a diferença do Ou para o Ou exclusivo. Se A e B forem verdadeiras, o resultado para o Ou exclusivo é falso. Logo, “C = A Xor B” (e não “C= A Or B”).

Eqv (Equivale a): o operador Eqv analisa dois valores lógicos e retorna verdadeiro quando ambos são equivalentes. Justamente o oposto do Xor. Ex.:

'Retorna True, pois ambas as condições são verdadeiras.
Response.Write((10>7) Eqv (2>1))

A tabela-verdade para o Eqv é a seguinte:

A	B	A EQV B
F	F	V
V	F	F
F	V	F
V	V	V

Também não creio que seja necessário colocar uma analogia…

Imp (Implica em): o operador Imp analisa dois valores lógicos e retorna falso apenas quando o primeiro é verdadeiro e o segundo é falso. Ex.:

'Retorna False, pois a primeira condição é verdadeira, enquanto que a segunda não é.
Response.Write((0<1) Eqv (2>11))

A tabela-verdade para o Imp é a seguinte:

A	B	A IMP B
V	V	V
V	F	F
F	V	V
F	F	V

De acordo com a Wikipedia, “na lógica e na matemática, a implicação, ou condicional é a indicação do tipo SE… ENTÃO, indicando que uma condição deve ser satisfeita necessariamente para que a outra seja verdadeira”.

Analogia – imagine as seguintes proposições:

A: chove;
B: jardim fica molhado.

A Imp B equivale a dizer que se A é verdadeira, B tem que o ser. Ou seja, se afirmo que “se chove, o jardim fica molhado”, sempre que chover, o jardim ficará molhado. Mas não posso concluir a partir daí que se o jardim ficar molhado é porque choveu… de repente foi só alguém que molhou as plantas. Então se a proposição A (chove) for falsa, não podemos afirmar nada sobre B (jardim fica molhado). Daí, apenas uma situação resulta numa resposta falsa: quando chover e o jardim não ficar molhado, pois isso contraria o que afirmei anteriormente. Complicado?

Operadores de Comparação

Estes operadores são normalmente utilizados para a formulação de uma condição. São eles:

= (igual)
<> (diferente)
> (maior que)
< (menor que)
>= (maior ou igual)
<= (menor ou igual)

Não preciso dizer mais nada, não é? Apenas tenham cuidado para não usar erroneamente o “==” do PHP e Javascript aqui. No VBScript, igual é apenas um. Para atribuir valor ou comparar.

Operadores do VBScript (aritméticos e de concatenação)

Iran Rodrigues — Sun, 04 Nov 2007 16:43:20 +0000

O VBScript possui uma vasta gama de operadores – aritméticos, de concatenação, de comparação e lógicos.

Os operadores aritméticos básicos são os mesmos para todas as linguagens estudadas por nós durante o curso:

Soma (+)

Dim a, b, c
a = 11
b = 4
'Soma
c = a + b
Response.Write(c)
'Resultado: 15

Subtração (-)

'Subtração
c = a - b
'Resultado: 7
Response.Write(c)

Multiplicação (*)

'Multiplicação
c = a * b
'Resultado: 44
Response.Write(c)

Divisão (/)

'Divisão
c = a / b
'Resultado: 2,75
Response.Write(c)

Os próximos operadores aritméticos não são tão triviais assim…

Divisão inteira (\) – retorna a porção inteira do resultado

'Divisão inteira
c = a \ b
'Resultado: 2
Response.Write(c)

Resto (mod)

'Resto
c = a mod b
'Resultado: 3
Response.Write(c)

Exponenciação (^)

'Exponenciação
c = a ^ b
'Resultado: 14641
Response.Write(c)

Para concatenar strings, podem ser utilizados dois operadores: o “+” (mais), que assim como no Javascript, pode ser usado para somar e para concatenar e o “&” (“e” comercial). Este último é usado exclusivamente para concatenar – concatenando até números. Para evitar confusões, recomendo o uso do “&” para concatenação.

Concatenação (& ou +)

'Concatenação
a = "Micro"
b = "camp"
c = a & b
'Resultado: Microcamp
Response.Write(c)

Detecção e conversão de subtipos em VBScript

Iran Rodrigues — Sun, 04 Nov 2007 16:30:34 +0000

Veja como detectar o subtipo de uma variável no VBScript e avaliar se seu valor pode ser convertido ou não em um outro subtipo.

Na última aula, neste link, conhecemos os subtipos de valores do VBScript. Veremos agora como detectar o subtipo de uma variável, bem como converter seu valor de um subtipo para outro.

Valores numéricos

A função IsNumeric() retorna um valor lógico, indicando se o valor fornecido (entre parênteses) é um número ou pode ser convertido em tal.

Exemplos:

Dim valor
' valor recebe número inteiro
valor = 35
Response.Write(valor)
Response.Write(" é numérico? -> ")
' IsNumeric informa se a variável contém um número
Response.Write(IsNumeric(valor))
Response.Write("
")

' valor recebe string
valor = "abc"
Response.Write(valor)
Response.Write(" é numérico? -> ")
Response.Write(IsNumeric(valor))
Response.Write("
")

' valor recebe string com números
valor = "123"
Response.Write(valor)
Response.Write(" é numérico? -> ")
Response.Write(IsNumeric(valor))
Response.Write("
")

' valor recebe data (a data é inserida entre tralhas (cerquilhas, jogos-da-velha, etc) no formato mês/dia/ano)
valor = #11/24/2007#
Response.Write(valor)
Response.Write(" é numérico? -> ")
Response.Write(IsNumeric(valor))
Response.Write("
")

' valor recebe booleano
valor = True
Response.Write(valor)
Response.Write(" é numérico? -> ")
Response.Write(IsNumeric(valor))
Response.Write("
")

Com os exemplos acima, podemos perceber quais subtipos são considerados numéricos pelo VBScript. Estes valores considerados numéricos podem ser convertidos em um número propriamente dito usando uma das seguintes funções:

CByte() – converte para um inteiro de subtipo byte;
CInt() – converte para um inteiro de subtipo integer;
CLng() – converte para um inteiro de subtipo long;
CSng() – converte para um real de subtipo single;
CDbl() – converte para um real de subtipo double.

A diferença entre os subtipos está na capacidade de armazenamento (por exemplo, o byte só suporta números entre 0 e 255) – lembrando que isso já foi visto na aula anterior.

Exemplos de conversões para valores numéricos (as conversões que resultam em estouro devem ser testadas e depois comentadas, para que o script não seja interrompido):

Dim valor
valor = "300"
' Convertendo para byte (estouro, pois o byte só suporta até 255)
Response.Write(CByte(valor))
' Convertendo para integer (OK)
Response.Write(CInt(valor))
valor = "40000"
' Convertendo para integer (estouro, pois o integer só suporta até 32767)
Response.Write(CInt(valor))
' Convertendo para long (OK)
Response.Write(CLng(valor))

Uma data pode ser convertida para um número inteiro. O valor obtido representa o número de dias passados desde o dia 30/12/1899 até a data especificada. Por exemplo, a data #2/1/1900# (primeiro de fevereiro) corresponde ao número 33.

Se à data é acrescida uma hora, como em #2/1/1900 12:00:00#, esta pode ser convertida em um número real, onde a parte decimal corresponde às horas passadas (representadas como frações do dia. A data especificada corresponde então ao número 33,5.

Dim dia
dia = #12/10/2007 19:42:00#
' Convertendo para double (OK)
Response.Write(CDbl(dia))

Datas

Para determinarmos se um valor é uma data/hora em potencial, utilizamos a função IsDate(). Confiram os exemplos:

Dim data
data = #11/24/2007#
Response.Write(IsDate(data))
data = "2/30/2007"
Response.Write(IsDate(data))
data = #21/22/2007#
Response.Write(IsDate(data))

Para a conversão, é usada a função CDate():

Dim valor
' valor = "20/25/2007"
' Convertendo para data (tipos incompatíveis)
'Response.Write(CDate(valor))
' valor = "12/25/2007"
' Convertendo para data (OK)
'Response.Write(CDate(valor))

Valores vazios ou nulos

Existem ainda funções para verificar se um valor é vazio ou nulo:

IsEmpty() – retorna verdadeiro quando uma variável está vazia – isto é, não foi incializada, apenas declarada – ou contém o valor empty, ou ainda null;
IsNull() – retorna verdadeiro quando uma variável contém o valor null.

' Declarando a variável "a"
Dim a
' Ela ainda não foi inicializada, logo, está vazia (mas não nula)
Response.Write("a é vazio =>")
Response.Write(IsEmpty(a))
Response.Write("
")
Response.Write("a é nulo =>")
Response.Write(IsNull(a))
Response.Write("
")
' O resultado acima também ocorreria caso inicializássemos a com o valor Empty
' Um valor só é nulo quando é explicitamente inicializado como Null
Dim b
b = Null
Response.Write("b é vazio =>")
Response.Write(IsEmpty(b))
Response.Write("
")
Response.Write("b é nulo =>")
Response.Write(IsNull(b))
Response.Write("
")

Embora algumas destas funções talvez nunca venham a ser usadas, algumas são muito úteis, podendo ser aplicadas, por exemplo, para a validação de dados submetidos via formulário.

Arquivos do mini-blog

Iran Rodrigues — Sat, 03 Nov 2007 16:20:36 +0000

Pessoal, disponibilizarei aqui os arquivos criados por nós durante a construção do blog. Estes serão atualizados conforme façamos novas alterações.

Atualizado em 08/11/2007:

Um trabalhinho para vocês… na última aula comentei que iria atualizar os arquivos, inserindo um link para sair da página (e encerrar a sessão). Pois bem, vou deixar esta tarefa para vocês… é bem simples.

A função que faz o “logout” do usuário é a session_destroy. Esta função, como o nome sugere, destrói os dados armazenados em sessões. Desta forma, o usuário é “esquecido” pelo sistema, tendo que fazer login novamente.

Mas mesmo para destruir a sessão, é necessário o uso da função session_start para iniciá-la (é como o Windows: quando você quer desligar o computador, você clica em “Iniciar”).

Finalizando, o link então deverá apontar para uma página contendo chamadas para as duas funções, na ordem correta – primeiro a session_start e depois a session_destroy, e exibir uma mensagem avisando ao usuário que ele saiu do sistema.

Mãos à obra!

Arquivo sa_aula8_index.php:






Untitled Document









">Comente | ">Ver comentários

| ">Excluir
| ">Editar

Arquivo sa_aula7_login.php:






Untitled Document




Login:



Senha:

Arquivo sa_aula7_cad_posts.php:






Untitled Document




Título:



Texto:

Arquivo sa_aula5_cad_autores.php:


http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">


Untitled Document




Login:



Senha:



Nome:

Arquivo conexao.php:

Arquivo comente.php:


http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">


Untitled Document




Seu nome:



Seu e-mail:





Comentários
:

Arquivo editar.php:


http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">


Untitled Document




Título:
" size="60" maxlength="100" />


Texto:


<?= $infoPost["texto"] ?>

Arquivo excluir.php:


http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">


Untitled Document

Começando a programar em ASP

Iran Rodrigues — Wed, 31 Oct 2007 02:11:40 +0000

Como em toda primeira aula de um novo módulo, iniciamos com teoria (definição, características, etc.) acerca do ASP, que pode ser resumida assim:

O ASP (de Active Server Pages) é uma estrutura de programação em Script que se utiliza de VBScript, JScript, PerlScript ou Python processadas pelo lado servidor para geração de conteúdo dinâmico na Web.

Ele roda nativamente em servidores Windows, através do serviço chamado de IIS (Internet Information Service) – o servidor web da Microsoft, ou do PWS (Personal Web Server) em ambientes com Windows 98. Além disso ele pode rodar em outras plataformas, como Linux no servidor Apache quando usando um Módulo de um programa como o Tomcat.

O script é interpretado no lado do servidor e o que é enviado ao lado do usuário/utilizador (navegador, por exemplo) é apenas a saída. que normalmente é uma linguagem de marcação como HTML, XHTML ou XML.

Linguagens como o Javascript e o VBScript podem ser processadas pelo navegador do visitante e, neste caso, este precisa ser compatível com a linguagem. Contudo, como o ASP é processado pelo servidor, há independência de navegadores, uma vez que eles só processarão HTML.

Através dessa tecnologia também é possível executar consultas a Banco de Dados, através da biblioteca de componentes ActiveX.

O uso desta tecnologia vem diminuindo sensivelmente pela maturação da tecnologia .NET, sendo gradativamente substituído pelo ASP.NET que proporciona uma gama maior de recursos e um melhor desempenho.

Fonte: Wikipedia.

Após a apresentação formal ao ASP, vimos como instalar o componente IIS e como criar um diretório virtual, para que pudéssemos acessar via browser as páginas que viessem a ser produzidas.

Quem perdeu a aula, veja aqui como instalar o IIS e aqui como criar um diretório virtual.

Em seguida, vimos como construir nosso primeiro programa:

<% Response.Write("Alô mundo!") %>

Onde Write é um método do objeto Response que tem por finalidade enviar texto ao browser (da mesma forma que o echo para o PHP). O “<%” e o “%>” são os delimitadores da linguagem, que separam o que será processado no servidor – sendo, portanto, código VBScript – do que será processado diretamente pelo browser – HTML, Javascript, etc.

Pudemos perceber que o VBScript não requer um delimitador de instruções, como o ponto-e-vírgula (;) do PHP. Embora, caso prefiramos utilizar eventualmente mais de uma instrução em uma mesma linha, torna-se necessário o uso dos dois pontos (:) para separar as instruções que coexistem na mesma linha. Ex.:

<% Response.Write("Alô ") : Response.Write("mundo!") %>

Vimos também como declarar variáveis:

<% Dim a %>

E vimos ainda a diretiva…

<% Option Explicit %>

…que torna obrigatória a declaração explícita de qualquer variável que venha a ser utilizada posteriormente.

Subtipos de dados do VBScript

Iran Rodrigues — Sun, 04 Nov 2007 16:17:10 +0000

Nesta aula, vimos que qualquer variável declarada no VBScript possui um só tipo: Variant. Portanto, para armazenar números (inteiros ou não), strings, valores lógicos (booleanos), ou quaisquer outros valores, não é necessário o uso de variáveis de tipo específico.

Na prática, uma mesma variável pode ser utilizada para armazenar valores diversos, como no exemplo a seguir:

Dim valor
'valor recebe número inteiro
valor = 10
Response.Write(valor)
Response.Write("
")
'valor recebe número real
valor = 25.3
Response.Write(valor)
Response.Write("
")
'valor recebe string
valor = "Palavra"
Response.Write(valor)
Response.Write("
")
'valor recebe booleano
valor = True
Response.Write(valor)
Response.Write("
")
'valor recebe data no formato mês/dia/ano
valor = #11/1/2007#
Response.Write(valor)
Response.Write("
")
'valor recebe hora
valor = #20:44:15#
Response.Write(valor)
Response.Write("
")

Obs.: Percebam que, ao contrário do PHP (onde datas são introduzidas como números ou strings), no VBScript podemos atribuir diretamente uma data e/ou hora a uma variável, devendo o valor estar entre tralhas (jogo-da-velha). Internamente este valor é armazenado como um número.

A partir do valor atribuído a uma variável, é possível definir seu subtipo. Ou seja, embora uma variável não possua um tipo definido – sendo todas Variant – a depender do valor que ela armazena no momento, ela passa a pertencer a um subtipo. No código acima, a mesma variável – valor – recebeu valores diversos, o que resultou na constante mudança de seu subtipo.

Os subtipos em VBScript são os seguintes:

Subtipo	Descrição
Empty	O valor é zero para variáveis numéricas ou uma string de tamanho zero (“”), para variáveis de texto.
Null	A variável não contém dados válidos.
Boolean	Contém True (Verdadeiro) ou False (Falso).
Byte	Contém um número inteiro de 0 a 255.
Integer	Contém um número inteiro de -32.768 a 32.767.
Currency	Contém um número de -922.337.203.685.477,5808 a 922.337.203.685.477,5807.
Long	Contém um número inteiro de -2.147.483.648 a 2.147.483.647.
Single	Contém um número de ponto flutuante de precisão simples na faixa de -3,402823E38 a -1,401298E-45 para valores negativos ou de 1,401298E-45 a 3,402823E38 para valores positivos.
Double	Contém um número de ponto flutuante de precisão dupla na faixa de -1,79769313486232E308 a -4,94065645841247E-324 para valores negativos ou de 4,94065645841247E-324 a 1,79769313486232E308 para valores positivos.
Date (Time)	Contém um número representando uma data entre 1º de janeiro de 100 a 31 de dezembro de 9999.
String	Contém uma string de tamanho variável que pode conter até aproximadamente 2 bilhões de caracteres.
Object	Contém um objeto.
Error	Contém um código numérico de erro.

Nas próximas aulas, veremos funções que permitem identificar o atual subtipo de uma variável, bem como realizar conversões entre estes subtipos.