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" 或 "@"
1
匹配 "a","b","c" 之外的任意一个字符
[f-k]
匹配 "f"~"k" 之间的任意一个字母
2
匹配 "A"~"F","0"~"3" 之外的任意一个字符
举例1：表达式 "bcd" 匹配 "abc123" 时，匹配的后果是：胜利；匹配到的内容是："bc"；匹配到的地位是：开始于1，完结于3。
[举例2：表达式 "1" 匹配 "abc123" 时，匹配的后果是：胜利；匹配到的内容是："1"；匹配到的地位是：开始于3，完结于4。
1.5 润饰匹配次数的特殊符号
后面章节中讲到的表达式，无论是只能匹配一种字符的表达式，还是能够匹配多种字符其中任意一个的表达式，都只能匹配一次。如果应用表达式再加上润饰匹配次数的特殊符号，那么不必反复书写表达式就能够反复匹配。
应用办法是："次数润饰"放在"被润饰的表达式"后边。比方："[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：表达式 "<td>(.*)</td>" 与字符串 "<td><p>aa</p></td> <td><p>bb</p></td>" 匹配时，匹配的后果是：胜利；匹配到的内容是 "<td><p>aa</p></td> <td><p>bb</p></td>" 整个字符串， 表达式中的 "</td>" 将与字符串中最初一个 "</td>" 匹配。
举例2：相比之下，表达式 "<td>(.*?)</td>" 匹配举例1中同样的字符串时，将只失去 "<td><p>aa</p></td>"， 再次匹配下一个时，能够失去第二个 "<td><p>bb</p></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,}" 之间的区别。
，匹配后果是胜利。如果 "<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" 示意一个十六进制数）
模式
字符范畴
/xXX
编号在 0 ~ 255 范畴的字符，比方：空格能够应用 "/x20" 示意
任何字符能够应用 "/u" 再加上其编号的4位十六进制数示意，比方："/中"
3.2 在表达式 "/s"，"/d"，"/w"，"/b" 示意非凡意义的同时，对应的大写字母示意相同的意义
表达式
可匹配
/S
匹配所有非空白字符（"/s" 可匹配各个空白字符）
/D
匹配所有的非数字字符
/W
匹配所有的字母、数字、下划线以外的字符
/B
匹配非单词边界，即左右两边都是 "/w" 范畴或者左右两边都不是 "/w" 范畴时的字符缝隙
3.3 在表达式中有非凡意义，须要增加 "/" 能力匹配该字符自身的字符汇总
字符
阐明
^
匹配输出字符串的开始地位。要匹配 "^" 字符自身，请应用 "/^"
$
匹配输出字符串的结尾地位。要匹配 "$" 字符自身，请应用 "/$"
( )
标记一个子表达式的开始和完结地位。要匹配小括号，请应用 "/(" 和 "/)"
[ ]
用来自定义可能匹配 '多种字符' 的表达式。要匹配中括号，请应用 "/[" 和 "/]"
{ }
润饰匹配次数的符号。要匹配大括号，请应用 "/{" 和 "/}"
.
匹配除了换行符（/n）以外的任意一个字符。要匹配小数点自身，请应用 "/."
?
润饰匹配次数为 0 次或 1 次。要匹配 "?" 字符自身，请应用 "/?"
+
润饰匹配次数为至多 1 次。要匹配 "+" 字符自身，请应用 "/+"
*
润饰匹配次数为 0 次或任意次。要匹配 "_" 字符自身，请应用 "/_"
|
左右两边表达式之间 "或" 关系。匹配 "|" 自身，请应用 "/|"
3.4 括号 "( )" 内的子表达式，如果心愿匹配后果不进行记录供当前应用，能够应用 "(?:xxxxx)" 格局
举例1：表达式 "(?:(/w)/1)+" 匹配 "a bbccdd efg" 时，后果是 "bbccdd"。括号 "(?:)" 范畴的匹配后果不进行记录，因而 "(/w)" 应用 "/1" 来援用。
3.5 罕用的表达式属性设置简介：Ignorecase，Singleline，Multiline，Global
表达式属性
阐明
Ignorecase
默认状况下，表达式中的字母是要辨别大小写的。配置为 Ignorecase 可使匹配时不辨别大小写。有的表达式引擎，把 "大小写" 概念延长至 UNICODE 范畴的大小写。
Singleline
默认状况下，小数点 "." 匹配除了换行符（/n）以外的字符。配置为 Singleline 可使小数点可匹配包含换行符在内的所有字符。
Multiline
默认状况下，表达式 "^" 和 "$" 只匹配字符串的开始 ① 和结尾 ④ 地位。如： ①xxxxxxxxx②/n ③xxxxxxxxx④ 配置为 Multiline 能够使 "^" 匹配 ① 外，还能够匹配换行符之后，下一行开始前 ③ 的地位，使 "$" 匹配 ④ 外，还能够匹配换行符之前，一行完结 ② 的地位。
Global
次要在将表达式用来替换时起作用，配置为 Global 示意替换所有的匹配。
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 或 "|" 的左右两边，对某个字符最好只有一边能够匹配，这样，不会因为 "|" 两边的表达式因为替换地位而有所不同。
-----------------正则表达式进阶篇（实例）--------------
----喜爱文章且想要学习编程的材料和视频加v【lezijie006】备注暗号965增加支付哦（不备注暗号会被回绝的o）---
1，定义正则表达式
1）定义正则表达式有两种模式，一种是一般形式，一种是构造函数形式。 2）一般形式：var reg=/表达式/附加参数 表达式：一个字符串，代表了某种规定，其中能够应用某些特殊字符，来代表非凡的规定，前面会具体阐明。 附加参数：用来扩大表达式的含意，目前次要有三个参数： g：代表能够进行全局匹配。 i：代表不辨别大小写匹配。 m：代表能够进行多行匹配。 下面三个参数，能够任意组合，代表复合含意，当然也能够不加参数。 例子： var reg=/a_b/; var reg=/abc+f/g; 3）构造函数形式：var reg=new RegExp(“表达式”,”附加参数”); 其中“表达式”与“附加参数”的含意与下面那种定义形式中的含意雷同。 例子： var reg=new RegExp(“a_b”); var reg=new RegExp(“abc+f”,”g”); 4）一般形式与构造函数形式的区别 一般形式中的表达式必须是一个常量字符串，而构造函数中的表达式能够是常量字符串，也能够是一个js变量，例如依据用户的输出来作为表达式参数等等： var reg=new RegExp(document.forms[0].exprfiled.value,”g”);
2，表达式模式
1）表达式模式，是指表达式的表达方式与款式， 即 var reg=/表达式/附加参数 中的“表达式”怎么去形容？ 2）从标准上讲，表达式模式分为简略模式和复合模式。 3）简略模式：是指通过一般字符的组合来表白的模式，例如 var reg=/abc0d/; 可见简略模式只能示意具体的匹配。 4）复合模式：是指含有通配符来表白的模式，例如： var reg=/a+b?/w/; 其中的+、?和/w都属于通配符，代表着非凡的含意。因而复合模式能够表白更为抽象化的逻辑。 上面咱们着重说一下复合模式中各个通配符的含意及其应用。 5)复合模式中特殊字符的解说：
1>/：在许多编程语言外面被用作本义符，一般来说 /符号前面如果跟的是一般字符c，那么/c就代表非凡的含意，例如n原本代表字符n，但/n就代表换行。 /符号前面如果跟的是特殊字符c，那么/c就代表一般字符c，例如/个别用作本义符，但//则调表一般字符/。 Javascript的正则表达式中/的用法与下面雷同，只是不同的编程语言，特殊字符表可能不太一样罢了。
2>^：匹配输出字符串的起始端，如果是多行匹配，即表达式的附加参数中含有m，则也在一个换行符后匹配。 例子：/^B/匹配 “Bab Bc ”中的第一个B 例子2：/^B/gm匹配 “Badd B cdaf B dsfB” 中的第一行第一个B，第三行中的第一个B 3>$：匹配输出字符创的尾端，如果是多行匹配，即表达式的附加参数中含有m，则也在一个换行符前匹配。 与^的用法相同。 例子：/t$/匹配“bat”中的t，然而不匹配“hate”中的t 例子2：/t$/匹配 “tag at bat” 中第一行的最初一个t和第二行的t。
4>_：匹配前一个字符0次或屡次。 例子：/ab_/匹配“dddabbbbc”中的“abbbb”，也匹配“ddda”中的“a”
5>+：匹配前一个字符1次或屡次。 例子：/ab+/匹配“dddabbbbc”中的“abbbb”，但不匹配“ddda” 与前面的{1,}（原型：{n,}）的用法相似
6>?：?的用法比拟非凡，一般来说它用来对前一个字符做0次或1次匹配，然而它有另外两种非凡的用法： 如果紧跟在_、+、?和{ }之后，则示意原始匹配的最小次数匹配，例如： /ba_/原本匹配“bbbaaaa”中的“baaaa”，然而/ba_?/则匹配“bbbaaaa”中的“b”（因为_示意0次或屡次匹配，而加?应该示意起码次数匹配，即0次匹配）。 同理：/ba+?/则匹配“baaaa”中的“ba”。 作为语法结构符号，应用于前置断言中，即前面要说到的x(?=y)和x(?!=y)
7>.：小数点中的“.”号，匹配任何一个独自的字符，然而换行符除外。 规范中总共有哪些字符？请参考：字符集 例如：/a.b/匹配“acbaa”中的“acb”，然而不匹配“abbb”。
8>(x)：示意匹配x(并非特指字符x或者特指一个字符，x示意一个字符串)，而且匹配会被记住，在语法中这种()被称为“capturing parentheses ”，即捕获用的小括号。 匹配会被记住，是因为在表达式提供的函数中，有些函数返回一个数组，该数组会保留所匹配的所有字符串，例如exec()函数。 另外还要留神()中的x被记住的前提是匹配x。 例子1： var regx=/a(b)c/; var rs=regx.exec(“abcddd”); 从下面能够看出,/a(b)c/匹配“abcddd”中的“abc”，因为()的起因，b也会记录下来，因而rs返回的数字内容为： {abc,b} 例子2： var regx=/a(b)c/; var rs=regx.exec(“acbcddd”); rs返回null，因为/a(b)c/不匹配“acbcddd”，所以()中的b不会被记录下来（只管字符串中含有b）
9>(?:x)：匹配x，但不会记住x，这种格局中的()被称为“non-capturing parentheses ”，即非捕获用的小括号。 例子： var regx=/a(?:b)c/; var rs=regx.exec(“abcddd”); 从下面能够看出,/a(?:b)c/匹配“abcddd”中的“abc”，因为(?:)的起因，b不会记录下来，因而rs返回的数字内容为： {abc}
10>X(?=y)：匹配x，仅当前面紧跟着y时。如果合乎匹配，则只有x会被记住，y不会被记住。 例子： var regx=/user(?=name)/; var rs=regx.exec(“The username is Mary”); 后果：匹配胜利，而且rs的值为{user}
11>X(?!y)：匹配x，仅当前面不紧跟着y时。如果合乎匹配，则只有x会被记住，y不会被记住。 例子： var regx=/user(?!name)/; var rs=regx.exec(“The user name is Mary”); 后果：匹配胜利，而且rs的值为{user} 例子2： var regx=//d+(?!/.)/; var rs=regx.exec(“54.235”); 后果：匹配成绩，rs的值为{5}，不匹配54是因为54前面跟着“.”号，当然235也匹配，然而因为exec办法的行为，235不会被返回
12>x|y：匹配x或y。留神如果x和y都匹配上了，那么只记住x。 例子： var regx=/beijing|shanghai/; var rs=regx.exec(“I love beijing and shanghai”); 后果：匹配胜利，rs的值为{beijing}，尽管shanghai也匹配，但不会被记住。
13>{n}：匹配前一个字符的n次呈现。 n必须是一个非正数，当然如果是一个正数或小数也不会报语法错误。 例子： var regx=/ab{2}c/; var rs=regx.exec(“abbcd”); 后果：匹配胜利，rs的值为：{abbc}。
14>{n,}：匹配前一个字符的至多n次呈现。 例子： var regx=/ab{2,}c/; var rs=regx.exec(“abbcdabbbc”); 后果：匹配胜利，rs的值为：{abbc}。留神为什么abbbc也符合条件为什么没有被记住，这与exec办法的行为无关，前面会对立解说。
15>{n,m}：匹配前一个字符的至多n次最多m次的呈现。 只有n与m为数字，而且m>=n就不会报语法错误。 例子： var regx=/ab{2,5}c/; var rs=regx.exec(“abbbcd”); 后果：匹配胜利，rs的值为：{abbbc}。 例子2： var regx=/ab{2,2}c/; var rs=regx.exec(“abbcd”); 后果：匹配胜利，rs的值为：{abbc}。 例子3： var regx=/ab(2,5)/; var rs=regx.exec(“abbbbbbbbbb”); 后果：匹配胜利，rs的值为：{abbbbb}，这阐明，如果前一个字符呈现多于m次，则只匹配m次。另外： var regx=/ab(2,5)c/; var rs=regx.exec(“abbbbbbbbbbc”); 后果：匹配失败，rs的值为：null，为什么匹配失败，因为b多于5个则b(2,5)会匹配前5个b，，而表达式/ab(2,5)c/中b前面是c，但字符串中5个b之后还是b所以会报错。
16>[xyz]：xyz示意一个字符串，该模式示意匹配[]中的一个字符，模式上[xyz]等同于[x-z]。 例子： var regx=/a[bc]d/; var rs=regx.exec(“abddgg”); 后果：匹配胜利，rs的值为：{abd} 例子2： var regx=/a[bc]d/; var rs=regx.exec(“abcd”); 后果：匹配失败，rs的值为：null，之所以失败，是因为[bc]示意匹配b或c中的一个，但不会同时匹配。
17>xyz：该模式示意匹配非[]中的一个字符，模式上xyz等同于x-z。 例子： var regx=/abcd/; var rs=regx.exec(“afddgg”); 后果：匹配胜利，rs的值为：{afd} 例子2： var regx=/abcd/; var rs=regx.exec(“abd”); 后果：匹配失败，rs的值为：。
18>[/b]：匹配退格键。
19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。 例子： var regx=//bc./; var rs=regx.exec(“Beijing is a beautiful city”); 后果：匹配胜利，rs的值为：{ci}，留神c前边的空格不会匹配到后果中，即{ ci}是不正确的。
20>/B：代表一个非单词边界。 例子： var regx=//Bi./; var rs=regx.exec(“Beijing is a beautiful city”); 后果：匹配胜利，rs的值为：{ij}，即匹配了Beijing中的ij。
21>/cX，匹配一个控制字符。例如， /cM 匹配一个 Control-M 或 回车符。 x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一 个原义的 ’c’ 字符。（理论的例子还需补充）
21>/d：匹配一个数字字符，等同于[0-9]。 例子： var regx=/user/d/; var rs=regx.exec(“user1”); 后果：匹配胜利，rs的值为：{user1}
22>/D：匹配一个非数字字符，等同于0-9。 例子： var regx=/user/D/; var rs=regx.exec(“userA”); 后果：匹配胜利，rs的值为：{userA}
23>/f：匹配一个换页符。
24>/n：匹配一个换行符。因为是换行符，所以在表达式中要退出m参数。 例子： var regx=/a/nbc/m; var str=“a bc”; var rs=regx.exec(str); 后果：匹配胜利，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因而在个别的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至多在textarea域中是这样的。 25>/r：匹配一个回车符
26>/s：匹配一个空格符，等同于[ /f/n/r/t/v/u00A0/u2028/u2029]. 例子： var regx=//si/; var rs=regx.exec(“Beijing is a city”); 后果：匹配胜利，rs的值为：{ i}
27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029]. 例子： var regx=//Si/; var rs=regx.exec(“Beijing is a city”); 后果：匹配胜利，rs的值为：{ei}
28>/t：匹配一个tab 例子： var regx=/a/tb/; var rs=regx.exec(“a bc”); 后果：匹配胜利，rs的值为： {a bc}
29>/v：匹配一个竖向的tab
30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。 例子： var regx=//w/; var rs=regx.exec(“$25.23”); 后果：匹配胜利，rs的值为：{2}
31>/W：匹配一个非数字、_或字母表字符，即3。 例子： var regx=//w/; var rs=regx.exec(“$25.23”); 后果：匹配胜利，rs的值为：{$}
32>/n：留神不是/n，这里n是一个正整数，示意匹配第n个()中的字符。 例子： var regx=/user([,-])group/1role/; var rs=regx.exec(“user-group-role”); 后果：匹配胜利，rs的值为：{user-group-role,-}，同样对user,group,role的匹配也是胜利的，但像user-group,role等就不对了。
33>/0：匹配一个NUL字符。
34>/xhh：匹配一个由两位16进制数字所表白的字符。
35>/uhhhh：匹配一个由四位16进制数字所表白的字符。
3，表达式操作
1）表达式操作，在这里是指和表达式相干的办法，咱们将介绍六个办法。 2）表达式对象（RegExp）办法：
1>exec(str)，返回str中与表达式相匹配的第一个字符串，而且以数组的模式体现，当然如果表达式中含有捕获用的小括号，则返回的数组中也可能含有()中的匹配字符串，例如： var regx=//d+/; var rs=regx.exec(“3432ddf53”); 返回的rs值为：{3432} var regx2=new RegExp(“ab(/d+)c”); var rs2=regx2.exec(“ab234c44”); 返回的rs值为：{ab234c,234} 另外，如果有多个适合的匹配，则第一次执行exec返回一个第一个匹配，此时继续执行exec，则顺次返回第二个第三个匹配。例如： var regx=/user/d/g; var rs=regx.exec(“ddduser1dsfuser2dd”); var rs1=regx.exec(“ddduser1dsfuser2dd”); 则rs的值为{user1}，rs的值为{rs2}，当然留神regx中的g参数是必须的，否则无论exec执行多少次，都返回第一个匹配。前面还有相干内容波及到对此设想的解释。
2>test(str)，判断字符串str是否匹配表达式，返回一个布尔值。例如： var regx=/user/d+/g; var flag=regx.test(“user12dd”); flag的值为true。
3）String对象办法
1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，退出参数g则返回所有的匹配 例子： var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.match(regx); rs的值为：{user1,user3}
2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。 例子： var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.search(regx); rs的值为：0
3>replace(expr,str)，将字符串中匹配expr的局部替换为str。另外在replace办法中，str中能够含有一种变量符号$，格局为$n，代表匹配中被记住的第n的匹配字符串（留神小括号能够记忆匹配）。 例子： var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.replace(regx,”00”); rs的值为：003userddd0045 例子2： var regx=/u(se)r/d/g; var str=“user13userddduser345”; var rs=str.replace(regx,”$1”); rs的值为：se3userdddse45 对于replace(expr,str)办法还要特地留神一点，如果expr是一个表达式对象则会进行全局替换（此时表达式必须附加参数g，否则也只是替换第一个匹配），如果expr是一个字符串对象，则只会替换第一个匹配的局部，例如： var regx=“user” var str=“user13userddduser345”; var rs=str.replace(regx,”00”); rs的值为： 0013userddduser345
4>split(expr)，将字符串以匹配expr的局部做宰割，返回一个数组，而且表达式是否附加参数g都没有关系，后果是一样的。 例子： var regx=/user/d/g; var str=“user13userddduser345”; var rs=str.split(regx); rs的值为：{3userddd,45}
4，表达式相干属性
1）表达式相干属性，是指和表达式相干的属性，如上面的模式： var regx=/myexpr/; var rs=regx.exec(str); 其中，和表达式本身regx相干的属性有两个，和表达式匹配后果rs相干的属性有三个，上面将逐个介绍。 2）和表达式本身相干的两个属性：
1>lastIndex，返回开始下一个匹配的地位，留神必须是全局匹配（表达式中带有g参数）时，lastIndex才会有一直返回下一个匹配值，否则该值为总是返回第一个下一个匹配地位，例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var lastIndex1=regx.lastIndex; rs=regx.exec(“sdsfuser1dfsfuser2”); var lastIndex2=regx.lastIndex; rs=regx.exec(“sdsfuser1dfsfuser2”); var lastIndex3=regx.lastIndex; 下面lastIndex1为9，第二个lastIndex2也为9，第三个也是9；如果regx=/user/d/g，则第一个为9，第二个为18，第三个为0。
2>source，返回表达式字符串本身。例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var source=regx.source; source的值为user/d 3）和匹配后果相干的三个属性：
1>index，返回以后匹配的地位。例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var index1=rs.index; rs=regx.exec(“sdsfuser1dfsfuser2”); var index2=rs.index; rs=regx.exec(“sdsfuser1dfsfuser2”); var index3=rs.index; index1为4，index2为4，index3为4，如果表达式退出参数g，则index1为4，index2为13，index3会报错（index为空或不是对象）。
2>input，用于匹配的字符串。例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var input=rs.input; input的值为sdsfuser1dfsfuser2。
3>[0]，返回匹配后果中的第一个匹配值，对于match而言可能返回一个多值的数字，则除了[0]外，还能够取[1]、[2]等等。例如： var regx=/user/d/; var rs=regx.exec(“sdsfuser1dfsfuser2”); var value1=rs[0]; rs=regx.exec(“sdsfuser1dfsfuser2”); var value2=rs[0]; value1的值为user1,value2的值为user2
5，理论利用
1）理论利用一 形容：有一表单，其中有一个“用户名”input域 要求：汉字，而且不能少于2个汉字，不能多于4个汉字。 实现：
2）理论利用二 形容：给定一个含有html标记的字符串，要求将其中的html标记去掉。 实现：
三，小结
1，Javascript正则表达式，我想在个别的程序员之中，使用者应该不是很多，因为咱们解决的页面个别都不是很简单，而简单的逻辑个别咱们都在后盾解决实现了。然而目前趋势曾经呈现了扭转，富客户端曾经被越来越多的人承受，而Javascript就是其中的关键技术，对于简单的客户端逻辑而言，正则表达式的作用也是很要害的，同时它也是Javascript高手必须要把握的重要技术之一。
2，为了可能便于大家对后面讲述的内容有一个更为综合和粗浅的意识，我将后面的一些关键点和容易犯糊涂的中央再零碎总结一下，这部分很要害！
总结1：附件参数g的用法** 表达式加上参数g之后，表明能够进行全局匹配，留神这里“能够”的含意。咱们具体叙述：
1）对于表达式对象的exec办法，不退出g，则只返回第一个匹配，无论执行多少次均是如此，如果退出g，则第一次执行也返回第一个匹配，再执行返回第二个匹配，顺次类推。例如 var regx=/user/d/; var str=“user18dsdfuser2dsfsd”; var rs=regx.exec(str);//此时rs的值为{user1} var rs2=regx.exec(str);//此时rs的值仍然为{user1} 如果regx=/user/d/g；则rs的值为{user1}，rs2的值为{user2} 通过这个例子阐明：对于exec办法，表达式退出了g，并不是说执行exec办法就能够返回所有的匹配，而是说退出了g之后，我能够通过某种形式失去所有的匹配，这里的“形式”对于exec而言，就是顺次执行这个办法即可。
2）对于表达式对象的test办法，退出g于不加上g没有什么区别。
3）对于String对象的match办法，不退出g，也只是返回第一个匹配，始终执行match办法也总是返回第一个匹配，退出g，则一次返回所有的匹配（留神这与表达式对象的exec办法不同，对于exec而言，表达式即便加上了g，也不会一次返回所有的匹配）。例如： var regx=/user/d/; var str=“user1sdfsffuser2dfsdf”; var rs=str.match(regx);//此时rs的值为{user1} var rs2=str.match(regx);//此时rs的值仍然为{user1} 如果regx=/user/d/g，则rs的值为{user1,user2}，rs2的值也为{user1,user2}
4）对于String对象的replace办法，表达式不退出g，则只替换第一个匹配，如果退出g，则替换所有匹配。（结尾的三道测试题能很好的阐明这一点）
5）对于String对象的split办法，加上g与不加g是一样的，即： var sep=/user/d/; var array=“user1dfsfuser2dfsf”.split(sep); 则array的值为{dfsf, dfsf} 此时sep=/user/d/g，返回值是一样的。
6）对于String对象的search办法，加不加g也是一样的。
总结2：
附加参数m的用法 附加参数m，表明能够进行多行匹配，然而这个只有当应用^和$模式时才会起作用，在其余的模式中，加不退出m都能够进行多行匹配（其实说多行的字符串也是一个一般字符串），咱们举例说明这一点
1）应用^的例子 var regx=/^b./g; var str=“bd76 dfsdf sdfsdfs dffs b76dsf sdfsdf”; var rs=str.match(regx); 此时退出g和不退出g，都只返回第一个匹配{bd}，如果regx=/^b./gm，则返回所有的匹配{bd,b7}，留神如果regx=/^b./m，则也只返回第一个匹配。所以，退出m表明能够进行多行匹配，退出g表明能够进行全局匹配，综合到一起就是能够进行多行全局匹配
2）应用其余模式的例子，例如 var regx=/user/d/; var str=“sdfsfsdfsdf sdfsuser3 dffs b76dsf user6”; var rs=str.match(regx); 此时不加参数g，则返回{user3}，退出参数g返回{user3,user6}，加不退出m对此没有影响。
3）因而对于m咱们要分明它的应用，记住它只对^和$模式起作用，在这两种模式中，m的作用为：如果不退出m，则只能在第一行进行匹配，如果退出m则能够在所有的行进行匹配。咱们再看一个^的例子 var regx=/^b./; var str=“ret76 dfsdf bjfsdfs dffs b76dsf sdfsdf”; var rs=str.match(regx); 此时rs的值为null，如果退出g，rs的值依然为null，如果退出m，则rs的值为{bj}（也就是说，在第一行没有找到匹配，因为有参数m，所以能够持续去上面的行去找是否有匹配），如果m和g都加上，则返回{bj,b7}（只加m不加g阐明，能够去多行进行匹配，然而找到一个匹配后就返回，退出g表明将多行中所有的匹配返回，当然对于match办法是如此，对于exec呢，则须要执行屡次能力顺次返回）
总结3：
在HTML的textarea输出域中，按一个Enter键，对应的控制字符为“/r/n”，即“回车换行”，而不是“/n/r”，即“换行回车”，咱们看一个后面咱们举过的例子： var regx=/a/r/nbc/; var str=“a bc”; var rs=regx.exec(str); 后果：匹配胜利，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因而在个别的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至多在textarea域中是这样的。
- abc ↩
- A-F0-3 ↩
- A-Za-z0-9_ ↩