正则表达式及其使用

深碍√TFBOYSˉ_ 2022-11-17 13:52 265阅读 0赞

### 正则表达式及其使用 ###

正则表达式(regular expression，常简写为regex、regexp或RE)描述了一种字符串匹配的模式（pattern）【一个正则表达式通常被称为一个模式（pattern）】，可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。在很多文本编辑器里，正则表达式通常被用来检索、替换那些匹配某个模式的文本。许多程序设计语言都支持利用正则表达式进行字符串操作。

字符串是编程时涉及到的最多的一种数据结构，对字符串进行操作的需求几乎无处不在。如判断一个字符串是否是合法的电话号码格式、身份证格式、合法的Email地址，虽然可以编程代码处理，但这样做不但麻烦，而且代码难以复用。正则表达式(Regular Expression)是一种用来匹配字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的。

电话号码的正则表达式

匹配固定电话号码：0\\d\{2,3\}-\[1-9\]\\d\{6,7\}

其中

0\\d\{2,3\}为区号：国内区号都是以0开头；

\- ：区号与电话号分隔；

\[1-9\]\\d\{6,7\}为电话号： \[1-9\]，电话号第一位不能为0；\\d\{6,7\}，6到7位任意数字。

匹配11位手机号码：1\[3-9\]\\\\d\{9\}

其中

国内手机号第一位都是1，第二位是3-9之间的数字，后面9位可任意取

