正则表达式语法
JScript 和 VBScript 正则表达式
正则表达式语法
一个正则表达式就是由普通字符(例如字符 a 到 z)以及特殊字符(称为元字符)组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板,将某个字符模式与所搜索的字符串进行匹配。
这里有一些可能会遇到的正则表达式示例:
JScript
VBScript
匹配
/^/[ /t]*$/
"^/[ /t]*$"
匹配一个空白行。
//d{2}-/d{5}/
"/d{2}-/d{5}"
验证一个ID 号码是否由一个2位数字,一个连字符以及一个5位数字组成。
/.*/
".*"
匹配一个 HTML 标记。
下表是元字符及其在正则表达式上下文中的行为的一个完整列表:
字符
描述
/
将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如,'n' 匹配字符 "n"。'/n' 匹配一个换行符。序列 '//' 匹配 "/" 而 "/(" 则匹配 "("。
^
匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性,^ 也匹配 '/n' 或 '/r' 之后的位置。
$
匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性,$ 也匹配 '/n' 或 '/r' 之前的位置。
*
匹配前面的子表达式零次或多次。例如,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
?
当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串 "oooo",'o+?' 将匹配单个 "o",而 'o+' 将匹配所有 'o'。
.
匹配除 "/n" 之外的任何单个字符。要匹配包括 '/n' 在内的任何字符,请使用象 '[./n]' 的模式。
(pattern)
匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到,在VBScript 中使用 SubMatches 集合,在JScript 中则使用 $0…$9 属性。要匹配圆括号字符,请使用 '/(' 或 '/)'。
(?:pattern)
匹配 pattern 但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如, 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern)
正向预查,在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如,'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ,但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。
(?!pattern)
负向预查,在任何不匹配 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 之前至少有 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 匹配版权符号 (©)
2001 Microsoft Corporation. 保留所有权利。
深入浅出之正则表达式(一)
原贴地址:http://dragon.cnblogs.com/archive/2006/05/08/394078.html
前言:
半年前我对正则表达式产生了兴趣,在网上查找过不少资料,看过不少的教程,最后在使用一个正则表达式工具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”,而会匹配“123+111=234”中的“111=2”。因为“+”在这里表示特殊含义(重复1次到多次)。
在编程语言中,要注意,一些特殊的字符会先被编译器处理,然后再传递给正则引擎。因此正则表达式>在C++中要写成“1//+1=2”。为了匹配“C:/temp”,你要用正则表达式>。而在C++中,正则表达式则变成了“C:temp”。
· 不可显示字符
可以使用特殊字符序列来代表某些不可显示字符:
>代表Tab(0x09)
>代表回车符(0x0D)
>代表换行符(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”,使用>。你可以使用>匹配gray或grey。这在你不确定你要搜索的字符是采用美国英语还是英国英语时特别有用。相反,>将不会匹配 graay或graey。字符集中的字符顺序并没有什么关系,结果都是相同的。
你可以使用连字符“-”定义一个字符范围作为字符集。>匹配 0到9之间的单个数字。你可以使用不止一个范围。>匹配单个的十六进制数字,并且大小写不敏感。你也可以结合范围定义与单个字符定义。>匹配一个十六进制数字或字母X。再次强调一下,字符和范围定义的先后顺序对结果没有影响。
· 字符集的一些应用
查找一个可能有拼写错误的单词,比如> 或 >。
查找程序语言的标识符,>。(*表示重复0或多次)
查找C风格的十六进制数>。(+表示重复一次或多次)
· 取反字符集
在左方括号“[”后面紧跟一个尖括号“^”,将会对字符集取反。结果是字符集将匹配任何不在方括号中的字符。不像“.”,取反字符集是可以匹配回车换行符的。
需要记住的很重要的一点是,取反字符集必须要匹配一个字符。>并不意味着:匹配一个q,后面没有u跟着。它意味着:匹配一个q,后面跟着一个不是u的字符。所以它不会匹配“Iraq”中的q,而会匹配“Iraq is a country”中的q和一个空格符。事实上,空格符是匹配中的一部分,因为它是一个“不是u的字符”。
如果你只想匹配一个q,条件是q后面有一个不是u的字符,我们可以用后面将讲到的向前查看来解决。
· 字符集中的元字符
需要注意的是,在字符集中只有4个 字符具有特殊含义。它们是:“] / ^ -”。“]”代表字符集定义的结束;“/”代表转义;“^”代表取反;“-”代表范围定义。其他常见的元字符在字符集定义内部都是正常字符,不需要转义。例如,要搜索星号*或加号+,你可以用>。当然,如果你对那些通常的元字符进行转义,你的正则表达式一样会工作得很好,但是这会降低可读性。
在字符集定义中为了将反斜杠“/”作为一个文字字符而非特殊含义的字符,你需要用另一个反斜杠对它进行转义。>将会匹配一个反斜杠和一个X。“]^ -”都可以用反斜杠进行转义,或者将他们放在一个不可能使用到他们特殊含义的位置。我们推荐后者,因为这样可以增加可读性。比如对于字符“^”,将它放在除了左括号“[”后面的位置,使用的都是文字字符含义而非取反含义。如>会匹配一个x或^。>会匹配一个“]”或“x”。>或> 都会匹配一个“-”或“x”。
· 字符集的简写
因为一些字符集非常常用,所以有一些简写方式。
>代表>;
>代表单词字符。这个是随正则表达式实现的不同而有些差异。绝大多数的正则表达式实现的单词字符集都包含了>。
>代表“白字符”。这个也是和不同的实现有关的。在绝大多数的实现中,都包含了空格符和Tab符,以及回车换行符>。
字符集的缩写形式可以用在方括号之内或之外。>匹配一个白字符后面紧跟一个数字。>匹配单个白字符或数字。>将匹配一个十六进制数字。
取反字符集的简写
> = >
> = >
> = >
· 字符集的重复
如果你用“?*+”操作符来重复一个字符集,你将会重复整个字符集。而不仅是它匹配的那个字符。正则表达式>会匹配837以及222。
如果你仅仅想重复被匹配的那个字符,可以用向后引用达到目的。我们以后将讲到向后引用。
6. 使用?*或+ 进行重复
?:告诉引擎匹配前导字符0次或一次。事实上是表示前导字符是可选的。
+:告诉引擎匹配前导字符1次或多次
*:告诉引擎匹配前导字符0次或多次
匹配没有属性的HTML标签,“”是文字符号。第一个字符集匹配一个字母,第二个字符集匹配一个字母或数字。
我们似乎也可以用。但是它会匹配。但是这个正则表达式在你知道你要搜索的字符串不包含类似的无效标签时还是足够有效的。
· 限制性重复
许多现代的正则表达式实现,都允许你定义对一个字符重复多少次。词法是:{min,max}。min和max都是非负整数。如果逗号有而max被忽略了,则max没有限制。如果逗号和max都被忽略了,则重复min次。
因此{0,}和*一样,{1,}和+ 的作用一样。
你可以用>匹配1000~9999之间的数字(“/b”表示单词边界)。>匹配一个在100~99999之间的数字。
· 注意贪婪性
假设你想用一个正则表达式匹配一个HTML标签。你知道输入将会是一个有效的HTML文件,因此正则表达式不需要排除那些无效的标签。所以如果是在两个尖括号之间的内容,就应该是一个HTML标签。
许多正则表达式的新手会首先想到用正则表达式 >>,他们会很惊讶的发现,对于测试字符串,“This is a first test”,你可能期望会返回,然后继续进行匹配的时候,返回。
但事实是不会。正则表达式将会匹配“first”。很显然这不是我们想要的结果。原因在于“+”是贪婪的。也就是说,“+”会导致正则表达式引擎试图尽可能的重复前导字符。只有当这种重复会引起整个正则表达式匹配失败的情况下,引擎会进行回溯。也就是说,它会放弃最后一次的“重复”,然后处理正则表达式余下的部分。
和“+”类似,“?*”的重复也是贪婪的。
· 深入正则表达式引擎内部
让我们来看看正则引擎如何匹配前面的例子。第一个记号是“”。到目前为止,“first test”。引擎会试图将“>”与换行符进行匹配,结果失败了。于是引擎进行回溯。结果是现在“first tes”。于是引擎将“>”与“t”进行匹配。显然还是会失败。这个过程继续,直到“first”与“>”匹配。于是引擎找到了一个匹配 “first”。记住,正则导向的引擎是“急切的”,所以它会急着报告它找到的第一个匹配。而不是继续回溯,即使可能会有更好的匹配,例如“”。所以我们可以看到,由于“+”的贪婪性,使得正则表达式引擎返回了一个最左边的最长的匹配。
· 用懒惰性取代贪婪性
一个用于修正以上问题的可能方案是用“+”的惰性代替贪婪性。你可以在“+”后面紧跟一个问号“?”来达到这一点。“*”,“{}”和“?”表示的重复也可以用这个方案。因此在上面的例子中我们可以使用“”。让我们再来看看正则表达式引擎的处理过程。
再一次,正则表达式记号“”匹配“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”格式的日期,但是我们想允许用户来选择分隔符。很快能想到的一个方案是>。看上去它能匹配日期“02/12/03”。问题在于02512703也会被认为是一个有效的日期。
> 看上去是一个好一点的解决方案。记住点号在一个字符集里不是元字符。这个方案远不够完善,它会匹配“99/99/99”。而>又更进一步。尽管他也会匹配“19/39/99”。你想要你的正则表达式达到如何完美的程度取决于你想达到什么样的目的。如果你想校验用户输入,则需要尽可能的完美。如果你只是想分析一个已知的源,并且我们知道没有错误的数据,用一个比较好的正则表达式来匹配你想要搜寻的字符就已经足够。
8. 字符串开始和结束的锚定
锚定和一般的正则表达式符号不同,它不匹配任何字符。相反,他们匹配的是字符之前或之后的位置。“^”匹配一行字符串第一个字符前的位置。>将会匹配字符串“abc”中的a。>将不会匹配“abc”中的任何字符。
类似的,$匹配字符串中最后一个字符的后面的位置。所以>匹配“abc”中的c。
· 锚定的应用
在编程语言中校验用户输入时,使用锚定是非常重要的。如果你想校验用户的输入为整数,用>。
用户输入中,常常会有多余的前导空格或结束空格。你可以用>和>来匹配前导空格或结束空格。
· 使用“^”和“$”作为行的开始和结束锚定
如果你有一个包含了多行的字符串。例如:“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)--将会在每行的行首插入“> ”。
· 绝对锚定
>只匹配整个字符串的开始位置,>只匹配整个字符串的结束位置。即使你使用了“多行模式”,>和>也从不匹配新行符。
即使/Z和$只匹配字符串的结束位置,仍然有一个例外的情况。如果字符串以新行符结束,则/Z和$将会匹配新行符前面的位置,而不是整个字符串的最后面。这个“改进”是由Perl引进的,然后被许多的正则表达式实现所遵循,包括Java,.NET等。如果应用>到“joe/n”,则匹配结果是 “joe”而不是“joe/n”。
深入浅出之正则表达式(二)
原贴地址:http://dragon.cnblogs.com/archive/2006/05/09/394923.html
前言:
本文是前一片文章《深入浅出之正则表达式(一)》的续篇,在本文中讲述了正则表达式中的组与向后引用,先前向后查看,条件测试,单词边界,选择符等表达式及例子,并分析了正则引擎在执行匹配时的内部机理。
本文是Jan Goyvaerts为RegexBuddy写的教程的译文,版权归原作者所有,欢迎转载。但是为了尊重原作者和译者的劳动,请注明出处!谢谢!
9. 单词边界
元字符>也是一种对位置进行匹配的“锚”。这种匹配是0长度匹配。
有4种位置被认为是“单词边界”:
1) 在字符串的第一个字符前的位置(如果字符串的第一个字符是一个“单词字符”)
2) 在字符串的最后一个字符后的位置(如果字符串的最后一个字符是一个“单词字符”)
3) 在一个“单词字符”和“非单词字符”之间,其中“非单词字符”紧跟在“单词字符”之后
4) 在一个“非单词字符”和“单词字符”之间,其中“单词字符”紧跟在“非单词字符”后面
“单词字符”是可以用“/w”匹配的字符,“非单词字符”是可以用“/W”匹配的字符。在大多数的正则表达式实现中,“单词字符”通常包括>。
例如:>能够匹配单个的4而不是一个更大数的一部分。这个正则表达式不会匹配“44”中的4。
换种说法,几乎可以说>匹配一个“字母数字序列”的开始和结束的位置。
“单词边界”的取反集为>,他要匹配的位置是两个“单词字符”之间或者两个“非单词字符”之间的位置。
· 深入正则表达式引擎内部
让我们看看把正则表达式>应用到字符串“This island is beautiful”。引擎先处理符号>。因为/b是0长度,所以第一个字符T前面的位置会被考察。因为T是一个“单词字符”,而它前面的字符是一个空字符(void),所以/b匹配了单词边界。接着>和第一个字符“T”匹配失败。匹配过程继续进行,直到第五个空格符,和第四个字符“s”之间又匹配了>。然而空格符和>不匹配。继续向后,到了第六个字符“i”,和第五个空格字符之间匹配了>,然后>和第六、第七个字符都匹配了。然而第八个字符和第二个“单词边界”不匹配,所以匹配又失败了。到了第13个字符i,因为和前面一个空格符形成“单词边界”,同时>和“is”匹配。引擎接着尝试匹配第二个>。因为第15个空格符和“s”形成单词边界,所以匹配成功。引擎“急着”返回成功匹配的结果。
10. 选择符
正则表达式中“|”表示选择。你可以用选择符匹配多个可能的正则表达式中的一个。
如果你想搜索文字“cat”或“dog”,你可以用>。如果你想有更多的选择,你只要扩展列表>。
选择符在正则表达式中具有最低的优先级,也就是说,它告诉引擎要么匹配选择符左边的所有表达式,要么匹配右边的所有表达式。你也可以用圆括号来限制选择符的作用范围。如>,这样告诉正则引擎把(cat|dog)当成一个正则表达式单位来处理。
· 注意正则引擎的“急于表功”性
正则引擎是急切的,当它找到一个有效的匹配时,它会停止搜索。因此在一定条件下,选择符两边的表达式的顺序对结果会有影响。假设你想用正则表达式搜索一个编程语言的函数列表:Get,GetValue,Set或SetValue。一个明显的解决方案是>。让我们看看当搜索SetValue时的结果。
因为>和>都失败了,而>匹配成功。因为正则导向的引擎都是“急切”的,所以它会返回第一个成功的匹配,就是“Set”,而不去继续搜索是否有其他更好的匹配。
和我们期望的相反,正则表达式并没有匹配整个字符串。有几种可能的解决办法。一是考虑到正则引擎的“急切”性,改变选项的顺序,例如我们使用>,这样我们就可以优先搜索最长的匹配。我们也可以把四个选项结合起来成两个选项:>。因为问号重复符是贪婪的,所以SetValue总会在Set之前被匹配。
一个更好的方案是使用单词边界:>或>。更进一步,既然所有的选择都有相同的结尾,我们可以把正则表达式优化为>。
11. 组与向后引用
把正则表达式的一部分放在圆括号内,你可以将它们形成组。然后你可以对整个组使用一些正则操作,例如重复操作符。
要注意的是,只有圆括号“()”才能用于形成组。“[]”用于定义字符集。“{}”用于定义重复操作。
当用“()”定义了一个正则表达式组后,正则引擎则会把被匹配的组按照顺序编号,存入缓存。当对被匹配的组进行向后引用的时候,可以用“/数字”的方式进行引用。>引用第一个匹配的后向引用组,>引用第二个组,以此类推,>引用第n个组。而>则引用整个被匹配的正则表达式本身。我们看一个例子。
假设你想匹配一个HTML标签的开始标签和结束标签,以及标签中间的文本。比如This is a test,我们要匹配和以及中间的文字。我们可以用如下正则表达式:“]*>.*?”
首先,“”将会匹配“”的第一个字符“”。然后[A-Z]匹配B,[A-Z0-9]*将会匹配0到多次字母数字,后面紧接着0到多个非“>”的字符。最后正则表达式的“>”将会匹配“”的“>”。接下来正则引擎将对结束标签之前的字符进行惰性匹配,直到遇到一个“”符号。然后正则表达式中的“/1”表示对前面匹配的组“([A-Z][A-Z0-9]*)”进行引用,在本例中,被引用的是标签名“B”。所以需要被匹配的结尾标签为“”
你可以对相同的后向引用组进行多次引用,>将匹配“axaxa”、“bxbxb”以及“cxcxc”。如果用数字形式引用的组没有有效的匹配,则引用到的内容简单的为空。
一个后向引用不能用于它自身。>是错误的。因此你不能将>用于一个正则表达式匹配本身,它只能用于替换操作中。
后向引用不能用于字符集内部。>中的>并不表示后向引用。在字符集内部,>可以被解释为八进制形式的转码。
向后引用会降低引擎的速度,因为它需要存储匹配的组。如果你不需要向后引用,你可以告诉引擎对某个组不存储。例如:>。其中“(”后面紧跟的“?:”会告诉引擎对于组(Value),不存储匹配的值以供后向引用。
· 重复操作与后向引用
当对组使用重复操作符时,缓存里后向引用内容会被不断刷新,只保留最后匹配的内容。例如:>将匹配“cab=cab”,但是>却不会。因为 ([abc])第一次匹配“c”时,“/1”代表“c”;然后([abc])会继续匹配“a”和“b”。最后“/1”代表“b”,所以它会匹配“cab= b”。
应用:检查重复单词--当编辑文字时,很容易就会输入重复单词,例如“the the”。使用>可以检测到这些重复单词。要删除第二个单词,只要简单的利用替换功能替换掉“/1”就可以了。
· 组的命名和引用
在PHP,Python中,可以用group)>>来对组进行命名。在本例中,词法?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)是关闭大小写不敏感。你可以很快的进行测试。>应该匹配TEst,但是不能匹配teST或TEST.
13. 原子组与防止回溯
在一些特殊情况下,因为回溯会使得引擎的效率极其低下。
让我们看一个例子:要匹配这样的字串,字串中的每个字段间用逗号做分隔符,第12个字段由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”。匹配失败,继续回溯。大家可以想象,这样的回溯组合是个非常大的数量。因此可能会造成引擎崩溃。
用于阻止这样巨大的回溯有几种方案:
一种简单的方案是尽可能的使匹配精确。用取反字符集代替点号。例如我们用如下正则表达式>,这样可以使失败回溯的次数下降到11次。
另一种方案是使用原子组。
原子组的目的是使正则引擎失败的更快一点。因此可以有效的阻止海量回溯。原子组的语法是正则表达式)>>。位于(?>)之间的所有正则表达式都会被认为是一个单一的正则符号。一旦匹配失败,引擎将会回溯到原子组前面的正则表达式部分。前面的例子用原子组可以表达成(.*?,){11}) P>>。一旦第十二个字段匹配失败,引擎回溯到原子组前面的>。
14. 向前查看与向后查看
Perl 5 引入了两个强大的正则语法:“向前查看”和“向后查看”。他们也被称作“零长度断言”。他们和锚定一样都是零长度的(所谓零长度即指该正则表达式不消耗被匹配的字符串)。不同之处在于“前后查看”会实际匹配字符,只是他们会抛弃匹配只返回匹配结果:匹配或不匹配。这就是为什么他们被称作“断言”。他们并不实际消耗字符串中的字符,而只是断言一个匹配是否可能。
几乎本文讨论的所有正则表达式的实现都支持“向前向后查看”。唯一的一个例外是Javascript只支持向前查看。
· 肯定和否定式的向前查看
如我们前面提过的一个例子:要查找一个q,后面没有紧跟一个u。也就是说,要么q后面没有字符,要么后面的字符不是u。采用否定式向前查看后的一个解决方案为>。否定式向前查看的语法是查看的内容)>>。
肯定式向前查看和否定式向前查看很类似:查看的内容)>>。
如果在“查看的内容”部分有组,也会产生一个向后引用。但是向前查看本身并不会产生向后引用,也不会被计入向后引用的编号中。这是因为向前查看本身是会被抛弃掉的,只保留匹配与否的判断结果。如果你想保留匹配的结果作为向后引用,你可以用>来产生一个向后引用。
· 肯定和否定式的先后查看
向后查看和向前查看有相同的效果,只是方向相反
否定式向后查看的语法是:查看内容)>>
肯定式向后查看的语法是:查看内容)>>
我们可以看到,和向前查看相比,多了一个表示方向的左尖括号。
例:>将会匹配一个没有“a”作前导字符的“b”。
值得注意的是:向前查看从当前字符串位置开始对“查看”正则表达式进行匹配;向后查看则从当前字符串位置开始先后回溯一个字符,然后再开始对“查看”正则表达式进行匹配。
· 深入正则表达式引擎内部
让我们看一个简单例子。
把正则表达式>应用到字符串“Iraq”。正则表达式的第一个符号是>。正如我们知道的,引擎在匹配>以前会扫过整个字符串。当第四个字符“q”被匹配后,“q”后面是空字符(void)。而下一个正则符号是向前查看。引擎注意到已经进入了一个向前查看正则表达式部分。下一个正则符号是 >,和空字符不匹配,从而导致向前查看里的正则表达式匹配失败。因为是一个否定式的向前查看,意味着整个向前查看结果是成功的。于是匹配结果“q” 被返回了。
我们在把相同的正则表达式应用到“quit”。>匹配了“q”。下一个正则符号是向前查看部分的>,它匹配了字符串中的第二个字符“i”。引擎继续走到下个字符“i”。然而引擎这时注意到向前查看部分已经处理完了,并且向前查看已经成功。于是引擎抛弃被匹配的字符串部分,这将导致引擎回退到字符“u”。
因为向前查看是否定式的,意味着查看部分的成功匹配导致了整个向前查看的失败,因此引擎不得不进行回溯。最后因为再没有其他的“q”和>匹配,所以整个匹配失败了。
为了确保你能清楚地理解向前查看的实现,让我们把>应用到“quit”。>首先匹配“q”。然后向前查看成功匹配“u”,匹配的部分被抛弃,只返回可以匹配的判断结果。引擎从字符“i”回退到“u”。由于向前查看成功了,引擎继续处理下一个正则符号>。结果发现>和“u”不匹配。因此匹配失败了。由于后面没有其他的“q”,整个正则表达式的匹配失败了。
· 更进一步理解正则表达式引擎内部机制
让我们把 >应用到“thingamabob”。引擎开始处理向后查看部分的正则符号和字符串中的第一个字符。在这个例子中,向后查看告诉正则表达式引擎回退一个字符,然后查看是否有一个“a”被匹配。因为在“t”前面没有字符,所以引擎不能回退。因此向后查看失败了。引擎继续走到下一个字符“h”。再一次,引擎暂时回退一个字符并检查是否有个“a”被匹配。结果发现了一个“t”。向后查看又失败了。
向后查看继续失败,直到正则表达式到达了字符串中的 “m”,于是肯定式的向后查看被匹配了。因为它是零长度的,字符串的当前位置仍然是“m”。下一个正则符号是>,和“m”匹配失败。下一个字符是字符串中的第二个“a”。引擎向后暂时回退一个字符,并且发现>不匹配“m”。
在下一个字符是字符串中的第一个“b”。引擎暂时性的向后退一个字符发现向后查看被满足了,同时>匹配了“b”。因此整个正则表达式被匹配了。作为结果,正则表达式返回字符串中的第一个“b”。
· 向前向后查看的应用
我们来看这样一个例子:查找一个具有6位字符的,含有“cat”的单词。
首先,我们可以不用向前向后查看来解决问题,例如:
>
足够简单吧!但是当需求变成查找一个具有6-12位字符,含有“cat”,“dog”或“mouse”的单词时,这种方法就变得有些笨拙了。
我们来看看使用向前查看的方案。在这个例子中,我们有两个基本需求要满足:一是我们需要一个6位的字符,二是单词含有“cat”。
满足第一个需求的正则表达式为>。满足第二个需求的正则表达式为>。
把两者结合起来,我们可以得到如下的正则表达式:
>
具体的匹配过程留给读者。但是要注意的一点是,向前查看是不消耗字符的,因此当判断单词满足具有6个字符的条件后,引擎会从开始判断前的位置继续对后面的正则表达式进行匹配。
最后作些优化,可以得到下面的正则表达式:
>
15. 正则表达式中的条件测试
条件测试的语法为>。“if”部分可以是向前向后查看表达式。如果用向前查看,则语法变为:>,其中else部分是可选的。
如果if部分为true,则正则引擎会试图匹配then部分,否则引擎会试图匹配else部分。
需要记住的是,向前先后查看并不实际消耗任何字符,因此后面的then与else部分的匹配时从if测试前的部分开始进行尝试。
16. 为正则表达式添加注释
在正则表达式中添加注释的语法是:>
例:为用于匹配有效日期的正则表达式添加注释:
(?#year)(19|20)/d/d[- /.](?#month)(0[1-9]|1[012])[- /.](?#day)(0[1-9]|[12][0-9]|3[01])
揭开正则表达式的神秘面纱
转贴注:转贴后引用链接有错误,如需要请到原始网页查看。
[原创文章,转载请保留或注明出处:
http://www.regexlab.com/zh/regref.htm]
引言
正则表达式(regular expression)描述了一种字符串匹配的模式,可以用来:(1)检查一个串中是否含有符合某个规则的子串,并且可以得到这个子串;(2)根据匹配规则对字符串进行灵活的替换操作。
正则表达式学习起来其实是很简单的,不多的几个较为抽象的概念也很容易理解。之所以很多人感觉正则表达式比较复杂,一方面是因为大多数的文档没有做到由浅入深地讲解,概念上没有注意先后顺序,给读者的理解带来困难;另一方面,各种引擎自带的文档一般都要介绍它特有的功能,然而这部分特有的功能并不是我们首先要理解的。
文章中的每一个举例,都可以点击进入到测试页面进行测试。闲话少说,开始。
--------------------------------------------------------------------------------
1. 正则表达式规则
1.1 普通字符
字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号,都是"普通字符"。表达式中的普通字符,在匹配一个字符串的时候,匹配与之相同的一个字符。
举例1:表达式 "c",在匹配字符串 "abcde" 时,匹配结果是:成功;匹配到的内容是:"c";匹配到的位置是:开始于2,结束于3。(注:下标从0开始还是从1开始,因当前编程语言的不同而可能不同)
举例2:表达式 "bcd",在匹配字符串 "abcde" 时,匹配结果是:成功;匹配到的内容是:"bcd";匹配到的位置是:开始于1,结束于4。
--------------------------------------------------------------------------------
1.2 简单的转义字符
一些不便书写的字符,采用在前面加 "/" 的方法。这些字符其实我们都已经熟知了。
表达式
可匹配
/r, /n
代表回车和换行符
/t
制表符
//
代表 "/" 本身
还有其他一些在后边章节中有特殊用处的标点符号,在前面加 "/" 后,就代表该符号本身。比如:^, $ 都有特殊意义,如果要想匹配字符串中 "^" 和 "$" 字符,则表达式就需要写成 "/^" 和 "/$"。
表达式
可匹配
/^
匹配 ^ 符号本身
/$
匹配 $ 符号本身
/.
匹配小数点(.)本身
这些转义字符的匹配方法与 "普通字符" 是类似的。也是匹配与之相同的一个字符。
举例1:表达式 "/$d",在匹配字符串 "abc$de" 时,匹配结果是:成功;匹配到的内容是:"$d";匹配到的位置是:开始于3,结束于5。
--------------------------------------------------------------------------------
1.3 能够与 '多种字符' 匹配的表达式
正则表达式中的一些表示方法,可以匹配 '多种字符' 其中的任意一个字符。比如,表达式 "/d" 可以匹配任意一个数字。虽然可以匹配其中任意字符,但是只能是一个,不是多个。这就好比玩扑克牌时候,大小王可以代替任意一张牌,但是只能代替一张牌。
表达式
可匹配
/d
任意一个数字,0~9 中的任意一个
/w
任意一个字母或数字或下划线,也就是 A~Z,a~z,0~9,_ 中任意一个
/s
包括空格、制表符、换页符等空白字符的其中任意一个
.
小数点可以匹配除了换行符(/n)以外的任意一个字符
举例1:表达式 "/d/d",在匹配 "abc123" 时,匹配的结果是:成功;匹配到的内容是:"12";匹配到的位置是:开始于3,结束于5。
举例2:表达式 "a./d",在匹配 "aaa100" 时,匹配的结果是:成功;匹配到的内容是:"aa1";匹配到的位置是:开始于1,结束于4。
--------------------------------------------------------------------------------
1.4 自定义能够匹配 '多种字符' 的表达式
使用方括号 [ ] 包含一系列字符,能够匹配其中任意一个字符。用 [^ ] 包含一系列字符,则能够匹配其中字符之外的任意一个字符。同样的道理,虽然可以匹配其中任意一个,但是只能是一个,不是多个。
表达式
可匹配
[ab5@]
匹配 "a" 或 "b" 或 "5" 或 "@"
[^abc]
匹配 "a","b","c" 之外的任意一个字符
[f-k]
匹配 "f"~"k" 之间的任意一个字母
[^A-F0-3]
匹配 "A"~"F","0"~"3" 之外的任意一个字符
举例1:表达式 "[bcd][bcd]" 匹配 "abc123" 时,匹配的结果是:成功;匹配到的内容是:"bc";匹配到的位置是:开始于1,结束于3。
举例2:表达式 "[^abc]" 匹配 "abc123" 时,匹配的结果是:成功;匹配到的内容是:"1";匹配到的位置是:开始于3,结束于4。
--------------------------------------------------------------------------------
1.5 修饰匹配次数的特殊符号
前面章节中讲到的表达式,无论是只能匹配一种字符的表达式,还是可以匹配多种字符其中任意一个的表达式,都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号,那么不用重复书写表达式就可以重复匹配。
使用方法是:"次数修饰"放在"被修饰的表达式"后边。比如:"[bcd][bcd]" 可以写成 "[bcd]{2}"。
表达式
作用
{n}
表达式重复n次,比如:"/w{2}" 相当于 "/w/w";"a{5}" 相当于 "aaaaa"
{m,n}
表达式至少重复m次,最多重复n次,比如:"ba{1,3}"可以匹配 "ba"或"baa"或"baaa"
{m,}
表达式至少重复m次,比如:"/w/d{2,}"可以匹配 "a12","_456","M12344"...
?
匹配表达式0次或者1次,相当于 {0,1},比如:"a[cd]?"可以匹配 "a","ac","ad"
+
表达式至少出现1次,相当于 {1,},比如:"a+b"可以匹配 "ab","aab","aaab"...
*
表达式不出现或出现任意次,相当于 {0,},比如:"/^*b"可以匹配 "b","^^^b"...
举例1:表达式 "/d+/.?/d*" 在匹配 "It costs $12.5" 时,匹配的结果是:成功;匹配到的内容是:"12.5";匹配到的位置是:开始于10,结束于14。
举例2:表达式 "go{2,8}gle" 在匹配 "Ads by goooooogle" 时,匹配的结果是:成功;匹配到的内容是:"goooooogle";匹配到的位置是:开始于7,结束于17。
--------------------------------------------------------------------------------
1.6 其他一些代表抽象意义的特殊符号
一些符号在表达式中代表抽象的特殊意义:
表达式
作用
^
与字符串开始的地方匹配,不匹配任何字符
$
与字符串结束的地方匹配,不匹配任何字符
/b
匹配一个单词边界,也就是单词和空格之间的位置,不匹配任何字符
进一步的文字说明仍然比较抽象,因此,举例帮助大家理解。
举例1:表达式 "^aaa" 在匹配 "xxx aaa xxx" 时,匹配结果是:失败。因为 "^" 要求与字符串开始的地方匹配,因此,只有当 "aaa" 位于字符串的开头的时候,"^aaa" 才能匹配,比如:"aaa xxx xxx"。
举例2:表达式 "aaa$" 在匹配 "xxx aaa xxx" 时,匹配结果是:失败。因为 "$" 要求与字符串结束的地方匹配,因此,只有当 "aaa" 位于字符串的结尾的时候,"aaa$" 才能匹配,比如:"xxx xxx aaa"。
举例3:表达式 "./b." 在匹配 "@@@abc" 时,匹配结果是:成功;匹配到的内容是:"@a";匹配到的位置是:开始于2,结束于4。
进一步说明:"/b" 与 "^" 和 "$" 类似,本身不匹配任何字符,但是它要求它在匹配结果中所处位置的左右两边,其中一边是 "/w" 范围,另一边是 非"/w" 的范围。
举例4:表达式 "/bend/b" 在匹配 "weekend,endfor,end" 时,匹配结果是:成功;匹配到的内容是:"end";匹配到的位置是:开始于15,结束于18。
一些符号可以影响表达式内部的子表达式之间的关系:
表达式
作用
|
左右两边表达式之间 "或" 关系,匹配左边或者右边
( )
(1). 在被修饰匹配次数的时候,括号中的表达式可以作为整体被修饰
(2). 取匹配结果的时候,括号中的表达式匹配到的内容可以被单独得到
举例5:表达式 "Tom|Jack" 在匹配字符串 "I'm Tom, he is Jack" 时,匹配结果是:成功;匹配到的内容是:"Tom";匹配到的位置是:开始于4,结束于7。匹配下一个时,匹配结果是:成功;匹配到的内容是: "Jack";匹配到的位置时:开始于15,结束于19。
举例6:表达式 "(go/s*)+" 在匹配 "Let's go go go!" 时,匹配结果是:成功;匹配到内容是:"go go go";匹配到的位置是:开始于6,结束于14。
举例7:表达式 "¥(/d+/.?/d*)" 在匹配 "$10.9,¥20.5" 时,匹配的结果是:成功;匹配到的内容是:"¥20.5";匹配到的位置是:开始于6,结束于10。单独获取括号范围匹配到的内容是:"20.5"。
--------------------------------------------------------------------------------
2. 正则表达式中的一些高级规则
2.1 匹配次数中的贪婪与非贪婪
在使用修饰匹配次数的特殊符号时,有几种表示方法可以使同一个表达式能够匹配不同的次数,比如:"{m,n}", "{m,}", "?", "*", "+",具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中,总是尽可能多的匹配。比如,针对文本 "dxxxdxxxd",举例如下:
表达式
匹配结果
(d)(/w+)
"/w+" 将匹配第一个 "d" 之后的所有字符 "xxxdxxxd"
(d)(/w+)(d)
"/w+" 将匹配第一个 "d" 和最后一个 "d" 之间的所有字符 "xxxdxxx"。虽然 "/w+" 也能够匹配上最后一个 "d",但是为了使整个表达式匹配成功,"/w+" 可以 "让出" 它本来能够匹配的最后一个 "d"
由此可见,"/w+" 在匹配的时候,总是尽可能多的匹配符合它规则的字符。虽然第二个举例中,它没有匹配最后一个 "d",但那也是为了让整个表达式能够匹配成功。同理,带 "*" 和 "{m,n}" 的表达式都是尽可能地多匹配,带 "?" 的表达式在可匹配可不匹配的时候,也是尽可能的 "要匹配"。这 种匹配原则就叫作 "贪婪" 模式 。
非贪婪模式:
在修饰匹配次数的特殊符号后再加上一个 "?" 号,则可以使匹配次数不定的表达式尽可能少的匹配,使可匹配可不匹配的表达式,尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪" 模式,也叫作 "勉强" 模式。如果少匹配就会导致整个表达式匹配失败的时候,与贪婪模式类似,非贪婪模式会最小限度的再匹配一些,以使整个表达式匹配成功。举例如下,针对文本 "dxxxdxxxd" 举例:
表达式
匹配结果
(d)(/w+?)
"/w+?" 将尽可能少的匹配第一个 "d" 之后的字符,结果是:"/w+?" 只匹配了一个 "x"
(d)(/w+?)(d)
为了让整个表达式匹配成功,"/w+?" 不得不匹配 "xxx" 才可以让后边的 "d" 匹配,从而使整个表达式匹配成功。因此,结果是:"/w+?" 匹配 "xxx"
更多的情况,举例如下:
举例1:表达式 "<td>(.*)</td>" 与字符串 "<td><p>aa</p></td> <td><p>bb</p></td>" 匹配时,匹配的结果是:成功;匹配到的内容是 "<td><p>aa</p></td> <td><p>bb</p></td>" 整个字符串, 表达式中的 "</td>" 将与字符串中最后一个 "</td>" 匹配。
举例2:相比之下,表达式 "<td>(.*?)</td>" 匹配举例1中同样的字符串时,将只得到 "<td><p>aa</p></td>", 再次匹配下一个时,可以得到第二个 "<td><p>bb</p></td>"。
--------------------------------------------------------------------------------
2.2 反向引用 /1, /2...
表达式在匹配时,表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候,小括号包含的表达式所匹配到的字符串可以单独获取。这一点,在前面的举例中,已经多次展示了。在实际应用场合中,当用某种边界来查找,而所要获取的内容又不包含边界时,必须使用小括号来指定所要的范围。比如前面的 "<td>(.*?)</td>"。
其实,"小括号包含的表达式所匹配到的字符串" 不仅是在匹配结束后才可以使用,在匹配过程中也可以使用。表达式后边的部分,可以引用前面 "括号内的子匹配已经匹配到的字符串"。引用方法是 "/" 加上一个数字。"/1" 引用第1对括号内匹配到的字符串,"/2" 引用第2对括号内匹配到的字符串……以此类推,如果一对括号内包含另一对括号,则外层的括号先排序号。换句话说,哪一对的左括号 "(" 在前,那这一对就先排序号。
举例如下:
举例1:表达式 "('|")(.*?)(/1)" 在匹配 " 'Hello', "World" " 时,匹配结果是:成功;匹配到的内容是:" 'Hello' "。再次匹配下一个时,可以匹配到 " "World" "。
举例2:表达式 "(/w)/1{4,}" 在匹配 "aa bbbb abcdefg ccccc 111121111 999999999" 时,匹配结果是:成功;匹配到的内容是 "ccccc"。再次匹配下一个时,将得到 999999999。这个表达式要求 "/w" 范围的字符至少重复5次,注意与 "/w{5,}" 之间的区别。
举例3:表达式 "<(/w+)/s*(/w+(=('|").*?/4)?/s*)*>.*?<//1>" 在匹配 "<td id='td1' style="bgcolor:white"></td>" 时,匹配结果是成功。如果 "<td>" 与 "</td>" 不配对,则会匹配失败;如果改成其他配对,也可以匹配成功。
--------------------------------------------------------------------------------
2.3 预搜索,不匹配;反向预搜索,不匹配
前面的章节中,我讲到了几个代表抽象意义的特殊符号:"^","$","/b"。它们都有一个共同点,那就是:它们本身不匹配任何字符,只是对 "字符串的两头" 或者 "字符之间的缝隙" 附加了一个条件。理解到这个概念以后,本节将继续介绍另外一种对 "两头" 或者 "缝隙" 附加条件的,更加灵活的表示方法。
正向预搜索:"(?=xxxxx)","(?!xxxxx)"
格式:"(?=xxxxx)",在被匹配的字符串中,它对所处的 "缝隙" 或者 "两头" 附加的条件是:所在缝隙的右侧,必须能够匹配上 xxxxx 这部分的表达式。因为它只是在此作为这个缝隙上附加的条件,所以它并不影响后边的表达式去真正匹配这个缝隙之后的字符。这就类似 "/b",本身不匹配任何字符。"/b" 只是将所在缝隙之前、之后的字符取来进行了一下判断,不会影响后边的表达式来真正的匹配。
举例1:表达式 "Windows (?=NT|XP)" 在匹配 "Windows 98, Windows NT, Windows 2000" 时,将只匹配 "Windows NT" 中的 "Windows ",其他的 "Windows " 字样则不被匹配。
举例2:表达式 "(/w)((?=/1/1/1)(/1))+" 在匹配字符串 "aaa ffffff 999999999" 时,将可以匹配6个"f"的前4个,可以匹配9个"9"的前7个。这个表达式可以读解成:重复4次以上的字母数字,则匹配其剩下最后2位之前的部分。当然,这个表达式可以不这样写,在此的目的是作为演示之用。
格式:"(?!xxxxx)",所在缝隙的右侧,必须不能匹配 xxxxx 这部分表达式。
举例3:表达式 "((?!/bstop/b).)+" 在匹配 "fdjka ljfdl stop fjdsla fdj" 时,将从头一直匹配到 "stop" 之前的位置,如果字符串中没有 "stop",则匹配整个字符串。
举例4:表达式 "do(?!/w)" 在匹配字符串 "done, do, dog" 时,只能匹配 "do"。在本条举例中,"do" 后边使用 "(?!/w)" 和使用 "/b" 效果是一样的。
反向预搜索:"(?<=xxxxx)","(?<!xxxxx)"
这两种格式的概念和正向预搜索是类似的,反向预搜索要求的条件是:所在缝隙的 "左侧",两种格式分别要求必须能够匹配和必须不能够匹配指定表达式,而不是去判断右侧。与 "正向预搜索" 一样的是:它们都是对所在缝隙的一种附加条件,本身都不匹配任何字符。
举例5:表达式 "(?<=/d{4})/d+(?=/d{4})" 在匹配 "1234567890123456" 时,将匹配除了前4个数字和后4个数字之外的中间8个数字。由于 JScript.RegExp 不支持反向预搜索,因此,本条举例不能够进行演示。很多其他的引擎可以支持反向预搜索,比如:Java 1.4 以上的 java.util.regex 包,.NET 中System.Text.RegularExpressions 命名空间,以及本站推荐的最简单易用的 DEELX 正则引擎。
--------------------------------------------------------------------------------
3. 其他通用规则
还有一些在各个正则表达式引擎之间比较通用的规则,在前面的讲解过程中没有提到。
3.1 表达式中,可以使用 "/xXX" 和 "/uXXXX" 表示一个字符("X" 表示一个十六进制数)
形式
字符范围
/xXX
编号在 0 ~ 255 范围的字符,比如:空格可以使用 "/x20" 表示
/uXXXX
任何字符可以使用 "/u" 再加上其编号的4位十六进制数表示,比如:"/u4E2D"
3.2 在表达式 "/s","/d","/w","/b" 表示特殊意义的同时,对应的大写字母表示相反的意义
表达式
可匹配
/S
匹配所有非空白字符("/s" 可匹配各个空白字符)
/D
匹配所有的非数字字符
/W
匹配所有的字母、数字、下划线以外的字符
/B
匹配非单词边界,即左右两边都是 "/w" 范围或者左右两边都不是 "/w" 范围时的字符缝隙
3.3 在表达式中有特殊意义,需要添加 "/" 才能匹配该字符本身的字符汇总
字符
说明
^
匹配输入字符串的开始位置。要匹配 "^" 字符本身,请使用 "/^"
$
匹配输入字符串的结尾位置。要匹配 "$" 字符本身,请使用 "/$"
( )
标记一个子表达式的开始和结束位置。要匹配小括号,请使用 "/(" 和 "/)"
[ ]
用来自定义能够匹配 '多种字符' 的表达式。要匹配中括号,请使用 "/[" 和 "/]"
{ }
修饰匹配次数的符号。要匹配大括号,请使用 "/{" 和 "/}"
.
匹配除了换行符(/n)以外的任意一个字符。要匹配小数点本身,请使用 "/."
?
修饰匹配次数为 0 次或 1 次。要匹配 "?" 字符本身,请使用 "/?"
+
修饰匹配次数为至少 1 次。要匹配 "+" 字符本身,请使用 "/+"
*
修饰匹配次数为 0 次或任意次。要匹配 "*" 字符本身,请使用 "/*"
|
左右两边表达式之间 "或" 关系。匹配 "|" 本身,请使用 "/|"
3.4 括号 "( )" 内的子表达式,如果希望匹配结果不进行记录供以后使用,可以使用 "(?:xxxxx)" 格式
举例1:表达式 "(?:(/w)/1)+" 匹配 "a bbccdd efg" 时,结果是 "bbccdd"。括号 "(?:)" 范围的匹配结果不进行记录,因此 "(/w)" 使用 "/1" 来引用。
3.5 常用的表达式属性设置简介:Ignorecase,Singleline,Multiline,Global
表达式属性
说明
Ignorecase
默认情况下,表达式中的字母是要区分大小写的。配置为 Ignorecase 可使匹配时不区分大小写。有的表达式引擎,把 "大小写" 概念延伸至 UNICODE 范围的大小写。
Singleline
默认情况下,小数点 "." 匹配除了换行符(/n)以外的字符。配置为 Singleline 可使小数点可匹配包括换行符在内的所有字符。
Multiline
默认情况下,表达式 "^" 和 "$" 只匹配字符串的开始 ① 和结尾 ④ 位置。如:
①xxxxxxxxx②/n
③xxxxxxxxx④
配置为 Multiline 可以使 "^" 匹配 ① 外,还可以匹配换行符之后,下一行开始前 ③ 的位置,使 "$" 匹配 ④ 外,还可以匹配换行符之前,一行结束 ② 的位置。
Global
主要在将表达式用来替换时起作用,配置为 Global 表示替换所有的匹配。
--------------------------------------------------------------------------------
4. 其他提示
4.1 如果想要了解高级的正则引擎还支持那些复杂的正则语法,可参见本站 DEELX 正则引擎的说明文档。
4.2 如果要要求表达式所匹配的内容是整个字符串,而不是从字符串中找一部分,那么可以在表达式的首尾使用 "^" 和 "$",比如:"^/d+$" 要求整个字符串只有数字。
4.3 如果要求匹配的内容是一个完整的单词,而不会是单词的一部分,那么在表达式首尾使用 "/b",比如:使用 "/b(if|while|else|void|int……)/b" 来匹配程序中的关键字。
4.4 表达式不要匹配空字符串。否则会一直得到匹配成功,而结果什么都没有匹配到。比如:准备写一个匹配 "123"、"123."、"123.5"、".5" 这几种形式的表达式时,整数、小数点、小数数字都可以省略,但是不要将表达式写成:"/d*/.?/d*",因为如果什么都没有,这个表达式也可以匹配成功。更好的写法是:"/d+/.?/d*|/./d+"。
4.5 能匹配空字符串的子匹配不要循环无限次。如果括号内的子表达式中的每一部分都可以匹配 0 次,而这个括号整体又可以匹配无限次,那么情况可能比上一条所说的更严重,匹配过程中可能死循环。虽然现在有些正则表达式引擎已经通过办法避免了这种情况出现死循环了,比如 .NET 的正则表达式,但是我们仍然应该尽量避免出现这种情况。如果我们在写表达式时遇到了死循环,也可以从这一点入手,查找一下是否是本条所说的原因。
4.6 合理选择贪婪模式与非贪婪模式,参见话题讨论。
4.7 或 "|" 的左右两边,对某个字符最好只有一边可以匹配,这样,不会因为 "|" 两边的表达式因为交换位置而有所不同。
正则表达式话题
[原创文章,转载请保留或注明出处:http://www.regexlab.com/zh/regtopic.htm]
引言
本文将逐步讨论一些正则表达式的使用话题。本文为本站基础篇之后的扩展,在阅读本文之前,建议先阅读正则表达式参考文档一文。
--------------------------------------------------------------------------------
1. 表达式的递归匹配
有时候,我们需要用正则表达式来分析一个计算式中的括号配对情况。比如,使用表达式 "/( [^)]* /)" 或者 "/( .*? /)" 可以匹配一对小括号。但是如果括号 内还嵌有一层括号的话 ,如 "( ( ) )",则这种写法将不能够匹配正确,得到的结果是 "( ( )" 。类似情况的还有 HTML 中支持嵌套的标签如 "<font> </font>" 等。本节将要讨论的是,想办法把有嵌套的的成对括号或者成对标签匹配出来。
匹配未知层次的嵌套:
有的正则表达式引擎,专门针对这种嵌套提供了支持。并且在栈空间允许的情况下,能够支持任意未知层次的嵌套:比如 Perl,PHP,GRETA 等。在 PHP 和 GRETA 中,表达式中使用 "(?R)" 来表示嵌套部分。
匹配嵌套了未知层次的 "小括号对" 的表达式写法如下:"/( ([^()] | (?R))* /)"。
[Perl 和 PHP 的示例代码]
匹配有限层次的嵌套:
对于不支持嵌套的正则表达式引擎,只能通过一定的办法来匹配有限层次的嵌套。思路如下:
第一步,写一个不能支持嵌套的表达式:"/( [^()]* /)","<font>((?!</?font>).)*</font>"。 这两个表达式在匹配有嵌套的文本时,只匹配最内层。
第二步,写一个可匹配嵌套一层的表达式:"/( ([^()] | /( [^()]* /))* /)"。这个表达式在匹配嵌套层数大于一时,只能匹配最里面的两层,同时,这个表达式也能匹配没有嵌套的文本或者嵌套的最里层。
匹配嵌套一层的 "<font>" 标签,表达式为:"<font>((?!</?font>).|(<font>((?!</? font>).)*</font>))*</font>"。这个表达式在匹配 "<font>" 嵌套层数大于一的文本时,只匹配最里面的两层。
第三步,找到匹配嵌套(n)层的表达式 与 嵌套(n-1)层的表达式之间的关系。比如,能够匹配嵌套(n)层的表达式为:
[标记头] ( [匹配 [标记头] 和 [标记尾] 之外的表达式] | [匹配 n-1 层的表达式] )* [标记尾]
回头来看前面编写的“可匹配嵌套一层”的表达式:
/( ( [^()] | /(([^()])*/) )* /)
<font> ( (?!</?font>). | (<font>((?!</?font>).)*</font>) )* </font>
PHP 和 GRETA 的简便之处在于,匹配嵌套(n-1)层的表达式用 (?R) 表示:
/( ( [^()] | (?R) )* /)
第四步,依此类推,可以编写出匹配有限(n)层的表达式。这种方式写出来的表达式,虽然看上去很长,但是这种表达式经过编译后,匹配效率仍然是很高的。
--------------------------------------------------------------------------------
2. 非贪婪匹配的效率
可能有不少的人和我一样,有过这样的经历:当我们要匹配类似 "<td>内容</td>" 或者 "加粗" 这样的文本时,我们根据正向预搜索功能写出这样的表达式:"<td>([^<]|<(?!/td>))*</td>" 或者 "<td>((?!</td>).)*</td>"。
当发现非贪婪匹配之时,恍然大悟,同样功能的表达式可以写得如此简单:"<td>.*?</td>"。顿时间如获至宝,凡是按边界匹配的地方,尽量使用简捷的非贪婪匹配 ".*?"。特别是对于复杂的表达式来说,采用非贪婪匹配 ".*?" 写出来的表达式的确是简练了许多。
然而,当一个表达式中,有多个非贪婪匹配时,或者多个未知匹配次数的表达式时,这个表达式将可能存在效率上的陷阱。有时候,匹配速度慢得莫名奇妙,甚至开始怀疑正则表达式是否实用。
效率陷阱的产生:
在本站基础文章里,对非贪婪匹配的描述中说到:“如果少匹配就会导致整个表达式匹配失败的时候,与贪婪模式类似,非贪婪模式会最小限度的再匹配一些,以使整个表达式匹配成功。”
具体的匹配过程是这样的:
"非贪婪部分" 先匹配最少次数,然后尝试匹配 "右侧的表达式"。
如果右侧的表达式匹配成功,则整个表达式匹配结束。如果右侧表达式匹配失败,则 "非贪婪部分" 将增加匹配一次,然后再尝试匹配 "右侧的表达式"。
如果右侧的表达式又匹配失败,则 "非贪婪部分" 将再增加匹配一次。再尝试匹配 "右侧的表达式"。
依此类推,最后得到的结果是 "非贪婪部分" 以尽可能少的匹配次数,使整个表达式匹配成功。或者最终仍然匹配失败。
当一个表达式中有多个非贪婪匹配,以表达式 "d(/w+?)d(/w+?)z" 为例,对于第一个括号中的 "/w+?" 来说,右边的 "d(/w+?)z" 属于它的 "右侧的表达式",对于第二个括号中的 "/w+?" 来说,右边的 "z" 属于它的 "右侧的表达式"。
当 "z" 匹配失败时,第二个 "/w+?" 会 "增加匹配一次",再尝试匹配 "z"。如果第二个 "/w+?" 无论怎样 "增加匹配次数",直至整篇文本结束,"z" 都不能匹配,那么表示 "d(/w+?)z" 匹配失败,也就是说第一个 "/w+?" 的 "右侧" 匹配失败。此时,第一个 "/w+?" 会增加匹配一次,然后再进行 "d(/w+?)z" 的匹配。循环前面所讲的过程,直至第一个 "/w+?" 无论怎么 "增加匹配次数",后边的 "d(/w+?)z" 都不能匹配时,整个表达式才宣告匹配失败。
其实,为了使整个表达式匹配成功,贪婪匹配也会适当的“让出”已经匹配的字符。因此贪婪匹配也有类似的情况。当一个表达式中有较多的未知匹配次数的表达式时,为了让整个表达式匹配成功,各个贪婪或非贪婪的表达式都要进行尝试减少或增加匹配次数,由此容易形成一个大循环的尝试,造成了很长的匹配时间。本文之所以称之为“陷阱”,因为这种效率问题往往不易察觉。
举例:"d(/w+?)d(/w+?)d(/w+?)z" 匹配 "ddddddddddd..." 时,将花费较长一段时间才能判断出匹配失败 。
效率陷阱的避免:
避免效率陷阱的原则是:避免“多重循环”的“尝试匹配”。并不是说非贪婪匹配就是不好的,只是在运用非贪婪匹配的时候,需要注意避免过多“循环尝试”的问题。
情况一:对于只有一个非贪婪或者贪婪匹配的表达式来说,不存在效率陷阱。也就是说,要匹配类似 "<td> 内容 </td>" 这样的文本,表达式 "<td>([^<]|<(?!/td>))*</td>" 和 "<td>((?!</td>).)*</td>" 和 "<td>.*?</td>" 的效率是完全相同的。
情况二:如果一个表达式中有多个未知匹配次数的表达式,应防止进行不必要的尝试匹配。
比如,对表达式 "<script language='(.*?)'>(.*?)</script>" 来说,如果前面部分表达式在遇到 "<script language='vbscript'>" 时匹配成功后,而后边的 "(.*?)</script>" 却匹配失败,将导致第一个 ".*?" 增加匹配次数再尝试。而对于表达式真正目的,让第一个 ".*?" 增加匹配成“vbscript'>”是不对的,因此这种尝试是不必要的尝试。
因此,对依靠边界来识别的表达式,不要让未知匹配次数的部分跨过它的边界。前面的表达式中,第一个 ".*?" 应该改写成 "[^']*"。后边那个 ".*?" 的右边再没有未知匹配次数的表达式,因此这个非贪婪匹配没有效率陷阱。于是,这个匹配脚本块的表达式,应该写成:"<script language='([^']*)'>(.*?)</script>" 更好。
正则表达式参考手册__Mini版
正则表达式参考手册__Mini版
正则表达式就是由普通字符(例如字符 a 到 z )以及特殊字符(称为元字符)组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板,将某个字符模式与所搜索的字符串进行匹配。
本文详细地列出了能在正则表达式中使用,以匹配文本的各种字符。当你需要解释一个现有的正则表达式时,可以作为一个快捷的参考。更多详细内容,请参考: Francois Liger,Craig McQueen,Pal Wilton[ 刘乐亭 译 ] C# 字符串和正则表达式参考手册北京:清华大学出版社 2003.2
一 . 匹配字符
字符类
匹配的字符
举 例
/d
从0 - 9的任一数字
/d/d 匹配 72, 但不匹配 aa 或 7a
/D
任一非数字字符
/D/D/D 匹配 abc, 但不匹配 123
/w
任一单词字符,包括 A-Z,a-z,0-9 和下划线
/w/w/w/w 匹配 Ab-2 ,但不匹配 ∑ £$ %* 或 Ab_@
/W
任一非单词字符
/W 匹配@,但不匹配 a
/s
任一空白字符,包括制表符,换行符,回车符,换页符和垂直制表符
匹配在 HTML,XML 和其他标准定义中的所有传统空白字符
/S
任一非空白字符
空白字符以外的任意字符 , 如 A%&g3; 等
.
任一字符
匹配除换行符以外的任意字符除非设置了 MultiLine 先项
[…]
括号中的任一字符
[abc] 将匹配一个单字符 ,a,b 或 c.
[a-z] 将匹配从 a 到 z 的任一字符
[ ^ …]
不在括号中的任一字符
[ ^ abc] 将匹配一个 a 、 b 、 c 之外的单字符 , 可以 a,b 或 A 、 B 、 C
[a-z] 将匹配不属于 a-z 的任一字符 , 但可以匹配所有的大写字母
二 . 重复字符
重复字符
含 义
举 例
{ n }
匹配前面的字符 n 次
x{2} 匹配 xx, 但不匹配 x 或 xxx
{ n, }
匹配前面的字符至少 n 次
x{2} 匹配 2 个或更多的 x, 如 xxx,xxx..
{ n,m }
匹配前面的字符至少 n 次 , 至多 m 次。如果 n 为 0 ,此参数为可选参数
x{2,4} 匹配 xx,xxx,xxxx, 但不匹配 xxxxx
?
匹配前面的字符 0 次或 1 次,实质上也是可选的
x? 匹配 x 或零个 x
+
匹配前面的字符 0 次或多次
x+ 匹配 x 或 xx 或大于 0 的任意多个 x
*
匹配前面的字符 0 次或更多次
x* 匹配 0,1 或更多个 x
三 . 定位字符
定位字符
描 述
^
随后的模式必须位于字符串的开始位置,如果是一个多行字符串,则必须位于行首。对于多行文本(包含回车符的一个字符串)来说,需要设置多行标志
$
前面的模式必须位于字符串的未端,如果是一个多行字符串,必须位于行尾
/A
前面的模式必须位于字符串的开始位置,忽略多行标志
/z
前面的模式必须位于字符串的未端,忽略多行标志
/Z
前面的模式必须位于字符串的未端,或者位于一个换行符前
/b
匹配一个单词边界,也就是一个单词字符和非单词字符中间的点。要记住一个单词字符是 [a-zA-Z0-9] 中的一个字符。位于一个单词的词首
/B
匹配一个非单词字符边界位置,不是一个单词的词首
注:定位字符可以应用于字符或组合,放在字符串的左端或右端
四 . 分组字符
分组字符
定 义
举 例
()
此字符可以组合括号内模式所匹配的字符, 它是一个捕获组,也就是说模式匹配的字符作为最终设置了 ExplicitCapture 选项――默认状态下字符不是匹配的一部分
输入字符串为: ABC1DEF2XY
匹配 3 个从 A 到 Z 的字符和 1 个数字的正则表达式:( [A-Z]{3}/d )
将产生两次匹配: Match 1=ABC1;Match 2=DEF2
每次匹配对应一个组: Match1 的第一个组= ABC;Match2 的第 1 个组= DEF
有了反向引用,就可以通过它在正则表达式中的编号以及 C# 和类 Group,GroupCollection 来访问组。如果设置了 ExplicitCapture 选项,就不能使用组所捕获的内容
( ?: )
此字符可以组合括号内模式所匹配的字符, 它是一个非捕获组,这意味着模式所的字符将不作为一个组来捕获,但它构成了最终匹配结果的一部分。它基本上与上面的组类型相同,但设定了选项 ExplicitCapture
输入字符串为: 1A BB SA 1 C
匹配一个数字或一个 A 到 Z 的字母,接着是任意单词字符的正则表达式为:( ?:/d|[A-Z]/w )
它将产生 3 次匹配:每 1 次匹配= 1A ;每 2 次匹配= BB; 每 3 次匹配= SA
但是没有组被捕获
( ? )
此选项组合括号内模式所匹配的字符,并用尖括号中指定 的值为组命名。在正则表达式中,可以使用名称进行反向引用,而不必使用编号。即使不设置 ExplicitCapture 选项,它也是一个捕获组。这意味着反向引用可以利用组内匹配的字符,或者通过 Group 类访问
输入字符串为: Characters in Sienfeld included Jerry Seinfeld,Elaine Benes,Cosno Kramer and George Costanza 能够匹配它们的姓名,并在一个组 llastName 中捕获姓的正则表达式为: /b[A-Z][a-z]+(?[A-Z][a-z]+)/b
它产生了 4 次匹配: First Match=Jerry Seinfeld; Second Match=Elaine Benes; Third Match=Cosmo Kramer; Fourth Match=George Costanza
每一次匹配都对应了一个 lastName 组:
第 1 次匹配: lastName group=Seinfeld
第 2 次匹配: lastName group=Benes
第 3 次匹配: lastName group=Kramer
第 4 次匹配: lastName group=Costanza
不管是否设置了选项 ExplictCapture ,组都将被捕获
( ?= )
正声明。声明的右侧必须是括号中指定的模式。此模式不构成最终匹配的一部分
正则表达式 /S+(?=.NET) 要匹配的输入字符串为: The languages were Java,C#.NET,VB.NET,C,Jscript.NET,Pascal
将产生如下匹配:〕
C#
VB
JScript
( ?! )
负声明。它规定模式不能紧临着声明的右侧。此模式不构成最终匹配的一部分
/d{3}(?![A-Z]) 要匹配的输入字符串为: 123A 456 789 111C
将产生如下匹配:
456
789
( ?
反向正声明。声明的左侧必须为括号内的指定模式。此模式不构成最终匹配的一部分
正则表达式 (?
它将产生如下匹配:
Mexico
England
( ?
反向正声明。声明的左侧必须不能是括号内的指定模式。此模式不构成最终匹配的一部分
正则表达式 (?
它将实现如下匹配:
56F
89C
( ?> )
非回溯组。防止 Regex 引擎回溯并且防止实现一次匹配
假设要匹配所有以“ ing ”结尾的单词。输入字符串如下: He was very trusing
正则表达式为: .*ing
它将实现一次匹配――单词 trusting 。“ . ” 匹配任意字符,当然也匹配“ ing ”。所以, Regex 引擎回溯一位并在第 2 个“ t ”停止,然后匹配指定的模式“ ing ”。但是,如果禁用回溯操作: (?>.*)ing
它将实现 0 次匹配。“ . ”能匹配所有的字符,包括“ ing ”――不能匹配,从而匹配失败
五 . 决策字符
字 符
描 述
举 例
( ?(regex)yes_regex|no_regex )
如果表达式 regex 匹配,那么将试?
正则表达式
最新推荐文章于 2024-08-24 13:06:38 发布