1、创建方式

    字面量创建
        const reg = / 正则符号 /
    内置构造函数创建
        const reg = new RegExp('正则符号')

字面量创建

内置构造函数创建

2、正则的元字符

    \d   表示 一位 数字 （0 - 9）
    \D   表示 一位 非数字（除了0 - 9 之外的）
    \s   表示 一位 空白 内容（空格/ 缩进）
    \S   表示 一位 非空白 内容（除了 空格/ 缩进）
    \w   表示 一位 数字/字母/下划线
    \W   表示 一位 非 数字/字母/ 下划线
    .    表示 一位 非换行内容
    \    表示 转义
         可以将 一个 没有特殊含义的字符，转移为可能具有特殊含义
         也可以将一个具有特殊含义的字符，转换为一个 不不具备特殊含义的字符

3、正则的边界元字符

    ^  表示开头
    $  表示结尾

4、正则的限定元字符

    *   表示0~无穷
    +   表示1~无穷
    ？  表示0~1
    {}
        {n}   表示必须出现n次
        {n,}  表示至少n次
        {n,m} 表示最少出现n次，最多m次

5、特殊元字符

    ()   将包含的内容当做一个整体
         单独捕获
    |    或
         表示左右两边满足其中一个就行
         注意：| 被包裹，小括号分成两个条件
               | 没有被包裹，将整个正则分成两个
    []   包含  当前规则名有一个字符，是[]内的
    [^]  不包含   当前规则表明有一个字符，不是[] 内的数据
    -    到   一般需要和 [] 连用

6、重复元字符

    \n    表示重复前边第几个小括号的内容
    

7、正则的标识符

    标识符也叫修饰符，由于修饰正则的，所以需要都写在正则的末尾
    i    表示忽略大小写
    g    表示全局

8、正则的两大特性

    1、贪婪
        在捕获的时候，尽可能的去多拿一些内容
        贪婪限定符，如果在正则使用，默认开启 贪婪模式
            *
            +
            ?
            {n,}
            {n,m}
        非贪婪模式在上面 的 限定符 后 加 一个 ?
            *?
            +?
            ??
            {n,}?
            {n,m}?
    2、懒惰
        在正则中我们每一次捕获都是处于懒惰模式，那么也就是说，每一次都会从 [0] 开始捕获
        如果 想要开启非贪婪懒惰模式，只 需要在 正则的最后添加一个修饰符 g

正则表达式 的 方法

    test 用来检测字符串是否符合我们正则的标准
    语法 ： 正则.test(字符串)
    返回值：Boolean
    
    exec 把字符串符合条件的内容 捕获出来
    语法： 正则.exec(字符串)
    返回值：
        1、当原始字符串没有符合正则规范的片段时，返回值为 NULL
        2、当原始字符串内 有符合正则规范的判断的时候
            返回值一定是一个数组，数组内的下标 [0] 为 捕获出来的字符串片段
            没有() 没有标识符g
                只能获取第一个匹配到的字符串片段
                不管匹配多少回，都是从字符串 [0] 的位置开始检索
            有()
                会返在返回值数组的 [1] 开始依次是每一个 () 内 单独内容
            有g
                g 叫全局标识符
                第二次捕获会从第一次捕获的结束位置开始进行检索
                直到找不到内容 返回NULL
                在下一次捕获的时候，会从字符串[0] 开始检索

正则 创建 的 两种方法的 区别

    //1、书写修饰符的区别
    const reg_1 = /\w/ig //(字面量的书写方式)
    const reg_2 = new RegExp('da','ig') //（内置构造函数的书写方式）
    
    
    //2、拼接变量和字符串
    const reg_1 = /^QQ|WW$/
    
    const str1 = 'QQ'
    const str2 = 'WW'
    
    const reg_2 = '/^' + str1 + str2 + '$/' // 这个拼接好之后一定是一个 字符串
    而不是 一个 正则
    
    const reg_3 = new RegExp('^' + str1 + '|' + str2 + '$') // 这个 不推荐使用
    
    // 3、书写元字符的区别
    
    const reg_1 = /\d\w\s/
    
    const reg_2 = new RegExp('\d\w\s')  // 这个运行到浏览器 后 为 \dws\ 不是
                                        // 我们想要的结构 ，可以通过 \ 转义符 来实现
    const reg_3 = new RegExp('\\d\\w\\s') // 通过这种方式 实现

字符串中能使用 正则的方法

    1. replace
        字符串.replace('要查找的字符串片段','替换的新字符串片段')
        字符串.replace(正则，'替换的字符串')
        
    2. search
        字符串.search('字符串片段')
        查找到返回 下标 没查询到 返回 -1
    3. match
        字符串.match('字符串片段')
        字符串.match(正则)
        
            如果正则没有修饰符g, 那么作用和 正则 的 exec 作用一样
            如果正则 有 修饰符g, 那么会将字符串中所有符合规则的部分存放在一个数组中返回