Autor: Indaya.com

Se otorga permiso para copiar, distribuir y/o modificar este documento bajo los términos de la Licencia de Documentación Libre GNU, Versión 1.1 o cualquier otra versión posterior publicada por la Free Software Foundation. Puede consultar una copia de la licencia original en: http://www.gnu.org/copyleft/fdl.html.

Introducción a la programación en ASP

Tal como hemos explicado, ASP (Active Server Pages) es la tecnología para la creación de páginas dinámicas del lado del servidor desarrollada por Microsoft.

El tipo de servidores que emplean este lenguaje son aquellos que funcionan con sistema operativo de la familia de Windows NT. Afortunadamente, también podemos visualizar páginas ASP sobre Windows 95/98, pero esto lo veremos más adelante.

Para escribir páginas ASP utilizamos un lenguaje de scripts, que se colocan en la misma página web junto con el código HTML. Comúnmente este lenguaje de scripts es Visual Basic Script, que deriva del conocido Visual Basic, aunque también se pueden escribir los scripts ASP en otro lenguaje: JScript, que deriva a su vez del conocido Javascript.

Existe una versión de Visual Basic Script en el lado cliente y otra en el lado del servidor. En los dos casos, como su nombre indica, el lenguaje de base es Visual Basic por lo que su aprendizaje puede ser perfectamente coordinado, ya que las sentencias y las sintaxis son prácticamente las mismas. En ASP, al estar programando páginas del lado del servidor, utlizaremos Visual Basic Script del lado del servidor y en este manual nos centraremos en este punto.

Este manual va destinado a aquellos que quieren comenzar de cero el aprendizaje de este lenguaje y que buscan en él la aplicación directa a su proyecto de sitio o a la mejora de su sitio HTML. Los capítulos son extremadamente simples, sino simplistas, buscando ser accesibles a la mayoría. Ellos serán complementados posteriormente con otros artículos de mayor nivel destinados a gente más experimentada.

Del mismo modo, puede resultar extremadamente útil el haber leído o leer inmediatamente después el manual de Visual Basic Script en el cual se explica más en profundidad el lenguaje Visual Basic que resulta ser utilizado en la mayoría de scripts ASP.

Otra referencia a la cual haremos alusión es el tutorial de SQL que nos será de gran ayuda para el tratamiento de bases de datos.

Nuestra intención es la de ir publicando paulatinamente diferentes capítulos de modo que rogamos un poco de paciencia a aquellos que estén esperando la continuación. Todo irá llegando.

Esperamos que este manual resulte de vuestro agrado y que corresponda a nuestras expectativas: El poder acercar este lenguaje a todos aquellos amantes del desarrollo de webs que quieren dar el paso hacia las webs “profesionales”.

Si te interesa trabajar con un editor específico de ASP te recomendamos el MS Visual Interdev.
Otra posibilidad es el Drumbeat de Macromedia aunque para empezar ninguno de los dos resulta absolutamente indispensable.

En capítulos anteriores hemos explicado que, dada la naturaleza de los lenguajes de lado servidor, nos es imposible trabajar offline como hacíamos para el caso de las páginas HTML que almacenábamos en nuestro disco duro. También dijimos que esto no era completamente cierto ya que podíamos resolver este eventual problema instalándonos en nuestro PC un servidor propio. Este servidor distribuido por Microsoft tiene dos versiones diferentes que son utilizadas dependiendo del equipo que estemos utilizando. Para los usuarios de W95 o W98, la versión disponible se llama Personal Web Server (PWS).

Si trabajamos bajo sistema Windows NT, o las versiones Profesional y Server de Windows 2000 y XP, el servidor a instalar es el Internet Information Server (IIS).

Existe también la posibilidad de trabajar en plataformas UNIX empleando en este caso el ChilisoftASP.

Los usuarios de W95 tienen varias posibilidades para hacerse con el PWS:

Descargarlo del sitio Microsoft , a partir de una antigua versión de Frontpage 98, instalándolo desde la opción pack de W-NT 4.0 o desde el CD de instalación de W98 (directorio add-ons/pws).
Los usuarios de Windows ME no tienen soporte para PWS, aunque se pueden probar una serie de pasos para lograr utilizarlo en el sistema.

Este documento de Microsoft explica mejor este asunto.

