正则表达式基本语法

正则表达式

作用: 我们自己书写一个 规则, 去验证 **字符串** 是否符合规则
    + 正则也是一个 JS 的复杂数据类型
正则表达式的创建
    1. 字面量创建正则表达式
      => var reg = /abcd/
    2. 内置构造函数创建正则表达式
      => var res = new RegExp('abcd')

  正则表达式两种创建方式的区别
1. 标识符的书写
    => 字面量方式, 直接书写在正则的最后面
    => 内置构造函数方式, 需要书写在第二个参数的位置

2. 字符串拼接
    => 字面量方式无法拼接字符串
    => 内置构造函数, 因为第一个参数位需要字符串格式, 所以可以使用字符串拼接

3. 书写基本元字符
    => 字面量方式直接书写 \s\d\w
    => 内置构造函数书写 \\s\\d\\w

一、元字符-基本元字符

正则表达式的组成
    + 文本
      => 没有特殊意义的文本
    + 元字符
      => 有特殊意义的 字符
    + 标识符
      => 书写在正则表达式的外面, 用来修饰整个正则表达式的
      
  元字符 - 基本元字符
    1. \s : 一位 空白内容
    2. \S : 一位 非空白内容
    3. \d : 一位 数字内容
    4. \D : 一位 非数字内容
    5. \w : 一位 数字字母下划线
    6. \W : 一位 非数字字母下划线的任意内容
    7. 点(.) : 一位 非换行以外的任意内容都行
    8. \ : 转义符
      => 把没有意义的转换成有意义的
      => 把有意义的转化成没有意义的

二、元字符-边界符

 1. ^ : 表示字符串开头
  2. $ : 表示字符串结尾
  + 当 开头 和 结尾 一起使用的时候
    => 表示从开头到结尾

三、元字符-修饰符

 元字符 - 修饰符
    + 修饰符只是用来修饰前面 **一个** 内容

  1. * : 表示 0 ~ 多次
  2. + : 表示 1 ~ 多次
  3. ? : 表示 0 ~ 1 次
  4. {n} : 表示指定 n 次
  5. {n,} : 表示至少 n 次, n ~ 多次
    => {0,} 等价于 *
    => {1,} 等价于 +
  6. {n,m} : 表示 n ~ m 次
    => {0,1} 等价于 ?

四、元字符-特殊符号

1. ()
    => 含义1: 一个整体
    => 含义2: 单独捕获(欠着)
  2. |
    => 一般和 () 连用
    => 表示一个内容或者另一个内容
  3. []
    => 任选
    => **一个 [] 只能表示一位字符**
    => 表示 [] 内的任意一个都行
  4. [^]
    => 非
    => **一个 [^] 只能表示一位字符**
    => 表示 [^] 内的任意一个都不行
  5. -
    => 至 或者 到
    => 和 [] 或者 [^] 连用的符号
    => 注意: 必须是 ASCII 编码连着的才可以
    => [0-9] 等价于 \d
    => [^0-9] 等价于 \D
    => [0-9a-zA-Z_] 等价于 \w
    => [^0-9a-zA-Z_] 等价于 \W

五、正则的标识符

书写在正则的外面，用来修饰整个正则表达式的
 1. i (ignore)
    => 作用: 忽略大小写不计
2. g (global)
    => 作用: 全局
    => 当你进行捕获的时候
     ->后一次捕获会从前一次捕获的结束位置开始查找

六、正则的常用方法

1. 匹配
    + 语法: 正则.test(要检测的字符串)
    + 返回值: 一个布尔值
      => 如果字符串满足正则要求, 那么就是 true
      => 如果字符串不满足正则要求, 那么就是 false

  2. 捕获
    + 语法: 正则.exec(要捕获的字符串)
    + 返回值:
      2-1. 如果字符串中没有满足正则表达式的内容
        => 那么就是 null
      2-2. 如果字符串中有满足正则表达式的内容
        2-2-1. 没有 () 没有全局 标识符 g
          => 结果是一个数组
          => 索引 [0] 位置就是满足正则要求的第一个内容
          => 你的每一次捕获都是从索引 0 开始去查找
        2-2-2. 有全局标识符 g
          => 结果是一个数组
          => 索引 [0] 位置就是满足正则要求的第一个内容
          => 第二次捕获是从第一次捕获的结束位置开始先后查找
          => 直到找到为 null, 再下一次又是从 [0] 开始查找
        2-2-3. 有 ()
          => 结果是一个数组
          => 索引 [0] 位置就是满足正则要求的第一个内容
          => 从索引 [1] 开始, 依次是正则表达式中的每一个小括号的单独内容

七、正则的特性

懒惰性: 每一次的捕获都会默认从 字符串的开头 开始去检测
      => 解决: 使用全局标识符 g
贪婪性: 在一次的匹配中尽可能的多获取内容
      => 如何进入非贪婪模式
      => 在修饰符后面再加一个 问号(?)
      贪婪修饰符    非贪婪修饰符
        *            *?
        +            +?
        ?            ??
        {n,}         {n,}?
        {n,m}        {n,m}?

八、字符串和正则合作的方法

1. replace()
      => 语法:
        -> 字符串.replace(换下字符, 换上字符)
        -> 字符串.replace(正则, 换上字符)
      => 返回值:
        -> 如果第一个参数传递的是字符串, 只能替换一个
        -> 如果第一个参数传递的是正则, 但是没有全局标识符 g, 那么只能替换一个
        -> 如果第一个参数传递的是正则, 并且有全局标识符 g, 那么全部替换

    2. search()
      => 语法:
        -> 字符串.search(字符片段)
        -> 字符串.search(正则)
      => 返回值:
        -> 字符串内有 字符串片段 或者 满足正则表达式的内容, 那么就是这一段内容的 索引
        -> 如果没有就是 -1

    3. match()
      => 语法:
        -> 字符串.match(字符片段)
        -> 字符串.match(正则)
      => 返回值:
        -> 如果第一个参数传递的是字符串或者没有全局标识符 g 的正则, 那么结果是 exec 一样
        -> 如果是一个正则并且有全局标识符g, 那么是一个数组
        -> 数组里面是原始字符串中的所有符合正则标准的片段