正则表达式正则表达式学习与总结，从零到一，小白入手，变成正则大神，开始学习吧~持续更新，点赞支持，谢谢！！！！

正则表达式由两部分组成

元字符

/*常用的元字符*/
// 1、量词元字符：设置出现的次数
*  零到多次
+ 一到多次
? 零次或一次
{n} 出现n次
{n,} 出现n到多次
{n,m} 出现n到m次

// 2、特殊元字符：单个或者组合在一起代表特殊的含义
\ 转义字符（普通->特殊->普通）
. 除\n(换行符)以外的任意字符
^ 以哪一个元字符作为开始
$ 以哪一个元字符作为结束
\n 换行符
\b 匹配一个单词的边界
\d 0-9之间的一个数字
\D 非0-9之间的一个数字
\w 数字、字母、下划线中的任意一个字符
\s 一个空白字符(包含空格、制表符、换页符等)
\t 一个制表符（一个TAB键：四个空格）
x | y x或者y中的一个字符
[xyz] x或者y或者z中的一个字符
[^xy] 除了x和y以外的任意字符
[a-z] 指定a-z这个范围中的任意字符 [0-9a-zA-Z_]===\w
[^a-z] 指定非a-z这个范围中的任意字符
() 正则中的分组符号
(?:) 只匹配不捕获
(?=) 正向预查
(?!) 负向预查

//3、 普通元字符：代表本身含义的
/abc/ 此正则匹配的就是 abc

修饰符

  i => ignoreCase 忽略单词大小写匹配
  m => multiline 多行匹配
  g => global 全局匹配

元字符详细解析

let reg = /^\d/;
console.log(reg.test("2021ll")) //true
console.log(reg.test('ll'))  //false

let reg = /\d$/;
console.log(reg.test("ll2021")) //true
console.log(reg.test('ll'))  //false

let reg = /\d/;
console.log(reg.test("ll2021hh")) //true
console.log(reg.test('ll'))  //false

let reg = /^\d$/;
console.log(reg.test("123456")) //true
console.log(reg.test('123gg456'))  //false

// 验证手机号码（11位，第一个数字是1即可）
let reg = /^1\d{10}$/

// .不是小数点，是除\n以外的任意字符
let reg = /^2.3$/
console.log(reg.test("2.3")) //true
console.log(reg.test("2@3"))// true
console.log(reg.test("23"))//false

let reg1 = /^2\.3$/
console.log(reg1.test("2.3")) //true
console.log(reg1.test("2@3"))// false
console.log(reg1.test("23"))//false

let reg2 = /^\\d$/
console.log(reg2.test("\\d")) //true
console.log(reg2.test("\d")) //false

let reg = /^18|29$/ //会存在很乱的优先级问题
console.log(reg.test("18"))//true
console.log(reg.test("29"))//true
console.log(reg.test("129"))//true
console.log(reg.test("189"))//true
console.log(reg.test("1829"))//true
console.log(reg.test("829"))//true
console.log(reg.test("182"))//true


let reg1 = /^(18|29)$/
console.log(reg1.test("18"))//true
console.log(reg1.test("29"))//true
console.log(reg1.test("129"))//false
console.log(reg1.test("189"))//false
console.log(reg1.test("1829"))//false
console.log(reg1.test("829"))//false
console.log(reg1.test("182"))//false

[]

// 1.中括号中出现的字符一般都代表本身的含义
let reg = /^[@+]+$/
console.log(reg.test("@@"))//true
console.log(reg.test("@+"))//true
console.log(reg.test("++"))//true

let reg1 = /^[@+]$/
console.log(reg1.test("@"))//true
console.log(reg1.test("+"))//true
console.log(reg1.test("++"))//false

 let reg2 = /^[\d]$/ //特殊情况，\d在中括号中还是0-9
console.log(reg2.test("d"))//false
console.log(reg2.test("\\"))//false
console.log(reg2.test("9"))//true


//2.中括号中不存在多位数
 let reg3 = /^[18]$/
console.log(reg3.test("1"))//true
console.log(reg3.test("8"))//true
console.log(reg3.test("18"))//false

let reg3 = /^[10-29]$/ //1或者0-2或者9
console.log(reg3.test("1"))//true
console.log(reg3.test("9"))//true
console.log(reg3.test("18"))//false

常用的正则表达式 1.验证是否为有效数字

/*
 * 1.可能出现+-号，也可能不出现
 * 2.一位0-9都可以，多为首位不能是0
 * 3.小数部分可能有可能没有，一旦有后面必须有小数点+数字
 */
let reg = /^[+-]?(\d|([1-9]\d))(\.\d+)?$/

2.验证密码

/*
 *数字字母下划线
 *6-16位
 */
let reg = /^\w{6,16}$/

3.验证真实姓名

/*
 * 1.汉字/^[\u4E00-\u9FA5]$/
 * 2.名字长度2-10位
 * 3.可能是译名 ·汉字
 */
let reg = /^[\u4E00-\u9FA5]{2,10}(·[\u4E00-\u9FA5]{2,10}){0,2}$/

4.验证邮箱

/*
 * 1.开头是数字字母下划线（1到多位）
 * 2.后面跟着 -数字字母下划线 或者 .数字字母下划线，整体零到多次((-\w+)|(\.\w+))*
 * 3.后面跟着@
 * 4.后面跟着数字字母一到多位 @[A-Za-z0-9]+
 * 5.((\.|-)[A-Za-z0-9]+)*匹配（.com.cn的.com）
 * 6.\.[A-Za-z0-9]+匹配（.com/.cn/.org/.edu/.net）
 */
let reg = /^\w+((-\w+)|(\.\w+))*@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/

5.身份证号码

