正则表达式到底是什么东西？

字符是计算机软件处理文字时最基本的单位，可能是字母，数字，标点符号，空格，换行符，汉字等等。
字符串是0个或更多个字符的序列。
文本也就是文字，字符串。说某个字符串
匹配某个正则表达式，通常是指这个字符串里有一部分（或几部分分别）能满足表达式给出的条件。

在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。
正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。

很可能你使用过Windows/Dos下用于文件查找的
通配符(wildcard)，也就是
*和
?。如果你想查找某个目录下的所有的Word文档的话，你会搜索
*.doc。在这里，
*会被解释成任意的字符串。和通配符类似，正则表达式也是用来进行文本匹配的工具，只不过比起通配符，它能更精确地描述你的需求——当然，代价就是更复杂——比如你可以编写一个正则表达式，用来查找
所有以0开头，后面跟着2-3个数字，然后是一个连字号“-”，最后是7或8位数字的字符串(像
010-12345678或
0376-7654321)。

入门

学习正则表达式的最好方法是从例子开始，理解例子之后再自己对例子进行修改，实验。下面给出了不少简单的例子，并对它们作了详细的说明。

假设你在一篇英文小说里查找
hi，你可以使用正则表达式
hi。

这几乎是最简单的正则表达式了，它可以精确匹配这样的字符串：
由两个字符组成，前一个字符是h,后一个是i。通常，处理正则表达式的工具会提供一个忽略大小写的选项，如果选中了这个选项，它可以匹配
hi,
HI,
Hi,
hI这四种情况中的任意一种。

不幸的是，很多单词里包含
hi这两个连续的字符，比如
him,
history,
high等等。用
hi来查找的话，这里边的
hi也会被找出来。如果要
精确地查找hi这个单词的话，我们应该使用
\bhi\b。

\b是正则表达式规定的一个特殊代码（好吧，某些人叫它
元字符，metacharacter），代表着
单词的开头或结尾，也就是单词的分界处。虽然通常英文的单词是由空格，标点符号或者换行来分隔的，但是
\b并不匹配这些单词分隔字符中的任何一个，它只匹配一个位置。

如果需要更精确的说法，
\b匹配这样的位置：它的前一个字符和后一个字符不全是(一个是,一个不是或不存在)
\w。

假如你要找的是
hi后面不远处跟着一个Lucy，你应该用
\bhi\b.*\bLucy\b。

这里，
.是另一个元字符，匹配
除了换行符以外的任意字符。
*同样是元字符，不过它代表的不是字符，也不是位置，而是数量——它指定*
前边的内容可以连续重复使用任意次以使整个表达式得到匹配。因此，
.*连在一起就意味着
任意数量的不包含换行的字符。现在
\bhi\b.*\bLucy\b的意思就很明显了：
先是一个单词hi,然后是任意个任意字符(但不能是换行)，最后是Lucy这个单词。

换行符就是'\n',ASCII编码为10(十六进制0x0A)的字符。

如果同时使用其它元字符，我们就能构造出功能更强大的正则表达式。比如下面这个例子：

0\d\d-\d\d\d\d\d\d\d\d匹配这样的字符串：
以0开头，然后是两个数字，然后是一个连字号“-”，最后是8个数字(也就是中国的电话号码。当然，这个例子只能匹配区号为3位的情形)。

这里的
\d是个新的元字符，匹配
一位数字(0，或1，或2，或……)。
-不是元字符，只匹配它本身——连字符(或者减号，或者中横线，或者随你怎么称呼它)。

为了避免那么多烦人的重复，我们也可以这样写这个表达式：
0\d{2}-\d{8}。这里
\d后面的
{2}(
{8})的意思是前面
\d
必须连续重复匹配2次(8次)。

测试正则表达式

其它可用的测试工具:

• RegexBuddy
• Javascript正则表达式在线测试工具

如果你不觉得正则表达式很难读写的话，要么你是一个天才，要么，你不是地球人。正则表达式的语法很令人头疼，即使对经常使用它的人来说也是如此。由于难于读写，容易出错，所以找一种工具对正则表达式进行测试是很有必要的。

元字符

现在你已经知道几个很有用的元字符了，如
\b,
.,
*，还有
\d.正则表达式里还有更多的元字符，比如
\s匹配
任意的空白符，包括空格，制表符(Tab)，换行符，中文全角空格等。
\w匹配
字母或数字或下划线或汉字等。

对中文/汉字的特殊处理是由.Net提供的正则表达式引擎支持的，其它环境下的具体情况请查看相关文档。

下面来看看更多的例子：

\ba\w*\b匹配
以字母
a开头的单词——先是某个单词开始处(
\b)，然后是字母
a,然后是任意数量的字母或数字(
\w*)，最后是单词结束处(
\b)。

好吧，现在我们说说正则表达式里的单词是什么意思吧：就是不少于一个的连续的
\w。不错，这与学习英文时要背的成千上万个同名的东西的确关系不大 🙂

\d+匹配
1个或更多连续的数字。这里的
+是和
*类似的元字符，不同的是
*匹配
重复任意次(可能是0次)，而
+则匹配
重复1次或更多次。

\b\w{6}\b 匹配
刚好6个字符的单词。

.
匹配除换行符以外的任意字符
\w
匹配字母或数字或下划线或汉字
\s
匹配任意的空白符
\d
匹配数字
\b
匹配单词的开始或结束
^
匹配字符串的开始
$
匹配字符串的结束

正则表达式引擎通常会提供一个“测试指定的字符串是否匹配一个正则表达式”的方法，如JavaScript里的RegExp.test()方法或.NET里的Regex.IsMatch()方法。这里的匹配是指是字符串里有没有符合表达式规则的部分。如果不使用
^和
$的话，对于
\d{5,12}而言，使用这样的方法就只能保证字符串里
包含5到12连续位数字，而不是整个字符串就是5到12位数字。

元字符
^（和数字6在同一个键位上的符号）和
$都匹配一个位置，这和
\b有点类似。
^匹配你要用来查找的字符串的开头，
$匹配结尾。这两个代码在验证输入的内容时非常有用，比如一个网站如果要求你填写的QQ号必须为5位到12位数字时，可以使用：
^\d{5,12}$。

这里的
{5,12}和前面介绍过的
{2}是类似的，只不过
{2}匹配
只能不多不少重复2次，
{5,12}则是
重复的次数不能少于5次，不能多于12次，否则都不匹配。

因为使用了
^和
$，所以输入的整个字符串都要用来和
\d{5,12}来匹配，也就是说整个输入
必须是5到12个数字，因此如果输入的QQ号能匹配这个正则表达式的话，那就符合要求了。