Por otro lado, los usuarios de Windows 2000 deben utilizar IIS 5.0, que se encuentra en la instalación. Es recomendable que leáis también las notas de los visitantes al pie de página, porque encontraréis muchos más datos sobre problemas en distintas versiones y compatibilidades con otros sistemas que van apareciendo.

Algunas versiones del PWS anteriores a la 4.0 requieren un archivo adicional

asp.exe para poder reconocer páginas ASP.

PWS podría ser considerado como una versión “light” del IIS4. En realidad en PWS no es suficientemente versátil para ejercer de servidor de un sitio de un tamaño mediano aunque si que podría en un momento dado hacerse cargo de un sitio de tamaño reducido y no muy concurrido. De todas formas, la utilidad del PWS radica sobre todo en que nos permite realizar las pruebas del sitio que vayamos a desarrollar en “local” sin necesidad de colgar nuestros archivos en el servidor que alberga nuestro sitio cada vez que queramos hacer una prueba sobre una pequeña modificación introducida. Esto resulta a todas luces práctico sobre todo para principiantes que necesitan hacer pruebas con una relativa frecuencia permitiendo el ahorro de mucho tiempo.

Dado que la mayoría de los posibles lectores de este manual trabajan en entorno W95 y 98, en este capítulo nos limitaremos a la descripción del PWS dejando el IIS4 para futuros capítulos. Sin embargo, las explicaciones que damos pueden ser igualmente útiles para quienes tengan que utilizar este último el cual presenta un funcionamiento básico análogo. El uso del PWS es extremadamente fácil. Una vez instalado, podemos observar la introducción de un nuevo icono en la barra de tareas así que en el menú de inicio correspondientes a la aplicación. A partir de cualquiera de ellos podemos tener acceso a la página principal o gestionario.

El siguiente paso es crear un directorio virtual dentro del cual alojaremos nuestra página. Hablamos de directorio virtual debido a que nuestra página puede estar alojada en cualquier parte de nuestro disco duro, donde a nosotros nos plazca y con un nombre de directorio que tampoco tiene por qué parecerse al que incluiremos en la URL cuando queramos ejecutar la página. De hecho, la URL que debemos introducir en el navegador para visualizar nuestra página ASP es del tipo: http://localhost/nombre_del_directorio virtual/archivo.asp

Como se puede observar, en este tipo de dirección no se especifica el camino en el disco duro donde se encuentran nuestros archivos.

Volviendo a la creación de nuestro directorio virtual, para hacerlo debemos pinchar sobre el icono “Avanzado” el cual nos da acceso a las opciones avanzadas del PWS. Una vez ahí, el siguiente paso es “Agregar” un directorio virtual. Una ventana en la que tendremos que introducir el nombre de dicho directorio virtual y especificar en qué carpeta del disco duro tenemos guardados los archivos y carpetas de la página aparecerá.

Como puede verse, la cosa es fácil. Ahora no queda más que introducir en el navegador el tipo de URL mencionada anteriormente para ejecutar los scripts creados.

Una opción interesante en el menú avanzado es la selección del tipo de archivo que será ejecutado por defecto. Aquí podríamos poner archivos con nombre index.html o index.asp o bien con el nombre default o home…

Conexión a base de datos (BD)

El siguiente paso, una vez instalado el servidor que nos permite trabajar en local, es crear los vínculos con las bases de datos que explotaremos en nuestros scripts. En efecto, la utilización de páginas dinámicas está muy frecuentemente asociada con el empleo de bases de datos.

Una base de datos es sencillamente un conjunto de tablas en las que almacenamos distintos registros (artículos de una tienda virtual, proveedores o clientes de una empresa, películas en cartelera en el cine…). Estos registros son catalogados en función de distintos parámetros que los caracterizan y que presentan una utilidad a la hora de clasificarlos. Así, por ejemplo, los artículos de una tienda virtual podrían catalogarse a partir de distintos campos como puede ser un número de referencia, nombre del artículo, descripción, precio, proveedor…

Las bases de datos son construidas sirviéndose de aplicaciones tales como el Microsoft Access o el MySQL las cuales resultan bastante sencillas de utilizar con unos conceptos mínimos.

