正则

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

        const reg = /aa/
        const s1 = 'qwer'
        const s2 = 'aa1'
        const s3 = '111a222a'
        const s4 = 'wndjnfdskuar234'
        console.log(reg.test(s1)); 
        console.log(reg.test(s2)); 
        console.log(reg.test(s3));

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

创建一个正则表达式

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

字面量创建

// 字面量创建一个正则表达式
const reg = /abc/

内置构造函数创建

const reg1 = new RegExp('abcdefg')

正则表达式里面的符号

元字符

\d: 匹配数字 :表示一位数字（0-9）
- 要求字符串中最少包含一位数字

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

\D: 匹配非数字
- 要求字符串中最少包含一位非数字

        const reg = /\D/
        const str = 'abc1'
        const str2 = '123'
        console.log(reg.test(str))  // true
        console.log(reg.test(str2)) // false

\s: 匹配空白字符(空格/制表符/...)
- 要求字符串中最少包含一位空格

       const reg = /\s/
       const str = 'a b'
       const str2 = 'ab'
       console.log(reg.test(str))  // true
       console.log(reg.test(str2)) // false

\S: 匹配非空白字符
- 要求字符串中最少包含一位非空格

        const reg = /\S/
        const str = 'a b'
        const str2 =' '
        console.log(reg.test(str))  // true
        console.log(reg.test(str2)) // false

\w: 匹配数字字母下划线

        const reg = /\w/
        const str = '1@#w'
        const str2 = '!@#$'
        console.log(reg.test(str))  // true
        console.log(reg.test(str2)) // false

\W: 匹配非数字字母下划线

        const reg = /\W/
        const str = '1@#w'
        const str2 = '345'
        console.log(reg.test(str))  // true
        console.log(reg.test(str2)) // false

.: 匹配非换行的任意字符

        console.log(/./.test('12fB$% '));//true
        console.log(/./.test('\n'));//false

\: 转义符号, 把有意义的符号转换成没有意义的字符, 把没有意义的字符转换成有意义的符号

        const reg = /\d\.\d/
        const reg1 = /qwe/  // 要求包含 字母 qwe
        const reg2 = /w/  // 要求包含 字母 w
        const reg3 = /\w/  // 要求包含 字母/数字/下划线 其中的一个

边界符

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

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

        const reg1 = /^\d/ //开头是数字
        const reg2 = /\d$/ //结尾是数字
        const reg3 = /^\d$/ //只能是一位数字
        console.log(reg1.test('1werq')); //true
        console.log(reg2.test('1werq2')); //true
        console.log(reg3.test('4')); //true

限定符

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

*: 前一个内容重复至少 0 次, 也就是可以出现 0~正无穷 次

        const reg = /^\d*$/ // 字符串只能由数字组成, 数字出现 0~正无穷次
        console.log(reg.test('qwerty')) // false
        console.log(reg.test('')) // true
        console.log(reg.test('qf001')) // false
        console.log(reg.test('1234567890')) // true

+: 前一个内容重复至少 1 次, 也就是可以出现 1~正无穷 次

        const reg = /^\d+$/ // 字符串只能由数字组成, 数字出现 1~正无穷次
        console.log(reg.test('qwerty')) // false
        console.log(reg.test('')) // false
        console.log(reg.test('qf001')) // false
        console.log(reg.test('1234567890')) // true

?: 前一个内容重复 0 或者 1 次, 也就是可以出现 0~1 次

        const reg = /^\d?$/ // 字符串只能由数字组成, 数字出现 0~1
        console.log(reg.test(''))       // true
        console.log(reg.test('9'))      // true
        console.log(reg.test('98888'))  // false

{n}: 前一个内容重复 n 次, 也就是必须出现 n 次

        const reg1 = /^\d{3}$/   // 字符串只能由数字组成, 数字必须出现 3 次
        console.log(reg1.test('1'))      // false
        console.log(reg1.test('12'))     // false
        console.log(reg1.test('123'))    // true
        console.log(reg1.test('1234'))   // false

{n,}: 前一个内容至少出现 n 次, 也就是出现 n ~ 正无穷 次

        const reg2 = /^\d{3,}$/   // 字符串只能由数字组成, 数字 最少出现 3 次
        console.log(reg2.test('1'))      // false
        console.log(reg2.test('12'))     // false
        console.log(reg2.test('123'))    // true
        console.log(reg2.test('1234'))   // true

{n, m}: 前一个内容至少出现 n 次至多出现 m 次, 也就是出现 n~m 次

        const reg2 = /^\d{3,5}$/   // 字符串只能由数字组成, 数字 最少出现 3 次, 最多出现 5 次
        console.log(reg2.test('1'))         // false
        console.log(reg2.test('12'))        // false
        console.log(reg2.test('123'))       // true
        console.log(reg2.test('1234'))      // true
        console.log(reg2.test('12345'))     // true
        console.log(reg2.test('123456'))    // false

特殊元字符

(): 将包含的内容当成一个整体，单独捕获

        const reg1 = /^abc$/ // 表明当前字符串必须是 'abc'
        const reg2 = /^abc{2}$/  // 表明当前字符串必须是 'abcc'
        console.log(reg2.test('abc'))
        console.log(reg2.test('abcc'))
        console.log(reg2.test('abccc'))
        console.log(reg2.test('abcabc'))
        const reg3 = /^(abc){2}$/   // 表明当前字符串必须是 abcabc
        console.log(reg3.test('abc'))
        console.log(reg3.test('abcc'))
        console.log(reg3.test('abccc'))
        console.log(reg3.test('abcabc'))

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

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

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

        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

