正则表达式规则表,正则表达式(4)----常用的正则表达式

正则表达式规则表,正则表达式(4)----常用的正则表达式详细介绍

本文目录一览： 20个常用的正则表达式

正则表达式:要求6-20位,只能有大小写字母和数字,并且大小写字母和数字都...[0-9A-Za-z] {6，20} 由6-20位数字或这字母组成。匹配行结尾位置。正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。
正则表达式：^(？！[0-9]+$)(？！[a-zA-Z]+$)[0-9A-Za-z]{6，20} 正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。
正则的写法：[\da-zA-Z]+ 可以匹配 数字，大小写字母 个数是至少一个 另外，不要用 \w+ 因为\w是匹配字母数字下划线，多一个下划线，不符合你的要求的。具体完整代码，此处不给贴，你就自己写吧。
var s = /^[a-z]+[a-za-z0-9_]*$/；alert(s.test(r))；这个只能判断只允许出现字母数字下划线，同时以小写字母开头，但是长度没法控制。用正则来判断这个长度应该是不行了。
收集整理项目中常用到的正则表达式1、正则表达式一般用于处理文本内容，常用命令有grep，sed，awk，vim等 通配符一般用于匹配文件名，常用命令有find，ls，cp等 各符号的含义不尽相同.什么地方使用正则表达式 vim grep sed awk nginx apache mail垃圾邮件过滤。
2、以下就是对超常用的PHP正则表达式进行的收集整理，为了方便大家更快更好的掌握php正则表达式。
3、Flags 写在结束的/之后，可以影响整个正则表达式的匹配行为。
正则表达式正则表达式，又称规则表达式。是计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。许多程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。
正则表达式(英文：Regular Expression)，在计算机科学中，是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。在很多文本编辑器或其他工具里，正则表达式通常被用来检索和/或替换那些符合某个模式的文本内容。
正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。
常用的65条正则表达式js常用正则表达式整数或者小数：^[0-9]+\.{0，1}[0-9]{0，2}$只能输入数字：^[0-9]*$。只能输入n位的数字：^\d{n}$。只能输入至少n位的数字：^\d{n，}$。只能输入m~n位的数字：。
以下就是对超常用的PHP正则表达式进行的收集整理，为了方便大家更快更好的掌握php正则表达式。
正则表达式是一种描述字符串结果的语法规则，是一个特定的格式化模式，可以匹配、替换、截取匹配的字符串。常用的语言基本上都有正则表达式，如JavaScript、java等。
超常用的PHP正则表达式收集整理以下就是对超常用的PHP正则表达式进行的收集整理，为了方便大家更快更好的掌握php正则表达式。
\：]*$！\是对php中单引号的转义。或者还有更简单的 ！^/？[a-z0-9 =\：]*$！i i表示忽略大小写。模式分隔符就是为了区分表达式和像i这样的模式修饰符而设计的。
什么是正则表达式：简单的说，正则表达式是一种可以用于模式匹配和替换的强大工具。在几乎所有的基于UNIX/LINUX系统的软件工具中找到正则表达式的痕迹，例如：Perl或PHP脚本语言。
ThinkPHP的自动验证常用的正则 一般我们见的比较多的是设置规则为require、email之类的，其实这些本身也是属于正则表达式验证方式，只是系统内置定义了一些常用的正则表达式而已。
关键地方是汉字的表示\xa0-\xff。下面是我写的例子程序，调试通过：？php str=汉字123456abcdef+-*/ABCDE！@#$%^&*()结尾。
PHP常用正则表达式汇总1、\w就是匹配字母或数字或下划线或汉字，+则与*差不多，区别是+包括重复0次，而*就可以。=就ushi匹配=号 两个斜杠则表示正则表达式的分界。
2、正则表达式的限定符有：ThinkPHP的自动验证机制是为了进行表单数据验证，验证可以支持function、 callback、confirm、equal、unique和regex，这里要讲的是使用正则表达式进行验证。特殊字符 许多元字符要求在试图匹配它们时特别对待。
3、^/？[a-zA-Z0-9 =\：]*$！\是对php中单引号的转义。或者还有更简单的 ！^/？[a-z0-9 =\：]*$！i i表示忽略大小写。模式分隔符就是为了区分表达式和像i这样的模式修饰符而设计的。

