ASP 初步资料

ASP编程入门进阶（一）：安装配置服务器
鉴于ASP脚本语言是在服务器端IIS或PWS中解释和运行，并可动态生成普通的HTML网页，然后再传送到客户端供浏览的这一特点。我们要在本机上进行调试，那就要求我们的个人电脑具有服务器的功能。
　　IIS为何物？IIS是Internet Information Server的缩写,它是微软公司主推的Web服务器。那PWS呢？它就显得有些古老了：）早期在WIN98，当然现在仍有人采用的操作系统，PWS（Personal Web Server）是一般用户最容易得到的web服务器： 在win98的安装盘的Add_on/pws目录下就可以找到pws的安装程序。而对于IIS是我们所推荐的，也是大部分朋友在使用的，有必要。1，打开控制面板　IIS服务器算是安装OK了，那具体有什么用处？又该如何使用呢？
首先IIS的作用之一就是可以解释执行ASP网页代码，并将结果显示出来。当然就现在而言，你的机器充当的既是服务器端，又是客户端，该技术对你来说是透明的，你不需要也没必要去研究它的原理，就这样去理解去应用。
那打开你的浏览器，随便IE，NS，TE还是MYIE，只要是能浏览网页的浏览器，在其地址栏输入：localhost/ 查看即可。出现当前该窗口就表示已经成功了：WEB服务正在运行这，就行了？你知道下面怎么办呢？很是没头绪，对吧。费尽心思学到现在，就是看了人家的一个ASP页面。那我自己做，调试自己的ASP网页又该如何呢？首先，你得想好你的ASP文件总要放在一个地方吧。打开“我的电脑”，在E盘下面建立一个“myasp”文件夹，以后所有的ASP文件先暂时放到这里吧。
然后，从“开始”菜单，“程序”—“附件”—打开“记事本”。在里面敲入　<%=now()%>　接着将文件保存到E:/myasp/文件夹里面，并且命名为time.asp一个很简单的ASP文件就OK了，下面我们怎么办？一句话：调试。怎么调试？还是输入我们刚才的http://localhost/ ？很显然是不行的。那这时候是不是难点来了：我该如何调试我自己定义的一个文件夹里的ASP文件呢？同样，一句话：用虚拟目录。那什么是虚拟目录？又该如何建立一个虚拟目录呢？
（引一段话：要从主目录以外的其他目录中进行发布，就必须创建虚拟目录。“虚拟目录”不包含在主目录中，但在显示给客户浏览器时就象位于主目录中一样。虚拟目录有一个“别名”，供 Web 浏览器用于访问此目录。别名通常要比目录的路径名短，便于用户输入。使用别名更安全，因为用户不知道文件是否真的存在于服务器上，所以便无法使用这些信息来修改文件。）
对初学者而言不必理会，重在实践，用多了自然会理解这段话的意思。
    大体上就是让我刚才的myasp文件夹用一个代号来标记，比如就标记为myasp，那我调试的时候只要输入：http://localhost/myasp/time.asp 就可以调试了。那如何标记呢？也就是如何建立一个虚拟目录呢？从“控制面板”里面打开“管理工具”，弹出的窗口中右键“新建”—“虚拟目录”，弹出“虚拟目录创建向导”，再下一步，目录：浏览到E:/myasp即可。紧跟一步，访问的权限一定要把“读取”和“运行脚本”打勾。最终点击“完成”。 那么剩下的就是调试该time.asp了。在“Internet信息服务”里面右键time.asp，选择“浏览”就可以看到了。就这么简单，你已经ASP入门了。
ASP编程入门进阶（二）：认识表单 说实话，无论是asp,php还是jsp进行网络编程的时候，都离不开和用户的交互。而人机对话的平台，基本上是靠相应的文本、列表框进行输入，然后通过按钮提交送至数据库的。所以学习网络编程就一定要了解这些输入平台相关的东西：表单（form）其基本格式如下：

可以总结出：表单即包括<form>...</form>之内的相关内容。其中内部可以分三大类：input，select，textarea
一，首先看<form>内部参数参数name：用来表示该表单的唯一名称，方便一个页面建立多个表单而不混淆，当然更是为了接受页面的确认关系。　参数action：显而易见，是表示当前表单中所有内容将送交某个页面去处理。处理包括接受信息，数据库比较添加，修改等。参数method：即表单的提交方法，含两种方法：post和get。post是传输信息内容，get是传输url值，具体用法将会在下一节“内置对象request”中介绍到。
二，再来看Input相关Input表示Form表单中的一种输入对象，其又随Type类型的不同而分文本输入框，密码输入框，单选/复选框，提交/重置按钮等，下面一一介绍。
1，type=text输入类型是text，这是我们见的最多也是使用最多的，比如登陆输入用户名，注册输入电话号码，电子邮件，家庭住址等等。当然这也是Input的默认类型。
参数name：同样是表示的该文本输入框名称。参数size：输入框的长度大小。参数maxlength：输入框中允许输入字符的最大数。参数value：输入框中的默认值特殊参数readonly：表示该框中只能显示，不能添加修改。

2，type=password不用我说，一看就明白的密码输入框，最大的区别就是当在此输入框输入信息时显示为保密字符。
参数和“type=text”相类似。

3，type=file当你在BBS上传图片，在EMAIL中上传附件时一定少不了的东西：）
提供了一个文件目录输入的平台，参数有name，size。

4，type=hidden非常值得注意的一个，通常称为隐藏域：如果一个非常重要的信息需要被提交到下一页，但又不能或者无法明示的时候。一句话，你在页面中是看不到hidden在哪里。最有用的是hidden的值。

5，type=button标准的一windows风格的按钮，当然要让按钮跳转到某个页面上还需要加入写JavaScript代码

6，type=checkbox多选框，常见于注册时选择爱好、性格、等信息。参数有name,value及特别参数checked（表示默认选择）其实最重要的还是value值，提交到处理页的也就是value。（附：name值可以不一样，但不推荐。）
<form name="form1">
a:<input type="checkbox" name="checkit" value="a" checked><br>
b:<input type="checkbox" name="checkit" value="b"><br>
c:<input type="checkbox" name="checkit" value="c"><br></form>
name值可以不一样，但不推荐<br>
<form name="form1">
a:<input type="checkbox" name="checkit1" value="a" checked><br>
b:<input type="checkbox" name="checkit2" value="b"><br>
c:<input type="checkbox" name="checkit3" value="c"><br>  </form>
7，type=radio即单选框，出现在多选一的页面设定中。参数同样有name,value及特别参数checked.
不同于checkbox的是，name值一定要相同，否则就不能多选一。当然提交到处理页的也还是value值。

8，type=image比较另类的一个，自己看看效果吧，可以作为提交式图片

9，type=submit and type=reset分别是“提交”和“重置”两按钮
submit主要功能是将Form中所有内容进行提交action页处理，reset则起个快速清空所有填写内容的功能。

Input的Type总结下来有10个，还是不少的，呵呵
三，接着再来看Select相关Select主要要来做下拉菜单，跳转菜单，（下拉）列表。
其本身有内嵌代码<option>...</option>，option参数value值为传递被处理的值，option还有参数selected，表示默认被选中。
1，下拉菜单只是菜单式显示。

2，跳转菜单在下拉菜单基础上添加JavaScript成为跳转菜单。

