创建正则表达式
使用字面量形式创建：
var pattern = /pattern/g || i || m;
/pattern/：两个反斜杠里面是你要匹配的规则。
g:匹配所有字符，而非发现第一个匹配项时立即停止。
i:不区分大小写。
m:多行匹配。 当在字符串使用 换行，但在正则中还是把它看成一行进行匹配，如下代码匹配以a开头的字符，使用 后应该是配到2个以a开头的字符，但是只匹配到一个a.当加上m使用多行匹配，就可以匹配到两个以a开头的字符。
var str = "abcde
af";
var reg = /^a/gm;
str.match(reg); //match返回匹配结果的数组。 不加 m["a"],加 m["a","a"];
g,i,m可以任意搭配。
使用构造函数创建：
var pattern = new RegExp("pattern","i||g||m");
接收两个字符串参数，第一个是要匹配的字符串模式，第二个是i||m||g.
表达式：
表达式放在[]里，一个[]代表一个位置，[]里面的内容表这个位置的可选范围。
[^abc]:匹配不包含a或b或c的任意字符。
[0-9]:匹配0-9的数字。
[A-z]:匹配所有的大小写英文字母。
(red|blue|green):匹配连续的字符。
如下，字符串只要包含[]里面的任意一个字符，就可以被匹配出来。
var reg = /[123][0-9A-z]/g;
var str = '1asdf3cs';
var arr = str.match(reg); //["1a","3c"]
元字符：
每个元字符代表一个位置。元字符可以放在表达式里
w:匹配所有0-9，A-z _(下划线)的任意字符。 相当于表达式的[0-9A-z_]
W:^w(w的取非). [^w]
var reg = /wabc/g;
var str = '_abcd123abcd';
var arr = str.match(reg); //["_abc", "3abc"]
d:配到0-9 [0-9]
D:对取非 [^0-9]
var reg = /dabc/g;
var str = '1abc2abcdef123';
ar arr = str.match(reg); //["1abc","2abc"]
s:匹配空白字符
S:取非
var reg = /sw/g;
var str = ' a d c';
var arr = str.match(reg); //[" a", " d", " c"]
:匹配单词边界
B:匹配非单词边界
var reg = /world/g;
var str = 'hello world hello';
var arr = str.match(reg); //["hello"]
量词 遵循贪婪原则，取多不取少
n+: 匹配至少包含一个n的字符
var reg = /w+/g;
var str = 'hello world_hello';
var arr = str.match(reg);
console.log(arr); //["hello","world_hello"];
n*:匹配至少0个或多个n的字符。
var reg = /w*/g;
var str = 'hello world_hello';
var arr = str.match(reg);
console.log(arr); //["hello","","world_hello",""]
n?:匹配0到1个n的字符
var reg = /w?/g;
var str = 'hello ';
var arr = str.match(reg); //["h", "e", "l", "l", "o", "", ""]
n{X}:匹配x个n的字符
var reg = /[wW]{3}/g;
var str = 'hello world_hello ';
var arr = str.match(reg); ["hel", "lo ", "wor", "ld_", "hel", "lo ", " "]
n{x,y}:匹配x到y个n的字符，同样遵循贪婪原则，能匹配y个（多）不匹配少。
n{x,}:第二个不写就是最少匹配x个，最多匹配无穷个。
在正则表达式中或者用一个|表示。
例如：判断字符串首尾有数字
var reg = /^d|d$/g;
var str = '123abd';
var result = reg.test(str);
判断字符首尾都有数字
var reg1 = /^d[dD]*d$/g;
var str = '123abc';
var result = reg.test(str);
子表达式
()放在括号里面的式子叫子表达式，他可以将括号里面匹配后的内容进行保存，因此我们可以反向引用这个匹配后的结果。
()1 在括号后面加1表示引用第一个子表达式，第一个括号叫第一个子表达式，第二个括号叫第二个子表达式，以此类推。
例如匹配型如aaaa类型的字符串
var reg = /(w)111/g; //匹配到一个a,将a反向引用，也就是说，1就代表a
var str = 'aaaa';
var result = str.match(reg); ["aaaa"]
匹配型如aabb类型的字符串
var reg = /(w)1(w)2/g;
var str = 'aabbabaaba';
var result = str.match(reg);
RegExp对象方法
test()判断字符串是否有规定匹配的片段，有返回true，没有返回false。
exec()返回一个数组，数组的第一位是第一个匹配的字符串，其他项如果有子表达式就是子表达式匹配的字符串。还有两个额外属性：index（匹配项在字符串中的位置），input（应用正则表达式的字符串）。
var reg = /(w)1(w)2/g;
var str = '123aabb';
var result = reg.exec(str); //["aabb", "a", "b", index: 3, input: "123aabb", groups: undefined]
exec();在全局的情况下也只返回一个。但在下次调用时会在上次匹配完的地方继续匹配。而不在全局的情况下，只匹配第一个，不会继续匹配。
var reg = /ab/g;
var str = 'abababab';
console.log(reg.lastIndex); // 0 开始搜索下一个匹配项的字符位置，从0算起
console.log(reg.exec(str)) //["ab", index: 0, input: "abababab", groups: undefined]
console.log(reg.lastIndex); //2
console.log(reg.exec(str)) //["ab", index: 2, input: "abababab", groups: undefined]
console.log(reg.lastIndex); //4
console.log(reg.exec(str))
console.log(reg.lastIndex);
持续调用exec，当匹配到字符串末尾时，在调用，就会返回空，在调用就会右从头开始，并且每次调用lastIndex都会改变。
支持正则表达式String对象的方法
match() 参数是正则表达式
当不全局模式时，返回的和exec一样，第一项是整个匹配的内容，其他项有子表达式匹配的内容，index和input。只匹配一个，不会继续匹配。
var reg = /ab/;
var str = 'abababab';
console.log(str.match(reg)); //["ab", index: 0, input: "abababab", groups: undefined]
当在全局匹配时，返回的只有匹配到的字符，并且是所有符合的，都存在数组
var reg = /ab/g;
var str = 'abababab';
console.log(str.match(reg)); //["ab", "ab", "ab", "ab"]
search() 参数是正则表达式 返回字符串中第一个匹配的索引，如果没有找到匹配项，返回-1.
replace()接收两个参数，第一个参数可以是字符串或RexExp对象。第二个参数可以是一个字符串或者是一个函数。把字符串含有第一个参数替换成第二个参数。
var str = 'aa';
var a = str.replace('a','b')
console.log(a) // ba 只能匹配到一个。
//当第一个参数使用正则表达式，并且是全局匹配，就会匹配所有的字符串
例：把aabb类型的字符变成bbaa类型的字符
var reg = /(w)1(w)2/g;
var str = 'aabb';
var a = str.replace(reg,"$2$2$1$1") //第二个参数一定是字符串或者是函数,在字符串里也可以反向引用，使用$1(第一个子表达式)$2(第二个字表达式)
console.log(a)
第二个参数传入函数。