正则表达式(4)----常用的正则表达式

正则表达式（2）---匹配规则

正则表达式（3）---运算符优先级

正则表达式(4)----常用的正则表达式

一、校验数字的表达式
数字：^[0-9]*$

n位的数字：^\d{n}$

至少n位的数字：^\d{n,}$

m-n位的数字：^\d{m,n}$

零和非零开头的数字：^(0|[1-9][0-9]*)$

非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$

带1-2位小数的正数或负数：^(-)?\d+(.\d{1,2})$

正数、负数、和小数：^(-|+)?\d+(.\d+)?$

有两位小数的正实数：^[0-9]+(.[0-9]{2})?$

有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$

非零的正整数：^[1-9]\d 或 ^+?[1-9][0-9] $

非零的负整数：^-[1-9][]0-9"*

非负整数：^\d+

非正整数：^-[1-9]\d*|0

非负浮点数：^\d+(.\d+)?

非正浮点数：^((-\d+(.\d+)?)|(0+(.0+)?))

正浮点数：^[1-9]\d .\d |0.\d [1-9]\d

负浮点数：^-([1-9]\d .\d |0.\d [1-9]\d )

浮点数：^(-?\d+)(.\d+)?

二、校验字符的表达式
汉字：^[\u4e00-\u9fa5]{0,}$

英文和数字：^[A-Za-z0-9]+

长度为3-20的所有字符：^.{3,20}$

由26个英文字母组成的字符串：^[A-Za-z]+$

由26个大写英文字母组成的字符串：^[A-Z]+$

由26个小写英文字母组成的字符串：^[a-z]+$

由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$

由数字、26个英文字母或者下划线组成的字符串：^\w+

中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$

中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+

可以输入含有^%&',;=? \x22]+

禁止输入含有 的字符：[^ \x22]+

三、特殊需求表达式
Email地址：^\w+([-+.]\w+) @\w+([-.]\w+) .\w+([-.]\w+)*$

域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?

InternetURL：[a-zA-z]+://[^\s]* 或 ^http://([\w-]+.)+[\w-]+(/[\w-./?%&=]*)?$

手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$

电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^((\d{3,4}-)|\d{3.4}-)?\d{7,8}$

国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}

电话号码正则表达式（支持手机号码，3-4位区号，7-8位直播号码，1－4位分机号）: ((\d{11})|^((\d{7,8})|(\d{4}|\d{3})-(\d{7,8})|(\d{4}|\d{3})-(\d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1})|(\d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1}))$)

身份证号(15位、18位数字)，最后一位是校验位，可能为数字或* * 字符X：( \d{15}$)|(^\d{18}$)|( \d{17}(\d|X|x)$)

帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$

密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$

强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在 8-10 之间)：^(?=. \d)(?=. [a-z])(?=.*[A-Z])[a-zA-Z0-9]{8,10}$

强密码(必须包含大小写字母和数字的组合，可以使用特殊字符，长度在8-10之间)：^(?=. \d)(?=. [a-z])(?=.*[A-Z]).{8,10}$

日期格式：^\d{4}-\d{1,2}-\d{1,2}

一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$

一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$

钱的输入格式：
1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$

2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$

3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$

4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧。下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$

5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$

6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$

7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$

8.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$

9.备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里

xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\.[x|X][m|M][l|L]$

中文字符的正则表达式：[\u4e00-\u9fa5]

双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))

空白行的正则表达式：\n\s*\r (可以用来删除空白行)