[3，下拉列表和下拉菜单最大的区别就是select多了一个size值，该值并非长度大小，而是列表的上下高度。
当然还有更主要的是：菜单只能选一个，而列表可以选多个，该特殊参数为multiple

四，最后关注的Textarea可以将Textarea文本区域理解为扩大化了的文本输入框。其参数没有value，默认值设定在<textarea>...</textarea>之间。其它参数还有rows,表示文本区域的行数；参数cols，表示文本区域的列数。
还有参数warp，当warp=off表示该文本区域中的不自动换行，当然不写默认是自动换行的。

最后总结：input根据type分10类，select从option处又分菜单和列表，textarea有行有列的文本输入区域
ASP编程入门进阶（三）：接触脚本程序 
有了前面的html中关于form的强化知识，是不是在想，下面就可以开始ASP之旅呢？未必。
一般系统学过ASP的编程人员都会切身体会到：在系统学习ASP的内置对象和内置组件之前，学会脚本语言是至关重要的。
为什么这么说呢？为什么要学脚本语言呢？ASP和脚本语言又有什么关系呢？
首先说说ASP是贵为何物吧。ASP是Microsoft Active Server Pages的简称，它是一种服务器端脚本环境，可用来创建交互式 Web 页并建立强大的 Web 应用程序。可以表明ASP是一种基于服务器端的脚本环境，那就明白ASP为什么需要IIS支持了，因为IIS即为常用的一类web服务器；那也就明白为什么要学脚本语言了，因为ASP提供的是一种脚本环境。
　再次需要说明的是，ASP只是一种环境，而非一种语言。如果真要形象化地说是ASP是网络编程语言的话，那也是属于一个html+脚本+asp提供的内置对象及组件的功能强大的混合语言。
所以，学点脚本非常重要！其实无论是学脚本语言，还是其它语言，我认为首先需要了解的是该语言涵盖的各类特性，包括：数据类型、事件、方法、 对象、属性、语法等当然这都是些空谈，正如在大学课堂上的某计算机语言课一样，搞纯研究性的就是觉得有些索而无味。还是实用些的好，能解决问题的程序才是好程序。当然，语言这东西还是要你去好好钻研的，比如你写求绝对值的程序，其实一个abs()函数就搞定了。你以后需要注意的是语言的函数、语法
目前有两种主要的脚本语言：VbScript和JavaScript。因为VbScript作为IIS默认的服务器脚本，所以我们所谈所学的基本是围绕VbScript为脚本的ASP的，当然也不排除有的时候使用javascript.
举一个很简单的例子：
<script language="vbscript">　<!--  sub button1_onclick
      msgbox (" 欢迎使用vbscript! " )　  end sub  -->　</script>
<script language="javascript">　<!--    function b213()
    {      alert("欢迎使用javascript!")     }     --></script>  <form>
<input type="button" name="button1" value="vbs"><br>
<input type="button" name="button2" value="js" οnclick="b213()">　</form>
vbscript中的Sub 就是一个事件过程。过程名包含两部分：一部分为按钮名，即 Button1（从 < INPUT > 标记中的 NAME 属性获取）；另一部分为事件名，即 OnClick。两部分由下划线 (_) 连接。单击按钮时，Internet Explorer 查找并运行相应的事件过程，即 Button1_OnClick，而MsgBox 就是一个函数，对于它更具体的参数，你就好好看下了。
一时来劲，可能大家都看到网上有种狂恶心的对话框组，原理是什么呢？请看：
在来个下面来看开页和退页弹出对话框的原理吧
script language="vbscript">　<!--　sub window_onload()
msgbox"welcome you!"
end sub　sub window_onunload()
msgbox"see you late!"　　end sub　-->　</script>
开页显示“welcome you!”，关页显示“see you late！”
以上只是一个显示对话框msgbox，当然还有书写对话框inputbox也顺便看下吧。

再来看看几个实用的函数：len()：返回字符串长度或者变量的字节长度　
lef()：截取一个字符串的前部分内容　　　right()：截取一个字符串的后部分内容
<script language=vbs>
text="1234567890abcdefgh"　i=10
lentext=len(text)　lefttext=left(text,i)　righttext=right(text,i)
alert ("文本长度是："&lentext)　alert ("文本左取"&i&" 得的是："&lefttext)　alert ("文本右取"&i&" 得的是："&righttext)  </script>
根据这几个，经常看到的长文章后面加“......”的情况就是如下：

还有个比较重要的函数replace()　在字符串中查找，替代指定的字符串replace(strtobesearched,strsearchfor,strreplacewith)
strtobesearched是字符串;　strsearchfor是被查找的子字符串;strreplacewith　是用来替代的子字符串。
下面的一个就是很有用的文字转换程序

这些都是比较现实较好玩的些，玩中学习也不错：）但毕竟我们是要编程的，说到编写程序，我知道程序结构可以分：
1，顺序结构：就是最普通的，从上往下，从左往右执行的程序
2，选择结构：给你两个条件，要不这样（if ... then），要不那样(else)，任君选择：）
3，循环结构：给你一个最大发挥的空间，在不超出这个范围内进行活动（循环），否则自动退出（跳出循环）。
再复杂的程序也无非是由这三种结构综合嵌套运用过来的，你说是吧。
顺序结构没多少要说，因为程序执行基本都是这方向。
来看看选择结构，当然选择结构也可以嵌套。
<body>  hello　<script language="vbscript">　<!--dim thishour
thishour=hour(time)
if thishour<=12 then
  document.bgcolor="red"
  document.fgcolor="black"
  document.write("上午好！")
else  if thishour<=18 then
    document.bgcolor="blue"
    document.fgcolor="white"
    document.write("下午好！") 
  else    document.bgcolor="green"
    document.fgcolor="yellow"
    document.write("晚上好！") 　  end if 　end if   -->　</script>
本页的作用是根据不同时间显示不同颜色和欢迎信息。
以上程序很简单吧，只要能认识英文就会懂程序（我是这么理解的：）先把现在的小时提交出来：hour(time)；
然后和12比较判断，如果<=12，肯定是上午了，否则就是下午和晚上；否则里面继续条件判断，如果时间再<=18的话，那肯定就是下午了；最后，不用说，瞎子猜猜也知道是晚上了。有关上一程序中的document.bgcolor就是文档的背景色,document.fgcolor就是文档的前景色（文字色），下一程序是动态改变背景颜色的。<script language="vbscript"><!--
sub setbgcolor(bcolor)　     document.bgcolor=bcolor
end sub　--> </script> <form>
<input type="radio" name="color" οnclick=setbgcolor("red")>red<br>
<input type="radio" name="color" οnclick=setbgcolor("gray")>gray<br>　</form>
有关条件选择结构的嵌套再show出一个表单检测的程序
<html><head><title>abc</title>
<script language="vbscript">
<!--　sub btnsubmit_onclick
   if form1.name.value<>"" then
    if form1.addr.value<>"" then
     if form1.email.value<>"" then     
       if instr(form1.email.value,"@")<>0 and instr(form1.email.value,".")<>0 then
         form1.submit       else
         alert"email error!"
       end if      else        alert "enter your email!"
        form1.elements("email").focus    
      end if    else      alert "enter your address!"
      form1.elements("addr").focus      
    end if   else    msgbox "enter your name please!"
    form1.elements("name").focus
   end ifend sub　--></script>  </head>  <body>
<form name="form1" method=post action="bug.html">
your name:<input type="text" name="name"><br>
your addr:<input type="text" name="addr"><br>
your email:<input type="text" name="email"><br>
<input type="button" name="btnsubmit" value="submit"></form>　</body>　</html>
程序是给出来了，但看起来比较难懂，有时程序执行时间也比较重要，所以得精简程序代码。正所谓：写程序容易，写经典程序难啊，那上面的程序还可以换种思维方式。改用javascript(注：学的是编程思想，不要太过计较脚本类型)
<html><head><title>abc</title><script language="javascript"><!--　function form1_onsubmit()
{　if (document.form1.name.value=="")
       {         alert("请设定您的登陆名。")
         document.form1.name.focus()
         return false        }　　else if(document.form1.addr.value=="")
       {          alert("请填写您的地址。")
         document.form1.addr.focus()　         return false        }　}　-->　</script>　</head>　<body>
<form name="form1" οnsubmit="return form1_onsubmit()">
your name:<input type="text" name="name">　<br>　your addr:<input type="text" name="addr"><br>
<input type="submit" name="submit" value="submit">　</form>　</body>　html>
最后来看下循环结构吧：1到500可不是一个一个写出来的。

当然循环不只可以用for，还可以用do while...loop等。反正程序这东西是代替我们少做了许多重复单一无聊的事——只要你合理利用程序。应该有些成就吧，学语言，学编程就是学语法语义，学编程架构思想。当然这要你有扎实的本语言的基础，基础是什么？你知道哪些函数吗？你知道怎么用程序怎么判断偶数吗（包含了运算）？你知道如何进行表单检测吗？你知道哪三种程序架构吗？呵呵，把以上的程序吃透，最好再多看看脚本参考手册，跟我就可以开始ASP的上路了。
ASP基本语法 
建立ASP程序 　　ASP程序是扩展名为.asp的文本文件，其中包括文字，HTML语句，ASP命令及其他脚本语言。　　ASP命令必须放在"＜%"与"%＞"之间。
程序注释 为了养成良好的编程风格外，适度的注释不可少，ASP提供了两中注释方式1、单引号()，在单引号之后的这行文字都视为注释　2、rem 关键词，在REM后的文字，视为注释
赋值语句　　ASP中一般变量的赋值语句是 "="，　　而对象是用 set 语句来赋值。
条件语句和循环语句
了解编程语言的朋友一定知道在程序中控制程序流程的语句主要可以分为条件语句和循环语句，在 VBScript 中可使用以下条件语句： 　 　If...Then...Else 语句　和　Select Case 语句
　 　If...Then...Else 语句用于计算条件是否为 True 或 False，并且根据计算结果指定要运行的语句。通常，条件是使用比较运算符对值或变量进行比较的表达式，If...Then...Else 语句可以按照需要进行嵌套。 
　　 让我们来创建两个范例文件：if1.asp 和 if2.asp 
　　 将以下语句剪贴到记事簿中，并保存为 if1.asp( 注意：请将程序中“<”后的空格去掉 ) 　
　< html>　　< head>　　< TITLE>if1.asp< /TITLE>　　< /head>< body bgcolor="#FFFFFF">
　　< form action="if2.asp" method=get>
　　Your First Name< INPUT NAME="FirstName" MaxLength=20>< p>
　　Your Last Name< INPUT NAME="LastName" MaxLength=20>< p>
　　< INPUT TYPE=submit>< INPUT TYPE=reset>　　< /form>　　< /body>　　< /html>
　　将以下语句剪贴到记事簿中，并保存为 if2.asp 　　< html>　　< head>　　< TITLE>ifrespond.asp< /TITLE>　　< /head>　　< % fname=request.querystring("Firstname")
　　lname=request.querystring("Lastname")
　　If fname="George" and lname="Washington" then %>
　　Hi.You must be the first president!
　　< % else %>　　Hi!Nice to Meet You　　< %end if %>　　< /body>　　< /html>
　 　asp1.asp 产生一个文本输入框，要求用户输入姓、名 
　 　asp2.asp 则是用 IF 语句判断用户输入的姓名是否为“George Washington”, 并做出相应的反馈。在此我们遇到了一个 ASP 的内建对象 request，通过使用 request 对象可以访问任何用 HTTP 请求传递的信息，包括从 HTML 表格中用 POST 方法或 GET 方法传递的参数、cookie 和用户认证。而 QueryString 集合检索 HTTP 查询字符串中变量的值，HTTP 查询字符串由问号 (?) 后的值指定。如： 　 　http://localhost/if2.asp?Firstname=George&Lastname=Washington 
　　 生成值为 "Firstname=George&Lastname=Washington" 的变量名字符串。
　　 If...Then...Else 语句的一种变形允许您从多个条件中选择，即添加 ElseIf 子句以扩充 If...Then...Else 语句的功能，使您可以控制基于多种可能的程序流程。 　　 我们将 asp2.asp 的程序部分扩充如下：　
< %　　fname=lcase(request.querystring("Firstname"))
　　lname=lcase(request.querystring("Lastname"))
　　If fname="george" and lname="washington" then %>
　　Hi.You must be the first president!< p>
　　< % elseIf fname="ronald" and lname="reagan" then %>
　　Hi.You must be the actor president!< p>
　　< % elseIf fname="jimmy" and lname="carter" then %>
　　Hi.You must be the peanut farmer president!< p>
　　< % elseIf fname="naoko" or fname="charles" then %>
　　Hi.Your name reminds me of someone,but I am not sure who!< p>
　　< % else %>　　Hi!Nice to Meet You　　< % end if %>
　 　可以添加任意多个 ElseIf 子句以提供多种选择。但使用多个 ElseIf 子句经常会使程序变得很累赘。在多个条件中进行选择的更好方法是使用 Select Case 语句。 
　 　Select Case 结构提供了 If...Then...ElseIf 结构的一个变通形式，可以从多个语句块中选择执行其中的一个。Select Case 语句提供的功能与 If...Then...Else 语句类似，但是可以使代码更加简练易读。Select Case 结构在其开始处使用一个只计算一次的简单测试表达式。表达式的结果将与结构中每个 Case 的值比较。如果匹配，则执行与该 Case 关联的语句块，我们同样可以用 Select Case 语句来写 asp2.asp 文件：
　　< %　　fname=lcase(request.querystring("Firstname"))
　　lname=lcase(request.querystring("Lastname"))
　　name=fname+lname
　　Select case name
　　case "georgewashington"
　　response.write "Hi.You must be the first president!< p>"
　　case "ronaldreagan"
　　response.write "Hi.You must be the actor president!< p>"
　　case "jimmycarter"
　　response.write "Hi.You must be the peanut farmer president!< p>"
　　case "naokocharles"
　　response.write "Hi.Your name reminds me of someone,but I am not sure who!< p>"
　　case else　　response.write "Hi!Nice to Meet You"　　　End Select %>
请注意 Select Case 结构只计算开始处的一个表达式，且只计算一次，而 If...Then...ElseIf 结构计算每个ElseIf 语句的表达式，这些表达式可各不相同。因此仅当每个ElseIf 语句计算的表达式都相同时，才以使用 Select Case代替 If...Then...ElseIf 结构。Select Case 语句也是可以是嵌套的，每一层嵌套的Select Case语句必须有与之匹配的End Select 语句。
（四）内置对象Request  系统学习ASP，就是先从ASP的几大内置对象开始的.asp一般称有五大对象：Request、Response、Server、Session、Application
当然一直还没有提到的就是，ASP到底是什么样？我看代码怎么知道是ASP代码？很简单，当看到“<%”和“%>”就表明是ASP，并且两者之间的就是ASP源码。那为什么要学对象，对象的作用又是如何的？其实ASP所提供的这些可在脚本中使用的内建对象，使用户更容易收集通过浏览器请求发送的信息、响应浏览器以及存储用户信息，从而使对象开发者摆脱了很多烦琐的工作。而Request对象的主要作用就是：在服务器端接受并得到从客户端浏览器提交或上传的信息。Request 对象可以访问任何基于 HTTP 请求传递的所有信息，包括从Form表单用 POST方法或 GET 方法传递的参数、cookie 等。
一、Request.form("name") 这是接受上一页的信息时，常会用到的一种接受方式。Request是ASP对象，form则是Request对象所包含的对象集合（这与HTML页中的form表单不一样的），name也就是上一页表单中的某个文本框、密码框，或者隐藏域等的名称。并且还有一点非常重要：上一页Form表单的递交方法一定要为Post方法。看下面两个程序。
1，test1.html（本页是HTML的，主要提供输入信息的平台，将信息提交到ASP页进行受处理）
<form action="submit1.asp" method="post">
your name:<input tpye="text"  name="yourname"><br>
your pwd: <input type="password" name="yourpwd"><br>
<input type="submit" value="submit"></form>
注意method就是post，且提交的页面action为submit1.asp。
2，submit1.asp（ASP页面，进行从test1.html接受name="yourname"和name="yourpwd"的两个值）
your name is:<%=request.form("yourname")%><br>
your pwd is:<%=request.form("yourpwd")%>
通过IIS进行HTTP协议的页面调试，你会发现两个页面进行了关联：test1.html中动态输入的name和pwd，在submit1.asp页进行相应动态显示。这就是接收提取并显示信息的过程。
3，改进的submit1.asp
<% for each i in request.form%>　<%=i%>:　<%=request.form(i)%>　<br>　<%next%>
采用了for循环语句，将上页所有的form标签信息进行接受、并显示。这在上表单页有很多项目时，非常快捷地出来结果。
　　request.form后面的("yourname")或("yourpwd")变成了变量 i，通过for循环对该form集合进行遍历提取，这是一种不同于机械地“有几个就提取几个”的编程思想，注意掌握。
二，Request.querystring("name")
此时由Request.form变为Request.querystring，最主要的还是上页表单递交时，采用的什么方法。当采用post就用Request.form，否则当采用get时就采用Request.querystring了。
那Request.querystring最大特色在哪里呢？Request.querystring能检索并接受 HTTP 查询字符串中变量的值，而HTTP 查询字符串则是由问号 (?) 后的值指定的。继续看一个程序。
1、test2.html（本页同是HTML的，主要提供输入信息的，将信息提交到ASP页进行处理，提交方法是get）

与test1.html最大区别也就是method="get"。
2、submit2.asp（ASP页面，从test1.html接受name="yourname"和name="yourpwd"两个值）
your name is:<%=request.querystring("yourname")%><br>
your pwd is:<%=request.querystring("yourpwd")%>
注意此时的浏览器地址栏，文件后面多出了？号，？号后面附有变量名及所被赋的值，当然多个变量名之间是用&号进行连接的。而Request.querystring最大的功能就是能将？号后面的这些变量名分开，并且所对应的值也一一取出。
刚才说到不同的变量名之间是用&号进行连接，但如果是相同的变量名时，request.querystring到底是提取前一个？后一个？还是两个一起？用例子说话。
3、query.asp（名称是query.asp，因为在该页程序中是反馈给自己。）
<a href="query.asp?bookname=《asp教程》">《asp教程》</a><br>
<a href="query.asp?bookname=《jsp教程》">《jsp教程》</a><br>
<a href="query.asp?bookname=《xsp教程》&bookname=《xml》">《xsp教程》</a><br>
you chosed <%=request.querystring("bookname")%>
很明显当点《xsp教程》时，显示的是“《xsp教程》,《xml》”，中间自动加了“，”号。
最后仍需要说明的是：request.querystring在分页程序里面是经常用到的。
三、Request.ServerVariables("xxx")即服务器的环境变量，该变量包含的内容比较多，我们同样先采用for循环进行遍历查看。1、server1.asp　<%for each i in request.servervariables%> 
<%=i%>:　<%=request.servervariables(i)%>　<hr> 　<%Next%>
可以看到一大堆环境变量，其中还有没有值的，下面摘取几个比较常用的。
http_user_agent(客户端机器的相关环境)：<%=request.servervariables("http_user_agent")%><br>
http_accept_language(浏览语言)：<%=request.servervariables("http_accept_language")%><br>
CONTENT_LENGTH(客户端发出内容的长度)：<%=request.servervariables("CONTENT_LENGTH")%><br>
CONTENT_TYPE(内容的数据类型。如“text/html”。同附加信息 的查询一起使用，如 HTTP 查询 GET、POST 和 PUT)：<%=request.servervariables("CONTENT_TYPE")%><br>
LOCAL_ADDR(返回接受请求的服务器地址。如果在绑定多个IP地址的多宿主机器上查找请求所使用的地址时，这条变量非常重要)：<%=request.servervariables("LOCAL_ADDR")%><br>
REMOTE_ADDR(发出请求的远程主机client的 IP 地址)：<%=request.servervariables("REMOTE_ADDR")%><br>
SERVER_NAME(出现在自引用 URL 中的服务器主机名、DNS 化名 或 IP 地址)：<%=request.servervariables("SERVER_NAME")%><br>
SCRIPT_NAME(主机名后面的虚拟地址)：<%=request.servervariables("SCRIPT_NAME")%><br>
LOGON_USER(用户登录 Windows NT 的帐号)：<%=request.servervariables("LOGON_USER")%><br>
SERVER_PORT(发送请求的端口号)：<%=request.servervariables("SERVER_PORT")%>
根据以上的SERVER_NAME是提取的服务器主机名，SCRIPT_NAME是提取的虚拟地址，则两者的结合再加上http:// 是不是就是个完整的网址呢。
2、server2.asp　<%a=request.servervariables("server_name")%>
<%b=request.servervariables("script_name")%>　<%="http://"&a&b%>
其中http:// 用引号引起，表示是字符串，a和b分别是对应了具体值的变量，在ASP中进行这样的连接就是采用&号。
根据这个结果，我们是不是就可以随时提取动态的URL地址了。再来看看query.asp，要求一定要保存为query.asp的，因为如果不是该文件名，程序指向就会出错。但现在的这个文件就随便你保存为什么文件，都一样执行。
3、xxx.asp（随便你保存成什么文件）
<%filepath=request.servervariables("script_name")%>
<a href="<%=filepath%>?bookname=《asp教程》">《asp教程》</a><br>
<a href="<%=filepath%>?bookname=《jsp教程》">《jsp教程》</a><br>
<a href="<%=filepath%>?bookname=《xsp教程》&bookname=《xml》">《xsp教程》</a><br>
you chosed <%=request.querystring("bookname")%>
先将当前文件的地址取出并赋值给变量filepath，然后所有的链接地址开头都只要直接引用该变量就OK了。是不是很有用，有点万能的感觉。
四、Request.Cookies("name")不用我说，Cookie是个很重要的东西，究竟如何，等我们学完了下面的对象Response后，会有个特别Cookie的专题讲座。
　　以上四则运用，属于Request对象的所包含的四个对象集合：form、querystring、servervarivables、cookies。当然还有个ClientCertificate就不说啦一个ASP内置对象除了对象集合外还有对象属性、对象方法
Request对象的对象属性只有一个就是TotalBytes（接受的字节数），你可将<%=request.totalbytes%>该语句加入到任何一个接受数据的ASP页面中进行显示了。
Request对象的对象方法也还是一个：BinaryRead 。
   说实话，这东东不常用，我也没用过，呵呵。OK~！有关Request对象的学习就差不多了，最主要是先好好理解三个对象集合，cookies不着急，下节继续学习对象Response。
ASP编程入门进阶（五）：内置对象Response 
通过对Request对象的学习，可以了解到，Request对象是服务器端用来获取客户端的信息的。但作为服务器和客户端进行交互，是不是还缺少服务器端向客户端发送信息呢？对象Response正是担任此责任。负责将信息传递给用户的对象就是Response了，它可动态地响应客户端的请求，并将动态生成的响应结果返回给客户端浏览器。
一、Response.write  write方法是使用最频繁的一个了，write就是写：将指定的字符串写到当前 HTTP 输出。
1、write.asp　<%　response.write ("hello,world"&"<br>")
Randomize　　response.write "任意数是"&rnd()&"<br>"　%>
response.write后面为所显示的信息，可以用括号包含，也可以直接书写（注意和response.write之间有空格）。
    书写的字符串信息或者HTML代码相关，用引号包含；而ASP本身的函数或变量则不需要，直接用即可。并且无论字符串信息、HTML代码、函数还是变量之间进行连接都是采用&号（针对vbscript）
    以上遇到一个随机函数rnd()，该函数返回一个小于 1 但大于或等于 0 的值。
需要注意的是在调用 Rnd 之前，先使用无参数的 Randomize 语句初始化随机数生成器，该生成器具有基于系统计时器的种子。若缺少Randomize，则无法继续生成随机种子。下面一个利用随机函数的例子，产生随机背景颜色效果：

当然要产生指定范围的随机整数，请使用以下公式： 
Int((upperbound - lowerbound + 1) * Rnd + lowerbound)
这里， upperbound 是此范围的上界，而 lowerbound 是此范围内的下界。

随机函数在做考试系统的时候非常有用，当然你也可以用来自己摇奖，拿个头彩也分点我就行了
二、Response.end这是Response常用的一种方法，使 Web 服务器停止处理脚本并返回当前结果，文件中剩余的内容将不被处理。主要放在一页多功能的ASP页中，为让程序运行到此，抑或往下的程序没必要再执行显示……
2、end.asp　<%response.write now()
response.end            '程序执行显示到此结束　response.write rnd()　%>
三、Response.clear
该方法主要作用是清除缓冲区中的所有 HTML 输出，但该方法只清除响应正文而不清除响应标题。该方法和end方法似相反，end是到此结束返回上面的结果，而clear却是清除上面的执行，然后只返回下面的结果。
3、clear.asp　<%response.write now()
response.clear           '以上程序到此全被清除　response.write rnd()%>
下面通过一个例子来仔细看看end and clear
4、end2clear.asp　<%　filepath=request.servervariables("script_name")
user=Request.Form("username")
pwd=Request.Form("password")　%>
<form method="POST" action="<%=filepath%>">
name:<input type="text" name="username"><br>
pwd:<input type="password" name="password"><br>
<input type="submit" value="submit">
</form>　<%　If user="cnbruce" and pwd="cnbruce" Then    
   response.write "采用clear方法，上面的程序结果将清除。"
   response.clear     ' 清空存储在缓存中的页面
Else　   response.write "采用end方法，下面的程序将停运。"
   Response.End ' 立即停止脚本处理，并将缓存中的页面输出  End If　%>
如果你只看到“刷新”链接就表明clear方法已经生效<br>
<a href="<%=filepath%>">刷新</a>　
以上程序中，当输入用户名和密码同为cnbruce的时候会发现clear方法的处理结果，反之是另外一个效果。
四、Response.redirect方法是让浏览器立即重定向到程序指定的URL地址。这在根据客户的不同响应，为不同的客户指定不同的页面，或根据不同的情况指定不同的页面时，显得非常重要。该方法是立即生效的，在其后的脚本都不执行。
5、redirect.asp　<%response.redirect("http://www.cnbruce.com/")%>
以上四则运用属于Response对象的几个比较重要的方法：write、end、clear、redirect当然方法还有：AddHeader、AppendToLog、BinaryWrite、Flush……
早说过，一个ASP对象除了对象方法外，还有对象属性，那response对象的属性有哪些呢？
五、Response.ContentType　ContentType 属性指定服务器响应的 HTTP 内容类型。如果未指定 ContentType，默认为 text/html。
6、contenttype.asp（非text/html的）
<% Response.ContentType = "text/HTML" %>
<% Response.ContentType = "image/GIF" %>
<% Response.ContentType = "image/JPEG" %>
<% Response.ContentType = "text/plain" %>
<% Response.ContentType = "image/JPEG" %>
六、Response.charsetCharset 属性将字符集名称附加到 Response 对象中 content-type 标题的后面，用来设置服务器响应给客户端的文件字符编码。
7、charset.asp　<% Response.charset = "big5" %>
中文显示，但采用的big5繁体的编码，所以看到的是乱码。当然Response.ContentType和Response.charset应用得比较少了。直接在head头部属性里面添加就OK了。
七、Response.expires　该属性指定了在浏览器上缓冲存储的页，距过期还有多少时间。如果用户在某个页过期之前又回到此页，就会显示缓冲区中的页面。但若设置 response.expires=0，则可使缓存的页面立即过期。这是一个较实用的属性，当客户通过 ASP 的登陆页面进入WEB 站点后，应该利用该属性使登陆页面立即过期，以确保安全。引用一个经典的例子
例8、expires.asp　<%
Response.Expires = 0 
Response.Expiresabsolute = Now() - 1 
Response.AddHeader "pragma","no-cache" 
Response.AddHeader "cache-control","private" 
Response.CacheControl = "no-cache" 　%> 
八，Response.status设置服务器要响应的状态行的值。Response.status="状态描述字符串"，字符串可以为一个三位整数或一串说明文字组成，但必须放在<html>之前。
例9 、status.asp　<% Response.Status = "401 Unauthorized" %>
九，Response.buffer　比较重要的一个，值为true or false。该属性指示是否缓冲页输出。
引用：当缓冲页输出时，只有当前页的所有服务器脚本处理完毕或者调用了 Flush 或 End 方法后，服务器才将响应发送给客户端浏览器，服务器将输出发送给客户端浏览器后就不能再设置 Buffer 属性。因此应该在 .asp 文件的第一行调用 Response.Buffer。　Response.buffer=true。
对于Response对象的属性和方法先到这里，剩下一个数据集合，即cookie。继续看cookies讲座吧。
ASP编程入门进阶（六）：Cookies讲座 
什么是 Cookie？Cookie其实是一个标签，经常可能听到的中文翻译：小舔饼。当你访问一个需要唯一标识你的站址的 WEB 站点时，它会在你的硬盘上留下一个标记，下一次你访问同一个站点时，站点的页面会查找这个标记。
  　每个 WEB 站点都有自己的标记，标记的内容可以随时读取，但只能由该站点的页面完成。每个站点的Cookie与其他所有站点的Cookie存在同一文件夹中的不同文件内（你可以在 win2k  Documents and Settings 文件夹下特定用户的 cookies 文件夹中）。
　　一个 Cookie 就是一个唯一标识客户的标记，Cookie 可以包含在一个对话期或几个对话期之间某个 WEB 站点的所有页面共享的信息，使用 Cookie 还可以在页面之间交换信息。这项功能经常被使用在要求认证客户密码以及电子公告板、WEB 聊天室等 ASP 程序中。
　　尽管现在听起来cookie没有什么激动人心的，但实际上利用它，你能实现许多有意义的功能！比如说：你可以在站点上放置一个调查问答表，询问访问者最喜欢的颜色和字体，然后根据这些定制用户的web界面。并且，你还可以保存访问者的登录密码，这样，当访问者再次访问这个站点时，不用再输入密码进行登录。 
　　当然，cookie也有一些不足。首先，由于利用cookie的功能可以编程实现一些不良企图，所以大多数的浏览器中都有安全设定，其中可以设置是否允许或者接受cookie（IE浏览器中“工具”--“Internet选项...”--“安全”--“自定义级别”--“Cookie的使用”；Netscape浏览器中“工具”--“Cookie管理器”--“管理贮存的Cookie”即可），因此这就不能保证随时能使用cookie。再者，访问者可能有意或者无意地删除cookie。当访问者的机器遇到“蓝屏”死机时，或者重新格式化硬盘、安装系统后，原来保存的cookie将全部丢失。最后一点，有一些最初始的浏览器并不能支持cookie。 
◆ 怎样利用cooklie？ 有2种使用cookie的基本方式：
1、将cookie写入访问者的计算机（使用 Response 命令）
2、从访问者的计算机中取回cookie（使用 Request 命令）
◆ 创建cookie的基本语法: Response.Cookies(cookie)[(key)|.attribute]=value
这里的 cookie 是指定 cookie 的名称。而如果指定了 key，则该 cookie 就是一个字典。（测试一cookie是否为一个字典可用后面代码显示布尔值：<%=Request.Cookies("cookiename").HasKeys%>。为true是字典，false则不是。 ）
Attribute 指定 cookie 自身的有关信息。Attribute 参数可以是下列之一 : 
①Domain 若被指定，则 cookie 将被发送到对该域的请求中去。域属性表明cookie由哪个网站产生或者读取，默认情况下，cookie的域属性设置为产生它的网站，但你也可以根据需要改变它。（Response.Cookies("CookieName").Domain = "www.mydomain.com"）
②Path 为路径属性，该属性可以实现更多的安全要求，通过设置网站上精确的路径，就能限制cookie的使用范围。如果未设置该属性，则使用应用程序的路径。（Response.Cookies("CookieName").Path = "/maindir/subdir/path" ）
③Expires 指定 cookie 的过期日期。为了在会话结束后将 cookie 存储在客户端磁盘上，或在许多时候，我们希望能更长时间地在访问者的计算机上保存cookie。必须设置该日期。若此项属性的设置未超过当前日期，则在任务结束后 cookie 将到期。后面的代码，就可以设置cookie的使用到期时间为“2010年1月1日”： Response.Cookies("CookieName").Expires=#January 01, 2010#
后面的代码，将设定cookie的过期时间为“cookie的创建时间＋365天”：Response.Cookies("CookieName").Expires=Date+365
但最好不要随便写 Response.Cookies("CookieName").Expires=Date，这样页面之间的调用时值会为空。执行下面的代码将会在访问者的计算机中创建一个cookie，名字＝VisitorName，值＝Ken ：　Response.Cookies("VisitorName")="Ken"
　　执行下面的代码将会在访问者的计算机中创建一个cookie，名字＝VisitorName，值＝表单中UserName的值
Response.Cookies("VisitorName")=Request.Form("UserName")
你可以扩展下面的代码成为Cookie子关键值（CookieSubName），即cookie字典的生成。代码如下：
Response.Cookies("VisitorName")("FirstName")="Ken" 
Response.Cookies("VisitorName")("LastName")="Baumbach" 
◆ 读取cookie的基本语法：Request.Cookies(cookie)[(key)|.attribute]
cookie 指定要检索其值的 cookie。 
key 可选参数，用于从 cookie 字典中检索子关键字的值。 
attribe 指定 cookie 自身的有关信息。如：HasKeys 只读，指定 cookie 是否包含关键字。
如果客户端浏览器发送了两个同名的 cookie,那么 Request.Cookie 将返回其中路径结构较深的一个。例如，如果有两个同名的的 cookie，但其中一个的路径属性为 /www/ 而另一个为 /www/home/，客户端浏览器同时将两个 cookie 都发送到 /www/home/ 目录中，那么 Request.Cookie 将只返回第二个 cookie。案例分析：
◆ num.asp（通过留在本地磁盘上的cookie记录一年内访问本站的次数，第一次显示“首次访问”，以后显示“第几次访问”）
<%　dim num　num=request.cookies("visitnum")
if num > "0" then
num=num+1
Response.write "您已是第"&num&"次访问本站点了。"
Else　Response.write "欢迎您首次访问本站。"
num=1　end if
response.cookies("visitnum")=num
response.cookies("visitnum").expires=date+365　%> 
◆ showcookie.asp（从Cookies文件夹中遍历出浏览器所有的Cookie name，以及相关的字典Cookie的显示（蓝字显示））  <%　For each cookie in Request.Cookies
if Request.cookies(cookie).HasKeys =false then
Response.write cookie & "=" & Request.Cookies(cookie)
Response.write ("<br>") 　Else
for each key in Request.Cookies(cookie)
Response.write ("<font color=blue>")
Response.write cookie & ".("&key&")" & "=" & Request.Cookies(cookie)(key)
Response.write ("</font><br>") Next　end if　next　　%> 
◆ check.asp　'首先，设置页面。然后，检查表单变量（在同一个页面中）。如果表单变量存在，就创建cookie，并设置到期时间。<%@ LANGUAGE="VBSCRIPT" %>　<% 
bgcolor = Request.Form("bgcolor")
fgcolor = Request.Form("fgcolor")
pwd = Request.form("pwd")
If bgcolor <>"" or fgcolor <>"" then
Response.cookies("check")("bgcolor") = bgcolor
Response.Cookies("check")("fgcolor") = fgcolor
Response.Cookies("check")("pwd") = pwd
Response.Cookies("check").Expires=#may 01, 2004#  End if '接着，读取cookie
bgcolor = request.cookies("check")("bgcolor")
fgcolor = request.cookies("check")("fgcolor")
pwd = request.cookies("check")("pwd")
'如果cookie在访问者的计算机上不存在，就创建一个表单，询问相关信息
If bgcolor ="" and fgcolor ="" and pwd="" then　　%>
<HTML> <HEAD> </HEAD><body><DIV ALIGN="CENTER" >
<Form action="check.asp" method="POST">
Bgcolor: <input type="text" name="bgcolor"><BR>
Fgcolor: <input type="text" name="fgcolor"><BR>
Password:<input type="password" name="pwd"><BR>
    <input type="submit" value="Submit"> </Form></DIV></BODY><%　End if
'如果cookie已经存在，并且bgcolor存在，就跳转到color.asp。 
If bgcolor <> "" then  Response.Redirect "color.asp"　　End if　　%>
◆ color.asp（显示用户爱好颜色的页面特性）
<%　bgcolor=request.cookies("check")("bgcolor")
fgcolor=request.cookies("check")("fgcolor")
pwd=request.cookies("check")("pwd")　%>
<%response.write("<body bgcolor="&bgcolor&"><font color="&fgcolor&">")%>
你的密码是：　<%response.write(" "&pwd&" ")%>
ASP编程入门进阶（七）：内置对象Server 
Server 对象提供对服务器上的方法和属性的访问 , 其大多数方法和属性作为实用程序的功能服务（IIS HELP翻译）。
有了 Server 对象，你就可以在服务器上启动 ActiveX 对象例程，并使用 Active Server 服务提供象 HTML 和 URL 编码这样的函数。
一、Script.ScriptTimeout在脚本运行超过一段时间之后，即作超时处理。服务器一般的默认脚本运行时间是90秒。
你可以从“Internet信息服务”中“默认Web站点”的属性弹出框中看出，你也可以自己设定。
呵呵，上面的可不是，900秒了。
应该是“主目录”标签中的“配置”对话框中，WINXP一样。


在理解脚本运行时间之前，先来看一个程序，主要功能就是进行计算网页执行时间的。

当然对应的ASP也就是看到许多站点都有的页面执行时间显示
1、time.asp　　<%startime=timer()%>
<a href=#bot>到下面看执行的时间</a>　<%
for i= 1 to 5000
response.write("<hr width="&int(500+i)&">")  next　%>
当然中间还可以添加其它内容。<br>　<%endtime=timer()%>　<a name=bot></a>
<%=FormatNumber((endtime-startime)*1000,3)%>毫秒
那如果上面的程序变成for i= 1 to 5000000呵呵，是不是机器快反应不过来的感觉，那这个就是脚本的执行时间了。为了让程序能很好的执行，就该把脚本执行时间放长了。怎么放长？ 
<%Server.ScriptTimeout=110%>
时间的设定当然是比默认90秒大的，现在的代码就是：指定服务器处理脚本在 110 秒后超时。还有，脚本时间的确定要看自身的程序了，一般情况100秒左右也差不多了，即使能执行出来，可能观看网页的人早就把它叉叉了。
以上的ScriptTimeout就是Server对象唯一属性了
二，Server.HtmlEncode　HtmlEncode就是Server对象的其中一个方法了。它允许你对特定的字符串进行 HTML 编码，虽然 HTML 可以显示大部分你写入 ASP 文件中的文本，但是当你需要实际包含 HTML 标记中所使用的字符，就会遇到问题。这是因为，当浏览器读到这样的字符串时，会试图进行解释。
还是看一个程序，我想在页面显示“&nbsp;”这样的代码（附：&nbsp;是空格的代码）
那么当我进行书写的时候你会发现，浏览器已经给我解释了的。
所以，为了要让一些特殊代码能够显示，就运用该方法了。
2，htmlencode.asp　<%Response.write ("这是没有采用 HTMLEncode 方法的测试。<br> 这里就另起一行，说明代码被执行。&nbsp;")%>　<hr>
<%Response.write Server.HtmlEncode("这是对 HTMLEncode 方法的测试。<br> 这里应该不会另起一行，也就是代码没有被执行了。&nbsp;")%>
这在许多网站，论坛都存在的一些BUG，不信你可以到各论坛试试：敲入&nbsp;就是没有，急死你呢：）当然HtmlEncode只是其中的一个原因，最主要的还是UBB代码的转换。不过关于这点我也已经调试解决了。调试地址参看 http://www.cnbruce.com/juven/showart.asp
当然经典论坛不存在这问题，要不你也不会看到效果了。
三，Server.UrlEncode正如 HtmlEncode 方法使客户可以将字符串翻译成可接受的 HTML 格式一样，Server 对象的 UrlEncode 方法则是根据 URL 规则对字符串进行正确编码，当字符串数据以 URL形式传递到服务器时，在字符串中不允许出现空格，也不允许出现特殊字符。为此，如果你希望在发送字符串之前进行 URL 编码，可使用 Server.URLEncode 方法。
为方便起见，我们先看为处理送交，然后处理接受的效果。
3，urlencode.asp　<%filepath=request.servervariables("script_name")%>
接受URL中的值（没有处理接受值，发现值被解释了）： <%=request.querystring("cnbruce")%>
<form action="<%=filepath%>">
你可以输入“&lt;hr&gt”等代码看看:<input type="text" size="20" name="cnbruce"><input type="submit">
</form>
接受URL中的值（进行了urlencode编码，不会执行）： <%=Server.URLEncode(request.querystring("cnbruce"))%>
当然你会发现，虽然不执行了，但会出现“<”变成了“%3C”，“>”变成了“%3E”，那这就是因为没有在发送之前处理。
不过，我们还可以通过Replace函数将这些特殊代码再逆转过来。
4，vurlencode.asp　<%　function tihuan(what)
tihuan=what
if not isnull(what) then
tihuan=replace(tihuan,"%3C","&lt;")
tihuan=replace(tihuan,"%3D","=")
tihuan=replace(tihuan,"%3E","&gt;")
tihuan=replace(tihuan,"%26","&")
tihuan=replace(tihuan,"空格我不知道，呵呵。哪个告诉我下：）","&nbsp;")
tihuan=replace(tihuan,"%3B","&#59;")
tihuan=replace(tihuan,"%22",""")
tihuan=replace(tihuan,"%2B","+")
tihuan=replace(tihuan,"%2F","/")
end if　end function　%>
<%filepath=request.servervariables("script_name")%>
接受URL中的值（没有处理接受值，发现值被解释了）： <%=request.querystring("cnbruce")%>
<form action="<%=filepath%>">
你可以输入“&lt;hr&gt”等代码看看:<input type="text" size="20" name="cnbruce"><input type="submit">
</form>　接受URL中的值（进行了urlencode编码，不会执行）： <%=tihuan(Server.URLEncode(request.querystring("cnbruce")))%>
呵呵，其实上面我是做的无用功啦，真正应该是在发送之前就该处理下的，不过对学习该方法的举例确是个好方法：）
四，Server.MapPath　相信看过我写的《DW2ASP系列》的朋友，都卡在这个上了。DW毕竟是入门的好东西,但要系统学ASP编程,对这个就该好好认识了解下。
MapPath方法，具体的就是将指定的相对或虚拟路径，映射到服务器上相应的物理目录上。
用法，也就是语法了，如下：　Server.MapPath（Path）
Path 指定要映射物理目录的相对或虚拟路径。若 Path 以一个正斜杠 (/) 或反斜杠 (/) 开始，则 MapPath 方法返回路径时将 Path 视为完整的虚拟路径。若 Path 不是以斜杠开始，则 MapPath 方法返回同本文件中已有的路径相对的路径。这里需要注意的是 MapPath 方法不检查返回的路径是否正确或在服务器上是否存在。
当然这可以和Request.ServerVariables连起来使用看看。
5，mappath.asp　Request.ServerVariables("APPL_PHYSICAL_PATH") ： <%=Request.ServerVariables("APPL_PHYSICAL_PATH")%><p>
Request.ServerVariables("PATH_INFO") ： <%=Request.ServerVariables("PATH_INFO")%><p>
Request.ServerVariables("SCRIPT_NAME") ： <%=Request.ServerVariables("SCRIPT_NAME")%><p>
Request.ServerVariables("URL") ： <%=Request.ServerVariables("URL")%><p>
Request.ServerVariables("PATH_TRANSLATED") ： <%=Request.ServerVariables("PATH_TRANSLATED")%><hr>
上面都是通过ServerVariables提取得出的值，下面就来运用mapath把一个虚拟地址转变为实际的物理地址。<p>
Server.MapPath(Request.ServerVariables("URL")) ：<%=Server.MapPath(Request.ServerVariables("URL"))%><p>
或者自己随便写个不存在的路径，同样能够执行<p>
Server.MapPath("cnbruce.asp") ： <%=Server.MapPath("cnbruce.asp")%><p>
再来个“/”的<p>　Server.MapPath("/cnbruce.asp") ： <%=Server.MapPath("/cnbruce.asp")%><br>
Server.MapPath("/cnbruce.asp") ： <%=Server.MapPath("/cnbruce.asp")%><p>
你会发现物理地址转变到IIS默认根目录下面了。这就是如6to23之类的站点mappath的问题所在。还是虚拟主机好，即使是根，也还是自己站点的默认存放节点根。 
注意测试的地址和根目录下的地址，对应的是同一文件夹（这就是虚拟主机），6to23之类是不会相同的。有此些了解，对路径的处理应该要好多了，再返回我的站点，看看我对数据库的mappath路径的处理方法，相信又是一个理解层次了。
五、Server.CreatObject　 这个方法恐怕是 ASP 中最为实用，也是最强劲的功能了。它可用于创建已经注册到服务器上的 ActiveX 组件实例。这是一个非常重要的特性，因为通过使用 ActiveX 组件能够使你轻松地扩展 ActiveX 的能力，正是使用了 ActiveX 组件，你可以实现至关重要的功能，譬如数据库连接、文件访问、广告显示和其他 VBScript 不能提供或不能简单地依靠单独使用 ActiveX 所能完成的功能。也正是因为这些组件才使得 ASP 具有了强大的生命力。那今天就主要把Server对象学习了下，感觉好象是每个都有用的，重要啊。
还有，需要说明的，如果您从本处转载，发现和本源件有差错，比如代码&nbsp; 、 &lt 、 &gt等等，根本就是被执行了的。都说明您的站点存在着这些问题。
ASP编程入门进阶（八）：内置对象Session 
ASP对象中除了用于发送（Response）、接收和处理数据（requeest）、服务器访问（Server）的对象外，还有一些非常实用的标记Active Server应用程序（Application）和单个用户信息（Session）的对象。
Session对象　该对象在ASP使用中占相当大的比例。由于网页是一种无状态程序，无法得知用户浏览状态。在ASP中，通过Session对象来记录使用者私有的数据变量，以作为用户再次对服务器提出要求时做确认，用户在程序的Web页面之间跳转时，存在Session对象中的变量将不会消失。这些是很重要的功能，尤其是有会员的系统必须要用到的。像是会员的登入账号、时间、状态以及许许多多该记录的实时数据（如购物系统记录使用者的购物篮内的商品），这些信息属于各使用者私人所需要，通常开发者都是使用 Session 记录处理。
    在ASP中的Session是使用Cookies构成，服务器将所有的Session内记录的数据，以Cookies的方式传至用户的浏览器。通常一般浏览器会将这些Cookies存起来，每当使用者点选连结，再次与服务器做联机时，浏览器就会把这些Cookies传回Server供做处理：这即是Session的运作原理。由此可知会话状态Session仅在支持cookie的浏览器中保留，如果客户关闭了Cookie 选项Session也就不能发挥作用了。
一、Session.SessionID　 属性返回用户的会话标识。在创建会话时，服务器会为每一个会话生成一个单独的标识，会话标识以长整形数据类型返回。在很多情况下 SessionID 可以用于 WEB 页面注册统计。
    利用该属性可以解决一种对用户的控制问题。该问题的主要功能就是，针对某个网站的一个模块，当一个会员登录后正在看此模块时，另一个人用同样的会员名登录，就不能浏览这个模块：也就是说一个会员名同时只能一个人浏览此模块。
    通过用会员名（假设为UserID，唯一）和SessionID来实现了控制。当会员登录时，给这个会员一个Session记录登录状态如：Session("Status")="Logged"，同时把这个会员的Session.SessionID写入数据库。当他要浏览此模块时，先判断其是否登录，若已经登录再判断它的SessionID是否与数据库记录的相同，如果不同则不能访问。
    这样，当另一个用户用相同的会员名登录时，那么数据库中记录的就是新的SessionID，前者访问此模块时就不能通过检查。这就实现了一个会员名同时只能一个人浏览某个模块。这个功能在一些收费网站有很有特别作用，它防止了一个会员名给多个人浏览的问题，为公司保障了利益。
<%=Session.SessionId%>　是单独生成的唯一ID标识，可刷新调试。
二、Session.TimeOut　该属性设置的Session的最大间隔时间。间隔时间是指客户器端从最近一次向Web服务器提出要求，到下一次向Web服务器提出要求的时间。可以理解为：如果用户在该超时时限之内不刷新或请求网页，则该会话将终止。Timeout 属性是以分钟为单位，为该应用程序的Session对象指定超时时限的，一般默认为20分钟。这在网吧等公共场所，登录个人信息页而忘记关闭窗口时，显得比较重要（至少可以把时间设短些）。
<%=Session.TimeOut=10%>
以上SessionId、TimeOut属于Session对象的两个属性，下面看该对象的一个方法
Session.Abandon　该方法是Session对象的唯一方法，可以清除Session对象，用来消除用户的Session对象并释放其所占的资源。当然你如果没有明确调用Abandon方法，一旦会话超时，服务器也会将删除这些对象并释放资源。
下面就用两个页的程序来认识Session对象以及Abandon方法的利用。
1，login.asp　<%
'提取url中变量loginout的值是否为true，若为真，就执行Session.Abandon()。
if Request.QueryString("loginout")="true" then      Session.Abandon()
end if 　'只有在当点击了submit按钮的前提下，再来判断提取的东西都不为空，则建立Session对象。
submitname=request.form("submit1")
if submitname="submit" then
    if Request.Form("name")<>"" and Request.Form("pwd")<>"" then
        Session("name")=Request.Form("name")
        Session("pw")=Request.Form("pwd")
    end if　end if　%>　<%
'如果Session("name")不为空，则显示它的值，并且做一个到info.asp的链接。
if Session("name")<>"" then
response.write("你的name值是："&Session("name"))
response.write("<br><a href='info.asp'>显示你的资料</a>")
else　'否则，即Session("name")为空不存在，则显示表单用以输入建立Session的平台。
%>　<form action="login.asp" method="post">
姓名：<input type="text"     name="name"><br>
密码：<input type="password" name="pwd"><br>
<input type="submit" value="submit" name="submit1"></form>
<!--同样做了一个到info.asp的链接。-->
<a href="info.asp">显示你的资料</a><%end if%>
注意Session("name")为空和不为空的时候，都做了一个到info.asp的链接，具体调试结果如何，再来看info.asp的内容。
2，info.asp　<%　'如果session对象值为空则跳转到login.asp
if session("name")="" then
       Response.Redirect("login.asp")
'否则就显示个人信息
Else　       Response.Write("你的姓名："&session("name")&"<br>")
       Response.Write("你的密码："&session("pw")&"<br>")
end if　%>
<a href="login.asp">返回</a>
<a href="login.asp?loginout=true">退出</a>
可以看出来，info.asp页面内容的显示其实是需要条件的。那就是必须得有一个session值的存在，这样才可以显示具体的信息。这在登录系统中运用得比较多。
你可以把login.asp想象成一个登录窗口，当然我的这个比较简单（只要输入用名和密码就生产Session了），实际情况是：判断输入的用名和密码是否和数据库中的用名和密码吻合，如果正确吻合才生成Session的。然info.asp页面的作用刚好可以做为一权限页面，因为进入该页需要Session，而Session的产生是确保用名密码正确的。
所以当一开始出现表单窗口时，你点login.asp链接是打不开的，只有当提交了表单生成了Session后才能进入。这正是登录系统的精髓所在，Do You Know？：）
四、Session_OnStart　Session_OnStart属于Session对象的一类事件。它是在服务器创建新会话时发生的。服务器在执行请求的页之前先处理该脚本。Session_OnStart 事件是设置会话期变量的最佳时机，因为在访问任何页之前都会先设置它们。
对象的例程每一次启动时触发Session_OnStart事件，然后运行Session_Onstart事件的处理过程。也就是说，当服务器接收到应用程序中的URL的HTTP请求时，触发此事件，并建立一个Session对象。
当然说到Session_OnStart事件就不能不谈到一个文件Global.asa（P.S：我打算把该文件和Chat程序放在一起说的，所以现在先不作过多解释）
具体用法先透露，写在Global.asa文件内部
<SCRIPT RUNAT=Server Language=VBScript>
.......
Sub Session_OnStart
.......
End Sub
.......
</SCRIPT>
五、Session_OnEnd一看也就知道是Session对象的另一类事件了。当调用Session.Abandon方法时或者在TimeOut的时间内没有刷新，这会触发Session_OnEnd事件，然后执行里面的脚本。同样具体用法在后面将写的Global.asa文件专题中详细介绍到，简单语法如下：<SCRIPT RUNAT=Server Language=VBScript>.......
Sub Session_OnEnd　.......　End Sub.......　</SCRIPT>
以上就是对Session对象的系统学习。
ASP编程入门进阶（九）：内置对象Application 
在Web应用程序中，当一个用户访问该应用时，Session类型的变量可以供这个用户在该Web应用的所有页面中共享数据；如果另一个用户也同时访问该Web应用，他也拥有自己的Session变量，但两个用户之间无法通过Session变量共享信息，而Application类型的变量则可以实现站点多个用户之间在所有页面中共享信息。可以理解Session是局部变量，而Application则为全局变量。
在同一虚拟目录及其子目录下的所有 .asp 文件构成了 ASP 应用程序。我们非但可以使用 Application 对象，在给定的应用程序的所有用户之间共享信息，并在服务器运行期间持久的保存数据。而且，Application 对象还有控制访问应用层数据的方法和可用于在应用程序启动和停止时触发过程的事件。
一、Application("name")=Value
正如Session("name")=value一样，Application对象也没有内置的属性。当然用户可以自定义属性，该属性也可称为集合。
　　一旦分配了Application对象的属性，它就会持久地存在，直到关闭WEB服务器服务使得 Application 停止。由于存储在 Application 对象中的数值可以被应用程序的所有用户读取，所以 Application 对象的属性特别适合在应用程序的用户之间传递信息。<%　Application("MyName") = "cnbruce"　%>
二、Application.Lock方法是禁止其他用户修改Application对象的属性，以确保在同一时刻仅有一个客户可修改和存取 Application 变量。如果用户没有明确调用 Unlock 方法，则服务器将会在 .asp 文件结束或超时后即解除对 Application 对象的锁定。最简单的就是进行页面记数的例子了。
1，num.asp<%　Application.Lock
Application("NumVisits") = Application("NumVisits") + 1
Application.Unlock　%>
你是本页的第<%=Application("NumVisits")%>位访问者
当然，若如果你需要记数的初始值那就该写个判断了。
<%　if Application("NumVisits")<9999 then
Application("NumVisits")=10000
end if　Application.Lock
Application("NumVisits") = Application("NumVisits") + 1
Application.Unlock　%>
你是本页的第<%=Application("NumVisits")%>位访问者上面的程序，你会发现每刷新一次，都会记数累加，如按IP值访问来记数的话，则建立一个Session
2，vnum.asp　<%　if session("visitnum")="" then
Application.Lock　　Application("NumVisits") = Application("NumVisits") + 1
Application.Unlock　　session("visitnum")="visited"
end if　%>你是本页的第<%=Application("NumVisits")%>位访问者
三、Application.Unlock与Lock方法相反，Unlock方法是允许其他用户修改 Application 对象的属性。可以看出在上面的例子中，Unlock方法解除对象的锁定，使得下一个客户端能够增加 NumVisits 的值。当然需要注意的是：记数要确保服务器不被重启，因为所以的访问是数值是建立在页面之上的，并未进行保存成文件或保存到数据库这样的处理。一般当服务器重新启动就会触发Application的事件了。
四、Application_OnEnd事件　在应用程序退出时于 Session_OnEnd 事件之后发生，当然Application_OnEnd 事件的处理过程也必须写在 Global.asa 文件之中。
比如上面的程序中，若服务器关机必然会触发Application_OnEnd事件，那么该事件就可以进行数据保存的工作，已使得下次数据的续沿。当然Application_OnEnd 事件在应用程序退出时于Session_OnEnd 事件之后发生
<SCRIPT LANGUAGE="VBScript" RUNAT="Server">.............
Sub Application_OnEnd .............
End Sub .............</SCRIPT> 
五、Application_OnStart事件在首次创建新的会话( 即 Session_OnStart 事件 )之前发生。当WEB服务器启动并允许对应用程序所包含的文件进行请求时就触发Application_OnStart事件。
<SCRIPT LANGUAGE=ScriptLanguage RUNAT=Server>.............
Sub Application_OnStart.............End Sub.............</SCRIPT>
所以现在可以将Global.asa内部的代码可以想象
<SCRIPT LANGUAGE="VBScript" RUNAT="Server">
Sub Application_OnStart.....................End Sub 　Sub Session_OnStart .....................
End Sub 　　Sub Session_OnEnd 　.....................　End Sub 　Sub Application_OnEnd 
.....................End Sub </SCRIPT> 
具体Global.asa是怎么一回事？且听下回分解啊：）
ASP编程入门进阶（十）：Global.asa文件 
我们已经知道Application和Session对象的OnStart、OnEnd事件的脚本，都必须是在 Global.asa 文件中声明的。那究竟Global.asa是什么样的一个文件？它有何作用？又该如何运用呢？ 
首先.asa是文件后缀名，它是Active Server Application的首字母缩写。Global.asa文件可以管理在ASP应用中两个非常苛刻的对象：Application、Session。它其实是一个可选文件，程序编写者可以在该文件中指定事件脚本，并声明具有会话和应用程序作用域的对象。该文件的内容不是用来给用户显示的，而是用来存储事件信息和由应用程序全局使用的对象。该文件必须存放在应用程序的根目录内。每个应用程序只能有一个Global.asa文件。
关于Global.asa文件最常见的错误概念是它能为一般的使用的函数和子程序用作书库。Global.asa文件仅能用于创建对象的引用和俘获启动，以及结束Application对象和Session对象。Global.asa文件主要基于会话级事件被访问，在以下三种情况下被调用：
1，当Application_OnStart或Application_OnEnd事件被触发。
2，当Session_OnStart或Session_OnEnd事件被触发。
3，当引用一个在Global.asa文件里被实例化的对象（Object）。
Global.asa的标准文件格式如下：
<SCRIPT LANGUAGE="VBScript" RUNAT="Server">
Sub Application_OnStart
  'Application_OnStart 当任何客户首次访问该应用程序的首页时运行
End Sub 　　　Sub Session_OnStart 
  'Session_OnStart 当客户首次运行 ASP 应用程序中的任何一个页面时运行
End Sub 　　　Sub Session_OnEnd 
  'Session_OnEnd 当一个客户的会话超时或退出应用程序时运行
End Sub 　　　Sub Application_OnEnd 
  'Application_OnEnd 当该站点的 WEB 服务器关闭时运行　End Sub </SCRIPT>
一、Session_onStart　先看一个控制用户进入页面的代码：
1、Global.asa（放在被调试的虚拟目录的根目录下面）
<SCRIPT LANGUAGE="VBScript" RUNAT="Server">
Sub Session_OnStart '只要是用户第一次登录本站，则会跳转到首页
response.redirect("htp://www.cnbruce.com/")　　End Sub</SCRIPT>
然后调试当前虚拟目录下的任何文件，你会发现所有页面都跳转向htp://www.cnbruce.com/
通过此“强制进入某页”的例子，可以想象当首页需要被关注的时候是非常有必要的。下面就以一个“在线人数”的例子来继续观察Session_OnStart和Session_OnEnd事件
例2、Global.asa（放在被调试的虚拟目录的根目录下面）
<SCRIPT LANGUAGE=VBScript RUNAT=Server>
Sub Application_onStart '初始值为0
     Application("OnLine") = 0 
End Sub 　　Sub Session_onStart '一个用户访问进行记数加1
     Application.Lock 　     Application("OnLine") = Application("OnLine") + 1 
     Application.Unlock 　End Sub 
Sub Session_OnEnd '一个用户进程的结束，记数减1 （P.S.如果没有该事件程序，则执行的就是页面访问程序了。）　   Application.Lock 
   Application("OnLine") = Application("OnLine") - 1 
   Application.Unlock 　End Sub     </SCRIPT>
例3、online.asp　<%　if request.querystring("logout")="true" then
session.Abandon()　　response.end　end if　%>
当前共有<%=Application("OnLine")%>在线　
<a href="online.asp?logout=true">退出</a>
你发现在该页中只有一个Application("OnLine")，而且还是被显示引用的。那么其值来自何方？这正是Global.asa文件的关键所在。你可以在本机依次打开各个窗口，进行进行关闭窗口或退出两种方法的调试。
三、继续细化一下上面的程序你会发现：当进行“退出”连接后关闭窗口和直接关闭窗口效果是不一样的。因为Session存在时间的缘故，当直接进行关闭窗口，并不能触发Session_OnEnd事件，所以该如何实现这个几乎不可能的想法呢？
大家都知道，当网页进行关闭的时候可以连带一个onunload事件，那么该onunload只要能执行Session的注销功能不就我们需要的吗？废话少说，将online.asp进行修改
例3、online.asp　<%　if request.querystring("logout")="true" then
session.Abandon()　　response.end　　end if　%>
<body οnunlοad=javascript:window.open("exit.asp")>
当前共有<%=Application("OnLine")%>在线
<a href="online.asp?logout=true">退出</a>
注意，online.asp进行onunload的时候会打开exit.asp，那只要在exit.asp中再设置session.Abandon()就OK了。
例4、exit.asp　<%session.Abandon()%>　<script>　self.close()　</script>
当然，加了段Script脚本，目的是进行Session的注销以后立即进行关闭本身。
那现在基本一个在线统计的Web应用就可以了。
四、深入研究Global.asa从上面的调试中，举一反三的你，一定会提出一个问题：如何控制注册用户在线人数？那下面几个文件一个一个看：
例5、Global.asa（放在被调试的虚拟目录的根目录下面）
<SCRIPT LANGUAGE="VBScript" RUNAT="Server">
Sub Application_OnStart
application("online")=0
End Sub　Sub Session_OnStart
End Sub　Sub Session_OnEnd
if session.contents("pass") then '判断是否为登录用户的Session_OnEnd
  application.lock
  application("online")=application("online")-1
  application.unlock
end if　End Sub　Sub Application_OnEnd　End Sub</SCRIPT>
注意本Global.asa中的Session_OnStart块不做任何事件。因为一旦有用户访问服务器而不管用户是否登录，都会产生OnStart事件，而现在需要的只是登录用户的在线，所以不能在OnStart事件里使Applicaiton("online")加1。又因为不管是否是登录用户的会话结束都会产生OnEnd事件（假如有访客访问了服务器但并不登录，他的会话结束后也会产生OnEnd事件），所以在Session_OnEnd事件里用了句if语句来判断是否为已登录用户的OnEnd事件，如果是才将在线人数减1。
并且值得注意的是：session.contents("pass")的使用，因为在OnEnd事件里禁止使用Session对象，但是可以用Session对象的集合来调用session变量。也就是说不能直接写session("pass")，而是需要写session.contents("pass")。
例6　login.asp　<%　if request.querystring("logout")="true" then
session.Abandon()
end if　submitname=request.form("submit")
if submitname="submit" then
name=request.form("name")
pwd=request.form("pwd")
if name="cnbruce" and pwd="cnrose" then
  session("name")=name
  session("pass")=true
else　  response.write "Error Name Or Pwd.<a href='login.asp'>Back</a>"
  response.end　 end if　application.lock
application("online")=application("online")+1
application.unlock　%>
当前注册会员<%=application("online")%>人。
<a href="login.asp?logout=true">退出</a>
<%else%>　<form action="login.asp" method="post">
<input type="text" name="name"><br>
<input type="password" name="pwd"><br>
<input type="submit" name="submit" value="submit">　<%end if%>
只是简单地检测用名是cnbruce，密码是cnrose的时候，生成一个session("pass")=true，就是放在Global.asa中判断的。
五，继续发挥想象　想想，再想想。仅统计有多少人在线是不够的，还要判断用户的在线状态。
可以想象办法基本，当用户登录的时候，在login.asp里将online设为1（如果有数据库则上传），但用户离线时将online设为0，要完善它，就要修改一下Session_OnEnd事件，在该事件里将online设为0（同样将为0的值上传）……
当然，Global.asa远远不止这些。不过我们现在先不着急全部掌握，当我们接触到数据库的时候再返回过来看，继续研究该文件，相信到那时一定又会感悟到很多。所以，还是先把上面的这些吃透吧：）
ASP编程入门进阶（十一）：Chat聊天程序 
通常的聊天室所采用的程序，也就是Chat程序了，其基本结构原理是不会采用到数据库的。那究竟采用什么技术呢？我们知道ASP变量当中Session变量的作用是记录单个用户的信息，并且能跟踪用户的行为；Application对象的作用则起的全局变量，可以实现站点多个用户之间在页面中共享信息的。那可以想象，在针对当前聊天程序中，一个聊天成员即为一个Session变量，聊天成员之间的会话则当成Application变量进行共享显示，以使各成员都能看见。
那下面就采用一很经典的实例程序，进行了解和分析。
1，chat.asp　<%If Request.ServerVariables("Request_Method")="GET" then%>
  <form method="post" action="chat.asp">
   <input type="text" name="nick"  value="your nick name"><p>
   <input type="submit" value="come in"><p>
   <input type="hidden" name="log" size="20" value="1">　  </form>
<%Response.End 　  Else　  Response.clear　  dim talk
   If Request.Form("nick")<>"" then　    Session("nick")=Request.Form("nick")   End if　%>　<form method="post" action="chat.asp" name=form1> 
<%=Session("nick")%>说话：
<input type="text" name="talk" size="50"><br>
<input type="submit" value="提交">
<input type="reset" value="取消"></p>
</form>　<a href="chat.asp">离开</a><br>　
<%　If Request.Form("log")<>1 then
  If trim(Request.Form("talk"))="" then
    talk=Session("nick")&"不说一句话就想来敷衍大家"
  Else    talk=trim(Request.Form("talk"))
  End If Application.lock
  Application("show")="来自"&Request.ServerVariables("remote_addr")& "的" &Session("nick")&"在"&time& "的时候说：" &talk& "<br>" &Application("show")
Application.UnLock　 Response.Write Application("show")
End if　%>　<%End if%>
简单解释：１、<%If Request.ServerVariables("Request_Method")="GET" then%>的作用就是判断当前页面接受的方式，如果为GET方式则会显示“要求输入昵称”的表单页。因为页面的默然接受方式为GET，当在URL地址栏直接敲入时，也就是没有任何信息的时候，就应该显示要求“输入昵称”。
2、<input type="hidden" name="log" size="20" value="1">和下面的If Request.Form("log")<>1 then是有关联的：显然第一次输入昵称进入，同样将log隐藏域发送。但作为第一次的进入是无任何语句发言的，所以判断接受的log值不为1，亦即非首次登录（表示已经登录）时，执行内部相关聊天显示程序。
3、trim(Request.Form("talk"))=""，trim就是个函数了：删去字符串前，后的空格。初此，还有rtrim()：去掉字符串后的空格；ltrim()：去掉字符串前的空格。

4，Application.lock　  Application("show")="来自"&Request.ServerVariables("remote_addr")& "的" &Session("nick")&"在"&time& "的时候说：" &talk& "<br>" &Application("show")
Application.UnLock提取精华得Application.lock
  Application("show")=talk& "<br>" &Application("show")　　 Application.UnLock
可以看到是Application变量的叠加功能，每次Application("show")的值都建立在原有Application变量值的基础之上，再附加上最新的聊天内容：talk变量的值。这样就保证所有用户都能看到的共享信息了。未完待叙，就酱紫看先 :)
ASP编程入门进阶（十二）：ASP技巧累加 
一、On Error 语句　作用是：启用或禁用错误处理程序。一般用法如下：
On Error Resume Next　　On Error GoTo 0
如果在您的代码中未使用On Error Resume Next语句，所发生的运行时错误将显示错误信息，同时，代码的执行也随之终止。但当你采用它时，就会使程序按照产生错误的语句之后的语句继续执行，或是按照最近一次所调用的过程（该过程含有 On Error Resume Next 语句）中的语句继续运行。这个语句可以不顾运行时错误，继续执行程序，之后您可以在过程内部建立错误处理例程。在调用另一个过程时，On Error Resume Next 语句变为非活动的。所以，如果希望在例程中进行内部错误处理，则应在每一个调用的例程中执行 On Error Resume Next 语句。
如果您已启用 On Error Resume Next 错误处理程序，则可使用On Error GoTo 0禁用错误处理程序。

[附注：要在代码中生成运行时错误，请用Err对象的Raise方法。
这样的情况经常在调试程序的时候看见，比如分别调试下面两程序则会显示。
1，err1.asp　<%Err.Raise 6%>　技术信息（用于支持人员）　错误类型：Microsoft VBScript 运行时错误 (0x800A0006)　　溢出
2，err2.asp　　<%cnbruce.com%>　调试的时候也就是　技术信息（用于支持人员）
错误类型：Microsoft VBScript 运行时错误 (0x800A01A8)　缺少对象: 'cnbruce'
但当你在首行添加了On Error Resume Next之后，发现不报错提示，表明内部错误处理完成。但进行下列程序的时候发现
3，err3.asp　<%　On Error Resume Next
cnbruce.com
On Error GoTo 0　　cnbruce.com%>
这时运用了On Error GoTo 0，则会显示出错信息，只不过不是第三行，而是第五行的cnbruce.com错误对象了。通过上面几个例子，相信你对此语句应该有所领悟了。接着再看。
二，Option Explicit 语句　该语句的作用是：强制要求显式声明脚本中的所有变量。
　　所谓的显式声明，就是要使用 Dim、Private、Public 或 ReDim 语句声明所有变量。如果在程序中试图使用未经声明的变量名，则会出现错误。用该语句可以避免拼错已存在的变量名称。对于作用范围不清楚的变量，使用此语句也可避免发生混淆。当然，如果要使用 Option Explicit，该语句必须出现在脚本的任何其他语句之前。
4、err4.asp　<%　Option Explicit    ' 强制显示声明变量。
Dim MyVar          '声明变量。
MyVar = 10         '声明变量不产生错误。
MyInt = 10         '未声明变量产生错误。
response.write(MyInt)　%>
报错信息如下：　技术信息（用于支持人员）
错误类型：　Microsoft VBScript 运行时错误 (0x800A01F4)　变量未定义: 'MyInt'
再加一句：ASP中对VBScript提供了强劲的支持，能够无缝集成VBScript的函数、方法，这样给扩展ASP的现有功能提供了很大便利。由于ASP中已经模糊了变量类型的概念，所以，在进行ASP与VBScript交互的过程中，很多程序员也惯于不声明VBScript的变量，以后注意，这样加重了服务器的解析负担，进而影响服务器的响应请求速度。鉴于此，我们可以象在VB中强制用户进行变量声明一样在VBScript中强制用户进行变量声明。实现方法就是：在ASP程序行首放置<% option explicit%>。实践也证明，ASP文件中使用“Option Explicit”可以使得程序出错机会降到最少，并且会大大提升整体性能。另外，声明的变量有个顺序的技巧，要么以编译时间，要么以运行时间。声明的变量都按此顺序引用。
ASP编程入门进阶（十三）：ASP组件Ad/ContentRotator 
ASP的强大不仅仅局限于接受和显示的交互，更多的是运用ActiveX 组件进行更强大的Web应用。那究竟ActiveX组件为何物？它又是如何运作的呢？其实ActiveX Server Components(ActiveX 服务器组件)是一个存在于 WEB 服务器上的文件，该文件包含执行某项或一组任务的代码，组件可以执行公用任务，这样就不必自己去创建执行这些任务的代码。很形象的一句话：运用组件直接采用别人经典的功能强大的程序。只不过这程序已被封装了的。
那具体ActiveX组件是如何产生、如何得来的呢？一般由下面三个路径获得：
1，安装完IIS服务器以后，自带的一些内置组件，如Database Access数据库连接组件。
2，从第三方开发者处获得可选的组件，或者免费或者收费的，如一些上传组件（当然现在有无组件上传）。
3，如果你是一位Web程序开发者，可以使用Visual Basic 、Java 、Visual C＋＋ 、COBOL等程序设计语言来编写你所需要的ActiveX Server Component。这也就是所谓的ASP进行COM(Component Object Model)、COM+开发了。
　　当然无论是第三方还是自行开发，在使用之前都必须要进行系统的注册。不过这些都是后话。我们现在需要的，是尽快先把ASP自带的一些组件搞懂吧。　不过在使用内置组件之前，先用一个程序检测一下自己机器中的组件支持情况。引用一段网上流行的“阿江ASP探针”，将下列代码保存为asp文件进行调试查看。
1，objcheck.asp　<%Option Explicit %>　<%　Dim filename
filename=Request.ServerVariables("SCRIPT_NAME")
Dim ObjTotest(14,4)
ObjTotest(0,0) = "MSWC.AdRotator"
ObjTotest(0,1) = "广告轮显组件"
ObjTotest(1,0) = "MSWC.ContentRotator"
ObjTotest(1,1) = "内容轮显组件"
ObjTotest(2,0) = "MSWC.BrowserType"
ObjTotest(2,1) = "浏览器类型显示组件"
ObjTotest(3,0) = "MSWC.NextLink"
ObjTotest(4,0) = "MSWC.Tools"
ObjTotest(5,0) = "MSWC.Status"
ObjTotest(6,0) = "MSWC.Counters"
ObjTotest(7,0) = "MSWC.IISLog"
ObjTotest(8,0) = "MSWC.PermissionChecker"
ObjTotest(9,0) = "Microsoft.XMLDom"
ObjTotest(10,0) = "IISSample.ContentRotator"
ObjTotest(11,0) = "IISSample.PageCounter"
ObjTotest(12,0) = "Scripting.FileSystemObject"
ObjTotest(13,0) = "adodb.connection"
public IsObj,VerObj,TestObj
dim i　　for i=0 to 13
       on error resume next
       IsObj=false
       VerObj=""
       TestObj=""
       set TestObj=server.CreateObject(ObjTotest(i,0))
       If IsObject(TestObj) then
              IsObj = True
              VerObj = TestObj.version
              if VerObj="" or isnull(VerObj) then VerObj=TestObj.about
       end if　　       ObjTotest(i,2)=IsObj
       ObjTotest(i,3)=VerObj
Next　　sub ObjTest(strObj)
       on error resume next
       IsObj=false
       VerObj=""
       TestObj=""
       set TestObj=server.CreateObject (strObj)
       If IsObject(TestObj) then       
              IsObj = True
              VerObj = TestObj.version
              if VerObj="" or isnull(VerObj) then VerObj=TestObj.about
       end if       　End sub　　%>
<title>Object Check</title><table border="1" cellpadding="0" cellspacing="0" style="border-collapse: collapse" bordercolor="#cccccc" width=80%>
       <tr align=center><td width=40%>组 件 名 称</td><td width=40%>相 关 信 息</td></tr>       <%For i=0 to 13%>
       <tr>　              <td>&nbsp;<%=ObjTotest(i,0) & "&nbsp;<font color=#888888>" & ObjTotest(i,1)%></font></td>
              <td>&nbsp;
              <%              If Not ObjTotest(i,2) Then 
                     Response.Write "<font color=red>不支持</font>"
              Else                     Response.Write "支持，" & left(ObjTotest(i,3),22)
              End If%></td>　       </tr>　       <%next%>　</table>
<FORM action=<%=filename%> method=post>
<input type=text name="classname" size=40>
<INPUT type=submit value=" 确 定 ">
</FORM>　<%　Dim strClass
strClass = Trim(Request.Form("classname"))
If strClass <> "" then
Response.Write "<br>您指定的组件的检查结果："
       Dim Verobj1
       ObjTest(strClass)
         If Not IsObj then 
              Response.Write "<br><font color=red>很遗憾，该服务器不支持 " & strclass & " 组件！</font>"　　         Else              if VerObj="" or isnull(VerObj) then 
                     Verobj1="无法取得该组件版本"
              Else                     Verobj1="该组件版本是：" & VerObj
              End If              Response.Write "<br><font class=fonts>恭喜！该服务器支持 " & strclass & " 组件。" & verobj1 & "</font>"　         End If　　End if　%>
如果你可以运行该ASP文件，也就是说你拥有IIS的WEB服务了。既然有IIS，不出意外，我们今天要学的组件AdRotator相信应该也是支持的。
P.S.一般微软自带的大多是MSWC开头。
广告轮显组件AdRotator组件，其功能相当于在网站上建立了一个符合广告领域标准功能的广告系统。它具有每次访问ASP页面时，在页面上显示不同的广告内容；跟踪特定广告显示次数的能力以及跟踪客户端在广告上单击次数的能力。
AD Rotator 组件的工作原理是通过读取 AD Rotator 计划文件来完成的，该文件包括与要显示图象文件的地点有关的信息，以及每个图象的不同属性。下面就是一个标准的 AD Rotator 计划文件。
一、类型为txt文本 ，命名为myadrot.txt
redirect gourl.asp
width 88　　height 31　border 1　　　　　　*
http://www.cnbruce.com/images/logo.gif
http://www.cnbruce.com/　　　　CN-Bruce　　　　10
http://www.it365cn.com/images/logo.gif
http://www.it365cn.com　　　　　It365cn 　　　　10
http://www.blueidea.com/images/logo.gif
http://www.blueidea.com　　　　　Blue!dea　　　10
代码的前四行包含了广告的全局设置：
1，Redirect 指出广告将成为其热连接的URL。但其并非直接跳转的URL，它包含了两个参数的查询字符串：特定广告主页的URL和图象文件的URL。这些值从而可在gourl.asp文件中进行提取，并且与此同时gourl.asp还可以进行其他的处理工作，比如跟踪单击广告的次数、跳转到接受的的广告主页等。
2，width、height、border不用说一看就知道是连接图片的宽、高以及边框线大小。
“*”号表示了分隔符，以及“*”号下面的每四行为一个单位进行描述每个广告的细节。其中分别代表：
1，每个广告的描述包含图象文件的URL
2，广告对象的主页URL（如果广告客户没有主页，则该行为一个连字符“-”，指出该广告没有链接）
3，图象的替代文字
4，及指定该页与其他页交替显示频率的数值。
该文件是用户自创建的文件。它通常用来解析由AdRotator对象发送的查询字符串的脚本，并将用户重定向到与用户所点击的广告所相关的URL。那具体怎么应用该定向文件呢？
二、adrotator.asp文件　最主要的是连接myadrot.txt文件，并且执行myadrot.txt文件中的信息内容。很简单，两行代码。
<%set myad=Server.CreateObject("MSWC.adrotator")%>
<%=myad.getadvertisement("myadrot.txt")%>
“<%set myad=Server.CreateObject("MSWC.adrotator")%>”学过Server对象，相信还记得该对象强大的一个方法，那就是CreateObject。他可用于创建已经注册到服务器上的ActiveX组件实例。那这就表示引用组件MSWC.adrotator了。
“<%=myad.getadvertisement("myadrot.txt")%>”Ad Rotator组件支持的唯一方法也就是GetAdvertisement了，它只有一个参数:AdRotator计划文件的名称。注意指向文件的路径是当前虚拟目录的相对路径，物理路径是不允许的。也就是说当前的adrotator.asp和myadrot.txt是在同一目录下了。然后进行执行该ASP文件，多次刷新，会发现每次的广告确实是在轮显着的。这时再注意点击图片的超级连接地址。比如：
gourl.asp?url=http://www.cnbruce.com/&image=http://www.cnbruce.com/images/logo.gif　　很明显我们还需要建立gourl.asp，并且将url参数的值进行提取，再接着跳转到该url地址上。
三、gourl.asp　该页主要功能是提取url参数值，跳转到广告主页。代码如下：
<%whaturl=request.querystring("url")%>
<%response.redirect whaturl%>
功能很简单就完成。当然，刚才也说了，这个页还可以做其它一些事件：跟踪客户端在广告上单击次数，比如将接受过来的相同的url地址进行记数的累加，就能显示出该网站广告的点击次数，然后和相应广告商拿取相应的费用什么的……呵呵，在早期都要求需要实际点击率的，现在好象不管，只要广告挂那儿就行-_-!
不过，总的说来，这个组件的功能就是这样。你有多个广告商，并且是按比例单独显示，还需要计算实际点击率的时候，用Ad Rotator组件是最好不过。那也就是说视情况而定了。
最后再说下，该组件的实现需要三个文件：重定向文件、引用文件、处理转向文件。
Content Rotator组件正如Ad Rotator为广告轮显，Content Rotator组件则为内容轮显。
该组件就像一个简化了的Ad Rotator组件，所以其工作原理亦为：通过读取计划文件来完成的网页内容的显示。该计划文件也就是：内容调度文件(Content Schedule File)。
一，类型为txt文本 ，命名为context.txt
%% 3 //后面是注释
<color=red>ASP编程入门进阶</color>
%% 4 //下面显示表格
<table><tr><td>www.cnbruce.com</td></tr></table>　
%% 5　<A HREF="http://www.cnbruce.com">CN-Bruce</A>
该文件的结构比Ad Rotator的调度文件简单，仅需提供要使用的各个文本字符串的列表，由前面加两个百分号(%%)的语句行说明。为了设置每个条目的比率(决定它出现在返回页面中的频率)，在双百分号的后面添加了一个数字。如果其后跟双斜杠(//)就表示为添加的注释。接着就是通过ASP页面将这些信息按规定完整显示。
二、showcontext.asp　<% 　Set MyContent = Server.CreateObject("MSWC.ContentRotator")
Content = MyContent.ChooseContent("context.txt")　　Response.Write Content　%>
"Set MyContent = Server.CreateObject("MSWC.ContentRotator")"，先建立和Content Rotator组件的联系。
"Content = MyContent.ChooseContent("context.txt")"，表示采用Content Rotator组件的方法：ChooseContent，并且赋值给变量Content，到最后输出显示结果。
三、showall.asp以上页面内容个显示是通过Content Rotator组件的ChooseContent方法实现的。此外，该组件还有一方法：GetAllContent。示例如下：
<% 　Set MyContent = Server.CreateObject("MSWC.ContentRotator")
Content = MyContent.GetAllContent("context.txt")
Response.Write Content　%>
运行结果会发现context.txt所有内容被解释执行，并且分类之间会自动添加了<hr>水平线。
当然这个方法可以用在随机图片之类的特效页面上。
ASP编程入门进阶（十四）：Browser & Linking 组件
一、Browser Capabilities组件该组件最主要的作用是：提取识别客户端浏览器的版本信息。其原理是这样的：当客户端浏览器向服务器发送页面请求时，同时会自动发送一个User Agent HTTP标题，而该标题是一个声明浏览器及其版本的 ASCII 字符串。而Browser Capabilities组件就将User Agent映射到在文件Browscap.ini中所注明的浏览器 , 并通过BrowserType对象的属性来识别客户浏览器。若该对象在 browscap.ini 文件中找不到与该标题匹配的项，那么将使用默认的浏览器属性。若该对象既未找到匹配项且 browscap.ini 文件中也未指定默认的浏览器设置，则它将每个属性都设为字符串 "UNKNOWN"。
　默认情况下，browscap.ini文件被存放在 WINDOWS / SYSTEM / INERSRV( 如果是95/98+PWS4) 或 NT/SYSTEM32/INERSRV( 如果是 NT) 目录中，你可以自己编辑这个文本文件，以添加自己的属性或者根据最新发布的浏览器版本的更新文件来修改该文件。
可以得出结论，Browser Capabilities组件也就是提取某个文件中的内容，然后比较得出显示。具体该如何应用呢？
1、btinfo.asp　<%set bc=server.CreateObject("mswc.browsertype")%> 
浏览器名称是browser：<%=bc.browser%><br>  
浏览器版本是version：<%=bc.version%> <br>
浏览器主版本是majorver:<%=bc.majorver%> <br>
浏览器辅版本是minorver:<%=bc.minorver%> <br>
浏览器的运行平台是platform：<%=bc.platform%> <br>
很显然“<%set bc=server.CreateObject("mswc.browsertype")%> ”就是进行的浏览器组件的建立，以下诸如“bc.browser”之类即为显示浏览器的具体某个特性了。
2，btif.asp　<%set bc=server.CreateObject("mswc.browsertype")%> 
<%if bc.frames=true then%>  
浏览器支持多窗口(frames)显示   
<%else%>  浏览器不支持多窗口(frames)显示   
<%end if%>  <br>  　<%if bc.backgroundsounds=true then%>  
浏览器可以播放背景音乐(backgroundsounds)   
<%else%>  　浏览器不能播放背景音乐(backgroundsounds)   
<%end if%>  <br>  <%if bc.tables=true then%>  
浏览器支持表格(tables)显示   
<%else%>  　浏览器不支持表格(tables)显示   
<%end if%>  <br>  <%if bc.beta=true then%>  
你的浏览器是一测试版(beta)   <%else%>  你的浏览器是一正式版   
<%end if%>  <br>  <%if bc.activexcotrols=true then %>  
浏览器支持active控制   <%else%>  
浏览器不支持active控制   <%end if%>  <br> 
<%if bc.cookies=true then%>    浏览器支持cookie功能  <%else%>   
浏览器不支持cookie功能   <%end if%>     <br> 
<%if bc.vbscript=true then%>    
浏览器支持vbscript  <%else%>   浏览器不支持vbscript   
<%end if%>  <br> <%if bc.jscript=true then%>    浏览器支持jscript  
<%else%>   浏览器不支持jscript   <%end if%>
该代码则是检测当前浏览器对各类网页技术的支持情况，下面就可以根据某特定情况做相应变动。
3、fram.asp<%set bc=server.CreateObject("mswc.browsertype")
  if bc.frames then 　%>　<frameset rows="*,*">  
<frame src="http://www.google.com">
  <frame src="http://www.baidu.com">　</framest>　<%else%>
你的浏览器不支持框架　<%end if%>
很简单的意思：如果当前浏览器支持框架则进行frameset的显示，否则提示“你的浏览器不支持框架”，当然，需要提醒你的：不要过分依赖该组件，因为其只是提取browscap.ini里的值，而该值随时可以被客户修改，或者记录过时，不能真实反映到浏览器的情况，所以要慎用。
二、Content Linking组件　曾经用DW做网页都有这样一个烦恼：新做了页面，其它所有相关的页都要重新再做一次超级链接。一次也就罢了，多了多了不禁觉得无用功做了不少。试想如果能有一个专门的文件来负责页面的连接那该多好。Content Linking 组件也就应运而生了。它非但可以使你在这些页面中建立一个目录表，而且还可以在它们中间建立动态连接，并自动生成和更新目录表及先前和后续的 Web 页的导航链接。
　使用该组件，首先需要编写一个目录文件，也就是网页网址的顺序列表文件，它是一个文本文件，可以自由命名。其次，编写一个ASP文件，根据目录文件提供的信息自动生成带超链的目录页。如果需要在每一页上假如“向前或向后翻页”的超链，就再编写一个能自动生成翻页超链的包含文件，可使用inc为扩展名,例如"Nlink.inc"。以后，在组内每一页中包含它。
1，link.txt文件 redirect.asp?url=http://www.cnbruce.com/       cnbruce.com
redirect.asp?url=http://www.blueidea.com/       blueidea.com
redirect.asp?url=http://www.it365cn.com/       it365cn.com
该目录文件的网址就是连接网址，文本就是连接文本了，需要注意的是中间采用Tab键进行分隔。
2，link.asp文件 <%Set objNextLink = Server.CreateObject("MSWC.Nextlink")%>
<%　intCount = objNextLink.GetListCount("link.txt")
For i = 1 To intCount %>　
<a href="<%=objNextLink.GetNthURL("link.txt", i) %>">
<%=objNextLink.GetNthDescription("link.txt", i) %>
</a><br><%Next%>
“Set objNextLink = Server.CreateObject("MSWC.Nextlink")”建立Nextlink组件的连接
“objNextLink.GetListCount("link.txt")”提取link.txt文件中的列表数目
“objNextLink.GetNthURL("link.txt",i)”提取link.txt文件中第i行文本的连接网址
“objNextLink.GetNthDescription("link.txt",i)”提取link.txt文件中第i行文本的连接文本
3，redirect.asp文件，就是转向文件。
<%　Response.Clear  Response.Redirect Request.QueryString("url")　%>
呵呵，是不是觉得还没用到“上一页”、“下一页”的功能。再来~！
4，link1.txt   1.asp       ASP编程入门进阶（一）　　2.asp       ASP编程入门进阶（二）
3.asp  ASP编程入门进阶（三）　　4.asp       ASP编程入门进阶
　主要功能是设置文本和连接
5，link1.inc　<%Set Nextlink=Server.CreateObject("MSWC.NextLink")
Response.write "当前文章索引号为" & NextLink.GetListIndex("link1.txt") & "<br>"
Response.write "上一章的标题：" & NextLink.GetPreviousDescription("link1.txt") & "<br>" Response.write "下一章的标题：" & NextLink.GetNextDescription("link1.txt") & "<br>" count = NextLink.GetListCount("link1.txt")
Response.write "<a href="""&NextLink.GetNthUrl("link1.txt",1)&"""&>"&"第一章"&"</a> " Response.write "<a href="""&NextLink.GetPreviousUrl("link1.txt")&"""&>"&"上一章"&"</a> "
Response.write "<a href="""&NextLink.GetNextUrl("link1.txt")&"""&>"&"下一章"&"</a> "
Response.write "<a href="""&NextLink.GetNthUrl ("link1.txt",count)&"""&>"&"最后一章"&"</a><br>"　%>
GetListCount(目标文件名)       显示组件中包含的连接的文件数目。 
GetListIndex(目标文件名)       显示当前页在这些连接文件中的前后位置索引值。 
GetNextDescription(目标文件名) 显示连接文件中下一个的描述。 
GetNextURL(目标文件名)         显示连接文件中的下一个文件的URL地址。 
GetNthDescription(目标文件名, N)   显示连接文件中第N个网页的描述。 
GetNthURL(目标文件名, N)       显示连接文件中第N个网页的文件URL地址。
GetPreviousDescription(目标文件名) 显示连接文件中前一个文件的描述。 
GetPreviousURL(目标文件名)     显示连接文件中前一个文件的URL地址。
6，1.asp，2.asp，3.asp，4.asp
<!--#include file="link1.inc"--><br>
以下是具体内容，这就是一个很简单的分页程序了。当然接着的后面会有些更详细更复杂的分页，慢慢来吧，呵呵。
ASP编程入门进阶（十五）：计数器组件Counters 
该组件用于创建一个或多个计数器，这些计数器用于跟踪某一网页或某一网站访问次数的信息。你只能创建一个计数器组件，但该组件可以有多于一个的计数器。一旦创建了计数器，它将一直持续下去直到被删除为止。计数器不会在一个事件比如访问一页时自动增加。你必须使用Set和Increment方法人工的设置或增长计数器。
    计数器不受作用域限制。一旦创建了一个计数器，那么站点上的任何页都可以检索和控制它的值。
一、Counters.Set & Counters.Get  Counters.Set主要用来设置记数初始值，Counters.Get则是用来提取记数的值。
1，counts_set.asp　<%  Set Counters=server.createobject("MSWC.Counters")
Counters.Set "cnbruce",10
Counters.set "it365cn",20
Counters.set "blueidea",30　%>
共有<%= Counters.Get("cnbruce") %>次访问 cnbruce.com 网站 <br>
共有<%= Counters.Get("it365cn") %>次访问 it365cn.com 网站 <br>
共有<%= Counters.Get("blueidea") %>次访问 blueidea.com 网站 <br>
用法很简单，首先“Counters=server.createobject("MSWC.Counters")”表示建立了一Counters组件的连接；Counters.Set "cnbruce",10表示记数了名为“cnbruce”的初始值10；Counters.Get("cnbruce")就表示提取名为“cnbruce”的记数值了。
二、Counters.Increment该方法的功能是：记数每次加一。在上例中你刷新页面，记数是不会添加的，所以现在换用Increment方法。
2，counts_inc.asp　<%　Set Counters=server.createobject("MSWC.Counters")　%>
共有<%= Counters.Increment("cnbruce") %>次访问 cnbruce.com 网站 <br>
共有<%= Counters.Increment("it365cn") %>次访问 it365cn.com 网站 <br>
共有<%= Counters.Increment("blueidea") %>次访问 blueidea.com 网站 <br>
基本代码相似，主要就是Counters.Increment的功能累加1。
根据累加可以做个简单的投票系统了。
3，vote.asp　<%  set Counters=server.createobject("MSWC.Counters")
  vote = Request.QueryString("site")
  Counters.Increment(vote) 　%>
Vote for your Favorite Site:
<FORM NAME="Voting for Sites" METHOD="GET" ACTION="vote.asp">
<input type="RADIO" NAME="site" VALUE="cnbruce">cnbruce
<input type="RADIO" NAME="site" VALUE="it365cn">it365cn
<input type="RADIO" NAME="site" VALUE="blueidea">blueidea
<BR><INPUT TYPE="SUBMIT" VALUE="Submit Vote">
</FORM>　Current Vote Tally:<BR>
Cnbruce: <% =Counters.Get("cnbruce") %><BR>
It365cn: <% = Counters.Get("it365cn") %><BR> 
Blueidea: <% = Counters.Get("blueidea") %><BR>
功能是选择某单选按钮后提交，其对应的记数值则Counters.Increment
三、Counters.Remove该对象则是起的记数清空的作用了。
4，remove.asp　<%  set Counters=server.createobject("MSWC.Counters")
  vote = Request.QueryString("site")
  clear = Request.QueryString("clear")
  Counters.Increment(vote)
  If Not clear="" Then
    Counters.Remove("cnbruce")
    Counters.Remove("it365cn")
    Counters.Remove("blueidea")
  End If　%>  Vote for your Favorite Site:
<FORM NAME="Voting for Sites" METHOD="GET" ACTION="remove.asp">
<input type="RADIO" NAME="site" VALUE="cnbruce">cnbruce
<input type="RADIO" NAME="site" VALUE="it365cn">it356cn
<input type="RADIO" NAME="site" VALUE="blueidea">blueidea
<BR><INPUT TYPE="SUBMIT" VALUE="Submit Vote">　</FORM>
Current Vote Tally:<BR>
Cnbruce: <% =Counters.Get("cnbruce") %><BR>
It365cn: <% = Counters.Get("it365cn") %><BR> 
Blueidea: <% = Counters.Get("blueidea") %>
<FORM NAME="Clear Counters" METHOD="GET" ACTION="remove.asp">
<BR><INPUT TYPE="SUBMIT" VALUE="Clear the Counters" NAME="clear"> </FORM>
通过今天的接触可以总结出，一个简单的记数系统已经有两种方法：使用Application对象、使用Counters组件。但更多的还有采用FSO，或者是需要数据库的就是后话慢慢谈了。
　　在我们使用ASP组件时候还要注意一些东西：
当我们使用服务器组件创建对象时，一般有两种方法。比较常用的方法是用SERVER对象的CreateObject() 方法，象这样: SET NextLink = Server.CreateObject("MSWC.NextLink")
　　这种方法很好用，但是还有一种方法更节省系统资源。因为当你用Server.CreateObject()方法创建对象时，对象立即被加载，同时系统为这个对象分配好内存和其它资源。
  第二种创建对象的方法是利用HTML的<OBJECT>标记，语法是这样的：
<OBJECT Runat=Sever ID=NextLink ProgID="MSWC.NextLink" ></OBJECT>
利用<OBJECT>标记创建对象时，你要创建的对象不被马上加载，而是等到这个对象的方法或属性第一次被引用时才加载。这样，我们就会节省一些资源。虽然不是很多，但是当你的系统每天要承受近百万次的点击时，这对节省服务器资源就很有帮助了。（Pine译注）如其所言：我们的Counters则可以放于global.asa中
<OBJECT RUNAT=Server SCOPE=Application ID=Counter PROGID="MSWC.Counters"></OBJECT>
ASP编程入门进阶（十六）：FSO组件之驱动器操作
FSO，正如UFO般令人激动、令人神往，当然更多的亦是让人欢喜让人忧。君不见某空间服务商广告：100MB空间只要60RMB/年，支持数据库，支持什么什么……一问不支持FSO，立马泄气。那FSO究竟是什么东西，它的力量又是如何巨大，其操作的原理又是怎的怎的呢？这次来个彻底的理解。
    首先，FSO是FileSystemObject的简称。当然也就是我们的俗称FSO组件了，该组件可以用来处理驱动器、文件夹以及文件。它可以检测并显示出系统驱动器的信息分配情况；还能够创建、改变、移动和删除文件夹，并能探测一些给定的文件夹是否存在，若存在，还能提取出该文件夹的信息，如名称、被创建或最后一次修改的日期，等。FSO还使得对文件的处理变得很容易。
一、fso.GetDrive   正如其它组件的建立一样，FSO的引用也必须建立连接。
Set fso=Server.CreateObject("Scripting.FileSystemObject")
注意CreateObject的内部再也不是MSWC了，而是Scripting。
那下面就可以通过fso来处理驱动器了。比如fso.GetDriveName提取驱动器名，fso.GetDrive同样提取标准驱动器名。比如：
1，fso.asp  <%Set fso=Server.CreateObject("Scripting.FileSystemObject")%>
<%=fso.GetDriveName("d:")%><br>
<%=fso.GetDrive("d:")%>
你会发现GetDriveName("d:")就是“d:”，而GetDrive("d:")则为标准的“D:”，所以我们一般这样写fso.GetDrive(fso.GetDriveName(drvPath))来提取某个具体的驱动盘。
二、drv.GetInfo 提取该驱动盘的具体信息。
2，drv.asp<%  Set fso=Server.CreateObject("Scripting.FileSystemObject")
Set drv=fso.GetDrive(fso.GetDriveName("d:"))　%>
该盘的空间大小：<%=drv.TotalSize%><br>
该盘的剩余空间大小：<%=drv.FreeSpace%>
以上只是提取的D盘驱动器的信息，来个通用的函数，继续分别测试自己的驱动吧。
3，drvinfo.asp　<%  Function ShowDriveInfo(drvPath)
   Dim fso, drv, s
   Set fso = CreateObject("Scripting.FileSystemObject")
   Set drv = fso.GetDrive(fso.GetDriveName(drvPath))
   s = "驱动盘" & drv & "的卷标是："
   s = s & drv.VolumeName & "<br>"
   s = s & "总计空间：" & drv.TotalSize & "<br>"
   s = s & "剩余空间：" & drv.FreeSpace & "<br>"
   s = s & "文件类型：" & drv.DriveType & "<br>"
   s = s & "文件系统：" & drv.FileSystem
   Response.Write s　End Function　%>　<%
on error resume next
whatpath=request.form("path")
if whatpath<>"" then
ShowDriveInfo(whatpath)
end if%>　<form action="drvinfo.asp" method="post">
<input name="path"> <input type="submit"> </form>
其中的drv.TotalSize和drv.FreeSpace返回的是字节数，我们可以用FormatNumber()函数处理下。比如FormatNumber(Drive.TotalSize/1024,0)得到一眼就知磁盘多少G的值。
还有一个文件类型：drv.DriveType最多的时候是显示数值“2”，其实“2”就表示的“硬盘驱动器”，“1”表示“软盘驱动器”，“4”表示“光盘驱动器”……下面就用一个程序遍历显示自己机器上所有驱动器的信息
4，showall.asp　<%　Function tran(Driver)　Select Case Driver
Case 0: tran="设备无法识别"　Case 1: tran="软盘驱动器"　Case 2: tran="硬盘驱动器"　Case 3: tran="网络硬盘驱动器"　Case 4: tran="光盘驱动器"　Case 5: tran="RAM虚拟磁盘"　End Select　　End Function
set fso=Server.CreateObject("Scripting.FileSystemObject")%>
<table border=1 width="100%"><tr>
<td>盘符</td>　<td>类型</td>　<td>卷标</td>　<td>总计大小</td>　<td>可用空间</td>　<td>文件系统</td>
<td>序列号</td>　<td>是否可用</td>　<td>路径</td>　</tr>　<%
on error resume next　For each drv in fso.Drives　    Response.Write "<tr>"
    Response.Write "<td>" & drv.DriveLetter & "</td>"
    Response.write "<td>" & tran(drv.DriveType) & "</td>"
    Response.write "<td>" & drv.VolumeName & "</td>"
    Response.write "<td>" & FormatNumber(drv.TotalSize / 1024, 0)& "</td>"
    Response.write "<td>" & FormatNumber(drv.Availablespace / 1024, 0) & "</td>"
    Response.write "<td>" & drv.FileSystem & "</td>"
    Response.write "<td>" & drv.SerialNumber & "</td>"
    Response.write "<td>" & drv.IsReady & "</td>"
    Response.write "<td>" & drv.Path & "</td>"   Response.Write "</tr>"Next　set fs=nothing　%>　</table>
是不是很神气？那你可以对自己的机器调试，然后上传到自己的空间去调试，你会发现服务商会你进行了些设置：）
当然更神的还在后面面，比如对文件夹，对文件的操作（包括添加、修改和删除）。ps:你对驱动器是不能轻易添加删除的：）
ASP编程入门进阶（十七）：FSO组件之文件夹操作 
操作完驱动器，接着就是来操作文件夹了。其中包括：提取文件夹信息、创建文件夹、删除文件夹、复制文件夹、移动文件夹等。下面就具体来看。
一、fso.GetFolder一看就明白，是提取文件夹了。那具体是提取哪个文件夹呢？后面肯定要跟一个文件夹的路径。提取出来了再来显示该文件夹相关信息呢？是不是有要具体提取下去。所以，看程序：1，getfldr.asp　<%　Set fso = CreateObject("Scripting.FileSystemObject")
Set fldr = fso.GetFolder("c:/Program Files")
Response.Write "父文件夹名字是：" & fldr & "<br>"
If fldr.IsRootFolder = True Then
   Response.Write "该文件夹是一根文件夹" & "<br>"
Else   Response.Write "该文件夹不是根文件夹" & "<br>" 
End If　Response.Write "驱动器名字是：" & fldr.Drive & "<br>"　%>
首先建立FSO组件的连接是必不可少的啦，然后Set fldr = fso.GetFolder("c:/Program Files")设定fldr对象被赋值，以作下面程序的引用。
fldr.IsRootFolder即为判断该文件夹是否为一根文件夹，值为布尔值（true or false）；fldr.Drive则显示该文件夹所在的驱动器号了。
二、fso.CreateFolder
下面比较让人激动的是通过ASP建立文件夹了，你可以在你的权力范围内任意位置建立任意文件夹。
2，creatfldr.asp　<%　Set fso = CreateObject("Scripting.FileSystemObject")
fso.CreateFolder ("c:/cnbruce")
Response.Write "文件夹名为" & fso.GetBaseName("c:/cnbruce")%>
执行程序，应该发现C盘多出了cnbruce文件夹，fso.GetBaseName则是提取文件夹名。
三、fso.DeleteFolder　通过ASP可以建立了文件夹，则同样可以删除文件夹。
3，delfldr.asp　<%　Set fso = CreateObject("Scripting.FileSystemObject")
fso.DeleteFolder("c:/cnbruce")
Response.Write "文件夹已删除"%>
发现刚建立的cnbruce文件夹确实已被删除。那下面就采用一个通用程序来灵活应变下。
4，mainflr.asp　<%　Sub CreateAFolder(file)　  Dim fso
  Set fso = CreateObject("Scripting.FileSystemObject")
  fso.CreateFolder(file)
  response.write "已经建立了"&file
End Sub  Sub DeleteAFolder(file)
  Dim fso　  Set fso = CreateObject("Scripting.FileSystemObject")
  fso.DeleteFolder(file)
  response.write "已经删除了"&file
End Sub　%>　<%　　subname=request.form("submit")
create=request.form("create")
del=request.form("del")
if subname<>"" then    if create<>"" then
    call CreateAFolder(""&create&"")
  end if  if del<>"" then
    call DeleteAFolder(""&del&"")
  end if  　end if　%>
<form action="mainflr.asp" method="post">
<input name="create">
<input type="submit" value="建立" name="submit">
</form>　<hr> <form action="mainflr.asp" method="post">
<input name="del"> <input type="submit" value="删除" name="submit">　</form>
需要注意的是：删除并不会提示“确认要放入回收站”这项。这点你需要谨慎处理，特别是对你的系统文件夹。
四、fso.MoveFolder主要作用是进行文件夹的移动，相当于剪切粘贴动作。
5，movefldr.asp<%　Set fso = CreateObject("Scripting.FileSystemObject")
fso.CreateFolder ("c:/cnbruce")
fso.MoveFolder "c:/cnbruce", "C:/Program Files/"
%>　<a href="C:/Program Files/">查看cnbruce文件夹有没有移动过来</a>
格式：fso.MoveFolder "被移动的文件夹","移动到的文件夹"
本程序先是在C盘下建立了cnbruce文件夹，然后将其移动到C:/Program Files/文件夹下面。
不过同样需要注意的是你的系统文件夹不能乱移动。
五、fso.CopyFolder主要作用：将文件夹从某位置复制到另一位置。
6，copyfldr.asp　<%　Set fso = CreateObject("Scripting.FileSystemObject")
fso.CopyFolder "c:/Program Files/cnbruce", "c:/"　%>
<a href="C:/">查看cnbruce文件夹有没有复制过来</a>
该程序是建立在上一movefldr.asp的执行结果基础之上来完成复制到C盘根目录下的。当然，其拷贝也是将该文件夹包括里面所以子文件夹和文件统统拷贝。
到最后再试着将c:/Program Files/cnbruce和c:/cnbruce两个文件夹进行删除掉吧。
  不过，继续提醒你：不要写错了，比如写成c:/Program Files，那你就惨了：这叫玩命，学ASP玩出心跳出来了。
    对文件夹的操作差不多了，是不是感到用处比较大？不过还要注意注意正规合理利用该组件。然后接下来就是更微妙的：FSO对文件的操作。
ASP编程入门进阶（十八）：FSO组件之文件操作（上）
FSO中除了可以对驱动器、文件夹的操作以外，功能最强大的就是对文件的操作了。它可以用来记数、内容管理、搜索还可生成动态HTML页面等等。
一、fso.OpenTextFile无需多说，fso.OpenTextFile就是打开某个文件了，一般情况之下是打开的txt文本文件。所以首先我们先建立一个txt文件，然后通过FSO来读取其中的内容。
1，info.txt　　　name:cnbruce　　sex:male
建立了该文件，下面再做个ASP页面，当然最好两个文件是在同一目录下。
2，opentxt.asp　<%　whichfile=server.mappath("info.txt")
Set fso = CreateObject("Scripting.FileSystemObject")
Set txt = fso.OpenTextFile(whichfile,1)
rline = txt.ReadLine
rline = rline & "<br>" & txt.ReadLine
Response.Write rline　txt.Close　%>
需要注意：无论是通过FSO打开驱动器、打开文件夹、打开文件，以及以后要接触到的打开数据库，都只能是打开绝对物理路径地址。但一般情况是上传到空间服务商那,不能很直接地了解到自己文件的所在位置，所以强烈推荐使用server.mappath方法：平台移植性强，适用性强。
CreateObject("Scripting.FileSystemObject")建立了FSO组件的连接，fso.OpenTextFile(whichfile,1)打开了info.txt该文件。参数“1”表示“ForReading：以只读方式打开文件。不能写这个文件。”，其他还有参数“2”表示“ForWriting：以写方式打开文件”，参数“8”表示“ForAppending：打开文件并从文件末尾开始写”。打开了该文件，接下来是不是要显示文件中的内容？那就通过txt.ReadLine方法读取文本中的一整行，如果需要继续读取下一行，则继续使用txt.ReadLine方法。当然初此还有其它的读取方法，比如txt.Read(7)读取指定数量的字符，txt.ReadAll返回文本中的全部内容。
二、fso.CreateTextFile　如fso.CreateFolder建立文件夹般，fso.CreateTextFile则是建立文件了。
3，creattxt.asp　<%　whichfile=server.mappath("info.txt")
Set fso = CreateObject("Scripting.FileSystemObject")
Set MyFile = fso.CreateTextFile(whichfile,True)
MyFile.WriteLine("My Name Is CN-Bruce")
MyFile.WriteLine("My Sex Is Male")
MyFile.Close　%>　<a href="opentxt.asp">查看内容</a>
本次建立的文件是上一info.txt文件，fso.CreateTextFile(whichfile,True)其中的参数true即表示能覆盖已有文件。建立后需要向里面添加数据就采用“MyFile.WriteLine”了。
那现在就可以建立一个简单的文本记数器了，还记得以前的记数吗？
1，通过application、session、global.asa进行记数；
2，通过Counter组件进行记数。但两者都有通病，就是不能保存，如果服务器重新启动后，是不是所有记数全部清空了呢：）那现在就可以使用文本来记录数据了，即使重启，下次提取的也还是该文件。
试验：文本计数器首先建立一记数的文本文件counter.txt，设定初始值为“1”
4，counter.txt　　1　接着是记数的ASP文件，功能是显示文本的记数，本做加1的记数，然后还要将新的记数写入文本文件。
5，txtcount.asp　<%　whichfile=server.mappath("counter.txt")
'打开文件并将其值读取，最后关闭连接释放资源
set fso=createobject("Scripting.FileSystemObject")
set openfile=fso.opentextfile(whichfile,1)
visitors=openfile.readline
openfile.close　'页面显示记数内容并做加1运算
response.write "您是本页的第"&visitors&"位访客"
visitors=visitors+1　'将新的数值添加写入到文本，最后关闭所有连接释放资源
set creatfile=fso.createtextfile(whichfile)
creatfile.writeLine(visitors)　creatfile.close　set fso=nothing　%>
那根据这个可以继续地扩展内容：比如让记数用数字图片显示。当然前提就是你需要0-9的10张记数图片，并将此图片放于img文件夹中。下为一增强的txtcount.asp内容代码
<%　whichfile=server.mappath("counter.txt")
set fso=createobject("Scripting.FileSystemObject")
set openfile=fso.opentextfile(whichfile,1)
visitors=openfile.readline
openfile.close
CountLen=len(visitors)
response.write "您是本页的第"
for i=1 to 6-countLen        '表示最大值999999
response.write "<img src=img/0.gif></img>"
next 　for i=1 to countlen
response.write "<img src=img/" & mid(visitors,i,1) & ".gif></img>"
next　response.write "位访客"
visitors=visitors+1
set creatfile=fso.createtextfile(whichfile)
creatfile.writeLine(visitors)
creatfile.close　　　set fso=nothing　%>
本程序中采用的是mid函数，该函数的作用是返回某字符串中从第几位字符开始的几个字符。格式即为：Mid(string,start,length)

ASP编程入门进阶（十八）：FSO组件之文件操作（中） 
学会了FSO提取文件值，也学会了将信息输入到文件中，那下面就再来应用一下。不知道你有没有这样的习惯：看到一个文件，不自觉的右键选择用记事本打开。呵呵，几乎没有哪个文件是不可以的。所以现在，可以默认所有文件都是文本，只是后缀名不同而已；那么也就是说，现在可以提取任一文件的内容信息。OK，就来想象一下：提取一个文件的路径（采用file按钮进行查找定位），将该路径文件打开，并读取所有行，显示读取的信息
一、viewcode.asp　<%　Function ShowCode(filename) 
    Set fso = Server.CreateObject("Scripting.FileSystemObject")
    Set cnrs = fso.OpenTextFile(filename, 1)
    While Not cnrs.AtEndOfStream
        rsline = cnrs.ReadLine
        rsline = server.HTMLEncode(rsline)
        Response.Write(rsline & "<br>")
    Wend　end Function　%>
<form action="viewcode.asp" method="post">
输入文件名<input type="file" name="filename">
<input type="submit" value="查看源程序">
</form>　<%　file=request.form("filename")
response.write (file & "源程序如下<hr>")
If trim(file)<> "" then　　  Call ShowCode(file)　End If　%>　
以上程序调试时，可以选择html，asp页面，也可以打开任一应用程序等。定义的ShowCode函数，主要作用是打开、读取并显示文件中所有信息内容。注意添加了server.HTMLEncode(rsline)，针对含有标准HTML代码的文件。显示文件中所有行即用一条件循环进行遍历显示了。
　While Not cnrs.AtEndOfStream　...　Wend
　　接着，下面的这个例题具体就涉及open方法的问题了，还记得？正常情况之下打开文件是采用fso.OpenTextFile("c:/testfile.txt",1)，参数1的作用是：以只读模式打开文件。不能对此文件进行写操作。如果现在已经存在一文件，需要进行追加写入，则该怎么办呢？简单，参数为8即可。
　　这有什么用呢？呵呵，亚玛逊的网络故事接龙就是如此：能接龙就需要首先要显示原有故事，然后自己添加故事写入文件。这其中的写入文件最讲究的就是追加写入了。所以下面就可以实现。story.asp
　<%　If not request.Form("NextLine")="" then
  Set fso=Server.CreateObject("Scripting.FileSystemobject")
  textfile1=Server.MapPath("story.txt")
  set cnrs=fso.OpenTextFile(textfile1,8)
  cnrs.WriteLine(Request.Form("NextLine"))  cnrs.Close　end if　%>
故事如下：　<%　Set fso=Server.CreateObject("Scripting.FileSystemObject")
textfile1=Server.MapPath("story.txt")
set cnrs=fso.OpenTextFile(textfile1,1)
while not cnrs.AtEndOfStream
  Response.Write "&nbsp;" & cnrs.ReadLine
Wend　cnrs.close　%>　<hr>
<form method="post" action="story.asp">
请输入这个故事的新行:<input name="NextLine" type="text" size="70">
<input type="submit" value="提交">　</form>　
整个就是一很简单的读取信息和加入信息的混合利用，相信有了前面的基础看懂应该不成问题。当然还缺少个story.txt文件，里面写好故事开头就可以了。再下面，继续来，该侧重点主要就是练习一些函数的使用技巧了。
1、instr函数：返回某字符串在另一字符串中第一次出现的位置。
比如现在查找字母“A”在字符串“A110B121C119D1861”中第一次出现的位置，则可以

同样字母“B”的位置也就能确定。现在就来最关键的：提前字母“A”和“B”中间的值“110”。还记得mid函数吗？mid函数的主要作用是：从字符串中返回指定数目的字符。比如现在的“110”则应该是从字符串的第2位取得3个单位的值。

但设想一下：如果不是“110”，而是“1100”，那是不是要提取4位……这样就显出程序的不够完美。所以继续思考：所提取的值，永远是在字母“A”后面的，且值也永远是在字母“A”和“B”之间的，那么只要分别提取出“A”、“B”的位置，则中间数值的起始位应是字母“A”位+1，中间数值的长度应是字母“B”位-字母“A”位-1那么现在就可以让程序完美起来：

OK，那么现在你也就完全可以把字母“B”、“C”、“D”后面的值一一提取了。
当然需要注意的就是“D”后面有几位怎么取呢？采用字符串总长度-字母D所在位置数就可以了。
<script language=vbs>
my_string = "A110B121C119D1861"
a_num = instr(my_string,"A")
b_num = instr(my_string,"B")
c_num = instr(my_string,"C")
d_num = instr(my_string,"D")
total_num = len(my_string)
a_value = mid(my_string,a_num+1,b_num-a_num-1)
b_value = mid(my_string,b_num+1,c_num-b_num-1)
c_value = mid(my_string,c_num+1,d_num-c_num-1)
d_value = mid(my_string,d_num+1,total_num-d_num)
alert(a_value)　alert(b_value)　alert(c_value)　alert(d_value)　</script>
到现在，你也许确实学到了不少，但也许会提出疑问：这个放在FSO文件操作里有什么作用呢？那下面才是我们的正题：用FSO进行简单的文本投票。
　　投票页面首要的就是显示各类项目的投票数，并相应赋于某个变量。然后判断本次投票的选相，相对应地将投票数值加1，完毕后再将所有值继续写入文本。
1，一个HTML表单页website.html　以做投票点击的平台。

2，接受表单页值的result.asp
<%　whichfile=server.mappath("site.txt")
set fso=createobject("Scripting.FileSystemObject")
set thisfile=fso.opentextfile(whichfile)
my_string=thisfile.readline
a_num = instr(my_string,"A")
b_num = instr(my_string,"B")
c_num = instr(my_string,"C")
d_num = instr(my_string,"D")
total_num = len(my_string)
a_value = mid(my_string,a_num+1,b_num-a_num-1)
b_value = mid(my_string,b_num+1,c_num-b_num-1)
c_value = mid(my_string,c_num+1,d_num-c_num-1)
d_value = mid(my_string,d_num+1,total_num-d_num)
select case request.form("website")
    case "A": a_value=a_value+1
    case "B": b_value=b_value+1
    case "C": c_value=c_value+1
    case "D": d_value=d_value+1
end select
mynew_string="A" & cstr(a_value) & "B" & cstr(b_value) & "C" & cstr(c_value) & "D" & cstr(d_value)
set newfile=fso.createtextfile(whichfile)
newfile.writeLine(mynew_string)
newfile.close　　set fso=nothing
%>　当前投票：<br>　　cnbruce.com:<%=a_value%><br>
blueidea.com:<%=b_value%><br>
it356cn.com:<%=c_value%><br>
5d.cn:<%=d_value%><br>　　<a href="website.html">返回继续</a>
有了上面函数的基础，看这个应该不是很难的
3，最后不要忘了的记数文件site.txt
格式：A1B1C1D1　OK，三个文件就可以胜任一个很简单的投票系统了，如果要加强，需要细化的则结合以前的知识吧，比如投过一次后设置session或者cookies，当再次投票时候判断如果session或者cookies存在则不允许，也就是简单的投票防作假手段了……当然更多的还是要自己去想去实践了。
ASP编程入门进阶（十八）：FSO组件之文件操作（下） 
一，fso.GetFile　提取文件相应的 File 对象
1，getfile.asp　<%　　whichfile=Server.MapPath("cnbruce.txt")
Set fso = CreateObject("Scripting.FileSystemObject")
Set f1 = fso.CreateTextFile(whichfile,true)
f1.Write ("This is a test.My Name is cnbruce.")
f1.Close　　Set f2 = fso.GetFile(whichfile)
s = "文件名称：" & f2.name & "<br>"
s = s & "文件短路径名：" & f2.shortPath & "<br>"
s = s & "文件物理地址：" & f2.Path & "<br>"
s = s & "文件属性：" & f2.Attributes & "<br>"
s = s & "文件大小： " & f2.size & "<br>"
s = s & "文件类型： " & f2.type & "<br>"
s = s & "文件创建时间： " & f2.DateCreated & "<br>"
s = s & "最近访问时间: " & f2.DateLastAccessed & "<br>"
s = s & "最近修改时间: " & f2.DateLastModified　　response.write(s)　%>
其效果正如右键某文件，看到的具体属性信息。
其中Attributes返回的数值“32”表示：（Archive）上次备份后已更改的文件。可读写。
其它值附录如下： 
Normal        0      普通文件。               没有设置任何属性。 
ReadOnly      1      只读文件。               可读写。 
Hidden        2      隐藏文件。               可读写。 
System        4      系统文件。               可读写。 
Directory     16     文件夹或目录。           只读。 
Archive       32     上次备份后已更改的文件。 可读写。 
Alias         1024   链接或快捷方式。         只读。 
Compressed    2048   压缩文件。               只读。 
二，file.move文件将指定的文件或文件夹从某位置移动到另一位置。其实该方法仍然属于fso.GetFile后的一个应用。
2，movefile.asp　<%　　whichfile=Server.MapPath("cnbruce.txt")
Set fso = CreateObject("Scripting.FileSystemObject")
Set f1 = fso.CreateTextFile(whichfile,true)
f1.Write ("This is a test.My Name is cnbruce.")
f1.Close　　Set f2 = fso.GetFile(whichfile)
f2.Move "C:/"
%>　<a href="C:/">查看下有没有</a>
简单的剪切粘贴的功能实现。
三，File.Copy　同样属于fso.GetFile后的一个应用。就只是单纯地拷贝文件到某位置。
3，copyfile.asp　<%
whichfile=Server.MapPath("cnbruce.txt")
Set fso = CreateObject("Scripting.FileSystemObject")
Set f1 = fso.CreateTextFile(whichfile,true)
f1.Write ("This is a test.My Name is cnbruce.")
f1.Close　Set f2 = fso.GetFile(whichfile)
f2.Copy "D:/"
%>　<a href="D:/">查看下有没有</a>
和本ASP页面同在目录下的cnbruce.txt文件依然存在。
四，file.Delete很显然，就是直接删除文件了。
4，delfile.asp　<%　whichfile=Server.MapPath("cnbruce.txt")
Set fso = CreateObject("Scripting.FileSystemObject")
Set f1 = fso.CreateTextFile(whichfile,true)
f1.Write ("This is a test.My Name is cnbruce.")
f1.Close　Set f2 = fso.GetFile(whichfile)
f2.move "d:/"　　Set f3 = fso.GetFile("d:/cnbruce.txt")
f3.delete 　%>　<a href="d:/">查看下是没有该文件的</a>
当然FSO还没有结束，比如上传文件，ASP转HTML等都需要用到FSO。更精彩的依然是在后面。
ASP编程入门进阶（十九）：ASP技巧累加（二） 
严格控制Session可以将不需要Session的内容（比如帮助画面，访问者区域，等等）移动到关闭Session的独立ASP应用程序中。在基础页面上，可以给ASP一个指示，让它不需要使用Session。将下面的代码直接加入到ASP页面的头部：<%@EnableSessionState=False%>
在Web服务器上缓存经常使用的数据　典型的情况是：ASP页面从后台存储中取回数据，然后以超文本标记语言（HTML）的形式形成结果。不管数据库的速度如何，从内存中取回数据要比从后台存储设备中快得多。从本地硬盘读取数据通常也非常快。所以，提高性能可以通过缓存服务器上的数据来实现，无论是将数据缓存在内存中，或者本地硬盘中。缓存是经典的“空间换时间”的折中方式。如果缓存得恰当，就可以看到显著的性能提升。为了让缓存有效，必须保证缓存数据是经常要重用的，而且也是计算起来繁琐的。装满陈旧数据的缓存是对内存的浪费。
　　不经常改变的数据是缓存的较好对象，因为不需要随时考虑这些数据更新后的同步操作。组合框、参考表格、DHTML代码、扩展标记语言串、菜单以及站点配置变量（包括数据源名字，Internet协议地址IP以及Web路径）都是很好的缓存对象。注意：要缓存数据表达式而不是数据本身。如果一个ASP页面经常变化并且很费力去缓存（比如整个产品目录），就要考虑预产生HTML，而不是每次发生请求时再描述它。
在Application或Session对象中缓存经常使用的数据ASP中的Application和Session对象是在内存中缓存数据的便利容器。你可以将数据赋值给Application和Session对象，这些数据在HTTP调用期间将一直保持在内存中。Session中的数据是为每一个用户服务的，Application中的数据是所有用户共享的。
　　何时需要在Application和Session中装入数据？通常，当应用程序启动或者会话开始时，数据就被装入了。为了在这时装入数据，在Application OnStart()或者Session OnStart()中分别添加适当的代码。这些函数位于文件Global.asa中，如果原来不存在，就添加上。也可以在数据首次需要的时候调入，在ASP页面中添加代码，检查数据是否存在，如果没有发现，就调入它。这里有一个例子，它代表了被称为“lazy evalution”的经典性能处理技术：直到需要，再去计算。 
拷贝经常使用的数据到脚本变量中在ASP中存取COM对象时，应该拷贝经常使用的对象数据到脚本变量中，这样就减少了对COM对象的方法调用。这些调用要比存取脚本变量相对来说费时费力。当存取Collection和Dictionary对象时，使用这项技巧也减少了昂贵的查找操作。通常，如果要不止一次地存取对象数据，就应将数据放入脚本变量中，对象数据主要也就是Request变量（表单和查询字符串变量）。比如，站点要传递一个叫做UserID的查询字符串变量，假设它将在一个特殊页面被引用12次，那么不需要调用Request("UserID")12次，只要在ASP页面的头部分配给UserID一个变量，然后在页面中使用它，这样做就节省了11次COM方法的调用。
在任何可能时使用Server.Transfer，而不要用Response.Redirect
Response.Redirect告诉浏览器请求另一个不同的页面，这常常用于引导用户到登录页面或者出错处理页面。由于重定向强迫了一个新页面请求，结果是浏览器必须要与Web服务器循环2次，并且Web服务器必须处理一个额外的请求。Server.Transfer执行在同一服务器上的页面传输，这将避免额外的浏览器－Web服务器的数据循环，形成良好的系统性能，对于用户也有较好的响应时间。当然Server.Transfer只支持相对路径（即站内使用）。
ASP编程入门进阶（二十）：ADO组件之显示数据记录 
学习ASP的万里长征就快到终点了：等把ASP的ADO组件搞定。当然这也是最重要的一步，几乎前面所有的学习都是为了这个最终的目的。OK，下面就来详细系统地来一一掌握，步步为营，各个击破。
一，拥有数据库可以这么说：静态页面和动态页面最大的区别就是采用了数据库。其中运用操作数据库主要是对数据库内容进行：显示、插入、修改、更新、查询和删除。这些方法当然也不是一口就能吃出来的，要慢慢感受咀嚼、理解消化。当然首先很重要的便是先拥有数据库了。
　一般而言，我们所说的数据库其实就是一个数据库文件，该文件是由一些数据库管理系统（DBMS）建立生成的。目前一般的DBMS也就是常用常听说的ACCESS，SQLSERVER，MYSQL，ORACLE。当然一般个人站点，小型企业采用ACCESS完全足够；稍微大些的就采用同样是Microsoft公司的SQL SERVER或者是MYSQL，值得注意的是MYSQL一般是和另外一种网络编程语言PHP完美结合的。当然更大型的就采用ORACLE了。呵呵，曾经在学习PB时还运用到SYBASE数据库，UNIX系统的Informix数据库……DBMS简直是多如牛毛-_-!话说过来，目前我们就直接使用ACCESS了：1，使用简单；2，入门掌握容易；3，实在没有比这个更适合初学的了。一切还得从实际操作开始。
1、打开ACCESS数据库，选择新建数据库，将其命名为cnbruce.mdb，并保存到一专门文件夹database中　　
2、在新建的数据库容器中双击“使用设计器创建表”，弹出的表1窗口中字段名称输入“cn_id”，数据类型选择“自动编号”，并选择上方工具栏中的钥匙按钮，将该字段设为主键。继续输入字段“cn_title”，数据类型选择“文本”；NEXT输入字段“cn_content”，数据类型选择“备注”；
PS：备注和一般类型文本最大的区别就是备注允许插入的字段值相对要多些，这在插入一些较长文章的时候尤其重要。
　　仍然输入字段“cn_author”，数据类型选择“文本”；并且切换到下面“常规”中的“允许空字符串”选择“是”。
PS：这表面允许cn_author字段的值可以是空的，这在当提交表单，某些信息不填写但要正确插入数据库时，显得很重要。
最后输入字段“cn_time”，数据类型选择“日期/时间”，继续切换到“常规”中的“默认值”输入“now()”函数，末了，我们将“表1”另存为“cnartile”

3，双击打开cnartile表，填写第一行：“cn_title”输入“test”，“cn_content”输入“this is a test”，“cn_author”输入“cnbruce”，时间已经自动添加。完成！关闭表，关闭数据库。

二，建立数据库连接OK，数据库已经建立完毕，并且已经填写了一行信息内容。那么现在需要的就是同过ASP将该行信息显示出来。要想显示，首先还是需要ASP与该数据库文件建立连接，具体怎么建立？往下看。
1，conn.asp：主要起的是连接并打开某数据库文件的功能。该文件建议单独存在，并且位置是和存放数据库的文件夹database处与同一物理层次。
<%　　db_path = "database/cnbruce.mdb"
Set conn= Server.CreateObject("ADODB.Connection")
connstr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="&Server.MapPath(db_path)　　conn.Open connstr　%>　
db_path = "database/cnbruce.mdb"，不用说，就是将数据库的相对路径赋到一个变量上，以方便下面继续调用。
Set conn= Server.CreateObject("ADODB.Connection")，和其它建立组件一样，建立了一个ADO连接，并用一对象conn来接受。
connstr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="&Server.MapPath(db_path)，很显然就是连接字符串了，其包括打开数据库的驱动方法OLEDB，和打开和哪个数据库的连接（即数据库的路径）。
需要再次提醒的是：无论是FSO对文件、文件夹的操作还是ADO对数据库的操作，对被操作文件的取得都是获得的绝对的物理地址，一般情况之下，采用Server.MapPath方法相对较好。
conn.Open connstr最后对象conn通过连接字符串connstr打开了数据库的连接。
三，显示数据库内容　建立了数据库，建立了和数据库的连接，下面水到渠成地就是将数据库中的内容通过ASP显示出来。
2，showit.asp　<!--#include file="conn.asp" -->
<%　Set rs = Server.CreateObject ("ADODB.Recordset")
sql = "Select * from cnarticle"
rs.Open sql,conn,1,1　%>　<%
if rs.EOF and rs.BOF then
   response.write ("暂时还没有文章")
else   Do Until rs.EOF
      response.write("文章标题是:"& rs("cn_title"))
      response.write("<br>文章作者是:"& rs("cn_author"))
      response.write("<br>文章加入时间是:"& rs("cn_time"))
      response.write("<br>文章内容是:"& rs("cn_content"))
      response.write("<hr>")      rs.MoveNext   Loop　end if　%>　<%
rs.close 　Set rs = Nothing　conn.close 　set conn=Nothing　%>
简单调试本页，不出任何意外，相信一定能将数据库中的信息显示出来了。 　下面就来具体一个一个解释来理解没行的含义：
1，<!--#include file="conn.asp" --> 没有任何争议，主要是调用conn.asp的所起的功效，这在解释conn.asp文件的时候已经明白。
2，Set rs = Server.CreateObject ("ADODB.Recordset") ADO组件除了Connection连接以外，还有Recordset绑定记录集（相信用过DW做ASP的人现在开始有些重回故里的感觉了）当然 rs 可以形象地想象成数据库表中的某一行。
3，sql = "Select * from cnarticle" 标准的SQL结构化查询语言。很简单：建立了数据库连接，也绑定了记录集，那具体需要哪些信息呢？也就是要筛选一些记录集合了，不过当前采用的是无任何条件，即可以提取所有。
4，rs.Open sql,conn,1,1 真正地打开通向数据库中记录集的大门，具体有关后面的参数可以从如下网址中获得。
5，if rs.EOF and rs.BOF then 该语句里面涉及到了rs.EOF 和 rs.BOF 以及两者的逻辑运算 and 。rs.EOF 表示到达数据库表中的最后一行，rs.BOF 表示到达数据库表中的第一行。整个语句可以理解为，如果当前数据库中的最后一行就是数据库表中第一行，那么可以肯定：当前数据库表中没有任何数据。
6，Do Until rs.EOF ... 
rs.MoveNext 　Loop
主要就是一个DO LOOP 循环语句了，其中循环的结束条件为：直到rs.EOF，即值得数据库表的最后一行。那么在这些条件满足的许可之内，就是来显示具体的信息了。
每次循环只能显示数据库表中的一行，如果要继续读取下行，那么 rs.MoveNext 功能真是如此。
7，rs("cn_title")等等 主要就是具体显示记录集中的哪个特定字段的信息值了。很是简单。
8，最后不要忘了释放资源空间关闭记录集连接，关闭数据库连接。
四一些特殊条件　有没有注意到，数据库表信息的显示一般是按照时间的先后排列的，也就经常提到的按时间的升序排列。需要注意：按时间升序，并不一定每个数据库表中都要有一个时间/日期类型的字段，只要存在一个自动编号的字段就可以了。因为该字段是永不重复，并且是依次增大的。因此，按时间升序其实就是按自动编号中号码数值的增加来进行排序的。
当然，问题的关键来了，那就是要按照时间的降序排列，即始终从最新的内容开始显示。那具体需要哪些手术呢？很简单，将连接字符串稍做修改。
由 sql = "Select * from cnarticle" 添加修改为
sql = "Select * from cnarticle order by cn_id desc" 
其中 order by cn_id 即通过cn_id字段，desc 即降序了。
2，有是时候，只需要提取最前或者最新的几条信息，那这个又具体如何操作呢？同样还是连接字符串的修改由 sql = "Select * from cnarticle order by cn_id desc" 添加修改为
sql = "Select top 3 * from cnarticle order by cn_id desc" 
其中 top 3 就表示提取最新的三条信息内容了。
　That's All. 现在一个文章系统、新闻系统或者留言本显示部分的精华内容你已不费吹灰之力搞定。留下你的是：文章的格式可能显示不对劲，比如回车、空格都不显示了，那么你就还要学会处理接受的数据库表的值（在ASP的几个练习中提到的）；文章不能老是打开数据库输入信息啊，那么你就要继续学会如何用ASP插入数据到库表；再有就是文章多了，一个页面看是不是很麻烦？那么你还要学会分页技术……
要搞的太多了，后面我会详细道来：）
ASP编程入门进阶（二十）：ADO组件之插入数据记录
简单的显示记录已经掌握，现在需要的就是通过ASP将信息内容插入到数据库中。
一、拥有数据库cnbruce.mdb
本数据库的作用就是用来被插入数据的，可以直接采用上节中已经建立的cnbruce.mdb文件，当然连接打开数据库的文件conn.asp也就顺利引用了。
二、建立输入插入信息的页面平台addit.html
本页的主要作用是：显示一些文本输入框以用来提供输入信息内容提交数据库。
1，addit.html

本页其实很简单，就是通过submit按钮将表单的信息内容提交到addit.asp页面去处理。
三、建立处理接受数据并插入数据库表的页面程序addit.asp
2，addit.asp　<!--#include file="conn.asp" -->　<%
whattitle=request.form("title")
whoauthor=request.form("author")
whatcontent=request.form("content")　%>　<%
Set rs = Server.CreateObject ("ADODB.Recordset")
sql = "Select * from cnarticle"
rs.Open sql,conn,3,2　%>　<%　rs.addnew
rs("cn_title")=whattitle　rs("cn_author")=whoauthor　rs("cn_content")=whatcontent
rs.update　%>　文章添加成功，<a href="showit.asp">浏览</a>　<%　rs.close 
Set rs = Nothing　conn.close 　set conn=Nothing　%>恩，接着就是来具体分析一下。
1，<!--#include file="conn.asp" --> 不用说，凡是要和数据库有联系的都要运用到该连接文件。
2，whattitle=request.form("title")之类 就是将上页表单中接受过来的值赋到一变量上，方便下面程序的调用。
3，rs.Open sql,conn,3,2 注意参数和显示数据库时采用的参数的不同。
4，rs.addnew 很简单也很显眼的一个声明：新建一个数据库记录集行。
5，rs("cn_title")=whattitle之类 即将接受的表单值对应到相关字段中。
6，rs.update 只是值和数据库字段的对应，完了后还要将对应的值上传提交到数据库表中去。
7，插入后可以跳转到showit.asp查看 需要说明，以后的ASP例题可能都是建立在前几节内容的基础之上完成的。
8，释放资源 是规矩，不要忘记。
　　那么，现在插入并显示数据库记录，对你来说完全是小菜一碟了。大体框架搭建完毕，下面就是具体的细化了。其中包括：客户端的表单检测，防止用户信息输入的遗漏；当然最好还是要加上服务器端的表单检测，由于客户端的某些原因（比如自行设计提交非检测的页面）基于安全考虑，一切还是依服务器端所接受信息为准。那下面就继续细化应用下了。
1，客户端检测 其实就是通过简单的脚本检测，这在初学ASP提到脚本的时候说到，下面将再次重复。加强的addit.html
<script laguage="javascript">
<!--　function form1_onsubmit()
{　if (document.form1.title.value=="")
    {　      alert("请输入文章标题")
      document.form1.title.focus()
      return false　     }
else if(document.form1.content.value=="")
    { 　      alert("请输入文章内容")
      document.form1.content.focus()
      return false     }　}　-->　</script>
<form action="addit.asp" method="post" name="form1" οnsubmit="return form1_onsubmit()">
Title:<input type="text" name="title"><br>
Author:<input type="text" name="author"><br>
Content:<br>
<textarea name="content" rows="8" cols="30"></textarea><br>
<input type="submit" value="Add">
<input type="reset" value="Reset">
</form>
2，服务器端检测 有人也许会问，既然有了客户端的检测，那还有多个服务器端的检测呢？原因很简单，比如仿照HTML表单提交页，自行设计一张去除了表单检测的页面。当点击提交，并且没有任何信息时，到达服务器端如没有任何防御则肯定会造成数据插入的失败。
加强的addit.asp　<!--#include file="conn.asp" -->　
<%　whattitle=trim(request.form("title"))
whoauthor=trim(request.form("author"))
whatcontent=trim(request.form("content"))　%>　
<%if whattitle="" then%>
<script language=vbs>
alert("请输入文章标题")
history.go(-1)</script>　<%end if%>
<%if whatcontent="" then%>
<script language=vbs>
alert("请输入文章标题")
history.go(-1)　</script>　<%end if%>　<%
Set rs = Server.CreateObject ("ADODB.Recordset")
sql = "Select * from cnarticle"
rs.Open sql,conn,3,2　%>　　<%
rs.addnew
rs("cn_title")=whattitle
rs("cn_author")=whoauthor
rs("cn_content")=whatcontent
rs.update　%>
文章添加成功，<a href="showit.asp">浏览</a>
<%　rs.close 　Set rs = Nothing　conn.close 　set conn=Nothing　%>
可以看出，就是添加了如下类似的判断。　<%if whattitle="" then%>
<script language=vbs>alert("请输入文章标题")　history.go(-1)　</script>　<%end if%>
　　很简单，如果接受过来的信息为空，则弹出警告框，并且确认后返回到上页即addit.html了。当然cn_author没有设置检测，因为当初设计该字段的接受值是允许为空的。
OK，总结一下，插入记录主要就是　rs.addnew　　rs("cn_title")=whattitle　　...　rs.update
很简单，先声明addnew，然后一一对应，再提交插入数据库。这是一种插入数据库的方法，下面来接触了解一下另外一种。需要注意，结构化的查询语言也就是SQL语句能够完成一些比较苛刻的数据库操作。当然，对于诸如提取、插入信息之流就更不在话下了。所以下面采用的插入记录的方法就是直接采用SQL语法完成。
修改了的addit.asp
<!--#include file="conn.asp" -->　<%
whattitle=request.form("title")
whoauthor=request.form("author")
whatcontent=request.form("content")　%>　<%
sql = "insert into cnarticle(cn_title,cn_author,cn_content) values(' "&whattitle&" ',' "&whoauthor&" ',' "&whatcontent&" ')"
conn.Execute(sql)　%>
文章添加成功，<a href="showit.asp">浏览</a>
<%　conn.close 　　　set conn=Nothing　%>
本程序中，你会发现只要一行的SQL语句，不需要建立Rescord记录集行，不需要声明addnew，不要执行update。直接通过conn.Execute(sql)来完成。
当然应用此种方法，若必填字段接受值为空时，同样能够插入记录。这和采用第一种会报
Microsoft JET Database Engine 错误 '80040e21' 
字段 'xxx.xxx' 不能是零长度的字符串。 具有很大的容错性。是程序的可读性还是方法的简便高效率就任君选择了。
ASP编程入门进阶（二十一）：ADO组件之分页程序 
应该来说，学会了如何插入记录，如何显示记录，那么现在简单的完整的文章系统、新闻系统和留言系统不成问题。那接着下面的问题就是：随着信息内容的不段增加，单独通过一张页面显示所有信息是不行也是很不理性的。所以，解决的办法就是采用分页技术。
1，rs.RecordCount　很显然，RecordCount就是用来显示数据库表中一共多少条记录的，也可以形象地说表中一共有多少行。经常用在分页中就是一共有N篇文章等总计的信息显示。
2，rs.PageSize
rs.PageSize也就是一页的大小，也就表示一张ASP页可以显示记录的条数。值是自己定义的，比如经常看到的每页显示N篇文章之类的信息。
3，rs.AbsolutePage 和 rs.pagecount　说到分页，一定不能不提到 rs.AbsolutePage 。记录集的AbsolutePage属性最主要的作用就是决定着当前显示的是第几页。它的值是有依据的，指定了rs.PageSize，那么rs.pagecount的信息值就是rs.RecordCount和rs.PageSize整除结果。比如：总信息记录rs.RecordCount共20条，每页显示条数rs.PageSize设为5条，那么页数rs.pagecount数就是20/5=4页次，而rs.AbsolutePage则就只能是第1页，第2页……第4页。
说到现在，弄个具体程序来调试一下。继续对showit.asp进行修改如下：
<!--#include file="conn.asp" -->
<%　Set rs = Server.CreateObject ("ADODB.Recordset")
sql = "Select * from cnarticle order by cn_id desc"
rs.Open sql,conn,1,1
%>　　<%　page=request.querystring("page")  'page值为接受值 
rs.PageSize = 2 '每页显示记录数
rs.AbsolutePage = Page '显示当前页等于接收的页数 %>　<% 
For i = 1 to rs.PageSize '利用for next 循环依次读出当前页的记录
if rs.EOF then　　　  Exit For  end if 
response.write("<br>文章内容是:"& rs("cn_content"))
rs.MoveNext　next%>　　<% 
rs.close 　Set rs = Nothing　　conn.close 　　set conn=nothing 　%>
HERE，你调试的前提就是数据库中的记录相对要大于4条，这样测试效果才明显；还有测试的方法就是在showit.asp后面添加?page=1或者?page=2等调试观察网页显示效果。
其实，说到底，显示数据库内容就是　<% 　For i = 1 to rs.PageSize
if rs.EOF then　　  Exit For 　 end if 
response.write("<br>文章内容是:"& rs("cn_content"))　　rs.MoveNext　next%>
起的作用，但想象一下：该程序应该都只能显示出2条信息（一直不变的2条信息）。但为什么加上?page=1和?page=2会显示不同的结果呢？……那绝对就是rs.AbsolutePage的作用了。这个搞清楚，相信分页的整体架构就有点眉目了。
<!--#include file="conn.asp" -->　<%
Set rs = Server.CreateObject ("ADODB.Recordset")
sql = "Select * from cnarticle"
rs.Open sql,conn,1,1　%>
<%filepath=request.servervariables("path_info")%>
<%　page=request.querystring("page")  'page值为接受值
rs.PageSize = 2 '每页显示记录数
if Not IsEmpty(page) then '如果page已经初始化...
    if Not IsNumeric(page) then '判断page值是否为数字
     page=1　   else    Page = cint(page) '接收page并化为数字型赋给page变量
    end if       if Page > rs.PageCount then '如果接收的页数大于总页数
        rs.AbsolutePage = rs.PageCount '设置当前显示页等于最后页        
    elseif Page <= 0 then '如果page小于等于0
        rs.AbsolutePage = 1 '设置当前显示页等于第一页
    else　        rs.AbsolutePage = Page '如果大于零,显示当前页等于接收的页数 
    end if　else　　rs.AbsolutePage=1
end if　Page = rs.AbsolutePage%>　<% 
For i = 1 to rs.PageSize '利用for next 循环依次读出当前页的记录
if rs.EOF then　  Exit For 　 end if 
  response.write("文章标题是:"& rs("cn_title"))
  response.write("<br>文章作者是:"& rs("cn_author"))
  response.write("<br>文章加入时间是:"& rs("cn_time"))
  response.write("<br>文章内容是:"& rs("cn_content"))
  response.write("<hr>")　  rs.MoveNext　Next　%>
<form action="<%=filepath%>" method="get">
<!--首先保证总页数不为1、不为0-->
<%if rs.pagecount<>1 and rs.pagecount<>0 then%>
<!--如果当前页数大于1，无论何时都应显示首页和上一页的连接-->
<%if page>1 then%>　    [<a Href="<%=filepath%>?Page=<% = 1%>">首页</a>]
    [<a Href="<%=filepath%>?Page=<% = page -1 %>">上一页</a>]
<!--如果当前页数大于1并且小于总页面数时，显示出尾页和下一页的连接-->
    <%if page<rs.pagecount then %>
    [<a Href="<%=filepath%>?Page=<% = page + 1%>">下一页</a>]
    [<a Href="<%=filepath%>?Page=<% = rs.PageCount%>">尾页</a>]
<!--如果当前页数大于1并且仍大于或等于总页面数时，不显示出尾页和下一页的连接-->     <%else%>    [下一页] [尾页]
    <%end if%>　<!--否则，当前页数不大于1，则只显示尾页和下一页的连接-->
<%else%>　 [首页] [上一页]
[<a Href="<%=filepath%>?Page=<% = page + 1%>">下一页</a>] 
[<a Href="<%=filepath%>?Page=<% = rs.PageCount%>">尾页</a>]
<%end if %>　<!--最终，总页数若为1、为0则没有任何连接-->
<%else%>　 [首页] [上一页] [下一页] [尾页]
<%end if%>　[页次:<font clor=red><b><%=page%></b></font>/<%=rs.PageCount%>]
[共<%=rs.RecordCount%>篇 <font color=red><b><%=rs.PageSize%></b></font>篇/页]
转到<input name="page" size=5 value="<%=page%>">页
<input type="submit" value="Enter">
</form>　<%　rs.close 　　Set rs = Nothing　　conn.close 　set conn=Nothing　%>
长长的分页代码，搞懂是真不易，平台引用起来还需要修改也是比较麻烦。能做成一个函数，下次调用起来就很方便了。
<%　function pagination(pagecount,pagesize,page,resultcount)
       Dim query, a, x, temp
       action = "http://" & Request.ServerVariables("HTTP_HOST") & Request.ServerVariables("SCRIPT_NAME")
       query = Split(Request.ServerVariables("QUERY_STRING"), "&")
       For Each x In query            a = Split(x, "=")
           If StrComp(a(0), "page", vbTextCompare) <> 0 Then
               temp = temp & a(0) & "=" & a(1) & "&"
           End If　       Next       
       Response.Write("<form method=get οnsubmit=""document.location = '" & action & "?" & temp & "Page='+this.page.value;return false;"">")              
       if page<=1 then        Response.Write ("[首页] [上一页] ")
       else       Response.Write("[<a href=" & action & "?" & temp & "Page=1>首页</a>] ")
              Response.Write("[<a href=" & action & "?" & temp & "Page=" & (Page-1) & ">上一页</a>] ")
       end if       if page>=pagecount then
              Response.Write ("[下一页] [尾页]")              
       else       Response.Write("[<a href=" & action & "?" & temp & "Page=" & (Page+1) & ">下一页</a>] ")
              Response.Write("[<a href=" & action & "?" & temp & "Page=" & pagecount & ">尾页</a>]")                     
       end if　Response.Write("[页次:<font color=red>" & page & "</font>/" & pageCount)       
       Response.Write("] [共" & resultcount & "条 <font color=red>"& pagesize & "</font>条/页]")
       Response.Write(" 转到" & "<input name=page size=4 value=" & page & ">" & "页<input type=submit value=go>") End function　%>
如要引用，则可以：<%call pagination(rs.PageCount,rs.pagesize,page,rs.RecordCount) %>
（完）