C# 正则表达式

最新推荐文章于 2020-02-19 13:48:26 发布

@朱较瘦

最新推荐文章于 2020-02-19 13:48:26 发布

阅读量626

点赞数

分类专栏： C#

C# 专栏收录该内容

67 篇文章 2 订阅

订阅专栏

http://www.cnblogs.com/stg609/archive/2009/06/03/1492709.html#anchorA

C#定义正则表达式：

下面列出了用于定义正则表达式的各种类别的字符、运算符和结构：

字符转义
字符类
定位点
分组构造
限定符
反向引用构造
备用构造
替换

杂项构造

C#正则表达式的匹配规则大部分与javascript通用：http://blog.csdn.net/zhulongxi/article/details/51424974

一、字符转义

正则表达式中的反斜杠字符（\）指示其后跟的字符是特殊字符，或应按原义解释该字符。

转义字符	描述	模式	匹配
\a	与报警 (bell) 符 \u0007 匹配。	\a	"Warning!" + '\u0007' 中的 "\u0007"
\b	在字符类中，与退格键 \u0008 匹配。	[\b]{3,}	"\b\b\b\b" 中的 "\b\b\b\b"
\t	与制表符 \u0009 匹配。	(\w+)\t	"Name\tAddr\t" 中的 "Name\t" 和 "Addr\t"
\r	与回车符 \u000D 匹配。（\r 与换行符 \n 不是等效的。）	\r\n(\w+)	"\r\Hello\nWorld." 中的 "\r\nHello"
\v	与垂直制表符 \u000B 匹配。	[\v]{2,}	"\v\v\v" 中的 "\v\v\v"
\f	与换页符 \u000C 匹配。	[\f]{2,}	"\f\f\f" 中的 "\f\f\f"
\n	与换行符 \u000A 匹配。	\r\n(\w+)	"\r\Hello\nWorld." 中的 "\r\nHello"
\e	与转义符 \u001B 匹配。	\e	"\x001B" 中的 "\x001B"
\ nnn	使用八进制表示形式指定一个字符（nnn 由二到三位数字组成）。	\w\040\w	"a bc d" 中的 "a b" 和 "c d"
\x nn	使用十六进制表示形式指定字符（nn 恰好由两位数字组成）。	\w\x20\w	"a bc d" 中的 "a b" 和 "c d"
\c X \c x	匹配 X 或 x 指定的 ASCII 控件字符，其中 X 或 x 是控件字符的字母。	\cC	"\x0003" 中的 "\x0003" (Ctrl-C)
\u nnnn	使用十六进制表示形式匹配一个 Unicode 字符（由 nnnn 表示的四位数）。	\w\u0020\w	"a bc d" 中的 "a b" 和 "c d"
\	在后面带有不识别的转义字符时，与该字符匹配。	\d+[\+-x\]\d+\d+[\+-x\\d+	"(2+2) * 39" 中的 "2+2" 和 "39"

二、字符类

字符类与一组字符中的任何一个字符匹配

字符类	描述	模式	匹配
[character_group]	匹配 character_group 中的任何单个字符。默认情况下，匹配区分大小写。	[mn]	"mat" 中的 "m"，"moon" 中的 "m" 和 "n"
[^character_group]	非：与不在 character_group 中的任何单个字符匹配。默认情况下，character_group 中的字符区分大小写。	[^aei]	"avail" 中的 "v" 和 "l"
[ first - last ]	字符范围：与从 first 到 last 的范围中的任何单个字符匹配。	(\w+)\t	"Name\tAddr\t" 中的 "Name\t" 和 "Addr\t"
.	通配符：与除 \n 之外的任何单个字符匹配。若要匹配原意句点字符（. 或 \u002E），您必须在该字符前面加上转义符 (\.)。	a.e	"have" 中的 "ave"， "mate" 中的 "ate"
\p{ name }	与 name 指定的 Unicode 通用类别或命名块中的任何单个字符匹配。	\p{Lu}	"City Lights" 中的 "C" 和 "L"
\P{ name }	与不在 name 指定的 Unicode 通用类别或命名块中的任何单个字符匹配。	\P{Lu}	"City" 中的 "i"、 "t" 和 "y"
\w	与任何单词字符匹配。	\w	"Room#1" 中的 "R"、 "o"、 "m" 和 "1"
\W	与任何非单词字符匹配。	\W	"Room#1" 中的 "#"
\s	与任何空白字符匹配。	\w\s	"ID A1.3" 中的 "D "
\S	与任何非空白字符匹配。	\s\S	"int __ctr" 中的 " _"
\d	与任何十进制数字匹配。	\d	"4 = IV" 中的 "4"
\D	匹配不是十进制数的任意字符。	\D	"4 = IV" 中的 " "、 "="、 " "、 "I" 和 "V"

三、定点位

定位点或原子零宽度断言会使匹配成功或失败，具体取决于字符串中的当前位置，但它们不会使引擎在字符串中前进或使用字符。

断言	描述	模式	匹配
^	匹配必须从字符串或一行的开头开始。	^\d{3}	"567-777-" 中的 "567"
$	匹配必须出现在字符串的末尾或出现在行或字符串末尾的 \n 之前。	-\d{4}$	"8-12-2012" 中的 "-2012"
\A	匹配必须出现在字符串的开头。	\A\w{3}	"Code-007-" 中的 "Code"
\Z	匹配必须出现在字符串的末尾或出现在字符串末尾的 \n 之前。	-\d{3}\Z	"Bond-901-007" 中的 "-007"
\z	匹配必须出现在字符串的末尾。	-\d{3}\z	"-901-333" 中的 "-333"
\G	匹配必须出现在上一个匹配结束的地方。	\\G$\d$	"(1)(3)(5)[7](9)" 中的 "(1)"、 "(3)" 和 "(5)"
\b	匹配必须出现在 \w（字母数字）和 \W（非字母数字）字符之间的边界上。	\w	"Room#1" 中的 "R"、 "o"、 "m" 和 "1"
\B	匹配不得出现在 \b 边界上。	\Bend\w*\b	"end sends endure lender" 中的 "ends" 和 "ender"

四、分组构造

分组构造描述了正则表达式的子表达式，通常用于捕获输入字符串的子字符串。

分组构造	描述	模式	匹配
( subexpression )	捕获匹配的子表达式并将其分配到一个从零开始的序号中。	(\w)\1	"deep" 中的 "ee"
(?< name >subexpression)	将匹配的子表达式捕获到一个命名组中。	(?< double>\w)\k< double>	"deep" 中的 "ee"
(?< name1 -name2 >subexpression)	定义平衡组定义。	(((?'Open'$)[^\($])+((?'Close-Open'\))[^])+)*(?(Open)(?!))$	"3+2^((1-3)(3-1))" 中的 "((1-3)(3-1))"
(?: subexpression)	定义非捕获组。	Write(?:Line)?	"Console.WriteLine()" 中的 "WriteLine"
(?imnsx-imnsx:subexpression)	应用或禁用 subexpression 中指定的选项。	A\d{2}(?i:\w+)\b	"A12xl A12XL a12xl" 中的 "A12xl" 和 "A12XL"
(?= subexpression)	零宽度正预测先行断言。	\w+(?=\.)	"He is. The dog ran. The sun is out." 中的 "is"、 "ran" 和 "out"
(?! subexpression)	零宽度负预测先行断言。	\b(?!un)\w+\b	"unsure sure unity used" 中的 "sure" 和 "used"
(?< =subexpression)	零宽度正回顾后发断言。	(?< =19)\d{2}\b	"1851 1999 1950 1905 2003" 中的 "51" 和 "03"
(?< ! subexpression)	零宽度负回顾后发断言。	(?< !19)\d{2}\b	"end sends endure lender" 中的 "ends" 和 "ender"
(?> subexpression)	非回溯（也称为"贪婪"）子表达式。	[13579](?>A+B+)	"1ABB 3ABBC 5AB 5AC" 中的 "1ABB"、 "3ABB" 和 "5AB"

五、限定符

限定符指定在输入字符串中必须存在上一个元素（可以是字符、组或字符类）的多少个实例才能出现匹配项

限定符	描述	模式	匹配
*	匹配上一个元素零次或多次。	\d*\.\d	".0"、 "19.9"、 "219.9"
+	匹配上一个元素一次或多次。	"be+"	"been" 中的 "bee"， "bent" 中的 "be"
?	匹配上一个元素零次或一次。	"rai?n"	"ran"、 "rain"
{ n }	匹配上一个元素恰好 n 次。	",\d{3}"	"1,043.6" 中的 ",043"， "9,876,543,210" 中的 ",876"、 ",543" 和 ",210"
{ n ,}	匹配上一个元素至少 n 次。	"\d{2,}"	"166"、 "29"、 "1930"
{ n , m }	匹配上一个元素至少 n 次，但不多于 m 次。	"\d{3,5}"	"166"， "17668"， "193024" 中的 "19302"
*?	匹配上一个元素零次或多次，但次数尽可能少。	\d*?\.\d	".0"、 "19.9"、 "219.9"
+?	匹配上一个元素一次或多次，但次数尽可能少。	"be+?"	"been" 中的 "be"， "bent" 中的 "be"
??	匹配上一个元素零次或一次，但次数尽可能少。	"rai??n"	"ran"、 "rain"
{ n }?	匹配前导元素恰好 n 次。	",\d{3}?"	"1,043.6" 中的 ",043"， "9,876,543,210" 中的 ",876"、 ",543" 和 ",210"
{ n ,}?	匹配上一个元素至少 n 次，但次数尽可能少。	"\d{2,}?"	"166"、 "29" 和 "1930"
{ n , m }?	匹配上一个元素的次数介于 n 和 m 之间，但次数尽可能少。	"\d{3,5}?"	"166"， "17668"， "193024" 中的 "193" 和 "024"

六、反向引用构造

反向引用允许在同一正则表达式中随后标识以前匹配的子表达式。

反向引用构造	描述	模式	匹配
\ number	反向引用。匹配编号子表达式的值。	(\w)\1	"seek" 中的 "ee"
\k< name >	命名反向引用。匹配命名表达式的值。	(?< char>\w)\k< char>	"seek" 中的 "ee"

七、备用构造

备用构造用于修改正则表达式以启用 either/or 匹配。

备用构造	描述	模式	匹配
\|	匹配以竖线 (\|) 字符分隔的任何一个元素。	th(e\|is\|at)	"this is the day. " 中的 "the" 和 "this"
(?( expression )yes \| no )	如果正则表达式模式由 expression 匹配指定，则匹配 yes；否则匹配可选的 no 部分。 expression 被解释为零宽度断言。	(?(A)A\d{2}\b\|\b\d{3}\b)	"A10 C103 910" 中的 "A10" 和 "910"
(?( name )yes \| no )	如果 name 或已命名或已编号的捕获组具有匹配，则匹配 yes；否则匹配可选的 no。	(?< quoted>")?(?(quoted).+?"\|\S+\s)	"Dogs.jpg "Yiska playing.jpg"" 中的 Dogs.jpg 和 "Yiska playing.jpg"

八、替换

替换是替换模式中使用的正则表达式。

字符	描述	模式	替换模式	输入字符串	结果字符串
$number	替换按组 number 匹配的子字符串。	\b(\w+)(\s)(\w+)\b	$3$2$1	"one two"	"two one"
${name}	替换按命名组 name 匹配的子字符串。	\b(?< word1>\w+)(\s)(?< word2>\w+)\b	${word2} ${word1}	"one two"	"two one"
$$	替换字符"$"。	\b(\d+)\s?USD	$$$1	"103 USD"	"$103"
$&	替换整个匹配项的一个副本。	(\$(\d(\.+\d+)?){1})	**$&	"$1.30"	"$1.30"
$`	替换匹配前的输入字符串的所有文本。	B+	$`	"AABBCC"	"AAAACC"
$'	替换匹配后的输入字符串的所有文本。	B+	$'	"AABBCC"	"AACCCC"
$+	替换最后捕获的组。	B+(C+)	$+	"AABBCCDD"	AACCDD
$_	替换整个输入字符串。	B+	$_	"AABBCC"	"AAAABBCCCC"

九、杂项构造

构造	描述	实例
(?imnsx-imnsx)	在模式中间对诸如不区分大小写这样的选项进行设置或禁用。	\bA(?i)b\w+\b 匹配 "ABA Able Act" 中的 "ABA" 和 "Able"
(?#comment)	内联注释。该注释在第一个右括号处终止。	\bA(?#Matches words starting with A)\w+\b
# [to end of line]	X 模式注释。该注释以非转义的 # 开头，并继续到行的结尾。	(?x)\bA\w+\b#Matches words starting with A

十、Regex类：Regex 类用于表示一个正则表达式。

Regex 类中一些常用的方法：

序号	方法 & 描述
1	public bool IsMatch( string input ) 指示 Regex 构造函数中指定的正则表达式是否在指定的输入字符串中找到匹配项。
2	public bool IsMatch( string input, int startat ) 指示 Regex 构造函数中指定的正则表达式是否在指定的输入字符串中找到匹配项，从字符串中指定的开始位置开始。
3	public static bool IsMatch( string input, string pattern ) 指示指定的正则表达式是否在指定的输入字符串中找到匹配项。
4	public MatchCollection Matches( string input ) 在指定的输入字符串中搜索正则表达式的所有匹配项。
5	public string Replace( string input, string replacement ) 在指定的输入字符串中，把所有匹配正则表达式模式的所有匹配的字符串替换为指定的替换字符串。
6	public string[] Split( string input ) 把输入字符串分割为子字符串数组，根据在 Regex 构造函数中指定的正则表达式模式定义的位置进行分割。

   十一、 
  c#正则表达式用法大全   
   只能输入数字： 
   "^[0-9]*$" 
   。 
  
 
   只能输入n位的数字： 
   "^\d{n}$" 
   。 
  
 
   只能输入至少n位的数字： 
   "^\d{n,}$" 
   。 
  
 
   只能输入m~n位的数字：。 
   "^\d{m,n}$" 
  
 
   只能输入零和非零开头的数字： 
   "^(0|[1-9][0-9]*)$" 
   。 
  
 
   只能输入有两位小数的正实数： 
   "^[0-9]+(.[0-9]{2})?$" 
   。 
  
 
   只能输入有1~3位小数的正实数： 
   "^[0-9]+(.[0-9]{1,3})?$" 
   。 
  
 
   只能输入非零的正整数： 
   "^\+?[1-9][0-9]*$" 
   。 
  
 
   只能输入非零的负整数： 
   "^\-[1-9][]0-9" 
   *$。 
  
 
   只能输入长度为3的字符： 
   "^.{3}$" 
   。 
  
 
   只能输入由26个英文字母组成的字符串： 
   "^[A-Za-z]+$" 
   。 
  
 
   只能输入由26个大写英文字母组成的字符串： 
   "^[A-Z]+$" 
   。 
  
 
   只能输入由26个小写英文字母组成的字符串： 
   "^[a-z]+$" 
   。 
  
 
   只能输入由数字和26个英文字母组成的字符串： 
   "^[A-Za-z0-9]+$" 
   。 
  
 
   只能输入由数字、26个英文字母或者下划线组成的字符串： 
   "^\w+$" 
   。 
  
 
   验证用户密码： 
   "^[a-zA-Z]\w{5,17}$" 
   正确格式为：以字母开头，长度在6~18之间，只能包含字符、数字和下划线。 
  
 
   验证是否含有^%& 
   ',;=?$\"等字符："[^%&' 
   ,;=?$\x22]+"。 
  
 
   只能输入汉字： 
   "^[\u4e00-\u9fa5]{0,}$" 
  
 
   验证Email地址： 
   "^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$" 
   。 
  
 
   验证InternetURL： 
   "^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$" 
   。 
  
 
   验证电话号码： 
   "^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$" 
   正确格式为： 
   "XXX-XXXXXXX" 
   、 
   "XXXX-XXXXXXXX" 
   、 
   "XXX-XXXXXXX" 
   、 
   "XXX-XXXXXXXX" 
   、 
   "XXXXXXX" 
   和 
   "XXXXXXXX" 
   。 
  
 
   验证身份证号（15位或18位数字）： 
   "^\d{15}|\d{18}$" 
   。 
  
 
   验证一年的12个月： 
   "^(0?[1-9]|1[0-2])$" 
   正确格式为： 
   "01" 
   ～ 
   "09" 
   和 
   "1" 
   ～ 
   "12" 
   。 
  
 
   验证一个月的31天： 
   "^((0?[1-9])|((1|2)[0-9])|30|31)$" 
   正确格式为； 
   "01" 
   ～ 
   "09" 
   和 
   "1" 
   ～ 
   "31" 
   。  
  
 
   利用正则表达式限制网页表单里的文本框输入内容： 
  
 
   用正则表达式限制只能输入中文：  
  
 
   用正则表达式限制只能输入全角字符：  
  
 
   用正则表达式限制只能输入数字： 
  
 
   用正则表达式限制只能输入数字和英文： 
  
 
   得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1 
  
 
   s= 
   "http://hi.baidu.com/accpandsvse" 
  
 
   s=s.replace(/(.*\/){0,}([^\.]+).*/ig, 
   "$2" 
   ) 
  
 
   alert(s)  
  
 
   匹配双字节字符(包括汉字在内)：[^\x00-\xff] 
  
 
   应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1） 
  
 
   String.prototype.len=function(){ 
   return 
   this 
   .replace([^\x00-\xff]/g, 
   "aa" 
   ).length;} 
  
 
   匹配空行的正则表达式：\n[\s| ]*\r 
  
 
   匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/ 
  
 
   匹配首尾空格的正则表达式：(^\s*)|(\s*$) 
  
 
   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)) 
  
 
   符号解释：  
  
 
   字符 描述   
  
 
   \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如， 
   '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 <= m。最少匹配 n 次且最多匹配 m 次。例如， 
   "o{1,3}" 
   将匹配  
   "fooooood" 
   中的前三个 o。 
   'o{0,1}' 
   等价于  
   'o?' 
   。请注意在逗号和两个数之间不能有空格。  
  
 
   ? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 
   "oooo" 
   ， 
   'o+?' 
   将匹配单个  
   "o" 
   ，而 
   'o+' 
   将匹配所有  
   'o' 
   。   
  
 
   . 匹配除  
   "\n" 
   之外的任何单个字符。要匹配包括  
   '\n' 
   在内的任何字符，请使用象  
   '[.\n]' 
   的模式。   
  
 
   (pattern) 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在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 匹配版权符号 (?)。 
  
 ﻿﻿ 
 