正则

正则表达式, 又名 "规则表达式"
由我们自己来书写 "规则", 专门用来检测 字符串 是否符合 "规则" 使用的
我们使用一些特殊的字符或者符号定义一个 "规则公式", 然后用我们定义好的 "规则公式" 去检测字符串是不是合格

var reg = /\d+/
var str1 = '123'
var str2 = 'abc'
console.log(reg.test(str1)) // true
console.log(reg.test(str2)) // false

上面的变量 reg 就是定制好的规则
检测 str1 这个字符串的时候, 符合规则
检测 str2 这个字符串的时候, 不符合规则

一、创建一个正则表达式

想制定 "规则", 就必须要按照人家要求的方式来制定
把一些字母和符号写在 // 中间的东西, 叫做正则表达式, 比如 \abcdefg\
创建正则表达式有两个方式 字面量 和 构造函数创建

1、字面量创建

// 字面量创建一个正则表达式
var reg = /abcdefg/

2、构造函数创建

var reg = new RegExp('abcdefg')

3、两种方式的区别

1. 书写修饰符的区别

        const reg_1 = /\w/ig
        const reg_2 = /abc/ig
        const reg_3 = /qf001/ig

        const reg_4 = new RegExp('abcd', 'ig')
        console.log(reg_3)// /qf001/gi
        console.log(reg_4)// /abcd/gi

2. 拼接变量和字符串

        const reg_5 = /^QQ|WW$/
        console.log('标准正则: ', reg_5)//标准正则:  /^QQ|WW$/
        const str1 = 'QQ'
        const str2 = 'WW'
        // const reg_5 = /^str1|str2$/ // 当前写法有问题, 因为正则中的 str1 和 str2 是当成正则的规则符号使用, 而不是 变量

        // /**
        //  *  1.字面量方式：
        //                  当前拼接之后我们得到的是一个字符串, 只不过长得很像我们的正则, 但是不能当作正则使用
        // */
        
        const reg_6 = '/^' + str1 + '|' + str2 + '$/'
        console.log('字面量的方式拼接字符串和变量', reg_6)// 字面量的方式拼接字符串和变量 /^QQ|WW$/

        // /**
        //  *  2.内置构造函数方式：
                                // 当前拼接后能够帮助我们创建一个正则, 但是这种写法会导致代码的可读性变得特别差, 所以开发时不建议这样书写
        // */

        const reg_7 = new RegExp('^' + str1 + '|' + str2 + '$')
        console.log('内置构造函数拼接字符串和变量', reg_7) // 内置构造函数拼接字符串和变量 /^QQ|WW$/

3. 书写元字符的区别

        const reg_a = /\d\w\s/
        console.log(reg_a)  // /\d\w\s/

        const reg_b = new RegExp('\d\w\s')// /dws/
        /**
         *  在 字符串中 我们书写的 \ 也是一个转义符
         * 
         *  能够将没有意义的字符转换成具有意义的符号
         *  也能够将有意义的符号, 转换成没有意义的字符
         * 
         * 
         *  \d: 通过 \ 转义符将 字母d 转换成一个具有特殊含义的符号
         *      但是 符号d 并没有任何特殊含义, 所以实际的符号我们接收到的是 d
         * 
         * 
         *  所以最终我们的 内置构造函数接收到的其实是       'dws'
        */
        console.log(reg_b)  // /dws/

        const reg_c = new RegExp('\\d\\w\\s')
        /**
         *  在 字符串中 我们书写的 \ 也是一个转义符
         * 
         * 
         *  我们在当前字符串中 是用了一个 \ 将他后边的 一个符号, 转换成没有意义的字符了
         * 
         *  所以最终我们的 内置构造函数接收到的其实是       '\d\w\s'
         * 
         *  然后就能够帮助我们创建出来一个正则, 内部是 元字符
        */
        console.log(reg_c)  // /\d\w\s/

二、正则表达式里面的符号

1、元字符

