正则表达式在线(正则表达式解析网站)「终于解决」

大家好，我是讯享网，大家多多关注。

简介

正则表达式描述了一种字符串匹配的模式，可以用来检查字符串是否包含某种子串，替换匹配的子串，或者从字符串中取出满足一定条件的子串等。

性格；角色；字母

形容

\

将下一个字符标记为特殊字符、原义字符、反向引用或八进制转义字符。例如，“n”匹配字符“n”。\n ‘匹配一个换行符。序列“\”匹配“\”和“\(“匹配”(”)。

^

输入匹配字符串的起始位置。如果设置了RegExp对象的Multiline属性，它也会匹配“\n”或“\r”之后的位置。

$

输入匹配字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也会匹配“\n”或“\r”之前的位置。

*

零次或多次匹配前一个子表达式。比如zo*可以匹配“z”和“zoo”。*相当于{0，}。

+

匹配前一个子表达式一次或多次。比如“zo+”可以匹配“zo”和“zoo”，但不能匹配“z”。+相当于{1，}。

？

匹配前一个子表达式零次或一次。比如“做(es)？”在“does”中可以搭配“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)”。

(模式)

匹配模式并获得匹配。使用VBScript中的matches集合和JScript中的[27]…属性，可以从生成的Matches集合中获得获得的匹配。若要匹配括号字符，请使用“\(”或“\)”。

(?:模式)

在没有获得匹配结果的情况下匹配模式，也就是说，它是一个非获得匹配，不会被存储以备后用。当使用OR字符“(|)”来组合模式的各个部分时，这很有用。比如“industr(？:y|ies)”是比“industry|industries”更简单的表达方式。

(?=模式)

正面预览，在任何字符串匹配模式的开头匹配搜索字符串。这是一个非获取匹配，即这个匹配不需要被获取以备后用。比如“Windows(？=95|98|NT|2000)”可以匹配” Windows2000 “中的” Windows “，但不能匹配” Windows3.1 “中的” Windows “预搜索不消耗字符，也就是说，发生一次匹配后，紧接着上一次匹配开始搜索下一次匹配，而不是包含预搜索的字符后开始搜索。

(?！图案)

否定预览在任何不匹配模式的字符串的开头匹配搜索字符串。这是一个非获取匹配，即这个匹配不需要被获取以备后用。比如“Windows(？！95|98|NT|2000)”可以匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。预搜索不消耗字符，也就是说，一个匹配发生后，紧接着上一个匹配开始下一个匹配的搜索，而不是在包含预搜索的字符后开始。

(?& lt=模式)

正面预览与正面预览类似，但方向相反。比如，“(？& lt=95|98|NT|2000)Windows可以匹配2000Windows中的Windows，但不能匹配3.1Windows中的Windows。

(?& lt！图案)

负面预览与正面预览类似，但方向相反。如“(？& lt！95|98|NT|2000)Windows可以匹配3.1Windows中的Windows，但不能匹配2000Windows中的Windows。

x|y

匹配x或Y..比如“z|food”可以搭配“z”或者“food”。“(z|f)ood”匹配“缩放”或“食物”。

[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”可以和动词中的“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是十六进制转义值。十六进制转义值的长度必须是两位数。比如“X 41”匹配“A”。\x041 \相当于\x04&1 \。ASCII编码可以用在正则表达式中。。

\数量

匹配num，其中num是正整数。对获得的匹配的引用。比如，“(。)”匹配两个连续的相同字符。

\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匹配版权符号()。

常用正则表达式

用户名

/^[a-z0-9_-]{3,16}$/

密码

/^[a-z0-9_-]{6,18}$/

十六进制值

/^#?([a-f0-9]{6}|[a-f0-9]{3})$/

电子邮箱/电子邮箱/电子邮箱

/^([a-z0-9_\.-]+)@([\da-z\。-]+)\.([a-z\。]{2,6})$/
/^[a-z\d]+(\.[a-z\d]+)*@([\da-z])？)+(\.{1，2}[a-z]+)+$/

