Regexpal 是一个 JavaScript 写成的正则表达式在线验证工具，对于常接触正则的程序员来说，是个很实用的工具。
正则表达式 (Regular Expression) 作为一种方便快捷的字符串处理方案，受到了越来越多程序员的欢迎。虽然初学正则表达式比较抓狂，但一旦开始使用它，你就发现它真是强大的不得了。在 Web 应用开发中，正则表达式更是被广泛使用。流行的编程语言，如 PHP，ASP，JavaScript 都支持正则表达式。虽然调用方法不太相同，但匹配规则 (pattern) 都是一样的。
无论是正则表达式的熟练者，还是刚学正则的新手，验证自己书写的表达式是否正确一直是个麻烦的问题。通常我的做法是写一小段程序，并载入相关数据进行验证。这种方法虽然有效，但很麻烦。Regexpal就可以简化这个问题。
打开 Regexpal 的主页，我们看到只有很简洁的两个框框。上面的输入框中，我们可以输入正则表达式（匹配规则），而在下面的框框中我们输入待匹配的数据。此外，根据具体要求，我们还可以设置忽略大小写、多行匹配等参数。Regexpal 的匹配结果是实时的，当你完成设置的同时，匹配结果将会以不同的颜色在下方的数据框中被标记出来。这样，我们就可以很直观的看到自己的正则表达式是否正确了。
Regexpal 对于程序员来说，应该是一个收入收藏夹的好工具。当然，对于平时有大量文档需要处理的朋友，我也建议你学习一下正则表达式。利用正则来处理文本绝对可以达到事半功倍的效果。如今比较流行的编辑器，如 Notepad++ 都能够很好的支持通过正则表达式查找和替换。利用正则来处理大量有规律的文本，比传统的手工方法要省时省力的多。

在FLASH热潮风靡世界的今天，WACOM也开始了她的再一次辉煌。
　　FLASH对 WACOM的支持并不能算是一个“好”字。但是WACOM会使FLASH发挥的更加多面化和完美化。很多朋友反映：在FLASH中用WACOM画出来的线条都不够平滑、不够流畅。这也是需要一些技巧的，首先在画之前你要确定你的画面是用纯线来表现还是用笔刷的块面线来表现，纯线条是没有粗细变化的，但是比较容易画的流畅；笔刷有压敏反应，所以可以画出非常自然的线条，遗憾的是掌握起来需要一定的熟练程度和技巧。下面我们来分别看一下（以下说 明针对FLASH5.0版本）：
　　纯线条的绘画比较好掌握，只要你有良好的运用普通铅笔或钢笔画画的技巧，你就可以 很快地掌握WACOM的使用方法。
　　1、在绘前，先要把FLASH中具有自动对齐功能的“磁铁”点掉，取消自动对齐功能；
　　2、然后点下工具栏中的铅笔工具，在对应的工具栏下方的线条模式里面选择最后一种 ：自由线条（Ink）；
　　3、接下来，检查一下View菜单下的Grid选项中的Snap to Grid选项是否是选中状态， 如果是，就要取消对它的选择。
好了现在你就拥有了相当的自由度了，试一下你的WACOM吧。
　　笔刷的块面线条的绘画掌握起来比较复杂一些，首先我们要做的一步就是上面所讲的纯 线条的绘画3步前奏。因为笔刷的块面线也是有边缘的，它的边缘也就是线条的属性，所以 不能忽略。
　　接下来，我们需要选择笔刷工具，在下面的对应属性中点下那个蝌蚪状的压敏支持按钮 （Use Pressure），选择合适的笔触外形和适当的粗细，这里说明一点：虽然WACOM可以画出自由粗细的线条，我们可以通过手上的压感来自己调节线条的粗细；但是因为压感控制的敏感度和用力的不均衡，不同粗细的笔刷会有不同的压力感应圈。选择合适粗细的笔刷是非 常重要的一步。
　　最后，先在空白纸上测试一下你的绘画速度：速度太快的话，线条会有折线点出现，速度太慢也一样会有很多弯曲折断的线条边缘出现；要经常用、多练习才可以掌握好。另外，机器的配置好坏也一样会影响线条的光滑度：速度慢的机器就要画得慢一点；速度快的机器 要加快绘画速度。
　　勾完线后的修改：纯线条的画面需要先点开时间线面板上的显示外框功能，然后按下磁铁自动对齐按钮。这样比较容易察看接合与否，没接合的地方用鼠标工具拖拽一端进行自动接合。笔刷的块面线稿也可以用显示外框功能和自动对齐功能来修正接合，或者也可以直接用笔刷添补接合。对于多出来的线头，直接用橡皮擦除或者快速拖拽转折线点使多余部分分 离开线稿，再点击删除。
　　对于抖动折线或小曲线过多的地方，可以先用鼠标工具圈选该部分，然后点几下“光滑 （Smooth）”按钮，再用鼠标工具调整为合适的曲度。
　　合理使用WACOM：
　　1、保持好良好的使用角度。一般来说：笔和板在60度-70度的倾斜度间最为顺手和协调 。低于45度会使敏感度降低很多；接近垂直的角度容易损伤板面和笔尖。
　　2、保持版面清洁。新板子手感非常舒适，相信大家也一定保护的很好了。用的时间稍久了就不会在乎这些了，这样是不对的。版面上的灰尘和污垢很容易影响你的绘画效果并加快笔尖和板面的损耗。建议大家买一块普通的擦眼镜用的绒布来维护板面，不要用面巾纸等粗糙的东西去擦。使用前擦拭一遍，使用后擦拭一遍，然后用绒布盖好板面。笔不用时要插在座中，以免掉落（笔中有一条很窄的电路板，如果松动了则直接影响使用效果）。
　　3、笔尖每使用一段时间（大约15天，根据频繁度来定）后最好用镊子夹住稍微旋转一下，这样有利于延长笔尖的使用寿命，避免出现摩擦斜角。
　　4、板子和笔不要离强磁场、高温的东西太近。
　　以上部分只是一点本人日常总结的小经验，不到之处尚请指正。最后祝各位闪客能顺利地用WACOM打造自己的闪光之作！谢谢阅览。
cink（青羽）2002.1.14. 凌晨2:49