正则的规则符号：有普通文本也有正则规定的符号

.: 匹配非换行的任意字符
\: 转译符号, 把有意义的符号转换成没有意义的字符, 把没有意义的字符转换成有意义的符号

\s: 匹配空白字符(空格/制表符/tab/换行)
\S: 匹配非空白字符
\d: 匹配一位数字（0-9）
\D: 匹配非数字
\w: 匹配数字字母下划线
\W: 匹配非数字字母下划线

利用元字符制定一些简单的规则

var reg = /\s/
var str = 'a b'
var str2 = 'ab'
var str3 = '12\n3'
console.log(reg.test(str))  // true
console.log(reg.test(str2)) // false
console.log(reg.test(str3)) //true

var reg = /\d/
var str = 'abc1'
var str2 = 'abc'
console.log(reg.test(str))  // true
console.log(reg.test(str2)) // false

var reg = /\w/
var str = 'a1'
var str2 = '#$%'
console.log(reg.test(str))  // true
console.log(reg.test(str2)) // false

2、限定符

*: 前一个内容重复至少 0 次, 也就是可以出现 0~正无穷 次
+: 前一个内容重复至少 1 次, 也就是可以出现 1~正无穷 次
?: 前一个内容重复 0 或者 1 次, 也就是可以出现 0~1 次
{n}: 前一个内容重复 n 次, 也就是必须出现 n 次
{n,}: 前一个内容至少出现 n 次, 也就是出现 n ~ 正无穷 次
{n,m}: 前一个内容至少出现 n 次至多出现 m 次, 也就是出现 n~m 次

限定符一般是配合元字符使用

var reg = /\d*/ // 验证数字出现 0~正无穷次
var str = 'abc'
var str2 = 'abc1'
var str3 = 'abc123'
console.log(reg.test(str))  // true
console.log(reg.test(str2))  // true
console.log(reg.test(str3))  // true

var reg = /\d+/ // 验证数字出现 1~正无穷次
var str = 'abc'
var str2 = 'abc1'
var str3 = 'abc123'
console.log(reg.test(str))  // false
console.log(reg.test(str2))  // true
console.log(reg.test(str3))  // true

var reg = /\d?/ // 验证数字出现 0~1 次都可以
var str = 'abc'
var str2 = 'abc1'
var str3 = 'abc123'
console.log(reg.test(str))  // true
console.log(reg.test(str2))  // true
console.log(reg.test(str3))  // true

var reg = /\d{3}/ // 验证数字出现 3 次
var str = 'abc'
var str2 = 'abc1'
var str3 = 'abc123'
var str4 = 'abc12332'
console.log(reg.test(str))  // false
console.log(reg.test(str2))  // false
console.log(reg.test(str3))  // true
console.log(reg.test(str4))  // true

var reg = /\d{3,}/ // 验证数字出现 3~正无穷次
var str = 'abc'
var str2 = 'abc1'
var str3 = 'abc123'
var str4 = 'abc1234567890'
console.log(reg.test(str))  // false
console.log(reg.test(str2))  // false
console.log(reg.test(str3))  // true
console.log(reg.test(str4))  // true

var reg = /\d{3,5}/ // 验证数字出现 3~5 次
var str = 'abc'
var str2 = 'abc1'
var str3 = 'abc123'
var str4 = 'abc1234567890'
console.log(reg.test(str))  // false
console.log(reg.test(str2))  // false
console.log(reg.test(str3))  // true
console.log(reg.test(str4))  // true

        const reg = /^\d{3}$/
        console.log(reg.test('1'))//false
        console.log(reg.test('12'))//false
        console.log(reg.test('134'))//true
        console.log(reg.test('1325'))//false

        const reg1 = /^\d{3,}$/
        console.log(reg1.test('1'))//false
        console.log(reg1.test('12'))//false
        console.log(reg1.test('134'))//true
        console.log(reg1.test('1325'))//true

        const reg2 = /^\d{3,5}$/
        console.log(reg2.test('12'))//false
        console.log(reg2.test('123'))//true
        console.log(reg2.test('1344'))//true
        console.log(reg2.test('13255'))//true
        console.log(reg2.test('13255453'))//false

