（十四）JavaScript RegExp正则表达式

转义符号 \（反斜杠）

\n（字符串换行）
\\（字符串\）
\?（字符串?）

创建正则表达式

1、语法/pattern/attributes

参数 pattern 是一个字符串，指定了正则表达式的模式。
参数 attributes 是一个可选的字符串，包含属性 “i”、“g” 和 “m”，
i 忽视大小写。
g 全局匹配（查找所有匹配而非在找到第一个匹配后停止）。
m 执行多行匹配。

var reg = /abc/ig;

2、语法new RegExp(pattern, attributes);

var reg = new RegExp("abc","i");

RegExp规则

方括号 []

方括号 [ ]查找方括号之间的任何字符
尖角号^ 放在方括号里面[^] 查找任何不在方括号之间的字符

小括号 ()

小括号()用来指定子表达式(也叫做分组)
后向引用用于重复搜索前面某个分组匹配的文本，\1代表分组1匹配的文本，\2代表分组2匹配的文本，以此类推。

var reg = /(\w)\1\1(\w)\2/g;
var str = 'aaacc bbbff aabrr';
console.log(    str.match(reg)    );  //["aaacc", "bbbff"]

元字符

. === [^\r\n]单个字符，除了行结束符\r和换行符\n。
\w === [0-9A-z_]
\W === [^\w]
\d === [0-9]
\D === [^\d]
\s === [\t\r\n\v\f ] （\s 包括制表符\t、回车符\r、换行符\n、垂直制表符\v、换页符\f、空格）
\S === [^\s]
\b === 单词边界
\B === 非单词边界

量词

假设n为一个字符串

n* 匹配0或多个n 字符串
n+ 匹配1或多个n 字符串
n? 匹配0或1个n 字符串
n{x} 匹配x个n 字符串 如：n{3} 三个n
n{x,y} 匹配x至y个n 字符串 如：n{1,3} 1至3个n
n{x,} 匹配x至无穷多个n 字符串

其他

^n 匹配开头为 n
n$ 匹配结尾为 n

正向预查/正向断言
(?=n) 匹配任何其后紧接指定字符串 n 的字符串

var reg = /.+?(?=@)/g;
var str = "test@qq.com"; 
console.log(    str.match(reg)    );  //["test"]

非 正向断言
(?!n) 匹配任何其后没有紧接指定字符串 n 的字符串
反向断言（javascript不支持）
(?<=n) 匹配任何前面紧接指定字符串 n 的字符串
非 反向断言（javascript不支持）
(?<!n) 匹配任何前面没有紧接指定字符串 n 的字符串

贪婪与非贪婪匹配
默认是贪婪匹配，非贪婪匹配 在量词后面添加 ?
*? 重复0次或多次（任意次），但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{x,y}? 重复x到y次，但尽可能少重复
{x,}? 重复x次以上，但尽可能少重复

var reg = /a.*b/g;
var str = "abaaab"; 
console.log(    str.match(reg)    );  //["abaaab"]

var reg = /a.*?b/g;
var str = "abaaab"; 
console.log(    str.match(reg)    );  //["ab", "aaab"]

RegExp 对象的方法

RegExpObject.test(string)

test() 方法用于检测一个字符串是否匹配某个模式.
如果字符串 string 中含有与 RegExpObject 匹配的文本，则返回 true，否则返回 false。

var reg = /a/;
var str = 'bbbbabb';
var str2 = 'cccc';
console.log(    reg.test(str)    );  //true
console.log(    reg.test(str2)    ); //false

RegExpObject.exec(string)

exec() 方法用于检索字符串中的正则表达式的匹配。

RegExpObject.lastIndex 游标

var reg = /a/g;
var str = 'aba';
console.log(    reg.exec(str)    );  //["a", index: 0, input: "aba"]
console.log(    reg.lastIndex    );  //1
console.log(    reg.exec(str)    );  //["a", index: 2, input: "aba"]
console.log(    reg.lastIndex    );  //3
console.log(    reg.exec(str)    );  //null
console.log(    reg.lastIndex    );  //0
console.log(    reg.exec(str)    );  //["a", index: 0, input: "aba"]
console.log(    reg.lastIndex    );  //1