在线正则表达式测试工具：[https://c.runoob.com/front-end/854][https_c.runoob.com_front-end_854]

下面简要介绍正则表达式基础知识

在正则表达式中，如果直接给出字符，就是精确匹配。用\\d可以匹配一个数字，\\w可以匹配一个字母或数字，.可以匹配任意字符，如：

'00\\d'可以匹配'007'，但无法匹配'00A'；'\\d\\d\\d'可以匹配'301'；'\\w\\w\\d'可以匹配'py3'；'py.'可以匹配'py3'、'py!'等。

在正则表达式中，\\s可以匹配一个空格（也包括Tab等空白符），所以\\s+表示至少有一个空格，例如匹配' '，' '等；

数量限定符：用\*表示任意个字符（包括0个），用+表示至少一个字符（1次或多次），用?表示0个或1个字符，用\{n\}表示n个字符，用\{n,m\}表示n-m个字符，如：

0\*42可以匹配42、042、0042、00042等；

goo+gle可以匹配google、gooogle、goooogle等;

colou?r可以匹配color或者colour;

\\d\{3\}\\s+\\d\{3,8\} 可以匹配：123 012、012 12345678等。

圆括号()可以用来定义操作符的范围和优先度。例如，gr(a|e)y等价于gray|grey，(grand)?father匹配father和grandfather。

上述这些构造子都可以自由组合，因此H(ae?|ä)ndel和H(a|ae|ä)ndel是相同的，表示\{"Handel", "Haendel", "Händel"\}。

要做更精确地匹配，可以用\[\]表示范围，如：

\[0-9a-zA-Z\\\_\]可以匹配一个数字、字母或者下划线；

\[0-9a-zA-Z\\\_\]+可以匹配至少由一个数字、字母或者下划线组成的字符串，如'a100'，'0\_Z'，'Py3000'等等；

\[a-zA-Z\\\_\]\[0-9a-zA-Z\\\_\]\*可以匹配由字母或下划线开头，后接任意个由一个数字、字母或者下划线组成的字符串，也就是Python合法的变量；

\[a-zA-Z\\\_\]\[0-9a-zA-Z\\\_\]\{0, 19\}更精确地限制了变量的长度是1-20个字符（前面1个字符+后面最多19个字符）。

A|B竖线|代表选择，可以匹配A或B，如：(P|p)ython可以匹配'Python'或者'python'。

^表示行的开头，^\\d表示必须以数字开头；$表示行的结束，\\d$表示必须以数字结束。

py也可以匹配'python'，但是加上^py$就变成了整行匹配，就只能匹配'py'了。

修饰符

正则表达式的修饰符用于指定额外的匹配策略。

标记不写在正则表达式里，标记位于表达式之外，格式如下：

/pattern/flags

下表列出了正则表达式常用的修饰符：

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#555555;width:66px;"> 修饰符 </td> 
 <td style="border-color:#555555;width:285px;"> 含义 </td> 
 <td style="border-color:#555555;width:448px;"> 描述 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:66px;"> i </td> 
 <td style="width:285px;"> ignore - 不区分大小写 </td> 
 <td style="width:448px;"> 将匹配设置为不区分大小写，搜索时不区分大小写: A 和 a 没有区别。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;vertical-align:top;width:66px;"> g </td> 
 <td style="vertical-align:top;width:285px;"> global - 全局匹配 </td> 
 <td style="vertical-align:top;width:448px;"> 查找所有的匹配项。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;width:66px;"> m </td> 
 <td style="width:285px;"> multi line - 多行匹配 </td> 
 <td style="width:448px;"> 使边界字符&nbsp;^&nbsp;和&nbsp;$&nbsp;匹配每一行的开头和结尾，记住是多行，而不是整个字符串的开头和结尾。 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#d4d4d4;vertical-align:top;width:66px;"> s </td> 
 <td style="vertical-align:top;width:285px;"> 特殊字符圆点&nbsp;.&nbsp;中包含换行符&nbsp;\n </td> 
 <td style="vertical-align:top;width:448px;"> 默认情况下的圆点&nbsp;.&nbsp;是 匹配除换行符&nbsp;\n&nbsp;之外的任何字符，加上&nbsp;s&nbsp;修饰符之后,&nbsp;.&nbsp;中包含换行符 \n。 </td> 
 </tr> 
 </tbody> 
</table>

例子、使用JavaScript语言，在字符串中查找 "runoob":

var str="Google runoob taobao runoob"; 
    var n1=str.match(/runoob/);   // 查找第一次匹配项
    var n2=str.match(/runoob/g);  // 查找所有匹配项
    var n3=str.match(/runoob/gi);  // 查找所有匹配项且不区分大小写

*精确的语法可能因不同的工具或程序而异。*

**正则表达式在JavaScript****中的用法：**

实例1、从字符串 str 中提取数字部分的内容(匹配一次)的例子：

var str = "abc123def";
    var patt1 = /[0-9]+/;
    document.write(str.match(patt1));

实例2、验证固定电话号码的例子：

var str = "0821-56389999";
    var patt1 = /0\d{2,3}-[1-9]\d{6,7}/;
    document.write(str.match(patt1));

**正则表达式在Python****中的用法：**

验证固定电话号码的例子

import re
    text = "021-88776543"
    m = re.match(r'0\d{2,3}-[1-9]\d{6,7}',text)
    print(m)
    if m:
        print("match")
    else:
    print('not match')

Python提供re模块，包含所有正则表达式的功能。

import re \#导入re

re.match \#从开始位置开始匹配，如果开头没有则无

re.search \#搜索整个字符串

re.findall \#搜索整个字符串，返回一个list

注意：

match 和 search 是匹配一次，findall 匹配所有。

**附、正则表达式参考**

**1.****正则表达式规则**

1.1 普通字符

字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号，都是"普通字符"。表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符。

例1：表达式 "c"，在匹配字符串 "abcde" 时，匹配结果是：成功；匹配到的内容是："c"；匹配到的位置是：开始于2，结束于3。（注：下标从0开始还是从1开始，因当前编程语言的不同而可能不同）

例2：表达式 "bcd"，在匹配字符串 "abcde" 时，匹配结果是：成功；匹配到的内容是："bcd"；匹配到的位置是：开始于1，结束于4。

1.2 简单的转义字符

一些不便书写的字符，采用在前面加 "\\" 的方法。这些字符其实我们都已经熟知了。

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td style="width:52.5pt;"> 表达式 </td> 
 <td> 可匹配 </td> 
 </tr> 
 <tr> 
 <td> \r, \n </td> 
 <td> 代表回车和换行符 </td> 
 </tr> 
 <tr> 
 <td> \t </td> 
 <td> 制表符 </td> 
 </tr> 
 <tr> 
 <td> \\ </td> 
 <td> 代表 "\" 本身 </td> 
 </tr> 
 </tbody> 
</table>

还有其他一些在后边章节中有特殊用处的标点符号，在前面加 "\\" 后，就代表该符号本身。如：^, $ 都有特殊意义，如果要想匹配字符串中 "^" 和 "$" 字符，则表达式就需要写成 "\\^" 和 "\\$"。

这些转义字符的匹配方法与 "普通字符" 是类似的。也是匹配与之相同的一个字符。

例1：表达式 "\\$d"，在匹配字符串 "abc$de" 时，匹配结果是：成功；匹配到的内容是："$d"；匹配到的位置是：开始于3，结束于5。

1.3 能够与 '多种字符' 匹配的表达式

正则表达式中的一些表示方法，可以匹配 '多种字符' 其中的任意一个字符。如，表达式 "\\d" 可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个。这就好比玩扑克牌时候，大小王可以代替任意一张牌，但是只能代替一张牌。

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td style="width:49.5pt;"> 表达式 </td> 
 <td> 可匹配 </td> 
 </tr> 
 <tr> 
 <td> \d </td> 
 <td> 任意一个数字，0~9 中的任意一个 </td> 
 </tr> 
 <tr> 
 <td> \w </td> 
 <td> 任意一个字母或数字或下划线，也就是 A~Z,a~z,0~9,_ 中任意一个 </td> 
 </tr> 
 <tr> 
 <td> \s </td> 
 <td> 包括空格、制表符、换页符等空白字符的其中任意一个 </td> 
 </tr> 
 <tr> 
 <td> . </td> 
 <td> 小数点可以匹配除了换行符（\n）以外的任意一个字符 </td> 
 </tr> 
 </tbody> 
</table>

例1：表达式 "\\d\\d"，在匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："12"；匹配到的位置是：开始于3，结束于5。

例2：表达式 "a.\\d"，在匹配 "aaa100" 时，匹配的结果是：成功；匹配到的内容是："aa1"；匹配到的位置是：开始于1，结束于4。

1.4 自定义能够匹配 '多种字符' 的表达式

使用方括号 \[ \] 包含一系列字符，能够匹配其中任意一个字符。用 \[^ \] 包含一系列字符，则能够匹配其中字符之外的任意一个字符。同样的道理，虽然可以匹配其中任意一个，但是只能是一个，不是多个。

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td style="width:60pt;"> 表达式 </td> 
 <td> 可匹配 </td> 
 </tr> 
 <tr> 
 <td> [ab5@] </td> 
 <td> 匹配 "a" 或 "b" 或 "5" 或 "@" </td> 
 </tr> 
 <tr> 
 <td> [^abc] </td> 
 <td> 匹配 "a","b","c" 之外的任意一个字符 </td> 
 </tr> 
 <tr> 
 <td> [f-k] </td> 
 <td> 匹配 "f"~"k" 之间的任意一个字母 </td> 
 </tr> 
 <tr> 
 <td> [^A-F0-3] </td> 
 <td> 匹配 "A"~"F","0"~"3" 之外的任意一个字符 </td> 
 </tr> 
 </tbody> 
</table>

例1：表达式 "\[bcd\]\[bcd\]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："bc"；匹配到的位置是：开始于1，结束于3。

例2：表达式 "\[^abc\]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："1"；匹配到的位置是：开始于3，结束于4。

1.5 修饰匹配次数的特殊符号

前面章节中讲到的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号，那么不用重复书写表达式就可以重复匹配。

使用方法是："次数修饰"放在"被修饰的表达式"后边。如："\[bcd\]\[bcd\]" 可以写成 "\[bcd\]\{2\}"。

<table style="width:600px;"> 
 <tbody> 
 <tr> 
 <td style="width:50.25pt;"> 表达式 </td> 
 <td> 作用 </td> 
 </tr> 
 <tr> 
 <td> {n} </td> 
 <td> 表达式重复n次，如："\w{2}" 相当于 "\w\w"； "a{5}" 相当于 "aaaaa" </td> 
 </tr> 
 <tr> 
 <td> {m,n} </td> 
 <td> 表达式至少重复m次，最多重复n次，如："ba{1,3}"可以匹配 "ba"或"baa"或"baaa" </td> 
 </tr> 
 <tr> 
 <td> {m,} </td> 
 <td> 表达式至少重复m次，如："\w\d{2,}"可以匹配 "a12","_456","M12344"... </td> 
 </tr> 
 <tr> 
 <td> ? </td> 
 <td> 匹配表达式0次或者1次，相当于 {0,1}，如："a[cd]?"可以匹配 "a","ac","ad" </td> 
 </tr> 
 <tr> 
 <td> + </td> 
 <td> 表达式至少出现1次，相当于 {1,}，如： "a+b"可以匹配 "ab","aab","aaab"... </td> 
 </tr> 
 <tr> 
 <td> * </td> 
 <td> 表达式不出现或出现任意次，相当于 {0,}，如："\^*b"可以匹配 "b","^^^b"... </td> 
 </tr> 
 </tbody> 
</table>

例1：表达式 "\\d+\\.?\\d\*" 在匹配 "It costs $12.5" 时，匹配的结果是：成功；匹配到的内容是："12.5"；匹配到的位置是：开始于10，结束于14。

例2：表达式 "go\{2,8\}gle" 在匹配 "Ads by goooooogle" 时，匹配的结果是：成功；匹配到的内容是："goooooogle"；匹配到的位置是：开始于7，结束于17。

1.6 其他一些代表抽象意义的特殊符号

一些符号在表达式中代表抽象的特殊意义：

<table style="width:560px;"> 
 <tbody> 
 <tr> 
 <td style="width:50.25pt;"> 表达式 </td> 
 <td> 作用 </td> 
 </tr> 
 <tr> 
 <td> ^ </td> 
 <td> 与字符串开始的地方匹配，不匹配任何字符 </td> 
 </tr> 
 <tr> 
 <td> $ </td> 
 <td> 与字符串结束的地方匹配，不匹配任何字符 </td> 
 </tr> 
 <tr> 
 <td> \b </td> 
 <td> 匹配一个单词边界，也就是单词和空格之间的位置，不匹配任何字符 </td> 
 </tr> 
 </tbody> 
</table>

例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。

一些符号可以影响表达式内部的子表达式之间的关系：

<table style="width:600px;"> 
 <tbody> 
 <tr> 
 <td style="width:48.75pt;"> 表达式 </td> 
 <td> 作用 </td> 
 </tr> 
 <tr> 
 <td> | </td> 
 <td> 左右两边表达式之间 "或" 关系，匹配左边或者右边 </td> 
 </tr> 
 <tr> 
 <td> ( ) </td> 
 <td> (1). 在被修饰匹配次数的时候，括号中的表达式可以作为整体被修饰 (2). 取匹配结果的时候，括号中的表达式匹配到的内容可以被单独得到 </td> 
 </tr> 
 </tbody> 
</table>

例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"，举例如下：

<table style="width:600px;"> 
 <tbody> 
 <tr> 
 <td style="width:69.75pt;"> 表达式 </td> 
 <td> 匹配结果 </td> 
 </tr> 
 <tr> 
 <td> (d)(\w+) </td> 
 <td> "\w+" 将匹配第一个 "d" 之后的所有字符 "xxxdxxxd" </td> 
 </tr> 
 <tr> 
 <td> (d)(\w+)(d) </td> 
 <td> "\w+" 将匹配第一个 "d" 和最后一个 "d" 之间的所有字符 "xxxdxxx"。虽然 "\w+" 也能够匹配上最后一个 "d"，但是为了使整个表达式匹配成功，"\w+" 可以 "让出" 它本来能够匹配的最后一个 "d" </td> 
 </tr> 
 </tbody> 
</table>

由此可见，"\\w+" 在匹配的时候，总是尽可能多的匹配符合它规则的字符。虽然第二个举例中，它没有匹配最后一个 "d"，但那也是为了让整个表达式能够匹配成功。同理，带 "\*" 和 "\{m,n\}" 的表达式都是尽可能地多匹配，带 "?" 的表达式在可匹配可不匹配的时候，也是尽可能的 "要匹配"。这 种匹配原则就叫作 "贪婪" 模式 。

非贪婪模式：

在修饰匹配次数的特殊符号后再加上一个 "?" 号，则可以使匹配次数不定的表达式尽可能少的匹配，使可匹配可不匹配的表达式，尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪" 模式，也叫作 "勉强" 模式。如果少匹配就会导致整个表达式匹配失败的时候，与贪婪模式类似，非贪婪模式会最小限度的再匹配一些，以使整个表达式匹配成功。举例如下，针对文本 "dxxxdxxxd" 举例：

<table style="width:600px;"> 
 <tbody> 
 <tr> 
 <td style="width:69.75pt;"> 表达式 </td> 
 <td> 匹配结果 </td> 
 </tr> 
 <tr> 
 <td> (d)(\w+?) </td> 
 <td> "\w+?" 将尽可能少的匹配第一个 "d" 之后的字符，结果是："\w+?" 只匹配了一个 "x" </td> 
 </tr> 
 <tr> 
 <td> (d)(\w+?)(d) </td> 
 <td> 为了让整个表达式匹配成功，"\w+?" 不得不匹配 "xxx" 才可以让后边的 "d" 匹配，从而使整个表达式匹配成功。因此，结果是："\w+?" 匹配 "xxx" </td> 
 </tr> 
 </tbody> 
</table>

例1：表达式 "<td>(.\*)</td>" 与字符串 "<td>aa</td> <td>bb</td>" 匹配时，匹配的结果是：成功；匹配到的内容是 "<td>aa</td> <td>bb</td>" 整个字符串， 表达式中的 "</td>" 将与字符串中最后一个 "</td>" 匹配。

例2：相比之下，表达式 "<td>(.\*?)</td>" 匹配举例1中同样的字符串时，将只得到 "<td>aa</td>"， 再次匹配下一个时，可以得到第二个 "<td>bb</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" 表示一个十六进制数）

<table style="width:600px;"> 
 <tbody> 
 <tr> 
 <td style="width:47.25pt;"> 形式 </td> 
 <td> 字符范围 </td> 
 </tr> 
 <tr> 
 <td> \xXX </td> 
 <td> 编号在 0 ~ 255 范围的字符，如：空格可以使用 "\x20" 表示 </td> 
 </tr> 
 <tr> 
 <td> \uXXXX </td> 
 <td> 任何字符可以使用 "\u" 再加上其编号的4位十六进制数表示，如："\u4E2D" </td> 
 </tr> 
 </tbody> 
</table>

3.2 在表达式 "\\s"，"\\d"，"\\w"，"\\b" 表示特殊意义的同时，对应的大写字母表示相反的意义

<table style="width:600px;"> 
 <tbody> 
 <tr> 
 <td style="width:82px;"> 表达式 </td> 
 <td style="width:516px;"> 可匹配 </td> 
 </tr> 
 <tr> 
 <td style="width:82px;"> \S </td> 
 <td style="width:516px;"> 匹配所有非空白字符（"\s" 可匹配各个空白字符） </td> 
 </tr> 
 <tr> 
 <td style="width:82px;"> \D </td> 
 <td style="width:516px;"> 匹配所有的非数字字符 </td> 
 </tr> 
 <tr> 
 <td style="width:82px;"> \W </td> 
 <td style="width:516px;"> 匹配所有的字母、数字、下划线以外的字符 </td> 
 </tr> 
 <tr> 
 <td style="width:82px;"> \B </td> 
 <td style="width:516px;"> 匹配非单词边界，即左右两边都是 "\w" 范围或者左右两边都不是 "\w" 范围时的字符缝隙 </td> 
 </tr> 
 </tbody> 
</table>

3.3 在表达式中有特殊意义，需要添加 "\\" 才能匹配该字符本身的字符汇总

<table style="width:600px;"> 
 <tbody> 
 <tr> 
 <td style="width:41.25pt;"> 字符 </td> 
 <td> 说明 </td> 
 </tr> 
 <tr> 
 <td> ^ </td> 
 <td> 匹配输入字符串的开始位置。要匹配 "^" 字符本身，请使用 "\^" </td> 
 </tr> 
 <tr> 
 <td> $ </td> 
 <td> 匹配输入字符串的结尾位置。要匹配 "$" 字符本身，请使用 "\$" </td> 
 </tr> 
 <tr> 
 <td> ( ) </td> 
 <td> 标记一个子表达式的开始和结束位置。要匹配小括号，请使用 "$" 和 "$" </td> 
 </tr> 
 <tr> 
 <td> [ ] </td> 
 <td> 用来自定义能够匹配 '多种字符' 的表达式。要匹配中括号，请使用 "\[" 和 "\]" </td> 
 </tr> 
 <tr> 
 <td> { } </td> 
 <td> 修饰匹配次数的符号。要匹配大括号，请使用 "\{" 和 "\}" </td> 
 </tr> 
 <tr> 
 <td> . </td> 
 <td> 匹配除了换行符（\n）以外的任意一个字符。要匹配小数点本身，请使用 "\." </td> 
 </tr> 
 <tr> 
 <td> ? </td> 
 <td> 修饰匹配次数为 0 次或 1 次。要匹配 "?" 字符本身，请使用 "\?" </td> 
 </tr> 
 <tr> 
 <td> + </td> 
 <td> 修饰匹配次数为至少 1 次。要匹配 "+" 字符本身，请使用 "\+" </td> 
 </tr> 
 <tr> 
 <td> * </td> 
 <td> 修饰匹配次数为 0 次或任意次。要匹配 "*" 字符本身，请使用 "\*" </td> 
 </tr> 
 <tr> 
 <td> | </td> 
 <td> 左右两边表达式之间 "或" 关系。匹配 "|" 本身，请使用 "\|" </td> 
 </tr> 
 </tbody> 
</table>

3.4 括号 "( )" 内的子表达式，如果希望匹配结果不进行记录供以后使用，可以使用 "(?:xxxxx)" 格式

例1：表达式 "(?:(\\w)\\1)+" 匹配 "a bbccdd efg" 时，结果是 "bbccdd"。括号 "(?:)" 范围的匹配结果不进行记录，因此 "(\\w)" 使用 "\\1" 来引用。

3.5 常用的表达式属性设置简介：Ignorecase，Singleline，Multiline，Global

<table> 
 <tbody> 
 <tr> 
 <td style="width:102px;"> 表达式属性 </td> 
 <td style="width:696px;"> 说明 </td> 
 </tr> 
 <tr> 
 <td style="width:102px;"> Ignorecase </td> 
 <td style="width:696px;"> 默认情况下，表达式中的字母是要区分大小写的。配置为 Ignorecase 可使匹配时不区分大小写。有的表达式引擎，把 "大小写" 概念延伸至 UNICODE 范围的大小写。 </td> 
 </tr> 
 <tr> 
 <td style="width:102px;"> Singleline </td> 
 <td style="width:696px;"> 默认情况下，小数点 "." 匹配除了换行符（\n）以外的字符。配置为 Singleline 可使小数点可匹配包括换行符在内的所有字符。 </td> 
 </tr> 
 <tr> 
 <td style="width:102px;"> Multiline </td> 
 <td style="width:696px;"> 默认情况下，表达式 "^" 和 "$" 只匹配字符串的开始 ① 和结尾 ④ 位置。如： ①xxxxxxxxx②\n ③xxxxxxxxx④ 配置为 Multiline 可以使 "^" 匹配 ① 外，还可以匹配换行符之后，下一行开始前 ③ 的位置，使 "$" 匹配 ④ 外，还可以匹配换行符之前，一行结束 ② 的位置。 </td> 
 </tr> 
 <tr> 
 <td style="width:102px;"> Global </td> 
 <td style="width:696px;"> 主要在将表达式用来替换时起作用，配置为 Global 表示替换所有的匹配。 </td> 
 </tr> 
 </tbody> 
</table>

**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 运算符优先权

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#a2a9b1;"> &nbsp;优先权 </td> 
 <td style="border-color:#a2a9b1;"> 符号 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a2a9b1;"> 最高 </td> 
 <td> \ </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a2a9b1;"> 高 </td> 
 <td> ()、(?:)、(?=)、[] </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a2a9b1;"> 中 </td> 
 <td> *、+、?、{ n}、{ n,}、{ n,m} </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a2a9b1;"> 低 </td> 
 <td> ^、$、中介字符 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a2a9b1;"> 次最低 </td> 
 <td> 串接，即相邻字符连接在一起 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#a2a9b1;"> 最低 </td> 
 <td> | </td> 
 </tr> 
 </tbody> 
</table>

[https_c.runoob.com_front-end_854]: https://c.runoob.com/front-end/854