统一资源定位器

/^(https？:\/\/)?([\da-z\。-]+)\.([a-z\。]{2，6})([\/\w \-]*)*\/?$/

ip地址

/((2[0-4]\d|25[0-5]|[01]？\d\d？)\.){3}(2[0-4]\d|25[0-5]|[01]？\d\d？)/
/^(？:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/

HTML标签

/^&lt；(【a-z]+)([^&lt；]+)*(?:& gt(.*)& lt；\/\ 1 & gt；| \ s+\/& gt；)$/

删除代码\ \注释

(?& lt！http:|\S)//。*$

Unicode编码中的汉字范围

/^[\u2E80-\u9FFF]+$/

1.普通字符

普通人物主要讲解以下内容，并举例说明。

//String regStr = & # 34；[a-z]& # 34；；//匹配a-z//String regStr = & # 34；[A-Z]& # 34；；//匹配A-Z//String regStr = & # 34；abc & # 34；//匹配字符串ABC//String regStr = & # 34；(?I)ABC & # 34；；//匹配的字母abc不区分大小写。//String regStr = & # 34；[0-9]”；//匹配0到9之间的任意字符//String regStr = & # 34；[^0-9]”；//匹配的不是0-9中的任何字符//String regStr = & # 34；[^0-9]{2}”；//匹配2个不是0-9的字符//String regStr = & # 34；\ \ d & # 34；//匹配任意数字字符，相当于[0-9]//String regStr = & # 34；\ \ D & # 34；//匹配任何非数字字符，相当于[0-9]//string regstr = & # 34；\ \ w & # 34；//匹配任意数字、字母、下划线，相当于[0-9a-za-z _]//string regstr = & # 34；\ \ W & # 34；//匹配除数字、字母、下划线以外的任意一个，相当于[0-9a-za-z _]//String regstr = & # 34；\ \ s & # 34；//匹配任何一个空字符//String regStr = & # 34；\ \ S & # 34；//匹配任何非空字符//String regStr = & # 34；ab | cd & # 34；//选择一个匹配器来匹配字符串ab或cd1)String regStr = & # 34；[a-z]& # 34；；//匹配A-Z中的任意字符。

@ Test public void test1(){ String str = & # 34；abc2021 & # 34；String regStr = & # 34[a-z]& # 34；；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；} }

结果展示显示结果

2)String regStr = & # 34；[A-Z]& # 34；；//匹配A-Z中的任意字符。

@ test public void test 2(){ String str = & # 34；ABCabc2021 & # 34；String regStr = & # 34[A-Z]& # 34；；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

3)字符串regStr = & # 34abc & # 34；//匹配字符串abc

@ test public void test 2(){ String str = & # 34；ABCabc2021 & # 34；String regStr = & # 34abc & # 34；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

4)字符串regStr = & # 34(?I)ABC & # 34；；//匹配的字母abc不区分大小写

@ test public void test 2(){ String str = & # 34；ABCabc2021 & # 34；String regStr = & # 34(?I)ABC & # 34；；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

5)String regStr = & # 34；[0-9]”；//匹配0到9之间的任何字符

@ test public void test 2(){ String str = & # 34；ABCabc2021 & # 34；String regStr = & # 34[0-9]”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

6)String regStr = & # 34；[^0-9]”；//匹配不是0-9中的任何字符

@Testpublic void test2(){ String str = “ABCabc2021”; String regStr = “[^0-9]”; Pattern compile = Pattern.compile(regStr); Matcher matcher = compile.matcher(str); while(matcher.find()){ System.out.println(“匹配到的数据为：”+matcher.group(0)); }}

