正则表达式详解

1.正则表达式：Regular Expression（RegExp）--按照某种规则去匹配符合条件的字符串。

2.RegExp对象的创建方式：

（1）.字面量

var reg = / 规则/;

看两个示例

var reg = /is/;
'He is a boy. This is a dog. Where is she?'.replace(reg,'IS');
-------"He IS a boy. This is a dog. Where is she?"

var reg = /is/g;     //g代表全局搜索
'He is a boy. This is a dog. Where is she?'.replace(reg,'IS');
-------"He IS a boy. This IS a dog. Where IS she?"

（2）.构造函数：var reg = new RegExp('规则')；

var reg = new RegExp('\bis\b');       //  用到了转义字符
'He is a boy. This is a dog. Where is she?'.replace(reg,'IS')
------"He IS a boy. This is a dog. Where is she?"

var reg = new RegExp('\bis\b','g');
'He is a boy. This is a dog. Where is she?'.replace(reg,'IS')
---------"He IS a boy. This IS a dog. Where IS she?"

3. 对RegExp规则的访问修饰符：g i m

g:全文搜索

i：忽略大小写搜索

m：多行搜索：若不指定 m，则：^ 只在字符串的最开头，$ 只在字符串的最结尾。
　　　　　　　若指定 m，则：^ 在字符串每一行的开头，$ 在字符串第一行的结尾。

//不加g，只会匹配一处。加了g，匹配所有。
//不加i，大小写严格区分;加了i，忽略大小写。
var reg = /is/g;
'He is a boy. Is he LiMing?'.replace(reg,'SS')
-------"He SS a boy. Is he LiMing?"

var reg = /is/gi;
'He is a boy. Is he LiMing?'.replace(reg,'SS')
-------"He SS a boy. SS he LiMing?"

var reg = /is/gim;
'He is a boy.
Is he LiMing?
Oh MY Gold!He is Tom'.replace(reg,'SS');
----"He SS a boy.
----SS he LiMing?
----Oh MY Gold!He SS Tom"


//m小例
var reg=/^@d/g;
'@123
@456
@678'.replace(reg,'Q')
---"Q23
---@456
---@678"

var reg=/^@d/gm;
'@123
@456
@678'.replace(reg,'Q')
---"Q23
---Q56
---Q78"

 4. 元字符:在正则表达式中有特殊含义的非字母字符

常用元字符
代码 　　　　　　　　　　 说明
. 　　　　　　　　　　　　匹配除换行符以外的任意字符
w 　　　　　　　　　　　 匹配字母或数字或下划线或汉字
s 　　　　　　　　　　　 匹配任意的空白符
d 　　　　　　　　　　　 匹配数字
 　　　　　　　　　　　 匹配单词的开始或结束
^ 　　　　　　　　　　　　匹配行的开始
$ 　　　　　　　　　　　　匹配行的结束

常用反义元字符
代码 　　说明
W 　　　　  匹配任意不是字母，数字，下划线，汉字的字符
S 　　 　　  匹配任意不是空白符的字符
D 　　　　　匹配任意非数字的字符
B 　　 　　  匹配不是单词开头或结束的位置
[^x] 　 　　  匹配除了x以外的任意字符
[^aeiou] 　　匹配除了aeiou这几个字母以外的任意字符


常用重复限定符
代码 　　　　　　说明
* 　　　　　　　 重复零次或更多次
+ 　　　　　　　 重复一次或更多次
? 　　　　　　　 重复零次或一次
{n} 　　　　　　重复n次
{n,} 　　　　　  重复n次或更多次
{n,m} 　　　　  重复n到m次

详情，参考一下

http://www.cnblogs.com/kissdodog/archive/2013/04/22/3036649.html，写的挺好的。

5. 贪婪模式: 正则表达式在匹配时，默认是贪婪模式，就是尽可能多的匹配

比如：

d{3,6}:那么默认是匹配6次。如果想变成非贪婪模式，则在最后加?，即d{3,6}?

'12345667'.replace(/d{3,6}/g,'Q')
-------"Q67"
'12345667'.replace(/d{3,6}?/g,'Q')
-------"QQ67"

6. 分组()：

'a1b2c3dafd'.replace(/([a-z]d){3}/g,'Q')
----------"Qdafd"

反向引用 $1

2016-12-25--->11/23/2016
'2012-02-23'.replace(/(d{4})-(d{2})-(d{2})/g,'$2/$3/$1')
-----"02/23/2012"

忽略分组  ?:
(?:d{4})-(d{2})-(d{2})    则第一个不算是分组内容了，从第二个开始算$1,$2

'2012-02-23'.replace(/(?:d{4})-(d{2})-(d{2})/,'$2/$1/$3')
"23/02/$3"

7.前瞻：正则表达式从文本头部向尾部开始解析，文本尾部方向，称为‘前’.前瞻就是在正则表达式匹配到规则的时候，向前介绍是否符合断言，后顾方向相反。JS不支持后顾。

正向前瞻:  exp(?=assert)   负向前瞻:  exp(?!assert)

示例

'a24c&45sad'.replace(/w(?=d)/g,'Q')
-----"QQ4c&Q5sad"

'a24c&45sad'.replace(/w(?!d)/g,'Q')
------"a2QQ&4QQQQ"

8.RegExp对象的属性：

lastIndex：当前表达式匹配内容的最后一个字符的下一个位置。在非全局中是没有意义的，总是返回0

source：正则表达式的文本字符串。注意点:文本内容不包括对象属性的gim。

var reg1 = /w/
reg1.source
----------"w"
var reg2=/dw/gim
reg2.source
---------"dw"

9. RegExp对象的test方法和exec方法

（1）.test():用于测试字符串参数中是否存在匹配正则表达式模式的字符串,有返回true。不需要全局。写上反而容易出现问题。

var reg1=/w/
var reg2=/w/g
reg1.test('a')----永远是true
reg2.test('a')---第一遍是对的，第二遍是错的，第三遍是对的...循环.和lastIndex有关系。

（2）.exec()使用正则表达式模式对字符串执行搜索，并将更新全局RegExp对象的属性以反映匹配结果。如果没有匹配的文本则返回null，否则返回一个结果数组（index声明匹配文本的第一个字符的位置。

var reg4 = /d(w)(w)d/g    //正则表达式
var ts = '1az2bb3cy4de5ed'     //被匹配字符串
while(r = reg4.exec(ts)){     //第一次 r=1az2  第二次=3cy4
    console.log(reg4.lastIndex+'	'+r.index+'	'+r)
}

-----4    0    1az2,a,z  

10.字符串对象和正则表达式相关的方法

(1).search()：不执行全局匹配，它忽略g标志，每次都从字符串的开始进行检索。返回索引的位置，如果没有返回-1

'a1b2c3d4'.search('a1')
----0
'a1b2c3d4'.search('d')
-----6

(2).match()
非全局调用--找到返回数组，没有找到返回null

var reg3=/d(w)d/
var ts = '$1a2b3c4d5e';
var ret = ts.match(reg3);
console.log(ret)
----------["1a2", "a", index: 1, input: "$1a2b3c4d5e"]

全局调用：没有找到任何匹配的字串，返回null；如果找到了一个或者多个匹配字串，则返回一个数组。数组中存放的是字符串中所有的匹配字串，而且也没有index属性或input属性。

var reg4 = /d(w)d/g
console.log(ts.match(reg4))
------["1a2", "3c4"]

如有不足，欢迎指正！