和忽略大小写的选项类似，有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项，
^和
$的意义就变成了
匹配行的开始处和结束处。

字符转义

如果你想查找元字符本身的话，比如你查找
.,或者
*,就出现了问题：你没办法指定它们，因为它们会被解释成别的意思。这时你就得使用
\来取消这些字符的特殊意义。因此，你应该使用
.和
\*。当然，要查找
\本身，你也得用
\.

例如：
deerchao.net匹配
deerchao.net，
C:\Windows匹配
C:\Windows。

重复

你已经看过了前面的
*,
+,
{2},
{5,12}这几个匹配重复的方式了。下面是正则表达式中所有的限定符(指定数量的代码，例如*,{5,12}等)：

重复零次或更多次
+
重复一次或更多次
?
重复零次或一次
{n}
重复n次
{n,}
重复n次或更多次
{n,m}
重复n到m次

下面是一些使用重复的例子：

Windows\d+匹配
Windows后面跟1个或更多数字

^\w+匹配
一行的第一个单词(或整个字符串的第一个单词，具体匹配哪个意思得看选项设置)

字符类

要想查找数字，字母或数字，空白是很简单的，因为已经有了对应这些字符集合的元字符，但是如果你想匹配没有预定义元字符的字符集合(比如元音字母a,e,i,o,u),应该怎么办？

很简单，你只需要在方括号里列出它们就行了，像
[aeiou]就匹配
任何一个英文元音字母，
[.?!]匹配
标点符号(.或?或!)。

我们也可以轻松地指定一个字符
范围，像
[0-9]代表的含意与
\d就是完全一致的：
一位数字；同理
[a-z0-9A-Z_]也完全等同于
\w（如果只考虑英文的话）。

下面是一个更复杂的表达式：
(?0\d{2}[) -]?\d{8}。

“(”和“)”也是元字符

这个表达式可以匹配
几种格式的电话号码，像
(010)88886666，或
022-22334455，或
02912345678等。我们对它进行一些分析吧：首先是一个转义字符
(,它能出现0次或1次(
?),然后是一个
0，后面跟着2个数字(
\d{2})，然后是
)或
-或
空格中的一个，它出现1次或不出现(
?)，最后是8个数字(
\d{8})。

分枝条件

不幸的是，刚才那个表达式也能匹配
010)12345678或
(022-87654321这样的“不正确”的格式。要解决这个问题，我们需要用到
分枝条件。正则表达式里的
分枝条件指的是有几种规则，如果满足其中任意一种规则都应该当成匹配，具体方法是用
|把不同的规则分隔开。听不明白？没关系，看例子：

0\d{2}-\d{8}|0\d{3}-\d{7}这个表达式能
匹配两种以连字号分隔的电话号码：一种是三位区号，8位本地号(如010-12345678)，一种是4位区号，7位本地号(0376-2233445)。

(?0\d{2})?[- ]?\d{8}|0\d{2}[- ]?\d{8}这个表达式
匹配3位区号的电话号码，其中区号可以用小括号括起来，也可以不用，区号与本地号间可以用连字号或空格间隔，也可以没有间隔。你可以试试用分枝条件把这个表达式扩展成也支持4位区号的。

\d{5}-\d{4}|\d{5}这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字，或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题：使用分枝条件时，要注意各个条件的顺序。如果你把它改成
\d{5}|\d{5}-\d{4}的话，那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配分枝条件时，将会从左到右地测试每个条件，如果满足了某个分枝的话，就不会去再管其它的条件了。

分组

我们已经提到了怎么重复单个字符（直接在字符后面加上限定符就行了）；但如果想要重复多个字符又该怎么办？你可以用小括号来指定
子表达式(也叫做
分组)，然后你就可以指定这个子表达式的重复次数了，你也可以对子表达式进行其它一些操作(后面会有介绍)。

(\d{1,3}.){3}\d{1,3}是一个
简单的IP地址匹配表达式。要理解这个表达式，请按下列顺序分析它：
\d{1,3}匹配
1到3位的数字，
(\d{1,3}.){3}匹配
三位数字加上一个英文句号(这个整体也就是这个
分组)重复3次，最后再加上
一个一到三位的数字(
\d{1,3})。

IP地址中每个数字都不能大于255. 经常有人问我, 01.02.03.04 这样前面带有0的数字, 是不是正确的IP地址呢? 答案是: 是的, IP 地址里的数字可以包含有前导 0 (leading zeroes).

不幸的是，它也将匹配
256.300.888.999这种不可能存在的IP地址。如果能使用算术比较的话，或许能简单地解决这个问题，但是正则表达式中并不提供关于数学的任何功能，所以只能使用冗长的分组，选择，字符类来描述一个正确的IP地址：
((2[0-4]\d|25[0-5]|[01]?\d\d?).){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)。

理解这个表达式的关键是理解
2[0-4]\d|25[0-5]|[01]?\d\d?，这里我就不细说了，你自己应该能分析得出来它的意义。

反义

有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外，其它任意字符都行的情况，这时需要用到
反义：

\W
匹配任意不是字母，数字，下划线，汉字的字符
\S
匹配任意不是空白符的字符
\D
匹配任意非数字的字符
\B
匹配不是单词开头或结束的位置
[^x]
匹配除了x以外的任意字符
[^aeiou]
匹配除了aeiou这几个字母以外的任意字符

例子：
\S+匹配
不包含空白符的字符串。

<a[^>]+>匹配
用尖括号括起来的以a开头的字符串。

后向引用

使用小括号指定一个子表达式后，匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下，每个分组会自动拥有一个
组号，规则是：从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推。

呃……其实,组号分配还不像我刚说得那么简单：

• 分组0对应整个正则表达式
• 实际上组号分配过程是要从左向右扫描两遍的：第一遍只给未命名组分配，第二遍只给命名组分配－－因此所有命名组的组号都大于未命名的组号
• 你可以使用

(?:exp)这样的语法来剥夺一个分组对组号分配的参与权．

后向引用用于重复搜索前面某个分组匹配的文本。例如，
\1代表
分组1匹配的文本。难以理解？请看示例：

\b(\w+)\b\s+\1\b可以用来匹配
重复的单词，像
go go, 或者
kitty kitty。这个表达式首先是
一个单词，也就是
单词开始处和结束处之间的多于一个的字母或数字(
\b(\w+)\b)，这个单词会被捕获到编号为1的分组中，然后是
1个或几个空白符(
\s+)，最后是
分组1中捕获的内容（也就是前面匹配的那个单词）(
\1)。

你也可以自己指定子表达式的
组名。要指定一个子表达式的组名，请使用这样的语法：
(?<Word>\w+)(或者把尖括号换成
'也行：
(?'Word'\w+)),这样就把
\w+的组名指定为
Word了。要反向引用这个分组
捕获的内容，你可以使用
\k<Word>,所以上一个例子也可以写成这样：
\b(?<Word>\w+)\b\s+\k<Word>\b。

使用小括号的时候，还有很多特定用途的语法。下面列出了最常用的一些：

(exp)
匹配exp,并捕获文本到自动命名的组里
(?<name>exp)
匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)
(?:exp)
匹配exp,不捕获匹配的文本，也不给此分组分配组号
(?=exp)
匹配exp前面的位置
(?<=exp)
匹配exp后面的位置
(?!exp)
匹配后面跟的不是exp的位置
(?<!exp)
匹配前面不是exp的位置
(?#comment)
这种类型的分组不对正则表达式的处理产生任何影响，用于提供注释让人阅读

我们已经讨论了前两种语法。第三个
(?:exp)不会改变正则表达式的处理方式，只是这样的组匹配的内容
不会像前两种那样被捕获到某个组里面，也不会拥有组号。“我为什么会想要这样做？”——好问题，你觉得为什么呢？

零宽断言

地球人，是不是觉得这些术语名称太复杂，太难记了？我也有同感。知道有这么一种东西就行了，它叫什么，随它去吧！人若无名，便可专心练剑；物若无名，便可随意取舍……

接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像
\b,
^,
$那样用于指定一个位置，这个位置应该满足一定的条件(即断言)，因此它们也被称为
零宽断言。最好还是拿例子来说明吧：

断言用来声明一个应该为真的事实。正则表达式中只有当断言为真时才会继续进行匹配。

(?=exp)也叫
零宽度正预测先行断言，它
断言自身出现的位置的后面能匹配表达式exp。比如
\b\w+(?=ing\b)，匹配
以ing结尾的单词的前面部分(除了ing以外的部分)，如查找
I'm singing while you're dancing.时，它会匹配
sing和
danc。

(?<=exp)也叫
零宽度正回顾后发断言，它
断言自身出现的位置的前面能匹配表达式exp。比如
(?<=\bre)\w+\b会匹配
以re开头的单词的后半部分(除了re以外的部分)，例如在查找
reading a book时，它匹配
ading。

假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：
((?<=\d)\d{3})+\b，用它对
1234567890进行查找时结果是
234567890。

下面这个例子同时使用了这两种断言：
(?<=\s)\d+(?=\s)匹配
以空白符间隔的数字(再次强调，不包括这些空白符)。

负向零宽断言

前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现，但并不想去匹配它时怎么办？例如，如果我们想查找这样的单词–它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样：

\b\w*q[^u]\w*\b匹配
包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐，直接就观察出来了)，你会发现，如果q出现在单词的结尾的话，像Iraq,Benq，这个表达式就会出错。这是因为
[^u]总要匹配一个字符，所以如果q是单词的最后一个字符的话，后面的
[^u]将会匹配q后面的单词分隔符(可能是空格，或者是句号或其它的什么)，后面的
\w*\b将会匹配下一个单词，于是
\b\w*q[^u]\w*\b就能匹配整个
Iraq fighting。
负向零宽断言能解决这样的问题，因为它只匹配一个位置，并不消费任何字符。现在，我们可以这样来解决这个问题：
\b\w*q(?!u)\w*\b。

