Workshop de ASP

helldanger1 · Mai 27, 2009

Artigos práticos sobre a programação de Active Server Pages, a linguagem de programação de Microsoft do lado do servidor com o qual poderemos criar aplicações web muito interessantes.

helldanger1 · Mai 27, 2009

Melhorar o registro em buscadores

Explicamos uma forma simples e efetiva de registrar a maior quantidade de URLS possíveis para sites programados em ASP.

Por Rubén Alvarez

O princípio de uma página com êxito é sem dúvida, a qualidade e o interesse de seus conteúdos. Não obstante, a este êxito contribuem muitos outros fatores como o desenho e a divulgação.

Este último aspecto, a divulgação, tem como uma das suas principais chaves de desenvolvimento, o correto registro em motores de busca. Os motores se encarregam de chegados à página a registrar, percorrê-la de cima à baixo a partir dos links que nela figuram e desta forma armazenar os dados que interessam a ele: etiquetas meta, texto...

O problema com as páginas dinâmicas é que, em muitas ocasiões, os links apresentam URLs complexas pelas quais se estão passando variáveis e que são dificilmente digeríveis pelos motores. Resultado: a quantidade de páginas registradas pelo buscador se vê sensivelmente diminuída.

Para determinados sites, isto não é um verdadeiro problema, entretanto, para outros nos quais uma única visita interessada pode supor um benefício importante ou também sites de lojas virtuais que vendem artigos exóticos, o fato de não estar eficientemente registrado pode supor uma séria limitação. E de qualquer forma, todos nós gostaríamos que nossa página aparecesse bem situada em uma busca.

Este suposto problema de registro devido à utilização de páginas dinâmicas pode resultar, contrariamente, uma valiosa vantagem. O único que se deve fazer é evitar passar parâmetros por meio das URLs. Mas... Como?

Simplesmente, no lugar de propor links do tipo:

http://www.meusite.com/script.asp?variavel=valor

O que faremos é mostrar um link como este:

http://www.meusite.com/valor/

Além disso, criaremos um diretório chamado "valor" dentro do qual introduziremos que conterá atribuição do valor da variável e incluiremos o script principal como um arquivo anexo. O arquivo, o interior do diretório seria o seguinte:

<%
variavel=valor
%>


Como exemplo podemos pensar numa loja virtual, sem ir muito longe nossa conhecida livraria virtual. Neste caso, poderíamos criar um diretório por título existente que poderia levar como nome a referência do livro. Dentro de cada diretório introduziríamos um arquivo do tipo anteriormente visto:

<%
id=referencia_do_livro
%>


No script de busca.asp poderíamos ademais introduzir umas etiquetas meta que fizessem chamadas ao banco de dados do qual poderíamos tirar informações específicas do livro em questão, por exemplo:

<META name="description" content="<%=RecordSet("descripcion")%>">

Com isto, não somente permitimos que o buscador possa ter acesso às páginas de todos os artigos como também personalizamos as etiquetas meta de forma automática e permitimos assim posicionar nossa página de uma maneira eficiente frente a determinadas buscas de internautas interessados por uma obra em particular.

Por outro lado, a criação dos diretórios e do arquivo que contem a variável pode ser facilmente realizadas e coordenadas ao sistema intranet a partir do qual realizamos as atualizações de nosso banco de dados. Esta automatização poderia ser culminada com um procedimento que permitisse, em caso de eliminação de um livro de nosso banco de dados, modificar o arquivo que contem a variável por outro que encaminha à página de entrada de nosso site. Desta forma não só ganhamos visitantes por nosso catálogo atual como também conseguimos atraí-los por existências anteriores!

Como se pode ver, trabalhar com uma linguagem dinâmica para a criação de um site baseado na exploração de um banco de dados pode ser assombrosamente útil se for realizado de uma forma inteligente. Com só página e um script de automatização estamos dispostos a registrar em motores de buscas tantas URLs como registros tivermos em nosso banco, tudo isto de uma forma simples e eficaz. Ademais, este tipo de estratégia pode ser facilmente adotado por sites já existentes sem precisar mexer nada no código.

helldanger1 · Mai 27, 2009

Include. Incluir arquivos ASP

Para incluir arquivos em ASP deve-se utilizar os include. Iremos revisá-los neste capítulo e também mostraremos as limitações desta técnica e alguma possível solução.

Por Miguel Angel Alvarez - Tradução de JML

Incluir arquivos em uma página consiste em inserir um pedaço de código que temos alojado em um arquivo a parte dentro do código da página ASP que estamos programando. Deste modo, podemos salvar um arquivo código das páginas que utilizamos habitualmente, como poderia ser o cabeçalho de nossas páginas ou a moldura que apresentam todas as páginas do site, e inclusive scripts em ASP que se dediquem a realizar algumas ações muito repetidas, como conexões com bases de dados. Trabalhar realizando includes é muito prático, pois não escrevemos duas vezes o mesmo código e além disso, se tivermos que muda-lo em algum momento somente teríamos que mudar o código desse arquivo a parte e todas as páginas serão modificadas automaticamente.

Para incluir arquivos em ASP deve-se utilizar os tópicos include que já vimos em capítulos anteriores, mas que revisaremos neste capítulo. Também, vamos mostrar limitações desta técnica e alguma possível solução.

Incluir arquivos

Utiliza-se com o enunciado de include, que pode ter duas formas:




As diferenças entre realizar o include "virtual" ao invés de "file" consistem em que a primeira tem em conta a raiz de seu domínio e com a segunda se tem em conta o lugar onde está o documento no qual estamos incluindo o arquivo. À princípio, pode ser mais útil trabalhar com o modo "virtual" pois se movemos de diretório as páginas de nosso site os includes continuarão funcionando. Vendo vários exemplos poderemos entendê-lo melhor.


Incluímos um arquivo chamado cabeçalho que está no diretório planilhas, que está por sua vez na raiz do domínio. Com este método o include funcionará independentemente de onde estiver o arquivo que o inclui.


Isto só funcionará se o arquivo que realiza o include estiver na raiz do domínio. Mas falhará se estivermos em qualquer subdiretório do domínio.


Assim, conseguiríamos que funcionasse se o arquivo o qual incluímos o cabeçalho estiver em um subdiretório imediatamente depois da raiz do domínio.

Include e a segurança

À princípio podemos utilizar qualquer extensão no arquivo que vamos incluir. As extensões mais correntes são .txt, .inc, .html ou .asp. Entretanto, é recomendável por motivos de segurança, nomeá-los como .asp, sobretudo se inserimos código ASP dentro do arquivo a incluir.

O motivo pelo qual é mais seguro nomear os includes com extensão .asp é que se um usuário tentar acessar ao arquivo que se inclui diretamente teclando sua URL na barra de endereços do navegador, algo assim como http://www.dominio.com/arquivos_a_incluir/funcoes_comuns.inc, receberia como resposta o código completo e sem executar do include e, provavelmente, não nos interesse que vejam esse código de nosso web site. É especialmente delicado este problema quando dentro do código colocamos informação crítica como pode ser a cadeia e conexão à base de dados.

Com a extensão .asp nos asseguramos que, no caso de que um usuário consiga acessar aos includes, estes se executarão no servidor e se eliminarão todos os códigos ASP que não desejarmos distribuir.

Modo de funcionamento e problemática

O modo de funcionar deste tipo de includes consiste em que primeiro se inserem os arquivos na página, criando um conjunto que será formado pelo arquivo fonte e todos os includes inseridos dentro dele. Uma vez criado esse grande diretório, executam-se os scripts ASP.

Poderia haver um problema se quisermos incluir um arquivo cujo nome devemos extrair de uma variável ASP. Imaginem que temos que incluir um arquivo que temos seu nome numa variável. Assim:

<%
arquivoInclude = "meuarquivo.html"
%>


Como o código ASP não se executa até depois de haver incluído o arquivo, na hora de incluí-lo não se resolveu o nome que se deseja incluir. Com outras palavras, ASP não sabe o que é que vale a variável arquivoInclude quando vai incluí-lo, portanto não realiza o include tal como desejaríamos.

Para dar um bom parâmetro a uma página web e que sua utilização seja fácil mais cedo ou mais tarde, o anterior será um inconveniente. Portanto, podemos resolver o problema da seguinte forma, criando uma função que realize o include do arquivo. Vejamos como seria essa função:

<%
function inclui(arquivo)
arquivo= request.serverVariaveis("APPL_PHYSICAL_PATH") & arquivo
set confile = createObject("scripting.filesystemobject")
set fich = confile.openTextFile(arquivo)
while not fich.atEndOfStream
lineactual = fich.readLine
response.write(lineactual)
wend
end function
%>

Teríamos que comentar várias coisinhas sobre esta função. Recebe o nome do arquivo que desejamos abrir. Para construir a rota completa deste arquivo teremos que utilizar o objeto request para extrair a variável do servidor que contem a rota do disco rígido onde se encontra o domínio. Uma vez construído o nome do arquivo com sua rota, criamos o arquivo nas 2 seguintes linhas. Finalmente, fazemos um loop que vai extraindo do arquivo o texto correspondente e imprimindo na página.

Somente destacamos um ponto contra esta forma de incluir os arquivos. Trata-se de que não poderemos incluir nada mais que código HTML, nunca código ASP, pois não se executaria e ficaria impresso na página junto com o código HTML. É uma limitação significativa, mas nos casos nos quais somente necessitamos incluir texto pode servir muito bem.

helldanger1 · Mai 27, 2009

Crie seu próprio buscador

Propomos um buscador básico para implementar em seu website, além de lhe mostrar funções para o tratamento de variáveis tipo cadeia que podem ser muito úteis para outras aplicações .

Por Rubén Alvarez