Nuestro objeto aquí no es explicar la forma de explotarlas sino cómo establecer una conexión entre la base de datos, almacenada en cualquier lugar del disco duro y nuestra página web alojada también en cualquier parte y reconocida por nuestro servidor personal a partir del directorio virtual.

Para crear este vínculo, nos servimos de los conectores ODBC (Open DataBase Connectivity) los cuales establecen el enlace con la base de datos.

El primer paso para crear esta conexión es ir al panel de configuración y abrir el icono ODBC 32bits. Dentro de él, deberemos crear un DSN (Data Source Name) de tipo sistema o usuario. Para ello nos colocamos en la solapa correspondiente (DSN sistema o DSN usuario) y seleccionamos “Añadir”. A continuación se nos pedirá seleccionar los controladores de la aplicación que hemos utilizado para crear la base de datos, el nombre que le queremos asignar (aquel que empleemos en nuestros scripts) y el camino para encontrarla en el disco duro.

Esta DSN permite en realidad definir la base de datos que será interrogada sin necesidad de pasar por la aplicación que hayamos utilizado para construirla, es decir, con simples llamadas y órdenes desde nuestros archivos ASP podremos obtener los datos que buscamos sin necesidad de ejecutar el Access o el MySQL los cuales, evidentemente, no tendrán por qué encontrarse en el servidor donde trabajemos.

ASP es principalmente utilizado sirviéndose del lenguaje Visual Basic Script que lo es más que una versión light del Visual Basic. Sin embargo, es posible programar páginas ASP en JavaScript. Lo único que hay que hacer es especificar en la propia página qué tipo de lenguaje estamos utilizando.

Dado que el lenguaje ASP está muy frecuentemente embebido dentro del código HTML, es importante poder marcar al servidor qué partes están escritas en un lenguaje y cuáles en otro. Es por ello que todas las partes del archivo que están escritas en ASP estarán siempre delimitadas por los símbolos: <% y %>.

De este modo, cuando realicemos nuestros scripts, lo primero que debemos definir es el tipo de lenguaje utilizado, lo cual se hace del siguiente modo:

<% @ LANGUAGE="VBSCRIPT" %> Para el caso en el que
programemos en Visual Basic Script

<% @ LANGUAGE="JSCRIPT" %> Si nos servimos del JavaScript
 en servidor para programar en ASP

Los scripts que serán presentados en este manual estarán basados en el VBS, el cual presenta toda una serie de prestaciones que lo hacen sin duda más accesible y apto para ASP. No es por nada que es el propio Microsoft quien ha creado ambos.

Con los elementos que hemos presentado hasta ahora, ya estamos en situación de poder escribir nuestro primer programa en ASP. Vamos a crear un programa que calcule el 20% de impuestos que habría que añadir a una serie de artículos. Para plasmar el concepto de función, explicado en el manual de páginas dinámicas, vamos a definir una función “impuesto” que emplearemos sucesivas veces. El programa podría resultar algo así:

<% @ LANGUAGE="VBSCRIPT"%>
<HTML>
<HEAD>
<TITLE>Funcion impuesto</TITLE>
</HEAD>
<BODY>
<%Function impuesto(precio_articulo)
precio_final=precio_articulo+precio_articulo*20/100
Response.Write precio_final
End Function%>
Un libro de 3500 ptas. se quedará en un precio de
<% impuesto(3500) %>
<br>
Una camisa de 6000 ptas. tendrá un precio final de
<% impuesto(6000) %>
<br>
Un CD de música de 2000 ptas.
costaría <% impuesto(2000) %> ptas.
</BODY>
</HTML>

Como puede verse, el script contiene dos partes fundamentales: Una primera en la que definimos la función que llamamos impuesto que depende únicamente de una variable (precio_articulo). Impuesto permite añadir un 20% al precio del artículo e imprimir el resultado en pantalla (Response.Write). En la segunda parte nos servimos de la función para realizar los cálculos necesarios y mostrarlos en pantalla acompañados de texto.

Resulta muy interesante, una vez ejecutado el script, ver el código fuente. Como puede verse, el código HTML que muestra el navegador no coincide con el que nosotros hemos escrito. Algo que no debe sorprendernos ya que, como ya hemos explicado, el servidor se encarga de procesarlo y hacerlo comprensible al navegador.

Los objetos ASP

