JS正则表达式

====== 1-1 正则表达式简介
正则表达式应用场景
1.在IDE中使用正则表达式处理规则复杂的字符串查找、替换需求
2.在JavaScript程序设计中使用正则表达式处理字符串

正则表达式
1.Regular Expression,使用单个字符串来描述、匹配一序列符合某个句法规则的字符串;
2.简言之：就是按照某种规则去匹配符合条件的字符串,而这种规则就是正则表达式

使用正则表达式的目的：
自己先定义一种规则,然后去匹配一个字符串中符合规则的子字符串,甚至是整个字符串是否符合规则

通配符
find ./ -name *.txt 在当前目录下查找所有的txt文件 *.txt *代表任意字符
匹配邮箱的正则表达式
^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\.[a-zA-Z0-9_-]{2,3}){1,2})$
匹配IP
((\.)|(2\[0-4][0-9]|25[0-5]|1\d{2}|\d{1,2})){7}

^(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])$

在线的正则表达式工具：http://regexper.com

语法：
\b：单词边界  \bis\b
.: 任意字符  需要转义 \.
*：0-n
+: 1-n
?: 0-1
\d: 数字
\转义

匹配日期：
2006/02/03  1998-03-07
^(\d{4})[\-](\d{2})[\-](\d{2})$  （）分组
取出：$2-$3-$1  02-03-2006  $1代表第一个小括号的内容,以此类推

====== 2-1 RegExp对象
 在浏览器Console,可以这么玩：
>var reg = /\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 = /\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?"

>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?"

g:global 全文搜索,不添加则搜索到第一个匹配停止；
i:ignore case 忽略大小写,默认大小写敏感；
m:multiple lines 多行搜索

====== 2-2 元字符
1）正则表达式由两种基本字符类型组成：
-原义文本字符
-元字符
2）元字符是在正则表达式中有特殊含义的非字母字符
3）* + ？$ ^ . | \ ( ) { } [ ]
4）元字符
字符 含义
\t 水平制表符
\v 垂直制表符
\n 换行符
\r 回车符
\0 空字符
\f 换页符
\cX 与X对应的控制字符(Ctrl+X)

====== 2-3 字符类
1.一般情况下正则表达式一个字符对应字符串一个字符
表达式 ab\t 的含义是： 一个字母a一个字母b加一个水平制表符 
2.可以使用元字符[]来构建一个简单的类,所谓类是指符合某些特征的对象,一个泛指,而不是特指某个字符
表达式[abc]:把字符a或b或c归为一类,表达式可以匹配这类的字符,即匹配abc中的一个
    'a1b2c3d4'.replace(/[abc]/g,'字符');
    "字符1字符2字符3d4"
3.字符类取反
  使用元字符^创建反向类/负向类,意思是：不属于某类的内容
  表达式[^abc] 表示不是字符a或b或c的内容
  'a1b2c3d4'.replace(/[^abc]/g,'马赛克');
  "a马赛克b马赛克c马赛克马赛克马赛克"

====== 2-4 范围类
1.使用字符类匹配数字[0123456789]简写[0-9]
2.可用[a-z]来连接两个字符表示 从a到z的任意字符,闭区间,包含a和z本身
  如：'a1b2c3zx4z9'.replace(/[a-z]/g,'Q');
  "Q1Q2Q3QQ4Q9"
3.在[]组成的类内部可连写[a-zA-Z]
  如：'a1b2c3zx4z9ADG'.replace(/[a-zA-Z]/g,'Q');
  "Q1Q2Q3QQ4Q9QQQ"
注意：
 当-在两个字符之间,表示范围,想匹配-,直接在后面加-即可,即当-在[]内部且在两个字符之间时表示范围,在其他位置时为普通字符.
 '2016-08-08'.replace(/[0-9-]/g,'Q');
 "QQQQQQQQQQ"

====== 2-5 JS的预定义类及边界
1.正则表达式提供了 预定义类 匹配常见的字符类
.  等价于 [^\r\n] 表示除了回车符和换行符之外的所有的字符
\d 等价于 [0-9] 数字字符d:digit
\D 等价于 [^0-9] 非数字字符
\s 等价于 [\t\n\x0B\f\r] 空白符 s:space
\S 等价于 [^\t\n\x0B\f\r] 非空白符
\w 等价于 [a-zA-Z_0-9] 单词字符（字母、数字下划线） w:word
\W 等价于 [^a-zA-Z_0-9] 非单词字符
    提示：大写的表示取反；
     ^在中括号内表示取反；在其他位置表示一行内容以xxx开头；
例子：匹配一个 ab+数字+任意字符 的字符串
    使用范围类：ab[0-9][^\r\n]    
    使用预定义类：ab\d.

2.边界：正则表达式提供了几个常用的边界匹配字符
常见的边界匹配字符：
^ 以XXX开始
$ 以XXX结束
\b 单词边界
\B 非单词边界
例子：
1. '@123@abc@'.replace(/^@./g,'Q');
 "Q23@abc@"