-:
- 一般需要和 [] 连用
- [0-9] 表明一个数字 0~9 即可
- [^0-9] 表明一个非数字内容
- [a-z] 表明一个小写字母 a~z 即可
- [A-Z] 表明一个大写字母 A~Z 即可

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

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

注意 : | 有没有被()包裹

包裹：将小括号内分成两个条件

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

不包裹：将整个正则分为两个

       /**
         *  或 将当前正则分为两个
         * 
         *      满足左或者右就行
         * 
         *      左: /^abc/
         *      右: /def$/
        */
        const reg = /^abc|def$/
        console.log(reg.test('abc'))
        console.log(reg.test('def'))
        console.log(reg.test('abcdef'))
        console.log(reg.test('qabc'))
        console.log(reg.test('defq'))
        console.log(reg.test('_abcdef_'))

重复元字符

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

/**
 *  小括号位置出现的是 abc, \1 位置也带是 abc
 *  小括号位置出现的是 def, \1 位置也带是 def
console.log(/\d+/.test('123'))
 * 表示 \1 位置需要出现一个 和 第1个 小括号 一模一样的
        const reg = /^<(span|p)><\/\1>$/
        console.log(reg.test('<p></p>'));//true
        console.log(reg.test('<span></span>'));//true
        console.log(reg.test('<p></span>'));//false

标识符

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

正则的捕获

语法: 正则.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 属性表示从字符串的索引几开始是匹配到的字符串

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

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

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

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

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

正则表达式的方法

test 用来检测字符串是否符合我们正则的标准

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

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

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 属性表示从字符串的索引几开始是匹配到的字符串

字符串的方法

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

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

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

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

案例

登录信息正则判断

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <style>
        * {
            margin: 0;
            padding: 0;
        }

        table {
            margin: 50px auto;
            height: 250px;
            width: 400px;
            border: 5px lightpink solid;
            border-radius: 10px;
            padding: 20px;
        }

        input {
            border-radius: 2px;
        }

        .prompt {
            color: red;
            text-indent: 1em;
            opacity: 0;
        }

        button {
            width: 400px;
        }
    </style>
</head>

<body>
    <table align="center">
        <tr>
            <td>用户名：</td>
            <td><input class="logName" type="text"></td>
        </tr>
        <tr>
            <td colspan="2" class="prompt">请按照规则填写用户名</td>
            <td></td>
        </tr>
        <tr>
            <td>密&nbsp;&nbsp;码：</td>
            <td><input class="logPass" type="password"></td>
        </tr>
        <tr>
            <td colspan="2" class="prompt">请按照规则填写密码</td>
            <td></td>
        </tr>
        <tr>
            <td>手机号：</td>
            <td><input class="logPho" type="text"></td>
        </tr>
        <tr>
            <td colspan="2" class="prompt">请按照规则填写手机号</td>
            <td></td>
        </tr>
        <tr>
            <td colspan="2"><button>注册</button></td>
            <td></td>
        </tr>
    </table>
    <script>
        let logName = document.querySelector('.logName')
        let logPass = document.querySelector('.logPass')
        let logPho = document.querySelector('.logPho')
        let pro = document.querySelectorAll('.prompt')
        let obj = {
            name:/^(\d|[a-z]){6,11}$/,
            pass:/^\w{6,12}$/,
            num:/^1[^2]\d{9}$/
        }
        logName.onblur = function () {
            !(obj.name.test(logName.value))?pro[0].style.opacity = 1:pro[0].style.opacity = 0
        }
        logPass.onblur = function () {
            !(obj.pass.test(logPass.value))?pro[1].style.opacity = 1:pro[1].style.opacity = 0
        }
        logPho.onblur = function () {
            !(obj.num.test(logPho.value))?pro[2].style.opacity = 1:pro[2].style.opacity = 0
        }
    </script>
</body>

</html>

密码强度检测

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <style>
        * {
            margin: 0;
            padding: 0;
        }

        .box {
            margin: 50px auto;
            width: 300px;
            padding: 20px;
            border: 5px lightpink solid;
            border-radius: 10px;
        }

        .box>.level {
            height: 30px;
            margin-top: 20px;
            display: flex;
            justify-content: space-between;
        }
        .box>.level>p {
            text-align: center;
            font-size: 20px;
            line-height: 30px;
            border-radius: 5px;
            width: 80px;
            color: white;
            background-color: #ccc;
        }

        .level>p:nth-child(1).active {
            background-color: rgb(238, 51, 51);

        }

        .level>p:nth-child(2).active {
            background-color: rgb(244, 219, 79);
        }

        .level>p:nth-child(3).active{
            background-color: rgb(22, 180, 51);
        }
        
    </style>
</head>

<body>
    <div class="box">
        密码：<input class="logPass" type="password">
        <div class="level">
            <p>弱</p>
            <p>中</p>
            <p>强</p>
        </div>
    </div>
    <script>
        let logPass = document.querySelector('.logPass')
        let level = document.querySelectorAll('.level>p')
        logPass.oninput = function (e) {
            let modes = 0;
            if (/\d/.test(logPass.value)) modes++;
            if (/[a-zA-Z]/.test(this.value)) modes++;
            if (/[!@#]/.test(e.target.value)) modes++;
            for (let i = 0; i < level.length; i++) {
                level[i].className = ''
                if (i < modes)
                    level[i].classList.add('active')
            }
        }
    </script>
</body>

</html>

js分享12-正则（小白必看）

正则

创建一个正则表达式

字面量创建

内置构造函数创建

正则表达式里面的符号

元字符

边界符

限定符

特殊元字符

重复元字符

标识符

正则的捕获

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

正则表达式的方法

test 用来检测字符串是否符合我们正则的标准

exec 把字符串中符合条件的内容捕获出来

字符串的方法

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

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

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

案例

登录信息正则判断

密码强度检测