1.正则表达式的创建
正则表达式创建
修饰符
g 全局查找
i 不区分大小写
/正则表达式内容/修饰符
var reg=/a/g
var reg=new RegExp(正则表达式内容,修饰符)
var reg=new RegExp("a","g");
创建正则表达式
+ 方式1: 字面量方式创建
=> const reg = /abcd/
+ 方式2: 内置构造函数方式创建
=> const reg = new RegExp('abcd')
2.两种正则创建方式的区别
还账 - 两种创建正则表达式的区别
1. 语法方式
=> 字面量: const reg = /元字符/修饰符
=> 内置构造函数: const reg = new RegExp('元字符', '修饰符')
2. 拼接变量
=> 字面量: 不能接受变量拼接
=> 内置构造函数: 可以接受变量拼接
3. 书写基本元字符
=> 字面量: 直接书写基本元字符
=> 内置构造函数: 书写 \\s \\d \\w ...
3.正则表达式针对字符串处理
正则方法
test(); 是否test中的字符满足正则表达式
exec(); 查找到满足的内容，并且返回这个内容对应的下标位置
字符串方法
match(); 高频使用方法 查找满足正则的字符内容，并且返回一个由满足内容组成的数组
search(); 在字符串中查找满足正则内容的字符，返回下标
replace();高频使用方法 替换方法
split(); 切割，使用正则切割
4.元字符
1. . 元字符 通配符，代表任意一个字符
console.log("abac".match(/a./)); //['ab', index: 0, input: 'abac', groups: undefined]
console.log("abac".match(/a./g)); //['ab', 'ac']
console.log("abcade".match(/a../g)) // ['abc', 'ade']
console.log("abcadcadd".match(/a.c/g)) //['abc', 'adc']
2. \. 转义 将通配符变为字符.
console.log("abca.cadd".match(/a\.c/g)) // ['a.c']
console.log("a\\b".match(/a\\/)[0]) // a\
3. [] 元字符 []内字符可以代表任何一个字符，或者的作用,可以在[]中选择任意一个字符
console.log("abcaccadc".match(/a.c/g)) //['abc', 'acc', 'adc']
console.log("abcaccadc".match(/a[bc]c/g)) //['abc', 'acc']
4. /[ab][cd]/g ac ad bc bd
在[]中. 不是通配符，而是字符.
console.log("aba.ad".match(/a[b.]/g)); //['ab', 'a.']
console.log("abca.cadd".match(/a[.]c/g)) //['a.c']
5. [^] 不要某个字符
/[1356790]/
/[^248]/ 如果^在[]里面的第一位，这个[]的内容取反 [1356790a-zA-Z.其他各种符号]
console.log("abcadcaec".match(/a[^d]c/g))
6. /[^\^]/ 匹配非^的所有字符
console.log("a^bacb".match(/a[^\^]b/g));
如果 ^不是在[]的第一位，则表示单一的^字符
[a^c] 满足a或者^或者c
var str="abacadae";
str=str.replace(/[bd]/g,"z");
str=str.replace(/[^cd]/g,"z");
str.replace(正则,function(被查找到元素,索引值,原字符串){
return 返回内容 替换被查找的元素
})
7. /[1-3]/ [123]
/[a-z]/ [abcdefghijklmnopqrstuvwxyz]
/[A-Z]/ [A....Z]
/[0-9]/ [0123456789]
/3[0-3]/ 30 31 32 33
/[1-31]/ [1-3 1] [123];
/[11122]/ [12]
5.元字符-基本元字符
正则的组成
+ 正则由各种各样的符号组成
+ 元字符: 正则要求的组成部分
=> 普通文本
=> 一些带有特殊意义的符号
+ 标识符(修饰符): 书写在正则外面用来修饰整个正则表达式的
元字符 - 基本元字符
1. \d 一位 数字(0-9) 内容
2. \D 一位 非数字 内容
3. \s 一位 空白内容(空格/制表符) 内容
4. \S 一位 非空白 内容
5. \w 一位 数字(0-9)字母(a-zA-Z)下划线(_) 任意内容都行
6. \W 一位 非数字字母下划线 任意内容
7. \n 一位 换行符
8. . 一位 非换行 以外的任意字符
9. \ 转义符, 作用: 把有意义的符号转换成没有意义的文本, 把没有意义的文本转换成有意义的符号
=> 注意: \ 转义的是紧挨着他 **后面** 的 **一个** 内容
6.元字符-边界符
元字符 - 边界符
1. ^
=> 表示字符串开头
-> 注意: 当你开启换行匹配的时候, 表示每一行的开头
2. $
=> 表示字符串结尾
-> 注意: 当你开启换行匹配的时候, 表示每一行的结尾
+ 注意:
=> 当 ^ 和 $ 一起使用的时候
=> 表示从开头到结尾
// 小例子
// /^[1-9]$|^[12]\d$|^3[01]$/.test('31') //判断1-31 // [12]\d意思 1(0-9) 2(0-9)
// [1-9]\d表示10-99 1\d{2}表示100-199 2[0-4]\d代表200-249
// /^\d$|^[1-9]\d$|^1\d{2}$|^2[0-4]\d$|^25[0-5]$/.test("255") //0-255
// 0.0.0.0-255.255.255.255 ip地址验证 \. 转义 . {3}重复3次
// /^(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])(\.(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])){3}$/.test("0.0.0.0")
7.元字符-限定符
元字符 - 限定符
+ 意义: 修饰其余符号出现次数
+ 注意: 一个限定符只能修饰该限定符前面的 **一个内容**
1. * 表示 0 ~ 多次
2. + 表示 1 ~ 多次
3. ? 表示 0 ~ 1 次
4. {n} 表示指定 n 次
5. {n,} 表示至少 n 次, n ~ 多次
=> {0,} 等价于 *
=> {1,} 等价于 +
6. {n,m} 表示 n ~ m 次
=> {0,1} 等价于 ?
例:
/a{1,}/ 最大值不限 1-无穷次重复
/a{0,}/ 最大值不限 0-无穷次重复
/a{0,1}/ /a?/ /ab?c/ "ac" "abc"
/a{0,}/ /a*/ 可以没有，也可以重复任意多次
/a{1,}/ /a+/ 至少1次以上
/a{min,max}/ min最小重复次数 max最大重复次数
7.1常见小组合
1. \D+\d a1 ab2 abva3 0(不符合) 第一位不能是数字 表示在字符串中含有数值，但是不是第一位
2. .*[a-z] !a 3a a aa %&a 在字符串至少有一个小写字母，位置任意
3. .*[A-Z] !A 3A A aA %&A 在字符串至少有一个大写字母，位置任意
4. [a-zA-Z0-9]{8,16} a-zA-Z0-9 重复至少8，最多16
8.元字符-特殊符号
或
=> || 逻辑或
=> | 按位或(位或)
=> 在正则 | 占位或
元字符 - 特殊符号
1. ()
=> 含义1: 一个整体
=> 含义2: 单独捕获(欠着)
2. | 或(占位或)
=> 含义: 或者的意思
=> 或的边界: 其他的或 / () 的边界 / 正则的边界
3. []
=> 表示书写在 [] 内的任意一个都行
=> 注意: 一个 [] 只占一位字符位置
4. [^] 非
=> 表示书写在 [^] 内的任意一个都不行
=> 注意: 一个 [^] 只占一位字符位置
5. - 至(到)
=> 和 [] 或者 [^] 连用
=> 注意: 必须要 unicode 编码连着的才可以
=> 常用:
-> 0-9 表示数字
-> a-z 表示小写字母
-> A-Z 表示大写字母
-> \u4e00-\u9fa5 表示所有中文汉字
=> 等价:
-> [0-9] 等价于 \d
-> [^0-9] 等价于 \D
-> [a-zA-Z0-9_] 等价于 \w
-> [^a-zA-Z0-9_] 等价于 \W
9.标识符
标识符
+ 书写在正则的外面
=> 用来修饰整个正则表达式的
1. i
=> 忽略大小写不计
2. g
-> 全局标识符 g 的意思
+ 第二次捕获从第一次的结尾位置开始向后检索
+ 直到捕获不到返回 null
+ 再下一次捕获的时候又从 [0] 开始检索
3. y
-> 粘性全局标识符 y 的意思
+ 第二次捕获从第一次的结尾位置开始向后检索
+ 但是要求第二个满足条件的片段必须和前一个满足条件的片段紧挨着
4. m
=> 换行匹配
=> 默认情况下
-> ^ 表示的是字符串开头
-> $ 表示的是字符串结尾
=> 一旦你写了标识符 m 以后
-> ^ 表示每一行的开头
-> $ 表示每一行的结尾
5. s
=> 加换行
=> 本身正则内的 . 表示的是 非换行 的任意字符
=> 当你加了标识符 s 的时候, . 表示包括换行在内的任意字符
=> /./s 表示通配
6. -> () 的作用
+ 返回值除了 [0] 是捕获出来的字符串片段
+ 从 [1] 开始是每一个 () 内单独的内容
特殊符号
+ 匹配但不捕获
+ 我们的 () 有两个含义
=> 含义1: 一个整体
=> 含义2: 单独捕获
+ 当你只需要 () 的 含义1 不需要 含义2 的时候
=> 可以书写 ?: 这个符号连接在 小括号的开始括号位置
=> 书写 (?:内容)
10.正则的两大特性
正则的两大特性
1. 懒惰性
+ 当你使用 exec 去捕获内容的时候
+ 默认每一次都是从 [0] 开始检索
+ 解决: 在书写正则表达式的时候书写全局标识符 g
2. 贪婪性
+ 当你使用限定符的时候, 会按照尽量多的可能去捕获内容
+ 私人: 正则表达式默认贪婪成性
=> 当你使用限定符的时候 : 能拿多少拿多少
-> *
-> +
-> ?
-> {n,}
-> {n,m}
=> 当你使用非贪婪限定符的时候 : 能拿多少拿多少
-> 解决正则贪婪性的问题
-> *?
-> +?
-> ??
-> {n,}?
-> {n,m}?
+ 解释:
=> {3,5} 在捕获的时候, 能拿 5 个就不拿 3 个
=> {3,5}? 在捕获的时候, 能拿 3 个就不拿 5 个
例:
/a{1,5}/ 最小1次 最大5次 超过5次匹配最大5次
1.贪婪匹配 匹配满足最大的值
console.log("aaaaaaa".match(/a{1,5}/));
/a{0,5}/ 0就是没有 5就是重复5次
console.log("ac".match(/ab{0,2}c/g));
console.log("abc".match(/ab{0,2}c/g));
console.log("abbc".match(/ab{0,2}c/g));
console.log("abbbc".match(/ab{0,2}c/g));
console.log("abc".match(/ab{0,1}c/g));
console.log("colour".match(/colou{0,1}r/g));
console.log("color".match(/colou{0,1}r/g));
非贪婪匹配 在贪婪匹配后面使用? 就是非贪婪匹配
非贪婪匹配有两个条件
1、必须在?后面有某个结束限制 找到第一个结束限制后停止，不继续向后查找
2、非贪婪匹配中使用. \w 等等可能包含了结束限制内容，才会使用非贪婪匹配
11.元字符-重复元字符
元字符 - 重复元字符
+ \数字
=> \1 \2 \3 \4 \5 \6 \7 \8 \9
+ 意义: 重复第 x 个小括号内容(一模一样)
+ 注意: 数字的意义是 **第几个小括号**
例:
12.预查
预查
正则内的预查分成两种
+ 正向预查
=> 正向肯定预查 (?=)
=> 正向否定预查 (?!)
+ 负向预查
=> 负向肯定预查 (?<=)
=> 负向否定预查 (?<!)
1.后瞻肯定断言
console.log("abacad".replace(/a(?=c)/g,"0"))
console.log("abacad".replace(/^(?=c)/g,"0"))
console.log("cabacad".replace(/^(?=c)/g,"0"))
2.后瞻否定断言
console.log("abacad".replace(/a(?!c)/g,"0"));
3.前瞻肯定断言
console.log("abcbeb".replace(/(?<=c)b/g,"0"));
4.前瞻否定断言
console.log("abcbeb".replace(/(?<!c)b/g,"0"));
13.群组可以按相同字符归类
1.(n)\1是固定方式 n重复1次
2.(n)\1+ n重复1次以上
3.(n)\1* n重复0次以上
console.log("aaaabbbcccccccc".match(/([a-z])\1/g)) //['aa', 'aa', 'bb', 'cc', 'cc', 'cc', 'cc']
console.log("aaaabbbcccccccc".match(/([a-z])\1+/g)) //['aaaa', 'bbb', 'cccccccc']
console.log("aaaabbbdcccccccc".match(/([a-z])\1*/g)) //['aaaa', 'bbb', 'd', 'cccccccc']
console.log("aaaabbbdcccaaaccccc".match(/([a-z])\1*/g)) //['aaaa', 'bbb', 'd', 'ccc', 'aaa', 'ccccc']