El ASP es un lenguaje diseñado para la creación de aplicaciones en internet. Esto quiere decir que existen toda una serie de tareas bastante corrientes a las cuales debe dar un tratamiento fácil y eficaz. Nos referimos por ejemplo al envío de e-mails, acceso a archivos, gestión de variables del cliente o servidor como pueden ser su IP o la lengua aceptada…

El lenguaje VB propiamente dicho no da una solución fácil y directa a estas tareas sino que invoca a los denominados objetos que no son más que unos módulos incorporados al lenguaje que permiten el desarrollo de tareas específicas. Estos objetos realizan de una manera sencilla toda una serie de acciones de una complejidad relevante. A partir de una llamada al objeto este realizará la tarea requerida. En cierta forma, estos objetos nos ahorran el tener que hacer largos programas para operaciones sencillas y habituales.

Algunos de estos objetos están incorporados en el propio ASP, otros deben de ser incorporados como si se tratase de componentes accesorios. Por supuesto, no podríamos ejecutar correctamente un script en el cual tuviésemos que llamar a un objeto que no estuviese integrado en el servidor. Este tipo de “plug-in” son generalmente comprados por el servidor a empresas que los desarrollan.

Como todo objeto del mundo real, los objetos del mundo informático tienen sus propiedades que los definen, realizan un cierto numero de funciones o métodos y son capaces de responder de una forma definible ante ciertos eventos.

Dado el nivel de esta obra, la descripción de la totalidad de objetos con sus métodos y propiedades resulta ciertamente fuera de lugar. Nos contentaremos pues con ir describiendo los más frecuentemente utilizados y ejemplificarlos de la manera más práctica dejando la enumeración exhaustiva en forma de apéndice.

Como ejemplo, podríamos hacer alusión a un script que ejecute una secuencia diferente en función del día de la semana en el que nos encontramos.

Este tipo de acciones pueden ser llevadas a cabo gracias a una paleta de instrucciones presentes en la mayoría de los lenguajes. En este capítulo describiremos someramente algunas de ellas propuestas por el VBS y que resultan de evidente utilidad para el desarrollo de páginas ASP.

Para evitar el complicar el texto, nos limitaremos a introducir las más importantes dejando de lado otras cuantas que podrán ser fácilmente asimilables a partir de ejemplos prácticos.

Las condiciones: IF

Cuando queremos que el programa, llegado a un cierto punto, tome un camino determinado en determinados casos y otro diferente si las condiciones de ejecución difieren, nos servimos del conjunto de instrucciones If, Then y Else. La estructura de base de este tipo de instrucciones es la siguiente:

IF condición THEN
Instrucción 1
Instrucción 2
...
ELSE
Instrucción A
Instrucción B
...
END IF

Llegados a este punto, el programa verificará el cumplimiento o no de la condición. Si la condición es cierta las instrucciones 1 y 2 serán ejecutadas. De lo contrario (Else), las instrucciones A y B serán llevadas a cabo.

Una vez finalizada la estructura, deberemos cerrar con un End If.

Esta estructura de base puede complicarse un poco más si tenemos cuenta que no ecesariamente todo es blanco o negro y que muchas posibilidades pueden darse. Es por ello que otras condiciones pueden plantearse dentro de la condición principal. Hablamos por lo tanto de condiciones anidadas que tendrían una estructura del siguiente tipo:

IF condición THEN
Instrucción 1
Instrucción 2
...
ELSE
IF condición2 THEN
Instrucción A
Instrucción B
...
ELSE
Instrucción X
...
END IF
END IF

De este modo podríamos introducir tantas condiciones como queramos dentro de una condición principal. En este tipo de estructuras es importante cerrar correctamente cada uno de los IF con sus END IF correspondientes. De gran ayuda es la instrucción ELSE IF que permite en una sola línea y sin necesidad de añadir un END IF introducir una condición anidada.

El uso de esta herramienta resultará claro con un poco de práctica. Pongamos un ejemplo sencillo de utilización de condiciones. El siguiente programa permitiría detectar la lengua empleada por el navegador y visualizar un mensaje en dicha lengua.

