目录

1. 正则表达式

1.1 创建

1.2 RegExp 对象属性

1.3 RegExp 对象方法

1.4 RegExp 分组

2. 元字符和正则表达式规则

1正则表达式

正则表达式本身就是一种语言，由普通字符和特殊的元字符（metacharacters）组成。它描述了字符串的匹配模式，用于转换和处理字符串。

其中，元字符（metacharacters）也是由普通字符组成，具有特殊意义。比如 {3} 代表了将前面的字符或分组重复匹配三次，$ 代表了匹配一行的结束位置。（更多的元字符请看下面的 表格。）

正则表达式常被用来执行复杂的 “搜索-替换” 、验证字符串格式是否正确。

当今的大多数程序设计语言都包含正则表达式。甚至包括脚本语言、编辑器、应用程序、数据库和一些命令行的工具也包含正则表达式工具。下面介绍 Javascript 中实现正则表达式的 Regex 对象。

1.1 创建

Regex 是 Javascript 的内置对象，描述一个字符串的匹配模式，为字符串操作提供了强大的匹配和替换方法。

和数组、对象差不多，Regex 对象的创建也有常量、构造函数、普通函数三种创建方式：

直接量语法

/pattern/attributes

构造函数

new RegExp( pattern , attributes ) ;

普通函数

RegExp( pattern , attributes ) ;

其中的 pattern 是正则表达式的匹配模式，由字符和元字符（表格）构成，attributes 是正则表达式的标记，可以是 "i"、"g"、"m" 三个字母或三个字符的任意组合：

• "i"：大小写不敏感
• "g"：全局匹配（查找所有匹配而非在找到第一个匹配后停止）
• "m"：多行匹配

在使用函数创建正则表达式的时候，如果 pattern 不是一个字符串，而是一个正则表达式，则忽略第二个参数：

var a = /ch/ig ;
var b = new RegExp( /ch/ig) ;
var c = RegExp( "ch" , "ig" ) ;

1.2 对象属性

• regexOjbect.source 属性是一个只读的字符串，包含了描述这个正则表达式的文本；
• regexOjbect.global 属性是一个只读的布尔值，表明这个正则表达式是否为具有标识 "g" ；
• regexOjbect.ignoreCase 属性是一个只读的布尔值，表明这个正则表达式是否为具有标识 "i" ；
• regexOjbect.multiline 属性是一个只读的布尔值，表明这个正则表达式是否为具有标识 "m" ；
• regexOjbect.lastIndex 属性是一个数值，如果正则表达式有 “g” 标识，这个属性表明下一次检索的起始位置。

var reg = /ch/g ;
var testString = "String type contains one char or a set of chars."
alert( reg.source ) ;// "ch"alert( reg.global ) ;// truealert( reg.ignoreCase) ;// falsealert( reg.multiline) ;// falsealert( reg.lastIndex) ;// 0reg.test( testString  ) ;// truealert( reg.lastIndex) ;// 27reg.test( testString  ) ;// truealert( reg.lastIndex) ;// 44reg.test( testString  ) ;// falsealert( reg.lastIndex) ;// 0

可以看到，当正则表达式匹配结束或失败时，regexOjbect.lastIndex 被重置。

1.3 对象方法

test

Regex.test 方法测试正则表达式指定的模式是否出现在字符串中，返回 true 或 false 。

var a = /ch/ig ;
a.test( "chinses " ) ;// truea.test( "abc") ;// false

compile

Regex.compile 方法可以在脚本执行过程中编译正则表达式，也可以改变和重新编译正则表达式。形式如下：

RegExpObject.compile( regexp , attributes ) ;

regexp 是一个正则表达式，用于替换 RegExpObject。

modifier 是正则表达式的匹配属性（ "i" / "g" / "i" ）。

如果缺省参数，RegExpObject 被重置为一个空的正则表达式 //。

var reg = /man/ ;
"I'm woman !".replace( reg , "child" ) ;// "I'm wochild !"reg.compile( /(wo)?man/ ) ;
"I'm woman !".replace( reg , "child" ) ;// "I'm child !"

如果 regexp 是正则表达式本身，结果就是重新编译并重置它的属性，比如 lastIndex。