HTML标记的正则表达式：<(\S ?)[^>] >. ?|<. ? /> ( 首尾空白字符的正则表达式：^\s |\s ) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)

腾讯QQ号：[1-9][0-9]{4,} (腾讯QQ号从10000开始)

中国邮政编码：[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)

IP地址：((?:(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d))

javascript中的正则表达式有什么规范

正则表达式规则
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：表达式 "(.*)" 与字符串 "

aa

bb

" 匹配时，匹配的结果是：成功；匹配到的内容是 "

aa

bb

" 整个字符串， 表达式中的 "" 将与字符串中最后一个 "" 匹配。

举例2：相比之下，表达式 "(.*?)" 匹配举例1中同样的字符串时，将只得到 "

aa

"， 再次匹配下一个时，可以得到第二个 "

bb

"。

--------------------------------------------------------------------------------

2.2 反向引用 \1, \2...

表达式在匹配时，表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候，小括号包含的表达式所匹配到的字符串可以单独获取。这一点，在前面的举例中，已经多次展示了。在实际应用场合中，当用某种边界来查找，而所要获取的内容又不包含边界时，必须使用小括号来指定所要的范围。比如前面的 "(.*?)"。

其实，"小括号包含的表达式所匹配到的字符串" 不仅是在匹配结束后才可以使用，在匹配过程中也可以使用。表达式后边的部分，可以引用前面 "括号内的子匹配已经匹配到的字符串"。引用方法是 "\" 加上一个数字。"\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*)*>.*?
" 在匹配 "" 时，匹配结果是成功。如果 "" 与 "" 不配对，则会匹配失败；如果改成其他配对，也可以匹配成功。

正则表达式规则如下：

表达式 描述 表达式 描述

^ 匹配行首 $ 匹配行尾

. 匹配任何单个字符 [] 匹配集合中的字符

[^] 匹配不在集合中的字符 ? 匹配前一个样式0或1次

* 匹配前一个样式0或更多次 + 匹配前一个样式1或更多次

| 匹配前一个或后一个样式 & 匹配前一个样式0或更多次

# 匹配前一个样式1或更多次 {} Group char to form one pattern

() Group and remember \ 下一个字符直接用原意（只对a-z之外的字符有效）

< 匹配词的开始 > 匹配词的结尾

\x## 匹配ASCII码为##（16进制）的字符 \N### 匹配ASCII码为##（10进制）的字符

\o### 匹配ASCII码为##（8进制）的字符 \a 匹配 \a

\b 匹配 \b \f 匹配 \f

\r 匹配 0x13(回车) \t 匹配 0x09(跳格)

\v 匹配 \v \e 匹配 Esc(0x05)

\n 匹配0x10(换行) \s 匹配空格(回车，换行，制表符，空格)

\S 匹配非空格(!\s) \w 整字匹配

\W 非整字匹配 \d 匹配数字

\D 匹配非数字 \U 匹配大写字母

\L 匹配小写字母 \C 后面开始大小写敏感

\c 后面开始大小写不敏感 \# 匹配前面定义的组(#: 1-9, a-f)
密码正则表达式

