RegExp对象

正则表达式

/pattern/flags new RegExp(pattern [, flags])

pattern	正则表达式的文本
flags	若是指定，标志能够具备如下值的任意组合：
g	全局匹配
i	忽略大小写
m	多行;让开始和结束字符（^ 和 $）工做在多行模式工做
u	Unicode。把模式看成Unicode代码点(code points)的序列。
y	黏度; 在目标字符串中，只从正则表达式的lastIndex属性指定的显示位置开始匹配（而且不试图从任何以后的索引匹配）。

//字面量
var regex = /xyz/i;
//构造函数
var regex = new RegExp('xyz', "i");

这两种写法——字面量和构造函数——在运行时有一个细微的区别。采用字面量的写法，正则对象在代码载入时（即编译时）生成；采用构造函数的方法，正则对象在代码运行时生成。考虑到书写的便利和直观，实际应用中，基本上都采用字面量的写法。

匹配规则

MDN
javascript标准参考教程

正则对象的属性和方法

<h4>属性</h4>
正则对象的属性分红两类。
一类是修饰符相关，返回一个布尔值，表示对应的修饰符是否设置。

ignoreCase：返回一个布尔值，表示是否设置了i修饰符，该属性只读。
global：返回一个布尔值，表示是否设置了g修饰符，该属性只读。
multiline：返回一个布尔值，表示是否设置了m修饰符，该属性只读。

var r = /abc/igm;

r.ignoreCase // true
r.global // true
r.multiline // true

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

lastIndex：返回下一次开始搜索的位置。该属性可读写，可是只在设置了g修饰符时有意义。
source：返回正则表达式的字符串形式（不包括反斜杠），该属性只读。

var r = /abc/igm;

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

<h4>方法</h4>
test() 正则对象的test方法返回一个布尔值，表示当前模式是否能匹配参数字符串。

若是正则表达式带有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

//lastIndex属性只对同一个正则表达式有效，因此下面这样写是错误的

var count = 0;
while (/a/g.test('babaa')) count++;

exec() 正则对象的exec方法，能够返回匹配结果。若是发现匹配，就返回一个数组，成员是每个匹配成功的子字符串，不然返回null。

若是正则表示式包含圆括号（即含有“组匹配”），则返回的数组会包括多个成员。第一个成员是整个匹配成功的结果，后面的成员就是圆括号对应的匹配成功的组。也就是说，第二个成员对应第一个括号，第三个成员对应第二个括号，以此类推。整个数组的length属性等于组匹配的数量再加1。

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

r.exec(s) // ["_x", "x"]

若是正则表达式加上g修饰符，则可使用屡次exec方法，下一次搜索的位置从上一次匹配成功结束的位置开始。

//exec方法的返回数组还包含如下两个属性：
//    input：整个原字符串。
//    index：整个模式匹配成功的开始位置（从0开始计数）。

var r = /a(b+)a/g;

var a1 = r.exec('_abbba_aba_');
a1 // ['abbba', 'bbb']
a1.index // 1
r.lastIndex // 6

var a2 = r.exec('_abbba_aba_');
a2 // ['aba', 'b']
a2.index // 7
r.lastIndex // 10

var a3 = r.exec('_abbba_aba_');
a3 // null
a3.index // TypeError: Cannot read property 'index' of null
r.lastIndex // 0

var a4 = r.exec('_abbba_aba_');
a4 // ['abbba', 'bbb']
a4.index // 1
r.lastIndex // 6

字符串对象的方法

字符串对象的方法之中，有4种与正则对象有关。

match()：返回一个数组，成员是全部匹配的子字符串。
search()：按照给定的正则表达式进行搜索，返回一个整数，表示匹配开始的位置。
replace()：按照给定的正则表达式进行替换，返回替换后的字符串。
split()：按照给定规则进行字符串分割，返回一个数组，包含分割后的各个成员。

//String.prototype.match()

var s = 'abba';
var r = /a/g;
s.match(r) // ["a", "a"]
r.exec(s) // ["a"]

//String.prototype.search()

'_x_x'.search(/x/)

//String.prototype.replace()

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

//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 replacer(match) {
  return match.toUpperCase();
});
// The QUICK BROWN fox jumped over the LAZY dog.

//String.prototype.split()

// 非正则分隔
'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', '*' ]