匹配中文字符的正则表达式： [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
String.prototype.len=function(){return this.replace([^\x00-\xff]/g,”aa”).length;}
匹配空行的正则表达式：\n[\s| ]*\r
匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
匹配首尾空格的正则表达式：(^\s*)|(\s*$)
应用：JavaScript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：
String.prototype.trim = function()
{
return this.replace(/(^\s*)|(\s*$)/g, “”);
}
利用正则表达式分解和转换IP地址：
下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的JavaScript程序：
function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error(“Not a valid IP address!”)
}
}
不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：
var ip=”10.100.20.168″
ip=ip.split(“.”)
alert(“IP值是：”+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))
匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
匹配网址URL的正则表达式：http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?
利用正则表达式去除字串中重复的字符的算法程序：[注：此程序不正确，原因见本贴回复]
var s=”abacabefgeeii”
var s1=s.replace(/(.).*\1/g,”$1″)
var re=new RegExp(“[“+s1+”]”,”g”)
var s2=s.replace(re,””)
alert(s1+s2) //结果为：abcefgi
我原来在CSDN上发贴寻求一个表达式来实现去除重复字符的方法，最终没有找到，这是我能想到的最简单的实现方法。思路是使用后向引用取出包括重复的字符，再以重复的字符建立第二个表达式，取到不重复的字符，两者串连。这个方法对于字符顺序有要求的字符串可能不适用。
得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1
s=”http://www.9499.net/page1.htm”
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,”$2″)
alert(s)
利用正则表达式限制网页表单里的文本框输入内容：
用正则表达式限制只能输入中文：onkeyup=”value=value.replace(/[^\u4E00-\u9FA5]/g,”)” onbeforepaste=”clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\u4E00-\u9FA5]/g,”))”
用正则表达式限制只能输入全角字符： onkeyup=”value=value.replace(/[^\uFF00-\uFFFF]/g,”)” onbeforepaste=”clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\uFF00-\uFFFF]/g,”))”
用正则表达式限制只能输入数字：onkeyup=”value=value.replace(/[^\d]/g,”) “onbeforepaste=”clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\d]/g,”))”
用正则表达式限制只能输入数字和英文：onkeyup=”value=value.replace(/[\W]/g,”) “onbeforepaste=”clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\d]/g,”))”
补充：
^\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地址
^[a-zA-z]+://匹配(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$　　//匹配url
利用正则表达式去除字串中重复的字符的算法程序：
var s=”abacabefgeeii”
var s1=s.replace(/(.).*\1/g,”$1″)
var re=new RegExp(“[“+s1+”]”,”g”)
var s2=s.replace(re,””)
alert(s1+s2) //结果为：abcefgi
===============================
如果var s = “abacabefggeeii”
结果就不对了，结果为：abeicfgg
正则表达式的能力有限
1.确认有效电子邮件格式
下面的代码示例使用静态 Regex.IsMatch 方法验证一个字符串是否为有效电子邮件格式。如果字符串包含一个有效的电子邮件地址，则 IsValidEmail 方法返回 true，否则返回 false，但不采取其他任何操作。您可以使用 IsValidEmail，在应用程序将地址存储在数据库中或显示在 ASP.NET 页中之前，筛选出包含无效字符的电子邮件地址。
[Visual Basic]
Function IsValidEmail(strIn As String) As Boolean
‘ Return true if strIn is in valid e-mail format.
Return Regex.IsMatch(strIn, (“^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$”)
End Function
[C#]
bool IsValidEmail(string strIn)
{
// Return true if strIn is in valid e-mail format.
return Regex.IsMatch(strIn, @”^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$”);
}
2.清理输入字符串
下面的代码示例使用静态 Regex.Replace 方法从字符串中抽出无效字符。您可以使用这里定义的 CleanInput 方法，清除掉在接受用户输入的窗体的文本字段中输入的可能有害的字符。CleanInput 在清除掉除 @、-（连字符）和 .（句点）以外的所有非字母数字字符后返回一个字符串。
[Visual Basic]
Function CleanInput(strIn As String) As String
‘ Replace invalid characters with empty strings.
Return Regex.Replace(strIn, “[^\w\.@-]”, “”)
End Function
[C#]
String CleanInput(string strIn)
{
// Replace invalid characters with empty strings.
return Regex.Replace(strIn, @”[^\w\.@-]”, “”);
}
3.更改日期格式
以下代码示例使用 Regex.Replace 方法来用 dd-mm-yy 的日期形式代替 mm/dd/yy 的日期形式。
[Visual Basic]
Function MDYToDMY(input As String) As String
Return Regex.Replace(input, _
“\b(?\d{1,2})/(?\d{1,2})/(?\d{2,4})\b”, _
“${day}-${month}-${year}”)
End Function
[C#]
String MDYToDMY(String input)
{
return Regex.Replace(input,
“\\b(?\\d{1,2})/(?\\d{1,2})/(?\\d{2,4})\\b”,
“${day}-${month}-${year}”);
}
Regex 替换模式
本示例说明如何在 Regex.Replace 的替换模式中使用命名的反向引用。其中，替换表达式 ${day} 插入由 (?…) 组捕获的子字符串。
有几种静态函数使您可以在使用正则表达式操作时无需创建显式正则表达式对象，而 Regex.Replace 函数正是其中之一。如果您不想保留编译的正则表达式，这将给您带来方便
4.提取 URL 信息
以下代码示例使用 Match.Result 来从 URL 提取协议和端口号。例如，“http://www.contoso.com:8080/letters/readme.html”将返回“http:8080”。
[Visual Basic]
Function Extension(url As String) As String
Dim r As New Regex(“^(? \w+)://[^/]+?(? :\d+)?/”, _
RegexOptions.Compiled)
Return r.Match(url).Result(“${proto}${port}”)
End Function
[C#]
String Extension(String url)
{
Regex r = new Regex(@”^(? \w+)://[^/]+?(? :\d+)?/”,
RegexOptions.Compiled);
return r.Match(url).Result(“${proto}${port}”);
}

前言：
本文是前一片文章《深入浅出之正则表达式（一）》的续篇，在本文中讲述了正则表达式中的组与向后引用，先前向后查看，条件测试，单词边界，选择符等表达式及例子，并分析了正则引擎在执行匹配时的内部机理。
本文是Jan Goyvaerts为RegexBuddy写的教程的译文，版权归原作者所有，欢迎转载。但是为了尊重原作者和译者的劳动，请注明出处！谢谢！
9. 单词边界
元字符<<\b>>也是一种对位置进行匹配的“锚”。这种匹配是0长度匹配。
有4种位置被认为是“单词边界”：
1) 在字符串的第一个字符前的位置(如果字符串的第一个字符是一个“单词字符”)
2) 在字符串的最后一个字符后的位置(如果字符串的最后一个字符是一个“单词字符”)
3) 在一个“单词字符”和“非单词字符”之间，其中“非单词字符”紧跟在“单词字符”之后
4) 在一个“非单词字符”和“单词字符”之间，其中“单词字符”紧跟在“非单词字符”后面
“单词字符”是可以用“\w”匹配的字符，“非单词字符”是可以用“\W”匹配的字符。在大多数的正则表达式实现中，“单词字符”通常包括<<[a-zA-Z0-9_]>>。
例如：<<\b4\b>>能够匹配单个的4而不是一个更大数的一部分。这个正则表达式不会匹配“44”中的4。
换种说法，几乎可以说<<\b>>匹配一个“字母数字序列”的开始和结束的位置。
“单词边界”的取反集为<<\B>>，他要匹配的位置是两个“单词字符”之间或者两个“非单词字符”之间的位置。
· 深入正则表达式引擎内部
让我们看看把正则表达式<<\bis\b>>应用到字符串“This island is beautiful”。引擎先处理符号<<\b>>。因为\b是0长度 ，所以第一个字符T前面的位置会被考察。因为T是一个“单词字符”，而它前面的字符是一个空字符(void)，所以\b匹配了单词边界。接着<>和第一个字符“T”匹配失败。匹配过程继续进行，直到第五个空格符，和第四个字符“s”之间又匹配了<<\b>>。然而空格符和<>不匹配。继续向后，到了第六个字符“i”，和第五个空格字符之间匹配了<<\b>>，然后<>和第六、第七个字符都匹配了。然而第八个字符和第二个“单词边界”不匹配，所以匹配又失败了。到了第13个字符i，因为和前面一个空格符形成“单词边界”，同时<>和“is”匹配。引擎接着尝试匹配第二个<<\b>>。因为第15个空格符和“s”形成单词边界，所以匹配成功。引擎“急着”返回成功匹配的结果。
10. 选择符
正则表达式中“|”表示选择。你可以用选择符匹配多个可能的正则表达式中的一个。
如果你想搜索文字“cat”或“dog”，你可以用<>。如果你想有更多的选择，你只要扩展列表<>。
选择符在正则表达式中具有最低的优先级，也就是说，它告诉引擎要么匹配选择符左边的所有表达式，要么匹配右边的所有表达式。你也可以用圆括号来限制选择符的作用范围。如<<\b(cat|dog)\b>>，这样告诉正则引擎把(cat|dog)当成一个正则表达式单位来处理。
· 注意正则引擎的“急于表功”性
正则引擎是急切的，当它找到一个有效的匹配时，它会停止搜索。因此在一定条件下，选择符两边的表达式的顺序对结果会有影响。假设你想用正则表达式搜索一个编程语言的函数列表：Get，GetValue，Set或SetValue。一个明显的解决方案是<>。让我们看看当搜索SetValue时的结果。
因为<>和<>都失败了，而<>匹配成功。因为正则导向的引擎都是“急切”的，所以它会返回第一个成功的匹配，就是“Set”，而不去继续搜索是否有其他更好的匹配。
和我们期望的相反，正则表达式并没有匹配整个字符串。有几种可能的解决办法。一是考虑到正则引擎的“急切”性，改变选项的顺序，例如我们使用<>，这样我们就可以优先搜索最长的匹配。我们也可以把四个选项结合起来成两个选项：<>。因为问号重复符是贪婪的，所以SetValue总会在Set之前被匹配。
一个更好的方案是使用单词边界：<<\b(Get|GetValue|Set|SetValue)\b>>或<<\b(Get(Value)?|Set(Value)?\b>>。更进一步，既然所有的选择都有相同的结尾，我们可以把正则表达式优化为<<\b(Get|Set)(Value)?\b>>。
11. 组与向后引用
把正则表达式的一部分放在圆括号内，你可以将它们形成组。然后你可以对整个组使用一些正则操作，例如重复操作符。
要注意的是，只有圆括号“()”才能用于形成组。“[]”用于定义字符集。“{}”用于定义重复操作。
当用“()”定义了一个正则表达式组后，正则引擎则会把被匹配的组按照顺序编号，存入缓存。当对被匹配的组进行向后引用的时候，可以用“\数字”的方式进行引用。<<\1>>引用第一个匹配的后向引用组，<<\2>>引用第二个组，以此类推，<<\n>>引用第n个组。而<<\0>>则引用整个被匹配的正则表达式本身。我们看一个例子。
假设你想匹配一个HTML标签的开始标签和结束标签，以及标签中间的文本。比如This is a test，我们要匹配和以及中间的文字。我们可以用如下正则表达式：“<([A-Z][A-Z0-9]*)[^>]*>.*?”
首先，“<”将会匹配“”的第一个字符“<”。然后[A-Z]匹配B，[A-Z0-9]*将会匹配0到多次字母数字，后面紧接着0到多个非“>”的字符。最后正则表达式的“>”将会匹配“”的“>”。接下来正则引擎将对结束标签之前的字符进行惰性匹配，直到遇到一个“”
你可以对相同的后向引用组进行多次引用，<<([a-c])x\1x\1>>将匹配“axaxa”、“bxbxb”以及“cxcxc”。如果用数字形式引用的组没有有效的匹配，则引用到的内容简单的为空。
一个后向引用不能用于它自身。<<([abc]\1)>>是错误的。因此你不能将<<\0>>用于一个正则表达式匹配本身，它只能用于替换操作中。
后向引用不能用于字符集内部。<<(a)[\1b]>>中的<<\1>>并不表示后向引用。在字符集内部，<<\1>>可以被解释为八进制形式的转码。
向后引用会降低引擎的速度，因为它需要存储匹配的组。如果你不需要向后引用，你可以告诉引擎对某个组不存储。例如：<>。其中“(”后面紧跟的“?:”会告诉引擎对于组(Value)，不存储匹配的值以供后向引用。
· 重复操作与后向引用
当对组使用重复操作符时，缓存里后向引用内容会被不断刷新，只保留最后匹配的内容。例如：<<([abc]+)=\1>>将匹配“cab=cab”，但是<<([abc])+=\1>>却不会。因为([abc])第一次匹配“c”时，“\1”代表“c”；然后([abc])会继续匹配“a”和“b”。最后“\1”代表“b”，所以它会匹配“cab=b”。
应用：检查重复单词–当编辑文字时，很容易就会输入重复单词，例如“the the”。使用<<\b(\w+)\s+\1\b>>可以检测到这些重复单词。要删除第二个单词，只要简单的利用替换功能替换掉“\1”就可以了。
· 组的命名和引用
在PHP，Python中，可以用<<(?Pgroup)>>来对组进行命名。在本例中，词法?P就是对组(group)进行了命名。其中name是你对组的起的名字。你可以用(?P=name)进行引用。
.NET的命名组
.NET framework也支持命名组。不幸的是，微软的程序员们决定发明他们自己的语法，而不是沿用Perl、Python的规则。目前为止，还没有任何其他的正则表达式实现支持微软发明的语法。
下面是.NET中的例子：
(?group)(?’second’group)
正如你所看到的，.NET提供两种词法来创建命名组：一是用尖括号“<>”，或者用单引号“’’”。尖括号在字符串中使用更方便，单引号在ASP代码中更有用，因为ASP代码中“<>”被用作HTML标签。
要引用一个命名组，使用\k或\k’name’.
当进行搜索替换时，你可以用“${name}”来引用一个命名组。
12. 正则表达式的匹配模式
本教程所讨论的正则表达式引擎都支持三种匹配模式：
<>使正则表达式对大小写不敏感，
<>开启“单行模式”，即点号“.”匹配新行符
<>开启“多行模式”，即“^”和“$”匹配新行符的前面和后面的位置。
· 在正则表达式内部打开或关闭模式
如果你在正则表达式内部插入修饰符(?ism)，则该修饰符只对其右边的正则表达式起作用。(?-i)是关闭大小写不敏感。你可以很快的进行测试。<<(?i)te(?-i)st>>应该匹配TEst，但是不能匹配teST或TEST.
13. 原子组与防止回溯
在一些特殊情况下，因为回溯会使得引擎的效率极其低下。
让我们看一个例子：要匹配这样的字串，字串中的每个字段间用逗号做分隔符，第12个字段由P开头。
我们容易想到这样的正则表达式<<^(.*?,){11}P>>。这个正则表达式在正常情况下工作的很好。但是在极端情况下，如果第12个字段不是由P开头，则会发生灾难性的回溯。如要搜索的字串为“1,2,3,4,5,6,7,8,9,10,11,12,13”。首先，正则表达式一直成功匹配直到第12个字符。这时，前面的正则表达式消耗的字串为“1,2,3,4,5,6,7,8,9,10,11,”，到了下一个字符，<

>并不匹配“12”。所以引擎进行回溯，这时正则表达式消耗的字串为“1,2,3,4,5,6,7,8,9,10,11”。继续下一次匹配过程，下一个正则符号为点号<<.>>，可以匹配下一个逗号“,”。然而<<，>>并不匹配字符“12”中的“1”。匹配失败，继续回溯。大家可以想象，这样的回溯组合是个非常大的数量。因此可能会造成引擎崩溃。
用于阻止这样巨大的回溯有几种方案：
一种简单的方案是尽可能的使匹配精确。用取反字符集代替点号。例如我们用如下正则表达式<<^([^,\r\n]*,){11}P>>，这样可以使失败回溯的次数下降到11次。
另一种方案是使用原子组。
原子组的目的是使正则引擎失败的更快一点。因此可以有效的阻止海量回溯。原子组的语法是<<(?>正则表达式)>>。位于(?>)之间的所有正则表达式都会被认为是一个单一的正则符号。一旦匹配失败，引擎将会回溯到原子组前面的正则表达式部分。前面的例子用原子组可以表达成<<^(?>(.*?,){11})P>>。一旦第十二个字段匹配失败，引擎回溯到原子组前面的<<^>>。
14. 向前查看与向后查看
Perl 5 引入了两个强大的正则语法：“向前查看”和“向后查看”。他们也被称作“零长度断言”。他们和锚定一样都是零长度的（所谓零长度即指该正则表达式不消耗被匹配的字符串）。不同之处在于“前后查看”会实际匹配字符，只是他们会抛弃匹配只返回匹配结果：匹配或不匹配。这就是为什么他们被称作“断言”。他们并不实际消耗字符串中的字符，而只是断言一个匹配是否可能。
几乎本文讨论的所有正则表达式的实现都支持“向前向后查看”。唯一的一个例外是JavaScript只支持向前查看。
· 肯定和否定式的向前查看
如我们前面提过的一个例子：要查找一个q，后面没有紧跟一个u。也就是说，要么q后面没有字符，要么后面的字符不是u。采用否定式向前查看后的一个解决方案为<>。否定式向前查看的语法是<<(?!查看的内容)>>。
肯定式向前查看和否定式向前查看很类似：<<(?=查看的内容)>>。
如果在“查看的内容”部分有组，也会产生一个向后引用。但是向前查看本身并不会产生向后引用，也不会被计入向后引用的编号中。这是因为向前查看本身是会被抛弃掉的，只保留匹配与否的判断结果。如果你想保留匹配的结果作为向后引用，你可以用<<(?=(regex))>>来产生一个向后引用。
· 肯定和否定式的先后查看
向后查看和向前查看有相同的效果，只是方向相反
否定式向后查看的语法是：<<(?>
肯定式向后查看的语法是：<<(?<=查看内容)>>
我们可以看到，和向前查看相比，多了一个表示方向的左尖括号。
例：<<(?>将会匹配一个没有“a”作前导字符的“b”。
值得注意的是：向前查看从当前字符串位置开始对“查看”正则表达式进行匹配；向后查看则从当前字符串位置开始先后回溯一个字符，然后再开始对“查看”正则表达式进行匹配。
· 深入正则表达式引擎内部
让我们看一个简单例子。
把正则表达式<>应用到字符串“Iraq”。正则表达式的第一个符号是<>。正如我们知道的，引擎在匹配<>以前会扫过整个字符串。当第四个字符“q”被匹配后，“q”后面是空字符(void)。而下一个正则符号是向前查看。引擎注意到已经进入了一个向前查看正则表达式部分。下一个正则符号是<>，和空字符不匹配，从而导致向前查看里的正则表达式匹配失败。因为是一个否定式的向前查看，意味着整个向前查看结果是成功的。于是匹配结果“q”被返回了。
我们在把相同的正则表达式应用到“quit”。<>匹配了“q”。下一个正则符号是向前查看部分的<>，它匹配了字符串中的第二个字符“i”。引擎继续走到下个字符“i”。然而引擎这时注意到向前查看部分已经处理完了，并且向前查看已经成功。于是引擎抛弃被匹配的字符串部分，这将导致引擎回退到字符“u”。
因为向前查看是否定式的，意味着查看部分的成功匹配导致了整个向前查看的失败，因此引擎不得不进行回溯。最后因为再没有其他的“q”和<>匹配，所以整个匹配失败了。
为了确保你能清楚地理解向前查看的实现，让我们把<>应用到“quit”。<>首先匹配“q”。然后向前查看成功匹配“u”，匹配的部分被抛弃，只返回可以匹配的判断结果。引擎从字符“i”回退到“u”。由于向前查看成功了，引擎继续处理下一个正则符号<>。结果发现<>和“u”不匹配。因此匹配失败了。由于后面没有其他的“q”，整个正则表达式的匹配失败了。
· 更进一步理解正则表达式引擎内部机制
让我们把<<(?<=a)b>>应用到“thingamabob”。引擎开始处理向后查看部分的正则符号和字符串中的第一个字符。在这个例子中，向后查看告诉正则表达式引擎回退一个字符，然后查看是否有一个“a”被匹配。因为在“t”前面没有字符，所以引擎不能回退。因此向后查看失败了。引擎继续走到下一个字符“h”。再一次，引擎暂时回退一个字符并检查是否有个“a”被匹配。结果发现了一个“t”。向后查看又失败了。
向后查看继续失败，直到正则表达式到达了字符串中的“m”，于是肯定式的向后查看被匹配了。因为它是零长度的，字符串的当前位置仍然是“m”。下一个正则符号是<>，和“m”匹配失败。下一个字符是字符串中的第二个“a”。引擎向后暂时回退一个字符，并且发现<>不匹配“m”。
在下一个字符是字符串中的第一个“b”。引擎暂时性的向后退一个字符发现向后查看被满足了，同时<>匹配了“b”。因此整个正则表达式被匹配了。作为结果，正则表达式返回字符串中的第一个“b”。
· 向前向后查看的应用
我们来看这样一个例子：查找一个具有6位字符的，含有“cat”的单词。
首先，我们可以不用向前向后查看来解决问题，例如：
<< cat\w{3}|\wcat\w{2}|\w{2}cat\w|\w{3}cat>>
足够简单吧！但是当需求变成查找一个具有6-12位字符，含有“cat”，“dog”或“mouse”的单词时，这种方法就变得有些笨拙了。
我们来看看使用向前查看的方案。在这个例子中，我们有两个基本需求要满足：一是我们需要一个6位的字符，二是单词含有“cat”。
满足第一个需求的正则表达式为<<\b\w{6}\b>>。满足第二个需求的正则表达式为<<\b\w*cat\w*\b>>。
把两者结合起来，我们可以得到如下的正则表达式：
<<(?=\b\w{6}\b)\b\w*cat\w*\b>>
具体的匹配过程留给读者。但是要注意的一点是，向前查看是不消耗字符的，因此当判断单词满足具有6个字符的条件后，引擎会从开始判断前的位置继续对后面的正则表达式进行匹配。
最后作些优化，可以得到下面的正则表达式：
<<\b(?=\w{6}\b)\w{0,3}cat\w*>>
15. 正则表达式中的条件测试
条件测试的语法为<<(?ifthen|else)>>。“if”部分可以是向前向后查看表达式。如果用向前查看，则语法变为：<<(?(?=regex)then|else)>>，其中else部分是可选的。
如果if部分为true，则正则引擎会试图匹配then部分，否则引擎会试图匹配else部分。
需要记住的是，向前先后查看并不实际消耗任何字符，因此后面的then与else部分的匹配时从if测试前的部分开始进行尝试。
16. 为正则表达式添加注释
在正则表达式中添加注释的语法是：<<(?#comment)>>
例：为用于匹配有效日期的正则表达式添加注释：
(?#year)(19|20)\d\d[- /.](?#month)(0[1-9]|1[012])[- /.](?#day)(0[1-9]|[12][0-9]|3[01])

前言：
半年前我对正则表达式产生了兴趣，在网上查找过不少资料，看过不少的教程，最后在使用一个正则表达式工具RegexBuddy时发现他的教程写的非常好，可以说是我目前见过最好的正则表达式教程。于是一直想把他翻译过来。这个愿望直到这个五一长假才得以实现，结果就有了这篇文章。关于本文的名字，使用“深入浅出”似乎已经太俗。但是通读原文以后，觉得只有用“深入浅出”才能准确的表达出该教程给我的感受，所以也就不能免俗了。
本文是Jan Goyvaerts为RegexBuddy写的教程的译文，版权归原作者所有，欢迎转载。但是为了尊重原作者和译者的劳动，请注明出处！谢谢！
1. 什么是正则表达式
基本说来，正则表达式是一种用来描述一定数量文本的模式。Regex代表Regular Express。本文将用<>来表示一段具体的正则表达式。
一段文本就是最基本的模式，简单的匹配相同的文本。
2. 不同的正则表达式引擎
正则表达式引擎是一种可以处理正则表达式的软件。通常，引擎是更大的应用程序的一部分。在软件世界，不同的正则表达式并不互相兼容。本教程会集中讨论Perl 5 类型的引擎，因为这种引擎是应用最广泛的引擎。同时我们也会提到一些和其他引擎的区别。许多近代的引擎都很类似，但不完全一样。例如.NET正则库，JDK正则包。
3. 文字符号
最基本的正则表达式由单个文字符号组成。如<>，它将匹配字符串中第一次出现的字符“a”。如对字符串“Jack is a boy”。“J”后的“a”将被匹配。而第二个“a”将不会被匹配。
正则表达式也可以匹配第二个“a”，这必须是你告诉正则表达式引擎从第一次匹配的地方开始搜索。在文本编辑器中，你可以使用“查找下一个”。在编程语言中，会有一个函数可以使你从前一次匹配的位置开始继续向后搜索。
类似的，<>会匹配“About cats and dogs”中的“cat”。这等于是告诉正则表达式引擎，找到一个<>，紧跟一个<>，再跟一个<>。
要注意，正则表达式引擎缺省是大小写敏感的。除非你告诉引擎忽略大小写，否则<>不会匹配“Cat”。
· 特殊字符
对于文字字符，有11个字符被保留作特殊用途。他们是：
[ ] \ ^ $ . | ? * + ( )
这些特殊字符也被称作元字符。
如果你想在正则表达式中将这些字符用作文本字符，你需要用反斜杠“\”对其进行换码 (escape)。例如你想匹配“1+1=2”，正确的表达式为<<1\+1=2>>.
需要注意的是，<<1+1=2>>也是有效的正则表达式。但它不会匹配“1+1=2”，而会匹配“123+111=234”中的“111=2”。因为“+”在这里表示特殊含义（重复1次到多次）。
在编程语言中，要注意，一些特殊的字符会先被编译器处理，然后再传递给正则引擎。因此正则表达式<<1\+2=2>>在C++中要写成“1\\+1=2”。为了匹配“C:\temp”，你要用正则表达式<>。而在C++中，正则表达式则变成了“C:\\\\temp”。
· 不可显示字符
可以使用特殊字符序列来代表某些不可显示字符：
<<\t>>代表Tab(0x09)
<<\r>>代表回车符(0x0D)
<<\n>>代表换行符(0x0A)
要注意的是Windows中文本文件使用“\r\n”来结束一行而Unix使用“\n”。
4. 正则表达式引擎的内部工作机制
知道正则表达式引擎是如何工作的有助于你很快理解为何某个正则表达式不像你期望的那样工作。
有两种类型的引擎：文本导向(text-directed)的引擎和正则导向(regex-directed)的引擎。Jeffrey Friedl把他们称作DFA和NFA引擎。本文谈到的是正则导向的引擎。这是因为一些非常有用的特性，如“惰性”量词(lazy quantifiers)和反向引用(backreferences)，只能在正则导向的引擎中实现。所以毫不意外这种引擎是目前最流行的引擎。
你可以轻易分辨出所使用的引擎是文本导向还是正则导向。如果反向引用或“惰性”量词被实现，则可以肯定你使用的引擎是正则导向的。你可以作如下测试：将正则表达式<>应用到字符串“regex not”。如果匹配的结果是regex，则引擎是正则导向的。如果结果是regex not，则是文本导向的。因为正则导向的引擎是“猴急”的，它会很急切的进行表功，报告它找到的第一个匹配 。
· 正则导向的引擎总是返回最左边的匹配
这是需要你理解的很重要的一点：即使以后有可能发现一个“更好”的匹配，正则导向的引擎也总是返回最左边的匹配。
当把<>应用到“He captured a catfish for his cat”，引擎先比较<>和“H”，结果失败了。于是引擎再比较<>和“e”，也失败了。直到第四个字符，<>匹配了“c”。<>匹配了第五个字符。到第六个字符<>没能匹配“p”，也失败了。引擎再继续从第五个字符重新检查匹配性。直到第十五个字符开始，<>匹配上了“catfish”中的“cat”，正则表达式引擎急切的返回第一个匹配的结果，而不会再继续查找是否有其他更好的匹配。
5. 字符集
字符集是由一对方括号“[]”括起来的字符集合。使用字符集，你可以告诉正则表达式引擎仅仅匹配多个字符中的一个。如果你想匹配一个“a”或一个“e”，使用<<[ae]>>。你可以使用<>匹配gray或grey。这在你不确定你要搜索的字符是采用美国英语还是英国英语时特别有用。相反，<>将不会匹配graay或graey。字符集中的字符顺序并没有什么关系，结果都是相同的。
你可以使用连字符“-”定义一个字符范围作为字符集。<<[0-9]>>匹配0到9之间的单个数字。你可以使用不止一个范围。<<[0-9a-fA-F] >>匹配单个的十六进制数字，并且大小写不敏感。你也可以结合范围定义与单个字符定义。<<[0-9a-fxA-FX]>>匹配一个十六进制数字或字母X。再次强调一下，字符和范围定义的先后顺序对结果没有影响。
· 字符集的一些应用
查找一个可能有拼写错误的单词，比如<> 或 <>。
查找程序语言的标识符，<>。(*表示重复0或多次)
查找C风格的十六进制数<<0[xX][A-Fa-f0-9]+>>。(+表示重复一次或多次)
· 取反字符集
在左方括号“[”后面紧跟一个尖括号“^”，将会对字符集取反。结果是字符集将匹配任何不在方括号中的字符。不像“.”，取反字符集是可以匹配回车换行符的。
需要记住的很重要的一点是，取反字符集必须要匹配一个字符。<>并不意味着：匹配一个q，后面没有u跟着。它意味着：匹配一个q，后面跟着一个不是u的字符。所以它不会匹配“Iraq”中的q，而会匹配“Iraq is a country”中的q和一个空格符。事实上，空格符是匹配中的一部分，因为它是一个“不是u的字符”。
如果你只想匹配一个q，条件是q后面有一个不是u的字符，我们可以用后面将讲到的向前查看来解决。
· 字符集中的元字符
需要注意的是，在字符集中只有4个 字符具有特殊含义。它们是：“] \ ^ -”。“]”代表字符集定义的结束；“\”代表转义；“^”代表取反；“-”代表范围定义。其他常见的元字符在字符集定义内部都是正常字符，不需要转义。例如，要搜索星号*或加号+，你可以用<<[+*]>>。当然，如果你对那些通常的元字符进行转义，你的正则表达式一样会工作得很好，但是这会降低可读性。
在字符集定义中为了将反斜杠“\”作为一个文字字符而非特殊含义的字符，你需要用另一个反斜杠对它进行转义。<<[\\x]>>将会匹配一个反斜杠和一个X。“]^-”都可以用反斜杠进行转义，或者将他们放在一个不可能使用到他们特殊含义的位置。我们推荐后者，因为这样可以增加可读性。比如对于字符“^”，将它放在除了左括号“[”后面的位置，使用的都是文字字符含义而非取反含义。如<<[x^]>>会匹配一个x或^。<<[]x]>>会匹配一个“]”或“x”。<<[-x]>>或<<[x-]>>都会匹配一个“-”或“x”。
· 字符集的简写
因为一些字符集非常常用，所以有一些简写方式。
<<\d>>代表<<[0-9]>>;
<<\w>>代表单词字符。这个是随正则表达式实现的不同而有些差异。绝大多数的正则表达式实现的单词字符集都包含了<>。
<<\s>>代表“白字符”。这个也是和不同的实现有关的。在绝大多数的实现中，都包含了空格符和Tab符，以及回车换行符<<\r\n>>。
字符集的缩写形式可以用在方括号之内或之外。<<\s\d>>匹配一个白字符后面紧跟一个数字。<<[\s\d]>>匹配单个白字符或数字。<<[\da-fA-F]>>将匹配一个十六进制数字。
取反字符集的简写
<<[\S]>> = <<[^\s]>>
<<[\W]>> = <<[^\w]>>
<<[\D]>> = <<[^\d]>>
· 字符集的重复
如果你用“?*+”操作符来重复一个字符集，你将会重复整个字符集。而不仅是它匹配的那个字符。正则表达式<<[0-9]+>>会匹配837以及222。
如果你仅仅想重复被匹配的那个字符，可以用向后引用达到目的。我们以后将讲到向后引用。
6. 使用?*或+ 进行重复
?：告诉引擎匹配前导字符0次或一次。事实上是表示前导字符是可选的。
+：告诉引擎匹配前导字符1次或多次
*：告诉引擎匹配前导字符0次或多次
<[A-Za-z][A-Za-z0-9]*>匹配没有属性的HTML标签，“<”以及“>”是文字符号。第一个字符集匹配一个字母，第二个字符集匹配一个字母或数字。
我们似乎也可以用<[A-Za-z0-9]+>。但是它会匹配<1>。但是这个正则表达式在你知道你要搜索的字符串不包含类似的无效标签时还是足够有效的。
· 限制性重复
许多现代的正则表达式实现，都允许你定义对一个字符重复多少次。词法是：{min,max}。min和max都是非负整数。如果逗号有而max被忽略了，则max没有限制。如果逗号和max都被忽略了，则重复min次。
因此{0,}和*一样，{1，}和+ 的作用一样。
你可以用<<\b[1-9][0-9]{3}\b>>匹配1000~9999之间的数字(“\b”表示单词边界)。<<\b[1-9][0-9]{2,4}\b>>匹配一个在100~99999之间的数字。
· 注意贪婪性
假设你想用一个正则表达式匹配一个HTML标签。你知道输入将会是一个有效的HTML文件，因此正则表达式不需要排除那些无效的标签。所以如果是在两个尖括号之间的内容，就应该是一个HTML标签。
许多正则表达式的新手会首先想到用正则表达式<< <.+> >>，他们会很惊讶的发现，对于测试字符串，“This is a first test”，你可能期望会返回，然后继续进行匹配的时候，返回。
但事实是不会。正则表达式将会匹配“first”。很显然这不是我们想要的结果。原因在于“+”是贪婪的。也就是说，“+”会导致正则表达式引擎试图尽可能的重复前导字符。只有当这种重复会引起整个正则表达式匹配失败的情况下，引擎会进行回溯。也就是说，它会放弃最后一次的“重复”，然后处理正则表达式余下的部分。
和“+”类似，“?*”的重复也是贪婪的。
· 深入正则表达式引擎内部
让我们来看看正则引擎如何匹配前面的例子。第一个记号是“<”，这是一个文字符号。第二个符号是“.”，匹配了字符“E”，然后“+”一直可以匹配其余的字符，直到一行的结束。然后到了换行符，匹配失败(“.”不匹配换行符)。于是引擎开始对下一个正则表达式符号进行匹配。也即试图匹配“>”。到目前为止，“<.+”已经匹配了“first test”。引擎会试图将“>”与换行符进行匹配，结果失败了。于是引擎进行回溯。结果是现在“<.+”匹配“first tes”。于是引擎将“>”与“t”进行匹配。显然还是会失败。这个过程继续，直到“<.+”匹配“first”与“>”匹配。于是引擎找到了一个匹配“first”。记住，正则导向的引擎是“急切的”，所以它会急着报告它找到的第一个匹配。而不是继续回溯，即使可能会有更好的匹配，例如“”。所以我们可以看到，由于“+”的贪婪性，使得正则表达式引擎返回了一个最左边的最长的匹配。
· 用懒惰性取代贪婪性
一个用于修正以上问题的可能方案是用“+”的惰性代替贪婪性。你可以在“+”后面紧跟一个问号“?”来达到这一点。“*”，“{}”和“?”表示的重复也可以用这个方案。因此在上面的例子中我们可以使用“<.+?>”。让我们再来看看正则表达式引擎的处理过程。
再一次，正则表达式记号“<”会匹配字符串的第一个“<”。下一个正则记号是“.”。这次是一个懒惰的“+”来重复上一个字符。这告诉正则引擎，尽可能少的重复上一个字符。因此引擎匹配“.”和字符“E”，然后用“>”匹配“M”，结果失败了。引擎会进行回溯，和上一个例子不同，因为是惰性重复，所以引擎是扩展惰性重复而不是减少，于是“<.+”现在被扩展为“”。这次得到了一个成功匹配。引擎于是报告“”是一个成功的匹配。整个过程大致如此。
· 惰性扩展的一个替代方案
我们还有一个更好的替代方案。可以用一个贪婪重复与一个取反字符集：“<[^>]+>”。之所以说这是一个更好的方案在于使用惰性重复时，引擎会在找到一个成功匹配前对每一个字符进行回溯。而使用取反字符集则不需要进行回溯。
最后要记住的是，本教程仅仅谈到的是正则导向的引擎。文本导向的引擎是不回溯的。但是同时他们也不支持惰性重复操作。
7. 使用“.”匹配几乎任意字符
在正则表达式中，“.”是最常用的符号之一。不幸的是，它也是最容易被误用的符号之一。
“.”匹配一个单个的字符而不用关心被匹配的字符是什么。唯一的例外是新行符。在本教程中谈到的引擎，缺省情况下都是不匹配新行符的。因此在缺省情况下，“.”等于是字符集[^\n\r](Window)或[^\n]( Unix)的简写。
这个例外是因为历史的原因。因为早期使用正则表达式的工具是基于行的。它们都是一行一行的读入一个文件，将正则表达式分别应用到每一行上去。在这些工具中，字符串是不包含新行符的。因此“.”也就从不匹配新行符。
现代的工具和语言能够将正则表达式应用到很大的字符串甚至整个文件上去。本教程讨论的所有正则表达式实现都提供一个选项，可以使“.”匹配所有的字符，包括新行符。在RegexBuddy, EditPad Pro或PowerGREP等工具中，你可以简单的选中“点号匹配新行符”。在Perl中，“.”可以匹配新行符的模式被称作“单行模式”。很不幸，这是一个很容易混淆的名词。因为还有所谓“多行模式”。多行模式只影响行首行尾的锚定(anchor)，而单行模式只影响“.”。
其他语言和正则表达式库也采用了Perl的术语定义。当在.NET Framework中使用正则表达式类时，你可以用类似下面的语句来激活单行模式：Regex.Match(“string”,”regex”,RegexOptions.SingleLine)
· 保守的使用点号“.”
点号可以说是最强大的元字符。它允许你偷懒：用一个点号，就能匹配几乎所有的字符。但是问题在于，它也常常会匹配不该匹配的字符。
我会以一个简单的例子来说明。让我们看看如何匹配一个具有“mm/dd/yy”格式的日期，但是我们想允许用户来选择分隔符。很快能想到的一个方案是<<\d\d.\d\d.\d\d>>。看上去它能匹配日期“02/12/03”。问题在于02512703也会被认为是一个有效的日期。
<<\d\d[-/.]\d\d[-/.]\d\d>>看上去是一个好一点的解决方案。记住点号在一个字符集里不是元字符。这个方案远不够完善，它会匹配“99/99/99”。而<<[0-1]\d[-/.][0-3]\d[-/.]\d\d>>又更进一步。尽管他也会匹配“19/39/99”。你想要你的正则表达式达到如何完美的程度取决于你想达到什么样的目的。如果你想校验用户输入，则需要尽可能的完美。如果你只是想分析一个已知的源，并且我们知道没有错误的数据，用一个比较好的正则表达式来匹配你想要搜寻的字符就已经足够。
8. 字符串开始和结束的锚定
锚定和一般的正则表达式符号不同，它不匹配任何字符。相反，他们匹配的是字符之前或之后的位置。“^”匹配一行字符串第一个字符前的位置。<<^a>>将会匹配字符串“abc”中的a。<<^b>>将不会匹配“abc”中的任何字符。
类似的，$匹配字符串中最后一个字符的后面的位置。所以<>匹配“abc”中的c。
· 锚定的应用
在编程语言中校验用户输入时，使用锚定是非常重要的。如果你想校验用户的输入为整数，用<<^\d+$>>。
用户输入中，常常会有多余的前导空格或结束空格。你可以用<<^\s*>>和<<\s*$>>来匹配前导空格或结束空格。
· 使用“^”和“$”作为行的开始和结束锚定
如果你有一个包含了多行的字符串。例如：“first line\n\rsecond line”(其中\n\r表示一个新行符)。常常需要对每行分别处理而不是整个字符串。因此，几乎所有的正则表达式引擎都提供一个选项，可以扩展这两种锚定的含义。“^”可以匹配字串的开始位置(在f之前)，以及每一个新行符的后面位置(在\n\r和s之间)。类似的，$会匹配字串的结束位置(最后一个e之后)，以及每个新行符的前面(在e与\n\r之间)。
在.NET中，当你使用如下代码时，将会定义锚定匹配每一个新行符的前面和后面位置：Regex.Match(“string”, “regex”, RegexOptions.Multiline)
应用：string str = Regex.Replace(Original, “^”, “> “, RegexOptions.Multiline)–将会在每行的行首插入“> ”。
· 绝对锚定
<<\A>>只匹配整个字符串的开始位置，<<\Z>>只匹配整个字符串的结束位置。即使你使用了“多行模式”，<<\A>>和<<\Z>>也从不匹配新行符。
即使\Z和$只匹配字符串的结束位置，仍然有一个例外的情况。如果字符串以新行符结束，则\Z和$将会匹配新行符前面的位置，而不是整个字符串的最后面。这个“改进”是由Perl引进的，然后被许多的正则表达式实现所遵循，包括Java，.NET等。如果应用<<^[a-z]+$>>到“joe\n”，则匹配结果是“joe”而不是“joe\n”。

简介 Book Description
Flexible Rails is a unique, application-based guide for using Ruby on Rails 2 and Adobe Flex 3 to build rich Internet applications (RIAs). It is not an exhaustive Ruby on Rails or Flex reference. Instead, it is an extensive tutorial in which the reader builds multiple iterations of an interesting RIA using Flex and Rails together.
Author Peter Armstrong walks readers through eleven iterations in which the sample application–pomodo–is variously built, refactored, Debugged, sliced, diced and otherwise explored from every conceivable angle with respect to Ruby on Rails and Adobe Flex. The book unfolds both the application and the Flex-on-Rails approach side-by-side.
目录 Summary of contents
PART 1 GETTING STARTED ………………………………………………. 1
1 ■ Why are we here? Where are we going? 3
2 ■ Hello World 14
3 ■ Getting started 52
PART 2 BUILDING THE APPLICATION………………………………. 103
4 ■ Creating the main Flex UI 105
5 ■ Expanding the Rails code, RESTfully 118
6 ■ Flex on Rails 186
7 ■ Validation 261
PART 3 REFACTORING…………………………………………………. 293
8 ■ Refactoring to Cairngorm 295
9 ■ Holding state on the client properly 369
PART 4 FINISHING UP………………………………………………….. 419
10 ■ Finishing the application 421
11 ■ Refactoring to RubyAMF 468
12 ■ Rails on AIR (Adobe Integrated Runtime) 512
作者 About the Author
Peter Armstrong is a professional developer who has been working with Flex full-time since July 2004 and Ruby on Rails since mid-2005–that's before Rails 1.0. His background includes five years of working with Java Swing and a brief stint with PHP during the dotcom bubble in 2000.
下载 Download
点击下载此文件

本程序三个页面,其中的远程获取类非常不错.
这个也是学习asp小偷程序的好例子.
页面演示见:http://www.aspxuexi.com/forfun/pagerank/pr.asp
三个页面:
CLS_Asphttp.asp
<% '================================================================= '飞扬远程获取类(AspHttp) 1.0.1 Bate1 ' By 奔腾的心 ' 2006-04-19 '================================================================= Class FlyCms_AspHttp Public oForm,oXml,Ados Public strHeaders Public sMethod Public sUrl Public sReferer Public sSetCookie Public sLanguage Public sCONTENT Public sAgent Public sEncoding Public sAccept Public sData Public sCodeBase Private slresolveTimeout,slconnectTimeout,slsendTimeout,slreceiveTimeout ' ============================================ ' 类模块初始化 ' ============================================ Private Sub Class_Initialize() oForm = "" Set oXml = Server.CreateObject("MSXML2.ServerXMLHTTP") set Ados = Server.CreateObject("Adodb.Stream") slresolveTimeout = 20000 ' 解析DNS名字的超时时间,20秒 slconnectTimeout = 20000 ' 建立Winsock连接的超时时间,20秒 slsendTimeout = 30000 ' 发送数据的超时时间,30秒 slreceiveTimeout = 30000 ' 接收response的超时时间,30秒 End Sub ' ============================================ ' 返回版本信息 ' ============================================ Public Property Get Version Version = "飞扬asphttp类1.0.0" End Property ' ============================================ ' 解析DNS名字的超时时间 ' ============================================ Public Property Let lresolveTimeout(LngSize) If IsNumeric(LngSize) Then slresolveTimeout = Clng(LngSize) End If End Property ' ============================================ ' 建立Winsock连接的超时时间 ' ============================================ Public Property Let lconnectTimeout(LngSize) If IsNumeric(LngSize) Then slconnectTimeout = Clng(LngSize) End If End Property ' ============================================ ' 发送数据的超时时间 ' ============================================ Public Property Let lsendTimeout(LngSize) If IsNumeric(LngSize) Then slsendTimeout = Clng(LngSize) End If End Property ' ============================================ ' 接收response的超时时间 ' ============================================ Public Property Let lreceiveTimeout(LngSize) If IsNumeric(LngSize) Then slreceiveTimeout = Clng(LngSize) End If End Property ' ============================================ ' Method ' ============================================ Public Property Let Method(strMethod) sMethod = strMethod End Property ' ============================================ ' 发送url ' ============================================ Public Property Let Url(strUrl) sUrl = strUrl End Property ' ============================================ ' Data ' ============================================ Public Property Let Data(strData) sData = strData End Property ' ============================================ ' Referer ' ============================================ Public Property Let Referer(strReferer) sReferer = strReferer End Property ' ============================================ ' SetCookie ' ============================================ Public Property Let SetCookie(strCookie) sSetCookie = strCookie End Property ' ============================================ ' Language ' ============================================ Public Property Let Language(strLanguage) sLanguage = strLanguage End Property ' ============================================ ' CONTENT-Type ' ============================================ Public Property Let CONTENT(strCONTENT) sCONTENT = strCONTENT End Property ' ============================================ ' User-Agent ' ============================================ Public Property Let Agent(strAgent) sAgent = strAgent End Property ' ============================================ ' Accept-Encoding ' ============================================ Public Property Let Encoding(strEncoding) sEncoding = strEncoding End Property ' ============================================ ' Accept ' ============================================ Public Property Let Accept(strAccept) sAccept = strAccept End Property ' ============================================ ' CodeBase ' ============================================ Public Property Let CodeBase(strCodeBase) sCodeBase = strCodeBase End Property ' ============================================ ' 建立数据传送对向! ' ============================================ Public Function AddItem(Key, Value) On Error Resume Next Dim TempStr If oForm = "" Then oForm = Key + "=" + Server.URLEncode(Value) Else oForm = oForm + "&" + Key + "=" + Server.URLEncode(Value) End If End Function ' ============================================ ' 发送数据并取回远程数据 ' ============================================ Public Function HttpGet() Dim sReturn With oXml .setTimeouts slresolveTimeout,slconnectTimeout,slsendTimeout,slreceiveTimeout .Open sMethod,sUrl,False If sSetCookie<>“” Then
.setRequestHeader “Cookie”, sSetCookie '设定Cookie
End If
If sReferer<>“” Then
.setRequestHeader “Referer”, sReferer '设定页面来源
Else
.setRequestHeader “Referer”, sUrl
End If
If sLanguage<>“” Then
.setRequestHeader “Accept-Language”, sLanguage '设定语言
End If
.setRequestHeader “Content-Length”,Len(sData) '设定数据长度
If sCONTENT<>“” Then
.setRequestHeader “CONTENT-Type”,sCONTENT '设定接受数据类型
End If
If sAgent<>“” Then
.setRequestHeader “User-Agent”, sAgent '设定浏览器
End If
If sEncoding<>“” Then
.setRequestHeader “Accept-Encoding”, sEncoding '设定gzip压缩
End If
If sAccept<>“” Then
.setRequestHeader “Accept”, sAccept '文档类型
End If
Response.Write sData
.Send sData '发送数据
While .readyState <> 4
.waitForResponse 1000
Wend
strHeaders = .getAllResponseHeaders()
If sCodeBase<>“” Then
sReturn = bytes2BSTR(.responseBody)
Else
sReturn = .responseBody
End If
End With
HttpGet = sReturn
End Function
' ============================================
' 处理二进制数据
' ============================================
Private Function bytes2BSTR(vIn)
strReturn = “”
For i = 1 To LenB(vIn)
ThisCharCode = AscB(MidB(vIn,i,1))
If ThisCharCode < &H80 Then strReturn = strReturn & Chr(ThisCharCode) Else NextCharCode = AscB(MidB(vIn,i+1,1)) strReturn = strReturn & Chr(CLng(ThisCharCode) * &H100 + CInt(NextCharCode)) i = i + 1 End If Next bytes2BSTR = strReturn End Function ' ============================================ ' 类模块注销 ' ============================================ Private Sub Class_Terminate oForm = "" Set oXml = Nothing Set Ados = Nothing End Sub End Class %>
googleCH.asp
<% Const GOOGLE_MAGIC = &HE6359A60 Function sl(ByVal x, ByVal n) If n = 0 Then sl = x Else Dim k k = CLng(2 ^ (32 - n - 1)) Dim d d = x And (k - 1) Dim c c = d * CLng(2 ^ n) If x And k Then c = c or &H80000000 End If sl = c End If End Function '//from www.aspxuexi.com Function sr(ByVal x, ByVal n) If n = 0 Then sr = x Else Dim y y = x And &H7FFFFFFF Dim z If n = 32 - 1 Then z = 0 Else z = y \ CLng(2 ^ n) End If If y <> x Then
z = z or CLng(2 ^ (32 – n – 1))
End If
sr = z
End If
End Function
Function zeroFill(ByVal a, ByVal b)
Dim x
If (&H80000000 And a) Then
x = sr(a, 1)
x = x And (Not &H80000000)
x = x or &H40000000
x = sr(x, b – 1)
Else
x = sr(a, b)
End If
zeroFill = x
End Function
Private Function uadd(ByVal L1, ByVal L2)
Dim L11, L12, L21, L22, L31, L32
L11 = L1 And &HFFFFFF
L12 = (L1 And &H7F000000) \ &H1000000
If L1 < 0 Then L12 = L12 or &H80 L21 = L2 And &HFFFFFF L22 = (L2 And &H7F000000) \ &H1000000 If L2 < 0 Then L22 = L22 or &H80 L32 = L12 + L22 L31 = L11 + L21 If (L31 And &H1000000) Then L32 = L32 + 1 uadd = (L31 And &HFFFFFF) + (L32 And &H7F) * &H1000000 If L32 And &H80 Then uadd = uadd or &H80000000 End Function Private Function usub(ByVal L1, ByVal L2) Dim L11, L12, L21, L22, L31, L32 L11 = L1 And &HFFFFFF L12 = (L1 And &H7F000000) \ &H1000000 If L1 < 0 Then L12 = L12 or &H80 L21 = L2 And &HFFFFFF L22 = (L2 And &H7F000000) \ &H1000000 If L2 < 0 Then L22 = L22 or &H80 L32 = L12 - L22 L31 = L11 - L21 If L31 < 0 Then L32 = L32 - 1 L31 = L31 + &H1000000 End If usub = L31 + (L32 And &H7F) * &H1000000 If L32 And &H80 Then usub = usub or &H80000000 End Function Function mix(ByVal ia, ByVal ib, ByVal ic) Dim a, b, c a = ia b = ib c = ic a = usub(a, b) a = usub(a, c) a = a Xor zeroFill(c, 13) b = usub(b, c) b = usub(b, a) b = b Xor sl(a, 8) c = usub(c, a) c = usub(c, b) c = c Xor zeroFill(b, 13) a = usub(a, b) a = usub(a, c) a = a Xor zeroFill(c, 12) b = usub(b, c) b = usub(b, a) b = b Xor sl(a, 16) c = usub(c, a) c = usub(c, b) c = c Xor zeroFill(b, 5) a = usub(a, b) a = usub(a, c) a = a Xor zeroFill(c, 3) b = usub(b, c) b = usub(b, a) b = b Xor sl(a, 10) c = usub(c, a) c = usub(c, b) c = c Xor zeroFill(b, 15) Dim ret(3) ret(0) = a ret(1) = b ret(2) = c mix = ret End Function Function gc(ByVal s, ByVal i) gc = Asc(Mid(s, i + 1, 1)) End Function Function GoogleCH(ByVal sUrl) Dim iLength, a, b, c, k, iLen, m iLength = Len(sUrl) a = &H9E3779B9 b = &H9E3779B9 c = GOOGLE_MAGIC k = 0 iLen = iLength Do While iLen >= 12
a = uadd(a, (uadd(gc(sUrl, k + 0), uadd(sl(gc(sUrl, k + 1), 8), uadd(sl(gc(sUrl, k + 2), 16), sl(gc(sUrl, k + 3), 24))))))
b = uadd(b, (uadd(gc(sUrl, k + 4), uadd(sl(gc(sUrl, k + 5), 8), uadd(sl(gc(sUrl, k + 6), 16), sl(gc(sUrl, k + 7), 24))))))
c = uadd(c, (uadd(gc(sUrl, k + 8), uadd(sl(gc(sUrl, k + 9), 8), uadd(sl(gc(sUrl, k + 10), 16), sl(gc(sUrl, k + 11), 24))))))
m = mix(a, b, c)
a = m(0)
b = m(1)
c = m(2)
k = k + 12
iLen = iLen – 12
Loop
c = uadd(c, iLength)
Select Case iLen ' all the case statements fall through
Case 11
c = uadd(c, sl(gc(sUrl, k + 10), 24))
c = uadd(c, sl(gc(sUrl, k + 9), 16))
c = uadd(c, sl(gc(sUrl, k + 8), 8))
b = uadd(b, sl(gc(sUrl, k + 7), 24))
b = uadd(b, sl(gc(sUrl, k + 6), 16))
b = uadd(b, sl(gc(sUrl, k + 5), 8))
b = uadd(b, gc(sUrl, k + 4))
a = uadd(a, sl(gc(sUrl, k + 3), 24))
a = uadd(a, sl(gc(sUrl, k + 2), 16))
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 10
c = uadd(c, sl(gc(sUrl, k + 9), 16))
c = uadd(c, sl(gc(sUrl, k + 8), 8))
b = uadd(b, sl(gc(sUrl, k + 7), 24))
b = uadd(b, sl(gc(sUrl, k + 6), 16))
b = uadd(b, sl(gc(sUrl, k + 5), 8))
b = uadd(b, gc(sUrl, k + 4))
a = uadd(a, sl(gc(sUrl, k + 3), 24))
a = uadd(a, sl(gc(sUrl, k + 2), 16))
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 9
c = uadd(c, sl(gc(sUrl, k + 8), 8))
b = uadd(b, sl(gc(sUrl, k + 7), 24))
b = uadd(b, sl(gc(sUrl, k + 6), 16))
b = uadd(b, sl(gc(sUrl, k + 5), 8))
b = uadd(b, gc(sUrl, k + 4))
a = uadd(a, sl(gc(sUrl, k + 3), 24))
a = uadd(a, sl(gc(sUrl, k + 2), 16))
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 8
b = uadd(b, sl(gc(sUrl, k + 7), 24))
b = uadd(b, sl(gc(sUrl, k + 6), 16))
b = uadd(b, sl(gc(sUrl, k + 5), 8))
b = uadd(b, gc(sUrl, k + 4))
a = uadd(a, sl(gc(sUrl, k + 3), 24))
a = uadd(a, sl(gc(sUrl, k + 2), 16))
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 7
b = uadd(b, sl(gc(sUrl, k + 6), 16))
b = uadd(b, sl(gc(sUrl, k + 5), 8))
b = uadd(b, gc(sUrl, k + 4))
a = uadd(a, sl(gc(sUrl, k + 3), 24))
a = uadd(a, sl(gc(sUrl, k + 2), 16))
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 6
b = uadd(b, sl(gc(sUrl, k + 5), 8))
b = uadd(b, gc(sUrl, k + 4))
a = uadd(a, sl(gc(sUrl, k + 3), 24))
a = uadd(a, sl(gc(sUrl, k + 2), 16))
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 5
b = uadd(b, gc(sUrl, k + 4))
a = uadd(a, sl(gc(sUrl, k + 3), 24))
a = uadd(a, sl(gc(sUrl, k + 2), 16))
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 4
a = uadd(a, sl(gc(sUrl, k + 3), 24))
a = uadd(a, sl(gc(sUrl, k + 2), 16))
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 3
a = uadd(a, sl(gc(sUrl, k + 2), 16))
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 2
'//form http://www.aspxuexi.com
a = uadd(a, sl(gc(sUrl, k + 1), 8))
a = uadd(a, gc(sUrl, k + 0))
Case 1
a = uadd(a, gc(sUrl, k + 0))
End Select
m = mix(a, b, c)
GoogleCH = m(2)
End Function
Function CalculateChecksum(sUrl)
CalculateChecksum = “6” & CStr(GoogleCH(“info:” & sUrl))
End Function
%>
PR.asp


<% Sub Rw(Str) Response.Write Str & vbCrLf Response.Flush End Sub Function HttpGet(lresolveTimeout,lconnectTimeout,lsendTimeout,lreceiveTimeout,Method,Url,Referer,Data,SetCookie,Language,CONTENT,Agent,Encoding,Accept,CodeBase) Set DoGet = New FlyCms_AspHttp DoGet.lresolveTimeout = lresolveTimeout DoGet.lconnectTimeout = lconnectTimeout DoGet.lsendTimeout = lsendTimeout DoGet.lreceiveTimeout = lreceiveTimeout DoGet.Method = Method DoGet.Url = Url DoGet.Referer = Referer DoGet.Data = Data DoGet.SetCookie = SetCookie DoGet.Language = Language DoGet.CONTENT = CONTENT DoGet.Agent = Agent DoGet.Encoding = Encoding DoGet.Accept = Accept DoGet.CodeBase = CodeBase HttpGet = DoGet.HttpGet() Set DoGet = Nothing End Function Function GGPR(ByVal URL) Dim strRet sURL = "http://www.google.com/search?client=navclient-auto&ch=" & CalculateChecksum(URL) & "&features=Rank&q=info:" & URL Rw "查询地址: " & sURL & " " strRet = HttpGet(10000,10000,20000,20000,"GET",sUrl,"","","","zh-cn","","Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)","","*/*","gb2312") If InStr(strRet,":") Then R = Split(strRet,":") GGPR = R(2) Else GGPR = 0 End If Rw "返回结果: " & strRet & " " Rw "　　PR值: " & GGPR & " " End Function iURL = Request("iURL") If iURL="" Then iURL = "http://www.aspxuexi.com" Call GGPR(iURL) %>

现在网上流行的小偷程序比较多，有新闻类小偷，音乐小偷，下载小偷，那么它们是如何做的呢，下面我来做个简单介绍，希望对各位站长有所帮助。
（一）原理
小偷程序实际上是通过了XML中的XMLHTTP组件调用其它网站上的网页。比如新闻小偷程序，很多都是调用了sina的新闻网页，并且对其中的html 进行了一些替换，同时对广告也进行了过滤。用小偷程序的优点有：无须维护网站，因为小偷程序中的数据来自其他网站，它将随着该网站的更新而更新；可以节省 服务器资源，一般小偷程序就几个文件，所有网页内容都是来自其他网站。缺点有：不稳定，如果目标网站出错，程序也会出错，而且，如果目标网站进行升级维 护，那么小偷程序也要进行相应修改；速度，因为是远程调用，速度和在本地服务器上读取数据比起来，肯定要慢一些。
（二）事例
下面就XMLHTTP在ASP中的应用做个简单说明
<%
'常用函数
'1、输入url目标网页地址，返回值getHTTPPage是目标网页的html代码
function getHTTPPage(url)
     dim Http
     set Http=server.createobject("MSXML2.XMLHTTP")
     Http.open "GET",url,false
     Http.send()
     if Http.readystate<>4 then
         exit function
     end if
     getHTTPPage=bytesToBSTR(Http.responseBody,"GB2312")
     set http=nothing
     if err.number<>0 then err.Clear
end function
'2、转换乱玛，直接用xmlhttp调用有中文字符的网页得到的将是乱玛，可以通过adodb.stream组件进行转换
Function BytesToBstr(body,Cset)
         dim objstream
         set objstream = Server.CreateObject("adodb.stream")
         objstream.Type = 1
         objstream.Mode =3
         objstream.Open
         objstream.Write body
         objstream.Position = 0
         objstream.Type = 2
         objstream.Charset = Cset
         BytesToBstr = objstream.ReadText
         objstream.Close
         set objstream = nothing
End Function
'下面试着调用 http://www.sgxcn.com/doc/ 的html内容
Dim Url,Html
Url="http://www.sgxcn.com/doc/"
Html = getHTTPPage(Url)
Response.write Html
%>

说一下我对HTML防采集却不防搜索引擎蜘蛛的一些经验：
我开发过几个采集程序，也研究过很多采集程序代码，所以对采集程序的原理还算是稍微有些了解。
先说一下采集原理：
采集程序的主要步骤如下：
一、获取被采集的页面的内容
二、从获取代码中提取所有用的数据
一、获取被采集的页面的内容
我目前所掌握的ASP常用获取被采集的页面的内容方法：
1、用serverXMLHTTP组件获取数据
Function GetBody(weburl)
'创建对象
Dim ObjXMLHTTP
Set ObjXMLHTTP=Server.CreateObject(“MSXML2.serverXMLHTTP”)
'请求文件,以异步形式
ObjXMLHTTP.Open “GET”,weburl,False
ObjXMLHTTP.send
While ObjXMLHTTP.readyState <> 4
ObjXMLHTTP.waitForResponse 1000
Wend
'得到结果
GetBody=ObjXMLHTTP.responseBody
'释放对象
Set ObjXMLHTTP=Nothing
End Function
调用方法：
GetBody(文件的URLf地址)
2、或XMLHTTP组件获取数据
Function GetBody(weburl)
'创建对象
Set Retrieval = CreateObject(“Microsoft.XMLHTTP”)
With Retrieval
.Open “Get”, weburl, False, “”, “”
.Send
GetBody = .ResponseBody
End With
'释放对象
Set Retrieval = Nothing
End Function
调用方法：
GetBody(文件的URLf地址)
这样获取的数据内容还需要进行编码转换才可以使用
Function BytesToBstr(body,Cset)
dim objstream
set objstream = Server.CreateObject(“adodb.stream”)
objstream.Type = 1
objstream.Mode =3
objstream.Open
objstream.Write body
objstream.Position = 0
objstream.Type = 2
objstream.Charset = Cset
BytesToBstr = objstream.ReadText
objstream.Close
set objstream = nothing
End Function
调用方法：BytesToBstr(要转换的数据,编码)'编码常用为GB2312和UTF-8
二、从获取代码中提取所有用的数据
目前我掌握的方法有：
1、用ASP内置的MID函数截取需要的数据
Function body(wstr,start,over)
start=Newstring(wstr,start)
'设置需要处理的数据的唯一的开始标记
over=Newstring(wstr,over)
'和start相对应的就是需要处理的数据的唯一的结束标记
body=mid(wstr,start,over-start)
'设置显示页面的范围
End Function
调用方法：body(被采集的页面的内容,开始标记,结束标记)
2、用正则获取需要的数据
Function body(wstr,start,over)
Set xiaoqi = New Regexp'设置配置对象
xiaoqi.IgnoreCase = True'忽略大小写
xiaoqi.Global = True'设置为全文搜索
xiaoqi.Pattern = “”&start&“.+?”&over&“”'正则表达式
Set Matches =xiaoqi.Execute(wstr)'开始执行配置
set xiaoqi=nothing
body=””
For Each Match in Matches
body=body&Match.Value '循环匹配
Next
End Function
调用方法：body(被采集的页面的内容,开始标记,结束标记)
采集程序祥细思路：
1、取得网站的分页列表页的每页地址
目前绝大部分动态网站的分页地址都有规则，如:
动态页
第一页：index.asp?page=1
第二页：index.asp?page=2
第三页：index.asp?page=3
…..
静态页
第一页：page_1.htm
第二页：page_2.htm
第三页：page_3.htm
…..
取得网站的分页列表页的每页地址，只需要用变量替代每页地址的变化的字符即可如：page_<%="&page&"%>.htm
2、获取被采集网站的分页列表页内容
3、从分页列表代码中提取被采集的内容页面的URL连接地址
绝大部分分页页面里的内容页连接也有固定规则，如：
连接1
连接2
连接3
用以下代码就可以获得一个URL连接集合
Set xiaoqi = New Regexp
xiaoqi.IgnoreCase = True
xiaoqi.Global = True
xiaoqi.Pattern = ””“.+?”““
Set Matches =xiaoqi.Execute(页面列表内容)
set xiaoqi=nothing
url=””
For Each Match in Matches
url=url&Match.Value
Next
4、取得被采集的内容页面内容，根据”提取标记“从被采集的内容页面分别截取要取得的数据
因为是动态生成的页面，大多数内容页面内都有相同的html标记，我们可以根据这些有规则的标记提取需要的各个部分的内容。
如：
每个页面都有网页标题，用我上面写的MID截取函数就可以获得之间的值，也可以用正则表达式来获得。
例：body(““,”“)
介绍完采集器的祥细原理后，就开始说一下防采集的策略。
目前防采集的方法有很多种，先介绍一下常见防采集策略方法和它的弊端及采集对策：
一、判断一个IP在一定时间内对本站页面的访问次数，如果明显超过了正常人浏览速度，就拒绝此IP访问
弊端：
1、此方法只适用于动态页面，如：asp\jsp\php等…静态页面无法判断某个IP一定时间访问本站页面的次数
2、此方法会严重影响搜索引擎蜘蛛对其收录，因为搜索引擎蜘蛛收录时，浏览速度都会比较快而且是多线程。此方法也会拒绝搜索引擎蜘蛛收录站内文件
采集对策：只能放慢采集速度，或者不采
建议：做个搜索引擎蜘蛛的IP库，只允许搜索引擎蜘蛛快速浏览站内内容。搜索引擎蜘蛛的IP库的收集，也不太容易，一个搜索引擎蜘蛛，也不一定只有一个固定的IP地址。
评论：此方法对防采集比较有效，但却会影响搜索引擎对其收录。
二、用JavaScript加密内容页面
弊端：此方法适用于静态页面，但会严重影响搜索引擎对其收录情况，搜索引擎收到到的内容，也都是加密后的内容
采集对策：建议不采，如非要采，就把解密码的JS脚本也采下来。
建议：目前没有好的改良建议
评论：建议指望搜索引擎带流量的站长不要使用此方法。
三、把内容页面里的特定标记替换为”特定标记+隐藏版权文字“
弊端：此方法弊端不大，仅仅会增加一点点的页面文件大小，但容易反采集
采集对策：把采集来的含有隐藏版权文字内容的版权文字替掉，或替换成自己的版权。
建议：目前没有好的改良建议
评论：自己感觉实用价值不大，就算是加上随机的隐藏文字，也等于画蛇添足。
四、只允许用户登陆后才可以浏览
弊端：此方法会严重影响搜索引擎蜘蛛对其收录
采集对策：目前落伍已经有人发了对策文章 ，具体对策就看这个吧《ASP小偷程序如何利用XMLHTTP实现表单的提交以及cookies或session的发送》
建议：目前没有好的改良建议
评论：建议指望搜索引擎带流量的站长不要使用此方法。不过此方法防一般的采集程序，还是有点效果的。
五、用JavaScript、vbscript脚本做分页
弊端：影响搜索引擎对其收录
采集对策：分析JavaScript、vbscript脚本，找出其分页规则，自己做个对应此站的分页集合页即可。
建议：目前没有好的改良建议
评论：感觉懂点脚本语言的人都能找出其分页规则
六、只允许通过本站页面连接查看，如：Request.ServerVariables(“HTTP_REFERER”)
弊端：影响搜索引擎对其收录
采集对策：不知道能不能模拟网页来源。。。。目前我没有对应此方法的采集对策
建议：目前没有好的改良建议
评论：建议指望搜索引擎带流量的站长不要使用此方法。不过此方法防一般的采集程序，还是有点效果的。
从以上可以看出，目前常用的防采集方法，要么会对搜索引擎收录有较大影响，要么防采集效果不好，起不到防采集的效果。那么，还有没有一种有效防采集，而又不影响搜索引擎收录的方法呢？那就请继续往下看吧，精彩的地方马上呈献给大家。
下面就是我的防采集策略，防采集而又不防搜索引擎
从前面的我讲的采集原理大家可以看出，绝大多数采集程序都是靠分析规则来进行采集的，如分析分页文件名规则、分析页面代码规则。
一、分页文件名规则防采集对策
大部分采集器都是靠分析分页文件名规则，进行批量、多页采集的。如果别人找不出你的分页文件的文件名规则，那么别人就无法对你的网站进行批量多页采集。
实现方法：
我认为用MD5加密分页文件名是一个比较好的方法，说到这里，有人会说，你用MD5加密分页文件名，别人根据此规则也可以模拟你的加密规则得到你的分页文件名。
我要指出的是我们加密分页文件名时，不要只加密文件名变化的部分
如果I代表分页的页码，那么我们不要这样加密
page_name=Md5(I,16)&”.htm”
最好给要加密的页码上再跟进一个或多个字符，如：page_name=Md5(I&”任意一个或几个字母”,16)&”.htm”
因为MD5是无法反解密的，别人看到的会页字母是MD5加密后的结果，所以加人也无法知道你在 I 后面跟进的字母是什么，除非他用暴力****MD5，不过不太现实。
二、页面代码规则防采集对策
如果说我们的内容页面无代码规则，那么别人就无法从你的代码中提取他们所需要的一条条内容。
所以我们要的这一步做到防采集，就要使代码无规则。
实现方法：
使对方需要提取的标记随机化
1、定制多个网页模板，每个网页模板里的重要HTML标记不同，呈现页面内容时，随机选取网页模板，有的页面用CSS+DIV布局，有的页面用table布局，此方法是麻烦了点，一个内容页面，要多做几个模板页面，不过防采集本身就是一件很烦琐的事情，多做一个模板，能起到防采集的作用，对很多人来说，都是值得的。
2、如果嫌上面的方法太麻烦，把网页里的重要HTML标记随机化，也可以。
做的网页模板越多，html代码越是随机化，对方分析起内容代码时，就越麻烦，对方针对你的网站专门写采集策略时，难度就更大，在这个时候，绝大部分人，都会知难而退，因为这此人就是因为懒，才会采集别人网站数据嘛~~~再说一下，目前大部分人都是拿别人开发的采集程序去采集数据，自己开发采集程序去采集数据的人毕竟是少数。
还有些简单的思路提供给大家：
1、把对数据采集者重要，而对搜索引擎不重要的内容用客户端脚本显示
2、把一页数据，分为N个页面显示，也是加大采集难度的方法
3、用更深层的连接，因为目前大部分采集程序只能采集到网站内容的前3层，如果内容所在的连接层更深，也可以避免被采集。不过这样可能会给客户造成浏览上的不便。
如：
大多网站都是 首页—-内容索引分页—-内容页
如果改成：
首页—-内容索引分页—-内容页入口—-内容页
注：内容页入口最好能加上自动转入内容页的代码

其实，只要做好防采集的第一步(加密分页文件名规则)，防采集的效果就已经不错了，还是建议两条反采集方法同时使用，给采集者增加采集难度，使得他们知难页退。

六、对抓取的网页进行截取
首先写个截取子程序cutBy(head,headCusor,bot,botCusor)，它可以按照你指定的首尾字符串、及位置偏移指针，对抓取的网页进行裁减。程序中参数head,headCusor,bot,botCusor分别是首字符串，首偏移值，尾字符串，尾偏移值；偏移值单位为字符数，向前偏移为负值，向后偏移为正值。
public sub cutBy(head,headCusor,bot,botCusor)
if isGet_= false then call steal()
On Error Resume Next
url=src_
value_=mid(value_ ,instr(value_ ,head)+len(head)+headCusor,instr(value_ ,bot)-1+botCusor-instr(value_ ,head)-len(head)-headcusor)
If Err.Number<>0 Then Response.Write “裁减“&url&” 失败。”
end sub
把以上cutBy子程序添加到clsThief类中，然后在2hand-cj.asp中增加如下调用：
<% s1=" ” '要裁减的起始标志为