Quando trabalhamos com sites baseados em bancos de dados e nossos conteúdos começam a crescer, pode ser muito prático para o navegante poder recorrer a um formulário no qual possa introduzir palavras-chaves e operadores que lhe ajudem a matizar o elemento que estiver buscando. Este tipo de campo pode ser visto em uma infinidade de páginas e, embora sejam distintos em seu funcionamento em muitos casos, todos têm algo em comum: tratam-se de programas que permitem processar uma variável do tipo cadeia e transforma-la em uma ordem de busca para o banco de dados.

Neste artigo vamos propor duas funções que, usadas conjuntamente, permitem a criação de uma instrução SQL. O script permite especificar quais serão os campos de busca e dentro de que tabela a realizaremos.

Este programa deverá ir combinado com outro pequeno script de colheita de dados por formulário como os vistos em nosso manual de ASP a partir do qual obteríamos a variável cadeia introduzida pelo internauta.

Estas duas funções podem ser utilizadas diretamente para cada caso particular a condição de especificar os campos de busca no array campos, especificar a tabela e modificar a função gerasql para que realize a seleção dos campos que desejarmos.

Neste caso, com o objetivo de facilitar a compreensão simplificamos ao máximo as funções que o buscador pode realizar. Na verdade, o buscador só tratará campos usando o operador like. Por outro lado, empregará unicamente como operadores "+" e "-".

Todo tipo de modificações mais ou menos complexas, podem ser introduzidas de forma a melhorar sua versatilidade:

-Emprego de parênteses para maior eficácia dos operadores

-Eliminação de seqüências repetidas como "++" ou "--"

-Eliminação de operadores no princípio e final da cadeia

-Utilização de curingas...

Passamos agora a mostrar a lista para poder comentá-lo mais detalhadamente a seguir:
<%
function Tirar(cadeia,campos)
dim i
dim TirarAux
while InStr(cadeia," ")
Cadeia=Replace(Cadeia," "," ")
wend
if len(cadeia)>0 then
if InStr(cadeia," ")>0 then
Tirar= Tirar(left(cadeia,InStr(cadeia," ")-1),campos) & " OR " & Tirar(right(cadeia,len(cadeia)-InStr(cadeia," ")),campos)
elseif InStr(cadeia,"+")>0 then
Tirar=Tirar(left(cadeia,InStr(cadeia,"+")-1),campos) & " AND "& Tirar(right(cadeia,len(cadeia)-InStr(cadeia,"+")),campos)
elseif InStr(cadeia,"-")>0 then
Tirar=Tirar(left(cadeia,InStr(cadeia,"-")-1),campos) & " AND NOT " & Tirar(right(cadeia,len(cadeia)-InStr(cadeia,"-")),campos)
else
'observamos a sentenca
TirarAux=""
i=1
TirarAux= "( " & campos(i) & " Like '%" & cadeia & "%'"
i=i+1
while len(campos(i))>0
TirarAux= TirarAux & " OR " & campos(i) & " Like '%" & cadeia & "%'"
i=i+1
wend
TirarAux=TirarAux & " )"
Tirar=TirarAux
end if
else
tirar=""
end if
end function

function GeraSql(cadeia,tabela,campos)
if len(cadeia)>0 then
geraSql="Select * from " & tabela & " Where " & Tirar(cadeia,campos)
else
Response.Write "Nao ha criterios"
end if
end function

dim campos(3) 'o tamanho do array deve superar em um ao numero de campos
campos(1)="nome_campo1"
campos(2)="nome_campo2"

'para mostrar qual seria o resultado...
cadeia="ola carioca+cocacola-nescau"
tabla="qualquer"
resultado=GeraSql(cadeia,tabela,campos)

Response.Write resultado
%>

Como dissemos, o script consta principalmente de duas funções. A primeira delas, tirar, se encarrega de tratar a cadeia para separar as palavras e, tendo em conta os operadores, construir o fragmento final da sentença SQL. A busca se realiza dentro de uma série de campos que são definidos ao exterior da função em forma de array.

Nesta função se empregam diferentes funções de tratamento de variáveis de tipo cadeia, as quais explicamos a seguir:
InStr(cadeia,subcadeia) Devolve o número das posições nas quais uma determinada sub-cadeia aparece na cadeia principal
Replace(cadeia,subcadeia1,subcadeia2) Substitui um fragmento (subcadeia1) de uma cadeia por um novo fragmento (subcadeia2)
Len(cadeia) Devolve-nos a longitude da cadeia
Left(cadeia,numero_caracteres) Seleciona uma determinada quantidade de caracteres de nossa cadeia começando pela esquerda
Right(cadeia,numero_caracteres) Seleciona uma determinada quantidade de caracteres de nossa cadeia começando pela direita

É interessante observar a técnica de recursividade que se utiliza para decompor a cadeia principal em palavras independentes. Esta técnica se baseia em que função tirar se chama a si mesma para cada uma das sub-cadeias da cadeia principal. A parte dessa pequena astúcia o resto da função é de leitura fácil.

A segunda função, gerasql, se encarrega de acrescentar ao fragmento final tabela e o tipo de seleção que queremos realizar. Neste caso foram selecionados como resultado todos os campos da tabela, mas evidentemente, isto não tem porquê ser assim.

A última parte do script consiste na especificação dos campos dentro dos quais desejamos realizar nossa busca. A observar que o array há de ter uma longitude maior ao número de campos para o correto funcionamento do programa.

helldanger1 · Mai 27, 2009

O objeto RecordSet

Descrevemos alguns dos métodos e propriedades que nos ajudarão a tomar partido deste objeto.

Por Rubén Alvarez

Em nosso manual de ASP introduzimos as noções imprescindíveis para a interação com base de dados. Explicamos como conectar com a base de dados e de que forma podemos realizar as consultas mediante sentenças SQL.

Entretanto, temendo carregar em excesso um manual orientado a aprendizes, não apresentamos de uma maneira oficial os ADO (ActiveX Data Objects).

Quando interagimos com uma base de dados há três ações principais que são realizadas por três objetos diferentes:

-Primeiramente realiza-se uma conexão à base de dados. Esta tarefa é realizada pelo objeto Connection ao qual teremos que especificar a base de dados a qual queremos nos conectar mediante a interface ODBC.

-O objeto Command se encarregará a seguir de executar a sentença SQL pertinente.

-Os resultados da seleção são armazenados no objeto RecordSet em forma de uma tabela que pode ser consultada e explorada de muitas maneiras.

A tabela RecordSet se serve fundamentalmente de um cursor que se situa inicialmente no primeiro registro e que pode ser deslocado de múltiplas formas ao longo da tabela para, deste modo, extrair as informações que possam nos interessar.

Para mover este cursor, estão aqui os métodos que podem ser empregados:
Método Descrição
MoveFirst Posiciona o cursor no primeiro registro
MoveLast Posiciona o cursor no último registro
MoveNext Avança o cursor em um registro
MovePrevious Atrasa o cursor em um registro

Os métodos e propriedades que oferece este objeto são assombrosamente numerosos. Aquí sim, comentaremos os mais freqüentemente utilizados deixando o leitor se documentar sobre o resto.
Elemento Descrição
Open Abre o objeto RecordSet
Close Fecha o objeto RecordSet
Eof End Of File. Devolve o valor True quando o cursor tiver chegado depois do último registro.
Bof Begining Of File. Devolve o valor True quando o cursor estiver posicionado antes do primeiro registro. Muito útil quando se lêem tabelas ao contrário.
AbsolutePage No caso de estar paginando os resultados, nos indica a página atual na qual nos encontramos.
PageCount No caso de estar paginando os resultados, nos indica o número de páginas total.
RecordCount Devolve-nos a quantidade de registros contidos no objeto RecordSet.
Fields.Count Devolve-nos a quantidade de campos contidos no objeto RecordSet

Pode ser que depois de ler este artigo, ainda sejam vagos alguns conceitos relativos à aplicação destes métodos e propriedades. Esperamos que nosso seguinte capítulo, onde colocaremos em prática muitos destes elementos, permita esclarecer todo tipo de dúvidas.

helldanger1 · Mai 27, 2009

Paginar resultados em ASP

Aprenda a paginar os resultados obtidos ao consultar uma base de dados. Lista e descrição do script que poderá fazer um fusão com o buscador deste mesmo workshop.

Por Miguel Angel Alvarez - Tradução de JML

Em artigos anteriores vimos quais são as propriedades e métodos principais do objeto RecordSet, agora falta somente coloca-los em prática para consolidar nossos conhecimentos.

Neste capítulo propomos e descrevemos um script que divide em distintas páginas os registros obtidos a partir de uma consulta à base de dados mediante a exploração do objeto RecordSet.

Trata-se de um derivado do clássico script que podemos encontrar em qualquer tipo de buscador. De fato, este script pode ser muito facilmente fusionado com o protótipo de buscador proposto neste mesmo workshop de forma a providenciar a construção de uma sentença SQL que, despois de sua execução poderá ser paginada por meio deste script.

A seguir apresentamos a lista que, para maior clareza, utiliza uma única sentença SQL. Deixamos por sua conta a fusão deste script com o do buscador.

<html>
<head>
<title>Repaginador de resultados</title>
</head>
<%
sSQL="select o que quiser"
'esta sentenca SQL pode ser criada a partir de um buscador como o que vimos em outro artigo
'e armazenada em um sessao para emprega-la sucessivas vezes no script: session("ssql")=ssql

'atualizamos numero de pagina
If Request.QueryString("pag")<>"" Then
Session("pagina")=Request.QueryString("pag")
Else
Session("pagina")=1
End If

'constantes ADO VBScript
Const adCmdText = &H0001
Const adOpenStatic = 3

