js中正则表达式的模式匹配

参考Javascript权威指南（第6版）第10章

1、正则表达式的定义

正则表达式有两种定义方法，通常使用直接量方式。

（1）直接量

var pattern = /\d$/;
var pattern = /\d$/gim;

（2）RegExp()构造函数

注意转义字符前面的"\"必须换成"\\"。
var pattern = RegExp("\\d$","gim");

正则表达式三个修饰符的含义:

字符	含义
i	不区分大小写
g	全局匹配
m	多行匹配

正则表达式中，需要转义的标点符号包括：^$.*+?=!😐/()[]{}

如果不记得哪些标点符号需要反斜线转义，可以在每个标点符号前都加上反斜线“\”

2、正则表达式的字符类

字符	匹配
[...]	括号内的任意字符
[^...]	不在括号内的任意字符
.	除换行符和其他Unicode行终止符之外的任意字符
\w	[a-zA-Z0-9]
\W	[^a-zA-Z0-9]
\s	任何Unicode空白符
\S	任何非Unicode空白符的字符
\d	[0-9]
\D	[^0-9]
[\b]	退格直接量

3、正则表达式的重复字符语法

（1）贪婪匹配

尽可能多的匹配，见下表。

字符	含义
	匹配前一项n~m次
	匹配前一项n次及以上
	匹配前一项n次
?	匹配前一项0或1次，
+	匹配前一项1或多次，
*	匹配前一项0或多次，

（2）非贪婪匹配

在待匹配的字符后加一个问号“?”

举例：

var str = 'aaa';
var p1 = /a+/;//贪婪匹配
var p2 = /a+?/;//非贪婪匹配
var str1 = p1.exec(str);//aaa
var str2 = p2.exec(str);//a

4、选择-组合-引用

字符	含义
I	选择
(...)	组合，并且该组合匹配的字符串可供引用
(?:...)	只组合，不供引用
\n	第n个可引用分组第一次匹配的字符，n为可引用分组左括号的序号，从1开始

选择举例：

var str1 = "abc";
var str2 = "bac";
var pattern = /ab|ac|ba|bc/;//选择
var str11 = pattern.exec(str1);//ab
var str22 = pattern.exec(str2);//ba
alert(str11+"---"+str22);

组合、只组合举例：

//exec返回一个数组：元素0是与正则表达式匹配的字符串，余下元素是与圆括号内的子表达式相匹配的子串
//例1
var str = "aaaabaabcdcdef";
var p1 = /(a+b)+(cd)+/;//组合
var p2 = /(a+b)+(?:cd)+/;//只组合
var str1 = p1.exec(str);//aaaabaabcdcd,aab,cd 
var str2 = p2.exec(str);//aaaabaabcdcd,aab
alert(str1+"---"+str2);
//例2
var str = "agtAGe4545";
var p1 = /[a-zA-Z]*(\d+)/;//组合从字符串中抽取右侧数字
var p2 = /[a-zA-Z]*(?:\d+)/;//只组合,无法抽取右侧数字
var str1 = p1.exec(str);//agtAGe4545,4545
var str2 = p2.exec(str);//agtAGe4545
alert(str1+"---"+str2);

\n举例：

var str1 = "JavaScript9900script";
var str2 = "JavaScript9900Script";
var p1 = /([Jj]ava([Ss]cript))\d*\2/;//组合([Jj]ava([Ss]cript))
var p2 = /(?:[Jj]ava([Ss]cript))\d*\1/;//只组合(?:[Jj]ava([Ss]cript))
var str11 = p1.exec(str1);//null
var str22 = p1.exec(str2);//JavaScript9900Script,JavaScript,Script
var str33 = p2.exec(str2);//JavaScript9900Script,Script
alert(str11+"---"+str22+"---"+str33);

5、锚字符

字符	含义
^	字符串开头
$	字符串结尾
\b	单词边界或开头或结尾
\B	非单词边界
(?=p)	零宽正向先行断言，接下来的字符与p匹配
(?!p)	零宽负向先行断言，接下来的字符不与p匹配

开头、结尾举例：

var str1 = "abbc";
var str2 = "fbbcd";
var p1 = /^a[\w]+c$/;
var p2 = /[\w]+c$/;
var str11 = p1.exec(str1);//abbc
var str22 = p2.exec(str2);//null
alert(str11+"---"+str22);

单词边界与非单词边界举例：