结果展示@ test public void test 2(){ String str = & # 34；ABCabc2021 & # 34；String regStr = & # 34[^0-9]”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}结果显示

2.预选赛

/* * *限定词* *:表示任意次数，0次或n次，如(abc)*表示abc出现0次或多次*+:表示至少出现1次或n次，如(abc)+表示abc出现1次或多次*？:表示至少出现0次或1次，如abc？c出现0次或1次* {n}:出现n次，如[0-9]{2}，数字* {n}匹配2次，表示至少n次，如[0-9]{3，}匹配至少3次，* {n，m}匹配至少n次，最多m次，如[

@ test public void test 2(){ String str = & # 34；zypabcabc2021 & # 34；String regStr = & # 34zyp(ABC)* & # 34；；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

2)+:表示至少出现一次或n次，如(abc)+表示abc出现一次或多次。

@ test public void test 2(){ String str = & # 34；zypabc2021 & # 34；String regStr = & # 34zyp(ABC)+& # 34；；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

3)?:表示至少出现0次或1次，如abc？c表示0或1次。

@ test public void test 2(){ String str = & # 34；zyp2021 & # 34；String regStr = & # 34zyp(abc)？”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

4){n}:表示出现n次，如[0-9]{2}，表示该数匹配两次。

@ test public void test 2(){ String str = & # 34；zyp2021 & # 34；String regStr = & # 34[0-9]{2}”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

5){n，}表示至少出现n次，如[0-9]{3，}表示该数至少匹配3次。

@ test public void test 2(){ String str = & # 34；zyp2021 & # 34；String regStr = & # 34[0-9]{2,}”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

6){n，m}表示最少n次最多m次，如[0-9]{2，4}表示匹配次数2-4次。

@ test public void test 2(){ String str = & # 34；zyp2021 & # 34；String regStr = & # 34[0-9]{2,4}”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

3.探测器

/* * * Locator *:指示字符串的开头。比如有一个正则度为[0-9]+[a-z] *(必须以数字开头)的字符串123abc，就可以匹配成功。如果字符串是a123abc，它不匹配* $:它表示字符串以什么结尾。比如有一个正则度为[0-9]+[a-z]+$(表示以数字开头，以字母结尾)的字符串123abc，就可以匹配成功。如果字符串是a123abc1，则不匹配* \b:表示边缘匹配(在字符串末尾或空)的意思。有一个字符串abc123abc，其正则性为abc\b，最后一个abc * \B:与\b */1相反):表示该字符串以什么开头。

@ test public void test 2(){ String str = & # 34；2021zyp & # 34；String regStr = & # 34^[0-9]+”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

2) $:指示字符串以什么结尾。

@ test public void test 2(){ String str = & # 34；2021zyp & # 34；String regStr = & # 34[0-9]#34;；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

没有匹配到，因为要以数字结束没有匹配项，因为它以数字结尾。

3) \b:表示边缘匹配(在字符串的末尾或在空点阵之后)

@ test public void test 2(){ String str = & # 34；zyp2021zyp & # 34；String regStr = & # 34zyp \ \ b & # 34；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

匹配到的是最后一个“zyp”这场比赛是最后一场“zyp”

4) \B:与\B相反

@ test public void test 2(){ String str = & # 34；zyp2021zyp & # 34；String regStr = & # 34zyp \ \ B& # 34；；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

匹配到的是第一个“zyp”这场比赛是第一次“zyp”

4.分组

/* * *分组:可分为捕获分组和非捕获分组* 1。捕获分组:* 1) If (\d\d)(\d\d)表示匹配4位数，如果字符串位是2021abcd，*我们通过matcher . group(0)& lt；a1 & gt\d\d)(？& lta2 & gt\d\d)表示匹配4位数。如果字符串位是2021abcd，*我们通过matcher.group(0)得到2021 *通过matcher.group(1)得到20，或者通过matcher.group(a1)得到20 *通过matcher.group(2)得到21 *也可以通过matcher.group(a2)得到21 *这说明()起到了分组* * 2的作用。非捕获分组:取不到值* 1)如20(？:20 | 21 | 22)表示匹配2020 | 2021 | 2022 * 2)，如20(？=20|21|22)表示2020年或2021年或2022年的20 * 3)匹配，如20(？！20|21|22)表示匹配不匹配2020或2021或2022年的20，匹配其他20 * */捕获包1)，如(\d\d)(\d\d)表示匹配4位数。如果字符串是2021abcd，