function check(pwd){ //6-18位 ，由数字、大写字母、小写字母、特殊字符 var r = /^[0-9a-zA-Z!@#$^]{6,18}$/;//特殊字符可以补充，与后续校验同步即可 if(r.test(pwd)){ var a = /[0-9]/.exec(pwd)!=null ? 1:0; var b = /[a-z]/.exec(pwd)!=null ? 1:0; var c = /[A-Z]/.exec(pwd)!=null ? 1:0; var d = /[!@#$^]/.exec(pwd)!=null ? 1:0; return a + b + c + d >= 2;//至少2种 } return false;}
\w{6,18} \w（字母、数字）相当于[0-9a-zA-Z] {6,18}相当于 至少6次，最多18次。
该正则表达式： /^(\w[!@#]\w){6,18}$/
1、至少8-16个字符，至少1个大写字母，1个小写字母和1个数字，其他可以是任意字符：
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[^]{8,16}$/
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[\s\S]{8,16}$/
其中 [\s\S] 中的\s空白符，\S非空白符，所以[\s\S]是任意字符。也可以用 [\d\D]、[\w\W]来表示。
2、至少8个字符，至少1个大写字母，1个小写字母和1个数字,不能包含特殊字符（非数字字母）：
^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$
3、至少8个字符，至少1个字母，1个数字和1个特殊字符：
^(?=.*[A-Za-z])(?=.*\d)(?=.*[$@$!%*#?&])[A-Za-z\d$@$!%*#?&]{8,}$
4、至少8个字符，至少1个大写字母，1个小写字母和1个数字：
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$
5、至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符：
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}
6、最少8个最多十个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符：
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,10}

正则表达式

/\{\{(.+?)\}\}/g
最前面的“/”与最后面的“/”是分隔符，表示正则表达式的开始与结束。
最后的“g”标志则表示正则表达式使用的global（全局）的状态。使用 global 标志表明在被查找的字符串中搜索操作将查找所有符合的项，而不仅仅是第一个。这也被称为全局匹配。【相关的标志还有i（ignoreCase，表示忽略大小写）、m（multiline，表示允许跨行）】
然后我们再来看中间的主体部分：\{\{(.+?)\}\}花括号{}是正则里的限定符。但是我们这里是要找字符串里的花括号，所以前面加个“\”来表示是要找字符的花括号。“\{\{”“\}\}”就是找前后两组花括号。
“.”表示任意字符。“+”表示前面表达式一次乃至多次。“?”表示匹配模式是非贪婪的。
/\{\{(.+?)\}\}/g完整的意思就是：在全部范围内查找匹配前后有两组花括号的字符串。
例如：“{{}}”、“{{asdfasdfasdf56745}}”、“{{yuyuy#$%8787 9+_)(*)87 }}”
拓展资料：
正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。
许多程序设计语言都支持利用正则表达式进行字符串操作。例如，在Perl中就内建了一个功能强大的正则表达式引擎。正则表达式这个概念最初是由Unix中的工具软件（例如sed和grep）普及开的。正则表达式通常缩写成“regex”，单数有regexp、regex，复数有regexps、regexes、regexen。
参考资料：正则表达式-百度百科
[\u4e00-\u9fa5]

js正则表达式验证数字大于15小于200

正则表达式如下：
/^1[6-9]$|^[2-9]\d$|^1\d{2}$/解释：
^符号表示字符串的开始，^1表示字符串第一个字符为1
$符号表示字符串的结束
[]符号表示字符集合，即该位置匹配[]中任意一个字符，[6-9]即该字符可以是6、7、8、9中的任意一个，同理[2-9]表示2~9中任意一个字符
\d匹配任意一个数字，及0~9中任何一个字符
{2}表示前面匹配的字符数为2个，\d{2}即匹配了2个数字
|表示或的关系，任何一个表达式匹配，则整体表达式匹配
^1[6-9]$匹配2位数，第一位为1，第二位为6~9，即匹配16~19
^[2-9]\d$匹配2位数，第一位为2~9，第二位是任意数字，即匹配20~99
^1\d{2}$匹配3位数，第一位为1，后两位为任意数字，即匹配100~199
var reg = /^(1[6-9]|1\d{2}|[2-9]\d)$/;var num = 100;reg.test(num);
1[6-9]|[2-9][0-9]|1[0-9][0-9]
正则表达式如下：／＾1［6－9］＄｜＾［2－9］＼d＄｜＾1＼d｛2｝＄／。
＾符号表示字符串的开头，＾1表示字符串的第一个源字符是1
＄100符号表示字符串的结束
符号表示一组字符，即位置匹配［］中的任何字符，［6－9］表示字符可以是6、7、8或9中的任何字符。类似地，［2－9］表示2～9中的任何字符
＼d匹配0到9之间的任何数字和任何字符
｛2｝表示之前匹配的字符数为2，＼d｛2｝表示匹配的字符数为2
｜表示or的关系，如果任何一个表达式匹配，则整个表达式都匹配
＾1［6－9］＄匹配2位数字，第1位是1，第2位是6～9，即度匹配16～19
＾［2－9］＼d＄匹配2位数字，第一个是2～9，第二个是任意数字，即匹配20～99
＾1＼d｛2｝＄匹配3位数字，第1位是1，后2位是任意数字，即匹配100～199
扩展资料：
规则表系统由一些普通的位字符和一些元字符组成。普通字符包括大写字母、小写字母和数字，而元字符有特殊的含义，我们将在下面解释。
在其最简单的形式中，正则表达式看起来像一个普通的查找字符串。例如，正则表达式“testing”不包含元字符；它可以匹配字符串“testing”和“testing123”，但不能匹配“testing”。
理解元字符是真正使用正则表达式的最重要的事情。

正则表达式

首发于 Python办公自动化

无障碍 写文章

登录

第一小乔乔

进一步，是一步。一起工作进步，厨艺精进，生活美满。

22 人赞同了该文章

[图片上传失败...(image-f7fc00-1380062)]

match()和search()都只匹配出一个符合条件的字符串，若想要所有，可以使用re.findall()

# 用[]{}判断密码是否符合要求 ：密码是由数字和字母组成，并且位数是6-16位

##用split按-或者空白格分割字段

结果：['ahsb1sssa8', 'jjhd7nhs', '90nsjhf3', '4hh', 'h7', '8kjj', 'sfav']

#用sub替换符合条件的关键词， 试试马赛克脏话（想起农药不能痛骂队友的愤怒）

##练练转义

## findall返回符合表达式的子串

一、正则表达式语法

正则表达式是用匹配或者描述字符串的工具。

用处：

a.判断字符串是否满足某个条件---判断输入的字符串是否是邮箱/手机号码。是否是ip地址

b.提取满足条件的字符串

c.字符串替换

Python中通过re模块中相应的方法来支持正则表达式的匹配、查找和替换等功能

fullmatch(正则表达式字符串, 字符串) ---> 判断正则表达式和字符串是否完全匹配

正则表达式字符串: 就是一个字符串，字符串中是正则表达式语法。r'正则表达式'

正则表达式中包含两个部分，一个是正则语法对应的字符，二个是普通字符

1 .(点)(匹配任意字符)

一个.只匹配一个任意字符

2 \w(匹配字母数字下划线)

一个\w匹配一个字符

3 \s(匹配任意空白字符)

空白字符: 空格、制表符(\t)、回车(换行\n)等，都输入空白字符

一个\s匹配一个空白字符

4 \d(匹配数字字符)

一个\b不会去匹配一个字符，而是单纯的检测\b出现的位置是否是单词边界

单词边界: 字符串开始和结尾、空格、换行、标点符号等，可以将两个单词隔开的字符都单词边界

6 ^(检测是否是字符串开头)

re_str = r'^\d\d\d' # 判断一个字符串是否是三个数字开头

7 $(检测是否是字符串结尾)

8 \W(匹配非字母、数字下划线)

9 \S(匹配非空白字符)

10 \D(匹配非数字字符)

11 \B(检测是否不是单词边界)

12 [] (匹配中括号中出现的任意一个字符)

一个[]匹配一个字符

[字符集] --> 匹配一个字符，这字符是字符集中的任意一个字符

例如：[abc], [\d+]

[字符1-字符2] --> 匹配一个字符，这个字符是Unicode编码值在字符1到字符2中的任意一个字符;要求字符1的编码值要小于字符2

例如：[1-9] --> 数字1到9 [a-z] --> 小写字母 [A-Z] --> 大写字母

[\u0031-\u0039] --> 数字1到9

[\u4E00-\u9fa5] --> 匹配所有的汉字

注意：-在中括号中，如果放在两个字符之间表示范围。

13 [^字符集] (匹配一个不在字符集中的任意字符)

注意：^必须放在中括号中的最前面才有效

二、正则表达式次数相关符号

from re import fullmatch

1. *(匹配0次或者多次)

字符* --> 字符出现0次或者多次

2. +(匹配一次或者多次)

3. ?(匹配0次或者1一次)

练习：写一个正则表达式，匹配所有的整数（123, -2334, +9...可以匹配的，012， -023，+0122不能匹配）

{N} --> 匹配N次

{M,N} --> 匹配M到N次

{M,} --> 至少匹配M次

{,N} --> 最多匹配N次

三、分之和分组

import re

1. |(分之)

条件1|条件2 --> 先用条件1去匹配，如果匹配成功就匹配成功。如果条件1匹配失败，用条件2去匹配。

注意：如果条件1匹配成功就不会用条件2再去匹配

能匹配成功时abc，d和aaa

'abc'+W/H/Y

2. ()(分组)

a.组合(将括号中的内容作为一个整体进行操作)

b.捕获 -- 使用带括号的正则表达式匹配成功后，只获取括号中的内容

c.重复 -- 在正则表达式中可以通过\数字来重复前面()中匹配到的结果。数字代表前第几个分组

a.组合

匹配一个字符串，以数字字母的组合出现3次

b.捕获

c.重复

3.转义符号

正则表达式中可以通过在特殊的符号前加\，来让特殊的符号没有意义

. --> 任意字符 . --> 字符.

注意：在中括号有特殊功能的符号，只代表符号本身

\不管在哪儿都需要转义

-在[]外面没有特殊功能,在[]中要表示-本身，就不要放在两个字符之间

()需要转义

四、re模块中的函数

import re

1. compile

compile(正则表达式字符串) --> 将正则表达式字符串转换成正则表达式对象

2. fullmatch和match

fullmatch(正则表达式字符串, 字符串)

--> 用正则表达式去完全匹配字符串(匹配整个字符串)，返回匹配对象(SRE_Match)或者None

match(正则表达式字符串, 字符串)

--> 匹配字符串开头,返回匹配对象或者None

1.span(group=0) --> 获取匹配成功的区间(左闭右开区间)

print(result.span(0))

print(result.start(1)) # 获取匹配到的开始下标

print(result.end(1)) # 获取匹配到的结束下标后的下标

2.group(group = 0) --> 获取匹配结果

group()/group(0) --> 获取正则表达式完全匹配的结果

group(index>0) --> 获取正则表达式中第group个分组匹配到的结果

3.string --> 获取被匹配的原字符串

3.search

search(正则表达式, 字符串)

--> 查找字符串中满足正则表达式的第一个字符串。返回值是匹配对象或者None

练习：使用search匹配出一个字符串中所有的数字字符串'abc34jshd8923jkshd9lkkk890k' --> 34，8923，9，890

4.findall

findall(正则表达式, 字符串) --> 获取字符串中满足正则表达式的所有的子串，返回一个列表

注意：如果正在表达式中有分组，取值的时候只取分组中匹配到的结果;

如果有多个分组，会将每个分组匹配到的结果作为一个元祖的元素

5.finditer

finditer(正则表达式, 字符串)

--> 查找所有满足正则条件的子串，返回值是迭代器，迭代器中的元素是匹配对象

6. split

split(正则表达式,字符串) --> 将字符串按照满足正则表达式条件的子串进行分割

"""

str1 = 'ahsb1sssa8-jjhd7nhs+90nsjhf3-4hhh7+8kjj-'

result = re.split(r'[-+]', str1)

print(result)

7.sub

sub(正则表达式,repl,字符串) --> 将字符串中满足正则表达式条件的子串替换成repl。返回替换后的字符串

作业

1. 写一个正则表达式判断一个字符串是否是ip地址

规则：一个ip地址由4个数字组成，每个数字之间用.连接。每个数字的大小是0-255 例如：255.189.10.37 正确 256.189.89.9 错误

2. 计算一个字符串中所有的数字的和

例如：字符串是：‘hello90abc 78sjh12.5’ 结果是90+78+12.5 = 180.5

3. 验证输入的内容只能是汉字

4. 电话号码的验证

二、不定项选择题

编辑于 2020-12-21 17:02

Python

正则表达式

赞同 22

3 条评论

分享

[图片上传失败...(image-b1d3-1380060)]

懒人必备

[[图片上传失败...(image-645a0f-1380061)]

裸睡的猪发表于猪哥的Py...]( https://zhuanlan.zhihu.com/p/123179571 ) [# 【Python】正则表达式基础知识

正则表达式（regular expression）是一种处理字符串的工具，功能十分强大。正则表达式使用预定义的特定模式去匹配一类具有共同特征的字符串，主要用于字符串处理，可以快速，准确地完成复杂…

长弓瑾瑜]( https://zhuanlan.zhihu.com/p/61981995 ) [[图片上传失败...(image-c617e9-1380061)]

123456]( https://zhuanlan.zhihu.com/p/53589600 ) [# Python之正则表达式入门

前言：此文实际上是本人在慕课学习北京理工大学课程：Python网络爬虫与信息提取 一课所做的一部分笔记，是作为初学者的入门笔记，自然有许多遗漏或者疏忽，欢迎大家指出。一、正则表达式基…

热水]( https://zhuanlan.zhihu.com/p/396371447 )

切换为时间排序

写下你的评论...




发布

1-3 正则表表达式三—预定义字符集

我们在上节讲到了 字符集 ，相比普通 字符集 ，大大的简化了，方便了不少。可我们发现，一些常用的字符集还可以继续简化，这就引入了 预定义字符集 。 预定义字符集：正则表达式语法有一下几种种最常用的字符集定义了最简化写法，称为预定义字符集 。
\d : 匹配一个数字字符。等价于 [0-9]。
\D : 匹配一个非数字字符。等价于 [^0-9]。
\w : 匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。
\W : 匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。
\s : 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S : 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
所以，手机号规则可进一步简写为:1[3-8]\d\d\d\d\d\d\d\d\d
问题 : 手机号规则中\d写了9遍，车牌号规则中[0-9A-Z] 也写了五遍!
原因 :一个字符集(\d或[0-9])只能匹配一位字符，要 匹配9位字符，就必须重复写9遍；
程序用规则匹配字符串，就像彩票兑奖一样，是逐字逐 个规则匹配。不但内容要符合规则，位数首先要一致；
我们通过使用 预定义字符集 ，在匹配手机号时比 字符集 简化了不少，可我们发现后9位重复写了9个\d,如果这样写，我们发现不对， 字符集 不应该用来定义数量。那用什么来管理数量呢？正则表表达式又给我们引入了另外一个概念 数量词 。

正则表达式如何表示任意整数？

\d+表示连续的数字^\d+$表示整行都是数字[+-]*\d+表示可能带符号的连续数字^[+-]*\d+$表示可能带符号的整行数字([^\.\d]|^)(\d+)([^\.\d]|$)表示连续数字，但前后都没有小数点，整行都是数字也可以，匹配内容的第二个匹配项为数字
正则表达式验证整数方法有：
验证数字
1 ^[0-9]*$
验证所有整数，包括0和正负数整数
1 ^(0|[1-9][0-9]*|-[1-9][0-9]*)$
验证负整数
1 ^(-[1-9][0-9]*)$
验证正整数
1 ^([1-9][0-9]*)$
正则表达式
又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表通常被用来检索、替换那些符合某个模式(规则)的文本。