Regexp对象

概述
实例属性
实例方法
RegExp.prototype.test()g
RegExp.prototype.exec()g括号indexx input属性
字符串的实例方法
String.prototype.match()像exec返回字符串数组 区别g一次返回全部 lastibdex无效
String.prototype.search()
String.prototype.replace()加g一次换全部
String.prototype.split()
匹配规则
字面量字符和元字符
转义符
特殊字符
字符类
预定义模式
重复类
量词符
贪婪模式
修饰符
组匹配

1.概述
正则表达式(regular expression)是一种表达文本模式(即字符串结构)的方法

1.1新建正则表达式有两种方法。一种是使用字面量,以斜杠表示开始和结束。

var regex = /xyz/;
另一种是使用RegExp构造函数。

var regex = new RegExp('xyz');

主要区别是,第一种方法在引擎编译代码时,就会新建正则表达式,第二种方法在运行时新建正则表达式,所以前者的效率较高

RegExp构造函数还可以接受第二个参数,表示修饰符(详细解释见下文)。

var regex = new RegExp('xyz', 'i');
// 等价于
var regex = /xyz/i;

2.实例属性
正则对象的实例属性分成两类。

一类是修饰符相关,用于了解设置了什么修饰符。

RegExp.prototype.ignoreCase:返回一个布尔值,表示是否设置了i修饰符。
RegExp.prototype.global:返回一个布尔值,表示是否设置了g修饰符。
RegExp.prototype.multiline:返回一个布尔值,表示是否设置了m修饰符。
RegExp.prototype.flags:返回一个字符串,包含了已经设置的所有修饰符,按字母排序。
上面四个属性都是只读的。

var r = /abc/igm;

r.ignoreCase // true
r.global // true
r.multiline // true
r.flags // 'gim'

另一类是与修饰符无关的属性,主要是下面两个。

RegExp.prototype.lastIndex:返回一个整数,表示下一次开始搜索的位置。该属性可读写,但是只在进行连续搜索时有意义,详细介绍请看后文。
RegExp.prototype.source:返回正则表达式的字符串形式(不包括反斜杠),该属性只读。
var r = /abc/igm;

r.lastIndex // 0
r.source // "abc"

3.实例方法
3.1RegExp.prototype.test()
返回布尔值,看是否匹配
3.1.1带g
(1)则每一次test方法都从上一次结束的位置开始向后匹配。 回记住lastindex
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

(2)可以指定lastIndex属性指定开始搜索的位置,
var r = /x/g;
var s = '_x_x';

r.lastIndex = 4;
r.test(s) // false

r.lastIndex // 0
r.test(s)

(3)注意,带有g修饰符时,正则表达式内部会记住上一次的lastIndex属性,这时不应该更换所要匹配的字符串,否则会有一些难以察觉的错误。

var r = /bb/g;
r.test('bb') // true
r.test('-bb-') // false

(4)lastIndex属性只对同一个正则表达式有效,所以下面这样写是错误的。

var count = 0;
while (/a/g.test('babaa')) count++;
上面代码会导致无限循环,因为while循环的每次匹配条件都是一个新的正则表达式,导致lastIndex属性总是等于0。每次新建一个regexp对象

3.1.3如果正则模式是一个空字符串,则匹配所有字符串。

new RegExp('').test('abc')
// true

3.1.2RegExp.prototype.exec()
匹配到的返回字符串数组,只有一个元素的数组。否则返回null

(1)有括号(组匹配) 返回多个成员

第一个成员是整个匹配成功的结果,后面的成员就是圆括号对应的匹配成功的组。也就是说,第二个成员对应第一个括号,第三个成员对应第二个括号,以此类推。整个数组的length属性等于组匹配的数量再加1。

var s = '_x_x';
var r = /_(x)/;

r.exec(s) // ["_x", "x"]
上面代码的exec方法,返回一个数组。第一个成员是整个匹配的结果,第二个成员是圆括号匹配的结果。

(2)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_"
上面代码中的index属性等于1,是因为从原字符串的第二个位置开始匹配成功。

(3)正则表达式加上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 // 4
reg.lastIndex // 5

var r3 = reg.exec(str);
r3 // ["a"]
r3.index // 8
reg.lastIndex // 9

var r4 = reg.exec(str);
r4 // null
reg.lastIndex // 0