Set Conn = Server.CreateObject("ADODB.Connection")
Set Command = Server.CreateObject("ADODB.Command")
Set RS =Server.CreateObject("ADODB.RecordSet")
Conn.Open "nome de sua base de dados"
RS.Open sSQL,Conn,adopenstatic,adcmdtext

'resultados por pagina a escolher arbitrariamente
num_registros = 5

'Dimensionamos as paginas e determinamos a pagina atual
RS.PageSize=num_registros
RS.AbsolutePage=Session("pagina")
%>

<body>
<div align="center">
Número de página actual: <b><%=Session("pagina")%></b>
<br>
Número de páginas total: <b><%=RS.PageCount%></b>
<br>
Número de registros por página: <b><%=RS.PageSize%></b>
<br>
Número de registros selecionados: <b><%=RS.RecordCount%></b>
</div>
<br><br>

<table cellspacing="2" cellpadding="2" border="1" align="center">
<%
'Contamos o número de campos
num_campos=RS.Fields.Count For campo=0 to num_campos-1%>
<td align="center"><%=RS(campo).Name%></td>
<%
Next
registros_mostrados = 0
While (Not RS.eof And registros_mostrados < num_registros)
registros_mostrados = registros_mostrados +1
%>
<tr>
<%For campo=0 to num_campos-1 %>
<td align="center"><%=RS(campo)%></td>
<%Next%>
</tr>
<%
RS.MoveNext
Wend
%>
<tr>
<td colspan="<%=num_campos%>" align="center">
<%
i=0
While i<RS.PageCount
i=i+1
%>
<b><a href="paginar.asp?pag=<%=i%>"><%=i%></a></b>
<%
Wend
%>
</td>
</tr>
</table>
<%
RS.Close
Conn.Close
%>
</body>
</html>

helldanger1 · Mai 27, 2009

O primeiro passo foi definir a sentença SQL cujos resultados vamos paginar. Se quisermos fusionar este script ao do buscador deveremos salvar a ordem gerada por nossas funções em uma variável session para não perdê-la cada vez que clicamos sobre um dos links para irmos a outra página com resultados.

A seguir definimos a página na qual nos encontramos. Esta será a primeira por padrão ou terá um valor definido (passado por URL) se o internauta se encontra navegando pelos resultados.

A abertura do objeto RecordSet deve ser feito neste caso de uma forma distinta de como vimos em casos anteriores. Uma série de parâmetros em forma de constantes são requeridos para sua correta abertura. Não vamos entrar em detalhes sobre o que isso significa unicamente diremos que estes pârametros fazem parte de uma coleção de constantes ADO. Diremos também que esta é a forma clássica de abertura que nos permite selecionar os registros mediante SQL e movermos em todos os sentidos com o ponteiro do objeto RecordSet.

Executada a senteça SQL nos falta por dimensionar as páginas. Deveremos especificar o número de registros para mostrar em cada uma (PageSize) e em qual delas nos encontramos (AbsolutePage). O objeto se encarregará de calcular outra série de propriedades como são o número de páginas total (PageCount) e o número de registros presentes em nosso objeto (RecordCount).

Quisemos aproveitar este artigo para apresentar duas propriedades Hemos querido aprovechar este artículo para presentar dos propiedades úteis para a gestão de campos: A coleção Fields, que nos dá acesso ao conjunto de campos cujo número pode ser facilmente computado (RS.Fields.Count) e, por outro lado, a propriedade Name que nos permite extrair o nome de tais campos tal como podemos ver no primeiro loop for.

A forma de mostrar os resultados na tela não difiere do que foi visto em outros scripts. Somente há que lembrarmos de introduzir uma condição suplementária no loop While e é que a quantidade de registros mostrados não sobrepasse o número de registros por página previamente definido.

Finalmente, antes de fechar os objetos, geramos dinamicamente os links que apontam para esta mesma página pelos quais passamos o número de página que queremos visualizar. Este loop, simplificado ao máximo, pode ser complementado com um loop à página anterior, outro à seguinte, um à primeira e outro à última. Podemos também gerar o número de página atual não em forma de link, mas sim em forma de texto simples visto que isso permite ao visitante ver rapidamente em que página se encontra e se evita de mostrar um link que aponta ao mesmo conteúdo que se está vendo.

Outras melhoras possíveis são: Calcular o intervalo de resultados que está sendo mostrado na página (A frase típica: "Aqui estão os resultados de x a y"), umma mensagem de "Nenhum resultado obtido" para casos nos que o Recordset está vazio (RS.Eof), apresentar um formulário para efetuar uma nova busca sem sair da página...

Esperamos que possam aproveitar este script para seus websites.

helldanger1 · Mai 27, 2009

Global .ASA

Relembramos o conceito de aplicações e sessões e vemos seu funcionamento. Também mostramos o trabalho com o arquivo global .asa para controlar sucessos de aplicação e sessão.

Por Miguel Angel Alvarez - Tradução de JML

Para falar do Global.ASA é necessário relembrarmos ou clarearmos previamente dois conceitos como são as aplicações e as sessões.

Aplicações e sessões

Uma aplicação pode-se entender como mais ou menos o que é um website. Os domínios da aplicação são o diretório raiz e os subdiretórios desta. Em um servidor web como PWS temos uma aplicação na raiz do servidor, e por cada diretório virtual que criarmos teremos outra aplicação.

O funcionamento das aplicações está ligado ao das sessões. As aplicações são globais a todo o site e as sessões são particulares de cada usuário. Concretamente funcionam com este processo:
A aplicação está parada, assim como as sessões, porque não há nenhum usuário dentro.
A aplicação é colocada em funcionamento quando entra o primeiro usuário.
O primeiro usuário coloca em andamento uma sessão.
Os seguintes usuários já têm em andamento a aplicação, com o qual somente desatam a criação de uma sessão cada um.
Com cada usuário que abandona a página (para isso se passam 20 minutos ou mais sem consultar nenhuma outra página), fecha-se uma sessão.
Com o último usuário que sai fecha-se a aplicação.
Podem-se criar variáveis de aplicação e de sessão em qualquer momento. Remarcamos, as variáveis aplication vão ser comuns para todos os recursos da aplicação todos os usuários, etc. todos acessam a mesma variável. As variáveis de sessão são locais a cada usuário, portanto cada usuário tem uma cópia da variável sessão distinta do outro usuário, que pode ter valores distintos.

Para criar variáveis de aplicação

Application("nomeDeVariavel") = valor

Para se assegurar exclusão mútua ao acessar a uma variável de aplication se utilizam os métodos lock e unlock, desta maneira:

Application.lock
Application("nomeDeVariavel") = valor
Application.unlock

Criar variáveis de sessão

Session("nomeDeVariavel") = valor

O que é o global.asa

Global.ASA vai nos servir para controlar os eventos principais associados com o início e fim da aplicação, assim como com o início e fim de sessão. Com outras palavras, com global.asa podemos fazer coisas quando se iniciem e acabem as aplicações e as sessões.

O global.asa se coloca no diretório raiz da aplicação e tem a seguinte sintaxe:

<SCRIPT LANGUAGE=VBScript RUNAT=server>

sub application_onStart()
'sentencas que se executam ao entrar o primeiro usuario
end sub

sub application_onEnd()
'sentencas a executar ao partir o ultimo usuario
end sub

sub session_onStart()
'sentencas que se executam cada vez que entra um usuario
end sub

sub session_onEnd()
'sentencas a executar ao partir cada usuario
end sub

</SCRIPT>

Um etalhe a destacar por sua utilidade prática é que se quisermos substituir nosso global.asa por outro, terá que apagar o serviço e voltar a ligar, ou inclusive voltar a reiniciar o computador se o anterior não funcionar. Se não fizermos isto sempre tomará a versão antiga do global.asa, mesmo se tiver mudado. Por esta mesma razão, há que ter cuidado que o arquivo global.asa não tenha erros, pois nossa página dará erros até que reiniciemos o serviço, com o conseguinte espaço de tempo no qual estará o domínio cortado.

helldanger1 · Mai 27, 2009

Contar usuários ativos

Vemos um exemplo de Global.ASA que nos serve para contar os usuários ativos que temos em um web site em um dado momento.

Por Miguel Angel Alvarez - Tradução de JML

Podemos ver um exemplo de global.asa utilizado para levar o controle dos usuários que acessam à página web. A conta nos informa do número de usuários que estão ativos no site, ou seja, o número de sessões abertas.

<SCRIPT LANGUAGE=VBScript RUNAT=server>

sub application_onStart()
'sentenças que se executam ao entrar o primeiro usuário
application("num_usuarios")=0
end sub

sub session_onStart()
'sentenças a executar ao sair o último usuário
application.lock
application("num_usuarios") = application("num_usuarios") + 1
application.unlock
end sub

sub session_onEnd()
'sentenças que se executam cada vez que entra um usuário
application.lock
application("num_usuarios") = application("num_usuarios") - 1
application.unlock
end sub

</SCRIPT>

é muito fácil de entender, quando se inicia a aplicação se inicia em zero a variável que conta o número de usuários ativos. Não é necessário bloquear o objeto application porque neste momento não se têm processos concorrentes que pudessem estar modificando a aplicação, porque ainda não chegou ninguém. No inicio de uma sessão se incrementa em um o número de usuários e no final decresce a um outra vez. Não é necessário definir ações ao acabar a aplicação porque a variável de aplicação que salva o número de usuários desaparece sozinha ao acabar a aplicação.

Visualizar o número de usuários

Agora, se desejarmos ver o número de usuários em qualquer momento, o único que teremos que fazer é pegar na página o conteúdo da variável de aplicação que conta o número de usuários, em um script parecido ao seguinte.

<html>
<head>
<title>Mostro usuários ativos</title>
</head>

<body>
<h1>Usuários ativos
<%
application.lock
response.write application("num_usuarios")
application.unlock
%>
</h1>

