正则

字面量
    var reg = / \bis\b /g;
    匹配语句中为is的单词,g表示为全文匹配
    eg: 'This is a boy.That is a dog'.replace(reg,'IS');
构造函数
    var reg = new RegExp('\\bis\\b','g');
    eg: 'This is a boy.That is a dog'.replace(reg,'IS');

修饰符
    g:global表示全文匹配
    i:ignore case忽略大小写
    m:multiple lines 多行搜素
eg:全文匹配并忽略大小写：
    'This is a boy. That is a dog.'.replcae('/\bis\b/gi','IS');

正则表达式有两种基本字符类组成：
 1. 原义文本字符
 2. 元字符 ：是在正则表达式中有特殊含义的非字母字符.
    * + ? $ ^ . | \ () {} []

字符类:
    可以使用元字符[]来构建一个简单的类
    所谓类是指符合某些特性的对象，一个泛指，而不是指某个字符.
    表达式 [abc] 把字符a或b或c归为一类，表达式可以匹配这类的字符.

    >字符类取反
    把abc以外的字符都替换为X:
    source: 'a1B2c3d4'.replace(/[^abc]/g,'X');
    res: "aXXXcXXX"

范围类：
    可以使用[a-z]来连接两个字符白哦是从a到z的任意字符
    eg: 把a-z的字符替换为字符'Q':
    source: 'a1B2c3d4'.replace(/[a-z]/g,'Q');
    res: "Q1B2Q3Q4"
    > 在[]组成的类内部是可以连写的：[a-zA-Z]
    > 在匹配日期类时也想同时匹配'-':
    source: '2019-08-13'.replace(/[0-9-]/g,'A')
    即在后面多加一个'-'即可.

预定义类：
    .   :   除了回车符和换行符之外的所有字符
    \d  :   数字字符
    \D  :   非数字字符
    \s  :   空白符
    \S  :   非空白符
    \w  :   单词字符(字母、数字、下划线) 等效：[a-zA-Z_0-9]
    \W  :   非单词字符

    eg:匹配一个 ab + 数字 + 任意字符 的字符串
    reg： ab\d.

边界：
    ^   :   以xxx开始
    $   :   以xxx结束
    \b  :   单词边界(word boundary)
    \B  :   非单词边界

    eg：替换 'This is a Boy' 中的 This 中的 is
     'This is a Boy'.replace(/\Bis\b/gi,'A');

量词：
    ?       :   出现零次或一次(最多出现一次)
    +       :   出现一次或多次(至少出现一次)
    *       :   出现零次或多次(任意次)
    {n}     :   出现 n 次
    {n,m}   :   出现 n 到 m 次
    {n,}    :   至少出现 n 次

贪婪模式:正则表达式尽可能多的匹配
    eg:
    source:'12345678'.replace(/\d{3,5}/g,'A');
    res:    AA

非贪婪模式：让正则表达式尽可能少的匹配，即一旦成功匹配就不再继续尝试，只需在量词后加?即可
    eg:
    source:'123456789'.match(/\d{3,5}?/g);
    res:    ['123','456','789']

分组：使用()可以达到分组的功能，使量词作用于分组
    eg:
    (Byron){3}  :   'Byron'循环三次

前瞻：
    正则表达式从文本头部向尾部开始解析，文本尾部方向，称为"前"
    前瞻就是在正则表达式匹配到规则的时候，向前检查是否符合断言，后顾/后瞻方向相反.
    符合和不符特定断言成为 肯定/正向 匹配和 否定/负向匹配
    *正向后顾/负向后顾JavaScript不支持
    正向前瞻    :   exp(?=assert)
    负向前瞻    :   exp(?!assert)
    eg:
    resource    :   'a2*34v8'.replace(/\w(?=\d)/g,'X')
    res         :   'X2*X4X8' 

对象属性：
    global          ：  是否全文搜索,默认false
    ignore case     :   是否大小写敏感,默认是false
    multiline       :   多行搜索,默认值是false
    lastIndex       :   是当前表达式匹配内容的最后一个字符的下一个位置
    source          :   正则表达式的文本字符串