2. '@123@abc@'.replace(/.@$/g,'Q');
 "@123@abQ"
3. '@123@abc@'.replace(/.@/g,'Q');
 "@12QabQ"

====== 2-6 量词
? 出现<=1次（最多出现一次）
+ 出现>=1次（至少出现一次）
* 出现任意次（任意次）
{n} 出现n次
{n,m} 出现n到m次
{n,} 出现至少n次

====== 2-7 JS正则贪婪模式与非贪婪模式
贪婪模式 {3,5}尽量多的匹配5个
非贪婪模式 {3,5}?尽量少的匹配3个

正则中默认采用贪婪模式，即尽可能的使用正则匹配多的字符匹
非贪婪模式 -- 量词后加?
alert("123456789".match(/\d{3,6}/g)); 123456
alert("123456789".match(/\d{3,6}?/g)); 123,456
>'12345678'.replace(/\d{3,6}/g, 'X');
<"X78"
>'12345678'.replace(/\d{3,6}?/g, 'X');
<"XX78"


====== 2-8 分组
1.正则表达式中()用来分组,[]匹配里面中任意的元素,在[]中的^代表取反;
2.使用()达到分组的功能,使量词作用于分组；
例如：
Byron{3} n重复三次
(Byron){3} Byron整个单词重复三遍
>'a1b2c3d4'.replace(/[a-z]\d{3}/g, 'X');
<"a1b2c3d4"
>'a1b2c3d4'.replace(/([a-z]\d){3}/g, 'X');
<"Xd4"

3.使用 | 可以达到或的效果
Byron|Casper Byron或Casper
Byr(on|Ca)sper  Byronsper或ByrCasper
>'ByronCasper'.replace(/ByronCasper/g, 'X')
<"X"
>'ByronsperByrCasper'.replace(/Byr(on|Ca)sper/g, 'X')
<"XX"

4.反向引用
用$1..$N来表示匹配到的分组,也叫分组捕获；
2016-11-20 => 11/20/2015
'2016-11-20'.replace(/(\d{4})-(\d{2})-(\d{2})/g, '$2$3$1')
"11202016"
'2016-11-20'.replace(/(\d{4})-(\d{2})-(\d{2})/g, '$2/$3/$1')
"11/20/2016"
'2016-11-20'.replace(/(\d{4})-(\d{2})-(\d{2})/g, '$1')
"2016"
'2016-11-20'.replace(/(\d{4})-(\d{2})-(\d{2})/g, '$2')
"11"
'2016-11-20'.replace(/(\d{4})-(\d{2})-(\d{2})/g, '$3')
"20"

5.忽略分组
不想捕获某些分组,只需在分组内加上?:就可以；
(?:Byron).(ok)


====== 2-9 前瞻
1.正则表达式从文本头部向尾部开始解析，文本尾部方向，称为“前”；
2.“前瞻”就是在正则表达式匹配到规则的时候，向前检查是否符合断言(正则语法),后顾/后瞻方向相反；
3.JavaScript不支持后顾；
4.符合和不符合特定断言称为"肯定/正向"匹配和“否定/负向”匹配；
名称 正则
正向前瞻 exp(?=assert)
负向前瞻 exp(?!assert)
正向后顾 exp(?<=assert) JavaScript不支持
负向后顾 exp(?<!assert) JavaScript不支持
例如：
前瞻 \w(?=\d) 匹配到单词后还要看看它后面是不是数字
>"a2*3".replace(/\w(?=\d)/g, 'X');  断言只作为检查,不作为匹配处理的内容
<"X2*3" 只处理匹配到的表达式；
>"a2*345v8".replace(/\w(?=\d)/g, 'X');  
<"X2*XX5X8"
>"a2*345vv".replace(/\w(?=\d)/g, 'X');
<"X2*XX5vv"
>"345".replace(/\w(?=\d)/g, 'X'); '345'中'34'作单词,5作数字
<"XX5"
负向前瞻：
"a22b345vv".replace(/\w(?!\d)/g, 'X');
"a2Xb34XXX" 2b、5vv


====== 2-10 JS对象属性
1）global：是否全文搜索,默认是false；
2）ignoreCase：是否大小写敏感,默认是false；
3）multiline：多行搜索,默认是false；
4）lastIndex：是当前表达式匹配内容的最后一个字符的下一个字符位置；
5）source：这则表达式的文本字符串；
例如：
var reg1 = /\w/;
var reg2 = /\w/gim;
>reg1.global
false
>reg1.ignoreCase
false
>reg1.multiline
false
>reg2.global
true
>reg2.ignoreCase
true
>reg2.multiline
true

>reg1.global = true
>reg1.global
false ==>global、ignoreCase、multiline三个属性是只读的；

>reg1.source
"\w"
>reg2.source
"\w"