</body>
</html>

Não têm nenhuma dificuldade. Se quisermos podemos prová-lo em nosso computador. Já sabemos que o global.asa se coloca no diretório raiz de uma aplicação ou em um diretório virtual que tivermos criado com um servidor como Personal Web Server. Se quisermos ver como se incrementa o número de sessões sem necessidade de que outros usuários se conectem podemos entrar na página com navegadores distintos e se tomarão como sessões distintas embora o computador onde se acesse seja o mesmo.

helldanger1 · Mai 27, 2009

Percorrido arrays e coleções

Vemos com detalhe o loop For Each para realizar percorridos, inclusive para realizar percorridos genéricos a formulários.

Por Miguel Angel Alvarez - Tradução de JML

Em nosso manual de ASP vimos várias estruturas de controle, uma delas ainda temos que ver em mais alguns exemplos. Trata-se da estrutura FOR...EACH que serve para percorrer todos os elementos de uma coleção, por exemplo, um array ou uma coleção como as variáveis do servidor. Para acabar, veremos um exemplo prático adicional que consiste no percorrido genérico das variáveis que recebemos por POST ou por GET.

FOR...EACH

O loop FOR...EACH utiliza-se com a seguinte sintaxe:

For Each elemento in coleção
'Fazemos coisas para cada elemento da coleção
Next

Percorrido genérico de Arrays

Um exemplo para ver o funcionamento deste loop poderia ser o seguinte percorrido genérico de um array

<%
dim nomes(3)
nomes(1) = "pedro"
nomes(2) = "luis"
nomes(3) = "sabrina"
for each valor in nomes
response.write valor & "<br>"
next
%>

Percorre-se o array de nomes percorrendo cada valor e imprimindo-o.
Percorrido genérico de coleções

As coleções são como arrays com a diferença que se pode ser acessar o valor que salva o array em cada posição com uma cadeia de caracteres em vez de um número.

Um exemplo muito interessante de percorrido de coleções foi visto em seu momento para mostrar todas as variáveis do servidor, as ServerVariables.

<%
For Each elemento in Request.ServerVariables
Response.Write elemento&" : "&Request.ServerVariables(elemento)& "<br>"
Next
%>

Este exemplo é mais interessante, porque se trata de uma coleção e não um array típico. A coleção de ServerVaribles se acessa da seguinte maneira.

request.servervariables("nome da variavel")

onde "nome da variavel" poderia ser HTTP_ACCEPT_LANGUAGE, APPL_PHYSICAL_PATH ou qualquer outra variavel da lista de serverVariables.

Percorrido genérico das variáveis enviadas por POST ou GET

Outro exemplo interessante e prático é o que vem a seguir. Trata-se de percorrer as variáveis que chegam à página de um formulário ou pela URL de maneira genérica, ou seja, sem nos importar quantos elementos chegam e quais são. Este exemplo você pode chegar a necessitar quando não souber que tipo de formulário estão mandando nem quantas variáveis lhe enviam pela URL.

Em nosso exemplo vamos nos centrar em um formulário com method POST, com o qual recolhemos as variáveis com o método request.Form. Os exemplos para uma lista de variáveis chegada pela URL, com o método GET, podem-se recolher de um modo parecido, usando request.QueryString.

<%
For Each elemento in Request.form
Response.Write elemento & ": " & Request.form(elemento) & "<br>"
Next
%>

É exatamente o mesmo exemplo que para percorrer uma coleção como a ServerVaribles, mas mostrando agora a coleção request.form.

Poderemos utilizar este script quando quisermos realizar percorridos genéricos. Nas seguintes linhas pode-se ver um exemplo de formulário que utilizamos para ilustrar este exemplo na prática.

<form action="recorridoform.asp" method="POST">
Nome: <input type="Text" name="nome">
<br>
<br>
Idade: <input type="Text" name="idade" size=3>
<br>
<br>
Profissao: <input type="Text" name="profissao">
<br>
<br>
<input type="Submit" value="Enviar">
</form>

helldanger1 · Mai 27, 2009

Mais sobre cookies

Veremos umas notas adicionais sobre o uso de cookies.

Por Miguel Angel Alvarez - Tradução de JML

Já vimos no básico de ASP um capítulo dedicado às cookies, que seria adequado rever para ter a base necessária para poder entender este novo capítulo.

As cookies estão em uma coleção

As cookies se salvam em uma coleção assim como muitas outras coisas em ASP. Poderíamos acessar todas as cookies de uma página através do loop For Each.

<%
response.cookies ("id") = "Pedro"
response.cookies ("idioma") = "ing"
response.cookies ("cor") = "verde"

cadeia = ""
for each biscoito in Request.cookies
cadeia = cadeia & "Cookie " & biscoito & ": " & Request.cookies(biscoito) & "<br>"
next
response.write cadeia
%>

Neste exemplo, primeiro criamos umas cookies e logo, fazemos um percorrido na coleção de cookies para mostrar seu valor. Os valores de intermédios se salvam em uma variável cadeia porque é aconselhável não escrever nada na página até não haver realizado todo o trabalho com as cookies. Uma vez percorrida toda a coleção se mostra a variável cadeia na página, que contém todas as cookies da página.

Subclassificação de cookies

Para continuar, vamos ver como se pode colocar em uma cookie um maior número de dados através da subclassificação. Onde antes criávamos uma cookie agora aprenderemos a criar uma subcoleção de cookies.

<%
Response.cookies ("usuario")("id") = "eugim"
Response.cookies ("usuario")("idioma") = "pt"
Response.cookies ("usuario")("cor") = "vermelho"
%>

Loop aninhado para mostrar subcoleção

Se desejarmos mostrar as subcoleções de uma maneira mais bonita, podemos fazer um loop aninhado. O loop mais geral seria o que vai percorrendo as cookies de primeiro nível. Em cada iteração do loop se perguntará se a cookie atual tem subcookies. Se não tiver, escreva a cookie atual e continue com a seguinte iteração. No caso de que tenha subcookies, se coloca em um loop que mostra cada uma delas. O código para fazer isto seria o seguinte:

<%
cadeia = ""
for each biscoito in request.cookies
if request.cookies(biscoito).HasKeys then
for each subbiscoito in request.cookies(biscoito)
cadeia = cadeia &" " & subgalleta & ": " & request.cookies(biscoito)(subbiscoito) & "<br>"
next
else
cadeia = cadeia & biscoito & ": " & request.cookies(biscoito) & "<br>"
end if
next
response.write cadeia
%>

Amaneira de trabalhar com subclassificações é muito parecida a de trabalhar com matrizes ou arrays de 2 dimensões.

Data de validade programada

Como foi dito no capítulo de cookies básico, para que os biscoitinhos se salvem no ordenado uma vez acabada a sessão durante um tempo, temos que colocar data de validade neles. É muito útil colocar uma data de validade relativa à data atual, por exemplo 1 ano ou mais tarde, assim, quando passe um tempo, a página salvará as cookies mais adiante no tempo também. Para isso, vamos utilizar uma função de data que se chama DateAdd() e funciona conforme este esquema.

DateAdd(intervalo, numero, data)

Intervalo é um string que representa as unidades sobre as quais vai se acrescentar a data. Por exemplo, os meses se indicam com "m", os anos com "yyyy", e os dias com "d".
Número se utiliza para indicar quantos intervalos se acrescentam, 1 ano ou 8 meses, por exemplo.
Data é a data a partir da qual se acrescentam o número de intervalos. Costuma-se utilizar neste parâmetro a palavra Now que indica que se toma a data atual.

<%
response.cookies("id").expires = DateAdd("d",1,Now)
%>

No exemplo, a cookie vencerá sua validade um dia depois.

helldanger1 · Mai 27, 2009

Detector de navegador

Um breve exemplo sobre como detectar o navegador do usuário.

Por Miguel Angel Alvarez - Tradução de JML

Em algumas ocasiões é necessário detectar o navegador do usuário e sua versão, para mostrar um conteúdo distinto em cada caso. Por exemplo, poderemos mostrar um script em Javascript diferente dependendo do navegador ou um banner distinto. Um detalhe importante é que não devemos construir páginas distintas para cada navegador, devemos tentar que as páginas sejam compatíveis e em algumas ocasiões este método pode ser útil para nós.

Para detectá-lo dispomos da coleção ServerVariables e teoricamente a variável HTTP_USER_AGENT nos dará a informação que queremos. Para começar podemos visualizar o conteúdo dessa variável.

<% Response.write Request.ServerVariables("HTTP_USER_AGENT") %>

Este tag tem toda a informação que você pode necessitar, mas provavelmente seja um problema resgatar os dados deste texto para estar a par de todos os detalhes que se necessita. Um exemplo para tratar a cadeia pode ser o seguinte:

Vamos fazer uso de alguma função de cadeia. Teoricamente vamos utilizar a função inStr, que serve para encontrar um substring dentro de outra cadeia de caracteres.

InStr([start, ]string1, string2[, comparação])

Início, é opcional e indica a posição inicial a partir da qual buscar
String1, é a cadeia onde realizamos a busca
String2, é a cadeia que estamos buscando
Comparação, opcional, indica se se realiza uma comparação binária (valor 0, por padrão) ou textual (valor 1)

InStr devolve 0 se não encontra o string e se o encontra devolve a posição do primeiro caractere.

<%
nav = Request.ServerVariables("HTTP_USER_AGENT")
if instr(nav,"MSIE") then
response.write "Seu navegador é Internet Explorer"
elseif instr(nav,"Mozilla") then
response.write "Seu navegador provavelmente seja de Netscape"
else
response.write "Seu navegador não é Netscape nem Explorer"
end if
%>

