|
Programación en ASP |
|
Manual
por: DesarrolloWeb.com |
Versión
on-line: |
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. El
lector interesado por la sintaxis de Visual Basic Script y su programación del
lado del cliente puede encontrar en este mismo sitio otro manual para tratar
exclusivamente Visual Basic Script.
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.
Antes de comenzar a leer este manual es altamente aconsejable, sino
imprescindible, haber leído previamente el manual sobre páginas dinámicas
en el cual se explica a grandes rasgos qué es el ASP, algunos conceptos útiles
sobre el modo de trabajar con páginas dinámicas al mismo tiempo que nos
introduce algunos elementos básicos de la programación como pueden ser las
variables y las funciones.
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".
Los scripts que usamos en estos primeros ejemplos pueden ser descargados aquí.
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. También podemos elegir Homesite, un editor
que no es específico para las ASP, pero que se comporta bastante bien y ofrece
ayudas interesantes.
Informe
de Rubén Alvarez
Pasos previos I:
Instalación del PWS
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 W-NT el servidor a instalar es el Internet Information
Server (IIS4). 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...
Informe
de Rubén Alvarez
Pasos previos II:
Conexión a 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.
Informe
de Rubén Alvarez
Inicio a la
programación en ASP
A lo largo de los capítulos precedentes nos ha quedado claro que el ASP es un
lenguaje orientado a las aplicaciones en red creado por Microsoft que funciona
del lado servidor. Es en efecto el servidor quien se ocupa de ejecutarlo,
interpretarlo y enviarlo al cliente (navegador) en forma de código HTML.
ASP es principalmente utilizado sirviéndose del lenguaje Visual Basic Script
que no es más que una versión light del Visual Basic. Sin embargo, es posible
programar páginas ASP en Java Script. 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 Java Script 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" %> |
Si quieres ver el efecto que produce pincha aquí
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 browser 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.
Informe
de Rubén Alvarez
Bucles y
condiciones I
La programación exige en muchas ocasiones la repetición de acciones sucesivas o
la elección de una determinada secuencia y no de otra dependiendo de las
condiciones específicas de la ejecución.
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. Para una mayor información sobre este tipo de
elementos así como sobre los tipos de variables, referirse al manual de VBScript que
trata más detenidamente estos aspectos.
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
necesariamente 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" %> |
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.
Si quieres ver el efecto que produce pincha aquí
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.
Informe
de Rubén Alvarez
Bucles y
condiciones II
Los bucles FOR
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" %> |
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.
Si quieres ver el efecto que produce pincha aquí
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.
Informe
de Rubén Alvarez
Bucles y
condiciones III
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.
Informe
de Rubén Alvarez
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.
Informe
de Rubén Alvarez
Objeto Request I
Bucles y condiciones son muy útiles para procesar los datos dentro de un mismo
script. Sin embargo, en un sitio internet, las páginas vistas y los scripts
utilizados son numerosos. Muy a menudo necesitamos que nuestros distintos
scripts estén conectados unos con otros y que se sirvan de variables comunes.
Por otro lado, el usuario interacciona por medio de formularios cuyos campos
han de ser procesados para poder dar una respuesta. Todo este tipo de factores
dinámicos han de ser eficazmente regulados por un lenguaje como el ASP.
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&variable2=valor2&..."></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> |
|
<HTML> |
Si quieres ver el efecto que produce pincha aquí
Informe
de Rubén Alvarez
Objeto Request II
Transferir variables por formulario
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> |
Si quieres ver el efecto que produce pincha aquí
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:
|
HTTP_ACCEPT_LANGUAGE |
Nos
informa de la lengua preferida por el navegador |
|
HTTP_USER_AGENT |
Indica
cuál es el navegador utilizado. |
|
PATH_TRANSLATED |
Nos
devuelve el path físico del disco duro del servidor en el que se encuentra
nuestro script |
|
SERVER_SOFTWARE |
Nos
dice qué tipo de software utiliza el servidor |
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:
|
<% |
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.
Informe
de Rubén Alvarez
Objeto Response
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.
Informe
de Rubén Alvarez
Las famosas
cookies
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:\Windows\Cookies para los usuarios de IE 4+ o a
C:\...\Netscape\Users\defaultuser 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 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.
Informe
de Rubén Alvarez
Objeto Session
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:
|
<% @
LANGUAGE="VBSCRIPT" %> |
Informe
de Rubén Alvarez
Trabajar con bases
de datos en ASP
Una de las principales ventajas que presenta el trabajar con páginas dinámicas
es el poder almacenar los contenidos en bases de datos. De esta forma, podemos
organizarlos, actualizarlos y buscarlos de una manera mucho más simple.
ASP nos ofrece una forma muy eficaz de interaccionar con estas bases de datos
gracias al uso del componente ADO (ActiveX Data Objects) el cual permite
acceder a dichas bases de una forma sencilla.
Este ADO no es más que un conjunto de objetos que, utilizados en conjunto, nos
permiten explotar de una forma muy versátil las bases de datos de nuestra
aplicación. No entraremos por el momento en consideraciones teóricas al
respecto.
Por otra parte, lo scripts ASP deben establecer un dialogo con la base de
datos. Este dialogo se lleva a cabo a partir de un idioma universal: el SQL
(Structured Query Language) el cual es común a todas las bases de datos. Este
lenguaje resulta, como veremos en el manual de SQL, muy potente
y fácil de aprender.
En este manual de ASP nos limitaremos a utilizar las instrucciones básicas que
serán aprendidas a medida que explicamos las diferentes formas de actuar sobre
una base de datos a partir de páginas ASP.
La base de datos que ha sido utilizada en estos ejemplos es MS Access. No es
por supuesto la única si bien es la más corriente en pequeños PCs y resulta
absolutamente operativa siempre que las tablas no sean astronómicamente
grandes. Esperamos poder ofreceros próximamente también un pequeño curso de
Access en el que explicar los principios rudimentarios necesarios para poder
servirnos de él. No obstante, esta aplicación resulta suficientemente fácil e
intuitiva como para poder prescindir de dicho curso por el momento.
Así pues, para sumergirnos en estos capítulos siguientes, hemos de cumplir los
siguientes requisitos técnicos:
-Instalar el
PWS
-Enlazar la
base de datos con ODBC
-Instalar el MS Access (viene dentro dell pack Office)
-Disponer de un browser y un editor (MS IE y Home Site son nuestras humildes
recomendaciones)
La base de datos y los scripts que usamos en los ejemplos pueden ser
descargados aquí.
Informe
de Rubén Alvarez
Selecciones en una
tabla
Dentro de una base de datos, organizada por tablas, la selección de una tabla
entera o de un cierto numero de registros resulta una operación rutinaria.
A partir de esta selección se puede posteriormente efectuar toda una serie de
cambios o bien realizar una simple lectura.
El siguiente script nos permite realizar la lectura de la tabla clientes contenida
en nuestra base de datos. A primera vista todo nos puede parecer un poco
complejo, pero nada más lejos de la realidad.
|
<HTML> |
Antes de nada, si lo que deseamos es interrogar una base de datos, lo primero
que hay que hacer es obviamente establecer la conexión con ella. Esto se hace a
partir del objeto Connection el cual es "invocado" o más técnicamente
dicho instanciado por medio de la primera instrucción en la cual el objeto toma
el nombre arbitrario de la variable Conn .
El paso siguiente es abrir el objeto y asignarle la base de datos con la que
debe contactar. En este caso, la base la hemos llamado Mibase. Este debe de ser
el mismo nombre con el que la hemos bautizado cuando hemos configurado los
conectores ODCB, además, este nombre no tiene por qué coincidir necesariamente
con el nombre del archivo.
Una vez creada la conexión a nuestra base de datos, el paso siguiente es hacer
nuestra petición. Esta petición puede ser formulada primeramente y almacenada
en una variable (sSQL) para, a continuación, ser ejecutada por medio de la
instrucción siguiente.
La petición que hemos realizado en este caso es la de seleccionar todos los
campos que hay en la tabla clientes (* es un comodín) y ordenar los resultados
por orden alfabético con respecto al campo nombre. Podemos ver más
detalladamente este tipo de instrucciones SQL en nuestro manual de SQL.
El resultado de nuestra selección es almacenado en la variable RS en forma de
tabla. Para ver la tabla lo que hay que hacer ahora es "pasearse" por
esta tabla "virtual" RS la cual posee una especie de cursor que, a
menos que se especifique otra cosa, apunta al primer registro de la selección.
El objetivo ahora es hacer desplazarse al cursor a lo largo de la tabla para
poder leerla en su totalidad. La forma de hacerlo es a partir de un bucle Do
While el cual ya ha sido explicado anteriormente y que lo único que hace es
ejecutar las instrucciones comprendidas entre el Do y el Loop siempre que la
condición propuesta (Not RS.Eof) sea verdadera. Esto se traduce como
"Ejecutar este conjunto de instrucciones mientras que la tabla de
resultados (RS) no llegue al final (Eof, End of File).
Las instrucciones incluidas en el bucle son, por un lado, la impresión en el
documento de los valores de determinados campos ( =RS("nombre del
campo")) y por otro, saltar de un registro al otro mediante la instrucción
RS.MoveNext.
Todo este conjunto de instrucciones ASP viene en combinación con un código HTML
que permite su visualización en forma de tabla. Además, se han incluido unos
enlaces que apuntan hacia otra serie de scripts que veremos más adelante y que
formaran en conjunto una aplicación.
Es interesante ver el código fuente resultante de este script. En este caso el
código que ve el cliente resulta sensiblemente más sencillo.
Para ver funcionar el script pincha aquí
Informe
de Rubén Alvarez
Creación de un
nuevo registro
En este caso lo que buscamos es crear, a partir de los datos recibidos de un
formulario, un nuevo registro en nuestra tabla clientes. Tendremos pues dos
archivos diferentes, uno que podría ser un HTML puro en el que introducimos el
formulario a rellenar y que nos envía al segundo, un script muy parecido al
previamente visto para realizar una selección. He aquí los dos scripts:
|
<HTML> |
|
<HTML> |
Como puede verse, la forma de operar es idéntica a la vista anteriormente para
el display de una tabla. En este caso hemos introducido un enlace a este primer
script de lectura para ver cómo los cambios se han hecho efectivos.
La construcción de la sentencia SQL se hace por fusión de los distintos
elementos constitutivos. La forma de fusionarlos mediante el símbolo &.
Todo lo que sea texto tiene que ir entre comillas. Sería interesante introducir
una línea suplementaria en vuestro código para imprimir la sSQL formada. La
línea sería del siguiente tipo:
Response.Write sSQL
Esta línea iría situada evidentemente después de haber construido la sentencia.
Para ver funcionar el script pincha aquí
Informe
de Rubén Alvarez
Actualización de
un registro existente
Para mostrar cómo se actualiza un registro presente en nuestra base de datos,
vamos a hacerlo a partir de un caso un poco más complejo para que empecemos a
familiarizarnos con estas operaciones. Realizaremos un par de scripts que
permitan cambiar el numero de teléfono de las distintas personas presentes en
nuestra base. El nombre de estas personas, así como el nuevo numero de
teléfono, serán recogidos por medio de un formulario.
El archivo del formulario va a ser esta vez un script ASP en el que
efectuaremos una llamada a nuestra base de datos para construir un menú
desplegable donde aparezcan todos los nombres. La cosa quedaría así:
|
<HTML> |
La manera de operar para construir el menú desplegable es la misma que para
visualizar la tabla. De nuevo empleamos un bucle Do While que nos permite
mostrar cada una de las opciones.
El script de actualización será muy parecido al de inserción:
|
<TITLE>Actualizar2.asp</TITLE> |
Nada que comentar al respecto salvo la estructura de la sentencia SQL que en
este caso realiza un Update en lugar de un Insert. Aconsejamos, como para el
caso precedente imprimir el valor de sSQL de manera a ver cómo queda la
sentencia una vez construida.
Para ver funcionar el script pincha aquí
Informe
de Rubén Alvarez
Borrado de un
registro
Otra de las operaciones elementales que se pueden realizar sobre una base de
datos es el borrar un registro. Para hacerlo, SQL nos propone sentencias del
tipo Delete. Veámoslo con un ejemplo aplicado a nuestra agenda. Primero,
crearemos un menú desplegable dinámico como para el caso de las
actualizaciones:
|
<HTML> |
El siguiente paso es hacer efectiva la operación a partir de la ejecución de la
sentencia SQL que construimos a partir de los datos del formulario:
|
<HTML> |