<% @ LANGUAGE="VBSCRIPT"
%>
  <HTML>
  <HEAD>
  <TITLE>Detector de Lengua</TITLE>
  </HEAD>
  <BODY>
  <%
  'Antes de nada introducimos mensajes en forma de variables
   espanol="Hola"
   ingles="Hello"
   frances="Bonjour"

  'Ahora leemos del navegador cuál es su lengua oficial
   idioma=Left(Request.ServerVariables("HTTP_ACCEPT_LANGUAGE"),2)

  'Formulamos las posibilidades que se pueden dar
  If idioma="es" Then
  Response.Write espanol
  ElseIf idioma="fr" Then
  Response.Write frances
  Else
  Response.Write ingles
  End If %>
  </BODY>
  </HTML>

Para poder ver el funcionamiento de este script es necesario cambiar el idioma preferido lo cual puede ser realizado a partir del menú de opciones del navegador.

Como puede verse, las variables que contienen texto son almacenadas entre comillas.

Para leer la lengua aceptada por el navegador lo que hacemos es definir una variable (idioma) que recoge las dos primeras letras empezando por la izquierda del idioma aceptado por el navegador (“HTTP_ACCEPT_LANGUAGE”). Este idioma aceptado puede ser requerido como una variable del objeto ServerVariables. Por el momento dejaremos esto tal cual, ya nos encargaremos de verlo más detenidamente en otros capítulos.

La tercera parte de script se encarga de ver si el navegador está en español (es), francés (fr) o en cualquier otro idioma que no sea ninguno de estos dos y de imprimir cada uno de los mensajes que proceda en cada caso.

Otro punto a comentar es el hecho de poder comentar los programas. Como puede observarse, dentro del script hemos introducido unos mensajes que nos sirven para leerlo más fácilmente. Estos mensajes no ejercen ninguna influencia en el desarrollo del mismo. Para introducirlos es necesario escribirlos detrás de un apóstrofe: ‘

Los comentarios son de gran utilidad cuando tratamos con programas muy extensos y complicados los cuales. En estos casos, resultan de gran ayuda a la hora de depurar fallos o introducir modificaciones. Es altamente aconsejable el acostumbrarse a utilizarlos.

En muchas ocasiones resulta necesario el ejecutar un conjunto de instrucciones un número definido de veces. Esto puede ser llevado a cabo a partir de la instrucción FOR/NEXT.

La estructura clásica:

FOR contador=número inicial to número final STEP incremento

Instrucción 1

Instrucción 2

...

NEXT

A partir de este tipo de estructuras ejecutamos las instrucciones contenidas entre el FOR y el NEXT un cierto número de veces definido por el número inicial, final y el incremento. El incremento resulta de 1 por defecto.

Pongamos un ejemplo:

<% @ LANGUAGE="VBSCRIPT"

%>

  <HTML>

  <HEAD>

  <TITLE>Bucle for/next</TITLE>

  </HEAD>

  <BODY>  <%For i=1 to 5%>

  <font size=<%Response.Write i%>>Vuelta número

  <%Response.Write i%></font><br>

  <%Next

For i=5 to 1 Step -1%>

  <font size=<%Response.Write i%>>Contamos atrás:

  <%Response.Write i%></font><br>

  <%Next%>

</BODY>

  </HTML>

Este script compuesto de dos bucles cuenta primero de 1 a 5. La variable i toma por lo tanto todos los valores enteros comprendidos entre estos dos números y puede ser utilizada dentro del bucle como lo hacemos en este caso para aumentar el tamaño de la letra. El segundo bucle realiza el proceso inverso (el incremento es negativo) produciendo una disminución del tamaño de la letra.

Lo que puede resultar interesante para ver hasta qué punto el programar páginas dinámicas puede ahorrarnos texto con respecto a la misma página programada en código HTML, es mirar el código fuente de la página a partir del navegador.

Los bucles DO WHILE/LOOP

Otra forma de realizar este tipo de secuencias bucle es a partir de la instrucción DO WHILE. En este caso lo que especificamos para fijar la extensión del bucle no es el número de vueltas sino el que se cumpla o no una condición. La estructura de este tipo de bucles es análoga a la de los bucles FOR/NEXT:

DO WHILE condición

Instrucción 1

Instrucción 2

...

LOOP

El bucle se dará mientras la condición propuesta siga siendo válida.

Como se verá en ejemplos posteriores, este tipo de bucles resulta muy práctico para la lectura de bases de datos.