Utilizamos a saída da função InStr como expressão a avaliar no IF. Si InStr não encontrou nada, devolverá um zero, que será interpretado como um false. Se tiver encontrado a cadeia devolverá a posição do primeiro caractere, que será diferente de zero e será interpretada como true.

Não podemos estar certos de que o navegador seja Netscape porque não indica claramente em sua tag HTTP_USER_AGENT a marca do navegador.

Colocamos um caso no qual não sabemos que navegador é, ou melhor, que estamos convencidos que não é Explorer e nem Netscape. Serão poucos os casos de que não se possa detectar. Neste caso, estamos quase certos de que o navegador será antigo e devemos fazer ações básicas que sejam compatíveis com os navegadores menos avançados.

Browser Capabilites

Porém, esta não é a única forma de detectar o navegador. Existe um interessante objeto que pode nos devolver os dados que estamos buscando de uma maneira mais ordenada. Trata-se do componente Browser Capabilites, que é utilizado da seguinte forma:

<html>
<head>
<title>Browser Capabilities</title>
</head>
<body>

<%
Set nav = Server.CreateObject("MSWC.BrowserType")
%>
Navegador: <%=nav.browser %>
<br><br>
Versão: <%=nav.versao%>
<br><br>

<%
if (nav.vbscript = TRUE) then
%>
Pode executar VBScript
<% else %>
NAO pode executar VBScript
<% end if %>

<br><br>

<% if (nav.javascript = TRUE) then %>
Pode executar Javascript
<% else %>
NAO pode executar Javascript
<%
end if
set bc=nothing
%>

</body>
</html>

Pode ocorrer de não ser possível ver este exemplo em determinados navegadores por não detectarem corretamente os valores. Isto é devido a que o nosso servidor pode possuir o arquivo browscap.ini pouco atualizado.

A responsabilidade de que o arquivo não esteja bem atualizado é de nosso provedor de hosting, mas se em algum caso quisermos atualizar o arquivo podemos fazer. Para conseguir uma versão atualizada podemos visitar a página Browscap onde se pode baixar o arquivo.

Se temos um provedor de hosting deveriam se oferecer a atualizar o arquivo, mas se temos nosso próprio servidor poderemos atualiza-lo nós mesmos subscrevendo nosso browscap.ini atual, que em nosso sistema está no diretório c:\windows\system\inetsrv.

Este método é interessante, mas segundo nossa experiência não é o suficiente para assegurarmos que todos os navegadores se detectam corretamente. Uma última possibilidade é comprar um componente comercial, como o que vendem na mesma página onde podemos baixar browscap.ini, que informam que tem maiores possibilidades para detectar navegadores, plug-ins, definição de tela... O problema é que custa bastante dinheiro. BrowserHawk: Detect flash, detect screen size, detect connection speed, detect disabled cookies, detect Java and more.

helldanger1 · Mai 27, 2009

Trabalho com o buffer da página

Vemos em que casos salva-se a página em um buffer ao processá-la e a utilidade de trabalhar com o buffer com exemplos práticos.

Por Miguel Angel Alvarez - Tradução de JML

As páginas ASP se constroem primeiro em um buffer do servidor e mais tarde se mandam ao cliente. Esta é a configuração pré-determinada de ASP 3.0, embora não fosse assim nas versões anteriores. Isto quer dizer que o código HTML que vai gerando o servidor ao processar a página ASP, vai se salvando em uma memória intermediária até que termina de se processar, momento no qual o servidor se encarrega de mandar o conteúdo do buffer.

Nota: É importante saber em qual versão de ASP estamos trabalhando. Os IIS 4.0 têm instalado ASP 2.0 por padrão e os IIS 5.0 têm ASP 3.0.

Nós podemos em certa medida controlar o envio da página ao cliente para que este se realize nos momentos que nós desejarmos. Para isto temos alguns métodos e propriedades do objeto response a nossa disposição.

Response.Buffer é uma propriedade que se estiver true (a opção por padrão em ASP 3.0) indica ao servidor que deve utilizar o buffer. Se estiver false (opção por padrão para versões anteriores de ASP) não o utiliza.
Response.Flush método para ordenar ao servidor que mande o que tenha no buffer ao cliente.
Response.Clear método que limpa o buffer, o esvazia e perde seu conteúdo. Só é útil se estivermos utilizando o buffer
Response.End método que detém a execução da página, a termina.

Algumas utilidades

Com a propriedade buffer e os métodos anteriores poderemos implementar várias funcionalidades. Por exemplo, se uma página estiver composta por grandes blocos de processamento os quais utiliza bastante tempo podemos, entre bloco e bloco mandar ao cliente os dados que já estiverem escritos.

<%
'Código da página lento de processar
...
Response.Flush 'envio o escrito até agora

'Outro pedaço de código da página lento de processar
...
Response.Flush 'envio o escrito até agora
...
%>

Trabalho com cabeçalhos e texto

Também podemos com estas ferramentas evitar algum erro derivado de escrever nos cabeçalhos do HTTP depois de haver escrito na página texto ou HTML. Recordemos as cookies, foi dito quando se comentava que viajam nos cabeçalhos do HTTP e que estes são mandados ao cliente antes que o texto com o código da página. Por esta razão, todo o trabalho com as cookies há de ser realizado antes de escrever nenhum texto na página. É parecido ao que acontece com o objeto método redirect do objeto response.

Trata-se de escrever muito texto na página e logo tratar de ler uma cookie do cliente. Deveria dar um erro, mas dependerá se a página estiver ou não no buffer, pois se não estiver no buffer não foi mandado e, portanto, não escrevemos nenhum texto no cliente. Como dissemos que se mande ou não se mande dependerá da propriedade response.buffer.

Este exemplo, com response.buffer em true, funciona perfeitamente porque, embora já tivermos escrito coisas na página, não as mandamos ao cliente, porque estão no buffer.

<%
response.buffer = true
for i=0 to 1000
response.write "Workshop de ASP de criarweb.com "
next
response.clear
response.cookies ("ppepe") = "pqpqpqpqpqpqpqpqpq"
response.write request.cookies ("ppepe")
%>

Com response.buffer a false o mesmo script vai dar um erro porque não se pode ler ou escrever cookies se já tivermos escrito algo na página e se mandou ao cliente. False é a opção pré-determinada em ASP 2.0 e 1.0.

<%
response.buffer = false
for i=0 to 1000
response.write "Workshop de ASP de criarweb.com "
next
response.cookies ("ppepe") = "pqpqpqpqpqpqpqpqpq"
response.write request.cookies ("ppepe")
%>

Sair se o usuário foi embora

Outro exemplo interessante para ilustrar o que se pode fazer controlando os fluxos é detê-los no caso de que o cliente abandone a página. Imagine que temos um processo que requer muito processamento e o cliente vai embora da página antes de termina-lo. Para evitar todo esse tempo perdido no processamento de sua solicitação, pode-se ir comprovando à medida que vai passando o tempo se o cliente continua na espera, pois se não continuar será inútil terminar o processamento que estávamos realizando.

Para conseguir saber se o cliente continua à espera pode-se utilizar uma propriedade do objeto response chamada IsClientConnected que devolve true no caso do cliente continuar à espera e false no caso contrário. O exemplo a seguir esclarecerá tudo.

<%
' Processamento muito longo no tempo
...
if not Response.IsClientConnected then
Response.End
end if
...
' Processamento muito longo
%>

É interessante destacar que a propriedade Response.IsClientConnected não pode ser utilizada com segurança até ASP 3.0. EM ASP 2.0 foi implementada, embora não seja aconselhável usa-la porque tinha algum problema para dar resultados corretos.

helldanger1 · Mai 27, 2009

Utilização ou não do Cache

Vemos as ferramentas que estão a nossa disposição em ASP que nos ajudam a controlar o uso do cache dos navegadores e servidores proxy.

Por Miguel Angel Alvarez - Tradução de JML

É habitual que os programadores de páginas dinâmicas que ver com o cache, em algumas ocasiões e tenham que evitar que os navegadores a utilizem para que tudo funcione corretamente. Existem várias opções para configurar o comportamento do cache através dos cabeçalhos do HTTP, que são o que vamos introduzir neste capítulo.

Em geral, os navegadores salvam uma cópia de cada arquivo ao qual acessar no cache do navegador e quando consultam outra vez um arquivo que já tem no cache local comprovam a data da cópia que têm com a que está no servidor. Se os dois têm a mesma data de modificação o servidor lhe envia uma mensagem informando. Se ao contrário, a página que está no servidor é mais nova o servidor a envia ao cliente. Esta comprovação pode ser alterada graças aos cabeçalhos do HTTP, através das propriedades Response.Expires e Response.ExpiresAbsolute.

Response.Expires

Serve para indicar, em minutos, o tempo que há que passar até que a página perca a validade. Durante este tempo não se solicitará a página ao servidor e se utilizará a página que está no cache.

<%
response.expires=2 'vencerá em 2 minutos
%>

Se igualarmos a propriedade a 0, a página caduca instantaneamente, com o qual se evita o cachê.

<%
response.expires=0 'vence instantaneamente
%>

Response.ExpiresAbsolute

Com esta propriedade pode-se expressar o momento exato no qual caducará a página e a partir do qual o navegador não deve tomar do cache.

<%
response.expiresAbsolute=dateAdd("yyyy",1,now) 'vencera dentro de um ano
%>

Neste exemplo se define que a página caduca no ano seguinte depois de haver recebido, visto que se utiliza a função dateAdd() para acrescentar um ano ou a data atual. Poderíamos ter posto qualquer outra data composta pelo dia e a hora com o formato correspondente em nosso sistema.

Ejemplos:

Páginas públicas o privadas