3、边界符

^: 表示开头
$: 表示结尾

边界符是限定字符串的开始和结束的

var reg = /^\d{3,5}$/
var str = 'abc'
var str2 = 'abc123'
var str3 = '1'
var str4 = '1234567'
var str5 = '123'
var str6 = '12345'
console.log(reg.test(str))  // false
console.log(reg.test(str2))  // false
console.log(reg.test(str3))  // false
console.log(reg.test(str4))  // false
console.log(reg.test(str5))  // true
console.log(reg.test(str6))  // true

  var reg = /^\d\w$/  //数字字母下划线数字
  var reg2 = /^abc$/  //以abc开头，以abc结尾
  var reg3 = /^a\dc$/  //以a开头，以c结尾，中间是数字

  console.log(reg.test('6_'))//true
  console.log(reg.test('68'))//true
  console.log(reg.test('6a'))//true
  console.log(reg.test('6aa6'))//false

  console.log(reg2.test('abc'))//true
  console.log(reg2.test('abcd'))//false
  console.log(reg2.test('abccba'))//false


  console.log(reg3.test('a2c'))//true
  console.log(reg3.test('a23456c'))//false
  console.log(reg3.test('a66'))//false

4、特殊符号

(): 限定一组元素

        // ()   包含的内容当成一个整体
        const reg1 = /^abc$/ // 表明当前字符串必须是 'abc'
        const reg2 = /^abc{2}$/  // 表明当前字符串必须是 'abcc'
        console.log(reg2.test('abc'))//false
        console.log(reg2.test('abcc'))//true
        console.log(reg2.test('abccc'))//false
        console.log(reg2.test('abcabc'))//false
        const reg3 = /^(abc){2}$/   // 表明当前字符串必须是 abcabc
        console.log(reg3.test('abc'))//false
        console.log(reg3.test('abcc'))//false
        console.log(reg3.test('abccc'))//false
        console.log(reg3.test('abcabc'))//true

[]: 字符集合, 表示写在 [] 里面的任意一个都行

        // const reg = /^abcd$/     // 字符串只能是 abcd
        const reg = /^[abcd]$/      // 字符串是 abcd 其中的一个就行

        console.log(reg.test('a'))//true
        console.log(reg.test('b'))//true
        console.log(reg.test('c'))//true
        console.log(reg.test('d'))//true
        console.log(reg.test('ad'))//false
        console.log(reg.test('abcd'))//false

[^]: 反字符集合, 表示写在 [^] 里面之外的任意一个都行

    
        // const reg = /^abcd$/     // 字符串只能是 abcd
        // const reg = /^[abcd]$/      // 字符串是 abcd 其中的一个就行
        const reg = /^[^abcd]$/      // 字符串只能有一个内容, 并且不能是 abcd 其中的某一个

        console.log(reg.test('a'))  // false
        console.log(reg.test('b'))  // false
        console.log(reg.test('c'))  // false
        console.log(reg.test('d'))  // false
        console.log(reg.test('1'))  // true
        console.log(reg.test('@'))  // true
        console.log(reg.test('A'))  // true

-: 范围, 比如 a-z 表示从字母 a 到字母 z 都可以

        const reg = /^[0-9]$/
        console.log(reg.test('5'))//true
        console.log(reg.test('10'))//false
        console.log(reg.test('@'))//false
        console.log(reg.test('w'))//false
        console.log(reg.test('d'))//false
        console.log(reg.test('D'))//false