Todo este tipo de controladores de flujo (condiciones y bucles) pueden ser matizados y optimizados a partir del uso de operadores lógicos. Así, podemos exigir que sean dos las condiciones que se den para llevar a cabo un conjunto de instrucciones:

IF condición 1 AND condición 2 THEN ...

También podemos requerir que sea una de las dos:

IF condición 1 OR condición 2 THEN...

Del mismo modo, es posible exigir que la condición de

un bucle DO sea la inversa a la enunciada:

DO WHILE NOT condición

He aquí, en conclusión, un conjunto de recursos básicos para controlar el desarrollo de programas. Su utilidad resultará más que patente y su uso irá haciéndose intuitivo a medida que nos familiaricemos con el lenguaje.

Como veremos, todo este tipo de aspectos interactivos pueden ser gestionados a partir del objeto Request.

El objeto Request nos devuelve informaciones del usuario que han sido enviadas por medio de formularios, por URL o a partir de cookies (veremos de qué se tratan seguidamente). También nos informa sobre el estado de ciertas variables del sistema como pueden ser la lengua utilizada por el navegador, el número IP del cliente…

Transferir variables por URL

Para pasar las variables de una página a otra lo podemos hacer introduciendo dicha variable en la dirección URL de la página destino dentro del enlace hipertexto. La sintaxis sería la siguiente:

  <a href="destino.asp?variable1=valor1&;..."></a>

Para recoger la variable en la página destino lo hacemos por medio del objeto Request con el método Querystring:

Request.querystring("variable1")
Request.querystring("variable2")

Las dos páginas serían así:

  <HTML>  <HEAD>

<TITLE>Página origen.asp</TITLE>

</HEAD>

<BODY>

<a href="destino.asp?saludo=hola&texto=Es variable texto">
Paso

variables saludo y texto a la página destino.asp</a>

</BODY>

</HTML>

  <HTML>  <HEAD>

<TITLE>destino.asp</TITLE>

</HEAD>

<BODY>

Variable saludo:
<%Response.Write Request.Querystring("saludo")%><br>

Variable texto:
<%Response.Write Request.Querystring("texto")%><br>

</BODY>

</HTML>

El proceso es similar al explicado para las URLs. Primeramente, presentamos una primera página con el formulario a rellenar y las variables son recogidas en una segunda página que las procesa:

<HTML><HEAD>

<TITLE>formulario.asp</TITLE>

</HEAD>

<BODY>

<FORM METHOD="POST" ACTION="destino2.asp">

Nombre<br>

<INPUT TYPE="TEXT" NAME="nombre"><br>

Apellidos<br>

<INPUT TYPE="TEXT" NAME="apellidos"><br>

<INPUT TYPE="SUBMIT">

</FORM>

</BODY>

</HTML>

<HTML><HEAD>

<TITLE>destino2.asp</TITLE>

</HEAD>

<BODY>

Variable nombre: <%=Request.Form("nombre")%><br>

Variable apellidos: <%=Request.Form("apellidos")%>

</BODY>

</HTML>

Otras utilidades de Request: las ServerVariables

El objeto Request nos da acceso a otras informaciones relativas al cliente y el servidor las cuales pueden resultar de una gran utilidad. Estas informaciones son almacenadas como variables las cuales son agrupadas en una colección llamada ServerVariables.

Dentro de esta colección tenemos variables tan interesantes como:

Para visualizar en pantalla alguna de estas variables, debemos escribir algo como:

Response.write request.servervariables("nombre de la variable")

Una forma rápida de visualizar todas estas variables es a partir de un script con esta secuencia:

<%For Each elemento in Request.ServerVariables

Response.Write elemento&" :
"&Request.ServerVariables(elemento)& "<br>"

Next

%>

Esto nos daría por un lado el nombre de la variable y del otro su valor.

Este tipo de bucle For Each/Next se parece a otros ya vistos. En este caso, el bucle se realiza tantas veces como elementos tiene la colección (ServerVariables) que no es más que el conjunto de elementos comprendidos en la extensión del objeto (Request). Este tipo de bucle es aplicable a otras colecciones de éste y otros objetos como por ejemplo los Request.Form o Request.Querystring o las cookies. De esta forma seríamos capaces de visualizar el nombre y contenido de tales colecciones sin necesidad de enunciarlas una por una.