var str1 = "javascript is good";
var str2 = "java is good";
//匹配java单词本身，而javascript中的java不进行匹配
var p1 = /\bjava\b/;//\b匹配单词边界或开头或结尾
var str11 = p1.exec(str1);//null
var str22 = p1.exec(str2);//java
alert(str11+"---"+str22);
//匹配javascript中的java，java单词本身不进行匹配
var p2 = /java\B/;//\B匹配非单词边界
var str33 = p2.exec(str1);//java
var str44 = p2.exec(str2);//null
alert(str33+"---"+str44);

零宽正/负向先行断言举例：

var str = 'javascriptTool';
var p1 = /java(?=script)([a-z]\w*)/;
var p2 = /java(?!script)([a-z]\w*)/;
var str1 = p1.exec(str);//["javascriptTool","scriptTool"]
var str2 = p2.exec(str);//null

6、RegExp对象

5个属性和3个方法

• global:boolean,是否有“g”属性
• ignoreCase:boolean,是否有“i”属性
• multiline:boolean,是否有“m”属性
• lastIndex:下一个匹配开始的位置
• source:正则表达式的文本

（1）exec

pattern.exec(str)

下面两种情况，exec总是包含它返回的数组中的每个匹配项的全部细节。
情况一：pattern是非全局模式
没有找到任何匹配则返回null；
找到匹配则返回数组（非全局检索），数组的元素0是与正则表达式匹配的字符串，余下元素是与圆括号内的子表达式相匹配的子串。该数组除了有一般的length属性外，还有index属性（返回匹配文本的第一个字符位置）和input属性（返回输入的str）。
情况二：pattern是全局模式
将从pattern的lastIndex属性指定的位置开始搜索，找到一个匹配项后，将lastIndex设为该匹配项之后的第一个字符的位置。这使得可以重复循环调用exec()，遍历一个字符串中所有匹配项。如果exec()找不到匹配项，则返回null，并将lastIndex重置为0。注意：如果在成功找到一个字符串的匹配项之后，立刻开始搜索另一个新字符串，必须手动将lastIndex重置为0。
举例：

var str = "agtAGe45agt67";
var p1 = /[a-zA-Z]*(\d+)/;
var str1 = p1.exec(str);
$('body').append("非全局<br>");
$('body').append("str1.input="+str1.input+"<br>");
$('body').append("str1.index="+str1.index+"<br>");
$('body').append("str1="+str1+"<br>");
//$('body').append("str1.length="+str1.length+"<br>");
$('body').append("p1.lastIndex="+p1.lastIndex+"<br>");
var p2 = /[a-zA-Z]*(\d+)/g;//全局
$('body').append("全局<br>");
while((str2 = p2.exec(str))!=null){
	$('body').append("-------------------<br>");
	$('body').append("str2.input="+str2.input+"<br>");
	$('body').append("str2.index="+str2.index+"<br>");	
	$('body').append("str2="+str2+"<br>");
	//$('body').append("str2.length="+str2.length+"<br>");
	$('body').append("p2.lastIndex="+p2.lastIndex+"<br>");	
}

结果：

非全局
str1.input=agtAGe45agt67
str1.index=0
str1=agtAGe45,45
p1.lastIndex=0
全局
-------------------
str2.input=agtAGe45agt67
str2.index=0
str2=agtAGe45,45
p2.lastIndex=8
-------------------
str2.input=agtAGe45agt67
str2.index=8
str2=agt67,67
p2.lastIndex=13

（2）test

pattern.test(str)

如果匹配返回true,反正返回false

（3） toString

pattern.toString()

使用正则表达式直接量的格式返回一个正则表达式的字符串表示

7、用于模式匹配的String方法

(1) search

str.search(pattern);//pattern可以为字符串

返回第一个与pattern匹配的子串的起始位置；如果找不到子串，则返回-1。不支持全局检索，因为它忽略正则表达式中的g。
举例：

var str = "abcdefg123456";
var r = str.search(/\d/);//7

(2) replace

情况一：

str.replace(pattern,str2);

如果pattern中有g，则替换str中所有与pattern匹配的子串为str2；
如果无g，则只替换str中第一个与pattern匹配的子串为str2。
str2中的"$"含义见下表。