正则对象的方法:
RegExp.prototype.test(str)      :       用于测试字符串参数中是否存在匹配正则表达式模式的字符串,存在结果为true,不存在为false
eg:
resource:
    var reg = /\w/g;
    while(reg.test('ab')){
        console.log(reg.lastIndex);
    }
res:
    1
    2
若只是为了测试是否匹配,则没有必要使用g全局变量属性.

RegExp.prototype.exec(str)      :       使用正则表达式模式对字符串执行搜索,并将更新全局RegExp对象的属性以反映匹配结果.
                                        如果没有匹配的文本则返回null,否则返回一个结果数组.
    非全局调用:
        调用非全局的 RegExp 对象的 exec() 时,返回数组
        第一个元素是与正则表达式相匹配的文本
        第二个元素是与 RegExpObject 的第一个子表达式相匹配的文本(如果有的话) 
        第三个元素是与 RegExp 对象的第二个子表达式相匹配的文本(如果有的话),以此类推

字符串对象的方法:
    String.prototype.search(reg)    :   search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串
                                        方法返回第一个匹配结果 index;查找不到返回-1
                                        search() 方法不执行全局匹配，它将忽略标志 g ,并且总是从字符串的开始进行检索.                                  

    String.prototype.match(reg)     :   match() 方法将检索字符串,以找到一个或多个与 regexp 相匹配的文本.
                                        regexp 是否具有标志 g 对结果影响很大.
        非全局调用：
            如果regexp没有标志 g ，那么 match() 方法就只能在字符串中执行一次匹配
            如果没有找到任何匹配的文本,将返回 null,否则它将返回一个数组，其中存放了与它找到的匹配文本有关信息
            > 返回数组的第一个元素存放的是匹配文本，而其余的元素存放的是与正则表达式的子表达式匹配的文本
            > 除了常规的数组元素之外，返回的数组还含有2个对象属性：
                index   :   声明匹配文本的起始字符串的位置
                input   ：  声明对 stringObject 的引用

        全局调用：
            如果 regexp 具有标志 g 则 match() 方法将执行全局检索,找到字符串中的所有匹配字符串
                如果没有找到任何匹配的子串,则返回null
                如果找到了一个或多个匹配字串,则返回一个数组
            数组中存放的是字符串中所有的匹配字串,而且也没有index 属性或 input 属性
    
    String.prototype.split(reg)     :      
        经常使用 split 方法把字符串分割为字符数组,
            resource    :   'a,b,c,d'.split(',');
            res         :   ["a","b","c";"d"]
        在一些复杂的分割情况下我们可以使用正则表达式解决
            resource    :   'a1b2c3d'.split(/\d/);
            res         :   ["a","b","c";"d"]

    String.prototype.replace(reg)   :
        字符串替换       :
            String.prototype.replace(str,replaceStr)
            String.prototype.replace(reg,replaceStr)
            String.prototype.replace(reg,function)
                function 参数含义
                    function 会在每次匹配替换的时候调用，有四个参数
                        1.匹配字符串
                        2.正则表达式分组内容，没有分组则没有该参数
                        3.匹配项在字符串中的index
                        4.原字符串
                eg: a1b2c3d4e5 --> a2b3c4d5e6
                    无分组
                    resource:
                        'a1b2c3d4e5'.replace(/\d/g,function(match,index,origin){
                            console.log(index);
                            return parseInt(match) + 1;
                            
                        });
                    res     :
                        1
                        3
                        5
                        7
                        9
                        "a2b3c4d5e6"
                eg: a1b2c3d4e5 --> a12c34e5
                    有分组
                    resource:
                    'a1b2c3d4e5'.replace(/(\d)(\w)(\d)/g,function(match,group1,group2,group3,index,origin){
                        console.log(match);
                        return group1 + group3;
                    });

                    res:
                        1b2
                        3d4
                        "a12c34e5"