Em algumas ocasiões é importante controlar a privacidade da informação que se manda. Suponhamos que em nosso acesso a Internet tenhamos um proxy perto. Os servidores proxy têm a sua própria memória cache e se um usuário acede a uma página a qual já tinha acessado outro usuário possivelmente o proxy lhe envie a cópia da página que tinha em sua memória cache. Em algumas ocasiões nos interessará que a página sirva o proxy e em outras nos interessará que a página sirva diretamente o servidor e isto poderemos dominar facilmente com Response.Expires. Porém, existe um caso especial que pode ser especialmente problemático que um usuário acesse a uma página que estava construída para outro, por exemplo no caso de que a informação fosse confidencial ou extraída para o usuário primeiro.

Para evitar que páginas com conteúdos pessoais possam ser mandadas a outras pessoas distintas de seu dono por culpa dos servidores proxy esá a propriedade Response.CacheControl. Se lhe atribuíamos o valor "Private" a página não será salva pelos servidores proxy. Se lhe atribuímos o valor "Public" as páginas sim que serão armazenadas nos servidores proxy e poderão ser enviadas a outras pessoas.

<%
Response.CacheControl = "Public"
%>

<%
Response.CacheControl = "Private"
%>

Outro truque

Outra maneira de evitar o cache, pode ser realizado de uma maneira mais artesanal. Trata-se de conseguir que o URL a qual acessamos sempre varie. Como sempre será distinta nunca se buscarão os arquivos do cache.

Conseguir que o URL da página seja sempre diferente pode ser feito graças ao passo de parâmetros pela URL, embora logo na página não utilizemos os parâmetros para nada, conseguiremos que a URL varie. Para mandar em um parâmetro sempre um número distinto podemos anexar uma variável que construímos com a hora do sistema.

<%
Tempo_url = year(now) & month(now) & day(now) & hour(now) & minute(now) & second(now)
%>
<a href="exemplocachev21.asp?parametro=<%=Tempo_url%>">Ver</a>

Não chegar a salvar a página no cache

Pode ser útil dizer ao navegador que não chegue a salvar a página no cache mandando-lhe um cabeçalho especial no HTTP, sobretudo em casos como o anterior, que estamos salvando muitas páginas no cache, uma por cada vez que se acesse com um parâmetro diferente na URL.

<%
Response.AddHeader "PRAGMA", "NO-CACHE"
%>

Com Response.AddHeader podem ser mandado mais tipos de cabeçalhos do http como a data de modificação do documento (LAST-MODIFIED) ou o tempo no qual tem que se realizar um refresh da página.

helldanger1 · Mai 27, 2009

Objeto Server

Uma descrição do objeto e o que poder ser feito com ele. Descrição de sua propriedade ScriptTimeout e todos seus métodos.

Por Miguel Angel Alvarez - Tradução de JML

O objeto server serve para realizar una ampla gama de coisas, já o havíamos utilizado em muitas ocasiões, como para conectar com uma base de dados ou para conectar com o sistema de arquivos, mas seus usos são muito mais amplos. Neste capítulo, vamos conhecê-lo com maior profundidade.

Como seu próprio nome indica, o objeto Server é utilizado realizar ações relacionadas com o servidor, como instanciar objetos, executar páginas ou transferir a execução a outras páginas. Vamos ver as propriedades e métodos do objeto.

Propriedades
ScriptTimeout Serve para definir o tempo máximo de execução de um script ASP. Limitar o tempo serve para evitar que uma página que tenha algum problema em sua execução chegue a bloquear o servidor ou algum recurso do sistema, de modo que quando passa um tempo a página pára sua execução e libera os recursos.

Somente teremos que utilizar esta variável se o processamento da página demora muito tempo, para que o script não fique na metade de seu processamento por exceder o tempo limite. O tempo padrão é 90.

<%
Server.ScriptTimeout = 200
%>

Métodos
CreateObject ("Id") Serve para instanciar objetos no servidor, como objetos que conectam com bases de dados, com o sistema de arquivos, objetos para mandar e-mails, etc. Este método devolve sempre uma instancia do objeto com esse identificador. Já vimos exemplos dele em outros capítulos e também os veremos no próximo capítulo.
Execute("URL") Pelo ASP 3.0 (IIS 5.0) pode-se executar uma página web por outra página. O controle e o estado da execução transfere-se da primeira página ao qual se indica como parâmetro e quando acaba a execução da página se devolve à página original.
Transfer("URL") É o mesmo que a anterior só que o controle da página não se devolve à página original. Somente para ASP 3.0.
GetLastError() Devolve o último erro que ocorreu na execução da página ASP como uma instancia de um ASPError que tem informação sobre o nome do arquivo, a página onde aconteceu o erro, etc.
HTMLEncode("str") Recebe uma cadeia a qual substitui os caracteres especiais do HTML, por exemplo, < converte-se em <

<%
cadeia = Server.HTMLEncode("Isto é uma <b>Besteira</b>, este texto ""é falso"" Ok?")
response.write cadeia
%>

Isto nos devolveria
Isto é uma <b>Tontería</b>, este texto "é falso" ¿Ok?
URLEncode("str") Quando mandamos informação como parâmetro pela URL devemos converter certo tipo de caracteres que não são válidos, como os espaços ou outros símbolos, por seus correspondentes códigos, por exemplo, + utiliza-se para o espaço ou %23 para o caractere #.

<%
cadeia = Server.URLEncode("caractere invalido!")
response.write cadeia
%>

Que nos devolveria
car%E1cter+no+valido%21 e poderíamos utiliza-lo para construir um link deste modo.

<a href="http://www.desarrolloweb.com?param= <%=Server.URLEncode("caractere inválido!")%>">
caractere inválido!
</a>
MapPath("url") Devolve a rota completa no disco do arquivo indicado com o parâmetro URL.

<%
cadeia = server.MapPath("index.asp")
response.write cadeia
%>

Devolveria algo parecido a isto
C:\inetpub\wwwroot\index.asp

helldanger1 · Mai 27, 2009

Leitura e escritura de arquivos em ASP

Explicação e referência sobre como se pode ler e escrever um arquivo em ASP.

Por Miguel Angel Alvarez - Tradução de JML

Em algumas ocasiões é necessário que nossas aplicações realizem ações de leitura ou escritura de arquivos de texto no servidor.

Para dar um exemplo, poderíamos salvar todos documentos das reportagens de nosso site em arquivos de texto e através de nossas páginas ASP poderíamos abrir esses arquivos de texto mostrá-los dentro do desenho de nosso site. Isto é uma técnica habitual, que utilizamos também em criarweb. Qualquer um que já tiver programado um pouquinho conhecerá a importância que tem o manejo de arquivos de texto em programas, de modo que não serão necessários mais exemplos de possíveis usos.

Como estamos em ASP, temos que ter em conta que os arquivos que podemos manipular se encontram no servidor, já que ASP pode ter acesso aos recursos do servidor e não aos do cliente.

Para ler ou escrever arquivos de texto no servidor utilizando ASP deve-se criar um objeto File System Object (FSO), que serve para ter acesso ao sistema de arquivos do servidor onde estão nossas páginas. Até agora não falamos muito do FSO em criarweb.com, mas pensamos em fazer uma série de reportagens para trata-lo mais a fundo. Por agora, será suficiente que saibamos que para ler ou escrever um arquivo devemos nos apoiar no FSO necessariamente. Para criar uma conexão com o FSO em nossas páginas ASP fazemos o seguinte:

set con_FSO = createObject("scripting.filesystemobject")

Neste momento já temos acesso ao sistema de arquivos através do File System Object, nossa variável com_FSO salva o objeto que realiza a conexão com o sistema de arquivos. Agora devemos criar o objeto TextStream, que será o objeto final que necessitaremos ter para ler ou escrever o arquivo.

Existem em ASP três métodos para criar o TexStream que se utilizam em casos distintos, segundo as ações que pretendamos realizar com o arquivo. Os três métodos devolvem um objeto TextStream.

CreateTextFile (arquivo,sobrescreve,unicode)
Este método criará um arquivo em nosso sistema de arquivos e devolverá um objeto TextStream, que é o que utilizaremos para movermos pelo arquivo, ler ou escrever. O parâmetro arquivo é para indicar a rota do sistema de arquivos do servidor onde se criará o arquivo. Os outros dois parâmetros são opcionais. Quando está a true sobrescreve, indica que se havia um arquivo com esse nome se sobrescreve. Quando unicode está a true indica-se que o arquivo deve ser criado com jogo de caracteres unicode.

OpenTextFile (arquivo,tipo_acesso,criar,formato)
Com este método abrimos um arquivo de texto para ler ou escrever e nos devolve o objeto TextStream necessário para realizar as ações sobre o arquivo. O parâmetro arquivo indica a rota do arquivo a criar. O parâmetro tipo_acesso é opcional, indica o tipo de acesso que vamos realizar, por padrão abre-se para leitura, ForReading (1), também podemos abri-lo para escritura ForWriting (2) e para acrescentar ForAppending (8). Com o parâmetro criar, também opcional, indica-se se se deve criar o arquivo no caso de que não exista, por padrão não se cria. Por último, formato nos serve para indicar o formato do arquivo, ASCII é o pré-determinado.

OpenAsTextStream (tipo_acesso,formato)
É o terceiro método para obter um TextStream, a diferença é que se aplica ao objeto File (arquivo) que não vimos, ao invés do objeto FileSystemObject.

Se quisermos criar um objeto TextStream a partir de um FSO necessitamos utilizar um dos dois primeiros métodos, sendo o terceiro útil para criar um TexStream a partir de um objeto File.

O objeto TextStream

Como assinalamos, é o que utilizamos para nos movermos pelo arquivo e realizar as ações sobre o texto, enfocadas à leitura ou à escrita. Têm as seguintes propriedades.

AtEndOfLine vale true se nos encontrarmos ao final da linha do arquivo.
AtEndOfStream vale true se estivermos no final do arquivo.
Colum salva o valor da coluna do caractere atual no qual estamos situados dentro do arquivo.
Line salva o valor da linha atual.

