1.声明方法

• new RegExp()

var a= new RegExp('xyz');   //等同于/xyz/
var b= new RegExp("\\s");   //等同于/\s/
var c =new RegExp("\s");     //等同于/s/  这里注意 使用new声明正则的时候如果存在转译就会消耗一个"\"符号

• 直接书写

var a=/xyz/;
var b=/\s/;

2.正则对象的属性和方法

• 修饰符属性
  与修饰符有关的属性,返回一个布尔值
  >ignoreCase :表示不区分大小写
  >global ：表示是否全局匹配
  >multiline ：表示是否多行匹配

var a=/xyz/igm;
a.ignoreCase // true;
a.global         //true;
a.mulitline      //true;

• 另外有一些与修饰符无关的属性，主要有两个
  >lastindex 下一次匹配的位置，要跟修饰符g一起用
  >source 正则的字符串形式

var a= /xyz/igm;
var b=/\s/igm;
a.lastindex;        //0 从头开始
b.source  ;       //"\s"

• 方法
  • test() 返回Boolean值 表示当前正则是否能够匹配字符串
    >正则中没有修饰符g，则只匹配一次

/x/.test("_x_x");
/y/.test("_x_x");

>正则中有修饰符g ，则多次匹配

var a=/x/g;
var s="_x_x";
a.test(s);       //true;
a.lastIndex;  //2;
a.test(s);      //true;
a.lastIndex   //4;

• exec(): 如果发现匹配，则返回一个数组，如果没有匹配 则返回null；

var s="_x_x";
/x/.exec(s);     //["x"]
/y/.exec(s)       //null

>使用exec()如果正则中有（） 则含有组匹配 如果成功匹配 则返回的数组中第一个值是匹配成功的值，第二个值组内匹配的值 ，如果存在多个组匹配则数组长度+1，位置依次类推。

var a = /_(x)/;
a.exec("_x_x")  //["_x","x"]
var b=/a(b)(c)/;
b.exec("abc")   //  ["abc",b,c]

> 使用exec()返回的数组中有两个属性 一个是input 另一个是index

var a=/a(b+)a/g;
var s="_abbba_aba"
var a1=a.exec(s);
a1.index   //1 从字符串第二位成功匹配
a1.input   //"_abbba_aba" 匹配的原字符串

> 如果正则中含有修饰符g则可以多次使用exec()进行匹配

var a=/a(b+)a/g;
var s="_abbba_aba"
var a1=a.exec(s);
console.log(a1);            //["abbba","bbb"]
console.log(a.lastIndex);   //    6
var a2=a.exec(s);
console.log(a2);            //["aba","b"]
console.log(a.lastIndex);   //  10
var a3=a.exec(s);
console.log(a3);           // null             本次的匹配位置是10 字符串最大索引是9 所以null
console.log(a.lastIndex); //undefined
var a4=a.exec(s);
console.log(a4.index);                        //index=1 重新开始匹配
console.log(a3);           //["abbba","bbb"]       
console.log(a.lastIndex); //   6

3.字符串的属性和方法

• search
  >如果匹配成功则返回第一个满足匹配字符串的位置，如果没有匹配成功则返回-1

var s="_x_x";
s.match(/x/);       //1
s.match(/y/);       //-1

• match
  >如果不带修饰符g 则返回第一次匹配值组成的数组 如果没有成功则返回null

var s="_x_x";
s.match(/x/);     //["x"]
s.match(/y/);      //null

>如果带修饰符g 则返回所有匹配组成的数组

var s="_x_x";
s.match(/x/g);   //["x","x"]

>如果存在组匹配，如果成功匹配，数组的第一个值是匹配结果，第二个值是组内匹配结果,依次类推。

var s="_abba_aba";
s.match(/a(b+)a/);  ["abba","bb"]

• split
  >函数调用:str.split(separator, [limit])
  返回值是一个数组。参数第一个参数可以是正则，第二个参数可以限定返回数组的长度，

var s="a, b,  c,d"
var arr=s.split(/,\s*/);           //其中\s* 代表匹配0到多个空格
console.log(arr)                     //["a", "b", "c", "d"]
var arr2=s.split(/,\s*/,2)      
console.log(arr2)                  //["a", "b"]

• replace
  >函数调用：str.replace(search, replacement)replace()返回值是一个新的字符串。
  >>参数第一个值可以是正则 正则可以带修饰符g，带g的情况下会做全局匹配替换