exec

Regex.exec 方法用于检索字符串中正则表达式的匹配。形式如下：

var ResultArray = RegExpObject.exec( string ) ; 

Regex.exec 方法返回一个数组：

• 数组的元素，就是匹配的结果；
• 数组的属性 index 表示匹配发生的位置，input 表示原始字符串；
• 未找到匹配返回 null，而不是空数组 [ ]；

执行 exec 后：

• 如果匹配成功，正则表达式的属性 lastIndex 设为匹配文本后面的位置；
• 如果匹配失败，正则表达式的属性 lastIndex 设为 0 。

非全局匹配的情况下，exec 的返回结果和 String.match 相同。

[ 匹配的结果 , 第 1 个子表达式匹配的结果 , 第二个..... , 第 n 个子表达式匹配的结果 ]

全局匹配的情况下，可以通过反复调用 exec 方法来遍历字符串中的所有匹配文本。

var str = "30-AC-F6-B1-EC-14" ;
var reg = /(\d{2})|([A-Z]{2})/g ;
reg.exec( str ) ;// [ "30" , "30" , undefined ]alert( reg.lastIndex ) ;//  2// 在 "30" 这个匹配结果中, \d{2} 匹配到了 "30", [A-Z]{2} 匹配失败。reg.exec( str ) ;// [ "AC" , undefined , "AC" ]alert( reg.lastIndex ) ;// 5

用 for 来遍历：

var str = "30-AC-F6-B1-EC-14" ;
var reg = /(\d{2})|([A-Z]{2})/g ;
var match = reg .exec( str ) ;
var numberArr = [ ] ;
var literalArr = [ ] ;
while( match ){if( match[ 1 ] )numberArr.push( match[ 1 ] );if( match[ 2 ] )literalArr.push( match[ 2 ] ); match = reg .exec( str ) ;
}
alert("数字："+ numberArr + "   字母：" + literalArr );

1.4 分组

正则表达式中，使用括号 ( ) 进行分组。

分组的正则表达式有两个作用：一是可以让重复的模式作用于整个组而不是单一字符，另一个是可以用特殊转义序列对其进行引用。

var reg = /^(.).*\1$/ ;// 匹配开头和结尾字符相同的字符串reg.test( "seats" ) ;// true

其中使用 \n 引用前面第 n 个 捕获子表达式 的捕获结果。

分组的捕获结果，还可以用 RegExp 的静态属性 $1...$9 引用。在 string.replace 方法中：

var reg = /(\d+)/g ;// 匹配数字"var a = 98 + 23 ;".replace( reg , "<i>$1</i>") ;// "var a = <i>98</i> + <i>23</i> ;"

在 string.replace 的 replacement 参数中 "$1" ... "$9" 拥有特殊意义，引用模式匹配过程中 捕获子表达式 捕获的结果。

也可以在 replacement 外使用 RegExp.$1 ... RegExp.$9 访问对应分组捕获的结果。

var reg = /(\d+)/g ;// 匹配数字"var a = 98 + 23 ;".replace( reg , "<i>" + RegExp.$1 + "</i>") ;// "var a = <i>98</i> + <i>23</i> ;"

var reg = /(\d+)-(\d+)/g ;
reg.exec( "021-88776655,010-99585960" ) ;// ["021-88776655", "021", "88776655"]alert( "区号：" + RegExp.$1 + " 号码：" + RegExp.$2 ) ;// 区号：021 号码：88776655reg.exec( "021-88776655,010-99585960" ) ;// ["010-99585960", "010", "99585960"]alert( "区号：" + RegExp.$1 + " 号码：" + RegExp.$2 ) ;// 区号：010 号码：99585960

2元字符和正则表达式规则

