正则表达式及应用-CSDN博客

本文链接：https://blog.csdn.net/tiegang/article/details/1462894

"*@*.*"
="/w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*"
17种正则表达式

--------------------------------------------------------------------------------
March 25,2004
"^/d+$"　　//非负整数（正整数 + 0）
"^[0-9]*[1-9][0-9]*$"　　//正整数
"^((-/d+)|(0+))$"　　//非正整数（负整数 + 0）
"^-[0-9]*[1-9][0-9]*$"　　//负整数
"^-?/d+$"　　　　//整数
"^/d+(/./d+)?$"　　//非负浮点数（正浮点数 + 0）
"^(([0-9]+/.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*/.[0-9]+)|([0-9]*[1-9][0-9]*))$"　　//正浮点数
"^((-/d+(/./d+)?)|(0+(/.0+)?))$"　　//非正浮点数（负浮点数 + 0）
"^(-(([0-9]+/.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*/.[0-9]+)|([0-9]*[1-9][0-9]*)))$"　　//负浮点数
"^(-?/d+)(/./d+)?$"　　//浮点数
"^[A-Za-z]+$"　　//由26个英文字母组成的字符串
"^[A-Z]+$"　　//由26个英文字母的大写组成的字符串
"^[a-z]+$"　　//由26个英文字母的小写组成的字符串
"^[A-Za-z0-9]+$"　　//由数字和26个英文字母组成的字符串
"^/w+$"　　//由数字、26个英文字母或者下划线组成的字符串
"^[/w-]+(/.[/w-]+)*@[/w-]+(/.[/w-]+)+$"　　　　//email地址
(//b[a-zA-Z0-9])([a-zA-Z0-9//.//-_]){1,16}([a-zA-Z0-9])@([a-zA-Z0-9]([a-zA-Z0-9//-]){0,25})((//.[a-zA-Z0-9]([a-zA-Z0-9//-]){0,25}){1,3}$)

"^[a-zA-z]+://(/w+(-/w+)*)(/.(/w+(-/w+)*))*(/?/S*)?$"　　//url

----------------------------------------------------------------------------------
限定符

有时候不知道要匹配多少字符。为了能适应这种不确定性，正则表达式支持限定符的概念。这些限定符可以指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。

下表给出了各种限定符及其含义的说明：

字符描述

* 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。
* 等价于{0,}。

+ 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以
及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。

? 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do"
或 "does" 中的"do" 。? 等价于 {0,1}。

{n} n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob"
中的 'o'，但是能匹配 "food" 中的两个 o。

{n,}   n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中
        的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o
        {0,}' 则等价于 'o*'。

{n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。
刘， "o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价
于 'o?'。请注意在逗号和两个数之间不能有空格。

对一个很大的输入文档而言，章节数很轻易就超过九章，因此需要有一种方法来处理两位数或者三位数的章节号。限定符就提供了这个功能。下面的Visual Basic Scripting Edition 正则表达式可以匹配具有任何位数的章节标题：

/Chapter [1-9][0-9]*/

下面的 VBScript 正则表达式执行同样的匹配：

"Chapter [1-9][0-9]*"

请注意限定符出现在范围表达式之后。因此，它将应用于所包含的整个范围表达式，在本例中，只指定了从 0 到 9 的数字。

这里没有使用 '+' 限定符，因为第二位或后续位置上并不一定需要一个数字。同样也没有使用 '?' 字符，因为这将把章节数限制为只有两位数字。在 'Chapter' 和空格字符之后至少要匹配一个数字。

如果已知章节数限制只有99 章，则可以使用下面的 Visual Basic Scripting Edition 表达式来指定至少有一位数字，但不超过两个数字。

/Chapter [0-9]{1,2}/

对 VBScript 可以使用下述正则表达式：

"Chapter [0-9]{1,2}"

上述表达式的缺点是如果有一个章节号大于 99，它仍只会匹配前两位数字。另一个缺点是某些人可以创建一个 Chapter 0，而且仍能匹配。一个更好的用来匹配两位数的 Visual Basic Scripting Edition 表达式如下：

/Chapter [1-9][0-9]?/

或者

/Chapter [1-9][0-9]{0,1}/

对 VBScript 而言，下述表达式与上面等价：

"Chapter [1-9][0-9]?"

或者

"Chapter [1-9][0-9]{0,1}"

'*'、 '+'和 '?' 限定符都称之为贪婪的，也就是说，他们尽可能多地匹配文字。有时这根本就不是所希望发生的情况。有时则正好希望最小匹配。

例如，你可能要搜索一个 HTML 文档来查找一处包含在 H1 标记中的章节标题。在文档中该文字可能具有如下形式：

<H1>Chapter 1 – Introduction to Regular Expressions</H1>

下面的表达式匹配从开始的小于号 (<) 到 H1 标记结束处的大于号之间的所有内容。

/<.*>/

VBScript 的正则表达式为：

"<.*>"

如果所要匹配的就是开始的 H1 标记，则下述非贪婪地表达式就只匹配 <H1>。

/<.*?>/

或者

"<.*?>"

通过在 '*'、 '+' 或 '?' 限定符后放置 '?'，该表达式就从贪婪匹配转为了非贪婪或最小匹配。

------------------------------------------------------------------------------------------
正则表达式练习器

--------------------------------------------------------------------------------

正则表达式的用途很广泛，但要熟练掌握就不是一件容易的事情了。为此，我编写了这个练习器用来帮助学习。
请多指教！

*********将以下代码复制到 RegExp.htm 即可 **********
<HTML>
<HEAD>
<TITLE>正则表达式练习器</TITLE>
<meta name = **** e-mail:****>
<script language="JavaScript">
function OnMove() {
window.status = "("+window.event.clientX+","+window.event.clientY+")" + " :: "+document.location
}
</script>

<SCRIPT LANGUAGE="JavaScript1.2">
var re = new RegExp() //建立正则表达式对象
var nextpoint = 0      //匹配时的偏移量
//设置正则表达式
function setPattern(form) {
var mode
if(form.chkmode.checked) mode = "gi" //i:不分大小写 g:全局，好象没什么作用
else mode = "g"
re.compile(form.regexp.value,mode)
nextpoint = 0
form.reglist.value = ""
}
//检查是否有匹配
function findIt(form) {
setPattern(form)
var input = form.main.value
if (input.search(re) != -1) {
    form.output[0].checked = true
} else {
    form.output[1].checked = true
}
}
//检查匹配位置
function locateIt(form) {
setPattern(form)
var input = form.main.value
form.offset.value = input.search(re)
}
//检查所有的匹配情况
function execIt(form) {
if(nextpoint == 0 || ! form.scankmode.checked) {
    findIt(form)
    form.reglist.value = ""
}
var key = true
if(form.scankmode.checked) key = false
do {
    var input = form.main.value
    var matchArray = re.exec(input.substr(nextpoint))
    if(matchArray) {
      for(var i=1;i<matchArray.length;i++)
        matchArray = "$"+i+":"+matchArray
      form.reglist.value = (nextpoint+matchArray.index)+" => " + matchArray[0] +"n"+form.reglist.value
      form.matchlist.value = "$0:"+matchArray.join("n")
      nextpoint = nextpoint + matchArray.index + matchArray[0].length
    }else {
      if(!key)
        form.reglist.value = "没有找到n" + form.reglist.value
      form.matchlist.value = " "
      nextpoint = 0
      key = false
    }
}while (key)
}
//设置当前使用的正则表达式
function setregexp(n) {
var s = document.all.regexplist.value.split("rn")
document.all.regexp.value = s[n*2-1] //.replace("r","")
nextpoint = 0
}

//定义选择监视
var isNav = (navigator.appName == "Netscape")
function showSelection() {
if (isNav) {
    var theText = document.getSelection()
} else {
    var theText = document.selection.createRange().text
}
if(theText.length>0 && document.all.selechkmode.checked)
    document.all.regexp.value = theText
}
if (isNav) {
    document.captureEvents(Event.MOUSEUP)
}
document.onmouseup = showSelection
</SCRIPT>

</HEAD>
<BODY style="font-size=9pt;" OnMouseMove=OnMove()>
<FORM><table width=100% cellspacing=0 cellpadding=0><tr><td><font color=red>正规表达式练习器</font></td><td align=right><a href=mailto:czjsz_ah@stats.gov.cn>czjsz_ah@stats.gov.cn</a></td></tr></table>
<table width=100% broder=1 frame=above rules=none style="font-size:9pt;">
<tr><td width=50% valign=top>
输入一些被寻找的正文:<BR>
<TEXTAREA NAME="main" COLS=58 ROWS=5 WRAP="virtual" style="font-size:9pt;">
09-11-2001 09/11/2001 czjsz_ah@stats.gov.cn
asdff 12345 196.168.1.3 www.sohu.com ftp://www.chinaasp.com 2001.9.11 http://www.active.com.cn/club/bbs/bbsView.asp http://www.163.com/inden.htm
</TEXTAREA><BR>
进行匹配的正规表达式:　　忽略大小写<INPUT TYPE="checkbox" NAME="chkmode" checked style="font-size:8pt;height:18px"><BR>
<TEXTAREA NAME="regexp" COLS=51 ROWS=5 style="font-size:9pt;"></TEXTAREA>
<INPUT TYPE="button" VALUE="清除" onClick="this.form.regexp.value=''" style="font-size:8pt;height:18px"><BR>
<INPUT TYPE="button" VALUE="能找到吗?[regexObject.test(string)]" style="font-size:8pt;width:70%;height:18px" onClick="findIt(this.form)">
<INPUT TYPE="radio" NAME="output" style="font-size:8pt;height:18px">Yes
<INPUT TYPE="radio" NAME="output" style="font-size:8pt;height:18px">No <BR>
<INPUT TYPE="button" VALUE="在哪里?[string.search(regexObject)]" style="font-size:8pt;width:70%;height:18px" onClick="locateIt(this.form)">
<INPUT TYPE="text" NAME="offset" SIZE=4 style="font-size:8pt;height:18px">
</td>
<td valign=top>
测试用正则表达式列表:　
使用第<input type=text name=num size=2 value=1 style="font-size:8pt;height:18px">个<input type=button value=Go onClick=setregexp(this.form.num.value) style="font-size:8pt;height:18px">
　　　　允许复制<INPUT TYPE="checkbox" NAME="selechkmode" style="font-size:8pt;height:18px">
<textarea NAME="regexplist" cols=58 rows=14 wrap=off style="font-size:9pt;">
1.检查日期:
(1[0-2]|0?[1-9])[-./](0?[1-9]|[12][0-9]|3[01])[-./](dddd))
2.检查数字:
([-+]?[0-9]+.?[0-9]+)
3.检查URL:
((http|ftp)://)?(((([d]+.)+){3}[d]+(/[w./]+)?)|([a-z]w*((.w+)+){2,})([/][w.~]*)*)
4.检查E-mail
w+@((w+[.]?)+)
</textarea>
</td></tr>
<tr><td valign=bottom>
<INPUT TYPE="button" VALUE="有哪些?[regexObject.exec(string)]" style="font-size:8pt;width:70%;height:18px" onClick="execIt(this.form)">
　　单步<INPUT TYPE="checkbox" NAME="scankmode" style="font-size:8pt;height:18px"><BR>
<TEXTAREA NAME="reglist" COLS=58 ROWS=8 style="font-size:9pt;"></TEXTAREA>
</td>
<td valign=bottom>
匹配到的成分:(单步时可见)
<TEXTAREA NAME="matchlist" COLS=58 ROWS=8 style="font-size:9pt;"></TEXTAREA>
</td></tr></table></FORM>
<script>
setregexp(1)
</script>
</BODY>
</HTML>

对正则表达式练习器的改进

覆盖原execIt函数
修改后的execIt函数允许对多个正则表达式进行匹配(每个正则表达式一行)，并对每一个匹配成分显示出是第几个正则表达式匹配的。
这可视为语法分析的雏形，只要对匹配产生相应的动作。

function execIt(form) {
var mode
if(form.chkmode.checked) mode = "gi"
else mode = "g"
var regexpArray = form.regexp.value.split("rn") //获取正则表达式到数组

if(nextpoint == 0) form.reglist.value = ""
var key = true
if(form.scankmode.checked) key = false
else nextpoint = 0
do {
    var offs = 9999999999
    var pos = -1
    var input = form.main.value.substr(nextpoint)
    //对每个正则表达式进行匹配
    for(var i=0;i<regexpArray.length;i++) {
      re.compile(regexpArray,mode)
      var matchArray = re.exec(input)
      if(matchArray) {
        if(offs > matchArray.index) {
          offs = matchArray.index
          pos = i //保存距离起始位子最近的匹配
        }
      }
    }
    if(pos>=0) {
      re.compile(regexpArray[pos],mode)
      var matchArray = re.exec(input)
      for(var i=1;i<matchArray.length;i++)
        matchArray = "$"+i+":"+matchArray
      form.reglist.value = "["+(pos+1)+"]"+(nextpoint+matchArray.index)+" => " + matchArray[0] +"n"+form.reglist.value
      form.matchlist.value = "$0:"+matchArray.join("n")
      nextpoint = nextpoint + matchArray.index + matchArray[0].length
    }else {
      if(!key)
        form.reglist.value = "没有找到n" + form.reglist.value
      form.matchlist.value = " "
      nextpoint = 0
      key = false
    }
}while(key)
}

用正则表达式突出显示字符串中查询到的单词的函数

--------------------------------------------------------------------------------

圧(Windows Script 5.丵谋謃郕輚?
Function BoldWord(strContent,word)
    dim objRegExp
    Set objRegExp=new RegExp
    objRegExp.IgnoreCase =true
    objRegExp.Global=True

objRegExp.Pattern="(" & word & ")"
strContent=objRegExp.Replace(strContent,"<font color=""#FF0000"">$1</font>" )

Set objRegExp=Nothing
BoldWord=strContent
End Function

一个新版本的ubb转化程序

--------------------------------------------------------------------------------

记得以前贴过一个ubb代码转换为html格式的代码，前几天读ubb的源代码。所以有了这个新的版本。注意，这个版本可能还不能正常使用，详细见注。

这段代码将用户输入的ubb代码转化为html格式，注意，需要Script Engine 5.0的支持(使
用了RegExp对象)

注：pattern中使用()将知道regexp记忆搜索到的值，$1是第一个()，其余类推。但$2的
语法并不被5.0版本的vbscript.dll所支持，我检查了自己机器上的版本（安装过ie 5.5)，
发现vbscript.dll的版本为5.50.4629，最后修改日期为12月25日。该版本支持$1之类的语
法，这个简单的改进使regexp的功能逐渐与perl的正则表达式靠近

function UBBCode(strContent)

dim objRegExp
Set objRegExp=new RegExp
objRegExp.IgnoreCase =true
objRegExp.Global=True
'url
objRegExp.Pattern="([URL])(http://S+?)([/URL])"
strContent= objRegExp.Replace(strContent,"<A HREF=""$2"" TARGET=_blank>$2</A>")
objRegExp.Pattern="([URL])(S+?)([/URL])"
strContent= objRegExp.Replace(strContent,"<A HREF=""http://$2"" TARGET=_blank>$2</A>")

'email
objRegExp.Pattern="([EMAIL])(S+@S+?)([/EMAIL])"
strContent= objRegExp.Replace(strContent,"<A HREF=""mailto:$2"">$2</A>")

objRegExp.Pattern="([IMG])(S+?)([/IMG])"
strContent=objRegExp.Replace(strContent,"<IMG SRC=""$2"">")

objRegExp.Pattern="([QUOTE])(.+?)([/QUOTE])"
strContent=objRegExp.Replace(strContent,"<BLOCKQUOTE><font size=1
face=""Verdana, Arial"">quote:</font><HR>$2<HR></BLOCKQUOTE>")

objRegExp.Pattern="([i])(.+?)([/i])"
strContent=objRegExp.Replace(strContent,"<i>$2</i>")

objRegExp.Pattern="([b])(.+?)([/b])"
strContent=objRegExp.Replace(strContent,"<b>$2</b>")
set objRegExp=Nothing
UBBCode=strContent

end function

原版的转化程序，摘自freeware版本的ubb论坛，可到 http://www.ultimatebb.com/ 下载(Perl CGI方式)

sub UBBCode {

my $ThePost = shift;
$ThePost =~ s/([URL])(http://S+?)([/URL])/ <A HREF="$2"
TARGET=_blank>$2</A> /isg;

$ThePost =~ s/([URL])(S+?)([/URL])/ <A HREF="http://$2"
TARGET=_blank>$2</A> /isg;

$ThePost =~ s/([EMAIL])(S+@S+?)([/EMAIL])/ <A
HREF="mailto:$2">$2</A> /isg;

if (($UBBImages eq "ON") && ($OverrideImages ne "yes")) {
$ThePost =~ s/([IMG])(S+?)([/IMG])/ <IMG SRC="$2"> /isg;
}

$ThePost =~ s/([QUOTE])(.+?)([/QUOTE])/ <BLOCKQUOTE><font size="1"
face="Verdana, Arial">quote:</font><HR>$2<HR></BLOCKQUOTE>/isg;

$ThePost =~ s/([i])(.+?)([/i])/<i>$2</i>/isg;

$ThePost =~ s/([b])(.+?)([/b])/<b>$2</b>/isg;

return ($ThePost);

}

学习Asp的同志，不要放弃对CGI的学习，特别是一些老外的CGI程序，看后对我们的asp编程会有很大的启发

一个功能更强大的函数，也是用正则表达式写的

--------------------------------------------------------------------------------

<%
Option Explicit

Function stripHTML(strtext)
dim arysplit,i,j, strOutput
arysplit=split(strtext,"<")

if len(arysplit(0))>0 then j=1 else j=0

for i=j to ubound(arysplit)
     if instr(arysplit(i),">") then
       arysplit(i)=mid(arysplit(i),instr(arysplit(i),">")+1)
     else
       arysplit(i)="<" & arysplit(i)
     end if
next

strOutput = join(arysplit, "")
strOutput = mid(strOutput, 2-j)
strOutput = replace(strOutput,">",">")
strOutput = replace(strOutput,"<","<")

stripHTML = strOutput
End Function

<form method="post" id=form1 name=form1>
<b>Enter an HTML String:</b><br>
<textarea name="txtHTML" cols="50" rows="8" wrap="virtual"><%=Request("txtHTML")%></textarea>
<p>
<input type="submit" value="Strip HTML Tags!" id=submit1 name=submit1>
</form>

<% if Len(Request("txtHTML")) > 0 then %>
    <p><hr><p>
    <b><u>View of string <i>with no</i> HTML stripping:</u></b><br>
    <xmp>
    <%=Request("txtHTML")%>
    </xmp><p>
    <b><u>View of string <i>with</i> HTML stripping:</u></b><br>
    <pre>
    <%=StripHTML(Request("txtHTML"))%>
    </pre>
<% End If %>

用正则表达式写的HTML分离函数

--------------------------------------------------------------------------------

存成.asp文件，执行，你用ASPHTTP抓内容的时候用这个很爽，当然自己要改进一下了

<%
Option Explicit

Function stripHTML(strHTML)
'Strips the HTML tags from strHTML

Dim objRegExp, strOutput
Set objRegExp = New Regexp

objRegExp.IgnoreCase = True
objRegExp.Global = True
objRegExp.Pattern = "<.+?>"

'Replace all HTML tag matches with the empty string
strOutput = objRegExp.Replace(strHTML, "")

'Replace all < and > with < and >
strOutput = Replace(strOutput, "<", "<")
strOutput = Replace(strOutput, ">", ">")

stripHTML = strOutput 'Return the value of strOutput

Set objRegExp = Nothing
End Function

--------------------------------------------------------------------------------
　　一、正则表达式概述
　　二、正则表达式在VBScript中的应用
　　三、正则表达式在VavaScript中的应用
　　四、示例
　　五、总结

　　一、正则表达式概述
　　如果原来没有使用过正则表达式，那么可能对这个术语和概念会不太熟悉。不过，它们并不是您想象的那么新奇。
　　请回想一下在硬盘上是如何查找文件的。您肯定会使用 ? 和 * 字符来帮助查找您正寻找的文件。? 字符匹配文件名中的单个字符，而 * 则匹配一个或多个字符。一个如 'data?.dat' 的模式可以找到下述文件：data1.dat、data2.dat等等。如果使用 * 字符代替 ? 字符，则将扩大找到的文件数量。'data*.dat' 可以匹配下述所有文件名：data.dat、data1.dat、data12.dat等等，尽管这种搜索文件的方法肯定很有用，但也十分有限。? 和 * 通配符的有限能力可以使你对正则表达式能做什么有一个概念，不过正则表达式的功能更强大，也更灵活。
　　在我们编写ASP程序时，经常会判断一个字符串的有效性，如；一个串是否是数字、是否是有效的Email地址等等。如果不使用正则表达式，那么判断的程序会很长，并且容易出错，如果使用正则表达式，这些判断就是一件很轻松的工作了。后面我们将介绍如何判断数字和Email地址的有效性。
　　在典型的搜索和替换操作中，必须提供要查找的确切文字。这种技术对于静态文本中的简单搜索和替换任务可能足够了，但是由于它缺乏灵活性，因此在搜索动态文本时就有困难了，甚至是不可能的。
　　使用正则表达式，能完成些什么事情呢？
　　测试字符串的某个模式。例如，可以对一个输入字符串进行测试，看在该字符串是否存在一个电话号码模式或一个信用卡号码模式。这称为数据有效性验证。
　　替换文本。可以在文档中使用一个正则表达式来标识特定文字，然后可以全部将其删除，或者替换为别的文字。
　　根据模式匹配从字符串中提取一个子字符串。可以用来在文本或输入字段中查找特定文字。
　　例如，如果需要搜索整个 web 站点来删除某些过时的材料并替换某些HTML 格式化标记，则可以使用正则表达式对每个文件进行测试，看在该文件中是否存在所要查找的材料或 HTML 格式化标记。用这个方法，就可以将受影响的文件范围缩小到包含要删除或更改的材料的那些文件。然后可以使用正则表达式来删除过时的材料，最后，可以再次使用正则表达式来查找并替换那些需要替换的标记。
　　那么，正则表达式语法的语法是如何呢？
　　一个正则表达式就是由普通字符(例如字符 a 到 z)以及特殊字符(称为元字符)组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
　　这里有一些可能会遇到的正则表达式示例：
　　/^[ t]*$/ "^[ t]*$" 匹配一个空白行。
　　/d{2}-d{5}/ "d{2}-d{5}" 验证一个ID 号码是否由一个2位数字，一个连字符以及一个5位数字组成。
　　/<(.*)>.*</1>/ "<(.*)>.*</1>" 匹配一个 HTML 标记。

　　二、正则表达式在VBScript中的应用
　　VBScript使用RegExp对象、Matches集合以及Match对象提供正则表达式支持功能。我们还是先看一个例子。
<%
Function RegExpTest(patrn, strng)
Dim regEx, Match, Matches 　　'建立变量。
Set regEx = New RegExp 　　'建立正则表达式。
regEx.Pattern = patrn　　'设置模式。
regEx.IgnoreCase = True 　　'设置是否区分字符大小写。
regEx.Global = True 　　'设置全局可用性。
Set Matches = regEx.Execute(strng)　　'执行搜索。
For Each Match in Matches　　'遍历匹配集合。
    RetStr = RetStr & "Match found at position "
    RetStr = RetStr & Match.FirstIndex & ". Match Value is '"
    RetStr = RetStr & Match.Value & "'." & "<BR>"
Next
RegExpTest = RetStr
End Function
response.write RegExpTest("[ij]s.", "IS1 Js2 IS3 is4")
%>
在这个例子中，我们查找字符串中有无is或者js这两个词，忽略大小写。运行的结果如下：
Match found at position 0. Match Value is 'IS1'.
Match found at position 4. Match Value is 'Js2'.
Match found at position 8. Match Value is 'IS3'.
Match found at position 12. Match Value is 'is4'.
    下面我们就介绍这三个对象和集合。
    　　1、RegExp对象是最重要的一个对象，它有几个属性，其中：
　　○Global 属性，设置或返回一个 Boolean 值，该值指明在整个搜索字符串时模式是全部匹配还是只匹配第一个。如果搜索应用于整个字符串，Global 属性的值为 True，否则其值为 False。默认的设置为 False。
　　○IgnoreCase 属性，设置或返回一个Boolean值，指明模式搜索是否区分大小写。如果搜索是区分大小写的，则 IgnoreCase 属性为 False；否则为 True。缺省值为 False。
　　○Pattern 属性，设置或返回被搜索的正则表达式模式。必选项。总是一个 RegExp 对象变量。
    　　2、Match 对象
　　匹配搜索的结果是存放在Match对象中，提供了对正则表达式匹配的只读属性的访问。 Match 对象只能通过 RegExp 对象的 Execute 方法来创建，该方法实际上返回了 Match 对象的集合。所有的 Match 对象属性都是只读的。在执行正则表达式时，可能产生零个或多个 Match 对象。每个 Match 对象提供了被正则表达式搜索找到的字符串的访问、字符串的长度，以及找到匹配的索引位置等。
　　○FirstIndex 属性，返回在搜索字符串中匹配的位置。FirstIndex 属性使用从零起算的偏移量，该偏移量是相对于搜索字符串的起始位置而言的。换言之，字符串中的第一个字符被标识为字符 0
　　○Length 属性，返回在字符串搜索中找到的匹配的长度。
　　○Value 属性，返回在一个搜索字符串中找到的匹配的值或文本。
　　3、Matches 集合
　　正则表达式 Match 对象的集合。Matches 集合中包含若干独立的 Match 对象，只能使用 RegExp 对象的 Execute 方法来创建之。与独立的 Match 对象属性相同，Matches `集合的一个属性是只读的。在执行正则表达式时，可能产生零个或多个 Match 对象。每个 Match 对象都提供了与正则表达式匹配的字符串的访问入口、字符串的长度，以及标识匹配位置的索引。
　　学习了这三个对象和集合，如何应用于字符串的判断和替换呢？regExp对象的三个方法正好解决了这个问题，它们是Replace方法、Test方法和Execute方法。
　　1、Replace 方法
　　替换在正则表达式查找中找到的文本。我们还是先看个例子：下面的例子说明了 Replace 方法的用法。
<%
Function ReplaceTest(patrn, replStr)
Dim regEx, str1                                    ' 建立变量。
str1 = "The quick brown fox jumped over the lazy dog."
Set regEx = New RegExp                      ' 建立正则表达式。
regEx.Pattern = patrn                             ' 设置模式。
regEx.IgnoreCase = True                      ' 设置是否区分大小写。
ReplaceTest = regEx.Replace(str1, replStr)    ' 作替换。
End Function
Response.write ReplaceTest("fox", "cat") & "<BR>"            ' 将 'fox' 替换为 'cat'。
Response.write ReplaceTest("(S+)(s+)(S+)", "$3$2$1")        ' 交换词对.
%>
　　2、Test 方法
　　对指定的字符串执行一个正则表达式搜索，并返回一个 Boolean 值指示是否找到匹配的模式。正则表达式搜索的实际模式是通过RegExp对象的Pattern属性来设置的。RegExp.Global属性对Test方法没有影响。
　　如果找到了匹配的模式，Test方法返回True；否则返回False。下面的代码说明了Test 方法的用法。
<%
Function RegExpTest(patrn, strng)
Dim regEx, retVal                 ' 建立变量。
Set regEx = New RegExp         ' 建立正则表达式。
regEx.Pattern = patrn                 ' 设置模式。
regEx.IgnoreCase = False         ' 设置是否区分大小写。
retVal = regEx.Test(strng)         ' 执行搜索测试。
If retVal Then
    RegExpTest = "找到一个或多个匹配。"
Else
    RegExpTest = "未找到匹配。"
End If
End Function
Response.write RegExpTest("is.", "IS1 is2 IS3 is4")
%>
　　3、Execute 方法
　　对指定的字符串执行正则表达式搜索。正则表达式搜索的设计模式是通过 RegExp 对象的 Pattern 来设置的。
　　Execute 方法返回一个 Matches 集合，其中包含了在 string 中找到的每一个匹配的 Match 对象。如果未找到匹配，Execute 将返回空的 Matches 集合。

　　三、JavaScript中正则表达式的使用
　　在JavaScript 1.2版以后，JavaScript也支持正则表达式。
　　1、replace
　　replace在一个字符串中通过正则表达式查找替换相应的内容。replace并不改变原来的字符串，只是重新生成了一个新的字符串。如果需要执行全局查找或忽略大小写，那么在正则表达式的最后添加g和i。
例：
<SCRIPT>
re = /apples/gi;
str = "Apples are round, and apples are juicy.";
newstr=str.replace(re, "oranges");
document.write(newstr)
</SCRIPT>
结果是："oranges are round, and oranges are juicy."
例：
<SCRIPT>
str = "Twas the night before Xmas...";
newstr=str.replace(/xmas/i, "Christmas");
document.write(newstr)
</SCRIPT>
结果是："Twas the night before Christmas..."
例：
<SCRIPT>
re = /(w+)s(w+)/;str = "John Smith";
newstr = str.replace(re, "$2, $1");
document.write(newstr)
</SCRIPT>
结果是："Smith, John".
　　2、search
    search通过正则表达式查找相应的字符串，只是判断有无匹配的字符串。如果查找成功，search返回匹配串的位置，否则返回-1。
　　　　　　　　　search(regexp)
<SCRIPT>
function testinput(re, str){
   if (str.search(re) != -1)
      midstring = " contains ";
   else
       midstring = " does not contain ";
   document.write (str + midstring + re.source);
}
testinput(/^[1-9]/i,"123")
</SCRIPT>
　　3、match
　　match方法执行全局查找，查找结果存放在一个数组里。
例一：
<SCRIPT>
str = "For more information, see Chapter 3.4.5.1";
re = /(chapter d+(.d)*)/i;
found = str.match(re);
document.write(found);
</SCRIPT>
显示结果：Chapter 3.4.5.1,Chapter 3.4.5.1,.1
例二：
<SCRIPT>
str = "abcDdcba";
newArray = str.match(/d/gi);
document.write(newArray);
</SCRIPT>
显示结果D, d.

　　四、示例
1 、判断数字的正确性
<%@ Language=VBScript %>
<script language="javascript" runat="server">
       function isNumeric(strNumber) {
              return (strNumber.search(/^(-|+)?d+(.d+)?$/) != -1);
       }
       function isUnsignedNumeric(strNumber) {
              return (strNumber.search(/^d+(.d+)?$/) != -1);
       }
       function isInteger(strInteger) {
              return (strInteger.search(/^(-|+)?d+$/) != -1);
       }
       function isUnsignedInteger(strInteger) {
              return (strInteger.search(/^d+$/) != -1);
       }
</script>
<HTML>
       <BODY>
              <b>判断数字的正确性</b>
<%
Dim strTemp
strTemp = CStr(Request.Form("inputstring"))
If strTemp = "" Then strTemp = "0"
%>
<TABLE BORDER="1" CELLPADDING="4" CELLSPACING="2">
       <TR>
              <TD ALIGN="right"><B>原始字符串</B></TD>
              <TD><%= strTemp %></TD>
       </TR>
       <TR>
              <TD ALIGN="right"><B>数字</B></TD>
              <TD><%=isNumeric(strTemp)%></TD>
       </TR>
       <TR>
              <TD ALIGN="right"><B>非负数字</B></TD>
              <TD><%=isUnsignedNumeric(strTemp)%></TD>
       </TR>
       <TR>
              <TD ALIGN="right"><B>整数</B></TD>
              <TD><%=isInteger(strTemp)%></TD>
       </TR>
       <TR>
              <TD ALIGN="right"><B>非负整数()</B></TD>
              <TD><%=isUnsignedInteger(strTemp)%></TD>
       </TR>
</TABLE>
<FORM ACTION="<%=Request.ServerVariables("SCRIPT_NAME")%>" METHOD="post">
       请输入一个数字:<BR>
       <INPUT TYPE="text" NAME="inputstring" SIZE="50"></INPUT><BR>
       <INPUT TYPE="submit" Value="提交"></INPUT><BR>
</FORM>
</BODY>
</HTML>
2、判断Email地址的正确性
<%
Function isemail(strng)
       isemail = false
       Dim regEx, Match
       Set regEx = New RegExp
       regEx.Pattern = "^w+((-w+)|(.w+))*@[A-Za-z0-9]+((.|-)[A-Za-z0-9]+)*.[A-Za-z0-9]+$"
       regEx.IgnoreCase = True
       Set Match = regEx.Execute(strng)
if match.count then isemail= true
End Function
%>

ASP中正则表达式的应用（二）

--------------------------------------------------------------------------------
　　五、总结
　　上面我们介绍了正则表达式的基本概念，以及在VBScript和JavaScript中如何使用正则表达式，同时，通过一些实例让大家有了感性的认识。正则表达式的应用范围很广，能为大家解决很多实际中的问题。本文介绍的内容只是一些初步的知识，还有很多语法规则需要大家继续学习，在实践中发现问题，解决问题。返回顶部

　　　　　　　　　　　　　怎么实现数据记录的分页显示(作者：DarkMan)

怎么实现数据记录的分页显示 (1)

通过Recordset的GetRows方法，可以实现数据记录的分页显示。下面是一个完整的例子：
<%@ Language = VBSCRIPT %>
<% Option Explicit %>
<%
Dim iStart, iOffset
iStart = Request("Start")
iOffset = Request("Offset")

if Not IsNumeric(iStart) or Len(iStart) = 0 then
　　iStart = 0
else
　　iStart = CInt(iStart)
end if

if Not IsNumeric(iOffset) or Len(iOffset) = 0 then
　　iOffset = 10
else
　　iOffset = Cint(iOffset)
end if

Response.Write "察看 " & iOffset & " 个记录从 " & iStart & "开始 <BR>"

Dim objConn, objRS
Set objConn = Server.CreateObject("ADODB.Connection")
objConn.Open "Provider=SQLOLEDB.1;Data Source=(local);uid=sa;pwd=;Initial 　　　Catalog=pubs"

Set objRS = Server.CreateObject("ADODB.Recordset")
objRS.Open "SELECT * FROM Authors", objConn

Dim aResults
aResults = objRS.GetRows

objRS.Close
Set objRS = Nothing

objConn.Close
Set objConn = Nothing

Dim iRows, iCols, iRowLoop, iColLoop, iStop
iRows = UBound(aResults, 2)
iCols = UBound(aResults, 1)

If iRows > (iOffset + iStart) Then
　　iStop = iOffset + iStart - 1
Else
　　iStop = iRows
End If

For iRowLoop = iStart to iStop
    　　For iColLoop = 0 to iCols
      　Response.Write aResults(iColLoop, iRowLoop) & " "
    　Next
    　　Response.Write "<BR>"
　Next

Response.Write "<P>"
if iStart > 0 then
    '显示“前 10个”连接
    　　Response.Write "<A HREF=""paging.asp?Start=" & iStart-iOffset & _
                   　"&Offset=" & iOffset & """>前 " & iOffset & "</A>"
　end if

if iStop < iRows then
    '显示“后 10个”连接
    　Response.Write " <A HREF=""paging.asp?Start=" & iStart+iOffset & _
                   　　"&Offset=" & iOffset & """>后 " & iOffset & "</A>"
end if
%>

怎么实现数据的分页显示(2)
这里介绍另外一种分页显示的方法，是通过 MS SQL的存储过程。本方法不适用于Access数据库。
假设我们要对数据表MyTable的数据实现分页显示，首先写一个存储过程如下：
CREATE PROCEDURE sp_PagedItems
       　(
        　　@Page int,
        　　@RecsPerPage int
       　　)
　　AS

　　-- 加快表的插入速度
　　SET NOCOUNT ON

　　-- 开始记录号
　　DECLARE @RecCount int
　　SELECT @RecCount = @RecsPerPage * @Page + 1

　　--创建临时表
　　CREATE TABLE #TempItems
　　(
       　　ID int IDENTITY,
       　　Name varchar(50),
       　　Price currency
　)

　　-- 准备临时表
　　INSERT INTO #TempItems (Name, Price)
　　SELECT Name,Price FROM MyTable ORDER BY Price

　　-- 求出要查询的最小ID和最大ID
　　DECLARE @FirstRec int, @LastRec int
　　SELECT @FirstRec = (@Page - 1) * @RecsPerPage
　　SELECT @LastRec = (@Page * @RecsPerPage + 1)

　　-- 得到实际的记录，并返回是否还有数据!
　　SELECT *,
       　　MoreRecords =
       　(
        　　SELECT COUNT(*)
        　　FROM #TempItems TI
        　　WHERE TI.ID >= @LastRec
       　)
　　FROM #TempItems
　　WHERE ID > @FirstRec AND ID < @LastRec

　　-- 恢复设置
　　SET NOCOUNT OFF

　　在这个存储过程里，我们首先创建一个全部记录的临时表，并增加了一个自动编号的字段ID。这样，不同的记录就有一个递增的唯一标志。
　　根据当前的页号和每页的记录数，可以计算出每页的最小和最大的ID。从而得到当前页的所有记录。
　　为了显示的方便，存储过程还计算了 MoreRecords字段，作为显示下一页的判断条件。
　　利用了这个存储过程的程序代码如下：
　<%
　　'每页显示10条
　　Const iRecordsPerPage = 10

       　　Dim currentPage    '当前页号
       　　Dim bolLastPage    '在最后一页?
       　　
       　if len(Request.QueryString("page")) = 0 then
            　　 currentPage = 1
       　else
            　　 currentPage = CInt(Request.QueryString("page"))
       　end if

       　　'得到当前页的记录
       　　strSQL = "sp_PagedItems " & currentPage & "," & iRecordsPerPage
       　　objRS.Open strSQL, objConn
       　　
       　　'判断是否在最后一页
       　if Not objRS.EOF then
            　　 if CInt(objRS("MoreRecords")) > 0 then
            　　　         bolLastPage = False
            　　 else
            　　　         bolLastPage = True
            　　 end if
       　　end if
　　%>
　　<P>

　<TABLE BORDER=0 CELLSPACING=1 CELLPADDING=4 ALIGN=CENTER>
　　<TR><TH COLSPAN=2 BGCOLOR=NAVY>
       　　<FONT SIZE=+1 COLOR=WHITE>
            　　　 List of Items
       　　</FONT>
　　</TH></TR>
　<%
       　　Do While Not objRS.EOF %>
            　　 <TR><TD ALIGN=LEFT BGCOLOR=GRAY>
            　　         <%=objRS("Name")%>
            　　 </TD><TD ALIGN=CENTER BGCOLOR=GRAY>
            　　         <%=FormatCurrency(objRS("Price"))%>
            　　 </TD></TR>
　　<%         objRS.MoveNext
       　　Loop %>
　</TABLE>
　　<P>
　　<CENTER>
　<%

　　'第一页不显示“前一页”
　if currentPage > 1 then %>
       　　<INPUT TYPE=BUTTON VALUE="<< 前 <%=iMaxRecords%> 记录 "
       　　ONCLICK="document.location.href='thispage.asp?page=<%=currentPage-1%>'"> ;
       　　
　<% end if

　　'最后一页不显示“后一页”
　if Not bolLastPage then %>
　　<INPUT TYPE=BUTTON VALUE="后 <%=iMaxRecords%> 记录 >>"
　　ONCLICK="document.location.href='thispage.asp?page=<%=currentPage+1%>'"> ;
　<% end if %>
　　</CENTER>　　

转换文本为超联和Email格式的代码

--------------------------------------------------------------------------------

如果用户输入了http://aaa.bbb.ccc
下面这个代码将把他的输入转换成http://aaa.bbb.ccc
大家看看正则表达式有多厉害，呵呵。

<%
'调用这个函数来显示成超联结
Response.Write to_html(s_message)
%>

<%
Function to_html(s_string)
    to_html = Replace(s_string, """", """)
    to_html = Replace(to_html, "<", "<")
    to_html = Replace(to_html, ">", ">")
    to_html = Replace(to_html, vbcrlf, "<br>")
    to_html = Replace(to_html, "/<", "<")
    to_html = Replace(to_html, "/>", ">")
    to_html = edit_hrefs(to_html)
End Function
%>

s_str = s_str.replace(/bhttp://www(.[w+.:/_]+)/gi,
"http://?¤?$1");

    s_str = s_str.replace(/b(http://w+.[w+.:/_]+)/gi,
        "<a href="$1">$1</a>");

    s_str = s_str.replace(/b(www.[w+.:/_]+)/gi,
        "<a href="http://$1">$1</a>");

    s_str = s_str.replace(/bhttp://?¤?(.[w+.:/_]+)/gi,
        "<a href="http://www$1">http://www$1</a>");

    s_str = s_str.replace(/b(w+@[w+.?]*)/gi,
        "<a href="mailto:$1">$1</a>");


    return s_str;
}
</script>

在ASP中用“正则表达式对象”来校验数据的合法性

--------------------------------------------------------------------------------
　　我们在制作网站的时候,尤其是各种电子商务网站,首先都会让用户填写一些表格来获取注册用户的各种信息,因为用户有可能输入各式各样的信息,而有些不符合要求的数据会给我们的后端ASP处理程序带来不必要的麻烦,甚至导致网站出现一些安全问题。因此我们在将这些信息保存到网站的数据库之前,要对这些用户所输入的信息进行数据的合法性校验,以便后面的程序可以安全顺利的执行。所以我们一般会在后端编写一个ASP的校验程序来分析用户输入的数据是否是合法的。

　　或许有人会问了，使用运行在客户端的JavaScript不是可以更好更快的来校验用户的数据吗？的确，这样在大多的情况下是可以的，为什么是大多情况下呢？因为你编写的JavaScript不一定可以完全正常的同时运行在IE以及Netscape上面，因为微软的Jscript并不全和JavaScript相同，再加上还有一些浏览器不一定和微软以及Netscape兼容的很好，所以很有可能在客户端的Javascript不会精确的校验用户输入的各种数据，而ASP程序是运行在服务器端的，只是和你的服务器的环境有关，无论客户端是什么浏览器，对于你的ASP程序来说都是没有分别的，所以选择使用后端的ASP程序来进行数据合法性的校验是一个好的选择。

　　在使用ASP来进行后端的数据合法性校验的时候，有些人为满足不同环境下面的数据校验，编写了很多的函数来实现，比如，我们想要校验用户输入的URL 地址是否合法，是可以自己编写一段代码来逐个逐个字符的分析用户输入的信息，要分析的信息量小了，那还比较好办，若是分析的条件千变万化，那可就惨了，不但要编写很长很繁琐的代码，而且运行的效率极其低下，有没有好的解决办法呢？有，那就是VBScritp5.0提供的“正则表达式”对象，只要你的服务器安装了IE5.x，就会带VBScript5.0。其实，“正则表达式”原本是Unix下面的专利，尤其是在Perl语言中使用的最为广泛，正是由于“正则表达式”的强大功能，才使得微软慢慢将正则表达式对象移植到了视窗系统上面，利用

“正则表达式”对象，我们就可以非常方便的对各种数据进行合法性的校验了。

　　首先，让我们来了解一下究竟什么是VBScript的“正则表达式”对象，我们先来看一段程序：

Function CheckExp(patrn, strng)

Dim regEx, Match　　 ' 建立变量。

Set regEx = New RegExp ' 建立正则表达式。

regEx.Pattern = patrn ' 设置模式。

regEx.IgnoreCase = true ' 设置是否区分字符大小写。

regEx.Global = True ' 设置全局可用性。

Matches = regEx.test(strng) 　　　　' 执行搜索。

CheckExp = matches

End Function

　　在这段程序程序中，我们看到可以使用“New RegExp”来得到一个正则表达式对象，然后对这个对象进行正则匹配模板的赋值，也就是告诉正则表达式对象，你想要匹配一个什么样子的模板，然后使用方法Test来检测待处理的数据究竟和我们给出的模版是否相匹配，如果不匹配，那就表明待处理的数据不是合法的数据，从而也就实现了数据合法性的校验，我们可以看出，使用一个设计合理的匹配模板，我们可以轻松的校验一批格式类似的数据信息。

　　当然，VBScript5.0中的“正则表达式”对象还有很多的其他的方法和属性，比如方法Replace(),利用他我们就可以很快的实现现在网上很时髦的UBB风格的论坛以及BBS，这不在我们讨论范围之内，以后再加以论述，我们现在就看看在数据校验方面正则表达式对象常用的方法和属性：

常用方法： Execute 方法

描述：对指定的字符串执行正则表达式搜索。

语法：object.Execute(string)　　Execute 方法的语法包括以下几个部分：

object：必需的。总是一个 RegExp 对象的名称。

string：必需的。要在其上执行正则表达式的文本字符串。

说明：正则表达式搜索的设计模式是通过 RegExp 对象的 Pattern 来设置的。Execute 方法返回一个

Matches 集合，其中包含了在 string 中找到的每一个匹配的 Match 对象。如果未找到匹配，Execute 将返回空的 Matches 集合。

Test方法

描述：对指定的字符串执行一个正则表达式搜索，并返回一个 Boolean 值指示是否找到匹配的模式。

语法：object.Test(string)

Test 方法的语法包括以下几个部分：

object：必需的。总是一个 RegExp 对象的名称。

string：必需的。要执行正则表达式搜索的文本字符串。

说明：正则表达式搜索的实际模式是通过RegExp对象的Pattern属性来设置的。RegExp.Global属性对Test方法没有影响。如果找到了匹配的模式，Test方法返回True；否则返回False。

常用属性： Global属性

描述：设置或返回一个 Boolean 值，该值指明在整个搜索字符串时模式是全部匹配还是只匹配第一个。

语法：object.Global [= True | False ]

object 参数总是 RegExp 对象。如果搜索应用于整个字符串，Global 属性的值为 True，否则其值为 False。默认的设置为 True。

IgnoreCase属性

描述：设置或返回一个Boolean值，指明模式搜索是否区分大小写。

语法：object.IgnoreCase [= True | False ]

object 参数总是一个 RegExp 对象。如果搜索是区分大小写的，则 IgnoreCase 属性为 False；否则为 True。缺省值为 True。

Pattern属性

描述：设置或返回被搜索的正则表达式模式。这是一个最重要的属性，我们主要是设置这个属性来实现数据校验的。

语法：object.Pattern [= "searchstring"]

Pattern 属性的语法包含以下几个部分：

object：必需的。总是一个 RegExp 对象变量。

searchstring：可选的。被搜索的正则字符串表达式。它可能包含设置部分表格中的各种正则表达式字符。

设置：在书写正则表达式的模式时使用了特殊的字符和序列。下表描述了可以使用的字符和序列，并给出了实例。

字符描述：：将下一个字符标记为特殊字符或字面值。例如"n"与字符"n"匹配。"n"与换行符匹配。序列"/"与""匹配，"("与"("匹配。

^ ：匹配输入的开始位置。

$ ：匹配输入的结尾。

* ：匹配前一个字符零次或几次。例如，"zo*"可以匹配"z"、"zoo"。

+ ：匹配前一个字符一次或多次。例如，"zo+"可以匹配"zoo",但不匹配"z"。

? ：匹配前一个字符零次或一次。例如，"a?ve?"可以匹配"never"中的"ve"。

.：匹配换行符以外的任何字符。

(pattern) 与模式匹配并记住匹配。匹配的子字符串可以从作为结果的 Matches 集合中使用 Item [0]...[n]取得。如果要匹配括号字符(和 )，可使用"(" 或 ")"。

x|y：匹配 x 或 y。例如 "z|food" 可匹配 "z" 或 "food"。"(z|f)ood" 匹配 "zoo" 或 "food"。

{n}：n 为非负的整数。匹配恰好n次。例如，"o{2}" 不能与 "Bob 中的 "o" 匹配，但是可以与"foooood"中的前两个o匹配。

{n,} ：n 为非负的整数。匹配至少n次。例如，"o{2,}"不匹配"Bob"中的"o"，但是匹配"foooood"中所有的o。"o{1,}"等价于"o+"。"o{0,}"等价于"o*"。

{n,m} ：m 和 n 为非负的整数。匹配至少 n 次，至多 m 次。例如，"o{1,3}" 匹配 "fooooood"中前三个o。"o{0,1}"等价于"o?"。

[xyz] ：一个字符集。与括号中字符的其中之一匹配。例如，"[abc]" 匹配"plain"中的"a"。

[^xyz] ：一个否定的字符集。匹配不在此括号中的任何字符。例如，"[^abc]" 可以匹配"plain"中的"p".

[a-z] ：表示某个范围内的字符。与指定区间内的任何字符匹配。例如，"[a-z]"匹配"a"与"z"之间的任何一个小写字母字符。

[^m-z] ：否定的字符区间。与不在指定区间内的字符匹配。例如，"[m-z]"与不在"m"到"z"之间的任何字符匹配。

b ：与单词的边界匹配，即单词与空格之间的位置。例如，"erb" 与"never"中的"er"匹配，但是不匹配"verb"中的"er"。

B ：与非单词边界匹配。"ea*rB"与"never early"中的"ear"匹配。

d ：与一个数字字符匹配。等价于[0-9]。

D ：与非数字的字符匹配。等价于[^0-9]。

f ：与分页符匹配。

n ：与换行符字符匹配。

r ：与回车字符匹配。

s ：与任何白字符匹配，包括空格、制表符、分页符等。等价于"[ fnrtv]"。

S ：与任何非空白的字符匹配。等价于"[^ fnrtv]"。
-----------------------------------------------------------------------------------------
Private Sub Command1_Click()
    Dim sou As String, tmp() As String, i As Long
    sou = "<a href=""list/7mingxin.htm"">美女</a></span> <a href=""list/1yinyue.htm""><span class=""p140"">音乐</span></a> <span class=""p140""><a href=""list/2youxi.htm"">游戏</a> <a href=""list/46xiaoshuo.htm"">小说</a> <a href=""list/76tupian.htm"">图片</a> <a href=""list/3yingshi.htm"">电影</a> <a href=""list/8dongman.htm"">动漫</a> <a href=""list/9xiaohua.htm"">幽默笑话</a> <a href=""list/10flash.htm"">FLASH</a> <a href=""list/13luntan.htm"">论坛</a> <a href=""list/11lvyou.htm"">旅游</a> <a href=""list/68shishang.htm"">时尚</a> <a href=""list/14bizhi.htm"">桌面</a> <a href=""list/15tiyu.htm"">体育</a> <a href=""list/70xingzhuo.htm"">星座</a> <a href=""list/5jiaoyou.htm"">交友</a> <a href=""list/4liaotianshi.htm"">聊天</a>"
    tmp = Split(sou, "</a>")
    For i = 0 To UBound(tmp)
        tmp(i) = Replace(tmp(i), "<a href=""", "")
        tmp(i) = Replace(tmp(i), """>", vbCrLf)
        tmp(i) = Trim(tmp(i))
        Debug.Print tmp(i)
    Next
End Sub

1.工程->引用
microsoft VBScript Regular Expressions 5.5
2
引用后就可以使用
-----------------------------------------------------------------------------------------
"Chapter [1-9][0-9]*"
看了一下，应该是匹配 "Chapter " 加上任一大于零的并且不以"0"开头的数字的字符串，如"Chapter 2""Chapter 21""Chapter 231"，但不是"Chapter 02"或"Chapter A2"

*（星号）字符在正则表达式里是“匹配前一子表达式（在这里是"[0-9]"）零次或多次”。
不过在用于Like运算符的字符串里是“匹配任意长度的任意字符”的意思。

---------------------------------------------------------------------------------------
工程->引用->Microsoft VBScript Reqular Expressions

Public myReg As New RegExp '正则表达式

'限制输入数字
'obj为被限制的控件, PointNum为限制的小数位数, SignFlag为是否限制输入"+"号, 默认为限制
Public Sub SetNumber(obj As TextBox, PointNum As Integer, Optional SignFlag As Boolean = True)
On Error Resume Next
Dim ls_Pattern As String, ls_Text As String, ls_Tag, i As Long

    ls_Pattern = IIf(SignFlag, "^[/-]{0,1}", "^")
    ls_Pattern = ls_Pattern & "(0|[1-9][0-9]{0,50})([/.][0-9]{0," & PointNum & "}){0," & IIf(PointNum = 0, "0", "1") & "}$"
    myReg.IgnoreCase = True
    myReg.Pattern = ls_Pattern
    ls_Text = obj.Text
    ls_Tag = obj.Tag

    i = obj.SelStart
    If Not myReg.Test(ls_Text) And ls_Text <> "" Then
        obj.Text = ls_Tag
        obj.SelStart = IIf(i = 0, 1, i - Abs(Len(ls_Text) - Len(ls_Tag)))
    Else
        obj.Tag = ls_Text
    End If
'    Dim i As Long, ls_Text As String, ls_Tag As String, ls_Reverse As String
'
'    ls_Text = obj.Text
'    ls_Tag = obj.Tag
'    ls_Reverse = StrReverse(ls_Text)
'    i = obj.SelStart
'    If IsNumeric(ls_Text) And InStr(ls_Reverse, ".") <= PointNum + 1 And IIf(PointNum = 0, InStr(ls_Text, ".") = 0, True) And InStr(ls_Text, "&") = 0 And InStr(ls_Text, ",") = 0 And InStr(ls_Text, "+") = 0 And InStr(ls_Text, " ") = 0 And InStr(ls_Text, "　") = 0 And InStr(ls_Text, "d") = 0 And InStr(ls_Text, "D") = 0 And IIf(SignFlag, InStr(ls_Reverse, "-") <> 1, InStr(ls_Text, "-") = 0) And IIf(Left(ls_Text, 1) = "-", Mid(ls_Text, 2, 1) <> "0", IIf(Mid(ls_Text, 2, 1) = ".", True, Left(ls_Text, 1) <> "0")) Then
'        obj.Tag = ls_Text
'    Else
'        If ls_Text <> "" Then
'            obj.Text = ls_Tag
'            obj.SelStart = IIf(i = 0, 1, i - Abs(Len(ls_Text) - Len(ls_Tag)))
'        End If
'    End If
End Sub
------------------------------------------------------------------------------------
得到表达式的值
'先引用Microsoft Script Control 1.0
Private Sub Command1_Click()
    Dim sc As New ScriptControl
    Set sc = CreateObject("ScriptControl")
    sc.Language = "vbscript"
    Text2.Text = sc.Eval(Text1.Text)
End Sub
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
Option Explicit
Private Sub Command1_Click()
MsgBox (RegExpTest("is.", "IS1 is2 IS3 is4"))
End Sub
Function RegExpTest(PatternX As String, StringX As String) As String
Dim Matches As VBScript_RegExp_55.MatchCollection     ' 建立变量。
Dim regEx As New VBScript_RegExp_55.RegExp ' 建立正则表达式。
regEx.Pattern = PatternX ' 设置模式。
regEx.IgnoreCase = True ' 设置是否区分字符大小写。
regEx.Global = True      ' 设置全局可用性。
Set Matches = regEx.Execute(StringX)    ' 执行搜索。
'Dim Match As VBScript_RegExp_55.Match
'For Each Match In Matches     ' 遍历匹配集合。
'    RegExpTest = RegExpTest & "Match found at position "
'    RegExpTest = RegExpTest & Match.FirstIndex & ". Match Value is '"
'    RegExpTest = RegExpTest & Match.Value & "'." & vbCrLf
'Next
Dim i As Integer
For i = 0 To Matches.Count - 1 ' 遍历匹配集合。
    RegExpTest = RegExpTest & "Match found at position " & Matches.Item(i).FirstIndex & ". Match Value is '" & Matches.Item(i).Value & "'." & vbCrLf
Next
End Function

直接Reference:Microsoft VBScript Regular Expressions就可以了
Dim regEx As New RegExp
regEx.Pattern = "'{2,}"
regEx.IgnoreCase = True
regEx.Global = True
tmpValue = regEx.Replace(tmpValue, "'")

'补充一句我忘说了
'引用 Microsoft VBScript Regular Expressions 5.5 或 Microsoft VBScript Regular Expressions 1.0
Option Explicit
Private Sub Command1_Click()
MsgBox (RegExpTest("is.", "IS1 is2 IS3 is4"))
End Sub
Function RegExpTest(PatternX As String, StringX As String) As String
Dim Matches As VBScript_RegExp_55.MatchCollection    ' 建立变量。
Dim regEx As New VBScript_RegExp_55.RegExp ' 建立正则表达式。
regEx.Pattern = PatternX ' 设置模式。
regEx.IgnoreCase = True ' 设置是否区分字符大小写。
regEx.Global = True      ' 设置全局可用性。
Set Matches = regEx.Execute(StringX)    ' 执行搜索。
'Dim Match As VBScript_RegExp_55.Match
'For Each Match In Matches    ' 遍历匹配集合。
'    RegExpTest = RegExpTest & "Match found at position "
'    RegExpTest = RegExpTest & Match.FirstIndex & ". Match Value is '"
'    RegExpTest = RegExpTest & Match.Value & "'." & vbCrLf
'Next
Dim i As Integer
For i = 0 To Matches.Count - 1 ' 遍历匹配集合。
    RegExpTest = RegExpTest & "Match found at position " & Matches.Item(i).FirstIndex & ". Match Value is '" & Matches.Item(i).Value & "'." & vbCrLf
Next
End Function
---------------------------------------------------------------------------------------
shell 正则表达式语法

--------------------------------------------------------------------------------

　　一个正则表达式就是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。　

　　/　
　　将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'/n' 匹配一个换行符。序列 '//' 匹配 "/" 而 "/(" 则匹配 "("。　

　　^　
　　匹配输入字符串的开始位置。

　　$　
　　匹配输入字符串的结束位置。

　　*　
　　匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。 * 等价于{0,}。　

　　+　
　　匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。　

　　?　
　　匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。　

　　{n}　
　　n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。　

　　{n,}　
　　n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。　

　　{n,m}　
　　m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。 "o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。　

　　?　
　　当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。　

　　.　
　　匹配除 "/n" 之外的任何单个字符。要匹配包括 '/n' 在内的任何字符，请使用象 '[./n]' 的模式。　

　　(pattern)　
　　匹配pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在Visual Basic Scripting Edition 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '/(' 或 '/)'。　

　　(?:pattern)　
　　匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。　

　　(?=pattern)　
　　正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如， 'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。　

　　(?!pattern)　
　　负向预查，在任何不匹配Negative lookahead matches the search string at any point where a string not matching pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始　

　　x|y　
　　匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。　

　　[xyz]　
　　字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。　

　　[^xyz]　
　　负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。　

　　[a-z]　
　　字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。　

　　[^a-z]　
　　负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。　

　　/b　
　　匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er/b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。　

　　/B　
　　匹配非单词边界。'er/B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。　

　　/cx　
　　匹配由x指明的控制字符。例如， /cM 匹配一个 Control-M 或回车符。 x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。　

　　/d　
　　匹配一个数字字符。等价于 [0-9]。　

　　/D　
　　匹配一个非数字字符。等价于 [^0-9]。　

　　/f　
　　匹配一个换页符。等价于 /x0c 和 /cL。　

　　/n　
　　匹配一个换行符。等价于 /x0a 和 /cJ。　

　　/r　
　　匹配一个回车符。等价于 /x0d 和 /cM。　

　　/s　
　　匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ /f/n/r/t/v]。　

　　/S　
　　匹配任何非空白字符。等价于 [^ /f/n/r/t/v]。　

　　/t　
　　匹配一个制表符。等价于 /x09 和 /cI。　

　　/v　
　　匹配一个垂直制表符。等价于 /x0b 和 /cK。　

　　/w　
　　匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。　

　　/W　
　　匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。　

　　/xn　
　　匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如， '/x41' 匹配 "A"。'/x041' 则等价于 '/x04' & "1"。正则表达式中可以使用 ASCII 编码。.　

　　/num　
　　匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)/1' 匹配两个连续的相同字符。　

　　/n　
　　标识一个八进制转义值或一个后向引用。如果 /n 之前至少 n 个获取的子表达式，则 n 为后向引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。　

　　/nm　
　　标识一个八进制转义值或一个后向引用。如果 /nm 之前至少有is preceded by at least nm 个获取得子表达式，则 nm 为后向引用。如果 /nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足，若　n 和 m 均为八进制数字 (0-7)，则 /nm 将匹配八进制转义值 nm。　

　　/nml　
　　如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。　

　　/un　
　　匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， /u00A9 匹配版权符号 (?)。