Active Server Pages
Chapter 26
- What are Active Server Pages?
- ASP General Instructions Guide
- Displaying Date, Time, and Text Using Variables, and Forms
- If...Then and For...Next instructions
- Do...Loop and Select...Case instructions
- Subroutines and Include/virtual
- Session and Application methods
- Cookies
- Dictionary Object
- Open Read and Create files
- Introduction to Global.asa
- Active Server Pages Server-Side Scripting Programmer's Reference
- Free Chat Script
- Ready To Use (Free) ASP Scripts
- DSN
To add ASP to your current hosting account please email support@ExpertInternetServices.com .
Active Server Pages (ASPs) are Web pages that contain server-side scripts in addition to the usual mixture of text and HTML (Hypertext Markup Language) tags. Server-side scripts are special commands you put in Web pages that are processed before the pages are sent from your Personal Web Server to the Web browser of someone who's visiting your Web site. . When you type a URL in the Address box or click a link on a Web page, you're asking a Web server on a computer somewhere to send a file to the Web browser (sometimes called a "client") on your computer. If that file is a normal HTML file, it looks exactly the same when your Web browser receives it as it did before the Web server sent it. After receiving the file, your Web browser displays its contents as a combination of text, images, and sounds.
In the case of an Active Server Page, the process is similar, except there's an extra processing step that takes place just before the Web server sends the file. Before the Web server sends the Active Server Page to the Web browser, it runs all server-side scripts contained in the page. Some of these scripts display the current date, time, and other information. Others process information the user has just typed into a form, such as a page in the Web site's guestbook.
To distinguish them from normal HTML pages, Active Server Pages are given the ".asp" extension.
What Can You Do with Active Server Pages?
There are many things you can do with Active Server Pages.
What Do Active Server Pages Look Like?
The appearance of an Active Server Page depends on who or what is viewing it. To the Web browser that receives it, an Active Server Page looks just like a normal HTML page. If a visitor to your Web site views the source code of an Active Server Page, that's what they see: a normal HTML page. However, the file located in the server looks very different. In addition to text and HTML tags, you also see server-side scripts. This is what the Active Server Page looks like to the Web server before it is processed and sent in response to a request.
What Do Server-Side Scripts Look Like?
Server-side scripts look a lot like HTML tags. However, instead of starting and ending with lesser-than ( < ) and greater-than ( > ) brackets, they typically start with <% and end with %> . The <% is called an opening tag, and the %> is called a closing tag. In between these tags are the server-side scripts. You can insert server-side scripts anywhere in your Web page--even inside HTML tags.
Do You Have to Be a Programmer to Understand Server-Side Scripting?
There's a lot you can do with server-side scripts without learning how to program. For this reason, much of the online Help for Active Server Pages is written for people who are familiar with HTML but aren't computer programmers.
ASP General Instruction Guide
Definition
of How ASP Works
ASP
(active server pages) --- The Web Server finds the ASP file, then processes
all the ASP
code between <% ... %> before handing back the page to the browser. Code
between <% ... %> never arrives at the browser, the viewer never
sees the code.
Scripting
Languages in ASP
--- By default the File Level scripting language is set to VBScript.
If you wish to use another language, such as Jscript, you must let the
server know on what level you will be using another language other than
VBScript. This can be
accomplished by:
<%
@ Language=ScriptingLanguage
%>
Replace
the ScriptingLanguage
above
with the name of the scripting language you will be using on a specific page.
I.e.,
<% @ Language=Jscript
%>
You
can also change the Function-Level and System-Level scripting languages also,
but please note that Perl is much more suited for use at the System Level.
File
Naming Conventions and Where to Put the ASP Files
ASP
files are delineated by .asp
at the end of them, much as .htm
or .pl files.
They can be stored in the domainname-www file or where-ever you wish to
store them.
Interacting
With the User/Sending Dynamic Content to User
When
you write ASP,
you will see it directly on the server but the viewer will see only the html
code. The screen shot below shows
what the viewer sees.