Os métodos do objeto são os seguintes:

Close() fecha o arquivo. Necessário uma vez terminado o trabalho.
Read(numero) devolve um numero de caracteres do arquivo.
ReadAll() lê todo o arquivo e o devolve.
ReadLine() lê uma linha inteira.
Skip(numero) passa um numero de caracteres dado.
SkipLine() quebra de linha.
Write(texto) escreve um texto dado dentro do arquivo
WriteLine(texto) escreve um texto e coloca ao final uma quebra de linha.
WriteBlankLines(numero) coloca um numero dado de quebras de linha.

Estas notas servirão certamente como uma boa referência para realizar qualquer tipo de ação sobre arquivos, mas antes de acabar vamos ver um exemplo completo de trabalho com arquivos. Vamos fazer um pequeno script que cria um arquivo e escreve os números do 0 ao 9. Logo, fecharemos o arquivo e voltaremos a abri-lo para leitura para tirar seu conteúdo na página web.

<%
'criamos o nome do arquivo
arquivo= request.serverVariables("APPL_PHYSICAL_PATH") & "provas.txt"

'conectamos com o FSO
set confile = createObject("scripting.filesystemobject")

'criamos o objeto TextStream
set fich = confile.CreateTextFile(arquivo)

'escrevemos os números do 0 ao 9
for i=0 to 9
fich.write(i)
next

'fechamos o arquivo
fich.close()

'voltamos a abrir o arquivo para leitura
set fich = confile.OpenTextFile(arquivo)

'lemos o conteúdo do arquivo
texto_arquivo = fich.readAll()

'imprimimos na página o conteúdo do arquivo
response.write(texto_arquivo)

'fechamos o arquivo
fich.close()
%>

Na primeira linha do código criamos o nome do arquivo. O nome do arquivo é uma variável cadeia que contém a rota absoluta do arquivo no sistema do servidor. Como provavelmente ocorra em sua hospedagem ASP, você não sabe em que diretório e disco do servidor estão alojadas sua páginas (a não ser que seja você o administrador ou esteja trabalhando em local). Se for assim, necessitará de algum mecanismo para obter a rota onde estão seus arquivos e onde tem permissões de leitura e de escrita. Com o método
request.serverVariables("APPL_PHYSICAL_PATH") obtemos a rota física onde estão nossas páginas. A este caminho concatenamos o nome do arquivo que desejamos criar e já temos a rota completa do arquivo.

O resto de linhas podem ser bem entendidas com os comentários e as notas de cima neste artigo.

É importante assinalar que para ler e escrever em seus diretórios você necessitará as correspondentes permissões de leitura e escrita. Em servidores um pouco mais sérios como os que terá seu provedor de hospedagem necessitará que os outorguem permissões aos diretórios onde for escrever arquivos. As permissões de leitura costumam estar outorgadas desde o princípio.

Isso é tudo por agora, esperemos que este artigo seja bastante útil para resolver suas dúvidas com o tratamento de arquivos de texto em ASP.

helldanger1 · Mai 27, 2009

Cálculo de dias que faltam para uma data

Em ASP realizamos uma página que calcula os dias que faltam para uma data e diz algo como -Faltam 38 dias para o dia D-

Por Miguel Angel Alvarez - Tradução de JML

Vamos construir um script que calcule os dias que faltam para chegar a uma data qualquer. Para que a página web possa informar ao usuário dizendo algo como "Faltam 28 dias para meu aniversário".

Poderíamos utilizar este script em uma página web de um evento, feira ou qualquer outro acontecimento. É meio antiquadro dar este exemplo, mas poderíamos ter feito uma página que dissesse "Faltam 280 dias para o ano 2000"

Como estamos trabalhando com scripts do servidor, a data sobre a qual se calculará os dias que faltam será a data do sistema servidor. Isto tem como inconveniente que a hora do servidor pode ser ligeiramente diferente que a do computador do cliente, se os dois sistemas se encontram em países com fuso-horário distintos. Poderíamos fazer um script parecido em Javascript de cliente e tomaria a data do cliente, que pode ser útil em alguns casos. Simplesmente o assinalamos aqui porque é interessante que o leitor saiba.

Averiguamos as datas

Para realizar nosso cálculo começamos averiguando a data atual do servidor e a data do evento futuro.

data_atual = Now
data_futura = CDate("1/1/2025")

Nestas duas linhas de código obtemos primeiro a hora atual atribuindo à variável data_atual o valor da variável de sistema Now, que contém a data do servidor.

Posteriormente obtemos a data futura a partir de uma cadeia de caracteres, convertendo-a em um objeto Date (data) com a função CDate(). No exemplo obtemos a data correspondente ao 1 de janeiro de 2025, poderia ser qualquer outra.

Função DateDiff

Existe uma função de Visual Basic Script muito útil para o exercício. É a função DateDiff, que calcula a diferença entre duas datas e pode fazer o cálculo em dias, horas, minutos, segundos, etc.

A sintaxe é a seguinte:

DateDiff(intervalo, data1, data2)

Onde intervalo é a unidade na qual desejamos fazer o cálculo "s" para segundos, "d" para dias, "h" para as horas, "m" para meses, "yyyy" para anos...

Os parâmetros data1 e data2 são as duas datas envolvidas na subtração.

Podemos acessar a uma descrição mais detalhada desta função na library MSDN de Microsoft.

Calculamos os dias

A utilização da função DateDiff com as datas que havíamos obtido previamente é muito simples.

dias_restantes = DateDiff ("d", data_atual, data_futura)

Com isto já obtivemos o valor buscado e poderíamos imprimi-lo na página diretamente.

Tudo Junto

Finalmente, vamos ver todo o exercício de uma vez em uma página ASP.

<html>
<head>
<title>Cálculo dos dias que faltam para uma data</title>
</head>
<body>

<%
data_atual = Now
data_futura = CDate("1/1/2025")

dias_restantes = DateDiff ("d", data_atual, data_futura)
%>

Faltam <%=dias_restantes%> dias para o ano 2025

</body>
</html>

Até aqui chega este workshop de ASP que também pode nos servir para aprender a calcular outro tipo de diferenças, por exemplo, os segundos que faltam para uma data, os meses, ou qualquer outra coisa. Só haveria que utilizar a função DateDiff passando outro intervalo por parâmetro.

helldanger1 · Mai 27, 2009

Componentes do servidor ASP

Descrição dos componentes do servidor ASP, exemplos, modo de utilização, como instalá-los, etc.

Por Miguel Angel Alvarez - Tradução de JML

Vamos tentar passar algumas noções básicas sobre o que são os componentes de servidor de ASP, para nosso Workshop de ASP e pensando em futuros artigos nos quais explicaremos o funcionamento de algum outro componente interessante para os servidores IIS (nos quais se executam as páginas ASP de Microsoft)

O que são os componentes de servidor

Para falar de uma maneira simples, os componentes do servidor são programas que servem para realizar ações mais ou menos complexas nas nossas páginas ASP. Estas ações podem ser, por exemplo, o envio de correio eletrônico, realizar upload de arquivos ao servidor, conectar com um banco de dados, etc. Os que conhecem ASP saberão que a linguagem com a qual se escreve (VBScript ou Jscript) nos permite umas funcionalidades que não vão mais além das básicas de qualquer linguagem: trabalho com variáveis, tipos, estruturas de controle e um jogo de funções (que no caso de VBScript é bastante limitado).

Portanto, se em uma página ASP estamos pensando em fazer algo um pouco complexo, o mais certo é que tenhamos que realizar através de algum componente do servidor. Como dizíamos, inclusive as conexões e acesos ao banco de dados que muitos de vocês realizarão habitualmente se fazem através de um componente do servidor.

Active X

Para falar sobre os componentes de servidor é necessário falar também da tecnologia ActiveX de Microsoft. Esta se trata de um conjunto de tecnologias independentes da linguagem de programação orientadas a possibilitar que os diferentes componentes no ambiente da rede trabalhem entra si.

Os componentes ActiveX não são nada mais que os componentes de servidor que estamos comentando. Por outro lado, estão os controles ActiveX (controles desta vez, não componentes) que são pequenos programas que são inseridos nas páginas web através das etiquetas <OBJECT> e <PARAM>. Os controles são colocados em funcionamento no cliente, quando se executam são feitos dentro da página web. Um exemplo típico é a inovção de uma animação de Flash ou Shockwave. O motor de Flash ou Shockwave, é um controle ActiveX. Por outro lado, como dizíamos, os componentes ActiveX se colocam em funcionamento no servidor.

Os componentes ActiveX, portanto, são os que nos interessam neste artigo, pois são os que invocam desde ASP e se executam no servidor ao mesmo tempo que a página, antes de ser enviada ao cliente. Ademais, vamos nos centralizar no uso de componentes e não em sua programação que é um tema amplo demais.

Podemos indicar que para criar componentes de servidor pode-se utilizar qualquer linguagem de programação. Embora, muito habitualmente são feitos em Visual Basic, também pode ser feito em Delphi, Visual C++ ou o próprio C++, por exemplo. Para sua programação é necessário seguir algumas normas e estruturas.

Como se trabalha com os componentes

Os componentes são objetos que têm propriedades e métodos. As propriedades são as características do objeto e os métodos são suas funcionalidades. Para trabalhar com um componente primeiro devemos instancia-lo (cria-lo e inicia-lo). Uma vez criado, habitualmente, o configuraremos acessando a suas propriedades e atualizando seus valores. Finalmente, chamaremos aos seus métodos para colocar em funcionamento suas funcionalidades.

A instanciação de um componente de servidor se faz através do objeto server de ASP. É o server.createobject que muitos de vocês devem ter visto em mais de uma ocasião em códigos ASP.