|: 或, 正则里面的或 a|b 表示字母 a 或者 b 都可以

     /**
         *  或 将当前正则分为两个
         * 
         *      满足左或者右就行
         * 
         *      左: /^abc/
         *      右: /def$/
        */
        const reg = /^abc|def$/
        console.log(reg.test('abc'))//true
        console.log(reg.test('def'))//true
        console.log(reg.test('abcdef'))//true
        console.log(reg.test('qabc'))//false
        console.log(reg.test('defq'))//false
        console.log(reg.test('_abcdef_'))//false
        
        
        
        
        /**
         *  如果或被 小括号 包含, 那么就不会将 正则分为两个了
         * 
         *      当前正则的规则如下:
         *              1. a开头
         *              2. 后边跟上一个小写字母 b
         *              3. 小写 c 或者 小写 d 都可以
         *              4. 小写 e
         *              5. 以 f 结尾
        */
        const reg = /^ab(c|d)ef$/
        console.log(reg.test('abcef'))//true
        console.log(reg.test('abdef'))//true
        console.log(reg.test('abcdef'))//false

/**
 * 书写一个简单的邮箱验证
 * 
 *  验证规则:
 *      非 _$开头, 任意字符出现至少6次, 一个@符号, (163|126|qq|sina)中的任意一个, 一个点, (com|cn|net) 中的任意一个
*/
var reg = /^[^_$].{5,}@(163|126|qq)\.(com|cn|net)$/

5、标识符

修饰整个正则表达式
i: 表示忽略大小写
这个 i 是写在正则的最后面的, 例如: /\w/i
这就是在匹配的时候匹配数字字母下划线, 并且不区分大小写

        var myreg = /[a-z]/
        var myreg2 = /[a-z]/i
        console.log(myreg.test('AA'))//false
        console.log(myreg2.test('AA'))//true

g: 表示全局匹配
这个 g 是写在正则的最后面的, 例如: /\w/g
就是全局匹配数字字母下划线

6、重复元字符

\数字: 表示重复第 n 个小括号的内容, 要求和第 n 个小括号的内容一摸一样

/**
 * 表示 \1 位置需要出现一个 和 第1个 小括号 一模一样的
 *  小括号位置出现的是 abc, \1 位置也带是 abc
 *  小括号位置出现的是 def, \1 位置也带是 def
*/
var reg = /^(abc|def)\1$/
console.log(reg.test('abcabc')) // true
console.log(reg.test('defdef')) // true
console.log(reg.test('defabc')) // false


const reg = /^<(span|p)><\/\1>$/
console.log(reg.test('<p></p>'))        // true
console.log(reg.test('<span></span>'))  // true
console.log(reg.test('<span></p>'))     // false

// const reg = /^<span></span>$/
// const reg = /^<span><\/span>$/
// const reg = /^<(span|p)><\/(span|p)>$/
// console.log(reg.test('<p></p>'))             // true
// console.log(reg.test('<span></span>'))       // true
// console.log(reg.test('<span></p>'))          // true

三、正则的两大特性 (懒惰与贪婪)

懒惰
- 每次捕获都会从字符串 [0] 的位置开始检索
- 解决:
  - 给正则添加全局标识符
贪婪
- 每次捕获内容的时候会尽可能地多的去捕获内容
- 解决:
  - 使用非贪婪限定符(在原有限定符后面多加一个 ?)
- 贪婪限定符
  - *; +; ?; {n,}; {n,m}
- 非贪婪限定符
  - *?; +?; ??; {n,}?; {n,m}?

var str = `<div class="box" id="box"><span></span></div>`

// 贪婪捕获
var reg = /<div.*>/
console.log(reg.exec(str))

// 非贪婪捕获
var reg1 = /<div.*?>/
console.logIreg1.exec(str)

四、正则表达式的方法

1、（匹配）test 用来检测字符串是否符合我们正则的标准

语法: 正则.test(字符串)
返回值: boolean

console.log(/\d+/.test('123'))

2、（捕获）exec