var s="aaa"
var s1=s.replace(/a/,"b")         //s1="baa"
var s2=s.replace(/a/g,"b")       //s2="bbb"

>>参数第二个值可以是替换的字符串，也可以是$符号组成的参数，也可以是函数
$符号
$& 指代匹配的子字符串。
$` 指代匹配结果前面的文本。
$' 指代匹配结果后面的文本。 //其中'符号需要转译 $'
$n 指代匹配成功的第n组内容，n是从1开始的自然数。
$$ 指代美元符号$

var s1="hello world".replace(/(\w+) (\w+)/,"$2 $1");   //"world hello"
var s2=('abc').replace(/b/,"[$`-$&-$\']")                 //"a[a-b-c]c"      

function

var s='123';
var s2=s.replace(/\d/g,function(match){
  return match*2;
});                                                          //s2="246";

4.常用的一些写法

<pre>
\d ：匹配数字 相当于[0-9]
\w：匹配字母数字下划线相当于[A-Za-z0-9_]
\s ：匹配空格（包括制表符、空格符、断行符等） 相当于[\t\n\r\v\f]
[a-zA-Z0-9]: 匹配所有字母和数字

5.特殊字符

\cX 表示Ctrl-[X]，其中的X是A-Z之中任一个英文字母，用来匹配控制字符。
[\b] 匹配退格键(U+0008)，不要与\b混淆。
\n 匹配换行键。
\r 匹配回车键。
\t 匹配制表符tab（U+0009）。
\v 匹配垂直制表符（U+000B）。
\f 匹配换页符（U+000C）。
\0 匹配null字符（U+0000）。
\xhh 匹配一个以两位十六进制数表示的字符。
\uhhhh 匹配一个以四位十六进制数表示的unicode字符。

6.贪婪模式与非贪婪模式(+、*、？)

+符号和*符号默认是尽可能的匹配更多的字符,这就是贪婪模式。
如果在后面加上问号，就会变成一旦满足条件后就不再匹配 这就是非贪婪模式。
*?：表示某个模式出现0次或多次，匹配时采用非贪婪模式
+?：表示某个模式出现1次或多次，匹配时采用非贪婪模式。

/a+/.exec("aaa");           //["aaa"]
/a+?/.exec("aaa);          //["a"]       //满足有一个a即可
/a+?b/.exec("aab")         //["aab"]    //满足一个或者多个a后面有一个b
/a*?b/.exec("aab");           //["aab"]   //满足0个或者多个a后面有一个b
/a*?b/.exec("b")                 //["b"]     //没有a直接返回b

6.组匹配

• 定义：就匹配就是用括号包裹起来形成一个整体

var s="abcabc"
s.match(/abc+/);              //["abc"]      没有括号 只有c受到了加号的影响
s.match(/(abc)+/);            //["abcabc", "abc"]    

• 组匹配可以使用\n来替代组中的内容，还可以嵌套使用

var s="abc_cab";
/(..)(.)_\2\1/.test(s);      //其中\2代表的是ab\1代表的是c
var s="abc_ab_abc";
/((..).)_\2_\1/.test(s);     //其中\2代表的是ab \1代表的是abc

• 组匹配最大的应用就是用来匹配web标签

var tag=/^<(\w+)>([^<]*)<\/\1>$/;
var match=tag.exec("<h1>我是头标题</h1>")   //["<h1>我是头标题</h1>", "h1", "我是头标题"]

var html = '<b class="hello">Hello</b><i>world</i>';
var tag = /<(\w+)([^>]*)>(.*)<\/\1>/g;
var match1=tag.exec(html);            //["<b class="hello">Hello</b>", "b", " class="hello"", "Hello"]
var match2=tag.exec(html);            //["<i>world</i>", "i", "", "world"]

7.组匹配的其他用法

• 非捕获组 (?:x) 功能与普通的组匹配一样，但是使用exec和字符串的match的时候不会返回组中的内容

var match1=/(?:.)b(.)/.exec("abc");    //["abc", "c"]
var match2="foolfool".match(/(?:foo)+(.)/);    //["fool", "l"]

• 先行断言x(?=y ) 就是x必须是在y的前面 y不会返回

/\d+(?=%)/.exec("99%");   //["99"]

• 先行否定断言x(?!y) 就是x不能在y的前面 也不会返回

/\d+(?![.])/.exec(3.14);   //[14]