Tal y como se ha visto, el objeto Request gestiona todo lo relativo a entrada de datos al script por parte del usuario (formularios), provenientes de otra URL, del propio servidor o del browser.

Nos queda pues por explicar cómo el script puede “responder” a estos estímulos, es decir, cómo, después de procesar los debidamente los datos, podemos imprimir estos en pantalla, inscribirlos en las cookies o enviar al internauta a una u otra pagina. En definitiva, queda por definir la forma en la que ASP regula el contenido que es enviado al navegador.

Esta función es tomada en cargo por el objeto Response el cual ha sido ligeramente mencionado en capítulos precedentes concretamente en asociación al método Write.

En efecto, sentencias del tipo:

<%Response.Write "Una cadena de texto"%>

o bien,

<%Response.Write variable%>

Tienen como cometido imprimir en el documento HTML generado un mensaje o valor de variable. Este método es tan comúnmente utilizado que existe una abreviación del mismo de manera a facilitar su escritura:

<% = variable %> es análogo a <%response.write variable%>

Es importante precisar el hecho que imprimir en el documento HTML no significa necesariamente visualizar en pantalla ya que podríamos servirnos de estas etiquetas para crear determinadas etiquetas HTML. He aquí un ejemplo de lo que se pretende decir:

<% path="http://www.misitio.com/graficos/imagen.gif" %><
img src="<% =path %>">

Este fragmento de script nos generaría un código HTML que sería recibido en el navegador del siguiente modo:

<img src="http://www.misitio.com/graficos/imagen.gif">

Otro elemento interesante de este objeto Response es el método Redirect. Este método nos permite el enviar automáticamente al internauta a una página que nosotros decidamos.

Esta función, a todas luces práctica, puede ser empleada en scripts en los que enviamos al visitante de nuestro sitio a una u otra página en función del navegador que utiliza o la lengua que prefiere. También es muy útil para realizar páginas “escondidas” que realizan una determinada función sin mostrar ni texto ni imágenes y nos envían a continuación a otra página que es en realidad la que nosotros recibimos en el navegador.

Aquí se puede ver una secuencia de script que nos permitiría usar este método para el caso en el que tengamos páginas diferentes para distintas versiones de navegadores. En ella emplearemos un objeto que nos debe parecer familiar ya que lo acabamos de ver (Request.ServerVariables):

<%tipo_navegador = Request.ServerVariables("HTTP_USER_AGENT")

If Instr(1, tipo_navegador, "MSIE 3", 1) <> 0 then

Response.Redirect "MSIE3.asp"

ElseIf Instr(1, tipo_navegador, "MSIE 4", 1) <> 0 then

Response.Redirect "MSIE4.asp"

ElseIf Instr(1, tipo_navegador, "MSIE 5", 1) <> 0 then

Response.Redirect "MSIE5.asp"

ElseIf Instr(1, tipo_navegador, "Mozilla/4", 1) <> 0 then

Response.Redirect "Netscape4.asp"

Else

Response.Redirect "cualquiera.asp"

%>

Por supuesto, acompañando este script, debemos tener los correspondientes archivos MSIE3.asp, MSIE4.asp, MSIE5.asp… Cada uno de ellos con las particularidades necesarias para la buena visualización de nuestra página en tales navegadores.

Sin duda este término resultara familiar para muchos. Algunos lo habrán leído u oído pero no saben de qué se trata. Otros sin embargo sabrán que las cookies son unas informaciones almacenadas por un sitio web en el disco duro del usuario.

Esta información es almacenada en un archivo tipo texto que se guarda cuando el navegador accede al sitio web.

Es posible, por supuesto, ver estos archivos. Para abrirlos hay que ir al directorio C:WindowsCookies para los usuarios de IE 4+ o a C:…NetscapeUsersdefaultuser para usuarios de Netscape. Como podréis comprobar, en la mayoría de los casos la información que se puede obtener es indescifrable.

La utilidad principal de las cookies es la de poder identificar al navegador una vez éste visita el sitio por segunda vez y así, en función del perfil del cliente dado en su primera visita, el sitio puede adaptarse dinámicamente a sus preferencias (lengua utilizada, colores de pantalla, formularios rellenados total o parcialmente, redirección a determinadas páginas…).