语法: 正则.exec(字符串)
返回值:
1. 当原始字符串内没有符合正则规范的片段的时候, 返回值为 null
2. 当原始字符串内有符合正则规范的判断的时候
  - 返回值一定是一个数组: 数组内的 [0] 是捕获出来的字符串片段
  - 没有 () 没有标识符g
    - 只能获取第一组匹配到的字符串片段
    - 不管匹配多少回, 都是从字符串 [0] 的位置开始检索
  - 有 () 会在返回值数组的 [1] 开始依次是每一个 () 内的单独内容
  - 有 g
    - g 叫做全局标识符
    - 第二次捕获会从第一次捕获的结束位置开始进行检索
    - 直到找不到内容, 返回 null
    - 在下一次捕获的时候, 会从字符串 [0] 开始检索
扩展: 匹配但不捕获
- 当我们需要使用 () 的一个整体这个作用的时候, 但是又不想单独捕获出来
- 可以这样书写: (?:)

var reg = /\d{3}/
var str = 'hello123word456你好789'
var res = reg.exec(str)
console.log(res)
/*
    ['123', index: 5, input: 'hello123word456你好789', groups: undefined]
        0: "123"
        groups: undefined
        index: 5
        input: "hello123word456你好789"
        length: 1
*/

数组第 0 项就是匹配到的字符串内容
index 属性表示从字符串的索引几开始是匹配到的字符串

五、字符串的方法

字符串中有一些方法是可以和正则一起使用

1.search: 查找字符串中是否有满足条件的内容

语法: 字符串.search(正则)
返回值: 有的话返回开始索引, 没有返回 -1

var reg = /\d{3}/
var str1 = 'hello123'
var str2 = 'hello'
console.log(str1.search(reg))   // 5
console.log(str2.search(reg))   // -1

2.match: 找到字符串中符合正则条件的内容返回

语法: 字符串.match(正则)
返回值:
- 没有标识符 g 的时候, 是和 exec 方法一样
- 有标识符 g 的时候, 是返回一个数组, 里面是匹配到的每一项, 没有匹配到内容是返回的是 null

var reg = /\d{3}/
var str1 = 'hello123world456'
var str2 = 'hello world'
console.log(str1.match(reg))
/*
['123', index: 5, input: 'hello123world456', groups: undefined]
    0: "123"
    groups: undefined
    index: 5
    input: "hello123world456"
    length: 1
*/
console.log(str2.match(reg))    // -1

var reg = /\d{3}/g
var str1 = 'hello123world456'
var str2 = 'hello world'
console.log(str1.match(reg))    // ['123', '456']
console.log(str2.match(reg))    // null

3.replace: 是将字符串中满足正则条件的字符串替换掉

语法: 字符串.replace(正则, 要替换的字符串)
返回值: 替换后的字符串

var reg = /\d{3}/
var str1 = 'hello123world456'
var str2 = 'hello world'
console.log(str1.replace(reg, '哈哈哈哈'))    // hello哈哈哈哈world456
console.log(str2.replace(reg, '哈哈哈哈'))    // hello world

var reg = /\d{3}/g
var str1 = 'hello123world456'
var str2 = 'hello world'
console.log(str1.replace(reg, '哈哈哈哈'))    // hello哈哈哈哈world哈哈哈哈
console.log(str2.replace(reg, '哈哈哈哈'))    // hello world

正则表达式（十三）

正则

一、创建一个正则表达式

1、字面量创建

2、构造函数创建

3、两种方式的区别

1. 书写修饰符的区别

2. 拼接变量和字符串

3. 书写元字符的区别

二、正则表达式里面的符号

1、元字符

2、限定符

3、边界符

4、特殊符号

5、标识符

6、重复元字符

三、正则的两大特性 (懒惰与贪婪)

四、正则表达式的方法

1、（匹配）test 用来检测字符串是否符合我们正则的标准

2、（捕获）exec

五、字符串的方法

1.search: 查找字符串中是否有满足条件的内容

2.match: 找到字符串中符合正则条件的内容返回

3.replace: 是将字符串中满足正则条件的字符串替换掉