====== 2-11 test 和 exec方法
1）RegExp.prototype.test(str)
1.用于测试字符串参数中是否存在匹配正则表达式模式的字符串
2.如果存在则返回true，否则返回false
var reg1 = /\w/;
var reg2 = /\w/g;
while(reg2.test('ab')) {
  console.log(reg2.lastIndex);
}
<1
<2 0a1b2
>reg2.test('ab')   => 从0开始, 执行前lastIndex=0,执行后lastIndex=1
true
>reg2.test('ab')   => 执行前lastIndex=1,执行后lastIndex=2
true
>reg2.test('ab')   => 执行前lastIndex=2,执行后lastIndex=0
false              => 第二个位置后面什么都没有匹配到，lastIndex重置为0

>reg2.test('ab')
true
>reg2.test('ab')
true
>reg2.test('ab')
false

2）RegExp.prototype.exec(str)
1.使用正则表达式对字符串执行搜索，并将更新全局RegExp对象的属性以反映匹配结果；
2.如果没有匹配的文本则返回null,否则返回一个结果数组,它有两属性：
- index 表示匹配文本的第一个字符的位置；
- input 存放被检索的字符串string
3）非全局调用（global=false）
1.调用非全局的RegExp对象的exec()时,返回数组；
  - 第1个元素是与正则表达式相匹配的文本；
  - 第2个元素是与RegExp对象的第一个子表达式(第1个分组)相匹配的文本(如果有的话);
  - 第3个元素是与RegExp对象的第二个子表达式(第2个分组)相匹配的文本(如果有的话),以此类推;


====== 2-12 字符串对象与正则表达式相关方法
1）String.prototype.search(reg)
search()方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串；
方法返回第一个匹配结果 index，查找不到返回 -1
search()并不执行全局匹配，它将忽略标志g,且总是从字符串的开始进行检索
例子：
'abc1w2f3g'.search(1) 3
>'abc1w2f3g'.search(2) 5
>'abc1w2f3g'.search(/\d/) 3
>'abc1w2f3g'.search(/\d/g) 3

2）String.prototype.match(reg)
match()方法将检索字符串，以找到一个或多个与RegExp匹配的文本
RegExp是否具有标志g 对结果影响跟大
非全局调用，即没有g
1.如果RegExp没有标志g,那么match()方法就只能在字符串中执行一次匹配；
2.如果没有找到任何匹配的文本，将返回null，否则它将返回一个数组，其中存放了与它找到的匹配文本有关的信息；
3.返回数组的第一个元素存放的是匹配文本，而其余的元素存放的是与正则表达式的子表达式(即分组)匹配的文本；
4.除了常规的数组元素之外，返回的数组还含有2个对象属性：
   index 表示匹配文本的起始字符在字符串的位置
   input 表示对string对象的引用
   例如：
var reg3 = /\d(\w)\d/;
var str = 'x1a2b3c4d5e';

var ret = str.match(reg3);
console.log(ret); ["1a2", "a"]
console.log(ret.index + '\t' + reg3.lastIndex); "1 0"

全局调用
1.如果RegExp具有标志g,则match()方法将执行全局检索,找到字符串中的所有匹配子字符串
- 没有找到任何匹配的子串，则返回null
- 如果找到了一个或多个匹配的子串，则返回一个数组
2.数组元素中存放地字符串中所有的匹配子串，而且也没有index 属性或input属性
var reg4 = /\d(\w)\d/g;
var str = 'x1a2b3c4d5e';

var ret = str.match(reg4);
console.log(ret); ["1a2", "3c4"]
console.log(ret.index + '\t' + reg4.lastIndex); "undefined  0"

3）String.prototype.split('separator')
1.常用split方法把字符串分割为字符数组；
>'a,b,c,d'.split(',');   =>  ["a", "b", "c", "d"]
2.在一些复杂情况下可用正则表达式作为分隔符解决；
>'a1b2c3d'.split(/\d/);  =>  ["a", "b", "c", "d"]

4）String.prototype.replace(arg1, arg2)
String.prototype.replace(str,replaceStr)
String.prototype.replace(reg,replaceStr)
String.prototype.replace(reg,function)
function会在每次匹配替换的时候调用，有四个参数:
- 匹配的字符串
- 正则表达式分组内容，没有分组则没有该参数
- 匹配项在字符串中 index
- 原字符串
举例：
>'a1b1c1'.replace('1', 2);  => "a2b1c1" //'1'被隐式转换为/1/
>'a1b1c1'.replace(/1/g, 2); => "a2b2c2"
'a1b2c3d4e5'  =>  'a2b3c4d5e6' 有分组参数：
var newStr = 'a1b2c3d4e5'.replace(/\d/g, function(match, index, origin){
    console.log(index + '\t' + match);
    return parseInt(match) + 1;
});
console.log(newStr);
"1  1"
"3  2"
"5  3"
"7  4"
"9  5"
"a2b3c4d5e6"
无分组参数：
var newStr = 'a1b2c3d4e5'.replace(/(\d)(\w)(\d)/g, function(
  match, group1, group2, group3,index, origin){
    console.log(index + '\t' + match);
    return group1 + group2;
});
console.log(newStr);
"1  1b2"
"5  3d4"
"a1bc3de5"