/*
 *1.18位
 *身份证前六位：省市县
 *中间八位：年月日
 *最后一位X或者数字
 *倒数第二位： 偶数：女 奇数：男
 *其余的是经过算法算出来的
 */
let reg = /^(\d{6})(\d{4})(\d{2})(\d{2})\d{2}(\d)(\d|X)$/
//["130828199012040617", "130828", "1990", "12", "04", "1", "7", index: 0, input: "130828199012040617", groups: undefined]
reg.exec("130828199012040617")

两种创建正则表达式的区别

//方式一：
let reg = /\d+/g;
//方式二：
let reg = new RegExp("\\d+","g");

// 正则表达式中的部分内容是变量存储的值
let type = 'zll'
//方式一：
// 无法实现
//方式二：
let reg = new RegExp("^@"+type+"@$");
reg.test("@zll@") //true

正则捕获

实现正则捕获的方法

正则的RegExp.prototype上的方法
- exec
- test
- lastIndex属性当前正则下一次匹配的其实索引位置
字符串String.prototype上支持正则表达式处理的方法
- replace
- match
- splite

/*
 * 实现正则捕获的前提是：当前正则要和字符串匹配，如果不匹配捕获的结果是null
 * 每执行一次exec,只能捕获一个符合正则规则的，但是默认情况下，我们执行一百遍，获取的结果永远都是第一个匹配到的，其余的捕获不到，这就是正则捕获的懒惰性
 * 懒惰性捕获的原因：第一次匹配捕获完成，lastIndex没有改变，所以下一次exec依然是从字符串最开始找，找到的永远是第一个匹配到的
 * 解决捕获的懒惰性：设置全局匹配修饰符g，第一次匹配完成后，lastIndex会自己修改
 */
let str = "zll2021wzz2022"
let reg = /^\d+$/
console.log(reg.test(str)) //false
console.log(reg.exec(str)) //null

let reg1 = /\d+/g
console.log(reg1.exec(str))//["2021", index: 3, input: "zll2021wzz2022", groups: undefined]
console.log(reg1.lastIndex)//7
console.log(reg1.exec(str))//["2022", index: 10, input: "zll2021wzz2022", groups: undefined]
console.log(reg1.lastIndex)//14
console.log(reg1.exec(str))//null
console.log(reg1.lastIndex)//0

// 编写一个方法execAll,执行一次可以把所有匹配的结果捕获到（前提正则一定要设置全局全局修饰符g）
// 相当于字符串的match方法
function execAll(str="") {
    if (!this.global) return this.exec(str)
    let ary = [];
    let res = this.exec(str)
    while(res) {
        ary.push(res[0]);
        res = this.exec(str);
    }
    return ary.length ? ary : null;
}
RegExp.prototype.execAll = execAll

// 一次执行可以补货到所有匹配的数据，前提也是设置g
console.log("zll2021wzz2022".match(/\d+/g)) //["2021", "2022"]

正则的分组捕获

/*
 * 第一项：大正则匹配的结果
 * 其余项：每一个小分组单独匹配捕获的结果
 * 如果设置了分组（改变优先级），但是捕获的时候不需要单独捕获，可以基于?:来处理
 */
let reg = /^(\d{6})(\d{4})(\d{2})(\d{2})\d{2}(\d)(?:\d|X)$/
// ["130828199012040617", "130828", "1990", "12", "04", "1", "7", index: 0, input: "130828199012040617", groups: undefined]
// ["130828199012040617", "130828", "1990", "12", "04", "1", index: 0, input: "130828199012040617", groups: undefined]
reg.exec("130828199012040617")

/*
 * 既要捕获到{数字},也要单独的把数字获取到，例如：第一次找到{0}和0
 */
 
// 不设置g值匹配一次，exec和match获取到的结果一致,但只匹配到{0}和0
// ["{0}", "0", index: 0, input: "{0}年{1}月{2}日", groups: undefined]
let str = "{0}年{1}月{2}日"
let reg = /\{(\d+)\}/
console.log(reg.exec(str))
console.log(str.match(reg))

// 设置g，match不能单独匹配到数字
let str = "{0}年{1}月{2}日"
let reg = /\{(\d+)\}/g
console.log(str.match(reg)) //["{0}", "{1}", "{2}"]

function queryBigSmall(reg, str) {
    let aryBig = [];
    let arySmall = [];
    let res = reg.exec(str);
    while(res) {
        let [big, small] = res;
        aryBig.push(big);
        arySmall.push(small);
        res = reg.exec(str);
    }
    return [...aryBig, ...arySmall]
}
queryBigSmall(/\{(\d+)\}/g, '{1996}年{02}月{10}日')

正则捕获的贪婪性

默认情况下，正则捕获的时候，是按照当前正则所匹配的最长结果来获取的

let str = "2019@2020@2021"
let reg = /\d+/g;
console.log(str.match(reg)); //["2019", "2020", "2021"]
// 取消贪婪性：在两次元字符后面设置"?"
console.log(str.match(/\d+?/g)); //["2", "0", "1", "9", "2", "0", "2", "0", "2", "0", "2", "1"]

?号的总结

问号左边是非量词元字符：本身代表量词元字符，出现零到一次
问号左边是量词元字符：取消捕获时候的贪婪性
(?:) 只匹配不捕获
(?=) 正向预查
(?!) 负向预查

分组引用

分组引用就是通过"\数字"代表让其和对应分组出现一模一样的内容

let reg = /^[a-zA-Z]([a-zA-Z])\1[a-zA-Z]$/
console.log(reg.test('book')) // true
console.log(reg.test('foot')) // true
console.log(reg.test('moon')) // true
console.log(reg.test('deek')) // true
console.log(reg.test('week')) // true