javascript正则表达式基础教
javascript正则表达式基础教
正则表达式
小黑_spring 通过 麦库 发送。 [ 查看 小黑_spring 的共享资料库 ]
javascript正则表达式基础教程
正则表达式是对字符串的结构进行的形式化描述，非常简洁优美，而且功能十分强大。很多的语言都不同程度的支持正则表达式，而在很多的文本编辑器如Emacs，vim，UE中，都支持正则表达式来进行字符串的搜索替换工作。UNIX下的很多命令行程序，如awk，grep，find更是对正则表达式有良好的支持。
JavaScriptJavaScript同样也对正则表达式有很好的支持，RegExp是JavaScript中的内置“类”，通过使用RegExp，用户可以自己定义模式来对字符串进行匹配。而JavaScript中的String对象的replace方法也支持使用正则表达式对串进行匹配，一旦匹配，还可以通过调用预设的回调函数来进行替换。
正则表达式的用途十分广泛，比如在客户端的JavaScript环境中的用户输入验证，判断用户输入的身份证号码是否合法，邮件地址是否合法等。另外，正则表达式可用于查找替换工作，首先应该关注的是正则表达式的基本概念。
关于正则表达式的完整内容完全是另外一个主题了，事实上，已经有很多本专著来解释这个主题，限于篇幅，我们在这里只关注JavaScript中的正则表达式对象。
6.16.1正则表达式基础概念
本节讨论正则表达式中的基本概念，这些基本概念在很多的正则表达式实现中是一致的，当然，细节方面可能会有所不同，毕竟正则表达式是来源于数学定义的，而不是程序员。JavaScriipt的正则表达式对象实现了perl正则表达式规范的一个子集，如果你对perl比较熟悉的话，可以跳过这个小节。脚本语言perl的正则表达式规范是目前广泛采用的一个规范，Java中的regex包就是一个很好的例子，另外，如vim这样的应用程序中，也采用了该规范。
6.1.16.1.1 元字符与特殊字符
元字符，是一些数学符号，在正则表达式中有特定的含义，而不仅仅表示其“字面”上的含义，比如星号(*)，表示一个集合的零到多次重复，而问号(?)表示零次或一次。如果你需要使用元字符的字面意义，则需要转义。
下面是一张元字符的表：
|元字符
|含义
|
|————|————|
|^^
|串的开始
|
|$$
|串的结束
|
|******
|零到多次匹配
|
|++
|一到多次匹配
|
|??
|零或一次匹配
|
|\****bb
|单词边界
|
特殊字符，主要是指注入空格，制表符，其他进制(十进制之外的编码方式)等，它们的特点是以转义字符()为前导。如果需要引用这些特殊字符的字面意义，同样需要转义。
下面为转移字符的一张表：
|字符
|**含义**
|
|————–|————–|
|字符本身
|匹配字符本身
|
|\****rr
|匹配回车
|
|\****nn
|匹配换行
|
|\****tt
|制表符
|
|\****ff
|换页
|
|\****x#x#
|匹配十六进制数
|
|\****cXcX
|匹配控制字符
|
6.1.26.1.2 范围及重复
我们经常会遇到要描述一个范围的例子，比如，从00到3的数字，所有的英文字母，包含数字，英文字母以及下划线等等，正则表达式规定了如何表示范围：
|标志符
|**含义**
|
|————–|———————————-|
|**[[**…]
|在集合中的任一个字符
|
|[^[^****…]
|不在集合中的任一个字符
|
|..
|出\\nn之外的任一个字符
|
|\****ww
|所有的单字，包括字母，数字及下划线
|
|\****WW
|不包括所有的单字，\ww的补集
|
|\****ss
|所有的空白字符，包括空格，制表符
|
|\****SS
|所有的非空白字符
|
|\****dd
|所有的数字
|
|\****DD
|所有的非数字
|
|\****bb
|退格字符
|
结合元字符和范围，我们可以定义出很强大的模式来，比如，一个简化版的匹配Email的正则表达是为：
JsJs****代码
1. 1. varvar emailval = /^[\w-]+(.[\w-]+)@[\w-]+(.[\w-]+)+$/; emailval = /^[\w-]+(.[\w-]+)@[\w-]+(.[\w-]+)+$/;
2. 2.
3. 3. emailval.test(emailval.test(“kmustlinux@hotmail.com“”kmustlinux@hotmail.com“););//true//true
4. 4. emailval.test(emailval.test(“john.abruzzi@pl.kunming.china“”john.abruzzi@pl.kunming.china“););//true//true
5. 5. emailval.test(emailval.test(“@invalid.com””@invalid.com”););//false,//false,不合法
[\w-][\w-]表示所有的字符，数字，下划线及减号，[\w-]+表示这个集合最少重复一次，然后紧接着的这个括号表示一个分组(分组的概念参看下一节)，这个分组的修饰符为星号(*)，表示重复零或多次。这样就可以匹配任意字母，数字，下划线及中划线的集合，且至少重复一次。
而@符号之后的部分与前半部分唯一不同的是，后边的一个分组的修饰符为(+)，表示至少重复一次，那就意味着后半部分至少会有一个点号(.)，而且点号之后至少有一个字符。这个修饰主要是用来限制输入串中必须包含域名。
最后，脱字符(^)和美元符号($)限制，以……开始，且以……结束。这样，整个表达式的意义就很明显了。
再来看一个例子：在C/Java中，变量命名的规则为：以字母或下划线开头，变量中可以包含数字，字母以及下划线(有可能还会规定长度，我们在下一节讨论)。这个规则描述成正则表达式即为下列的定义：
JsJs****代码
1. 1. varvar variable = /[a-zA-Z_][a-zA-Z0-9_]/; variable = /[a-zA-Z_][a-zA-Z0-9_]/;
2. 2.
3. 3. print(variable.test(print(variable.test(“hello””hello”)); ));
4. 4. print(variable.test(print(variable.test(“world””world”)); ));
5. 5. print(variable.test(print(variable.test(“main“”main“)); ));
6. 6. print(variable.test(print(variable.test(“0871””0871”)); ));
将会打印：
**true
true
true
falsetrue
true
true
false**
前三个测试字符均为合法，而最后一个是数字开头，因此为非法。应该注意的是，test方法只是测试目标串中是否有表达式匹配的部分，而不一定整个串都匹配。比如上例中：
print(variable.test(print(variable.test(“0871_hello_world””0871_hello_world”));//true));//true
print(variable.test(print(variable.test(“@main””@main”));//true));//true
同样返回true，这是因为，test在查找整个串时，发现了完整匹配variable表达式的部分内容，同样也是匹配。为了避免这种情况，我们需要给variable做一些修改：
varvar variable =variable = /^[a-zA-Z_][a-zA-Z0-9_]$//^[a-zA-Z_][a-zA-Z0-9_]$/;;
通过加推导(+)，星推导(*)，以及谓词，我们可以灵活的对范围进行重复，但是我们仍然需要一种机制来提供诸如4位数字，最多10个字符等这样的精确的重复方式。这就需要用到下表中的标记：
|标记
|**含义**
|
|——————|———————-|
|**
////校验登录名：只能输入5-205-20个以字母开头、可带数字、“_”“_”、“.”“.”的字串
JavaJava****代码
1. 1. function isRegisterUserName(s) function isRegisterUserName(s)
2. 2. { {
3. 3. var patrn=/^[a-zA-Z]{var patrn=/^[a-zA-Z]{11}([a-zA-Z0-}([a-zA-Z0-99]|[.]){]|[.]){44,,1919}$/; }$/;
4. 4. ifif (!patrn.exec(s)) (!patrn.exec(s)) returnreturn falsefalse
5. 5. returnreturn truetrue
6. 6. } }
////校验用户姓名：只能输入1-301-30个以字母开头的字串
JavaJava****代码
1. 1. function isTrueName(s) function isTrueName(s)
2. 2. { {
3. 3. var patrn=/^[a-zA-Z]{var patrn=/^[a-zA-Z]{11,,3030}$/; }$/;
4. 4. ifif (!patrn.exec(s)) (!patrn.exec(s)) returnreturn falsefalse
5. 5. returnreturn truetrue
6. 6. } }
7. 7. }} }}
8. 8.
9. 9. ////校验密码：只能输入6-206-20个字母、数字、下划线
10. 10. <pre name=<pre name=”code””code” **classclass**==”java””java”>function isPasswd(s) >function isPasswd(s)
11. 11. { {
12. 12. var patrn=/^(\w){var patrn=/^(\w){66,,2020}$/; }$/;
13. 13. ifif (!patrn.exec(s)) (!patrn.exec(s)) returnreturn falsefalse
14. 14. returnreturn truetrue
15. 15. } }
16. 16.
17. 17.
18. 18.
////校验普通电话、传真号码：可以“+”“+”开头，除数字外，可含有“-”“-”
19. 19.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function isTel(s) >function isTel(s)
20. 20. { {
21. 21. //var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?(\d){1,12})+$/;//var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?(\d){1,12})+$/;
22. 22. var patrn=/^[+]{var patrn=/^[+]{00,,11}(\d){}(\d){11,,33}[ ]?([-]?((\d)|[ ]){}[ ]?([-]?((\d)|[ ]){11,,1212})+$/; })+$/;
23. 23. ifif (!patrn.exec(s)) (!patrn.exec(s)) returnreturn falsefalse
24. 24. returnreturn truetrue
25. 25. } }
26. 26.
27. 27.
28. 28.
////校验手机号码：必须以数字开头，除数字外，可含有“-”“-”
29. 29.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function isMobil(s) >function isMobil(s)
30. 30. { {
31. 31. var patrn=/^[+]{var patrn=/^[+]{00,,11}(\d){}(\d){11,,33}[ ]?([-]?((\d)|[ ]){}[ ]?([-]?((\d)|[ ]){11,,1212})+$/; })+$/;
32. 32. ifif (!patrn.exec(s)) (!patrn.exec(s)) returnreturn falsefalse
33. 33. returnreturn truetrue
34. 34. } }
35. 35.
36. 36.
37. 37.
////校验邮政编码
38. 38.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function isPostalCode(s) >function isPostalCode(s)
39. 39. { {
40. 40. //var patrn=/^[a-zA-Z0-9]{3,12}$/;//var patrn=/^[a-zA-Z0-9]{3,12}$/;
41. 41. var patrn=/^[a-zA-Z0-var patrn=/^[a-zA-Z0-99 ]{ ]{33,,1212}$/; }$/;
42. 42. ifif (!patrn.exec(s)) (!patrn.exec(s)) returnreturn falsefalse
43. 43. returnreturn truetrue
44. 44. } }
45. 45.
46. 46.
47. 47.
////校验搜索关键字
48. 48.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function isSearch(s) >function isSearch(s)
49. 49. { {
50. 50. var patrn=/^[^~!@#$%^&*()+=|\\\][\]\{\}:;'\,.<>/?]{var patrn=/^[^!@#$%^&*()+=|\][]{}:;’,.<>/?]{11}[^`!@$%^&()+=|\] }[^`~!@$%^&()+=|\]
51. 51. []{}:;’,.<>?]{ []{}:;’,.<>?]{00,,1919}$/; }$/;
52. 52. ifif (!patrn.exec(s)) (!patrn.exec(s)) returnreturn falsefalse
53. 53. returnreturn truetrue
54. 54. } }
55. 55.
56. 56. function isIP(s) function isIP(s) //by zergling//by zergling
57. 57. { {
58. 58. var patrn=/^[var patrn=/^[00–99.]{.]{11,,2020}$/; }$/;
59. 59. ifif (!patrn.exec(s)) (!patrn.exec(s)) returnreturn falsefalse
60. 60. returnreturn truetrue
61. 61. } }
62. 62.
63. 63.
64. 64.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>>正则表达式
65. 65.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>>”^\d+$””^\d+$” ////非负整数（正整数 + 0 + 0）
66. 66. “^[0-9][1-9][0-9]$””^[0-9][1-9][0-9]$” ////正整数
67. 67. “^((-\d+)|(0+))$””^((-\d+)|(0+))$” ////非正整数（负整数 + 0 + 0）
68. 68. “^-[0-9][1-9][0-9]$””^-[0-9][1-9][0-9]$” ////负整数
69. 69. “^-?\d+$””^-?\d+$” ////整数
70. 70. “^\d+(\.\d+)?$””^\d+(\.\d+)?$” ////非负浮点数（正浮点数 + 0 + 0）
71. 71. “^(([0-9]+\.[0-9][1-9][0-9])|([0-9][1-9][0-9]\.[0-9]+)|([0-9][1-9][0-9]))$””^(([0-9]+\.[0-9][1-9][0-9])|([0-9][1-9][0-9]\.[0-9]+)|([0-9][1-9][0-9]))$”
72. 72. ////正浮点数
73. 73. “^((-\d+(\.\d+)?)|(0+(\.0+)?))$””^((-\d+(\.\d+)?)|(0+(\.0+)?))$” ////非正浮点数（负浮点数 + 0 + 0）
74. 74. “^(-(([0-9]+\.[0-9][1-9][0-9])|([0-9][1-9][0-9]\.[0-9]+)|([0-9][1-9][0-9])))$””^(-(([0-9]+\.[0-9][1-9][0-9])|([0-9][1-9][0-9]\.[0-9]+)|([0-9][1-9][0-9])))$”
75. 75. ////负浮点数
76. 76. “^(-?\d+)(\.\d+)?$””^(-?\d+)(\.\d+)?$” ////浮点数
77. 77. “^[A-Za-z]+$””^[A-Za-z]+$” ////由2626个英文字母组成的字符串
78. 78. “^[A-Z]+$””^[A-Z]+$” ////由2626个英文字母的大写组成的字符串
79. 79. “^[a-z]+$””^[a-z]+$” ////由2626个英文字母的小写组成的字符串
80. 80. “^[A-Za-z0-9]+$””^[A-Za-z0-9]+$” ////由数字和2626个英文字母组成的字符串
81. 81. “^\w+$””^\w+$” ////由数字、2626个英文字母或者下划线组成的字符串
82. 82. “^[\w-]+(\.[\w-]+)@[\w-]+(\.[\w-]+)+$””^[\w-]+(\.[\w-]+)@[\w-]+(\.[\w-]+)+$” //email//email地址
83. 83. “^[a-zA-z]+://(\w+(-\w+))(\.(\w+(-\w+)))(\?\S)?$””^[a-zA-z]+://(\w+(-\w+))(\.(\w+(-\w+)))(\?\S)?$” //url //url
84. 84. “^[A-Za-z0-9_]$””^[A-Za-z0-9_]$”
85. 85.
86. 86.
87. 87.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>>正则表达式使用详解
88. 88.
89. 89.
简介
90. 90.
91. 91.
简单的说，正则表达式是一种可以用于模式匹配和替换的强有力的工具。其作用如下：
92. 92.
测试字符串的某个模式。例如，可以对一个输入字符串进行测试，看在该字符串是否存在一个电话号码模式或一个信用卡号码模式。这称为数据有效性验证。
93. 93.
替换文本。可以在文档中使用一个正则表达式来标识特定文字，然后可以全部将其删除，或者替换为别的文字。
94. 94.
根据模式匹配从字符串中提取一个子字符串。可以用来在文本或输入字段中查找特定文字。
95. 95.
96. 96.
基本语法
97. 97.
98. 98.
在对正则表达式的功能和作用有了初步的了解之后，我们就来具体看一下正则表达式的语法格式。
99. 99.
100. 100.
正则表达式的形式一般如下：
101. 101.
102. 102.
/love/
/love/ 其中位于“/”“/”定界符之间的部分就是将要在目标对象中进行匹配的模式。用户只要把希望查找匹配对象的模式内容放入“/”“/”定界符之间即可。为了能够使用户更加灵活的定制模式内容，正则表达式提供了专门的““元字符””。所谓元字符就是指那些在正则表达式中具有特殊意义的专用字符，可以用来规定其前导字符（即位于元字符前面的字符）在目标对象中的出现模式。
103. 103.
较为常用的元字符包括： “+” “+”， “” “”，以及 “?” “?”。
104. 104.
105. 105.
“+”
“+”元字符规定其前导字符必须在目标对象中连续出现一次或多次。
106. 106.
107. 107.
“”
“”元字符规定其前导字符必须在目标对象中出现零次或连续多次。
108. 108.
109. 109.
“?”
“?”元字符规定其前导对象必须在目标对象中连续出现零次或一次。
110. 110.
111. 111.
下面，就让我们来看一下正则表达式元字符的具体应用。
112. 112.
113. 113.
/fo+/
/fo+/ 因为上述正则表达式中包含“+”“+”元字符，表示可以与目标对象中的 “fool”, “fo”, “fool”, “fo”, 或者 “football” “football”等在字母ff后面连续出现一个或多个字母oo的字符串相匹配。
114. 114.
115. 115.
/eg*/
/eg*/ 因为上述正则表达式中包含“”“”元字符，表示可以与目标对象中的 “easy”, “ego”, “easy”, “ego”, 或者 “egg” “egg”等在字母ee后面连续出现零个或多个字母gg的字符串相匹配。
116. 116.
117. 117.
/Wil?/
/Wil?/ 因为上述正则表达式中包含““？””元字符，表示可以与目标对象中的 “Win”, “Win”, 或者“Wilson”,“Wilson”,等在字母ii后面连续出现零个或一个字母ll的字符串相匹配。
118. 118.
119. 119.
有时候不知道要匹配多少字符。为了能适应这种不确定性，正则表达式支持限定符的概念。这些限定符可以指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。
120. 120.
121. 121.
{n} n
{n} n 是一个非负整数。匹配确定的 n n 次。例如，’o{2}’’o{2}’ 不能匹配 “Bob””Bob” 中的 ‘o’’o’，但是能匹配 “food””food” 中的两个 o o。
122. 122.
123. 123.
{n,} n
{n,} n 是一个非负整数。至少匹配 n n 次。例如，’o{2,}’’o{2,}’ 不能匹配 “Bob””Bob” 中的 ‘o’’o’，但能匹配 “foooood””foooood” 中的所有 o o。’o{1,}’’o{1,}’ 等价于 ‘o+’’o+’。’o{0,}’’o{0,}’ 则等价于 ‘o*’’o*’。
124. 124.
125. 125.
{n,m} m
{n,m} m 和 n n 均为非负整数，其中n <= mn <= m。最少匹配 n n 次且最多匹配 m m 次。例如，”o{1,3}””o{1,3}” 将匹配 “fooooood””fooooood” 中的前三个 o o。’o{0,1}’’o{0,1}’ 等价于 ‘o?’’o?’。请注意在逗号和两个数之间不能有空格。
126. 126.
127. 127.
除了元字符之外，用户还可以精确指定模式在匹配对象中出现的频率。例如，/jim {/jim {22,,66}/ }/ 上述正则表达式规定字符mm可以在匹配对象中连续出现22–66次，因此，上述正则表达式可以同jimmyjimmy或jimmmmmyjimmmmmy等字符串相匹配。
128. 128.
在对如何使用正则表达式有了初步了解之后，我们来看一下其它几个重要的元字符的使用方式。
129. 129.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>\s>\s：用于匹配单个空格符，包括tabtab键和换行符；
130. 130. \S\S：用于匹配除单个空格符之外的所有字符；
131. 131. \d\d：用于匹配从00到99的数字；
132. 132. \w\w：用于匹配字母，数字或下划线字符；
133. 133. \W\W：用于匹配所有与\w\w不匹配的字符；
134. 134. . . ：用于匹配除换行符之外的所有字符。
135. 135.
136. 136.
（说明：我们可以把\s\s和\S\S以及\w\w和\W\W看作互为逆运算）
137. 137.
下面，我们就通过实例看一下如何在正则表达式中使用上述元字符。
138. 138.
/\s+/
/\s+/ 上述正则表达式可以用于匹配目标对象中的一个或多个空格字符。
139. 139.
/\d000/
/\d000/ 如果我们手中有一份复杂的财务报表，那么我们可以通过上述正则表达式轻而易举的查找到所有总额达千元的款项。
140. 140.
除了我们以上所介绍的元字符之外，正则表达式中还具有另外一种较为独特的专用字符，即定位符。定位符用于规定匹配模式在目标对象中的出现位置。 较为常用的定位符包括： “^”, “$”, “\b” “^”, “$”, “\b” 以及 “\B” “\B”。
141. 141.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>“^”>“^”定位符规定匹配模式必须出现在目标字符串的开头
142. 142. “$”“$”定位符规定匹配模式必须出现在目标对象的结尾
143. 143. “\b”“\b”定位符规定匹配模式必须出现在目标字符串的开头或结尾的两个边界之一
144. 144. “\B”“\B”定位符则规定匹配对象必须位于目标字符串的开头和结尾两个边界之内，
145. 145. 即匹配对象既不能作为目标字符串的开头，也不能作为目标字符串的结尾。
146. 146.
147. 147.
同样，我们也可以把“^”“^”和“$”“$”以及“\b”“\b”和“\B”“\B”看作是互为逆运算的两组定位符。举例来说： /^hell/ /^hell/ 因为上述正则表达式中包含“^”“^”定位符，所以可以与目标对象中以 “hell”, “hello” “hell”, “hello”或“hellhound”“hellhound”开头的字符串相匹配。 /ar$/ /ar$/ 因为上述正则表达式中包含“$”“$”定位符，所以可以与目标对象中以 “car”, “bar” “car”, “bar”或 “ar” “ar” 结尾的字符串相匹配。 /\bbom/ /\bbom/ 因为上述正则表达式模式以“\b”“\b”定位符开头，所以可以与目标对象中以 “bomb”, “bomb”, 或 “bom” “bom”开头的字符串相匹配。/man\b//man\b/ 因为上述正则表达式模式以“\b”“\b”定位符结尾，所以可以与目标对象中以 “human”, “woman” “human”, “woman”或 “man” “man”结尾的字符串相匹配。
148. 148.
为了能够方便用户更加灵活的设定匹配模式，正则表达式允许使用者在匹配模式中指定某一个范围而不局限于具体的字符。例如：
149. 149.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>/[A-Z]/>/[A-Z]/ 上述正则表达式将会与从AA到ZZ范围内任何一个大写字母相匹配。
150. 150. /[a-z]//[a-z]/ 上述正则表达式将会与从aa到zz范围内任何一个小写字母相匹配。
151. 151. /[/[00–99]/ ]/ 上述正则表达式将会与从00到99范围内任何一个数字相匹配。
152. 152. /([a-z][A-Z][/([a-z][A-Z][00–99])+/])+/ 上述正则表达式将会与任何由字母和数字组成的字符串，如 “aB0” “aB0” 等相匹配。
153. 153.
154. 154.
这里需要提醒用户注意的一点就是可以在正则表达式中使用 “()” “()” 把字符串组合在一起。“()”“()”符号包含的内容必须同时出现在目标对象中。因此，上述正则表达式将无法与诸如 “abc” “abc”等的字符串匹配，因为“abc”“abc”中的最后一个字符为字母而非数字。
155. 155.
如果我们希望在正则表达式中实现类似编程逻辑中的““或””运算，在多个不同的模式中任选一个进行匹配的话，可以使用管道符 “|” “|”。例如：/to|too|/to|too|22// 上述正则表达式将会与目标对象中的 “to”, “too”, “to”, “too”, 或 “ “22” ” 相匹配。
156. 156.
正则表达式中还有一个较为常用的运算符，即否定符 “[^]” “[^]”。与我们前文所介绍的定位符 “^” “^” 不同，否定符 “[^]” “[^]”规定目标对象中不能存在模式中所规定的字符串。例如：/[^A-C]//[^A-C]/ 上述字符串将会与目标对象中除AA，BB，和CC之外的任何字符相匹配。一般来说，当“^”“^”出现在 “[]” “[]”内时就被视做否定运算符；而当“^”“^”位于“[]”“[]”之外，或没有“[]”“[]”时，则应当被视做定位符。
157. 157.
最后，当用户需要在正则表达式的模式中加入元字符，并查找其匹配对象时，可以使用转义符“\”“\”。例如：/Th*/ /Th*/ 上述正则表达式将会与目标对象中的“Th”“Th”而非“The”“The”等相匹配。
158. 158.
在构造正则表达式之后，就可以象数学表达式一样来求值，也就是说，可以从左至右并按照一个优先级顺序来求值。优先级如下：
159. 159.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>>11．\ \ 转义符
160. 160. 22．(), (?:), (?=), [] (), (?:), (?=), [] 圆括号和方括号
161. 161. 33．*, +, ?, {n}, {n,}, {n,m} *, +, ?, {n}, {n,}, {n,m} 限定符
162. 162. 44．^, $, \anymetacharacter ^, $, \anymetacharacter 位置和顺序
163. 163. 55．|“|“或””操作
164. 164.
165. 165.
166. 166.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>>使用实例
167. 167.
在JavaScript JavaScript 1.21.2中带有一个功能强大的RegExp()RegExp()对象，可以用来进行正则表达式的匹配操作。其中的test()test()方法可以检验目标对象中是否包含匹配模式，并相应的返回truetrue或falsefalse。
168. 168.
我们可以使用JavaScriptJavaScript编写以下脚本，验证用户输入的邮件地址的有效性。
169. 169.
<pre name=
<pre name=”code””code” **classclass**==”java””java”> >
170. 170.
171. 171. <script language= <script language=”Javascript1.2””Javascript1.2”> >
172. 172. <!– start hiding <!– start hiding
173. 173. function verifyAddress(obj) function verifyAddress(obj)
174. 174. { {
175. 175. var email = obj.email.value; var email = obj.email.value;
176. 176. var pattern = var pattern =
177. 177. /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(.[a-zA-Z0-9_-])+/; /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(.[a-zA-Z0-9_-])+/;
178. 178. flag = pattern.test(email); flag = pattern.test(email);
179. 179. ifif(flag) (flag)
180. 180. { {
181. 181. alert(“Your email address is correct!”); alert(“Your email address is correct!”);
182. 182. returnreturn truetrue; ;
183. 183. } }
184. 184. elseelse
185. 185. { {
186. 186. alert(“Please alert(“Please trytry again!”); again!”);
187. 187. returnreturn falsefalse; ;
188. 188. } }
189. 189. } }
190. 190. // stop hiding –> // stop hiding –>
191. 191.
192. 192.
193. 193.
194. 194. <form onSubmit= <form onSubmit=”return verifyAddress(this);””return verifyAddress(this);”> >
195. 195. <input name= <input name=”email””email” type= type=”text””text”> >
196. 196. <input type= <input type=”submit””submit”> >
197. 197.
198. 198.
199. 199.
200. 200.
201. 201.
202. 202.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>>正则表达式对象
203. 203.
本对象包含正则表达式模式以及表明如何应用模式的标志。
204. 204.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>>语法 11 re = /pattern/[flags] re = /pattern/[flags]
205. 205. 语法 22 re = re = newnew RegExp( RegExp(“pattern””pattern”,[,[“flags””flags”]) ])
206. 206.
207. 207.
参数
208. 208.
re
re
209. 209.
必选项。将要赋值为正则表达式模式的变量名。
210. 210.
211. 211.
Pattern
Pattern
212. 212.
必选项。要使用的正则表达式模式。如果使用语法 11，用 “/“”/“ 字符分隔模式。如果用语法 22，用引号将模式引起来。
213. 213.
214. 214.
Flags
Flags
215. 215.
可选项。如果使用语法 22 要用引号将 flag flag 引起来。标志可以组合使用，可用的有：
216. 216.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>g >g （全文查找出现的所有 pattern pattern）
217. 217. i i （忽略大小写）
218. 218. m m （多行查找）
219. 219.
220. 220.
221. 221.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>>示例
222. 222.
下面的示例创建一个包含正则表达式模式及相关标志的对象(re)(re)，向您演示正则表达式对象的用法。在本例中，作为结果的正则表达式对象又用于 match match 方法中：
223. 223.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function MatchDemo() >function MatchDemo()
224. 224. { {
225. 225. var r, re; var r, re; // // 声明变量。
226. 226. var s = var s = “The rain in Spain falls mainly in the plain””The rain in Spain falls mainly in the plain”; ;
227. 227. re = re = newnew RegExp( RegExp(“ain””ain”,,”g””g”); ); // // 创建正则表达式对象。
228. 228. r = s.match(re); r = s.match(re); // // 在字符串 s s 中查找匹配。
229. 229. returnreturn(r); (r);
230. 230. } }
231. 231.
232. 232.
233. 233.
返回值： ain,ain,ain,ain\ ain,ain,ain,ain\
234. 234.
属性 lastIndex lastIndex 属性 | source | source 属性\ \
235. 235.
方法 compile compile 方法 | exec | exec 方法 | test | test 方法\ \
236. 236.
要求 版本 33\ \
237. 237.
请参阅 RegExp RegExp 对象 | | 正则表达式语法 | String | String 对象\ \
238. 238.
239. 239.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>exec >exec 方法
240. 240.
用正则表达式模式在字符串中运行查找，并返回包含该查找结果的一个数组。
241. 241.
rgExp.exec(str)
rgExp.exec(str)
242. 242.
243. 243.
参数
244. 244.
245. 245.
rgExp
rgExp
246. 246.
必选项。包含正则表达式模式和可用标志的正则表达式对象。
247. 247.
248. 248.
str
str
249. 249.
必选项。要在其中执行查找的 String String 对象或字符串文字。
250. 250.
251. 251.
说明\ \
252. 252.
如果 exec exec 方法没有找到匹配，则它返回 nullnull。如果它找到匹配，则 exec exec 方法返回一个数组，并且更新全局 RegExp RegExp 对象的属性，以反映匹配结果。数组的00元素包含了完整的匹配，而第11到nn元素中包含的是匹配中出现的任意一个子匹配。这相当于没有设置全局标志 (g) (g) 的 match match 方法。
253. 253.
如果为正则表达式设置了全局标志，exec exec 从以 lastIndex lastIndex 的值指示的位置开始查找。如果没有设置全局标志，exec exec 忽略 lastIndex lastIndex 的值，从字符串的起始位置开始搜索。
254. 254.
255. 255.
exec
exec 方法返回的数组有三个属性，分别是 input input、index index 和 lastIndex lastIndex。Input Input 属性包含了整个被查找的字符串。Index Index 属性中包含了整个被查找字符串中被匹配的子字符串的位置。LastIndex LastIndex 属性中包含了匹配中最后一个字符的下一个位置。
256. 256.
257. 257.
示例\ \
258. 258.
下面的例子举例说明了 exec exec 方法的用法：
259. 259.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function RegExpTest() >function RegExpTest()
260. 260. { {
261. 261. var ver = Number(ScriptEngineMajorVersion() + var ver = Number(ScriptEngineMajorVersion() + “.””.” + ScriptEngineMinorVersion()) + ScriptEngineMinorVersion())
262. 262. ifif (ver >= (ver >= 5.55.5){ ){ // // 测试 JScript JScript 的版本。
263. 263. var src = var src = “The rain in Spain falls mainly in the plain.””The rain in Spain falls mainly in the plain.”; ;
264. 264. var re = /\w+/g; var re = /\w+/g; // // 创建正则表达式模式。
265. 265. var arr; var arr;
266. 266. whilewhile ((arr = re.exec(src)) != ((arr = re.exec(src)) != nullnull) )
267. 267. document.write(arr.index + document.write(arr.index + “-“”-“ + arr.lastIndex + arr + + arr.lastIndex + arr + “\t””\t”); );
268. 268. } }
269. 269. elseelse{ {
270. 270. alert(alert(“”请使用 JScript JScript 的更新版本””); );
271. 271. } }
272. 272. } }
273. 273.
274. 274.
275. 275.
返回值：00-3The -3The 44-8rain -8rain 99-11in -11in 1212-17Spain -17Spain 1818-23falls -23falls 2424-30mainly -30mainly 3131-33in -33in 3434-37the -37the 3838-43plain -43plain
276. 276.
277. 277.
test
test 方法\ \
278. 278.
返回一个 Boolean Boolean 值，它指出在被查找的字符串中是否存在模式。
279. 279.
rgexp.test(str)
rgexp.test(str)
280. 280.
281. 281.
参数\ \
282. 282.
rgexp
rgexp
283. 283.
必选项。包含正则表达式模式或可用标志的正则表达式对象。
284. 284.
285. 285.
str
str
286. 286.
必选项。要在其上测试查找的字符串。
287. 287.
288. 288.
说明
289. 289.
test
test 方法检查在字符串中是否存在一个模式，如果存在则返回 truetrue，否则就返回 falsefalse。
290. 290.
全局 RegExp RegExp 对象的属性不由 test test 方法来修改。
291. 291.
292. 292.
示例
293. 293.
下面的例子举例说明了 test test 方法的用法：
294. 294.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function TestDemo(re, s) >function TestDemo(re, s)
295. 295. { {
296. 296. var s1; var s1; // // 声明变量。
297. 297. // // 检查字符串是否存在正则表达式。
298. 298. ifif (re.test(s)) (re.test(s)) // // 测试是否存在。
299. 299. s1 = s1 = “ contains “” contains “; ; // s // s 包含模式。
300. 300. elseelse
301. 301. s1 = s1 = “ does not contain “” does not contain “; ; // s // s 不包含模式。
302. 302. returnreturn((“‘“”‘“ + s + + s + “‘“”‘“ + s1 + + s1 + “‘“”‘“+ re.source + + re.source + “‘“”‘“); ); // // 返回字符串。
303. 303. } }
304. 304.
305. 305.
306. 306.
函数调用：document.write (TestDemo(/ain+/ ,document.write (TestDemo(/ain+/ ,”The rain in Spain falls mainly in the plain.””The rain in Spain falls mainly in the plain.”)); ));
307. 307.
308. 308.
返回值：’The rain in Spain falls mainly in the plain.’’The rain in Spain falls mainly in the plain.’ contains contains ‘ain+’’ain+’
309. 309.
310. 310.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>match >match 方法
311. 311.
使用正则表达式模式对字符串执行查找，并将包含查找的结果作为数组返回。\ \
312. 312.
stringObj.match(rgExp)
stringObj.match(rgExp)
313. 313.
314. 314.
参数\ \
315. 315.
stringObj
stringObj
316. 316.
必选项。对其进行查找的 String String 对象或字符串文字。
317. 317.
318. 318.
rgExp
rgExp
319. 319.
必选项。为包含正则表达式模式和可用标志的正则表达式对象。也可以是包含正则表达式模式和可用标志的变量名或字符串文字。
320. 320.
321. 321.
说明\ \
322. 322.
如果 match match 方法没有找到匹配，返回 nullnull。如果找到匹配返回一个数组并且更新全局 RegExp RegExp 对象的属性以反映匹配结果。
323. 323.
match
match 方法返回的数组有三个属性：inputinput、index index 和 lastIndex lastIndex。Input Input 属性包含整个的被查找字符串。Index Index 属性包含了在整个被查找字符串中匹配的子字符串的位置。LastIndex LastIndex 属性包含了最后一次匹配中最后一个字符的下一个位置。
324. 324.
如果没有设置全局标志 (g) (g)，数组的 00 元素包含整个匹配，而第 11 到 n n 元素包含了匹配中曾出现过的任一个子匹配。这相当于没有设置全局标志的 exec exec 方法。如果设置了全局标志，元素 00 到 n n 中包含所有匹配。
325. 325.
326. 326.
示例\ \
327. 327.
下面的示例演示了match match 方法的用法：
328. 328.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function MatchDemo() >function MatchDemo()
329. 329. { {
330. 330. var r, re; var r, re; // // 声明变量。
331. 331. var s = var s = “The rain in Spain falls mainly in the plain””The rain in Spain falls mainly in the plain”; ;
332. 332. re = /ain/i; re = /ain/i; // // 创建正则表达式模式。
333. 333. r = s.match(re); r = s.match(re); // // 尝试匹配搜索字符串。
334. 334. returnreturn(r); (r); // // 返回第一次出现 “ain” “ain” 的地方。
335. 335. } }
336. 336.
337. 337.
返回值：ain ain
338. 338.
339. 339.
本示例说明带 g g 标志设置的 match match 方法的用法。
340. 340.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function MatchDemo() >function MatchDemo()
341. 341. { {
342. 342. var r, re; var r, re; // // 声明变量。
343. 343. var s = var s = “The rain in Spain falls mainly in the plain””The rain in Spain falls mainly in the plain”; ;
344. 344. re = /ain/ig; re = /ain/ig; // // 创建正则表达式模式。
345. 345. r = s.match(re); r = s.match(re); // // 尝试去匹配搜索字符串。
346. 346. returnreturn(r); (r); // // 返回的数组包含了所有 “ain” “ain”
347. 347. // // 出现的四个匹配。
348. 348. } }
349. 349.
350. 350.
返回值：ain,ain,ain,ain ain,ain,ain,ain
351. 351.
352. 352.
上面几行代码演示了字符串文字的 match match 方法的用法。
353. 353.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>var r, re = >var r, re = “Spain””Spain”; ;
354. 354. r = r = “The rain in Spain””The rain in Spain”.replace(re, .replace(re, “Canada””Canada”); );
355. 355. returnreturn r; r;
356. 356.
357. 357.
返回值：The rain in Canada The rain in Canada
358. 358.
359. 359.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>search >search 方法
360. 360.
返回与正则表达式查找内容匹配的第一个子字符串的位置。
361. 361.
362. 362.
stringObj.search(rgExp)
stringObj.search(rgExp)
363. 363.
364. 364.
参数\ \
365. 365.
stringObj
stringObj
366. 366.
必选项。要在其上进行查找的 String String 对象或字符串文字。
367. 367.
368. 368.
rgExp
rgExp
369. 369.
必选项。包含正则表达式模式和可用标志的正则表达式对象。
370. 370.
371. 371.
说明
372. 372.
373. 373.
search
search 方法指明是否存在相应的匹配。如果找到一个匹配，search search 方法将返回一个整数值，指明这个匹配距离字符串开始的偏移位置。如果没有找到匹配，则返回 - -11。
374. 374.
375. 375.
示例\ \
376. 376.
下面的示例演示了 search search 方法的用法。
377. 377.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>function SearchDemo() >function SearchDemo()
378. 378. { {
379. 379. var r, re; var r, re; // // 声明变量。
380. 380. var s = var s = “The rain in Spain falls mainly in the plain.””The rain in Spain falls mainly in the plain.”; ;
381. 381. re = /falls/i; re = /falls/i; // // 创建正则表达式模式。
382. 382. r = s.search(re); r = s.search(re); // // 查找字符串。
383. 383. returnreturn(r); (r); // // 返回 Boolean Boolean 结果。
384. 384. } }
385. 385.
386. 386.
返回值：1818
387. 387.
388. 388.
389. 389.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>>正则表达式语法
390. 390.
一个正则表达式就是由普通字符（例如字符 a a 到 z z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
391. 391.
392. 392.
这里有一些可能会遇到的正则表达式示例：
393. 393.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>JScript VBScript >JScript VBScript 匹配
394. 394. /^[ \t]$/ /^[ \t]$/ “^[ \t]$””^[ \t]$” 匹配一个空白行。
395. 395. /\d{/\d{22}-\d{}-\d{55}/ }/ “\d{2}-\d{5}””\d{2}-\d{5}” 验证一个ID ID 号码是否由一个22位数字，一个连字符以及一个55位数字组成。
396. 396. /<(.)>.<//<(.)>.</\11>/ >/ “<(.)>.</\1>””<(.)>.</\1>” 匹配一个 HTML HTML 标记。
397. 397.
398. 398.
399. 399.
下表是元字符及其在正则表达式上下文中的行为的一个完整列表：
400. 400.
401. 401.
字符 描述
402. 402.
\
\ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 后向引用、或一个八进制转义符。例如，’n’’n’ 匹配字符 “n””n”。’\n’’\n’ 匹配一个换行符。序列 ‘\‘’\‘ 匹配 “" “" 而 “ “((“ “ 则匹配 “ “(“(“。
403. 403.
404. 404.
^
^ 匹配输入字符串的开始位置。如果设置了 RegExp RegExp 对象的 Multiline Multiline 属性，^ ^ 也匹配 ‘\n’’\n’ 或 ‘\r’’\r’ 之后的位置。
405. 405.
406. 406.
$
$ 匹配输入字符串的结束位置。如果设置了RegExp RegExp 对象的 Multiline Multiline 属性，$ $ 也匹配 ‘\n’’\n’ 或 ‘\r’’\r’ 之前的位置。
407. 407.
408. 408.
*
* 匹配前面的子表达式零次或多次。例如，zo* zo* 能匹配 “z””z” 以及 “zoo””zoo”。 * * 等价于。
413. 413.
414. 414.
{n} n
{n} n 是一个非负整数。匹配确定的 n n 次。例如，’o{2}’’o{2}’ 不能匹配 “Bob””Bob” 中的 ‘o’’o’，但是能匹配 “food””food” 中的两个 o o。
415. 415.
416. 416.
{n,} n
{n,} n 是一个非负整数。至少匹配n n 次。例如，’o{2,}’’o{2,}’ 不能匹配 “Bob””Bob” 中的 ‘o’’o’，但能匹配 “foooood””foooood” 中的所有 o o。’o{1,}’’o{1,}’ 等价于 ‘o+’’o+’。’o{0,}’’o{0,}’ 则等价于 ‘o*’’o*’。
417. 417.
418. 418.
{n,m} m
{n,m} m 和 n n 均为非负整数，其中n <= mn <= m。最少匹配 n n 次且最多匹配 m m 次。刘， “o{1,3}””o{1,3}” 将匹配 “fooooood””fooooood” 中的前三个 o o。’o{0,1}’’o{0,1}’ 等价于 ‘o?’’o?’。请注意在逗号和两个数之间不能有空格。
419. 419.
420. 420.
?
? 当该字符紧跟在任何一个其他限制符 (, +, ?, {n}, {n,}, {n,m}) (, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 “oooo””oooo”，’o+?’’o+?’ 将匹配单个 “o””o”，而 ‘o+’’o+’ 将匹配所有 ‘o’’o’。
421. 421.
422. 422.
.
. 匹配除 “\n””\n” 之外的任何单个字符。要匹配包括 ‘\n’’\n’ 在内的任何字符，请使用象 ‘[.\n]’’[.\n]’ 的模式。
423. 423.
(pattern)
(pattern) 匹配pattern pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches Matches 集合得到，在VBScript VBScript 中使用 SubMatches SubMatches 集合，在JScript JScript 中则使用 $ $00…$…$99 属性。要匹配圆括号字符，请使用 ‘(‘’(‘ 或 ‘)‘’)‘。
424. 424.
425. 425.
(?:pattern)
(?:pattern) 匹配 pattern pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 “”或”” 字符 (|) (|) 来组合一个模式的各个部分是很有用。例如， ‘industr(?:y|ies) ‘industr(?:y|ies) 就是一个比 ‘ ‘industry|industries’ industry|industries’ 更简略的表达式。
426. 426.
427. 427.
(?=pattern)
(?=pattern) 正向预查，在任何匹配 pattern pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如， ‘Windows (?=95|98|NT|2000)’’Windows (?=95|98|NT|2000)’ 能匹配 “Windows 2000””Windows 2000” 中的 “Windows””Windows” ，但不能匹配 “Windows 3.1””Windows 3.1” 中的 “Windows””Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
428. 428.
429. 429.
(?!pattern)
(?!pattern) 负向预查，在任何不匹配Negative lookahead matches the search string at any point where a string not matching pattern Negative lookahead matches the search string at any point where a string not matching pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如’Windows (?!95|98|NT|2000)’’Windows (?!95|98|NT|2000)’ 能匹配 “Windows 3.1””Windows 3.1” 中的 “Windows””Windows”，但不能匹配 “Windows 2000””Windows 2000” 中的 “Windows””Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
430. 430.
431. 431.
x|y
x|y 匹配 x x 或 y y。例如，’z|food’’z|food’ 能匹配 “z””z” 或 “food””food”。’(z|f)ood’’(z|f)ood’ 则匹配 “zood””zood” 或 “food””food”。
432. 432.
433. 433.
[xyz]
[xyz] 字符集合。匹配所包含的任意一个字符。例如， ‘[abc]’’[abc]’ 可以匹配 “plain””plain” 中的 ‘a’’a’。
434. 434.
435. 435.
[^xyz]
[^xyz] 负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]’’[^abc]’ 可以匹配 “plain””plain” 中的’p’’p’。
436. 436.
437. 437.
[a-z]
[a-z] 字符范围。匹配指定范围内的任意字符。例如，’[a-z]’’[a-z]’ 可以匹配 ‘a’’a’ 到 ‘z’’z’ 范围内的任意小写字母字符。
438. 438.
439. 439.
[^a-z]
[^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。例如，’[^a-z]’’[^a-z]’ 可以匹配任何不在 ‘a’’a’ 到 ‘z’’z’ 范围内的任意字符。
440. 440.
441. 441.
\b
\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’’er\b’ 可以匹配”never””never” 中的 ‘er’’er’，但不能匹配 “verb””verb” 中的 ‘er’’er’。
442. 442.
443. 443.
\B
\B 匹配非单词边界。’er\B’’er\B’ 能匹配 “verb””verb” 中的 ‘er’’er’，但不能匹配 “never””never” 中的 ‘er’’er’。
444. 444.
445. 445.
\cx
\cx 匹配由xx指明的控制字符。例如， \cM \cM 匹配一个 Control-M Control-M 或回车符。 x x 的值必须为 A-Z A-Z 或 a-z a-z 之一。否则，将 c c 视为一个原义的 ‘c’’c’ 字符。
446. 446.
447. 447.
\d
\d 匹配一个数字字符。等价于 [ [00–99]]。
448. 448.
449. 449.
\D
\D 匹配一个非数字字符。等价于 [^ [^00–99]]。
450. 450.
451. 451.
\f
\f 匹配一个换页符。等价于 \x0c \x0c 和 \cL \cL。
452. 452.
453. 453.
\n
\n 匹配一个换行符。等价于 \x0a \x0a 和 \cJ \cJ。
454. 454.
455. 455.
\r
\r 匹配一个回车符。等价于 \x0d \x0d 和 \cM \cM。
456. 456.
457. 457.
\s
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v] [ \f\n\r\t\v]。
458. 458.
459. 459.
\S
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v] [^ \f\n\r\t\v]。
460. 460.
461. 461.
\t
\t 匹配一个制表符。等价于 \x09 \x09 和 \cI \cI。
462. 462.
463. 463.
\v
\v 匹配一个垂直制表符。等价于 \x0b \x0b 和 \cK \cK。
464. 464.
465. 465.
\w
\w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’’[A-Za-z0-9_]’。
466. 466.
467. 467.
\W
\W 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’’[^A-Za-z0-9_]’。
468. 468.
469. 469.
\xn
\xn 匹配 n n，其中 n n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如， ‘\x41’’\x41’ 匹配 “A””A”。’\x041’’\x041’ 则等价于 ‘\x04’’\x04’ & & “1””1”。正则表达式中可以使用 ASCII ASCII 编码。. .
470. 470.
471. 471.
\num
\num 匹配 num num，其中 num num 是一个正整数。对所获取的匹配的引用。例如，’(.)\1’’(.)\1’ 匹配两个连续的相同字符。
472. 472.
473. 473.
\n
\n 标识一个八进制转义值或一个后向引用。如果 \n \n 之前至少 n n 个获取的子表达式，则 n n 为后向引用。否则，如果 n n 为八进制数字 ( (00–77))，则 n n 为一个八进制转义值。
474. 474.
475. 475.
\nm
\nm 标识一个八进制转义值或一个后向引用。如果 \nm \nm 之前至少有is preceded by at least nm is preceded by at least nm 个获取得子表达式，则 nm nm 为后向引用。如果 \nm \nm 之前至少有 n n 个获取，则 n n 为一个后跟文字 m m 的后向引用。如果前面的条件都不满足，若 n n 和 m m 均为八进制数字 ( (00–77))，则 \nm \nm 将匹配八进制转义值 nm nm。
476. 476.
477. 477.
\nml
\nml 如果 n n 为八进制数字 ( (00–33))，且 m m 和 l l 均为八进制数字 ( (00–77))，则匹配八进制转义值 nml nml。
478. 478.
479. 479.
\un
\un 匹配 n n，其中 n n 是一个用四个十六进制数字表示的 Unicode Unicode 字符。例如， \u00A9 \u00A9 匹配版权符号 (?) (?)。
480. 480.
481. 481.
482. 482.
<span style=
<span style=”font-size: 18pt””font-size: 18pt”>>优先权顺序
483. 483.
在构造正则表达式之后，就可以象数学表达式一样来求值，也就是说，可以从左至右并按照一个优先权顺序来求值。
484. 484.
485. 485.
下表从最高优先级到最低优先级列出各种正则表达式操作符的优先权顺序：
486. 486.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>>操作符 描述
487. 487. \ \ 转义符
488. 488. (), (?:), (?=), [] (), (?:), (?=), [] 圆括号和方括号
489. 489. *, +, ?, {n}, {n,}, {n,m} *, +, ?, {n}, {n,}, {n,m} 限定符
490. 490. ^, $, \anymetacharacter ^, $, \anymetacharacter 位置和顺序
491. 491. | “| “或””操作
492. 492.
493. 493.
494. 494.
普通字符
495. 495.
496. 496.
普通字符由所有那些未显式指定为元字符的打印和非打印字符组成。这包括所有的大写和小写字母字符，所有数字，所有标点符号以及一些符号。
497. 497.
498. 498.
最简单的正则表达式是一个单独的普通字符，可以匹配所搜索字符串中的该字符本身。例如，单字符模式 ‘A’’A’ 可以匹配所搜索字符串中任何位置出现的字母 ‘A’’A’。这里有一些单字符正则表达式模式的示例：
499. 499.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>/a/ >/a/
500. 500. //77/ /
501. 501. /M/ /M/
502. 502.
503. 503.
等价的 VBScript VBScript 单字符正则表达式为：
504. 504.
<pre name=
<pre name=”code””code” **classclass**==”java””java”>>”a””a”
505. 505. “7””7”
506. 506. “M””M”
507. 507.
508. 508.
可以将多个单字符组合在一起得到一个较大的表达式。例如，下面的 JScript JScript 正则表达式不是别的，就是通过组合单字符表达式 ‘a’’a’、’7’’7’以及 ‘M’’M’ 所创建出来的一个表达式。
509. 509.
510. 510.
/a7M/
/a7M/
511. 511.
等价的 VBScript VBScript 表达式为：
512. 512.
513. 513.
“a7M””a7M”
514. 514.
请注意这里没有连接操作符。所需要做的就是将一个字符放在了另一个字符后面。
515. 515.
516. 516.
正则表达式基础知识
call(),apply(),callee,caller,cookiecall(),apply(),callee,caller,cookie方法，setInterval()setInterval()，clearInterval(),setTimeout() ,clearTimeout() clearInterval(),setTimeout() ,clearTimeout()��
详细看附件例子，还是写的比较简单的。
1.1.关于cookiecookie的函数：
JsJs****代码
1. 1. //
2. 2. * cookie * cookie操作工具..
3. 3. * * 使用方法::保存值:CookieTool(‘name’,’1’,{expires: 7}) //:CookieTool(‘name’,’1’,{expires: 7}) //表示保存一个cookiecookie值为1,1,键值为name,name,失效时间77天以后
4. 4. * * 取值:CookieTool(‘name’) //:CookieTool(‘name’) //返回11
5. 5. * @param {} name * @param {} name
6. 6. * @param {} value * @param {} value
7. 7. * @param {} options * @param {} options
8. 8. * @return {} * @return {}
9. 9. */ */
10. 10. CookieTool = CookieTool = functionfunction(name, value, options) { (name, value, options) {
11. 11. ifif ( (typeoftypeof value != value != ‘undefined’’undefined’) { ) {
12. 12. options = options || {}; options = options || {};
13. 13. ifif (value === (value === nullnull) { ) {
14. 14. value = value = ‘’’’; ;
15. 15. options.expires = -1; options.expires = -1;
16. 16. } }
17. 17. varvar expires = expires = ‘’’’; ;
18. 18. ifif (options.expires && ( (options.expires && (typeoftypeof options.expires == options.expires == ‘number’’number’ || options.expires.toUTCString)) { || options.expires.toUTCString)) {
19. 19. varvar date; date;
20. 20. ifif ( (typeoftypeof options.expires == options.expires == ‘number’’number’) { ) {
21. 21. date = date = newnew Date(); Date();
22. 22. date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000)); date.setTime(date.getTime() + (options.expires * 24 * 60 * 60 * 1000));
23. 23. } } elseelse { {
24. 24. date = options.expires; date = options.expires;
25. 25. } }
26. 26. expires = expires = ‘; expires=’’; expires=’ + date.toUTCString(); + date.toUTCString();
27. 27. } }
28. 28. varvar path = options.path ? path = options.path ? ‘; path=’’; path=’ + (options.path) : + (options.path) : ‘’’’; ;
29. 29. varvar domain = options.domain ? domain = options.domain ? ‘; domain=’’; domain=’ + (options.domain) : + (options.domain) : ‘’’’; ;
30. 30. varvar secure = options.secure ? secure = options.secure ? ‘; secure’’; secure’ : : ‘’’’; ;
31. 31. document.cookie = [name, document.cookie = [name, ‘=’’=’, encodeURIComponent(value), expires, path, domain, secure].join(, encodeURIComponent(value), expires, path, domain, secure].join(‘’’’); );
32. 32. } } elseelse { {
33. 33. varvar cookieValue = cookieValue = nullnull; ;
34. 34. ifif (document.cookie && document.cookie != (document.cookie && document.cookie != ‘’’’) { ) {
35. 35. varvar cookies = document.cookie.split( cookies = document.cookie.split(‘;’’;’); );
36. 36. forfor ( (varvar i = 0; i < cookies.length; i++) { i = 0; i < cookies.length; i++) {
37. 37. varvar cookie = trim(cookies[i]); cookie = trim(cookies[i]);
38. 38. ifif (cookie.substring(0, name.length + 1) == (name + (cookie.substring(0, name.length + 1) == (name + ‘=’’=’)) { )) {
39. 39. cookieValue = decodeURIComponent(cookie.substring(name.length + 1)); cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
40. 40. breakbreak; ;
41. 41. } }
42. 42. } }
43. 43. } }
44. 44. returnreturn cookieValue; cookieValue;
45. 45. } }
46. 46. }; };
2.2.关于一个可以查看jsjs对象的jsjs函数，很酷的方法::
JsJs****代码
1. 1. //
2. 2. * * 用来查看一个对象的属性
3. 3. */ */
4. 4. functionfunction debugObjectInfo(obj){ debugObjectInfo(obj){
5. 5. traceObject(obj); traceObject(obj);
6. 6.
7. 7. functionfunction traceObject(obj){ traceObject(obj){
8. 8. varvar str = str = ‘’’’; ;
9. 9. ifif(obj.tagName&&obj.name&&obj.id) (obj.tagName&&obj.name&&obj.id)
10. 10. str= str=”
11. 11. elseelse{ {
12. 12. str= str=”
13. 13. } }
14. 14. varvar key=[]; key=[];
15. 15. forfor((varvar i i inin obj){ obj){
16. 16. key.push(i); key.push(i);
17. 17. } }
18. 18. key.sort(); key.sort();
19. 19. forfor((varvar i=0;i<key.length;i++){ i=0;i<key.length;i++){
20. 20. varvar v= v= newnew String(obj[key[i]]).replace(/</g, String(obj[key[i]]).replace(/</g,”<””<”).replace(/>/g,).replace(/>/g,”>””>”); );
21. 21. str+= str+=”
22. 22. } }
23. 23. str=str+ str=str+”“”“; ;
24. 24. writeMsg(str); writeMsg(str);
25. 25. } }
26. 26. functionfunction trace(v){ trace(v){
27. 27. varvar str= str=”
28. 28. str+=String(v).replace(/</g, str+=String(v).replace(/</g,”<””<”).replace(/>/g,).replace(/>/g,”>””>”); );
29. 29. str+= str+=”“”“; ;
30. 30. writeMsg(str); writeMsg(str);
31. 31. } }
32. 32. functionfunction writeMsg(s){ writeMsg(s){
33. 33. traceWin=window.open( traceWin=window.open(“”””,,”traceWindow””traceWindow”,,”height=600, width=800,scrollbars=yes””height=600, width=800,scrollbars=yes”); );
34. 34. traceWin.document.write(s); traceWin.document.write(s);
35. 35. } }
36. 36. } }
3.3.正则表达式：
g g 代表全局匹配
m m 代表可以进行多行匹配
i i 代表不区分大小写匹配
^ ^ 匹配输入字符串的开始位置
$ $ 匹配输入字符串的结束位置
- 匹配前面的子表达式零次或多次. . 等价于{0,}{0,}
- 匹配前面的子表达式一次或多次. . 等价于{1,}{1,}
? ? 匹配前面的子表达式零次或一次. . 等价于[0,1} , [0,1} , 当该字符跟在任何一个其他限制符(, +, ?, {n}, {n,}, {n,m}) (, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 “oooo” “oooo”，’o+?’ ‘o+?’ 将匹配单个 “o” “o”，而 ‘o+’ ‘o+’ 将匹配所有 ‘o’ ‘o’。
\d \d 匹配一个数字字符. . 等价于 [0-9] [0-9]
\D \D 匹配一个非数字符. . 等价于 [^0-9] [^0-9]
\w ,\w ,等价于 “[A-Za-z0-9_]” “[A-Za-z0-9_]”
\W \W 匹配任何非单词字符,,等价于 “[^A-Za-z0-9]” “[^A-Za-z0-9]”
\s \s 匹配任何空白字符, , 包括空格 制表符 换页符 等等. . 等价于[\f\n\r\t\v][\f\n\r\t\v]
\S \S 匹配任何非空白字符. . 等价于 [^\f\r\n\t\v] [^\f\r\n\t\v]
\b \b 匹配一个单词边界，也就是指单词和空格间的位置。
\B \B 匹配非单词边界。
正则表达式常用jsjs方法：
JsJs****代码
1. 1. //
2. 2. * * 在源字符串中查找满足要求的子串. .
3. 3. * @return {} * @return {}
4. 4. */ */
5. 5. functionfunction MatchDemo() { MatchDemo() {
6. 6. varvar r, re; r, re; // // 声明变量。
7. 7. varvar s = s = “The rain in Spain falls mainly in the plain””The rain in Spain falls mainly in the plain”; ;
8. 8. re = re = newnew RegExp( RegExp(“ain””ain”, , “g””g”); ); // // 创建正则表达式对象。
9. 9. r = s.match(re); r = s.match(re); // // 在字符串 s s 中查找匹配。
10. 10. returnreturn (r); (r);
11. 11. } }
12. 12.
13. 13. //
14. 14. * * 返回在源字符串中的满足正则表达式的全部的字串和位置信息. .
15. 15. */ */
16. 16. functionfunction RegExpTest() { RegExpTest() {
17. 17. varvar ver = Number(ScriptEngineMajorVersion() + ver = Number(ScriptEngineMajorVersion() + “.””.”
18. 18. + ScriptEngineMinorVersion()) + ScriptEngineMinorVersion())
19. 19. varvar ans = ans = ‘’’’; ;
20. 20. ifif (ver >= 5.5) { (ver >= 5.5) { // // 测试 JScript JScript 的版本。
21. 21. varvar src = src = “The rain in Spain falls mainly in the plain.””The rain in Spain falls mainly in the plain.”; ;
22. 22. varvar re = /\w+/g; re = /\w+/g; // // 创建正则表达式模式。
23. 23. varvar arr; arr;
24. 24. whilewhile ((arr = re.exec(src)) != ((arr = re.exec(src)) != nullnull) )
25. 25. ans += arr.index + ans += arr.index + “-“”-“ + arr.lastIndex + arr + + arr.lastIndex + arr + “\t””\t”; ;
26. 26. } } elseelse { {
27. 27. ans = ans = “”请使用 JScript JScript 的更新版本””; ;
28. 28. } }
29. 29. returnreturn ans; ans;
30. 30. } }
31. 31.
32. 32. //
33. 33. * * 对源字符串进行正则表达式检查,,看是不是符合正则表达式. .
34. 34. */ */
35. 35. functionfunction TestDemo() { TestDemo() {
36. 36. varvar s1; s1;
37. 37. varvar source = source = “abcdefg””abcdefg”; ;
38. 38. varvar regex = /\w+/g; regex = /\w+/g; // // 创建正则表达式模式。
39. 39. ifif (regex.test(source)) (regex.test(source))
40. 40. s1 = s1 = “ contains “” contains “; ;
41. 41. elseelse
42. 42. s1 = s1 = “ does not contain “” does not contain “; ;
43. 43. returnreturn ( (“‘“”‘“ + source + + source + “‘“”‘“ + s1 + + s1 + “‘“”‘“ + regex.source + + regex.source + “‘“”‘“); );
44. 44. } }
45. 45.
46. 46. //
47. 47. * * 在源字符串中查找正则表达式的字串. .
48. 48. * @return {} * @return {}
49. 49. */ */
50. 50. functionfunction SearchDemo() { SearchDemo() {
51. 51. varvar r, re; r, re;
52. 52. varvar s = s = “The rain in Spain falls mainly in the plain.””The rain in Spain falls mainly in the plain.”; ;
53. 53. re = /falls/i; re = /falls/i;
54. 54. r = s.search(re); r = s.search(re);
55. 55. returnreturn (r); (r);
56. 56. } }
4.4.很值得学习并要使用好的方法，callcall（）：
call([thisObj[,arg1[, arg2[, [,.argN]]]]])call([thisObj[,arg1[, arg2[, [,.argN]]]]])
参数
thisObjthisObj
可选项。将被用作当前对象的对象。
arg1, arg2, , argNarg1, arg2, , argN
可选项。将被传递方法参数序列。
说明
call call 方法可以用来代替另一个对象调用一个方法。call call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj thisObj 指定的新对象。
简单的例子：
JsJs****代码
1. 1. functionfunction add(a,b) add(a,b)
2. 2. { {
3. 3. alert(a+b); alert(a+b);
4. 4. } }
5. 5. functionfunction sub(a,b) sub(a,b)
6. 6. { {
7. 7. alert(a-b); alert(a-b);
8. 8. } }
9. 9.
10. 10. add.call(sub,3,1); add.call(sub,3,1);
11. 11. ////这个例子中的意思就是用 add add 来替换 sub sub，add.call(sub,3,1) == add(3,1) add.call(sub,3,1) == add(3,1) ，所以运行结果为：alert(4);alert(4);
稍微复杂的例子：
JsJs****代码
1. 1. functionfunction Class1() Class1()
2. 2. { {
3. 3. thisthis.name = .name = “class1””class1”; ;
4. 4.
5. 5. thisthis.showNam = .showNam = functionfunction() ()
6. 6. { {
7. 7. alert( alert(thisthis.name); .name);
8. 8. } }
9. 9. } }
10. 10.
11. 11. functionfunction Class2() Class2()
12. 12. { {
13. 13. thisthis.name = .name = “class2””class2”; ;
14. 14. } }
15. 15.
16. 16. varvar c1 = c1 = newnew Class1(); Class1();
17. 17. varvar c2 = c2 = newnew Class2(); Class2();
18. 18.
19. 19. c1.showNam.call(c2); c1.showNam.call(c2);
20. 20. //call //call 的意思是把 c1 c1 的方法放到c2c2上执行，原来c2c2是没有showNam() showNam() 方法，现在是把c1 c1 的showNam()showNam()方法放到 c2 c2 上来执行，所以this.name this.name 应该是 class2 class2，执行的结果就是 ：alertalert（”class2””class2”）;;
多重继承的例子：
JsJs****代码
1. 1. functionfunction Class10() Class10()
2. 2. { {
3. 3. thisthis.showSub = .showSub = functionfunction(a,b) (a,b)
4. 4. { {
5. 5. alert(a-b); alert(a-b);
6. 6. } }
7. 7. } }
8. 8.
9. 9. functionfunction Class11() Class11()
10. 10. { {
11. 11. thisthis.showAdd = .showAdd = functionfunction(a,b) (a,b)
12. 12. { {
13. 13. alert(a+b); alert(a+b);
14. 14. } }
15. 15. } }
16. 16.
17. 17.
18. 18. functionfunction Class2() Class2()
19. 19. { {
20. 20. Class10.call( Class10.call(thisthis); );
21. 21. Class11.call( Class11.call(thisthis); );
22. 22. } }
5.apply5.apply函数：
Function.apply(obj,args)Function.apply(obj,args)方法能接收两个参数
obj obj：这个对象将代替FunctionFunction类里thisthis对象
args args：这个是数组，它将作为参数传给FunctionFunction（args–>argumentsargs–>arguments）
实现类似callcall的继承的效果：
JsJs****代码
1. 1. functionfunction Person(name,age){ Person(name,age){ ////定义一个类，人类
2. 2. thisthis.name=name; .name=name; ////名字
3. 3. thisthis.age=age; .age=age; ////年龄
4. 4. thisthis.sayhello=.sayhello=functionfunction(){alert((){alert(“hello””hello”)}; )};
5. 5. } }
6. 6. functionfunction Print(){ Print(){ ////显示类的属性
7. 7. thisthis.funcName=.funcName=”Print””Print”; ;
8. 8. thisthis.show=.show=functionfunction(){ (){
9. 9. varvar msg=[]; msg=[];
10. 10. forfor((varvar key key inin thisthis){ ){
11. 11. ifif((typeoftypeof((thisthis[key])!=[key])!=”function””function”){ ){
12. 12. msg.push([key, msg.push([key,”:””:”,,thisthis[key]].join([key]].join(“”””)); ));
13. 13. } }
14. 14. } }
15. 15. alert(msg.join( alert(msg.join(“ “” “)); ));
16. 16. }; };
17. 17. } }
18. 18. functionfunction Student(name,age,grade,school){ Student(name,age,grade,school){ ////学生类
19. 19. Person.apply( Person.apply(thisthis,arguments); ,arguments);
20. 20. Print.apply( Print.apply(thisthis,arguments); ,arguments);
21. 21. thisthis.grade=grade; .grade=grade; ////年级
22. 22. thisthis.school=school; .school=school; ////学校
23. 23. } }
24. 24. varvar p1= p1=newnew Person( Person(“jake””jake”,10); ,10);
25. 25. p1.sayhello(); p1.sayhello();
26. 26. varvar s1= s1=newnew Student( Student(“tom””tom”,13,6,,13,6,””清华小学””); );
27. 27. s1.show(); s1.show();
28. 28. s1.sayhello(); s1.sayhello();
29. 29. alert(s1.funcName); alert(s1.funcName);
使用applyapply进行数组参数的函数的优化，很酷的方法：
JsJs****代码
1. 1. Math.maxMath.max后面可以接任意个参数，最后返回所有参数中的最大值。
2. 2.
3. 3. 比如
4. 4. alert(Math.max(5,8)) alert(Math.max(5,8)) //8//8
5. 5. alert(Math.max(5,7,9,3,1,6)) alert(Math.max(5,7,9,3,1,6)) //9//9
6. 6.
7. 7. 但是在很多情况下，我们需要找出数组中最大的元素。
8. 8. varvar arr=[5,7,9,1] arr=[5,7,9,1]
9. 9. alert(Math.max(arr)) alert(Math.max(arr)) // // 这样却是不行的。一定要这样写
10. 10.
11. 11. functionfunction getMax(arr){ getMax(arr){
12. 12. varvar arrLen=arr.length; arrLen=arr.length;
13. 13. forfor((varvar i=0,ret=arr[0];i<arrLen;i++){ i=0,ret=arr[0];i<arrLen;i++){
14. 14. ret=Math.max(ret,arr[i]); ret=Math.max(ret,arr[i]);
15. 15. } }
16. 16. returnreturn ret; ret;
17. 17. } }
18. 18.
19. 19. 用 apply apply呢，看代码：
20. 20. functionfunction getMax2(arr){ getMax2(arr){
21. 21. returnreturn Math.max.apply( Math.max.apply(nullnull,arr); ,arr);
22. 22. } }
下面是另外一个例子，用来合并两个数组：
JsJs****代码
1. 1. 再比如数组的pushpush方法。
2. 2. varvar arr1=[1,3,4]; arr1=[1,3,4];
3. 3. varvar arr2=[3,4,5]; arr2=[3,4,5];
4. 4. 如果我们要把 arr2 arr2展开，然后一个一个追加到arr1arr1中去，最后让arr1=[1,3,4,3,4,5] arr1=[1,3,4,3,4,5]
5. 5. arr1.push(arr2)arr1.push(arr2)显然是不行的。 因为这样做会得到[1,3,4,[3,4,5]] [1,3,4,[3,4,5]]
6. 6.
7. 7. 我们只能用一个循环去一个一个的push(push(当然也可以用arr1.concat(arr2)arr1.concat(arr2)，但是concatconcat方法并不改变arr1arr1本身) )
8. 8. varvar arrLen=arr2.length arrLen=arr2.length
9. 9. forfor((varvar i=0;i<arrLen;i++){ i=0;i<arrLen;i++){
10. 10. arr1.push(arr2[i]); arr1.push(arr2[i]);
11. 11. } }
使用applyapply的话：
JsJs****代码
1. 1. Array.prototype.push.apply(arr1,arr2) Array.prototype.push.apply(arr1,arr2)
正则表达式学习笔记
^^ The caret (^) tells the regular expression that the character must not match the characters to follow.
The caret (^) tells the regular expression that the character must not match the characters to follow.
比如要匹配所有除了aa或bb的字符,,字符类可以这么写[^ab][^ab]
^^ 定位符规定匹配模式必须出现在目标字符串的开头
那是否说^^ 在[ ][ ] 里面 就 表示排除((负向类****_))_ , , 在[ ][ ] 前面 就表示要在开头 ??
$$ 定位符规定匹配模式必须出现在目标对象的结尾
– 范围类,,如要匹配aa到zz的所有字母,,字符类可以这么写[a-z]
[a-z]
{n}{n} 出现多少次
/^[0-9]{7}$//^[0-9]{7}$/ 匹配的就是一个仅包含77个数字的字符串
7.1 RegExp
7.1 RegExp 对象可以有一个或两个参数.
.
var reCat = new var reCat = new RegExpRegExp (“cat”) (“cat”) ////这个表达式只会匹配字符串中出现的第一个”cat””cat”
var reCat = new var reCat = new RegExpRegExp (“cat”,”g”)(“cat”,”g”) ////匹配所有出现的”cat””cat”
正则表达式字面量
var reCat =var reCat = /cat/gi/cat/gi ;; 注意字面量不需 要放在引号里
判断某个字符串是否匹配指定的模式
RegExp.test(str)RegExp.test(str) 如果给定的字符串匹配这个模式,,返回truetrue , ,否则返回falsefalse . . reCat.test(“cat”)reCat.test(“cat”) ////返回truetrue
RegExp.RegExp. exec(str)exec(str) 返回一个数组 , ,数组中第一个元素是匹配字符串,,其他是反向引用 . . 如果没有找到匹配,,返回nullnull
返回的数组有一个indexindex 属性,,这个属性的值 是匹配字符串中第一个字符在原字符串中的下标
var toMarch6 = “1 3”;var toMarch6 = “1 3”;
var regExp6 = /(\d+)\s*(\d+)/;
var regExp6 = /(\d+)\s*(\d+)/;
var result = regExp6.exec(toMarch6);
var result = regExp6.exec(toMarch6);
dwr(result);
dwr(result);//1 3,1,3//1 3,1,3
dwr(RegExp.$1 +” “+RegExp.$2);dwr(RegExp.$1 +” “+RegExp.$2);//1 3//1 3
当正则表达式加上了参数gg , ,这个正则表达式会从正则表达式对象的lastIndexlastIndex 属 性指定的位置开始查找,,如果找到一个匹配,
,
会将lastIndexlastIndex 属性设置为匹配字符串后面 一个位置的下标.
.
var toMarch7 = “1 3 4 5”; var toMarch7 = “1 3 4 5”;
var regExp7 = /(\d+)\s*(\d+)/g;
var regExp7 = /(\d+)\s*(\d+)/g;
var result7
while((result7= regExp7.exec(toMarch7)) !=null){
var result7
while((result7= regExp7.exec(toMarch7)) !=null){
dwr(result7);
dwr(result7);////分别为1 3,1,3 1 3,1,3 和 4 5,4,5 4 5,4,5
dwr(regExp7.lastIndex);
dwr(regExp7.lastIndex);////分别为33和77
}
}
String.match(reCat)String.match(reCat) 返回一个包含在字符串中的所有匹配 的数组
var toMatch = “a bat, a cat, a fAt baT, a faT cat”;var toMatch = “a bat, a cat, a fAt baT, a faT cat”;
var reAt = /at/gi;var reAt = /at/gi; ////如果不加参数g,g,返回的数组只会包含一个匹配元素
var arrMatchs = toMatch.match(reAt);var arrMatchs = toMatch.match(reAt);
返回一个数组_[“at”,”at”,”At”,”aT”,”aT”,”at”][“at”,”at”,”At”,”aT”,”aT”,”at”]_
String.search(reCat)String.search(reCat) 与indexOfindexOf 类似,,返回在字符串中出现的第一个 匹配的位置 , ,全局匹配表达式gg 在这里不起作 用 toMatch.search(reAt);toMatch.search(reAt);////输出33
String.replace(matchStr, replaceStr)String.replace(matchStr, replaceStr)
用第二个参数替换 某个子串((第一个 参数))的所有匹配 . . 第一个参数 既可以是匹配的字符串 , ,也可以是用于匹配的一个正则表达式 ,
,
返回是替换后的整个字符串
var sToChange = “The sky is red”;var sToChange = “The sky is red”;
var reRed = /red/;var reRed = /red/;
sToChange.replace(reRed,”blue”sToChange.replace(reRed,”blue” ); ); ////输出The sky is blueThe sky is blue
String.split(reCat)String.split(reCat) 将字符串分割 成子串,,作为数组 返回
var sColor = “red, blue, yellow”;var sColor = “red, blue, yellow”;
var reExp = /,/;var reExp = /,/;
var arrs = sColor.split(reExp); //var arrs = sColor.split(reExp); //得到一个数组[“red”,”blue”,”yellow”[“red”,”blue”,”yellow” ] ] 注意逗号 在正则表达式有
特殊含义 , ,这边需要转义
7.2 7.2 简单模式((元字符 ,,字符类 ,,量词 ))
元字符 11 11个 (( )) [] {} \ ^ $ | ? * + .[] {} \ ^ $ | ? * + . 要匹配字符串中的元字符,,需要转义 /^//^/
注意var reMark = new RegExp(“\^”);var reMark = new RegExp(“\^”); 当正则表达式以非字面量的形式 表示时,,所有的反斜杠**”"“"** 都要用两个反斜杠**”\“”\“** 来替换.
.
因为javascriptjavascript字符串解析器会按照翻译\n\n 的 方式尝试翻译?.?.为了保证不会出现这个问题,,在元字符的前面加上两个反斜杠,
,
我们称之为双重转义 . .((不太懂这个解释,,我的理解是\ 本身也是元字符,,先要对它转义得到 “"“" , ,然后再用这个**”"“"** 对接下来的元字符转义))
|预定义的特殊字符
| |
|——————–|———————–|
|\****tt
|制表符
|
|\****nn
|换行符
|
|\****rr
|回车符
|
|\****ff
|换页符
|
|\****aa
|Alert Alert 字符
|
|\****ee
|Escape Escape 字符
|
|\****cXcX
|与 X X 相应 的控制字符
|
|\****bb
|回退字符
|
|\****vv
|垂直制表符
|
|\****oo
|空字符
|
字符类 将一些字符放入方括号中 .
.
1, 1, 简单类
var toMatch = “a bat, a cat, a fAt baT, a faT cat”;var toMatch = “a bat, a cat, a fAt baT, a faT cat”;
var reg = var reg = /[bcf]at/gi/[bcf]at/gi ;;
var arrs = toMatch.match(reg); var arrs = toMatch.match(reg); 返回的数组[“bat”, “Cat”, “fAt”, “baT”, “faT”, “cat”]
[“bat”, “Cat”, “fAt”, “baT”, “faT”, “cat”]
**2,2,**负向类 可 以指定要排除的字符 , ,^^ 要在[ ][ ] 里面
匹配除了 aa 和bb 以外的所有字符,,那么这个字符类为**[^ab][^ab]** . . 脱字符^^ 告诉正则表达式字符不能匹配后面 跟着的字符
只想获得包含atat但不能以bb或cc开头的字符, , /[^bc]at/gi/[^bc]at/gi
3, 3, 范围类
[a-z][a-z] 匹配所有小写字母
结合负向类可以排除给定范围内的所有字符 , , 例如要排除字符14,14,可以使用类**[^1-4][^1-4]**
4, 4, 组合类
[a-z1-9\n][a-z1-9\n]
5, 5, 预定义类
代码 等同于 匹配
.. [^\n\r][^\n\r] 除了换行回车意外的任意字符
\d\d [0-9][0-9] 数字
\D\D [^0-9][^0-9] 非数字
\s\s [ \t\n\r\x0B\f][ \t\n\r\x0B\f] 空白字符
\S\S [^ \t\n\r\x0B\f][^ \t\n\r\x0B\f] 非空白字符
\w\w [a-zA-Z_0-9][a-zA-Z_0-9] 单词字符((所有字母,,数字和下划线)
)
\W\W [^a-zA-Z_0-9][^a-zA-Z_0-9] 非单词字符
6, 6, 量词
用于指定某个特定模式出现的次数
?? 出现00次或11次
** 出现00次或多次((任意次)
)
++ 出现11次或多次((至少出现一次)
)
{n}{n} 一定出现nn次
{n,m}{n,m} 至少出现nn次但不超过mm次
{n,}{n,} 至少出现nn次
贪婪的**,,惰性的,,**支配性的量词
贪婪量 词 先看整个字符串是否匹配,,如果没有发现匹配,,它去掉该字符串中最后一个字符,,并再次尝试..重复这个过程直到发现匹配 或者字符串不剩任何字符.
.
结合 下面会见到的两个例子, , 实际过程可能是这样的::
第一步按上面的描述执行, , 如果字符串不剩任何字符还是没有找到一个匹配, , 那么删除字符串的第一个字符, , 重复第一步..
惰性量词 先看字符串中第一个字符是否匹配..如果单独这个 字符还不够,,就读入下一个字符,,组成两个字符的字符串..如果还是没有发现匹配,,惰性量词继续从
字符串中添加字符直到发现匹配或者整个字符串都检查过也没有匹配..与贪婪量词的工作方式正好相反.
.
支配量词 只尝试匹配整个字符串..如果整个字符串不能产生匹配,,不 做进一步尝试.(IE.(IE不支持,Mozilla,Mozilla把支配量词当做贪婪的)
)
贪婪 惰性 支配 描述
?? ???? ?+?+ 零次或一次出现
** ?? ++ 零次或多次出现
++ +?+? ++++ 一次或多次出现
{n}{n} {n}?{n}? {n}+{n}+ 恰好nn次出现
{n,m}{n,m} {n,m}?{n,m}? {n,m}+{n,m}+ 至少nn次之多mm次出现
{n,}{n,} {n,}?{n,}? {n,}+{n,}+ 至少nn次出现
7.3 7.3 复杂模式
1, 1, 分组
分组是通过一系 列括号包围一系列字符,,字符类以及量词来使用的.
.
/(dog){2}/g/(dog){2}/g 匹配dogdogdogdog
/{[bd]ad?}//{[bd]ad?}/ 匹配ba, da, bad, dadba, da, bad, dad 等
去掉开头结尾的空白字符
String.prototype.trim = function(){
String.prototype.trim = function(){
////注意, , 分组里面.?.?一定要是惰性的,,不然这 个分组会把最后的空白字符也匹配进去
var reExtraStr = /^\s+(.*?)\s+$/ ;
return this.replace(reExtraStr,”$1”);
}
var reExtraStr = /^\s+(.*?)\s+$/ ;
return this.replace(reExtraStr,”$1”);
}
2, 2, 反向引用
在 表达式计算完成之后,,每个分组都被存放在一个特殊的地方以备将来使用..这些存储在分组中的特殊值,,我们称之为反向引用(( backreference).backreference).
反向引用是按照从左到右遇到的左括号字符的顺序进行创建和编号的.
.
反向引用的几种不同使用方法:
:
- 使用正则表达式对象的test(), exec()test(), exec()方法后,,反向引用的值可以从RegExpRegExp对象的构造函数中获得
var toMarch = “#12345”; var toMarch = “#12345”;
var regExp = /#(\d*)/;
var regExp = /#(\d*)/;
regExp.exec(toMarch);
regExp.exec(toMarch);
dwr(RegExp.$1);
dwr(RegExp.$1);
- 还可以直接在定义分组的表达式中包含反向引用,,这可以通过使用特 殊转义序列如 \1\1 , \2 , \2 等实现..
var toMarch2 = “dogdog”; var toMarch2 = “dogdog”;
var regExp2 = /(dog)\1/;
var regExp2 = /(dog)\1/;
dwr(regExp2.test(toMarch2));
dwr(regExp2.test(toMarch2));
- 反向引用可以用在StringString对象的replace()replace()方法中
var toMarch3 = “123123123 3211231231”; var toMarch3 = “123123123 3211231231”;
var regExp3 = /(\d+)\s*(\d+)/;
var regExp3 = /(\d+)\s*(\d+)/;
var sNew = toMarch3.replace(regExp3,”$2 $1 “);
var sNew = toMarch3.replace(regExp3,”$2 $1 “); ////注意replacereplace不改变原来的字符串,,而是返回一个替换后的新 字符串
dwr(sNew);
dwr(sNew);
3, 3, 候选
用一个管道符((|| ), ),它放在两个单独的模式之间.
.
var toMarch4 = “dog”;var toMarch4 = “dog”;
var toMarch5 = “cat”;
var toMarch5 = “cat”;
var regExp4 = /dog|cat/;
var regExp4 = /dog|cat/;
dwr(regExp4.test(toMarch4));
dwr(regExp4.test(toMarch4));//true//true
dwr(regExp4.test(toMarch5));
dwr(regExp4.test(toMarch5));//true//true
OROR模式的一种通常用法是从用户输入中删除不合适的单词..
var userInput = “badWord1asdasdandBadWord2”;var userInput = “badWord1asdasdandBadWord2”;
var toMarch6 = /badword1|badword2/gi;
var toMarch6 = /badword1|badword2/gi;
var newStr = userInput.replace(toMarch6, function(march){
var newStr = userInput.replace(toMarch6, function(march){
return march.replace(/./g,”*”);
return march.replace(/./g,”*”);
});
});
dwr(newStr);
dwr(newStr); //asdasdand//asdasdand
string.replace(regexp, replacement)string.replace(regexp, replacement)
replacementreplacement 既 可以是一个替换的字符串,,也可以是一个function
function
如果是functionfunction的情况, , 这个functionfunction会为每一个匹配执行一次,,这 个functionfunction的返回值作为最终替换的字符串..
传给functionfunction的第一个参数是 第一个匹配的字符串;;
第二个参数是匹配字符串在原始字符串中的位置;;
第三个参数是原始字符串本身..
4, 4, 非捕获性分组
创建反向引用的分组称为捕获性分组, , 非捕获性分组不会创建反向引用.
.
在较长的正则表达式中存储反向引用会降低匹 配的速度.
.
要创建非捕获性分组,,只要在左括号后面紧跟一个问 号和冒号..
var str = “#123456”;var str = “#123456”;
var regE = /#(?: 123456)/;
var regE = /#(?: 123456)/;
regE.test(str);
regE.test(str);
dwr(RegExp.$1);
dwr(RegExp.$1); //“”//“”
////去除所有的HTMLHTML标签
String.prototype.skipHTML = function(){String.prototype.skipHTML = function(){
var regExp = /<(?:.|\s)*?>/g ;
var regExp = /<(?:.|\s)*?>/g ;
return this.replace(regExp,””);
return this.replace(regExp,””);
}
}
5, 5, 前瞻
表示当某个特定的字符分组出现在另一个字符串之前时才去捕获它.
.
前瞻分正向前瞻 和负向前瞻 , , 正向前瞻检查的是接下来出现的是不是某个特定的字符集. . 而负向前瞻则是检查接下来的不应该出现的特定字符集.
.
正向前瞻需要将模式放在(?=(?= 和 ) ) 之间,,注意这不是分组,,虽然它也用到 括号. . 负向前瞻需要将模式放在(!=(!= 和 ) ) 之间.
.
var toMarch1 = “bedroom”;var toMarch1 = “bedroom”;
var toMarch2 = “bedding”;
var toMarch2 = “bedding”;
var bedReg = /(bed(?=room))/;
var bedReg = /(bed(?=room))/;
dwr(bedReg.test(toMarch1));
dwr(bedReg.test(toMarch1)); //true//true
dwr(bedReg.exec(toMarch1));dwr(bedReg.exec(toMarch1)); //bed,bed //bed,bed 因此这个正则表达式返回的第一个匹配是bed,bed,而不是bedroom,bedroom,但是它只会去匹配后面跟着 room room的bed,bed,有点搞
dwr(RegExp.$1); dwr(RegExp.$1); //bed//bed
dwr(bedReg.test(toMarch2));
dwr(bedReg.test(toMarch2)); //false//false
6, 6, 边界
边界用于正则表达式中表示模式的位置.
.
^^ 行开头
$$ 行结尾
\b\b 单词的边界
\B\B 非单词的边界
查找一个出现在行尾的单词:
var toMarch3 = “Important word is the last one.”;:
var toMarch3 = “Important word is the last one.”;
var regExp3 =
var regExp3 = /(\w+).$//(\w+).$/ ; ; ////这边结合上面对贪婪量词的解释,,有点不明白为何能匹配one?.one?.
regExp3.test(toMarch3);
regExp3.test(toMarch3);
dwr(RegExp.$1);
dwr(RegExp.$1);//one//one
查找一个出现在行首的单词:
:
var toMarch4 = “Important word is the last one.”;var toMarch4 = “Important word is the last one.”;
var regExp4 =
var regExp4 = /^(\w+)//^(\w+)/ ; ; // //或者var regExp4 = /^(.+?)\b/;var regExp4 = /^(.+?)\b/;
regExp4.test(toMarch4);
regExp4.test(toMarch4);
dwr(RegExp.$1);
dwr(RegExp.$1);
抽取出所有的单词
var toMarch5 = “First Second Third Fourth Fifth Sixth”;var toMarch5 = “First Second Third Fourth Fifth Sixth”;
var regExp5 =
var regExp5 = /\b(\S+?)\b/g/\b(\S+?)\b/g ; ; ////或者 /\b(\S+)\b/g /\b(\S+)\b/g 和 /(\w+)/g /(\w+)/g
var sArr = toMarch5.match(regExp5);
var sArr = toMarch5.match(regExp5);
dwr(sArr);
dwr(sArr);//First Second Third Fourth Fifth Sixth//First Second Third Fourth Fifth Sixth
注意这边如果用/(\w+?)/g/(\w+?)/g 是不行的,,这样得到的是一个一个的字母F,i,r,s,t,S…F,i,r,s,t,S…
====================================================================================================================================================================================
与上面疑问类似的一个问题
例子代码，如下：
str = “abbb1234abbbaabbbaaabbb1234”;str = “abbb1234abbbaabbbaaabbb1234”;
re = /.*bbb/g;
re = /.*bbb/g;
alert(str.match(re)); //
alert(str.match(re)); //结果为abbb1234abbbaabbbaaabbbabbb1234abbbaabbbaaabbb
re = /.*?bbb/g;
re = /.*?bbb/g;
alert(str.match(re)); //
alert(str.match(re)); //结果为abbb,1234abbb,aabbb,aaabbbabbb,1234abbb,aabbb,aaabbb
re = /a*bbb/g;
re = /a*bbb/g;
alert(str.match(re)); //
alert(str.match(re)); //结果为abbb,abbb,aabbb,aaabbbabbb,abbb,aabbb,aaabbb
re = /a*?bbb/g;
re = /a*?bbb/g;
alert(str.match(re)); //
alert(str.match(re)); //结果为abbb,abbb,aabbb,aaabbbabbb,abbb,aabbb,aaabbb
对于第一、第二和第四个打印结果容易理解：
第一个str.match(re)str.match(re)，贪婪量词先匹配整个字串，若不匹配去掉一个尾字 符，继续匹配；
第二个str.match(re)str.match(re)，惰性量词从第一个字符开始递加去匹配，直到匹配成功，清空字串，从下一个 字符继续匹配。
第四个str.match(re)str.match(re)，同第二个。
但第三个就不知道如何解释，如果按照第一个的方式去理解：
先 匹配整个字串，发现不匹配，去掉尾字符，继续匹配……到最后，结果应该是abbbabbb；
而其结果却为abbb,abbb,aabbb,aaabbb
abbb,abbb,aabbb,aaabbb
以下为论坛解释
对于第三个正则，就是这样来执行的；
首 先清楚了是用了简单量词(),(),而我们知道了**是贪婪量词：
贪婪量词执行过程。正好楼主所说的那样。““先匹配整体，若不匹配则去掉尾字 符继续匹配，直到成功或者结束”
”
这样说应说只能得到第一被匹配的对象。
javascript
javascript 中的matchmatch返回的是所有匹配。
对于要返回所有匹配。
它还有第二个步：就是匹配成功后， 从最近的一个匹配后的下一个字符开始重新贪婪模式匹配。 重新执行它的步骤；
例:
:
str = “abbb1234abbbaabbbaaabbb1234”;str = “abbb1234abbbaabbbaaabbb1234”;
re = /a*bbb/g;
re = /a*bbb/g;
alert(str.match(re));
alert(str.match(re));
它的执行过程:
:
第一步：首先整个字符串(“abbb1234abbbaabbbaaabbb1234”)(“abbb1234abbbaabbbaaabbb1234”)匹配,,发现匹配不成 功，
接着。删除最后一个字符(“4”),(“4”),成了(“abbb1234abbbaabbbaaabbb123”),(“abbb1234abbbaabbbaaabbb123”),这样依次执行 下去；
执行……最后, , 发现(“abbb”)(“abbb”)可以被匹配了….所以生成第一个匹配值。
但在这个matchmatch方法中是返回所有匹配。所以..
..
第二步：从最近的一个匹配（这里就是第一次匹配了）后的下一个字符开始重新贪婪模式 匹配..得到字符串是
(“1234abbbaabbbaaabbb1234”),
(“1234abbbaabbbaaabbb1234”),然后。就按第一步执行。。
执行完第一步 后。
然后就从最近一次（这里就是第二次匹配了）
….
….后面的过程就是重复一二步了。。
但第二步时若继续按正则/abbb/g/abbb/g 去匹配“1234abbbaabbbaaabbb1234” “1234abbbaabbbaaabbb1234” 的话，应该是匹配不到才对吧？
怎么匹配不到呢。。
正 则表达式执行的时候。首先得找到前导字符(a), a(a), a是一个普通字符。普通字符，搜索的顺序为从左到右。。
所以搜索 “1234abbbaabbbaaabbb1234” “1234abbbaabbbaaabbb1234”字符串时，
得先匹配出aa字符来”abbbaabbbaaabbb1234”,
“abbbaabbbaaabbb1234”,
而 解析器又发现了aa后面是一个贪婪字符。就按贪婪模式去匹配((从右到左)
)
注意:: /abbb/g /abbb/g 用到了全局匹配, , 以上分析的症结所在可能就是因为一个”g””g”
====================================================================================================================================================================================
7, 7, 多行模式
一下代码中的正则表达式想要匹配行末的一个单词..它只会匹配最后的Sixth, Sixth, 但实际上这个字符串包含两个换行符,,因此, Second, Fourth, Second, Fourth也应该匹配出来,,因此引入了多行模式
var toMarch6 = “First Second\nThird Fourth\nFifth Sixth”;var toMarch6 = “First Second\nThird Fourth\nFifth Sixth”;
var regExp6 =
var regExp6 = /(\w+)$/g;/(\w+)$/g;
var sArr6 = toMarch6.match(regExp6);
var sArr6 = toMarch6.match(regExp6);
dwr(sArr6);
dwr(sArr6);
要 引入多行模式,,需要在正则表达式后面添加mm 选项, , 这会让$$边界匹配换行符(\n) (\n) 和字符串真正的结尾.
.
var regExp6 = var regExp6 = /(\w+)$/gm;/(\w+)$/gm;
判 断日期的正则表达式::
function isValidDate(s){function isValidDate(s){
var reDate = /(?:[1-9]|0[1-9]|[12][0-9]|3[01])/(?:[1-9]|0[1-9]|1[0-2])/(?:19\d{2}|20\d{2})/;
var reDate = /(?:[1-9]|0[1-9]|[12][0-9]|3[01])/(?:[1-9]|0[1-9]|1[0-2])/(?:19\d{2}|20\d{2})/;
return reDate.test(s);
return reDate.test(s);
}
}
