符号
(摘自《正则表达式之道》)
- 正则表达式由一些普通字符和一些元字符(metacharacters)组成。普通字符包括大小写的字母和数字,而元字符则具有特殊的含义,我们下面会给予解释。
- 在最简单的情况下,一个正则表达式看上去就是一个普通的查找串。例如,正则表达式"testing"中没有包含任何元字符,它可以匹配"testing"和"testing123"等字符串,但是不能匹配"Testing"。
- 要想真正的用好正则表达式,正确的理解元字符是最重要的事情。下表列出了所有的元字符和对它们的一个简短的描述。
元字符 |
描述 |
\ |
将下一个字符标记符、或一个向后引用、或一个八进制转义符。例如,“\\n”匹配\n。“\n”匹配换行符。序列“\\”匹配“\”而“\(”则匹配“(”。即相当于多种编程语言中都有的“转义字符”的概念。 |
^ |
匹配输入字行首。如果设置了RegExp对象的Multiline属性,^也匹配“\n”或“\r”之后的位置。 |
$ |
匹配输入行尾。如果设置了RegExp对象的Multiline属性,$也匹配“\n”或“\r”之前的位置。 |
* |
匹配前面的子表达式任意次。例如,zo*能匹配“z”,也能匹配“zo”以及“zoo”。*等价于{0,}。 |
+ |
匹配前面的子表达式一次或多次(大于等于1次)。例如,“zo+”能匹配“zo”以及“zoo”,但不能匹配“z”。+等价于{1,}。 |
? |
匹配前面的子表达式零次或一次。例如,“do(es)?”可以匹配“do”或“does”。?等价于{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为一组。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。 |
? |
当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时,匹配模式是非贪婪的。非贪婪模式尽可能少地匹配所搜索的字符串,而默认的贪婪模式则尽可能多地匹配所搜索的字符串。例如,对于字符串“oooo”,“o+”将尽可能多地匹配“o”,得到结果[“oooo”],而“o+?”将尽可能少地匹配“o”,得到结果 ['o', 'o', 'o', 'o'] |
.点 |
匹配除“\n”和"\r"之外的任何单个字符。要匹配包括“\n”和"\r"在内的任何字符,请使用像“[\s\S]”的模式。 |
(pattern) |
匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到,在VBScript中使用SubMatches集合,在JScript中则使用$0…$9属性。要匹配圆括号字符,请使用“\(”或“\)”。 |
(?:pattern) |
非获取匹配,匹配pattern但不获取匹配结果,不进行存储供以后使用。这在使用或字符“(|)”来组合一个模式的各个部分时很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。 |
(?=pattern) |
非获取匹配,正向肯定预查,在任何匹配pattern的字符串开始处匹配查找字符串,该匹配不需要获取供以后使用。例如,“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”,但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。 |
(?!pattern) |
非获取匹配,正向否定预查,在任何不匹配pattern的字符串开始处匹配查找字符串,该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”,但不能匹配“Windows2000”中的“Windows”。 |
(?<=pattern) |
非获取匹配,反向肯定预查,与正向肯定预查类似,只是方向相反。例如,“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”,但不能匹配“3.1Windows”中的“Windows”。 *python的正则表达式没有完全按照正则表达式规范实现,所以一些高级特性建议使用其他语言如java、scala等 |
(?<!patte_n) |
非获取匹配,反向否定预查,与正向否定预查类似,只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”,但不能匹配“2000Windows”中的“Windows”。 *python的正则表达式没有完全按照正则表达式规范实现,所以一些高级特性建议使用其他语言如java、scala等 |
x|y |
匹配x或y。例如,“z|food”能匹配“z”或“food”(此处请谨慎)。“[z|f]ood”则匹配“zood”或“food”。 |
[xyz] |
字符集合。匹配所包含的任意一个字符。例如,“[abc]”可以匹配“plain”中的“a”。 |
[^xyz] |
负值字符集合。匹配未包含的任意字符。例如,“[^abc]”可以匹配“plain”中的“plin”任一字符。 |
[a-z] |
字符范围。匹配指定范围内的任意字符。例如,“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。 注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围; 如果出字符组的开头,则只能表示连字符本身. |
[^a-z] |
负值字符范围。匹配任何不在指定范围内的任意字符。例如,“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。 |
\b |
匹配一个单词的边界,也就是指单词和空格间的位置(即正则表达式的“匹配”有两种概念,一种是匹配字符,一种是匹配位置,这里的\b就是匹配位置的)。例如,“er\b”可以匹配“never”中的“er”,但不能匹配“verb”中的“er”;“\b1_”可以匹配“1_23”中的“1_”,但不能匹配“21_3”中的“1_”。 |
\B |
匹配非单词边界。“er\B”能匹配“verb”中的“er”,但不能匹配“never”中的“er”。 |
\cx |
匹配由x指明的控制字符。例如,\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则,将c视为一个原义的“c”字符。 |
\d |
匹配一个数字字符。等价于[0-9]。grep 要加上-P,perl正则支持 |
\D |
匹配一个非数字字符。等价于[^0-9]。grep要加上-P,perl正则支持 |
\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_]”,这里的"单词"字符使用Unicode字符集。 |
\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-7),且m和l均为八进制数字(0-7),则匹配八进制转义值nml。 |
\un |
匹配n,其中n是一个用四个十六进制数字表示的Unicode字符。例如,\u00A9匹配版权符号(©)。 |
\p{P} |
小写 p 是 property 的意思,表示 Unicode 属性,用于 Unicode 正表达式的前缀。中括号内的“P”表示Unicode 字符集七个字符属性之一:标点字符。 其他六个属性: L:字母; M:标记符号(一般不会单独出现); Z:分隔符(比如空格、换行等); S:符号(比如数学符号、货币符号等); N:数字(比如阿拉伯数字、罗马数字等); C:其他字符。 *注:此语法部分语言不支持,例:javascript。 |
\< \> |
匹配词(word)的开始(\<)和结束(\>)。例如正则表达式\<the\>能够匹配字符串"for the wise"中的"the",但是不能匹配字符串"otherwise"中的"the"。注意:这个元字符不是所有的软件都支持的。 |
( ) | 将( 和 ) 之间的表达式定义为“组”(group),并且将匹配这个表达式的字符保存到一个临时区域(一个正则表达式中最多可以保存9个),它们可以用 \1 到\9 的符号来引用。 |
| | 将两个匹配条件进行逻辑“或”(or)运算。例如正则表达式(him|her) 匹配"it belongs to him"和"it belongs to her",但是不能匹配"it belongs to them."。注意:这个元字符不是所有的软件都支持的。 |
- 最简单的元字符是点,它能够匹配任何单个字符(注意不包括换行符)。假定有个文件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,它只匹配在行首出现的he。
- 有时候指定“除了×××都匹配”会比较容易达到目的,当抑扬字符(^)出方括号中时,它表示“排除”,例如要匹配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\} 或 10{1, 2},这个正则表达式匹配数字1后面跟着1或者2个0的模式。在这个元字符的使用中一个有用的变化是忽略第二个数字,例如正则表达式0\{3,\} 或 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()的对应实例,然后利用标记好的部分进行替换,是把第一和第二个参数交换位置。
正则表达式语法支持情况
命令或环境 |
. |
[ ] |
^ |
$ |
\( \) |
\{ \} |
? |
+ |
| |
( ) |
vi |
√ |
√ |
√ |
√ |
√ |
|||||
Visual C++ |
√ |
√ |
√ |
√ |
√ |
|||||
awk |
√ |
√ |
√ |
√ |
awk是支持该语法的,只是要在命令 行加入 --posix or --re-interval参数即可,可见 man awk中的interval expression |
√ |
√ |
√ |
√ |
|
sed |
√ |
√ |
√ |
√ |
√ |
√ |
||||
delphi |
√ |
√ |
√ |
√ |
√ |
√ |
√ |
√ |
√ |
|
python |
√ |
√ |
√ |
√ |
√ |
√ |
√ | √ | √ | √ |
java |
√ |
√ |
√ |
√ |
√ |
√ |
√ | √ | √ | √ |
javascript |
√ |
√ |
√ |
√ |
√ |
√ |
√ |
√ |
√ |
|
php |
√ |
√ |
√ |
√ |
√ |
|||||
perl |
√ |
√ |
√ |
√ |
√ |
√ |
√ |
√ |
√ |
|
C# |
√ |
√ |
√ |
√ |
√ | √ | √ |
√ |
√ |
√ |
速记理解技巧
. |
[ ] |
^ |
$ |
- 四个字符是所有语言都支持的正则表达式,所以这四个是基础的正则表达式。正则难理解因为里面有一个等价的概念,这个概念大大增加了理解难度,让很多初学者看起来会懵,如果把等价都恢复成原始写法,自己书写正则就超级简单了,就像说话一样去写你的正则了:
- 等价是等同于的意思,表示同样的功能,用不同符号来书写。
等价:
- ?,*,+,\d,\w 都是等价字符
- ?等价于匹配长度{0,1}
- *等价于匹配长度{0,}
- +等价于匹配长度{1,}
- \d等价于[0-9]
- \D等价于[^0-9]
- \w等价于[A-Za-z_0-9]
- \W等价于[^A-Za-z_0-9]
常用运算符与表达式:
- ^ 开始
- () 域段
- [] 包含,默认是一个字符长度
- [^] 不包含,默认是一个字符长度
- {n,m} 匹配长度
- . 任何单个字符(\. 字符点)
- | 或
- \ 转义
- $ 结尾
- [A-Z] 26个大写字母
- [a-z] 26个小写字母
- [0-9] 0至9数字
- [A-Za-z0-9] 26个大写字母、26个小写字母和0至9数字
- , 分割
分割语法:
- [A,H,T,W] 包含A或H或T或W字母
- [a,h,t,w] 包含a或h或t或w字母
- [0,3,6,8] 包含0或3或6或8数字
语法与释义:
- 基础语法 "^([]{})([]{})([]{})$"
- 正则字符串 = "开始([包含内容]{长度})([包含内容]{长度})([包含内容]{长度})结束"
- ?,*,+,\d,\w 这些都是简写的,完全可以用[]和{}代替,在(?:)(?=)(?!)(?<=)(?<!)(?i)(*?)(+?)这种特殊组合情况下除外。
- 初学者可以忽略?,*,+,\d,\w一些简写标示符,学会了基础使用再按表自己去等价替换
实例:
- 字符串;tel:086-0666-88810009999
- 原始正则:"^tel:[0-9]{1,3}-[0][0-9]{2,3}-[0-9]{8,11}$"
- 速记理解:开始 "tel:普通文本"[0-9数字]{1至3位}"-普通文本"[0数字][0-9数字]{2至3位}"-普通文本"[0-9数字]{8至11位} 结束"
- 等价简写后正则写法:"^tel:\d{1,3}-[0]\d{2,3}-\d{8,11}$" ,简写语法不是所有语言都支持。
JDK1.6中文翻译
字符 |
|
x |
字符 x |
\\ |
反斜线字符 |
\0n |
带有八进制值 0 的字符 n (0 <= n <= 7) |
\0nn |
带有八进制值 0 的字符 nn (0 <= n <= 7) |
\0mnn |
带有八进制值 0 的字符 mnn(0 <= m <= 3、0 <= n <= 7) |
\xhh |
带有十六进制值 0x 的字符 hh |
\uhhhh |
带有十六进制值 0x 的字符 hhhh |
\t |
制表符 ('\u0009') |
\n |
新行(换行)符 ('\u000A') |
\r |
回车符 ('\u000D') |
\f |
换页符 ('\u000C') |
\a |
报警 (bell) 符 ('\u0007') |
\e |
转义符 ('\u001B') |
\cx |
对应于 x 的控制符 |
字符类 |
|
[abc] |
a、b 或 c(简单类) |
[^abc] |
任何字符,除了 a、b 或 c(否定) |
[a-zA-Z] |
a 到 z 或 A 到 Z,两头的字母包括在内(范围) |
[a-d[m-p]] |
a 到 d 或 m 到 p:[a-dm-p](并集) |
[a-z&&[def]] |
d、e 或 f(交集) |
[a-z&&[^bc]] |
a 到 z,除了 b 和 c:[ad-z](减去) |
[a-z&&[^m-p]] |
a 到 z,而非 m 到 p:[a-lq-z](减去) |
预定义字符类 |
|
. |
任何字符(与行结束符可能匹配也可能不匹配) |
\d |
数字:[0-9] |
\D |
非数字: [^0-9] |
\s |
空白字符:[ \t\n\x0B\f\r] |
\S |
非空白字符:[^\s] |
\w |
单词字符:[a-zA-Z_0-9] |
\W |
非单词字符:[^\w] |
POSIX 字符类(仅 US-ASCII) |
|
\p{Lower} |
小写字母字符:[a-z] |
\p{Upper} |
大写字母字符:[A-Z] |
\p{ASCII} |
所有 ASCII:[\x00-\x7F] |
\p{Alpha} |
字母字符:[\p{Lower}\p{Upper}] |
\p{Digit} |
十进制数字:[0-9] |
\p{Alnum} |
字母数字字符:[\p{Alpha}\p{Digit}] |
\p{Punct} |
标点符号:!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ |
\p{Graph} |
可见字符:[\p{Alnum}\p{Punct}] |
\p{Print} |
可打印字符:[\p{Graph}\x20] |
\p{Blank} |
空格或制表符:[ \t] |
\p{Cntrl} |
控制字符:[\x00-\x1F\x7F] |
\p{XDigit} |
十六进制数字:[0-9a-fA-F] |
\p{Space} |
空白字符:[ \t\n\x0B\f\r] |
java.lang.Character 类(简单的 java 字符类型) |
|
\p{javaLowerCase} |
等效于 java.lang.Character.isLowerCase() |
\p{javaUpperCase} |
等效于 java.lang.Character.isUpperCase() |
\p{javaWhitespace} |
等效于 java.lang.Character.isWhitespace() |
\p{javaMirrored} |
等效于 java.lang.Character.isMirrored() |
Unicode 块和类别的类 |
|
\p{InGreek} |
Greek 块(简单块)中的字符 |
\p{Lu} |
大写字母(简单类别) |
\p{Sc} |
货币符号 |
\P{InGreek} |
所有字符,Greek 块中的除外(否定) |
[\p{L}&&[^\p{Lu}]] |
所有字母,大写字母除外(减去) |
边界匹配器 |
|
^ |
行的开头 |
$ |
行的结尾 |
\b |
单词边界 |
\B |
非单词边界 |
\A |
输入的开头 |
\G |
上一个匹配的结尾 |
\Z |
输入的结尾,仅用于最后的结束符(如果有的话) |
\z |
输入的结尾 |
Greedy 数量词 |
|
X? |
X,一次或一次也没有 |
X* |
X,零次或多次 |
X+ |
X,一次或多次 |
X{n} |
X,恰好 n 次 |
X{n,} |
X,至少 n 次 |
X{n,m} |
X,至少 n 次,但是不超过 m 次 |
Reluctant 数量词 |
|
X?? |
X,一次或一次也没有 |
X*? |
X,零次或多次 |
X+? |
X,一次或多次 |
X{n}? |
X,恰好 n 次 |
X{n,}? |
X,至少 n 次 |
X{n,m}? |
X,至少 n 次,但是不超过 m 次 |
Possessive 数量词 |
|
X?+ |
X,一次或一次也没有 |
X*+ |
X,零次或多次 |
X++ |
X,一次或多次 |
X{n}+ |
X,恰好 n 次 |
X{n,}+ |
X,至少 n 次 |
X{n,m}+ |
X,至少 n 次,但是不超过 m 次 |
Logical 运算符 |
|
XY |
X 后跟 Y |
X|Y |
X 或 Y |
(X) |
X,作为捕获组 |
Back 引用 |
|
\n |
任何匹配的 nth 捕获组 |
引用 |
|
\ |
Nothing,但是引用以下字符 |
\Q |
Nothing,但是引用所有字符,直到 \E |
\E |
Nothing,但是结束从 \Q 开始的引用 |
特殊构造(非捕获) |
|
(?:X) |
X,作为非捕获组 |
(?idmsux-idmsux) |
Nothing,但是将匹配标志i d m s u xon - off |
(?idmsux-idmsux:X) |
X,作为带有给定标志i d m s u x on - off |
(?=X) |
X,通过零宽度的正 lookahead |
(?!X) |
X,通过零宽度的负 lookahead |
(?<=X) |
X,通过零宽度的正 lookbehind |
(?<!X) |
X,通过零宽度的负 lookbehind |
(?>X) |
X,作为独立的非捕获组 |
JDK1.8官方原文
Characters |
|
x |
The character x |
\\ |
The backslash character |
\0n |
The character with octal value 0n (0 <= n <= 7) |
\0nn |
The character with octal value 0nn (0 <= n <= 7) |
\0mnn |
The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7) |
\xhh |
The character with hexadecimal value 0xhh |
\uhhhh |
The character with hexadecimal value 0xhhhh |
\x{h...h} |
The character with hexadecimal value 0xh...h (Character.MIN_CODE_POINT <= 0xh...h <= Character.MAX_CODE_POINT) |
\t |
The tab character ('\u0009') |
\n |
The newline (line feed) character ('\u000A') |
\r |
The carriage-return character ('\u000D') |
\f |
The form-feed character ('\u000C') |
\a |
The alert (bell) character ('\u0007') |
\e |
The escape character ('\u001B') |
\cx |
The control character corresponding to x |
Character classes |
|
[abc] |
a, b, or c (simple class) |
[^abc] |
Any character except a, b, or c (negation) |
[a-zA-Z] |
a through z or A through Z, inclusive (range) |
[a-d[m-p]] |
a through d, or m through p: [a-dm-p] (union) |
[a-z&&[def]] |
d, e, or f (intersection) |
[a-z&&[^bc]] |
a through z, except for b and c: [ad-z] (subtraction) |
[a-z&&[^m-p]] |
a through z, and not m through p: [a-lq-z](subtraction) |
Predefined character classes |
|
. |
Any character (may or may not match line terminators) |
\d |
A digit: [0-9] |
\D |
A non-digit: [^0-9] |
\h |
A horizontal whitespace character: [ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000] |
\H |
A non-horizontal whitespace character: [^\h] |
\s |
A whitespace character: [ \t\n\x0B\f\r] |
\S |
A non-whitespace character: [^\s] |
\v |
A vertical whitespace character: [\n\x0B\f\r\x85\u2028\u2029] |
\V |
A non-vertical whitespace character: [^\v] |
\w |
A word character: [a-zA-Z_0-9] |
\W |
A non-word character: [^\w] |
POSIX character classes (US-ASCII only) |
|
\p{Lower} |
A lower-case alphabetic character: [a-z] |
\p{Upper} |
An upper-case alphabetic character:[A-Z] |
\p{ASCII} |
All ASCII:[\x00-\x7F] |
\p{Alpha} |
An alphabetic character:[\p{Lower}\p{Upper}] |
\p{Digit} |
A decimal digit: [0-9] |
\p{Alnum} |
An alphanumeric character:[\p{Alpha}\p{Digit}] |
\p{Punct} |
Punctuation: One of !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ |
\p{Graph} |
A visible character: [\p{Alnum}\p{Punct}] |
\p{Print} |
A printable character: [\p{Graph}\x20] |
\p{Blank} |
A space or a tab: [ \t] |
\p{Cntrl} |
A control character: [\x00-\x1F\x7F] |
\p{XDigit} |
A hexadecimal digit: [0-9a-fA-F] |
\p{Space} |
A whitespace character: [ \t\n\x0B\f\r] |
java.lang.Character classes (simple java character type) |
|
\p{javaLowerCase} |
Equivalent to java.lang.Character.isLowerCase() |
\p{javaUpperCase} |
Equivalent to java.lang.Character.isUpperCase() |
\p{javaWhitespace} |
Equivalent to java.lang.Character.isWhitespace() |
\p{javaMirrored} |
Equivalent to java.lang.Character.isMirrored() |
Classes for Unicode scripts, blocks, categories and binary properties |
|
\p{IsLatin} |
A Latin script character (script) |
\p{InGreek} |
A character in the Greek block (block) |
\p{Lu} |
An uppercase letter (category) |
\p{IsAlphabetic} |
An alphabetic character (binary property) |
\p{Sc} |
A currency symbol |
\P{InGreek} |
Any character except one in the Greek block (negation) |
[\p{L}&&[^\p{Lu}]] |
Any letter except an uppercase letter (subtraction) |
Boundary matchers |
|
^ |
The beginning of a line |
$ |
The end of a line |
\b |
A word boundary |
\B |
A non-word boundary |
\A |
The beginning of the input |
\G |
The end of the previous match |
\Z |
The end of the input but for the final terminator, if any |
\z |
The end of the input |
Linebreak matcher |
|
\R |
Any Unicode linebreak sequence, is equivalent to \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029] |
Greedy quantifiers |
|
X? |
X, once or not at all |
X* |
X, zero or more times |
X+ |
X, one or more times |
X{n} |
X, exactly n times |
X{n,} |
X, at least n times |
X{n,m} |
X, at least n but not more than m times |
Reluctant quantifiers |
|
X?? |
X, once or not at all |
X*? |
X, zero or more times |
X+? |
X, one or more times |
X{n}? |
X, exactly n times |
X{n,}? |
X, at least n times |
X{n,m}? |
X, at least n but not more than m times |
Possessive quantifiers |
|
X?+ |
X, once or not at all |
X*+ |
X, zero or more times |
X++ |
X, one or more times |
X{n}+ |
X, exactly n times |
X{n,}+ |
X, at least n times |
X{n,m}+ |
X, at least n but not more than m times |
Logical operators |
|
XY |
X followed by Y |
X|Y |
Either X or Y |
(X) |
X, as a capturing group |
Back references |
|
\n |
Whatever the nth capturing group matched |
\k<name> |
Whatever the named-capturing group "n ame" matched |
Quotation |
|
\ |
Nothing, but quotes the following character |
\Q |
Nothing, but quotes all characters until \E |
\E |
Nothing, but ends quoting started by \Q |
Special constructs (named-capturing and non-capturing) |
|
(?<name>X) |
X, as a named-capturing group |
(?:X) |
X, as a non-capturing group |
(?idmsuxU-idmsuxU) |
Nothing, but turns match flags i d m s u x U on - off |
(?idmsux-idmsux:X) |
X, as a non-capturing group with the given flags i d m s u x o n - off |
(?=X) |
X, via zero-width positive lookahead |
(?!X) |
X, via zero-width negative lookahead |
(?<=X) |
X, via zero-width positive lookbehind |
(?<!X) |
X, via zero-width negative lookbehind |
(?>X) |
X, as an independent, non-capturing group |
扩展补充
字符 |
说明 |
---|---|
\ |
将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如,"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"。 |
. |
匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符,请使用诸如"[\s\S]"之类的模式。 |
(pattern) |
匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( ),请使用"\("或者"\)"。 |
(?:pattern) |
匹配 pattern 但不捕获该匹配的子表达式,即它是一个非捕获匹配,不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如,'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","l","i","n"。 |
[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。如果两种前面的情况都不存在,则 \nm 匹配八进制值 nm,其中 n 和 m 是八进制数字 (0-7)。 |
\nml |
当 n 是八进制数 (0-3),m 和 l 是八进制数 (0-7) 时,匹配八进制转义码 nml。 |
\un |
匹配 n,其中 n 是以四位十六进制数表示的 Unicode 字符。例如,\u00A9 匹配版权符号 (©)。 |
实例
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author ZC
* @date 2019/11/16
*/
public final class RegExpValidatorUtils {
/**
* 验证邮箱
*
* @return 如果是符合的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isEmail(String str) {
String regex = "^([\\w-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([\\w-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$";
return match(regex, str);
}
/**
* 验证IP地址(IPv4)
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isIP(String str) {
String num = "(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)";
String regex = "^" + num + "\\." + num + "\\." + num + "\\." + num + "$";
return match(regex, str);
}
/**
* 验证网址Url(http://或https://开头)
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isUrl(String str) {
String regex = "http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?";
return match(regex, str);
}
/**
* 验证电话号码(非手机号)
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isTelephone(String str) {
String regex = "^(\\d{3,4}-)?\\d{6,8}$";
return match(regex, str);
}
/**
* 验证输入手机号码
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isPhone(String str) {
String regex = "^[1]+[3,5]+\\d{9}$";
return match(regex, str);
}
/**
* 验证输入邮政编号
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isPostalcode(String str) {
String regex = "^\\d{6}$";
return match(regex, str);
}
/**
* 验证输入身份证号
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isIDcard(String str) {
String regex = "(^\\d{18}$)|(^\\d{15}$)";
return match(regex, str);
}
/**
* 验证输入一年的12个月
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isMonth(String str) {
String regex = "^(0?[[1-9]|1[0-2])$";
return match(regex, str);
}
/**
* 验证输入一个月的31天
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isDay(String str) {
String regex = "^((0?[1-9])|((1|2)[0-9])|30|31)$";
return match(regex, str);
}
/**
* 验证日期时间
*
* @return 如果是符合网址格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isDate(String str) {
// 严格验证时间格式的(匹配[2002-01-31], [1997-04-30],
// [2004-01-01])不匹配([2002-01-32], [2003-02-29], [04-01-01])
// String regex = "^((((19|20)(([02468][048])|([13579][26]))-02-29))|((20[0-9][0-9])|(19[0-9][0-9]))-((((0[1-9])|(1[0-2]))-((0[1-9])|(1\\d)|(2[0-8])))|((((0[13578])|(1[02]))-31)|(((01,3-9])|(1[0-2]))-(29|30)))))$";
// 没加时间验证的YYYY-MM-DD
// String regex = "^((((1[6-9]|[2-9]\\d)\\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\\d|3[01]))|(((1[6-9]|[2-9]\\d)\\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\\d|30))|(((1[6-9]|[2-9]\\d)\\d{2})-0?2-(0?[1-9]|1\\d|2[0-8]))|(((1[6-9]|[2-9]\\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))$";
// 加了时间验证的YYYY-MM-DD 00:00:00
String regex = "^((((1[6-9]|[2-9]\\d)\\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\\d|3[01]))|(((1[6-9]|[2-9]\\d)\\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\\d|30))|(((1[6-9]|[2-9]\\d)\\d{2})-0?2-(0?[1-9]|1\\d|2[0-8]))|(((1[6-9]|[2-9]\\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-)) (20|21|22|23|[0-1]?\\d):[0-5]?\\d:[0-5]?\\d$";
return match(regex, str);
}
/**
* 验证非零的正整数
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isIntNumber(String str) {
String regex = "^\\+?[1-9][0-9]*$";
return match(regex, str);
}
/**
* 验证大写字母
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isUpChar(String str) {
String regex = "^[A-Z]+$";
return match(regex, str);
}
/**
* 验证小写字母
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isLowChar(String str) {
String regex = "^[a-z]+$";
return match(regex, str);
}
/**
* 验证验证输入字母
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isLetter(String str) {
String regex = "^[A-Za-z]+$";
return match(regex, str);
}
/**
* 验证验证输入汉字
*
* @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
* @params 待验证的字符串
*/
public static boolean isChinese(String str) {
String regex = "^[\u4e00-\u9fa5],{0,}$";
return match(regex, str);
}
/**
* @return 如果str 符合 regex的正则表达式格式,返回true, 否则返回 false;
* @params regex
* 正则表达式字符串
* @params str
* 要匹配的字符串
*/
private static boolean match(String regex, String str) {
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
if(matcher.find()){
return matcher.matches();
}
return false;
}
}