字符	替换
$1,$2,...,$99	匹配第1~99个pattern中的圆括号子表达式的文本
$&	匹配pattern的子串
$`	匹配子串的左边文本
$'	匹配子串的右边文本
$$	美元符号

举例：确保“JavaScript”大小写正确

var str = "javascript javAScript";
var p1 = /javascript/i;//非全局，只替换第一个匹配的
var p2 = /javascript/gi;//全局，替换所有匹配的
var r1 = str.replace(p1,"JavaScript");//JavaScript javAScript
var r2 = str.replace(p2,"JavaScript");//JavaScript JavaScript
alert(r1+"---"+r2);

举例1：将一个名字从"Doe,John"转换为"John Doe"

var str = "Doe,John";
var pattern = /([a-zA-z]+)\s*\,\s*([a-zA-z]+)/;
var r = str.replace(pattern,"$2 $1");//John Doe
alert(r);

举例2：将成对双引号替换为成对单引号

var str = "\"Doe,John\"\"Doe,John\"";
var pattern = /\"([^\"]*)\"/g;
var r = str.replace(pattern,"\'$1\'");//'Doe,John''Doe,John'
alert(str+"---"+r);//"Doe,John""Doe,John"---'Doe,John''Doe,John'

情况二：

str.replace(str1,str2);

如果第一个参数是字符串而非正则表达式，则只有第一个str1替换为str2。
举例：

var str = "javascript javascript";
//使用字符串，则只替换第一个匹配的。
var r = str.replace("javascript","JavaScript");//JavaScript javascript
alert(r);

情况三：

str.replace(pattern,func);

如果第二个参数是函数，则func将在每个匹配结果上调用，func返回的字符串则将作为替换文本。传入func的第一个参数是匹配pattern的字符串，剩下的参数（可能有0或多个）是匹配该pattern的某个圆括号子表达式的字符串，下一个参数为str中出现匹配结果的位置，最后一个参数是str本身。
举例：将一个字符串中所有单词的首字母大写

var str = "this is a demo";
var pattern = /\b[a-zA-Z]+\b/g;
var r = str.replace(pattern,function(word){
	return word.substring(0,1).toUpperCase()+word.substring(1);
});//This Is A Demo
alert(r);

(3) match

match是最常用的String正则表达式方法。

str.match(pattern);

如果pattern中有g，则返回的数组包含所有匹配结果；
如果无g，则返回的数组的元素0是第一个匹配结果，余下元素是pattern中圆括号子表达式。
可见，对于一个非全局pattern，str.math(pattern)与pattern.exec(str)的结果一样。返回的数组有两个属性（与exec相同）：index和input。
举例：

var str = 'js is good';
var p1 = /\b([\w])+\b/;//非全局
var r1 = str.match(p1);
$('body').append(r1+'<br>');//js,s
$('body').append(r1.index+'<br>');//0
$('body').append(r1.input+'<br>');//js is good
var p2 = /\b[\w]+\b/g;//全局
var r2 = str.match(p2);
$('body').append(r2+'<br>');//js,is,good
$('body').append(r2.index+'<br>');//undefined
$('body').append(r2.input+'<br>');//undefined

举例：获取url的各个部分

var url = /(\w+):\/\/([\w.]+)\/(\S*)/;
var text = 'visit blog at http://www.example.com/~david';
var result = text.match(url);
if(result!=null){
	var fullurl = result[0];
	var protocol = result[1];
	var host = result[2];
	var path = result[3];
}
$('body').append(fullurl+'<br>');//http://www.example.com/~david
$('body').append(protocol+'<br>');//http
$('body').append(host+'<br>');//www.example.com
$('body').append(path+'<br>');//~david

(4) split

String.split()是Array.join()的反方法。

str.split(pattern,limit)//pattern可以为字符串

将str拆分为一个子串组成的数组，子串不包含pattern本身（特例除外）。limit为可选参数，指定返回数组的最大长度。
特例：如果pattern是一个包含圆括号表达式的正则表达式，则匹配这些圆括号表达式的子串（但不是匹配整个pattern的文本）将包含在返回数组中。
例1：

var str1 = "1|2|3";
var str2 = "|1|2|3|"
var r1 = str1.split("|");//1,2,3
var r2 = str2.split("|");//,1,2,3,
$('body').append(r1+'<br>');
$('body').append(r2+'<br>');

例2：

//句子切分为单词
var str1 = "js is good";
var r1 = str1.split(/\s+/);
$('body').append(r1+'<br>');//js,is,good
//单词切换为单一字母
var str2 = "good";
var r2 = str2.split("");
var r3 = str2.split("",2);
$('body').append(r2+'<br>');//g,o,o,d
$('body').append(r3+'<br>');//g,o

例3：希望返回的数组包含分隔符，则pattern应使用圆括号

var str = "ab12cd34ef";
var p1 = /\d+/;
var r1 = str.split(p1);
$('body').append(r1+'<br>');//ab,cd,ef
var p2 = /(\d+)/;//带圆括号
var r2 = str.split(p2);
$('body').append(r2+'<br>');//ab,12,cd,34,ef