Set meu_componente = Server.CreateObject(IDENTIFICADOR)

O identificador que lhe passamos é uma cadeia de caracteres que contém o código do componente que se quer criar. No caso de uma conexão com um banco de dados, o identificador é "ADODB.Connection". Cada componente de servidor tem seu próprio identificador, definido pelo programador do componente.

No manual de ASP I encontra-se uma explicação detalhada do componente de acesso aos dados (ADO), utilizado para acessar ao banco de dados.

De qualquer forma, para aprender a manejar um componente vocês terão umas instruções precisas na documentação que acompanha cada componente. É necessário ler a documentação porque cada componente tem suas próprias propriedades e métodos.

Componentes de interesse

Já assinalamos alguns exemplos de componentes úteis, como o envio de correio eletrônico pelo servidor ou subir arquivos ao servidor, mas podemos ver muito mais:
Acesso ao sistema de arquivos do servidor
Criação de imagens no servidor
DNS lookup
Execução de programas ou comandos no servidor
Muitos deles são comerciais e teremos que pagar para adquiri-los. É um dos problemas de ASP, que tudo custa bastante dinheiro, enquanto que em outras linguagens como PHP podemos encontrar "de casa" e/ou grátis.

Exemplos típicos de lugar onde se pode adquirir componentes variados são Serverobjects.com ou Persits.com, páginas de empresas que se dedicam a programa-los e vende-los. Também podemos encontrar um diretório de componentes e controles ActiveX em ActiveX.com.

Instalar componentes em nosso servidor

Alguns dos componentes que necessitamos na programação de páginas ASP já estão instalados por padrão nos servidores web, é o caso do componente de conexão com o banco de dados ou o de conexão com o sistema de arquivos do servidor (File System Object). Entretanto, outros componentes sim que necessitaremos instala-los na máquina que formos utiliza-los.

Um componente costuma ser um arquivo .dll, -biblioteca de Windows- e para instala-la em nosso sistema deveremos seguir suas instruções de instalação. Tanto as instruções de instalação como as de manejo do componente deveriam acompanhar à dll entre os arquivos de download do componente.

É habitual que a instalação dessa dll se realize manualmente. Para isso, copiaremos o arquivo .dll em nosso diretório system (\winnt\system32 em NT ou \windows\system em Win95) e logo, registraremos a dll em nosso sistema com o comando
regsvr32 meu_componente.dll, que devemos executar pela linha de comandos (C:\>).

Em alguns casos, o componente se instala em Windows igual que qualquer outra aplicação. Como dizíamos, cada componente pode ser instalado de forma diferente.

Se tivermos a página hospedada em um servidor que não é nosso, em um servidor de hosting, é importante perguntarmos ao suporte técnico desse provedor a maneira de instalar os componentes, pois geralmente há um procedimento definido para instala-los ou também pode não estar permitido. É importante que perguntem antes de contratar um servidor de hospedagem sobre este ponto, para que não ocorra depois de já ter pago que lhe digam que não permitem componentes próprios e que vocês necessitem um para construir a página.

helldanger1 · Mai 27, 2009

AspUpload

Apresentamos um clássico componente ASP que permite a seus visitantes subir arquivos no seu servidor.

Por Rubén Alvarez

Muitos são os componentes ASP disponíveis no mercado, gratuitos ou não, encarregados de administrar a transferência de arquivos por meio de um navegador para o servidor.

Interessante de ler para todos aqueles ao que sejam uma novidade falar dos componentes ASP no servidor.

Este tipo de componente adiciona outro elemento de interação com o usuário que seria capaz de enviar qualquer tipo de arquivo ao nosso servidor. Este arquivo poderia por sua vez ser aberto e mostrado ao resto dos usuários em tempo real.

Uma aplicação exemplo onde poderíamos usar este tipo de objetos seria um web site de chat onde, cada pessoa que entra, fornece, se o deseja, uma foto sua que será visualizada pelo resto dos interlocutores.

Administrar esta ou qualquer outra aplicação do estilo implica que faremos frente a toda uma série de situações que há que solucionar da maneira mais simples:
Não permitir a transferência de arquivos acima de um determinado tamanho
Controlar o tipo de extensão dos arquivos que há que atribuir
Certificarmos que os arquivos possam ou não ser re-escritos
Salvar parâmetros como a largura e altura de uma imagem
...
Como dissemos, existe uma infinidade de componentes que podem nos ajudar nesta tarefa. Nós comentaremos aqui o que utilizamos em alguma ocasão: AspUpload de Persits Software.

AspUpload permite ao servidor aceitar, salvar e manipular arquivos que tenham sido enviados por um usuário a partir de um clássico formulário em HTML. O conteúdo deste formulário é enviado a um script que invoca a um objeto que é quem realmente se encarrega de realizar todas as funções necessárias para o encontro e o armazenamento dos arquivos.

Entre outras coisas, este objeto nos permite:

Limitar o tamanho do arquivo a atribuir.
Permitir ou não o sobrescrever um arquivo.
Controlar os atributos do arquivo.
Mover, copiar, re-nomear e apagar o arquivo recebido.
Armazenar os arquivos no banco de dados.
Salvar os arquivos em memória, não no disco rígido.
Informa-nos sobre as dimensões e tipos de arquivo gráficos atribuídos.

A diferença de outros componentes análogos, AspUpload não é freeware. A razão pela qual expomos este e não algum outro é simplesmente, como já dissemos, porque se trata do que já utilizamos em alguma ocasião. Pode ser, não obstante, que o servidor que você utilizar já tenha adquirido e que sua utilização não lhe custe nada. Uma pequena consulta ao seu provedor pode resolver esta dúvida. Se este não for o seu caso, e você deseja fazer com um componente parecido, mas gratuito, simplesmente busque em ASP In.

De qualquer forma, este componente nos pareceu bastante profissional e de um manejo fácil e completo. Altamente recomendável para este tipo de tarefas.

Ademais, o componente vem documentado de uma forma excelente na página da empresa que o constrói, com exemplos rápidos e práticos para coloca-lo em funcionamento em um momento.

Exemplo rápido

Para termos uma idéia básica sobre como se utiliza este componente, vamos realizar um exemplo muito rápido e simples.

A seguir podemos ver o código que poderíamos utilizar para colocar um formulário em uma página web com o qual poderíamos selecionar algum arquivo para subir ao servidor.

<HTML>
<BODY BGCOLOR="#FFFFFF">

<FORM METHOD="POST" ENCTYPE="multipart/form-data" ACTION="carregar.asp">
<INPUT TYPE=FILE SIZE=60 NAME="FILE1"><BR>
<INPUT TYPE=FILE SIZE=60 NAME="FILE2"><BR>
<INPUT TYPE=FILE SIZE=60 NAME="FILE3"><BR>
<INPUT TYPE=SUBMIT VALUE="Upload!">
</FORM>

</BODY>
</HTML>

É importante colocar o atributo ENCTYPE="multipart/form-data" , que indica que se deve enviar o conteúdo do arquivo e não exclusivamente o nome.

Também podemos ver como seria o script que pega o arquivo e o salva no servidor. O arquivo carregar.asp:

<HTML>
<BODY>

<%
Set Upload = Server.CreateObject("Persits.Upload.1")
Count= Upload.Save("d:xvrtmeudominio.comhtmlupload")
%>
<% = Count %> arquivos subidos.

</BODY>
</HTML>

A única coisa diferente que fazemos é criar o componente no servidor e associa-lo à referência "Upload", isto é feito com Server.CreateObject. Posteriormente, utilizamos o método save do objeto para salvar o arquivo no servidor.

Lembramos novamente que na página do componente podemos obter a documentação inteira, que está muito clara e interessante.
Nota: PHP já tem a opção de upload de saída.
Uma das vantagens de PHP é que este tipo de ação pode ser realizado sem ter que instalar nenhum componente especial, já que o sistema de upload já vem implementado na própria linguagem.

helldanger1 · Mai 27, 2009

Exportar dados de MySQL a Microsoft Access

Explicamos como transferir informação armazenada num servidor de dados MySQL a uma base de dados Access.

Por Carlos Cuenca Díaz

Migrar dados da uma base de dados a outra é algo ao que muitos de nós tivemos de confrontar em algum momento. A continuação explicamos como recuperar informação armazenada num servidor de dados MySQL a uma base Access.

Para importar uma tabela de MySQL a Microsoft Access, desde Access, e com a base de dados na que desejamos importar os dados aberta, seleccionar o menu Ficheiro->Obter dados Externos->Importar. No ecrã de importar dados, na opção tipo do ficheiro seleccionar ODBC databases().

Seleccionar origem de dados, e dentro de esta, o nome da fonte de dados que criámos anteriormente. Uma vez seleccionada, e fizeste click em "Aceitar", aparecerá um ecrã de configuração do driver e podes configurar algumas opções de configuração que aparecem no driver ODBC, se não desejas marcar nenhuma, click sobre "OK".
Nota: é possível que, em algum caso, os dados da base nos sistemas MySQL e Access não sejam totalmente compatíveis e se produza alguma anomalia ao exporta-los. Realmente é só uma hipótese que pensamos, ainda que nas provas que realizámos não vimos nenhum tipo de problema. Claro que os campos com os que trabalhámos não eram estranhos.

Aparecerá uma janela onde pergunta que tabela de MySQL queremos exportar a Access:

Seleccionar a tabela, e faz click sobre "Aceitar"
Nota: se estamos a exportar dados a um servidor de bases de dados alojado nalgum provedor de hosting, temos d éter em conta que estes não sempre incluem acesso remoto ao servidor da base de dados, ou requer um aviso explicito por parte do cliente para a sua configuração.

Workshop de ASP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP

GForum VIP