js正则表达式的深入学习+分组+前瞻

1.首先是关于str.match(),参数是子字符串或者reg表达式；
返回包含匹配的子字符串的数组。关于多匹配与单匹配的区别参考之前博客。

(1) 'q123w34'.match('123')[0]; //'123'
(2) '23d34f45g56'.match(/\d{2}/g); //['23','34','45','56']

2.重点是str.replace的深入理解
参数有两个，一个是reg或者子字符串，另一个参数replacement是替换的子字符串，reg或者函数
eg：'12345'.replace(/\d+/,'0'); //00000
replacement中的 $ 字符具有特定的含义，从模式匹配得到的字符串将用于替换。

$1、$2、...、$99   匹配与 regexp 中的第 1 到第 99 个子表达式相匹配的文本。
$&    匹配与regexp 相匹配的子串。
$`    匹配位于匹配子串左侧的文本。
$'    匹配位于匹配子串右侧的文本。
(1)使用replacement作为reg：
var a = "20141021123212";
var reg4 = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/;
a = a.replace(reg4,"$1-$2-$3 $4:$5:$6");
//"2014-10-21 12:32:12"

var s = '1233333456';
s.replace(/(\d{3})(\d{4})/,"$1****");
//"123****456"

(2)使用replacement作为函数替换：
在本例中，我们将把字符串中所有单词的首字母都转换为大写：
[1]: 
name = 'aaa bbb ccc';
uw=name.replace(/\b\w+\b/g, function(word){
  return word.substring(0,1).toUpperCase()+word.substring(1);}
  );

[2]:
// match 为匹配整个字符串，即：'abc12345#$*%'
// p1 为第一个子表达式，([^\d]*)，匹配0个或多个非数字的字符，即:abc
// p2 为第二个子表达式,(\d*)，匹配0个或多个的数字，即：12345
// p3 为第三个子表达式，([^\w]*)，匹配0个或匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'，即 #$*%
// offset 为模式匹配出现的位置，从第一个字符已经匹配成功，则位置为0
// string为字符串本身，即 abc12345#$*%
function replacer(match, p1, p2, p3, offset, string) {
return [p1, p2, p3].join(' - ');
}
var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer); 
// 替换结果为：abc - 12345 - #$*%

3.捕获性分组:()，非捕获性分组:(?:)
参考:(http://blog.csdn.net/lihefei_coder/article/details/53022253)
捕获性分组：
捕获性分组工作模式()会把每个分组里匹配的值保存起来。

比如利用捕获性分组把 hello world 互换成 world hello：
方法一：通过exec函数

var str = 'hello world';           
var pattern = /([a-z]+)\s([a-z]+)/; 
var arr = pattern.exec(str); // exec方法返回的是一个数组，包含匹配到的字符串以及分组(也称子串)里的值
console.log(arr); //['hello world','hello','world'] 
//这时候两个分组的值都得到了,接下来用字符串拼接法实现互换
var n_str = arr[2]+' '+arr[1];
console.log(n_str) //world hello

方法二：通过String的replace() ,使用$1-$9

var str = 'hello world'; 
var pattern = /([a-z]+)\s([a-z]+)/; 
var n_str = str.replace(pattern,"$2 $1");
console.log(n_str) //world hello

非捕获性分组：(?:)
非捕获性分组工作模式下分组(?:)会作为匹配校验，并出现在匹配结果字符里面，但不作为子匹配返回。
比如利用非捕获性分组获取字符串000aaa111，而且只返回一个值为aaa111的数组：

//先看用捕获性分组匹配会返回什么
var str1 = '000aaa111';         
var pattern = /([a-z]+)(\d+)/; //捕获性分组匹配
var arr = pattern.exec(str1); 
console.log(arr) //['aaa111','aaa','111']   结果子串也获取到了，这并不是我们想要的结果
//非捕获性分组
var str2 = '000aaa111';
var pattern2 = /(?:[a-z]+)(?:\d+)/; //非捕获性分组匹配
var arr2 = pattern.exec(str2);  
console.log(arr2) //['aaa111']  结果正确

另外,非捕获性分组不能使用$1-$9匹配，

var str = 'hello world'; 
var pattern = /(?:[a-z]+)\s(?:[a-z]+)/; 
var n_str = str.replace(pattern,"$2 $1"); 
console.log(n_str)
//输出: "$2 $1"

4.前瞻：(?=)和(?!)
正向前瞻(?=表达式)表示后面要有什么，反向前瞻(?!=表达式)表示后面不能有什么。前瞻分组会作为匹配校验，但不出现在匹配结果字符里面，而且不作为子匹配返回。
正向前瞻匹配一批图片格式：

//正向前瞻，匹配.jpg后缀文件名
var str = '123.jpg,456.gif,abc.jpg';
var partern = /\w+(?=\.jpg)/g; //正向前瞻匹配
console.log(str.match(partern)); //['123', 'abc']   返回结果正确，没有匹配456.gif.
//返回匹配内容不包括前瞻匹配的内容。

反向前瞻匹配一批字母加数字：

//反向前瞻，匹配3个及以上的a，而且后面不能有000的字符
var str = 'aaa000 aaaa111 aaaaaaa222';
var partern = /a{3,}(?!000)/g; //反向前瞻匹配
console.log(str.match(partern)); //['aaaa', 'aaaaaaa']   返回结果正确，没有匹配aaa000

例子：

var str = '12.ty 8374.ty 090.ki'; 
var pattern = /\d+.(?=ty)/g; 
var n_str = str.match(pattern);
console.log(n_str) //world hello
//["12.", "8374."]