<%@ LANGUAGE="VBScript" %>
<HTML>
<HEAD><TITLE>Prueba de ASP</TITLE></HEAD>
<BODY>
Bienvenidos al ASP. Son las <% Response.Write( Time() ) %>
</BODY>
</HTML>
El código de arriba es una sencilla muestra de ASP. Como puedes ver, salvo la primera y la quinta líneas no tiene nada que no conozcamos ya. Analicemos esas dos líneas:
La primera es la definición del lenguaje de comandos que vamos a utilizar, en este caso VBScript; la arroba que hay al principio (@) indica que la página se debe ejecutar en el servidor y no en el navegador, que sólo debe recibir el resultado.
En la quinta línea ya tenemos un objeto (Response -respuesta-) con uno de sus métodos (Write -escribir-). El objeto Response es el que gestiona la salida para el navegador, y su método Write el encargado de escribir esa salida, dicho de otro modo, el conjunto Response.Write() escribirá en la pantalla del cliente el resultado generado por los comandos ASP, en este caso la hora proporcionada por la función Time()
Fíjate en que el valor real de la quinta línea es compuesto: por una parte está la frase "Bienvenidos al ASP. Son las " y por otro una secuencia de comandos que da la hora del servidor. El motor ASP se encargará de ejecutar los comandos y componer el texto final con las dos cosas antes de enviarlas al navegador del cliente.
Response.Write() es muy utilizado en ASP, ya que cualquier variable, valor o cadena de texto tiene que ser visualizada mediante este objeto, para abreviar se puede usar el signo igual (=) con el mismo resultado. En nuestro ejemplo de la quinta línea podría ser:
Bienvenidos al ASP. Son las <% = Time() %>
Response.Write() no sólo muestra el resultado de funciones como Time() (hora), Date() (fecha), o cualquier otra; podemos escribir cualquier valor para que sea visualizado, como cadenas de texto puras, cadenas concatenadas con constantes, funciones anidadas, variables de sesión, variables de aplicación, respuestas de otros objetos, código HTML, etc., etc., y por supuesto, podemos invocar el objeto Response tantas veces como sea necesario.
En el caso de que se quieran presentar dos datos concatenados (enlazados, unidos) en HTML, simplemente escribiríamos uno al lado del otro, pero en ASP hay que echar mano de un carácter especial: el ampersand (&). Así. en el ejemplo, si en lugar de presentar sólo la hora, quisiéramos ver la hora y el dia, habría que escribir:
Bienvenidos al ASP. Son las <% = Time() & " del dia " & Date() %>
Si lo que se trata de concatenar es un string (cadena de texto) que contiene comillas dobles, se puede hacer de dos formas: utilizando la función Chr() o escribiendo dos pares de comillas en lugar de uno.
Por ejemplo si queremos concatenar la cadena:
Esto es un con la cadena "string" que va entrecomillada, se escribirá:
<% = "Esto es un "& "" string "" %>
O también:
<% = "Esto es un " & Chr(34) & " string " & Chr(34) %>
Y en ambos casos este sería el resultado:
Esto es un "string"
El argumento 34 que se le ha dado a la función Chr() es el que le corresponde al carácter que queremos obtener, según la tabla de caracteres, que puedes consultar en este mismo manual. Este truco puede utilizarse para obtener cualquier carácter, pero sobre todo está indicado cuando hay que enviar caracteres especiales al cliente, pero no queremos que sean interpretados por él, tales como " % & y otros.
Otro truco que se utiliza al escribir ASP, es el truncamiento de líneas. Por ejemplo, si tienes que escribir una línea de comandos o strings que es muy larga, para evitar que el editor tenga que hacer scroll (desplazarse) por la derecha, cosa que dificulta después la lectura y revisión del código escrito, se puede utilizar el carácter de subrayado para indicar a ASP que la línea que viene justo debajo debe ser considerada como una misma línea. Así
<%
Response.Write("Este es un string de muestra que hay que concatener con otro, pero es demasiado largo y " & _
"recurriremos al carácter _ para que resulte más legible")
%>
Recuerda que entre la primera y la segunda línea no puede haber ninguna en blanco, ni tampoco un comentario; tienen que estar juntas. Se puede utilizar el truncamiento cuantas veces sea necesario. Como ya habrás visto, siempre que se utilizan strings (cadenas de texto), hay que escribirlas entre comillas dobles ("). Si se trata de números no hay que escribirlos entrecomillados, y si se trata de fechas, se escriben entre símbolos #. En el siguiente ejemplo se representan un string, un número y una fecha, por ese orden:
<%
Response.Write( "Esto es un texto" )
Response.Write( 50 )
Response.Write( #02/28/2000# )
%>
Y a propósito de las fechas, en ASP y VBScript, el único formato reconocido es INGLES-ESTADOS UNIDOS, sin tener en cuenta la configuración regional del usuario. Es decir, el formato que se reconoce es mm/dd/aaaa. Así en el ejemplo de arriba, tenemos el día 28 de Febrero de 2000. Lo que obliga a realizar las conversiones necesarias para el formato europeo de dd/mm/aaaa.
Al igual que cuando se diseña una página html cualquiera, hay que tener claro lo que se quiere hacer.... pues con ASP mucho más. Un cambio de idea en HTML no suele dar demasiados problemas, pero un cambio de idea en programación en general y en ASP en particular, puede acabar obligando a reescribir la aplicación... lo malo es que esto puede suceder muy a menudo...
Como ya se ha dicho, la programación de gestión es algo que tiende al caos con pasmosa rapidez, y el cambio de criterios salta cuando menos lo esperas. Para evitar en lo posible el tener que reescribir constantemente los programas, lo mejor es escribirlos de forma estructurada, es decir, evitar en lo posible escribir código en la forma "todo revuelto", y si hay que hacer algun cambio, que sea posible limitarlo a invocar una rutina en lugar de otra. Sería como construir el programa con piezas prefabricadas, donde cada una de las cuales hace una cosa diferente. En realidad en esa misma idea estan basados los objetos a los que se ha hecho referencia antes.
Además de construir rutinas o módulos de programa, podemos escribir partes del texto HTML de uso repetitivo (por ejemplo mensajes de error, formularios, textos de ayuda, cabeceras de publicidad, membretes, etc.) en ficheros aparte, e incluirlos cuando sea necesario. Esto tiene varias ventajas: Se simplifica el mantenimiento del programa, sólo hay que escribir el texto en cuestión una vez, si luego hay que cambiarlo, no es necesario ponerse a "bucear" entre cientos de líneas... y dejarnos siempre alguna sin cambiar: con editar un solo fichero realizamos el cambio en todas partes. Para esto se utilizan las includes de ASP.
Imagina que al ejemplo ASP del principio, fuera necesario ponerle algun párrafo adicional, como el logo de la empresa o cualquier otra cosa: Sólo tenemos que escribir un fichero con el texto o código necesario, y guardarlo con la extensión .inc, aunque también pueden guardarse con la extensión .asp igual que el fichero principal. Los ficheros de inclusión pueden ser de dos clases: file y virtual. Se escriben igual, pero los primeros se referencian mediante su ruta real en el disco del servidor, por ejemplo: "C:\asp\aplicaciones\logo.inc" y los segundos mediante su ruta virtual en el árbol del web, como "/miapliacacion/includes/logo.inc" La llamada a una include se escribe como un comentario de HTML. Esta es la sintaxis de una include virtual en el ejemplo anterior:
<%@ LANGUAGE="VBScript" %>
<HTML>
<HEAD><TITLE>Prueba de ASP</TITLE></HEAD>
<BODY>
<!--#include virtual="/miapliacacion/includes/logo.inc"-->
Bienvenidos al ASP. Son las <% Response.Write( Time() ) %>
</BODY>
</HTML>
Cuando el motor ASP detecta una include, busca el fichero en la ruta que se haya especificado, inserta su contenido en lugar de la instrucción, y continua con el resto de comandos secuencialmente. Si se produce un error en el código de una include, el debugger nos dará el número de línea como si su contenido hubiese estado escrito en el fichero principal. Los ficheros de inclusión no tienen los elementos típicos del HTML como <BODY>, <HEAD>, etc., eso debe ir en el fichero principal. Las includes son simples trozos del código que se guardan en otros ficheros, y aunque no veamos su contenido al editar el fichero principal, ASP los lee y depura como si solamente hubiese un único fichero.
ATENCION: Los ficheros de includes tienen un grave problema de seguridad si se guardan con la extensión .inc. Como ya sabemos, el IIS no muestra el código interno de un fichero .asp, sino que lo ejecuta como un programa, y es el HTML resultante de esa ejecución, realizada dentro del servidor, lo que se envia al cliente. Esto no ocurre con los ficheros .inc, de forma que si un cliente conoce la ruta donde reside un fichero .inc, y lo solicita, el servidor se lo enviará sin ejecutarlo previamente, por lo que se podrá ver el código fuente. Si el fichero de include contiene claves de acceso a bases de datos, o alguna otra información confidencial, ésta quedará al descubierto. Así pues, los ficheros con extensión .inc solamente deben utilizarse para contenidos "tontos", como cabeceras, gráficos, botonerias, logos, etc., y si contienen código sensible, se deben guardar con la extensión .asp
Otra forma de estructurar las aplicaciones puede ser escribir módulos en VBScript o JavaScript de forma independiente, de manera que el control del programa se escribe en HTML y mediante comandos Call() se invocan las distintas rutinas o módulos en el momento oportuno. Por ejemplo:
<SCRIPT LANGUAGE=VBScript RUNAT=Server>
Public Sub Rutina_hora
'------Aqui se obtiene la hora
Response.Write( Time() )
End Sub
</SCRIPT>
<HTML>
<HEAD><TITLE>Prueba de ASP</TITLE></HEAD>
<BODY>
Bienvenidos al ASP. Son las <% Call(Rutina_hora) %>
</BODY>
</HTML>
En este caso el módulo Rutina_hora es muy sencillo, pero si la aplicación tiene 15 ó 20 módulos de un montón de líneas cada uno, esta forma de escribir te permite ver más claramente las cosas. Con este estilo analizaremos más adelante una aplicación completa.
Fíjate en que hay algunas diferencias entre este ejemplo y el anterior, aunque hacen lo mismo. Concretamente en la primera línea ha desaparecido la arroba que indicaba la ejecución del código en el servidor. Ahora se indica también, pero con la instrucción RUNAT=Server. Otra cosa interesante está en la tercera línea: '------Aqui se obtiene la hora Esto es un comentario. En efecto, en el entorno de VBScript, los comentarios no se escriben como en HTML, sino escribiendo un apóstrofe (' OJO esto no es un acento) y a continuación el texto que se desea comentar. La indicación de comentario será efectiva hasta que se escriba un retorno. Se pueden (y se deben) escribir cuantos comentarios se estimen necesarios. El servidor ignorará el texto marcado como tal en el momento de la ejecución del programa.
El cliente no recibirá nada de esto, ya que todo ocurre en el servidor. El cliente solamente recibe esto:
<HTML>
<HEAD><TITLE>Prueba de ASP</TITLE></HEAD>
<BODY>
Bienvenidos al ASP. Son las 18:00:00
</BODY>
</HTML>