连续用了四次exec方法,前三次都是从上一次匹配结束的位置向后匹配。当第三次匹配结束以后,整个字符串已经到达尾部,匹配结果返回null,正则实例对象的lastIndex属性也重置为0,意味着第四次匹配将从头开始。

g修饰符允许多次匹配的特点,可以用一个循环完成全部匹配。

var reg = /a/g;
var str = 'abc_abc_abc'

while(true) {
var match = reg.exec(str);
if (!match) break;
console.log('#' + match.index + ':' + match[0]);
}
// #0:a
// #4:a
// #8:a
上面代码中,只要exec方法不返回null,就会一直循环下去,每次输出匹配的位置和匹配的文本。

4.字符串的实例方法
String.prototype.match():返回一个数组,成员是所有匹配的子字符串。
String.prototype.search():按照给定的正则表达式进行搜索,返回一个整数,表示匹配开始的位置。
String.prototype.replace():按照给定的正则表达式进行替换,返回替换后的字符串。一个而已 有g才替换全部
String.prototype.split():按照给定规则进行字符串分割,返回一个数组,包含分割后的各个成员

String.prototype.match()
正则表达式带有g修饰符,则该方法与正则对象的exec方法行为不同,会一次性返回所有匹配成功的结果。
var s = '_x_x';
var r1 = /x/;
var r2 = /y/;

s.match(r1) // ["x"]
s.match(r2) // null

设置正则表达式的lastIndex属性,对match方法无效,匹配总是从字符串的第一个字符开始。

var r = /a|b/g;
r.lastIndex = 7;
'xaxb'.match(r) // ['a', 'b']
r.lastIndex // 0
var s = 'abba';
var r = /a/g;

s.match(r) // ["a", "a"]
r.exec(s) // ["a"]

String.prototype.search()
字符串对象的search方法,返回第一个满足条件的匹配结果在整个字符串中的位置。如果没有任何匹配,则返回-1。

'_x_x'.search(/x/)
// 1

(2)String.prototype.replace()
正则表达式如果不加g修饰符,就替换第一个匹配成功的值,否则替换所有匹配成功的值。

'aaa'.replace('a', 'b') // "baa"
'aaa'.replace(/a/, 'b') // "baa"
'aaa'.replace(/a/g, 'b') // "bbb"

2.1replace方法的第二个参数可以使用美元符号$,用来指代所替换的内容。

$&:匹配的子字符串。
$`:匹配结果前面的文本。
$':匹配结果后面的文本。
$n:匹配成功的第n组内容,n是从1开始的自然数。
$$:指代美元符号$。
'hello world'.replace(/(w+)s(w+)/, '$2 $1')
// "world hello"

'abc'.replace('b', '[$`-$&-$']')
// "a[a-b-c]c"
上面代码中,第一个例子是将匹配的组互换位置,第二个例子是改写匹配的值。

2.2replace方法的第二个参数还可以是一个函数,将每一个匹配内容替换为函数返回值
'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 replacer(match) {
return match.toUpperCase();
});
// The QUICK BROWN fox jumped over the LAZY dog.
作为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;

}
);
// "<span id="p1">$1.99</span><span id="p2">$9.99</span><span id="p3">$5.00</span>"
上面代码的捕捉模式中,有四个括号,所以会产生四个组匹配,在匹配函数中用$1到$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' ]
上面代码使用正则表达式,去除了子字符串的逗号后面的空格。

// 例一
'aaaa'.split(/a*/)
// [ '', '', '' ]

// 例二
'aaa*a'.split(/a*/)
// ["", "", "", "*"]
上面代码的分割规则是0次或多次的a,由于正则默认是贪婪匹配,所以例一的第一个分隔符是aaa,第二个分割符是a,将字符串分成三个部分,包含开始处的空字符串。例二的第一个分隔符是aaa,第二个分隔符是0个a(即空字符),第三个分隔符是a,所以将字符串分成四个部分。

如果正则表达式带有括号,则括号匹配的部分也会作为数组成员返回。

'aaaa'.split(/(a*)/)
// [ '', 'aaa', '', 'a', '' ]
上面代码的正则表达式使用了括号,第一个组匹配是aaa,第二个组匹配是a,它们都作为数组成员返回。

(3)String.prototype.split()
5.匹配规则
字面量字符和元字符
转义符
特殊字符
字符类
预定义模式
重复类
量词符
贪婪模式
修饰符
组匹配

评论

暂无评论