零宽度负预测先行断言
(?!exp)，
断言此位置的后面不能匹配表达式exp。例如：
\d{3}(?!\d)匹配
三位数字，而且这三位数字的后面不能是数字；
\b((?!abc)\w)+\b匹配
不包含连续字符串abc的单词。

同理，我们可以用
(?<!exp),
零宽度负回顾后发断言来
断言此位置的前面不能匹配表达式exp：
(?<![a-z])\d{7}匹配
前面不是小写字母的七位数字。

请详细分析表达式
(?<=<(\w+)>).*(?=</\1>)，这个表达式最能表现零宽断言的真正用途。

一个更复杂的例子：
(?<=<(\w+)>).*(?=</\1>)匹配
不包含属性的简单HTML标签内里的内容。
(?<=<(\w+)>)指定了这样的
前缀：
被尖括号括起来的单词(比如可能是<b>)，然后是
.*(任意的字符串),最后是一个
后缀
(?=</\1>)。注意后缀里的
/，它用到了前面提过的字符转义；
\1则是一个反向引用，引用的正是
捕获的第一组，前面的
(\w+)匹配的内容，这样如果前缀实际上是<b>的话，后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒，不包括前缀和后缀本身)。

注释

小括号的另一种用途是通过语法
(?#comment)来包含注释。例如：
2[0-4]\d(?#200-249)|250-5|[01]?\d\d?(?#0-199)。

要包含注释的话，最好是启用“忽略模式里的空白符”选项，这样在编写表达式时能任意的添加空格，Tab，换行，而实际使用时这些都将被忽略。启用这个选项后，在#后面到这一行结束的所有文本都将被当成注释忽略掉。例如，我们可以前面的一个表达式写成这样：

1
2
3
4
5
6
7
8
1      (?<=    # 断言要匹配的文本的前缀

2      <(\w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)

3      )       # 前缀结束

4      .*      # 匹配任意文本

5      (?=     # 断言要匹配的文本的后缀

6      <\/\1>  # 查找尖括号括起来的内容：前面是一个"/"，后面是先前捕获的标签

7      )       # 后缀结束

8

贪婪与懒惰

当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。以这个表达式为例：
a.*b，它将会匹配
最长的以a开始，以b结束的字符串。如果用它来搜索
aabab的话，它会匹配整个字符串
aabab。这被称为
贪婪匹配。

有时，我们更需要
懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号
?。这样
.*?就意味着
匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧：

a.*?b匹配
最短的，以a开始，以b结束的字符串。如果把它应用于
aabab的话，它会匹配
aab（第一到第三个字符）和
ab（第四到第五个字符）。

为什么第一个匹配是aab（第一到第三个字符）而不是ab（第二到第三个字符）？简单地说，因为正则表达式有另一条规则，比懒惰／贪婪规则的优先级更高：最先开始的匹配拥有最高的优先权——The match that begins earliest wins。

*?
重复任意次，但尽可能少重复
+?
重复1次或更多次，但尽可能少重复
??
重复0次或1次，但尽可能少重复
{n,m}?
重复n到m次，但尽可能少重复
{n,}?
重复n次以上，但尽可能少重复

处理选项

上面介绍了几个选项如忽略大小写，处理多行等，这些选项能用来改变处理正则表达式的方式。下面是.Net中常用的正则表达式选项：

IgnoreCase(忽略大小写)
匹配时不区分大小写。
Multiline(多行模式)
更改^和$的含义，使它们分别在任意一行的行首和行尾匹配，而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$的精确含意是:匹配\n之前的位置以及字符串结束前的位置.)
Singleline(单行模式)
更改.的含义，使它与每一个字符匹配（包括换行符\n）。
IgnorePatternWhitespace(忽略空白)
忽略表达式中的非转义空白并启用由#标记的注释。
ExplicitCapture(显式捕获)
仅捕获已被显式命名的组。

一个经常被问到的问题是：是不是只能同时使用多行模式和单行模式中的一种？答案是：不是。这两个选项之间没有任何关系，除了它们的名字比较相似（以至于让人感到疑惑）以外。

平衡组/递归匹配

这里介绍的平衡组语法是由.Net Framework支持的；其它语言／库不一定支持这种功能，或者支持此功能但需要使用不同的语法。

有时我们需要匹配像
( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构，这时简单地使用
(.+)则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式，懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等，比如
( 5 / ( 3 + 2 ) ) )，那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的，配对的括号之间的内容呢？

为了避免
(和
(把你的大脑彻底搞糊涂，我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把
xx <aa <bbb> <bbb> aa> yy这样的字符串里，最长的配对的尖括号内的内容捕获出来？

这里需要用到以下的语法构造：

• (?'group') 把捕获的内容命名为group,并压入

堆栈(Stack)

• (?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
• (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
• (?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败

如果你不是一个程序员（或者你自称程序员但是不知道堆栈是什么东西），你就这样理解上面的三种语法吧：第一个就是在黑板上写一个"group"，第二个就是从黑板上擦掉一个"group"，第三个就是看黑板上写的还有没有"group"，如果有就继续匹配yes部分，否则就匹配no部分。

我们需要做的是每碰到了左括号，就在压入一个"Open",每碰到一个右括号，就弹出一个，到了最后就看看堆栈是否为空－－如果不为空那就证明左括号比右括号多，那匹配就应该失败。正则表达式引擎会进行回溯(放弃最前面或最后面的一些字符)，尽量使整个表达式得到匹配。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1<                         #最外层的左括号

2    [^<>]*                #最外层的左括号后面的不是括号的内容

3    (

4        (

5            (?'Open'<)    #碰到了左括号，在黑板上写一个"Open"

6            [^<>]*       #匹配左括号后面的不是括号的内容

7        )+

8        (

9            (?'-Open'>)   #碰到了右括号，擦掉一个"Open"

10            [^<>]*        #匹配右括号后面不是括号的内容

11        )+

12    )*

13    (?(Open)(?!))         #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败

14

15>                         #最外层的右括号

16

平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配
嵌套的<div>标签：
<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div>.

还有些什么东西没提到

上边已经描述了构造正则表达式的大量元素，但是还有很多没有提到的东西。下面是一些未提到的元素的列表，包含语法和简单的说明。你可以在网上找到更详细的参考资料来学习它们–当你需要用到它们的时候。如果你安装了MSDN Library,你也可以在里面找到.net下正则表达式详细的文档。这里的介绍很简略，如果你需要更详细的信息，而又没有在电脑上安装MSDN Library,可以查看关于正则表达式语言元素的MSDN在线文档。

\a
报警字符(打印它的效果是电脑嘀一声)
\b
通常是单词分界位置，但如果在字符类里使用代表退格
\t
制表符，Tab
\r
回车
\v
竖向制表符
\f
换页符
\n
换行符
\e
Escape
\0nn
ASCII代码中八进制代码为nn的字符
\xnn
ASCII代码中十六进制代码为nn的字符
\unnnn
Unicode代码中十六进制代码为nnnn的字符
\cN
ASCII控制字符。比如\cC代表Ctrl+C
\A
字符串开头(类似^，但不受处理多行选项的影响)
\Z
字符串结尾或行尾(不受处理多行选项的影响)
\z
字符串结尾(类似$，但不受处理多行选项的影响)
\G
当前搜索的开头
\p{name}
Unicode中命名为name的字符类，例如\p{IsGreek}
(?>exp)
贪婪子表达式
(?<x>–<y>exp)
平衡组
(?im-nsx:exp)
在子表达式exp中改变处理选项
(?im-nsx)
为表达式后面的部分改变处理选项
(?(exp)yes|no)
把exp当作零宽正向先行断言，如果在这个位置能匹配，使用yes作为此组的表达式；否则使用no
(?(exp)yes)
同上，只是使用空表达式作为no
(?(name)yes|no)
如果命名为name的组捕获到了内容，使用yes作为表达式；否则使用no
(?(name)yes)
同上，只是使用空表达式作为no

常用正则表达式

说明：正则表达式通常用于两种任务：1.验证，2.搜索/替换。用于验证时，通常需要在前后分别加上^和$，以匹配整个待验证字符串；搜索/替换时是否加上此限定则根据搜索的要求而定，此外，也有可能要在前后加上\b而不是^和$。此表所列的常用正则表达式，除个别外均未在前后加上任何限定，请根据需要，自行处理。

网址（URL）
[a-zA-z]+://[^\s]*
IP地址(IP Address)
((2[0-4]\d|25[0-5]|[01]?\d\d?).){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)
电子邮件(Email)
\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*
QQ号码
[1-9]\d{4,}
HTML标记(包含内容或自闭合)
<(.)(.)>.</\1>|<(.) />
密码(由数字/大写字母/小写字母/标点符号组成，四种都必有，8位以上)
(?=^.{8,}$)(?=.\d)(?=.\W+)(?=.[A-Z])(?=.[a-z])(?!.\n).$
日期(年-月-日)
(\d{4}|\d{2})-((1[0-2])|(0?[1-9]))-(([12][0-9])|(3[01])|(0?[1-9]))
日期(月/日/年)
((1[0-2])|(0?[1-9]))/(([12][0-9])|(3[01])|(0?[1-9]))/(\d{4}|\d{2})
时间(小时:分钟, 24小时制)
((1|0?)[0-9]|2[0-3]):([0-5][0-9])
汉字(字符)
[\u4e00-\u9fa5]
中文及全角标点符号(字符)
[\u3000-\u301e\ufe10-\ufe19\ufe30-\ufe44\ufe50-\ufe6b\uff01-\uffee]
中国大陆固定电话号码
(\d{4}-|\d{3}-)?(\d{8}|\d{7})
中国大陆手机号码
1\d{10}
中国大陆邮政编码
[1-9]\d{5}
中国大陆身份证号(15位或18位)
\d{15}(\d\d[0-9xX])?
非负整数(正整数或零)
\d+
正整数
[0-9][1-9][0-9]
负整数
-[0-9][1-9][0-9]
整数
-?\d+
小数
(-?\d+)(.\d+)?
不包含abc的单词
\b((?!abc)\w)+\b

正则表达式

在计算机科学中，是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。在很多文本编辑器或其他工具里，正则表达式通常被用来检索和/或替换那些符合某个模式的文本内容。许多 程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件（例如sed和grep）普及开的。正则表达式通常缩写成“regex”，单数有regexp、regex，复数有regexps、regexes、regexen。

概念

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

给定一个正则表达式和另一个字符串，我们可以达到如下的目的：

1. 给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）；

2. 可以通过正则表达式，从字符串中获取我们想要的特定部分。

正则表达式的特点是：

1. 灵活性、逻辑性和功能性非常的强；

2. 可以迅速地用极简单的方式达到字符串的复杂控制。

3. 对于刚接触的人来说，比较晦涩难懂。

由于正则表达式主要应用对象是文本，因此它在各种文本编辑器场合都有应用，小到著名编辑器EditPlus，大到Microsoft Word、Visual Studio等大型编辑器，都可以使用正则表达式来处理文本内容。

##引擎

正则引擎主要可以分为两大类：一种是DFA，一种是NFA。这两种引擎都有了很久的历史(至今二十多年)，当中也由这两种引擎产生了很多变体！于是POSIX的出台产生规范了不必要变体的继续产生。这样一来，主流的正则引擎又分为3类：一、DFA，二、传统型NFA，三、POSIX NFA。

DFA 引擎在线性时状态下执行，因为它们不要求回溯（并因此它们永远不测试相同的字符两次）。DFA 引擎还可以确保匹配最长的可能的字符串。但是，因为 DFA 引擎只包含有限的状态，所以它不能匹配具有反向引用的模式；并且因为它不构造显示扩展，所以它不可以捕获子表达式。

传统的 NFA 引擎运行所谓的“贪婪的”匹配回溯算法，以指定顺序测试正则表达式的所有可能的扩展并接受第一个匹配项。因为传统的 NFA 构造正则表达式的特定扩展以获得成功的匹配，所以它可以捕获子表达式匹配和匹配的反向引用。但是，因为传统的 NFA 回溯，所以它可以访问完全相同的状态多次（如果通过不同的路径到达该状态）。因此，在最坏情况下，它的执行速度可能非常慢。因为传统的 NFA 接受它找到的第一个匹配，所以它还可能会导致其他（可能更长）匹配未被发现。

POSIX NFA 引擎与传统的 NFA 引擎类似，不同的一点在于：在它们可以确保已找到了可能的最长的匹配之前，它们将继续回溯。因此，POSIX NFA 引擎的速度慢于传统的 NFA 引擎；并且在使用 POSIX NFA 时，您恐怕不会愿意在更改回溯搜索的顺序的情况下来支持较短的匹配搜索，而非较长的匹配搜索。

使用DFA引擎的程序主要有：awk,egrep,flex,lex,MySQL,Procmail等；

使用传统型NFA引擎的程序主要有：GNU Emacs,Java,ergp,less,more,.NET语言,PCRE library,Perl,PHP,Python,Ruby,sed,vi；

使用POSIX NFA引擎的程序主要有：mawk,Mortice Kern Systems’ utilities,GNU Emacs(使用时可以明确指定)；

也有使用DFA/NFA混合的引擎：GNU awk,GNU grep/egrep,Tcl。

举例简单说明NFA与DFA工作的区别：

比如有字符串this is yansen’s blog，正则表达式为 /ya(msen|nsen|nsem)/ (不要在乎表达式怎么样，这里只是为了说明引擎间的工作区别)。 NFA工作方式如下，先在字符串中查找 y 然后匹配其后是否为 a ，如果是 a 则继续，查找其后是否为 m 如果不是则匹配其后是否为 n (此时淘汰msen选择支)。然后继续看其后是否依次为 s,e，接着测试是否为 n ，是 n 则匹配成功，不是则测试是否为 m 。为什么是 m ？因为 NFA 工作方式是以正则表达式为标准，反复测试字符串，这样同样一个字符串有可能被反复测试了很多次！

而DFA则不是如此，DFA会从 this 中 t 开始依次查找 y，定位到 y ，已知其后为 a ，则查看表达式是否有 a ，此处正好有 a 。然后字符串 a 后为 n ，DFA依次测试表达式，此时 msen 不符合要求淘汰。nsen 和 nsem 符合要求，然后DFA依次检查字符串，检测到sen 中的 n 时只有nsen 分支符合，则匹配成功！

由此可以看出来，两种引擎的工作方式完全不同，一个(NFA)以表达式为主导，一个(DFA)以文本为主导！一般而论，DFA引擎则搜索更快一些！但是NFA以表达式为主导，反而更容易操纵，因此一般程序员更偏爱NFA引擎！ 两种引擎各有所长，而真正的引用则取决与你的需要以及所使用的语言！

##零宽断言

用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像\b,^,$那样用于指定一个位置，这个位置应该满足一定的条件(即断言)，因此它们也被称为零宽断言。最好还是拿例子来说明吧：

(?=exp)也叫零宽度正预测先行断言，它断言自身出现的位置的后面能匹配表达式exp。比如\b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I'm singing while you're dancing.时，它会匹配sing和danc。

(?<=exp)也叫零宽度正回顾后发断言 ，它断言自身出现的位置的前面能匹配表达式exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。

假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：((?<=\d)\d{3})+\b，用它对xxxxxxxxxx进行查找时结果是xxxxxxxxxx

下面这个例子同时使用了这两种断言：(?<=\s)\d+(?=\s)匹配以空白符间隔的数字(再次强调，不包括这些空白符)

断言用来声明一个应该为真的事实。正则表达式中只有当断言为真时才会继续进行匹配。

##负向零宽

如果我们只是想要 确保某个字符没有出现，但并不想去匹配它时怎么办？例如，如果我们想查找这样的单词–它里面出现了字母q，但是q后面跟的不是字母u,我们可以尝试这样：

\b\w*q[^u]\w*\b匹配包含 后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐，直接就观察出来了)，你会发现，如果q出单词的结尾的话，像 Iraq, Benq，这个表达式就会出错。这是因为[^u]总要匹配一个字符，所以如果q是单词的最后一个字符的话，后面的[^u]将会匹配q后面的单词分隔符(可能是空格，或者是句号或其它的什么)，后面的\w*\b将会匹配下一个单词，于是\b\w*q[^u]\w*\b就能匹配整个Iraq fighting。负向零宽断言能解决这样的问题，因为它只匹配一个位置，并不 消费任何字符。，我们可以这样来解决这个问题：\b\w*q(?!u)\w*\b。

零宽度负预测先行断言(?!exp)，断言此位置的后面不能匹配表达式exp。例如：\d{3}(?!\d)匹配三位数字，而且这三位数字的后面不能是数字；\b((?!abc)\w)+\b匹配不包含连续字符串abc的单词。

同理，我们可以用(?<!exp),零宽度负回顾后发断言来断言此位置的前面不能匹配表达式exp：(?<![a-z])\d{7}匹配前面不是小写字母的七位数字。

请详细分析表达式(?<=<(\w+)>).*(?=</\1>)，这个表达式最能表现零宽断言的真正用途。

一个更复杂的例子：(?<=<(\w+)>).*(?=</\1>)匹配不包含属性的简单HTML标签内里的内容。(?<=<(\w+)>)指定了这样的前缀：被尖括号括起来的单词(比如可能是<b>)，然后是.*(任意的字符串),最后是一个后缀(?=</\1>)。注意后缀里的/，它用到了前面提过的字符转义；\1则是一个反向引用，引用的正是捕获的第一组，前面的(\w+)匹配的内容，这样如果前缀实际上是<b>的话，后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒，不包括前缀和后缀本身)。

符号

正则表达式由一些普通字符和一些元字符（metacharacters）组成。普通字符包括大小写的字母和数字，而元字符则具有特殊的含义，我们下面会给予解释。

在最简单的情况下，一个正则表达式看上去就是一个普通的查找串。例如，正则表达式"testing"中没有包含任何元字符，它可以匹配"testing"和"123testing"等字符串，但是不能匹配"Testing"。

要想真正的用好正则表达式，正确的理解 元字符是最重要的事情。下表列出了所有的元字符和对它们的一个简短的描述。

最简单的元字符是点，它能够匹配任何单个字符（注意不包括换行符）。假定有个文件test.txt包含以下几行内容：

he is arat

he is in a rut

the food is Rotten

I like root beer

我们可以使用grep命令来测试我们的正则表达式，grep命令使用正则表达式去尝试匹配指定文件的每一行，并将至少有一处匹配表达式的所有行显示出来。命令

grep r.t test.txt

在test.txt文件中的每一行中搜索正则表达式r.t，并打印输出匹配的行。正则表达式r.t匹配一个r接着任何一个字符再接着一个t。所以它将匹配文件中的rat和rut，而不能匹配Rotten中的Rot，因为正则表达式是大小写敏感的。要想同时匹配大写和小写字母，应该使用字符区间元字符（方括号）。正则表达式[Rr]能够同时匹配R和r。所以，要想匹配一个大写或者小写的r接着任何一个字符再接着一个t就要使用这个表达式：[Rr].t。

要想匹配行首的字符要使用抑扬字符（^）——有时也被叫做插入符。例如，想找到text.txt中行首"he"打头的行，你可能会先用简单表达式he，但是这会匹配第三行的the，所以要使用正则表达式^he，它只匹配在行首出现的h。

有时候指定“除了×××都匹配”会比较容易达到目的，当抑扬字符（^）出方括号中时，它表示“排除”，例如要匹配he ，但是排除前面是t or s的情形（也就是the和she），可以使用：[^st]he。

可以使用方括号来指定多个字符区间。例如正则表达式[A-Za-z]匹配任何字母，包括大写和小写的；正则表达式[A-Za-z][A-Za-z]* 匹配一个字母后面接着0或者多个字母（大写或者小写）。当然我们也可以用元字符+做到同样的事情，也就是：[A-Za-z]+ ，和[A-Za-z][A-Za-z]*完全等价。但是要注意 元字符+ 并不是所有支持正则表达式的程序都支持的。关于这一点可以参考后面的正则表达式语法支持情况。

要指定特定数量的匹配，要使用大括号（注意必须使用反斜杠。想匹配所有10和100的实例而排除1和 1000，可以使用：10{1,2}，这个正则表达式匹配数字1后面跟着1或者2个0的模式。在这个元字符的使用中一个有用的变化是忽略第二个数字，例如正则表达式0{3,} 将匹配至少3个连续的0。

例1

将所有方法foo(a,b,c)的实例改为foo(b,a,c)。这里a、b和c可以是任何提供给方法foo()的参数。也就是说我们要实现这样的转换：

之前 之后

foo(10,7,2) foo(7,10,2)

foo(x+13,y-2,10) foo(y-2,x+13,10)

foo( bar(8), x+y+z, 5) foo( x+y+z, bar(8), 5)

下面这条替换命令能够实现这一魔法：

:%s/foo(([^,]*),([^,]*),([^)]*))/foo(\2,\1,\3)/g

让我们把它打散来加以分析。写出这个表达式的基本思路是找出foo()和它的括号中的三个参数的位置。第一个参数是用这个表达式来识别的：：([^,]*)，我们可以从里向外来分析它：

[^,] 除了逗号之外的任何字符

[^,]* 0或者多个非逗号字符

([^,]*) 将这些非逗号字符标记为\1，这样可以在之后的替换模式表达式中引用它

([^,]*), 我们必须找到0或者多个非逗号字符后面跟着一个逗号，并且非逗号字符那部分要标记出来以备后用。

正是指出一个使用正则表达式常见错误的最佳时机。为什么我们要使用[^,]*这样的一个表达式，而不是更加简单直接的写法，例如：.*，来匹配第一个参数呢？设想我们使用模式.*来匹配字符串"10,7,2"，它应该匹配"10,"还是"10,7,"？为了解决这个两义性（ambiguity），正则表达式规定一律按照最长的串来，在上面的例子中就是"10,7,"，显然这样就找出了两个参数而不是我们期望的一个。所以，我们要使用[^,]*来强制取出第一个逗号之前的部分。

这个表达式我们已经分析到了：foo(([^,]*)，这一段可以简单的翻译为“当你找到foo(就把其后直到第一个逗号之前的部分标记为\1”。然后我们使用同样的办法标记第二个参数为\2。对第三个参数的标记方法也是一样，只是我们要搜索所有的字符直到右括号。我们并没有必要去搜索第三个参数，因为我们不需要调整它的位置，但是这样的模式能够保证我们只去替换那些有三个参数的foo()方法调用，在foo()是一个重载（overloading）方法时这种明确的模式往往是比较保险的。然后，在替换部分，我们找到foo()的对应实例，然后利用标记好的部分进行替换，是把第一和第二个参数交换位置。

正则表达式语法支持情况

替换技巧

###实例目录

【1】 正则表达式应用——替换指定内容到行尾

【2】 正则表达式应用——数字替换

【3】 正则表达式应用——删除每一行行尾的指定字符

【4】 正则表达式应用——替换带有半角括号的多行

【5】 正则表达式应用——删除空行

【6】 正则表达式应用——实例应用

应用实例

【1】正则表达式应用——替换指定内容到行尾

原始文本如下面两行

abc aaaaa

123 abc 444

希望每次遇到“abc”，则替换“abc”以及其后到行尾的内容为“abc efg”

即上面的文本最终替换为：

abc efg

123 abc efg

解决：

① 在替换对话框，查找内容里输入“abc.*”，替换内容输入为“abc efg”

② 同时勾选“正则表达式”复选框，然后点击“全部替换”按钮

其中，符号的含义如下：

“.” =匹配任意字符

“*” =匹配0次或更多

注意：其实就是正则表达式替换，这里只是把一些曾经提出的问题加以整理，单纯从正则表达式本身来说，就可以引申出成千上万种特例。

【2】正则表达式应用——数字替换

希望把

asdadas123asdasdas456asdasdasd789asdasd

替换为:

asdadas[123]asdasdas[456]asdasdasd[789]asdasd

在替换对话框里面，勾选“正则表达式” 复选框；

在查找内容里面输入“([0-9])([0-9])([0-9])”，不含引号

“替换为:”里面输入“[\1\2\3]”，不含引号

####备注####：查找（[0-9]+） 替换：[\1] 更简单通用些

范围为你所操作的范围，然后选择替换即可。

实际上这也是正则表达式的使用特例，“[0-9]”表示匹配0～9之间的任何特例，同样“[a-z]”就表示匹配a～z之间的任何特例

上面重复使用了“[0-9]”，表示连续出现的三个数字

括号用来选择原型，进行分组，替换时要用

“\1”代表第一个“[0-9]”对应的原型，“\2”代表第二个“[0-9]”对应的原型，依此类推

“[”、“]”为单纯的字符，表示添加“[”或“]”，如果输入“其它\1\2\3其它”，则替换结果为：

asdadas其它123其它asdasdas其它456其它asdasdasd其它789其它asdasd

功能增强：

如果将查找内容“[0-9][0-9][0-9]”改为“[0-9]*[0-9]”，对应1 或 123 或 12345 或 …

大家根据需要定制

相关内容还有很多，可以自己参考正则表达式的语法仔细研究一下

【3】正则表达式应用——删除每一行行尾的指定字符

因为这几个字符在行中也是出现的,所以肯定不能用简单的替换实现

比如

12345 1265345

2345

需要删除每行末尾的“345”

这个也算正则表达式的用法，其实仔细看正则表达式应该比较简单，不过既然有这个问题提出，说明对正则表达式还得有个认识过程，解决方法如下

解决：

在替换对话框中，启用“正则表达式” 复选框

在查找内容里面输入“345$”

这里“$”表示从行尾匹配

如果从行首匹配，可以用“^”来实现，不过 EditPlus 有另一个功能可以很简单的删除行首的字符串

a. 选择要操作的行

b. 编辑－格式－删除行注释

c. 在弹出对话框里面输入要清除的行首字符，确定

【4】正则表达式应用——替换带有半角括号的多行

几百个网页中都有下面一段代码：

1
2
3
4
5
6
7
8
9
10
1<script LANGUAGE="JavaScript1.1">  

2

3<!-- 

4

5htmlAdWH('93163607', '728', '90');  

6

7//--> 

8

9</SCRIPT>  

10

我想把它们都去掉，可是找了很多search & replace的软件，都是只能对“一行”进行操作。

EditPlus 打开几百个网页文件还是比较顺畅的，所以完全可以胜任这个工作。

具体解决方法，在 Editplus 中使用正则表达式，由于“(”、“)”被用做预设表达式（或者可以称作子表达式）的标志，所以查找时会提示查找不到，所以也就无法进行替换了，这时可以把“(”、“)”使用任意字符标记替代，即 半角句号：“.”。替换内容为 在替换对话框启用“正则表达式”选项，这时就可以完成替换了

补充：

对( ) 这样的特殊符号，应该用( )来表示，这也是很标准的regexp语法，可以写为

【5】正则表达式应用——删除空行

启动EditPlus，打开待处理的文本类型文件。

①、选择“查找”菜单的“替换”命令，弹出文本替换对话框。选中“正则表达式” 复选框，表明我们要在查找、替换中使用正则表达式。然后，选中“替换范围”中的“当前文件”，表明对当前文件操作。

②、单击“查找内容” 组合框右侧的按钮，出现下拉菜单。

③、下面的操作添加正则表达式，该表达式代表待查找的空行。（技巧提示：空行仅包括空格符、制表符、回车符，且必须以这三个符号之一作为一行的开头，并且以回车符结尾，查找空行的关键是构造代表空行的正则表达式）。

直接在"查找"中输入正则表达式“^[ \t]*\n”，注意\t前有空格符。

（1）选择“从行首开始匹配”，“查找内容” 组合框中出现字符“^”，表示待查找字符串必须出文本中一行的行首。

（2）选择“字符在范围中”，那么在“^”后会增加一对括号“[]”，当前插入点在括号中。括号在正则表达式中表示，文本中的字符匹配括号中任意一个字符即符合查找条件。

（3）按一下空格键，添加空格符。 空格符是空行的一个组成成分。

（4）选择“制表符”，添加代表制表符的“\t”。

（5）移动光标，将当前 插入点移到“]”之后，然后选择“匹配 0 次或更多”，该操作会添加星号字符“*”。星号表示，其前面的括号“[]”内的 空格符或 制表符，在一行中出现0个或多个。

（6）选择“换行符”，插入“\n”，表示回车符。

④、“替换为” 组合框保持空，表示删除查找到的内容。单击“替换”按钮逐个行删除空行，或单击“全部替换”按钮删除全部空行（注意：EditPlus有时存在“全部替换”不能一次性完全删除空行的问题，可能是程序BUG，需要多按几次按钮）。

【6】 正则表达式应用——实例应用

1.验证用户名和密码：（"^[a-zA-Z]\w{5,15}$"）正确格式："[A-Z][a-z]_[0-9]"组成,并且第一个字必须为字母6~16位；

2.验证电话号码：（"^(\d{3.4}-)\d{7,8}$"）正确格式：xxx/xxxx-xxxxxxx/xxxxxxxx；

3.验证手机号码："^1[3|4|5|8][0-9]\d{8}$"；

4.验证身份证号（15位或18位数字）："\d{17}[[0-9],0-9xX]"；

5.验证Email地址：("^\w+([-+.]\w+)*@\w+([-.]\w+)*.\w+([-.]\w+)*$")；

6.只能输入由数字和26个英文字母组成的字符串：("^[A-Za-z0-9]+$") ;

7.整数或者小数：^[0-9]+.{0,1}[0-9]{0,2}$

8.只能输入数字："^[0-9]*$"。

9.只能输入n位的数字："^\d{n}$"。

10.只能输入至少n位的数字："^\d{n,}$"。

11.只能输入m~n位的数字："^\d{m,n}$"。

12.只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。

13.只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。

14.只能输入有1~3位小数的正实数："^[0-9]+(.[0-9]{1,3})?$"。

15.只能输入非零的正整数："^+?[1-9][0-9]*$"。

16.只能输入非零的负整数："^-[1-9][]0-9"*$。

17.只能输入长度为3的字符："^.{3}$"。

18.只能输入由26个英文字母组成的字符串："^[A-Za-z]+$"。

19.只能输入由26个大写英文字母组成的字符串："^[A-Z]+$"。

20.只能输入由26个小写英文字母组成的字符串："^[a-z]+$"。

21.验证是否含有^%&',;=?$"等字符："[^%&',;=?$\x22]+"。

22.只能输入汉字："^[\u4e00-\u9fa5]{0,}$"。

23.验证URL："^http://([\w-]+.)+[\w-]+(/[\w-./?%&=]*)?$"。

24.验证一年的12个月："^(0?[1-9]|1[0-2])$"正确格式为："01"～"09"和"1"～"12"。

25.验证一个月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为；"01"～"09"和"1"～"31"。

26.获取日期正则表达式：\d{4}[年|-|.]\d{\1-\12}[月|-|.]\d{\1-\31}日?

评注：可用来匹配大多数年月日信息。

27.匹配双字节 字符(包括汉字在内)：[^\x00-\xff]

评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

28.匹配空白行的正则表达式：\n\s*\r

评注：可以用来删除空白行

29.匹配HTML标记的正则表达式：<(\S*?)[^>]*>.*?</>|<.*? />

评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力

30.匹配首尾空白字符的正则表达式：^\s*|\s*$

评注：可以用来删除行首行尾的空白字符(包括空格、 制表符、换页符等等)，非常有用的表达式

31.匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*

评注：网上流传的版本功能很有限，上面这个基本可以满足需求

32.匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$

评注：表单验证时很实用

33.匹配腾讯QQ号：[1-9][0-9]{4,}

评注： 腾讯QQ号从10 000 开始

34.匹配中国邮政编码：[1-9]\d{5}(?!\d)

评注：中国邮政编码为6位数字

35.匹配ip地址：((2[0-4]\d|25[0-5]|[01]?\d\d?).){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)。

评注：提取ip地址时有用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
1Function IsRegu(Regu,s)  

2

3'正则表达式校验 

4

5If Regu="" Then  

6

7Exit Function 

8

9End if  

10

11Dim Re,Sre 

12

13Set Re = New RegExp  

14

15Re.Pattern = Regu 

16

17Sre = Re.Test(s)  

18

19If Sre = True Then 

20

21IsRegu = True  

22

23Else 

24

25IsRegu = False  

26

27End If 

28

29End Function  

30

31tmp=" " 

32

33if (IsRegu("\w+([-+.]\w+)\*@\w+([-.]\w+)\*\.\w+([-.]\w+)\*",tmp )) =false then  

34

35msgbox "E-mail地址不合法 ！" 

36

37FieldCheck\#N=false  

38

39end if 

40

不同的语言（如PHP和JAVA）、相同语言的不同类库（如来自Sun的Java Regular Expression类库跟Apache Jakarta的正则表达式类库）间，用法会有所差别，在使用的时候，要注意这些差别。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1function IsValidUrl(str) {  

2

3var regu = "^(https?://)"   

4+ "?(([0-9a-z_!~\*'().&=+$%-]+: )?[0-9a-z_!~\*'().&=+$%-]+@)?"   

5+ "(([0-9]{1,3}\.){3}[0-9]{1,3}"   

6+ "|"   

7+ "([0-9a-z_!~\*'()-]+\.)\*"   

8+ "([0-9a-z][0-9a-z-]{0,61})?[0-9a-z]\."   

9+ "[a-z]{2,6})"   

10+ "(:[0-9]{1,4})?"   

11+ "((/?)|"   

12+ "(/[0-9a-z_!~\*'().;?:@&=+$,%\#-]+)+/?)$";    

13var re = new RegExp(regu);   

14if (!re.test(str)) {   

15return false;   

16}   

17return true;   

18} 

19

启示

（1） 心中时刻保持新颖想法，尝试用各种新办法来解决遇到的问题。对于遇到的问题，在用常规的解决思路无法解决或不能很好解决的时候，可以大胆探索尝试采用新的方法或思路来解决问题，说大点就是创新！没有新思路估计今天的正则表达式还要等几百年才能露现人间。

（2） 善于学习和借鉴前人的经验和成果，UNIX鼻祖Ken Thompson是什么样子的人？是被计算机界尊称为“UNIX之父”的大师级别的人物，大师都在不断思考从其它学科、其它知识领域的工作成果，来改进自己的工作或程序，事实也证明这样做取得巨大结果和后来的深远影响是事先谁也无法预估到的，我们在做一些事情或研究的时间，是否也考虑学习大师的优秀习惯？

（3） 学好数学、英语并保持对数学、英语的兴趣，数学也是人类几千年积累的智慧结晶，学习数学知识可以培养和训练人的思维能力。看这篇文章的朋友，我想很多都是 计算机相关专业的朋友，至于数学和英语对于计算机学习和发展的重要性的道理，这里就不在多说，重在实践加持之以恒！

（4） 养成独立思考的习惯。上学时候老师经常说人与动物的最大区别是人能思考。拉美洲有句关于“思考”的谚语是，不会思考的人是白痴，不肯思考的人是懒汉，不敢思考的人是奴隶。我想大家和我一样，既不愿做懒汉、奴隶，更不愿做白痴。所以相信正则分享网的朋友们一定会选择做一个“会思、肯思、敢思”的人。

（5） 当正则表达式和字符串函数都能解决问题时，一定要使用字符串函数，这样不容易出错，最重要的是字符串函数比正则表达式实现性能上要好得多。