@ test public void test 2(){ String str = & # 34；2021abcd & # 34；String regStr = & # 34(\ \ d \ \ d)(\ \ d \ \ d)& # 34；；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；matcher . group(0):& # 34；+matcher . group(0))；system . out . println(& # 34；第一组:matcher . group(1):& # 34；+matcher . group(1))；system . out . println(& # 34；第二组:matcher . group(2):& # 34；+matcher . group(2))；}}

结果展示显示结果

结论:可以看出()会对规律性进行分组，并从1开始依次给出数字。

2)(?& lta1 & gt\d\d)(？& lta2 & gt\d\d)表示匹配4位数，如果字符串位是2021abcd

@ test public void test 2(){ String str = & # 34；2021abcd & # 34；String regStr = & # 34(?& lta1 & gt\d\d)(？& lta2 & gt\ \ d \ \ d)& # 34；；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；matcher . group(0):& # 34；+matcher . group(0))；system . out . println(& # 34；第一组:matcher . group(1):& # 34；+matcher . group(1))；system . out . println(& # 34；第二组:matcher . group(2):& # 34；+matcher . group(2))；system . out . println(& # 34；群组名称a1:matcher . group(1):& # 34；+matcher . group(& # 34；a1 & # 34));system . out . println(& # 34；组a2:matcher . group(2):& # 34；+matcher . group(& # 34；a2 & # 34));}}

结果展示显示结果

结论:可见()不仅能对规则进行分组，还能按顺序给出数字，从1开始。也可以给组命名，根据名称得到对应的匹配值。

非捕获分组

1)如20(？:20 | 21 | 22)表示匹配2020 | 2021 | 2022。

@ test public void test 2(){ String str = & # 34；2021 a 2022 b 2023 & # 34；；String regStr = & # 3420(?:20|21|22)”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

结果展示显示结果

2)如20(？=20|21|22)表示匹配2020或2021或2022的20。

@ test public void test 2(){ String str = & # 34；2021 a 2022 b 2023 & # 34；；String regStr = & # 3420(?=20|21|22)”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

这里匹配到的20，为2021和2022中的20这里匹配的20是2021年和2022年的20。

3)如20(？！20|21|22)表示匹配不匹配2020年或2021年或2022年的20个，匹配另外20个。

@ test public void test 2(){ String str = & # 34；2021 a 2022 b 2023 & # 34；；String regStr = & # 3420(?！20|21|22)”；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；}}

这里匹配到的20为2023中的20这里匹配的20是2023年的20。

5.反向参考

/* * *反向引用*如果我们要在一个字符串中找到4个连续的数字，并且第一个和第四个数字相同，那么第二个和第三个数字也相同。*这时我们使用反向引用就很简单了*反向引用的内部用法:\ \ n其中n代表组号，如:string 12345678870008，正则化为(\d)(\d)\2\1 *反向引用的外部用法:$ n其中n代表组号*/string

@ Test public void Test 2(){ String str = & # 34；12345678870008″；/* * *第一个(\d)会分配一组1 *第二个(\d)会分配一组2 * \ 2:表示引用组2的值，所以2和3的值会相同* \1:表示引用组1的值，所以1和4的值会相同*/string regstr =(\ \ d)(\ \ d)\ \ 2 \ \ 1 & # 34；；模式编译= pattern . compile(regStr)；matcher matcher = compile . matcher(str)；while(matcher . find()){ system . out . println(& # 34；匹配的数据是:& # 34；+matcher . group(0))；} }

结果展示显示结果