The
code below that shows what is actually on the server.
<%
@ LANGUAGE=VBScript %>
<%
Option
Explicit
Response.Expires
= 0
' in minutes
Dim
dtmTime, dtmLater, dtmDiff
dtmTime
= Time
dtmLater
= DateAdd("h",1,dtmTime)
dtmDiff
= DateDiff("h",Now,#1/1/2002#)
%>
<HTML>
<BODY>
Hello
User.
<P>The
server's time is: <%= dtmTime %>.</P>
</P>In
one hour, the server's time will be: <%= dtmLater %>.</P>
<%
If
dtmDiff > 0 Then
Response.Write "Still " & dtmDiff & " hours
"
Response.Write "to go till the year 2002.<BR>" &
VbCrLf
ElseIf
dtmDiff < 0 Then
Response.Write "Already " & Abs(dtmDiff) & "
hours passed since "
Response.Write "the beginning of the year 2002.<BR>"
& VbCrLf
Else
Response.Write "The year 2002 has just begun.<BR>"
& VbCrLf
Response.Write "<B>HAPPY NEW YEAR
!</B><BR>" & VbCrLf
End
If
%>
</BODY>
</HTML>
Please
note that the ASP
code does not show on the browser when a viewer clicks on "View
Source". Only the html
source code is visible. Please
note the highlighted sections under Notepad.
This is what the html source code looks like and what the viewer can
see. The ASP
code is not available.

Displaying
Information from a Database
ASP
can be used to display information directly from a database residing on the
server, without the database naming conventions being available to the viewer.
It also allows ease and speed in accessing the database information.
An
example is shown below:

The
html for the screen above is shown on the picture below:

Note
that the database information and other information pertaining to the table
shown is not shown in the html code. The
ASP
coding on the server that allowed the information to be shown follows:
<html><head>
<TITLE>dbsimple.asp</TITLE>
</head>
<body
bgcolor="#FFFFFF">
<%
'
this code opens the database
myDSN="DSN=testsite_com;uid=testasp;pwd=vnhDKJpC"
set
conntemp=server.createobject("adodb.connection")
conntemp.open
myDSN
'
this code retrieves the data
mySQL="select
* from publishers where state='NY'"
set
rstemp=conntemp.execute(mySQL)
'
this code detects if data is empty
If
rstemp.eof then
response.write "No records matched<br>"
response.write mySQL & "<br>So cannot make
table..."
connection.close
set connection=nothing
response.end
end
if
%>
<table
border=1>
<%
'
This code puts fieldnames into column headings
response.write
"<tr>"
for
each whatever in rstemp.fields
response.write "<td><B>" & whatever.name
& "</B></TD>"
next
response.write
"</tr>"
'
Now lets grab all the records
DO
UNTIL rstemp.eof
' put fields into variables
PubId=rstemp("pubid")
Name=rstemp("name")
Company_name=rstemp("company_name")
Address=rstemp("address")
City=rstemp("city")
State=rstemp("state")
Zip=rstemp("zip")
Telephone=rstemp("telephone")
Fax=rstemp("fax")
Comments=rstemp("comments")' write the fields to browser
cellstart="<td align=""top"">"
response.write "<tr>"
response.write cellstart & PubId & "</td>"
response.write cellstart & Name & "</td>"
response.write cellstart & Company_name &
"</td>"
response.write cellstart & Address & "</td>"
response.write cellstart & City & "</td>"
response.write cellstart & State & "</td>"
response.write cellstart & Zip & "</td>"
response.write cellstart & Telephone & "</td>"
response.write cellstart & Fax & "</td>"
response.write cellstart & Comments & "</td>"
response.write "</tr>"
rstemp.movenext
LOOP
%>
</table>
<%
'
Now close and dispose of resourcesrstemp.close
set
rstemp=nothing
conntemp.close
set
conntemp=nothing
%>
</body></html>
The date and time described in this section are those that are on the server.
To display the current date by itself in a Web page, type:
<% =date %>
at the point where you want it to appear. When you view the page in your browser, you should see something like this:
Thu, Jan 23, 1997
Note: Even though "=date" is a short script, it's actually made up of two parts. The "date" part tells the server, "Get me the date." The equal sign (=) tells the server to display the date in the Web page. If you typed just:
<% date %>
the server would get the current date from your system, but that's all. It wouldn't display it. There are times when it makes sense to use an ASP function without the equal sign.
To display the current time by itself, type:
<% =time %>
where you want it to appear. When you view the page, you should see something like this:
4:19:46 PM
To display the current date and time, type:
<% =now %>
where you want them to appear. When you view the page, you should see something like this:
1/23/97 4:19:46 PM
You can also use Active Server Pages (ASP) functions to customize the way the current date and time are displayed on your Web page. To do this, use the now function together with the following formatting functions.
To display the number of the current month in a Web page, type:
<% =month(now) %>
where you want it to appear. When you view the page in your browser, you'll see a 1 if the current month is January, 2 if it's February, and so on.
To display the name of the current month, type:
<% =monthname(month(now)) %>
where you want it to appear.
To display the day of the current month, type:
<% =day(now) %>
where you want it to appear. When you view the page, you'll see a number between 1 and 31.
To display the current year, type:
<% =year(now) %>
where you want it to appear.
Suppose you wanted to display today's date as day/month/year instead of month/day/year. To do so, you would use the day, month, and year ASP functions together, by typing:
<% =day(now) %>/<% =month(now) %>/<% =year(now) %>
When you viewed the page, you would see something like this:
23/1/1997
Later we'll see how you can change this so only the last two digits of the year are displayed, like this:
23/1/97
To display the day of the week as a number from 1 to 7 in a Web page, type:
<% =weekday(now) %>
where you want it to appear. When you view the page in Internet Explorer, you'll see a 1 if today is Sunday, 2 if it's Monday, and so on.
To display the day of the week by name, type:
<% =weekdayname(weekday(now)) %>
where you want it to appear.
To display just the hour part of the current time, type:
<% =hour(now) %>
where you want it to appear. The hour function is based on a 24-hour clock. When you view the page, you'll see a number between 0 and 23.
To display just the minutes part of the current time, type:
<% =minute(now) %>
where you want it to appear. When you view the page, you'll see a number between 0 and 59.
To display just the seconds part of the current time, type:
<% =second(now) %>
where you want it to appear. When you view the page, you'll see a number between 0 and 59.
Try typing this into a Web page:
The time is <% =time %>. That means it's <% =minute(now) %> minutes past <% =hour(now) %> o'clock.
When you view the page in Internet Explorer, you should see something like this:
The time is 1:36:05 PM. That means it's 36 minutes past 13 o'clock.
Remember, the hour function is based on a 24-hour clock. Later we'll see how to convert from the 24-hour clock to a 12-hour clock.
You probably won't ever use the timevalue function. It takes the different ways you can write the time, such as "2:24PM" and "14:24," and returns them in this format: "2:24:00 PM." This can be useful if you're using a function that needs to be given the time in that exact format.
Earlier in this section we saw how you can use the hour, minute, and second functions to break up the time into hours, minutes, and seconds. With the timevalue function, you can put them back together. Type this into a Web page:
When it's 23 minutes and 5 seconds past 4 o'clock in the afternoon,
that means it's <% =timevalue("16:23:05") %>.
This is the same as <% =timevalue("4:23:05PM") %>
or <% =timevalue("16:23:05PM") %>.
Make sure you type "16:23:05PM" and not "16:23:05 PM." The "05" and the "PM." should be run together, not separated by a space. When you view the page in Internet Explorer, you should see:
When it's 23 minutes and 5 seconds past 4 o'clock in the afternoon, that means it's 4:23:05 PM. This is the same as 4:23:05 PM or 4:23:05 PM.
The len function tells you how many characters are in a word or sequence of words. (The name "len" is an abbreviation of "length.") All characters are counted, including the space character. For example, to find the length of the sentence "The cat is on the mat," type this into a Web page:
There are <% =len("The cat is on the mat.") %> characters in
"The cat is on the mat."
When you view the page in Internet Explorer, you should see this:
There are 22 characters in "The cat is on the mat."
You can use the left function to look at the first few characters of a word or sequence of words. For example, to find the first character of "Frankenstein," type this into a Web page:
"Frankenstein" begins with the letter <% =left("Frankenstein", 1) %>.
When you view the page, you should see this:
"Frankenstein" begins with the letter F.
To look at the last few characters of a word or sequence of words, use the right function. For example, to find the last three letters of "Wednesday," type this into a Web page:
The last three letters of "Wednesday" are: <% =right("Wednesday", 3) %>.
When you view this page, you should see this:
The last three letters of "Wednesday" are: day.
What if you wanted to take a few letters from the middle of something? How would you specify exactly where in the middle you wanted to be? For example, how would you take out just the "apple" part of the word "pineapples"?
You could start with the fifth character from the left and then stop at the second character from the right. Or you could do it the following way.
Try typing this into a Web page:
<% =right("pineapples", 6) %> <% =left(right("pineapples", 6), 5) %>
This line takes the last six letters of the word "pineapples," which make up the word "apples." Then it takes the first five letters of the word "apples," which make up the word "apple."
When you view this page in Internet Explorer, you should see this:
apples apple
Then try typing this into a Web page:
<% =left("pineapples", 9) %> <% =right(left("pineapples", 9), 5) %>
This line takes the first nine letters of the word "pineapples," which make up the word "pineapple." Then it takes the last five letters of the word "pineapple," which make up the word "apple."
When you view this page, you should see this:
pineapple apple
Here are some examples of interesting things you can do with date, time, and text functions.
What if you wanted to have a link that pointed to a different page every day of the week? Here's how you can do that. First, choose the pages (HTML files) on your Web site that you want your link to point to. Name them "Sunday.htm," "Monday.htm," and so on. (If you don't have seven different HTML files, you can copy some of the files or make aliases on your Macintosh to them. The important thing is that there has to be one file or alias for every day of the week.)
To make the link, type
<a href= <% =weekdayname(weekday(now)) %>.htm>Link of the Day</a>
where you want it to appear. When you click this link in Internet Explorer, it will take you to today's page.
Earlier we saw how to change the date display from month/day/year to day/month/year like this:
23/1/1997
We can also change the date display so only the last two digits of the year are included. To do this, type
<% =day(now) %>/<% =month(now) %>/<% =(year(now) - 1900)) mod 100 %>
Now when you view the page, you should see something like this:
23/1/97
In an earlier example, we wrote a server-side script to display the current time in words, such as: "The time is 36 minutes and 5 seconds past 13 o'clock." This script used the ASP hour function, which returns just the hour part of the current time, based on a 24-hour clock.
In this example, we'll see how to change 24-hour clock times such as "13 o'clock" to 12-hour clock times ("1 o'clock PM"). To do this, we'll need to make the server-side script that uses the hour function a little more complicated. Instead of
<% =hour(now) %> o'clock
we'll need to write a script that looks at the hour and does one of the following:
The script is shown below. It isn't written quite the way a programmer would write it, but it works, and it's fairly easy to understand, since it follows the items in the bulleted list above exactly.
The hour is <% if hour(now) = 0 then %> midnight. <% end if if hour(now) = 12 then %> noon. <% end if if (hour(now) >= 1) and (hour(now) <= 11) then =hour(now) %> o'clock AM. <% end if if (hour(now) >= 13) and (hour(now) <= 23) then =hour(now) - 12 %> o'clock PM. <% end if %>
If you type (or better yet, cut-and-paste) this script in a Web page, when you view the page, you should see something like this:
The hour is 4 o'clock PM.
Using Variables, and Forms in Active Server Pages
Forms are a convenient way to communicate with visitors to your Web site. Using forms, you can create a survey form and ask visitors to fill it out. When they fill out the form, you can process the results automatically.With forms, there are two steps: first you create the form, and then you process it. To create a form for an Active Server Page, just create a standard HTML form.
To try out this example, create an HTML file ("form_response.html")
and cut-and-paste the following text into it.
| form_response.html |
| <html> <head><title>Asking for information</title></head> <body> <form method="post" action="form_response.asp"> Your name: <input type="text" name="name" size="20"><BR> Your email: <input type="password" name="email" size="15"><BR> <input type="Submit" value="Submit"> </form> </body> </html> |
Active Server Pages provide a mechanism for processing forms that, unlike CGI scripting, doesn't involve serious programming: the Request.Form.
Considering the form above, we may create the file bellow and get a response.
| form_response.asp |
| <html> <head><title>Responding to a form</title></head> <body> Your name is <% =Request.Form("name") %> <BR> Your email is <% =Request.Form("email") %> </body> </html> |
To display the contents of each field in the form, type:
<% =Request.Form(fieldname) %>where fieldname is the name of the field.
For example, if you have a field called "CatName" in your form, you can save it into a variable called "TheName" by typing:
<% TheName = Request.Form("CatName") %>
If you want to display "VisitorName" several times within a text you
only need to include the variable in the text. For example:
My catīs name is <% =TheName %>. Do you want to see <% =TheName %>?.
| nameandcolor.html |
| <html> <head><title>Name and Color</title></head> <body> <FORM ACTION="nameandcolor.asp" METHOD=POST> Let me know your Name and Favorite Color: <P>YOUR NAME: <INPUT TYPE="TEXT" NAME="YOURNAME" SIZE=20> <P>COLOR: <INPUT TYPE="RADIO" NAME="COLOR" VALUE="1" CHECKED>Red <INPUT TYPE="RADIO" NAME="COLOR" VALUE="2">Green <INPUT TYPE="RADIO" NAME="COLOR" VALUE="3">Blue <P> <INPUT TYPE="SUBMIT" VALUE="OK"> </FORM> </body> </html> |
Now, create an ASP file ("nameandcolor.asp") and cut-and-paste the
following text into it.
| nameandcolor.asp |
| <html> <head><title>Name and Color</title></head> <body> <% TheName = Request.Form("YOURNAME") %> <% colornumber = Request.Form("COLOR") %> Hi, <% =Thename %>.<BR> I know your favorite color is <% if colornumber = "1" then %> red <% end if %> <% if colornumber = "2" then %> green <% end if %> <% if colornumber = "3" then %> blue <% end if %>. </body> </html> |
The If....Then...Else instructions sequence is very similar to the one we
may find in different kind of scripting languages. Let's check an example.
| <% AA="water" If AA="water" Then End If |
We may use it this way:
| <% AA="water" If AA="water" Then %> I want to drink water <% Else %> I want to drink milk <% End If %> |
In both cases we have checked a condition (AA="water"), and we
have get a positive instruction (to write the sentence "I want to drink
water"). We are allowed to execute any kind of instructions (including
If....then....Else) and as many instructions as we want .
For....Next
This instructions is also similar in different programming languages. Let's
see a typical example.
| I want to say "Hello" 10 times<BR> <% For mynumber = 1 to 10 %> <% =mynumber %> Hello<BR> <% Next %> END |
In this case we have defined a variable ("mynumber") and using the For...Next instruction we have repeated 10 times line 4. Similarly to If....Then....Else instruction, we are allowed to execute any kind of instructions and as many of them as we want .
The For...Next instruction allows to define the value of the increment.
| <% For mynumber = 1 to 20 STEP 2 response.write("Hello<BR>") Next %> |
| <% For mynumber = 20 to 1 STEP -2 response.write("Hello<BR>") Next %> |
In both cases we will get the same response ("Hello" 10 times). The increment may be positive or negative as shown in the example.
Do While...Loop
Again, we will define a condition and one or more instructions:
| <% mynumber=0 Do While mynumber<10 response.write("Hello<HR>") Loop |
In this example the condition is "mynumber<10" and the instructions defines a response text and an increment of the variable "mynumber". In the example, mynumber will be increased until it gets a value of 10. Then the loop will be abandon. Several instruction may be used within the loop.
Do Until....Loop
Quite similar to the previous one, it also includes a condition and one or
more instructions:
| <% mynumber=0 Do Until mynumber=10 response.write("Hello<HR>") Loop |
In this example the condition is "mynumber=10", so mynumber will increased until it is equal to 10, and then the loop will be abandon.
Let's see an example using this Do Until...Loop:
| <% myfirstnumber=0 mysecondnumber=0 Do Until myfirstnumber=15 Do Until mynumber=15 Loop Response.write ("END") |
The result of the script is this one:
| XXXXXXXXXXXXXXX XXXXXXXXXXXXXX XXXXXXXXXXXXX XXXXXXXXXXXX XXXXXXXXXXX XXXXXXXXXX XXXXXXXXX XXXXXXXX XXXXXXX XXXXXX XXXXX XXXX XXX XX X END |
Select Case....End Select
This is a very useful instruction in case we want to check different values
for variable. Lets check an example:
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<% mynumber=3 Select Case mynumber Case 1 Response.write ("Number 1") Case 2 Response.write ("Number 2") Case 3 Response.write ("Number 3") Case 4 Response.write ("Number 4") Case 5 Response.write ("Number 5") Case Else Response write ("Mynumber is higher than 5") End Select %> |
In this example above, we have defined mynumber as 3, so they are executed the instructions following line 8 (in this case only one instruction is executed, but they may be several instructions). Case Else is not necessary.
Let's try a second example:
|
1
2 3 4 5 6 7 8 9 10 11 12 13 |
<% username=request.form("username") Select Case username Case "Peter" Response.write ("Hello, Peter") Case "John" Response.write ("Hello, John") Case "Joe" Response.write ("Hi, Joe") Case Else Response write ("I do not know you") End Select %> |
Let's see a different example:
| backgroundform.html |
| <html> <head><title>Chose background color</title></head> <form action="backgroundresponse.asp" method="post"> Which color do you prefer to use as your background? <BR> <input type="radio" name="kindofcolor" value="defined" checked> Defined color <select name="definedcolor"> <option value="#FFFFFF">White</option> <option value="#FF0000">Red</option> <option value="#00FF00">Green</option> <option value="#0000FF">Blue</option> </select> <BR> <input type="radio" name="kindofcolor" value="custom"> Custom color <input type="text" size="8" name="mycolor"></input> <BR><input type="Submit" value="Submit"></input> </form> </body> </html> |
| backgroundresponse.asp |
| <% kindofcolor=Request.form("kindofcolor") Select Case kindofcolor <html> |
Subroutines have the same utility in ASP as it has in other languages.
In the next two examples, we have asked our visitors his name, and depending on that answer a different response is sent to the client. The response will be the same in both cases, but in the second one subroutines are used. The use of subroutines may be very useful when there are a lot of instructions to be perform within a subroutine. This way it will allow us to simplify the structure of our script.
Example 1
| <% TheName=request.form("name) if TheName="John" then |
| <% TheName=request.form("name) if TheName="John" then Sub ResponseToJohn() Sub ResponseToUnknown() %> |
In order to call a subroutine, we will use this kind of code:
Whatever()
Where Whatever is the name of the subroutine (it is recommended to use a very descriptive name of the task we want to perform within the subroutine to make it easier to understand the script). We may also provide information to the subroutine in order to perform the specified task. The data will be provided this way:
Whatever(data1, data2 ... dataN)
In the following example we will provide different data to a unique subroutine depending on the Name of the person provided throw a form:
Example 3
| <% TheName=request.form("name) if TheName="John" then Sub ResponseToVisitor(AA,BB,CC) |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
In line 14 it is specified AA is the first variable to be get, BB the second one, and CC the third one. The values for the three variables are provided in the same order in line 5 or line 8.
The example above also shows subroutines are very useful to avoid
repeating a specific number of tasks several times within the script, so
that the script looks more organized and it is smaller.
Include/virtual
Server Site includes or SSI is a very simple programing language but it also has a very limited number of instructions. We will consider only one option SSI allows us to use within our asp scripts: include/virtual.
In the next example we will use the include option of SSI in a our asp script (response.asp). This command allows as to add a set of instructions from different files (file1.txt and file2.txt bellow) and execute them.
Example 4
| response.asp |
| <% TheName=request.form("name) if TheName="John" then |
| File1.html |
| Hi, John.<br> I know your are 31 years old, you are married to Sue, and you are living in New York. |
| File2.asp |
| <% for i=1 to 3 response.write(Thename & "...<BR>") next response.write("Who are you?") %> |
In this case, if the name of the person who is visiting our page is John, then we will respond with file1.html. If not, then we will execute some asp instructions from file2.asp.
The include file must be a text file (.txt, .html, .htm, .shtml,
.asp...). Although we have used file1.html and file2.asp, the script will
work exactly in the same way with file1.txt and file2.txt (changing the name
of the files would have no effect).
By using SSI and asp we may also get a secret page:
| secret_page.asp |
| <% UserName=request.form ("username") Password=request.form("password") if UserName="myusername" and Password="mypassword" then %> <!--#include virtual="/cgi-bin/secret_info.txt" --> <% else %> <Form Action=secretpage.asp method=post> Username: <input type=text name=username size=15><BR> Password: <input type=text name=password size=15><BR> <input type=Submit Value=Send> </form> <% end if %> |
| secret_info.txt |
| This is my secret information:<BR> My name is John.<BR> My surname is Smith.<BR> <BR>End of secret information. |
In this case it is convenient to save secret_info.txt file in the cgi-bin
directory (the .txt file is not accessible by visitors from this directory,
but it will be accessible from our top directory).
The Session method
The first time a user accesses to a our pages some connections and disconnections took place. During this process the server and the client will interchange information to identify each other. Due to this exchange of information our server will be able to identify a specific user and this information may be use to assign specific information to each specific client. This relationship between computers is call a session. During the time a session is active, it is possible to assign information to a specific client by using Session method. We will use an example to explain this method:
Let's suppose we want to allow specific user to access the information on our site or directory and we want to show a username in all pages visited by the user. In this case we may use the Session method.
In this example, we will ask the username of the person in our
index.asp page
| respondtoforms.asp | |
| <% IF
Request.form="" THEN %>
<html> <% ELSE %> <% <html> Hi <% =Session("username")
%>, you are allow to see these pages: <BR> </body> <% ELSE %> Error in username or password <% END IF %> <% END IF %> |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
Let's explain how this page works:
In line 1 it is checked whether information is submitted throw a form. If the answer is negative (Request.form=""), a form is displayed asking for username and password.
After filling the form and submitting it, as Request.form is not "" and the script will jump to line 15. In line 17 they are checked the username and password. If user name is "Joe" and Password is "please", then two variables are set for the client (lines 21-22):
Session("permission")="YES"
Session("username")="Joe"
These variables will be kept in the server during the time the session is active (normally it will expire after 20 minutes without contact).
Finally, if username and password are correct, a response page with links is send to the client with the name of the user in the top. In this example, if the username or password are incorrect the response page will include the text in line 38.
Now, let's suppose the user clicks in the link "Page 1"
(page1.asp). The code of page1.asp will be the following one:
| page1.asp | |
| <% IF
Session("permission")="YES" THEN %>
<html> Hi <% =Session("username")
%>, welcome to Page 1 <BR> </body> <% ELSE %> You are not allowed to access this page <% end IF %> |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
In line 1 it is check whether the value for Session("permission") is "YES". If the answer is positive a page with information is send to the client. If the answer is negative, the text in line 15 is send.
NOTES:
With Session method we have defined a value for Session("whatever")="Joe", but this information can not be share between visitors (Session("whatever") has a unique value for each visitor). To allow sharing information Application method is used.
For a better understanding of this method we will create a counter
which will be shown in the same page. In order to make it work, copy the
code below to your server:
| counter.asp | |
| <% Aplication.Lock Application("pagevisits")=Application("pagevisits")+1 Application.Unlock %> <html> Under construction<BR><BR> </body> |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
In the first part of this code, as Application method is shared between different clients, it is necessary to prevent other clients from modifying the information in Application("pagevisits"). Application.Lock will avoid that by stopping the information to be shared, and Application.Unlock will allow the information to be shared again. Line 3 increases the value for the counter.
Finally a html code is send to the client, including the value of the counter.
NOTES:
Session and Application method has been used to create a simple chat script (copy and paste the code to your site and it will work immediately.
Cookies method is very similar to Session
method: the basic difference is that with Cookies method the information
is save in the clients computer and not in the server, so it is more
suitable for sites with a lot of visitors. This method implies sending
information to the client and requesting it whenever the information is
needed. Additionally, we will learn how to delete the information save in
the clients computer when it is not necessary anymore.
When the visitor gets to our asp file we may save information related with him in his computer. The order will be like this one:
<% response.Cookies ("whatever")="information" %>
When this line is executed, the visitor will have the information in his computer, and whenever we need that information, we may request it using this code:
<% =request.Cookies ("whatever") %>
or
<% variable1=request.Cookies ("whatever") %>
Let's try an example using Cookies method: let's consider we have
visitors checking our site several times and we want to let them know how
many times they have accessed to our computer.
| <% If Request.Cookies ("NumberVisits")=""
Then %> <% Response.Cookies ("NumberVisits")=1 %> This is your first visit to this page. Welcome. <% Else %> <% VarNumberVisits=Request.Cookies ("NumberVisits") VarNumberVisits=NumberVisits+1 Response.Cookies("NumberVisits")=VarNumberVisits %> Welcome back to this page.
You have visited this page <% =VarNumberVisits %> times. <% End If %> |
Cookies method may be used to show visitors specific information we have requested throw a form, as for example a list of links related to a specific theme, information to allow access to the content of a page or to personalize the page (background color, frames or not frames...), information to fill a form automatically, etc.
In order to learn how Dictionary object works we will create a
small script which will translate number 1 to 10 from English to
Spanish.
| translate.asp | |
| <% SET MyDictionary=CreateObject("Scripting.Dictionary") MyDictionary.Add "one","uno"EnglishNumber="four" SpanishNumber=MyDictionary.Item (EnglishNumber) Response.Write(SpanishNumber) %> |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
How the script works
| if MyDictionary.Exists
("ten")=True then Response.Write("this key is included in the dictionary") lse Response.Write("Error: no such a key in the dictionary") end if |
Example: Translation of a number from English to Spanish
This example uses most of the elements explained above. Try it.
| translation.asp | |
| <html> <title>Page under construction</title> <body> <% MyDictionary.Add "one","uno"EnglishNumber=request.form("EnglishNumber") Response.Write("English number: " & EnglishNumber) if
MyDictionary.Exists (EnglishNumber)=True then <% Sub Sendform() %> </body> |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
Example: Password protected information
| secretpage.asp | |
| <% if request.form="" then Sendform() else SET MyDictionary=CreateObject("Scripting.Dictionary") MyDictionary.Add "John","123" MyDictionary.Add "Peter","456" MyDictionary.Add "Anna","789" Username=request.form("Username") Password=request.form("password") if
MyDictionary.Exists (Username)=True AND
Password=MyDictionary.Item (Username) then <% Sub Sendform() %> <% Sub SecretInfo() %> |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
Example 1: This one will be the basic code we need to open
a text file:
| 1 2 3 4 5 6 7 8 9 10 11 12 |
<% Set fs = CreateObject("Scripting.FileSystemObject") Set wfile = fs.OpenTextFile("c:\Mydir\myfile.txt") wfile.close response.write(filecontent) |
Line 2 will create the appropriate environment which allows to perform the operations involving files in the server. We have defined a variable named "fs" to do it (we may change the name of this variable).
In line 4 we have create a new variable named "wfile" and we have apply the method OpenTextFile to variable "fs". We have also define which is the exact location of the file we want to open in this line (the complete path is necessary).
In line 5 we have read all the content of the file to a variable named "filecontent" using the instruction "ReadAll".
Lines 7 to 9 are use to let the server know we have finished all operations involving files.
In line 11 we have response to the client with the content in the
variable "filecontent".
Example 2: Let's suppose we have a file with different
kind of information in each line (a name in the first line, the last
name in the second one, and the age in the third one), and we want
to use them separately. This one will be the script we may use:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<% Set fs = CreateObject("Scripting.FileSystemObject") Set wfile = fs.OpenTextFile("c:\Mydir\myfile.txt") wfile.close %> Your first name is <% =firstname %><BR> |
This example is very similar to the previous one, but in this case each line we have read from "myfile.txt" has been saved to a different variable (lines 5 to 7), and they have been used in lines 15 to 17 to respond to the client.
Example 3: This example will read all lines in the file,
and the response page will include the content of each line with its
line number.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<% Set fs = CreateObject("Scripting.FileSystemObject") Set wfile = fs.OpenTextFile("c:\Mydir\myfile.txt") counter=0 wfile.close %> |
In line 6 we will define the variable "counter", and in line 7 to 11 we will repeated instructions within the Do_While _Loop until the file does not reach the end of the file (the condition is "not wfile.AtEndOfStream").
Example 4: Let's suppose we have a file with a number in
line 1 and a second number in line 2.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
<% Set fs = CreateObject("Scripting.FileSystemObject") Set wfile = fs.OpenTextFile("c:\Mydir\myfile.txt") number1 = Clng(wfile.ReadLine) number1and2 = number1 + number2 wfile.close %> |
In the previous examples we were able to save the value in a line
to a variable, but that variable was a string class variable. In
this example we have saved the content of line 1 and line 2 to
variables "number1" and number2" by using the
function "Clng". This function has allow us to add
both numbers in line 9 and send the result to the client (line 10).
Create and Write a text file
Example 1: The basic code we need to create a file is very
similar to that one we have used to open a file:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
<% thetext="Write this text in the file" Set fs = CreateObject("Scripting.FileSystemObject") Set wfile = fs.CreateTextFile("c:\Mydir\myfile.txt",
True) wfile.close response.write("Text created") |
The differences to instructions when opening a file are line 6 and line 7:
The method used in line 6 is "CreateTextFile"; it is necessary to indicate the complete path to the file we want to create; in line 6 we may use the instruction True (to allow over-writing an existing file) or False (if the file exits, it is not over-written).
Line 7 will write in the file the string in variable
"thetext".