原文地址:https://wangdoc.com/javascript/
RegExp对象提供正则表达式功能。
概述
新建正则表达式有两种方法,一种是使用字面量,以斜杠表示开始和结束。(推荐)
var regex = /xyz/;
另一种是使用RegExp构造函数。
var regex = new RegExp("xyz");
它们的区别在于,第一种方法在引擎编译代码时,就会新建正则表达式,第二种方法在运行时新建正则表达式,所以第一种方式效率较高。
RegExp构造函数还可以接受第二个参数,表示修饰符。
var regex = new RegExp("xyz", "i");
// 等价于
var regex = /xyz/i;
实例属性
正则对象的实例属性分为两类。
一类是修饰符相关,返回一个布尔值,表示对应的修饰符是否设置。
- RegExp.prototype.ignoreCase:返回一个布尔值,表示是否设置了i修饰符。
- RegExp.prototype.global:返回一个布尔值,表示是否设置了g修饰符。
- RegExp.prototype.multiline:返回一个布尔值,表示是否设置了m修饰符。
上面三个属性都是只读的。
另一类是与修饰符无关的属性,主要是下面两个。 - RegExp.prototype.lastIndex:返回一个整数,表示下一次开始搜索的位置。该属性可读写,但是只在进行连续搜索是有意义。
- RegExp.prototype.source:返回正则表达式的字符串形式(不包括反斜杠),该属性只读。
var r = /abc/igm;
r.lastIndex; // 0
r.source; // abc
实例方法
RegExp.prototype.test()
正则实例对象的test方法返回一个布尔值,表示当前模式是否能匹配参数字符串。
/cat/.test("cats and dogs"); // true
如果正则表达式带有g修饰符,则每一次test方法都从上一次结束的位置开始向后匹配。
var r = /x/g;
var s = "_x_x";
r.lastIndex // 0
r.test(s) // true
r.lastIndex // 2
r.test(s) // true
r.lastIndex // 4
r.test(s) // false
注意,带有g的修饰符时,正则表达式内部会记住上一次的lastIndex属性,这时不应该更换要匹配的字符串,否则会有一些难以察觉的错误。
var r = /bb/g;
r.test("bb"); // true
r.test("-bb-"); // false
lastIndex属性只对同一个正则表达式有效,所以下面这样写是错误的。
var count = 0;
while (/a/g.test("babaa")) {
count++;
}
上面代码会导致无限循环,因为while循环的每次匹配条件都是一个新的正则表达式,导致lastIndex属性总是等于0。
如果正则表达式是一个空字符串,则匹配所有字符串。
new RegExp("").test("abc"); // true
RegExp.prototype.exec()
正则实例对象的exec方法,用来返回匹配结果。如果发现匹配,就返回一个数组,成员是匹配成功的子字符串,否则返回null。
var s = "_x_x";
var r1 = /x/;
var r2 = /y/;
r1.exec(s); // ["x"]
r2.exec(s); // null
如果正则表达式包含圆括号(即含有组匹配),则返回的数组会包含多个成员。第一个成员是整个匹配成功的结果,后面的成员就是圆括号对应的匹配成功的组。也就是说,第二个成员对应第一个括号,第三个成员对应第二个括号,依此类推。
var s = "_x_x";
var r = /_(x)/;
r.exec(s) // ["_x", "x"]
上面返回的第一个成员是整个正则匹配的结果,第二个成员是圆括号内正则匹配的结果。
exec方法的返回数组还包含以下两个属性:
- input:整个原字符串。
- index:整个模式匹配成功的开始位置(从0开始计数)。
var r = /a(b+)a/;
var arr = r.exec("_abbba_aba_");
arr // ["abbba", "bbb"]
arr.index // 1
arr.input // "_abbba_aba_"
如果正则表达式加上g修饰符,则可以使用多次exec方法,下一次搜索的位置从上次匹配成功结束的位置开始。
var reg = /a/g;
var str = "abc_abc_abc";
var r1 = reg.exec(str);
r1 // ["a"]
r1.index // 0
reg.lastIndex // 1
var r2 = reg.exec(str);
r2 // ["a"]
r2.index // 0
reg.lastIndex // 4
字符串的实例方法
字符串的实例方法之中,有4种与正则表达式有关。
- String.prototype.match():返回一个数组,成员是所有匹配的字符串。
- String.prototype.search():按照给定的正则表达式进行搜索,返回一个整数,表示匹配开始的位置。
- String.prototype.replace():按照给定的正则表达式进行替换,返回替换后的字符串。
String.prototype.split():按照给定规则进行字符串分割,返回一个数组,包含分割后的各个成员。
String.prototype.match()
字符串实例对象的match方法对字符串进行正则匹配,返回匹配结果。
在正则表达式没有g修饰符,该方法与正则对象的exec行为相同。
在正则表达式带有g修饰符,则该方法会一次性返回所有成功匹配的结果。
var s = "abba";
var r = /a/g;
s.match(r); ["a", "a"]
r.exec(s) // ["a"]
设置正则表达式的lastIndex属性,对match方法无效,匹配总是从字符串的第一个字符开始。
String.prototype.search()
字符串对象的search方法,返回第一个满足条件的匹配结果在整改字符串中的位置。如果没有匹配,则返回-1。
String.prototype.replace()
字符串对象的replace方法可以替换匹配的值。它接受两个参数,第一个是正则表达式,表示搜索模式,第二个是替换内容。如果正则表达式不加g修饰符,就替换第一个匹配成功的值,否则替换所有匹配成功的值。
"aaa".replace("a", "b"); // "baa"
"aaa".replace(/a/, "b"); // "baa"
"aaa".replace(/a/g, "b"); // "bbb"
replace方法的一个应用,就是消除字符串首尾两端的空格。
var str = " #id div.class ";
str.replace(/^\s+|\s+$/g, "")
replace方法的第二个参数可以使用美元符号$,用来指代所替换的内容。
- $&:匹配的子字符串。
- $`:匹配结果前面的文本
- $':匹配结果后面的文本。
- $n:匹配成功的第n组内容,n是从1开始的自然数
- $$:指代美元符号。
"hello world".replace(/(\w+)\s(\w+)/, "$2 $1"); "world hello"
"abc".replace("b", "[$`-$&-$\']"); // "a[a-b-c]c"
replace方法的第二个参数还可以是一个函数,将每一个匹配内容替换为函数返回值。
"3 and 5".replace(/[0-9]+/g, function(match) {
return 2 * match;
});
// "6 and 10"
var a = "The quick brown fox jumped over the lazy dog.";
var pattern = /quick|brown|lazy/ig;
a.replace(pattern, function(match) {
return match.toUpperCase();
});
作为replace方法第二个参数的替换函数,可以接受多个参数。其中,第一个参数是捕捉到的内容,第二个参数是捕捉到的组匹配(有多少个组匹配,就有多少个对应的参数)。此外,最后还可以添加两个参数,倒数第二个参数是捕捉到的内容在整个字符串的位置,最后一个参数是原字符串。
var prices = {
"p1": "$1.99",
"p2": "$9.99",
"p3": "$5.00"
};
var template = '<span id="p1"></span>'
+ '<span id="p2"></span>'
+ '<span id="p3"></span>';
template.replace(/(<span id=")(.*?)(">)(<\/span>)/g, function(match. $1, $2, $3, $4) {
return $1 + $2 + $3 + prices[$2] + $4;
});
String.prototype.split()
字符串对象的split方法按照正则规则分割字符串,返回一个由分割后的各个部分组成的数组。
str.split(separator, [limit])
该方法接受两个参数,第一个参数是正则表达式,表示分隔规则,第二个参数是返回数组的最大成员。
"a, b,c, d".split(","); // ["a", " b", "c", " d"]
// 正则分割,去除空格
"a, b,c, d".split(/, */); // ["a", "b", "c", "d"]
"a, b,c, d".split(/, */, 2); // ["a", "b"]
"aaa*a*".split(/a*/); // ["", "*", "*"]
"aaa**a*".split(/a*/); // ["", "*", "*", "*"] 第一个分隔符为aaa,第二个分隔符为0个a
如果正则表达式带有括号,则括号匹配的部分也会作为数组成员返回。
"aaa*a*".split(/(a*)/); ["", "aaa", "*", "a", "*"]
匹配规则
字面量字符和元字符
大部分字符串再正则表达式中,就是字面的含义,比如/a/匹配a。
点字符(.)
点字符(.)匹配除回车(\r)、换行(\n)、行分隔符(\u2028)和段分隔符(\u2029)以外的所有字符。注意,码点大于0xFFFF字符,点字符不能正确匹配。
比如c.t匹配cat、c2t但是不匹配coot。
位置字符串
位置字符用来提示字符所处的位置,主要有两个字符。
- ^表示字符串的开始位置
$表示字符串的结束位置
选择符(|)
选择符(|)在正则表达式中表示或关系(OR),即cat|dog表示匹配cat或dog。
转义符
正则表达式中,需要反斜杠转义,一共有12个字符:^、.、[、$、(、)、|、*、+、?、{和\。如果使用RegExp方法生成正则对象,转义需要使用两个斜杠,因为字符串内部会先转义一次。
(new RegExp("1\\+1")).test("1+1"); // true
特殊字符
- \cX表示Ctrl-[X],其中的X是A-Z之中任一个英文字母,用来匹配控制字符。
- [\b]匹配退格键(U+0008),不要与\b混淆。
- \n匹配换行键。
- \r匹配回车键。
- \t匹配制表符。
- \v匹配垂直制表符。
- \f匹配换页符。
- \0匹配null字符。
- \xhh匹配一个以两位十六进制数(\x00-xFF)表示的字符。
\uhhhh匹配一个以四位十六进制数(\u0000-\uFFFF)表示的Unicode字符。
字符类
字符类表示有一系列字符可供选择,只要匹配其中一个就可以了。所有可供选择的字符都放在方括号内,比如[xyz]表示x、y、z之中任选一个匹配。
脱字符(^)
如果方括号内的第一个字符是^,则表示除了字符类之中的字符,其他的字符都可以匹配。比如[^xyz]除了x、y、z之外都可以匹配。
如果方括号内没有其他字符,即只有[^],就表示匹配一切字符,其中包括换行符。相比之下,点号作为元字符(.)是不包括换行符的。
var s = "Please yes\nmake my day!"
s.match(/yes.*day/); // null
s.match(/yes[^]*day/); // ["yes\nmake my day"]
注意,脱字符只有在字符类的第一个位置(即[]内的第一个字符)才有特殊含义,否则就是字面含义。
连字符(-)
连字符(-)用来提供简写形式,表示字符的连续范围。比如,[abc]可以写成[a-c],[1-31]不代表1到31,只代表1到3。
连字符还可以用来指定Unicode字符的范围,例如[\u0128-\uFFFF]。
预定义模式
预定义模式指的是某些常见模式的简写方式。
- \d匹配0-9之间的任一数字,相当于[0-9]。
- \D匹配所有0-9以外的字符,相当于[^0-9]。
- \w匹配任意的字母、数字和下划线,相当于[A-Za-z0-9_]。
- \W除所有字母、数字和下划线之外的字符,相当于[^A-Za-z0-9_]。
- \s匹配空格(包括换行符、制表符、空格符等),相当于[ \t\r\n\v\f]。
- \S匹配非空格的字符,相当于[^ \t\r\n\v\f]。
- \b匹配词的边界。
- \B匹配非词边界,即在词的内部。
/\bworld/.test("hello world") // true
/\bworld/.test(helloworld) // false
\b表示词的边界,所有world的词首必须独立(词尾是否独立未指定),才会匹配。
重复类
模式的精确匹配次数,使用大括号({})表示。{n}表示恰好重复n次,{n,}表示至少重复n次,{n,m}表示重复不少于n次,不多于m次。
量词符
量词符用来设定某个模式出现的次数。
- ?问号表示某个模式出现0次或1次,等同于{0, 1}。
- *星号表示某个模式出现0次或多次,等同于{0,}。
+加号表示某个模式出现1次或多次,等同于{1,}。
贪婪模式
三个量词符都是最大可能匹配,即匹配直到下一个字符不满足匹配规则为止。这种成为贪婪模式。如果想将贪婪模式改为非贪婪模式,可以在量词符后面加一个问号。
var s = "aaa";
s.match(/a+?/); // ["a"]
修饰符
g修饰符
见前文。
i修饰符
见前文。
m修饰符
m修饰符表示多行模式。会修改^和$的行为。不加m修饰符时,^和$匹配字符串的开始和结尾,加上m修饰符以后,^和$还会匹配行首和行尾,即^和$会识别换行符\n。
/world$/.test("hello world\n"); false
/world$/m.test("hello world\n"); true
组匹配
概述
正则表达式的括号表示分组匹配,括号中的模式可以用来匹配分组的内容。
var m = "abcabc".match(/(.)b(.)/);
m // ["abc", "a", "c"]
注意,使用组匹配时,不宜同时使用g修饰符,否则match方法不会捕获分组的内容。
正则表达式内部,还可以用\n引用括号匹配的内容,n从1开始的自然数,表示对应顺序的括号。
/(.)b(.)\1b\2/.test("abcabc") // true
上面的代码中,\1表示第一个括号匹配的内容(即a),\2表示第二个括号匹配的内容(即c)。
括号还可以嵌套。
/y((..)\2)\1/.test("yabababab") // true
上面代码中,\1指向外层括号,\2指向内层括号。
非捕获组
(?:x)成为非捕获组,表示不返回改组匹配的内容,即匹配的结果中不计入这个括号。
var m = "abc".match(/(?:.)b(.)/);
m // ["abc", "c"]
先行断言
x(?=y)称为先行断言,x只有在y前面才匹配,y不会被计入返回结果。比如,要匹配后面跟着百分号的数字,可以写成/\d+(?=%)/。
var m = "abc".match(/b(?=c)/);
m // ["b"]
上面代码中,使用了先行断言,b在c前面所以被匹配,但是括号对应的c不会被返回。
先行否定断言
x(?!y)称为先行否定断言,x只有不在y前面才匹配,y不被计入返回结果。