Para crear un archivo cookies, modificar o generar una nueva cookie lo podemos hacer a partir del objeto Response con una sintaxis como la siguiente:

Response.Cookies("nombre de la cookie") = valor de la cookie

El valor de la cookie puede ser una variable, un numero o una cadena delimitada por comillas.

Es importante saber que las cookies tienen una duración igual a la sesión, es decir, a menos que lo especifiquemos, el archivo texto generado se borrará desde el momento en que el usuario haya abandonado el sitio por un tiempo prolongado (generalmente unos 20 minutos) o que el navegador haya sido cerrado. Podemos arreglar este supuesto inconveniente mediante la propiedad Expires:

Response.Cookies("nombre de la cookie").expires = #01/01/2002#

Esto nos permite decidir cual es la fecha de caducidad de la cookie. Hay que tener en cuenta que esto no es más que hipotético ya que el usuario es libre de borrar el archivo texto cuando le plazca.

Por otra parte, es interesante señalar que el hecho de que definir una cookie ya existente implica el borrado de la antigua. Del mismo modo, el crear una primera cookie conlleva la generación automática del archivo texto.

Para leer las cookies, nada más fácil que usando el objeto Request (y II)de la siguiente forma:

variable = Request.Cookies("nombre de la cookie")

Si por ejemplo quisiéramos recuperar del archivo txt la cookie correspondiente a la lengua del cliente y almacenarlo en nuestro script para futuros usos, podríamos escribir:

lengua=Request.Cookies("lengua")

Las cookies son una herramienta fantástica para personalizar nuestra página pero hay que ser cautos ya que, por una parte, no todos los navegadores las aceptan y por otra, se puede deliberadamente impedir al navegador la creación de cookies. Es por ello que resultan un complemento y no una fuente de variables infalible para nuestro sitio.

En los programas que hemos visto hasta ahora, hemos utilizado variables que solo existían en el archivo que era ejecutado. Cuando cargábamos otra página distinta, los valores de estas variables se perdían a menos que nos tomásemos la molestia de pasarlos por la URL o inscribirlos en las cookies o en un formulario para su posterior explotación. Estos métodos, aunque útiles, no son todo lo prácticos que podrían en determinados casos en los que la variable que queremos conservar ha de ser utilizada en varios scripts diferentes y distantes los unos de los otros.

Podríamos pensar que ese problema puede quedar resuelto con las cookies ya que se trata de variables que pueden ser invocadas en cualquier momento. El problema, ya lo hemos dicho, es que las cookies no son aceptadas ni por la totalidad de los usuarios ni por la totalidad de los navegadores lo cual implica que una aplicación que se sirviera de las cookies para pasar variables de un archivo a otro no sería 100% infalible.

Nos resulta pues necesario el poder declarar ciertas variables que puedan ser reutilizadas tantas veces como queramos dentro de una misma sesión. Imaginemos un sitio multilingüe en el que cada vez que queremos imprimir un mensaje en cualquier página necesitamos saber en qué idioma debe hacerse. Podríamos introducir un script identificador de la lengua del navegador en cada uno de los archivos o bien declarar una variable que fuese valida para toda la sesión y que tuviese como valor el idioma reconocido en un primer momento.

Estas variables que son válidas durante una sesión y que luego son “olvidadas” son definidas con el objeto Session de la siguiente forma:

Session("nombre de la variable") = valor de la variable

Una vez definida, la variable Session, será almacenada en memoria y podrá ser empleada en cualquier script del sitio web.

La duración de una sesión viene definida por defecto en 20 minutos. Esto quiere decir que si en 20 minutos no realizamos ninguna acción, el servidor dará por finalizada la sesión y todas las variables Session serán abandonadas. Esta duración puede ser modificada con la propiedad Timeout:

Session.Timeout = n° de minutos que queramos que dure

Una forma de borrar las variables Session sin necesidad de esperara que pase este plazo es a partir del método Abandon:

Session.Abandon

De este modo todas las variables Session serán borradas y la sesión se dará por finalizada. Este método puede resultar practico cuando estemos haciendo pruebas con el script y necesitemos reinicializar las variables.

Lo que se suele hacer es crear un archivo en el que se borran las cookies y se abandona la sesión. Este archivo será ejecutado cuando queramos hacer borrón y cuenta nueva