Character	Description
\	\ 标志着下一个字符是一个特殊的字符。元字符拥有特殊的意义，如果想使用这些字符，需用 \ 转义： var reg1 = /\{/ ;// 匹配大括号var reg2 = /\(/ ;// 匹配分组符号var reg3 = /\[/ ;// 匹配中括号var reg4 = /\\/ ;// 匹配反斜杠var reg5 = /\n/ ;// 匹配换行符
^	^ 匹配字符串的开始位置。如果进行多行（Multiline）匹配，^ 也会匹配 \n、\r 后面的位置。 var reg = /^a/ ; reg.test( "ab" ) ;// truereg.test( "ba" ) ;// falsereg = "abc\ndef\rghi" ; reg.replace( /^/gm , "-" ) ;//"-abc\n-def\r-ghi"
$	$ 匹配字符串的结束位置。如果进行多行（Multiline）匹配，$ 也会匹配 \n、\r 前面的位置。 var reg = /a$/ ; reg.test( "ab" ) ;// falsereg.test( "ba" ) ;// truereg = "abc\ndef\rghi" ; reg.replace( /$/gm , "-" ) ;//"abc-\ndef-\rghi-"
*	* 匹配前面的字符或者分组 0 次或多次。如 zo* 匹配 “zo” 和 “zoo”，甚至是 “z”。 + 等价于 {1,} var reg = /zo*/ ;// 或者 /zo{0,}/reg.test( "zoo" ) ;// truereg.test( "zo" ) ;// truereg.test( "z" ) ;// truereg.test( "loo" ) ;// false
+	+ 匹配前面的字符或者分组 1 次或多次。如 zo+ 匹配 “zo” 和 “zoo”，但不匹配 “z”。 + 等价于 {1,} var reg = /zo+/ ;// 或者 /zo{1,}/reg.test( "zoo" ) ;// truereg.test( "zo" ) ;// truereg.test( "z" ) ;// falsereg.test( "loo" ) ;// false
?	? 匹配前面的字符或者分组 1 次或多次。如 do(es)? 匹配 “do” 和 “does” 。 ? 等价于 {0,1} var reg = /do(es)?/ ;// 或者 /do(es){0,1}/reg.test( "do" ) ;// truereg.test( "does" ) ;// truereg.test( "to" ) ;// false
{n}	{n} 匹配前面的字符或者分组 n 次。其中 n 是非负整数。如 o{2} 匹配 "food" 的 2 个 "o" ，不匹配 "do" 中的 1 个 "o" 。 var reg = /o{2}/ ; reg.test( "too" ) ;// truereg.test( "food" ) ;// truereg.test( "to do" ) ;// false
{n,}	{n,} 匹配前面的字符或者分组至少 n 次。其中 n 是非负整数。如 o{1} 匹配 "yahoo" 的 2 个 "o" ，也匹配 "yahooooooooo"中的所有 "o" 。 {1,} 等价于 +。 var reg = /o{2}/ ; reg.test( "google" ) ;// truereg.test( "yahooooo" ) ;// truereg.test( "to do" ) ;// false
{n,m}	{n,m} 匹配前面的字符或者分组至少 n 次、至多 m 次。其中 n 和 m 都是非负整数。如 o{1,3} 匹配 "yahoo" 的前 3 个 "o" ，也匹配 "yahooooooooo"中的前 3 个 "o" 。 {0,1} 等价于 ?。 注意：数字和逗号之间不能有空格。 var reg = /o{2}/ ; reg.test( "google" ) ;// truereg.test( "yahooooo" ) ;// truereg.test( "to do" ) ;// false
?	其实 ? 有两个用途。 第一个用途上面提到了，用来匹配前面字符或分组 0 次或 1 次。 第二个用途，用在其他量词（比如 * , + , ? , {n} , {n,} , {n,m}）的后面，指示匹配模式为 “非贪婪匹配”，与之相反，默认匹配规则是 “贪婪匹配”，即尽量匹配更多的字符。比如，o+ 匹配 “ooooo” 中的全部 “o”，而 o+? 匹配第一个 “o”。 var reg = /o+?/ ; reg.test( "google" ) ;// truereg.test( "yahooooo" ) ;// truereg.test( "to do" ) ;// true
.	. 匹配除了 "\n" 外的任何字符。 想要匹配 "\n" 可以使用 [\s\S]。 var reg = /^a.*a$/ ;// 匹配一行首尾都是 a 的字符串reg.test( "abcdefga" ) ;// truereg.test( "abc") ;// false
(pattern)	(pattern) 匹配模式 pattern 并捕获结果。 RegExp.exec 返回的数组中： 第一个元素是整个正则表达式匹配到的字符串； 后面的元素，依次是针对该次匹配的子表达式 pattern 匹配结果。 想要子表达式捕获结果，需要用 ( ) 包围起来。 var reg = /ch/ ;// 没有子表达式reg.exec( "chese" ) ;// [ "ch" ]reg = /(c)(h)/ ; reg.exec( "chese" ) ;// [ "ch" , "c" , "h" ]reg = /(ch)/ ; reg.exec( "chese" ) ;// [ "ch" , "ch" ]reg = /(ch)|(ese)|(en)/ ; reg.exec( "chese" ) ;// [ "ch" , "ch" , undefined , undefined ]
(?:pattern)	(?:pattern) 匹配模式 pattern 并但不捕获结果。 加 ( ) 有时并不是为了捕获，而仅仅为了 “分组”，这时可以用这个元字符。 var reg = /^.*(?:\.|。)$/ ; 匹配以句号结尾的字符串 reg.exec( "Hello !" ) ;// nullreg.exec( "To be continued ." ) ;// ["To be continued ."]
(?=pattern)	(?=pattern) 零宽正向预测先行断言。断言此位置的后面匹配 pattern ，不捕获结果（零宽）。 先行断言 (?=pattern) 不会消耗字符，也就是说，下一次匹配是从上一次匹配之后的位置开始的，而不是在pattern 之后。 var reg = /Windows (?=2008|7)/g ; // 匹配 "Windows" ，后面必须死 "2008" 或 "7"var str = "最低配置 Windows 2008 ，推荐 Windows 7 。" ; alert( reg.exec( str ) ) ;// [ "Windows" ]alert( reg.lastIndex ) ;// 13 , 第 1 个 "Windows" 后面的位置alert( reg.exec( str ) ) ;// [ "Windows" ]alert( reg.lastIndex ) ;// 30 , 第 2 个 "Windows" 后面的位置
(?!pattern)	(?!pattern) 零宽负向预测先行断言，断言此位置的后面不匹配 pattern ，不捕获结果（零宽）。 先行断言 (?!pattern) 不会消耗字符，同上。 var reg = /Windows (?!2000|xp)/g ;// 匹配 "Windows" ，后面不能是 "2000" 或 "xp"var str = "最低配置 Windows 2008 ，推荐 Windows 7 。" ; alert( reg.exec( str ) ) ;// [ "Windows" ]alert( reg.lastIndex ) ;// 13 , 第 1 个 "Windows" 后面的位置alert( reg.exec( str ) ) ;// [ "Windows" ]alert( reg.lastIndex ) ;// 30 , 第 2 个 "Windows" 后面的位置
x|y	x|y 匹配 x 或 匹配 y 。 比如 see|saw 匹配 "see"，也可以匹配 "saw" var reg = /hello|hi/i ;// 匹配问候语 hello , hi , 忽略大小写reg.test( "Hello" ) ;// truereg.test( "Hi, are you ok !") ;// true
[xyz]	[xyz] 代表一个字符集（字符集中的元字符不需要转义）。匹配任何出现在中括号 [ ] 中的字母 。 比如 [abc] 匹配 "plain" 中的 “a”。 可以使用 - 表示字符的范围： 英文字母： [a-zA-Z] ； 阿拉伯数字： [0-9] ； 罗马数字： [Ⅰ-Ⅻ] ； 希腊字母、拼音字母…… ； Unicode 字符编码：[udddd-udddd]，其中 d 代表一个 16 进制的数字； Latin-1 字符编码：[xdd-xdd]，其中 d 代表一个 16 进制的数字； var reg = /[a-zA-Z-_]+/g ;// 匹配英文单词"I wanna be a scientist .".match( reg ) ;// ["I", "wanna", "be", "a", "scientist"]
[^xyz]	[^xyz] 代表一个排除字符集，不匹配任何出现在中括号 [ ] 中的字母 。 比如 [^abc] 匹配 "see" 中的 “s”。 var reg = /[<][^>].*?[>]/g ;// 匹配带尖括号的内容"<div></div>".match( reg ) ;// [ "<div>" , "</div>" ]
\b	\b 匹配单词边界。 比如 er\b 匹配 "her" 中的 “er”，但不匹配 “verb” 中的 “er” 。 \b通常用于查找位于单词的开头或结尾的匹配。 var reg = /\b[a-zA-Z-_]+(es|s)\b/g ;// 匹配以 "es" 或 "s" 结尾的单词"I bought 1 cup, 5 apples, and 6 dozens of eggs".match( reg ) ;// [ "apples" , "dozens" , "eggs" ]
\B	\B 匹配非单词边界的位置。 匹配位置的上一个和下一个字符的类型是相同的：即必须同时是单词字符，或必须同时是非单词字符； 字符串的开头和结尾处被视为非单词字符。 比如 er\B 不匹配 "her" 中的 “er”，匹配 “verb” 中的 “er” 。 \B通常用于排除位于单词的开头或结尾的匹配。 var reg = /[a-z-_]*\Boo\B[a-z-_]*/ig ;//匹配内部出现 "oo" 的单词。"I like reading book in the room too !".match( reg ) ;// [ "book" , "room" ]
\cx	\cx 匹配由 x 字符表示的控制字符。 如 \cM 表示 Ctl+M 或回车字符 "\r"，\cJ 表示换行符 "\n"。 /td>
\d	\d 匹配一个数字，相当于 [0-9] 。 var reg = /\d\d/g ;// 匹配两个连续的数字"[55,25,2422,579]".match( reg ) ;// ["55", "25", "24", "22", "57"]
\D	\D 匹配一个非数字的字符，相当于 [^0-9] 。
\f	\f 匹配一个换页符，相当于 \x0c 或 \cL 。
\n	\n 匹配一个换行符，相当于 \x0a 或 \cJ 。
\r	\r 匹配一个回车符，相当于 \x0d 或 \cM 。
\s	\s 匹配空白字符，包括空格 " "、制表符 "\t"、翻页符 "\f"、换行符 "\n"、垂直制表符 "\t"。 相当于 [\f\n\r\t\v]
\S	\S 匹配非空白字符，相当于 [\f\n\r\t\v]
\t	\t 匹配制表符，相当于 \x09、\cI。
\v	\v 匹配垂直制表符，相当于 \x0b 、\cK。
\w	\w 匹配任何单词字符，包括下划线，相当于 [A-Za-z0-9_] 。
\W	\w 匹配任何非单词字符，相当于 [^A-Za-z0-9_] 。
\xn	\xn 匹配 Latin-1 字符，其中的 n 为 16 位的数字。 。 所有的 ASCII 字符都可以用 \xn 来表示，如 \x41 匹配 “A” 。
\num	\num 引用前面第 num 个 捕获子表达式 捕获到的字符串。num 是一个正整数。 如 (.)\1 同一个字符匹配两次。 var reg = /(.)\2/g ; "book、see".match( reg ) ;// ["oo", "ee"]
\n	\n n 代表一个数字。 如果 \n 前面有至少 n 个 捕获子表达式 ，那么它就作为 “后向引用”，等同于上面的 \num 。 如果不满足上面的条件，n 又是一个八进制（0-7），那么它作为八进制转义码。 /\2/.test("") ;// true
\nm	\nm n 、 m 代表一个数字。 如果 \nm 前面是一个捕获字表达式： 如果 \nm 至少有 nm 个捕获字表达式，则将 \nm 视作后向引用； 如果 \nm 至少有 n 个捕获字表达式，则将 \n 视作后向引用，m 作为一个普通数字； 如果不满足上面的条件，n、m 又是八进制（0-7），那么 \nm 作为八进制转义码。
\nml	\nmlnm 当 n 在 0 - 3 间，m、l 在 0 - 7 间， 匹配八进制转义码 nml 。
\un	\un 匹配编码为 n 的 Unicode 字符 。 /\u00A9/.test("©") ;// true

相关文章

• Javascript – 字符串
• Javascript – 集合
• JavaScript Scope Chains and Closures
• Javascript – 对象
• Javascript – 控制语句
• Javascript – 表达式和运算符
• Javascript – Explaining JavaScript scope and closures
• Javascript – 常量和变量