当正则表达式不是全局匹配模式 g 时，游标不会动。

var reg = /(\w)\1\1(\w)\2/g;
var str = 'aaacc bbbff aabrr';
console.log( str.match(reg) );  //["aaacc", "bbbff"]

console.log( reg.exec(str) ); //["aaacc", "a", "c", index: 0, input: "aaacc bbbff aabrr"]
// exec方法 返回的类数组中 第0位 是  正则表达式相匹配的文本
// 第 1 位是第 1 个子表达式相匹配的文本，第 2 位是第 2 个子表达式相匹配的文本
// 以此类推

String 对象的方法

stringObject.match(regexp/substr)

match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。
该方法类似 indexOf() 和 lastIndexOf()，但是它返回指定的值，而不是字符串的位置。

var reg = /(\w)\1(\w)\2/;
var reg2 = /(\w)\1(\w)\2/g; // 带参数 g 全局匹配
var str = "aacc bbff aar";
console.log(    str.match(reg)    ); //  ["aacc", "a", "c", index: 0, input: "aacc bbff aar"]
console.log(    str.match(reg2)    ); // ["aacc", "bbff"]
// 不带 g （全局匹配）时，返回  正则表达式相匹配的文本 和 子表达式相匹配的文本
// 带 g （全局匹配）时，只返回  正则表达式相匹配的文本

stringObject.search(regexp/substr)

search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。
参数可以是字符串或正则表达式

var reg = /ab/g;
var str = "ababab";
var str2 = "aaa";
console.log(    str.search(reg)    );  // 0
console.log(    str2.search(reg)    );  // -1

search() 方法不执行全局匹配，它将忽略标志 g，只返回 stringObject 的第一个匹配的位置。
没有找到任何匹配的子串，则返回 -1。

stringObject.split(regexp/substr)

split() 方法用于把一个字符串分割成字符串数组。
参数可以是字符串或正则表达式

var reg = /\d\d/;
var str = "a11b34bb";
console.log(    str.split(reg)    );  //["a", "b", "bb"]

stringObject.replace(regexp/substr,replacement)

replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

var str = "aaa";
console.log(    str.replace('a','b')    );  //baa （查找替换子字符串时，只执行一次）

var reg = /a/g;
var str = "aaa";
console.log(    str.replace(reg,'b')    );  //bbb

replacement 中的 $ 字符具有特定的含义。
$1、$2、…、$99 与 regexp 中的第 1 到第 99 个子表达式相匹配的文本。
$& 与 regexp 相匹配的子串。
$` 位于匹配子串左侧的文本。
$’ 位于匹配子串右侧的文本。
$$ 直接量符号。

var reg = /(\w)\1(\w)\2/g;
var str = "aabb";
console.log(    str.replace(reg,"$2$2$1$1")    );  //bbaa

replacement 可以是字符串，也可以是函数。replacement是函数，则第一个形参表示正则表达式相匹配的文本，后面的形参就依次是子表达式相匹配的文本

var reg = /(\w)\1(\w)\2/g;
var str = "aabb3ccdd";
console.log(    str.replace(reg,function($,$1,$2){  //形参可自定
	console.log($);
	console.log($1);
	console.log($2);
	return $2 + $2 + $1 + $1;
})    );  

// aabb
// a
// b
// ccdd
// c
// d
// bbaa3ddcc

例子：变成小驼峰写法

var reg = /-(\w)/g;
var str = "the-first-name"; 
console.log(    str.replace(reg,function($,$1){  
	return $1.toUpperCase();
})    ); 

例子：字符串去重

var reg = /(\w)\1*/g;
var str = "aaaaabaaabbbbbcccc"; 
console.log(    str.replace(reg,"$1")    );  //ababc

例子：字符串数字科学技术法

var reg = /\B(?=(\d{3})+$)/g;
var str = "100000000";

console.log(    str.match(reg)    );  
// ["", ""] 目的是去匹配 后面紧跟 3的倍数位数字 的空

console.log(    str.replace(reg,'.')    );  
//100.000.000  把空替换成.  \B 非单词边界 以防成 .100.000.000

---

参考:
w3cschool
http://www.w3school.com.cn/jsref/jsref_obj_regexp.asp