目录
正则是用来处理（匹配）字符串的。
创建正则表达式的方法
1、通过字面量的方式
const re1 = /[abc]/
console.log('result: ', re1.test('hello'))2、通过构造函数方式
const re2 = new RegExp('[abc]', 'g')
console.log('result:', re2.test('abcd'))使用构造函数的传参说明：
new RegExp('正则表达式‘,'匹配模式')，并且两个参数都是字符串
匹配模式/修饰符
| 修饰符 | 含义 | 描述 |
|---|---|---|
| i | ignore - 不区分大小写 | 将匹配设置为不区分大小写，搜索时不区分大小写: A 和 a 没有区别。 |
| g | global - 全局匹配 | 查找所有的匹配项。 |
| m | multi line - 多行匹配 | 使边界字符 ^ 和 $ 匹配每一行的开头和结尾，记住是多行，而不是整个字符串的开头和结尾。 |
| s | 特殊字符圆点 . 中包含换行符 \n | 默认情况下的圆点 . 是 匹配除换行符 \n 之外的任何字符，加上 s 修饰符之后, . 中包含换行符 \n。 |
匹配方法
| 方法 | 描述 |
|---|---|
| exec | 一个在字符串中执行查找匹配的RegExp方法，它返回一个数组（未匹配到则返回 null）。 |
| test | 一个在字符串中测试是否匹配的RegExp方法，它返回 true 或 false。 |
| match | 一个在字符串中执行查找匹配的String方法，它返回一个数组，在未匹配到时会返回 null。 |
| matchAll | 一个在字符串中执行查找所有匹配的String方法，它返回一个迭代器（iterator）。 |
| search | 一个在字符串中测试匹配的String方法，它返回匹配到的位置索引，或者在失败时返回-1。 |
| replace | 一个在字符串中执行查找匹配的String方法，并且使用替换字符串替换掉匹配到的子字符串。 |
| split | 一个使用正则表达式或者一个固定字符串分隔一个字符串，并将分隔后的子字符串存储到数组中的 String 方法。 |
匹配语法
| 字符 | 描述 |
|---|---|
| \ | 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。 |
| ^ | 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。 |
| $ | 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。 |
| * | 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。 |
| + | 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。 |
| ? | 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。 |
| {n} | n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。 |
| {n,} | n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。 |
| {n,m} | m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。 |
| ? | 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。 |
| . | 匹配除换行符（\n、\r）之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用像"(.|\n)"的模式。 |
| x|y | 匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。 |
| [xyz] | 字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。 |
| [^xyz] | 负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。 |
| [a-z] | 字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。 |
| [^a-z] | 负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。 |
预定义字符类
| \b | 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 |
| \B | 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。 |
| \cx | 匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。 |
| \d | 匹配一个数字字符。等价于 [0-9]。 |
| \D | 匹配一个非数字字符。等价于 [^0-9]。 |
| \f | 匹配一个换页符。等价于 \x0c 和 \cL。 |
| \n | 匹配一个换行符。等价于 \x0a 和 \cJ。 |
| \r | 匹配一个回车符。等价于 \x0d 和 \cM。 |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 |
| \S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 |
| \t | 匹配一个制表符。等价于 \x09 和 \cI。 |
| \v | 匹配一个垂直制表符。等价于 \x0b 和 \cK。 |
| \w | 匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。 |
| \W | 匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。 |
贪婪模式
正则表达式默认是贪婪模式，即会尽可能多的匹配
console.log('1: ',/a{1,}/.exec('aaaaaa'))
console.log('2: ',/a{0,1}/.exec('aaaaaa'))
console.log('3: ',/a{2,5}/.exec('aaaaaa'))
由匹配结果可以看出，当匹配至少一个时，匹配的是多个；当匹配0个或者1个时匹配的是1个 ；当匹配2~5个之间时匹配的是5个，所以正则表达式默认是贪婪模式
非贪婪模式
在量词后面添加？就可以将贪婪模式修改为非贪婪模式
console.log('1: ',/a{1,}/.exec('aaaaaa'))
console.log('1加?号: ',/a{1,}?/.exec('aaaaaa'))
console.log('1-2: ',/a+/.exec('aaaaaa'))
console.log('1-2加?号: ',/a+?/.exec('aaaaaa'))
console.log('2: ',/a{0,1}/.exec('aaaaaa'))
console.log('2加?号: ',/a{0,1}?/.exec('aaaaaa'))
console.log('2-2: ',/a?/.exec('aaaaaa'))
console.log('2-2加?号: ',/a??/.exec('aaaaaa'))
console.log('3: ',/a{2,5}/.exec('aaaaaa'))
console.log('3加?号: ',/a{2,5}?/.exec('aaaaaa'))
console.log('3-2: ',/a*/.exec('aaaaaa'))
console.log('3-2加?号: ',/a*?/.exec('aaaaaa'))
由结果可以看出加了?号之后，匹配的就是最小的次数
分组与捕获
const re3 = /(ab)+/ //匹配一个或多个连续出现的字符串'ab'使用()可以进行分组
console.log('1:', /ab{2}/.exec('abb'))
console.log('2:', /ab{2}/.exec('abab'))
console.log('3: ',/(ab){2}/.exec('abb'))
console.log('4: ',/(ab){2}/.exec('abab'))
ab{2}匹配的是a后面跟两个b
(ab){2}匹配的是连续出现两个字符串'ab'
另外需要注意的是，使用（）之后还可以捕获到括号内部的内容
console.log(/(\w+)-(\w+)-(\w+)/.exec('abc-adb-efg-aaaaa'))
0：表示匹配的字符串
1：表示捕获的第一个()内的子表达式匹配的内容
2：表示捕获的第二个()内的子表大师匹配的内容
以此类推。
我们还可以获取到捕获的内容
1、通过索引过去
const reg = /(\w+)-(\w+)-(\w+)/
const str = 'abc-adb-efg-aaaaa'
const result = reg.exec(str)
console.log(result)
// 直接通过角标获取
console.log(result[0])
console.log(result[1])
console.log(result[2])
console.log(result[3])
// 通过RegExp的$获取
console.log('通过RegExp的$获取: ')
console.log(RegExp.$1)
console.log(RegExp.$2)
console.log(RegExp.$3)
// RegExp指的是上一次的正则表达式中捕获的内容
console.log('一个新的正则表达式: ')
console.log(/(\d{4})-(\d){1,2}-(\d){1,2}/.exec('2022-2-7'))
console.log(RegExp.$1)
console.log(RegExp.$2)
console.log(RegExp.$3)
反向引用
通过\1，\2等可以反向引用子表达式匹配的内容
const reg = /<(\w+)><(\w+)>(.+)<\/\2><\/\1>/
const str = "<div><strong>aaaa</strong></div>"
console.log('result:', reg.exec(str))
解释：
后半部分中<\/\2><\/\1>的解释：‘\/’是匹配</strong>中的'/'；\2表示反向引用匹配的第二个子表达式；'>'和'<'就是匹配'</strong>'或者‘</div>’中的'>'或者'<'；'\1'表示反向引用匹配的第一个子表达式。
由此可知：
\1指向RegExp.$1
\2指向RegExp.$2
\3指向RegExp.$3
\n指向RegExp.$n
由例子可以看出通过反向引用可以简化正则表达式。
非捕获
捕获就是正则表达式中用括号匹配的内容，保存到内存中，方便调用。js中每一个括号匹配的内容可以被RegExp对象捕获到，存储在RegExp的$1, $2, $3, $4, $5, $6, $7, $8, $9属性中，具体使用如上面的例子。注意：括号匹配项是无限的, 但是RegExp对象能捕获的只有九个。
那么非捕获就是不存储(不捕获)匹配的子表达式内容，可以在子表达式前面添加?:来实现。
console.log('result1: ',/(abc){2}/.exec('abcabc'))
console.log('result2: ',/(?:abc){2}/.exec('abcabc'))
由上面的介绍可知输出中1：代表的是匹配的第1个子表达式 ，n:表示匹配的第n个子表达式。
根据输出可以看出没有添加?:的正则表达式输出结果中有存储子表达式的内容，但是在添加?:(即非捕获)的正则表达式的输出结果中没有存储子表达式的内容。没有存储匹配的子表达式内容自然也就获取不到这些内容。
选择
正则表达式是从左向右进行匹配，一旦匹配上就不在继续匹配。
const reg = /12|34|56/
console.log('1: ',reg.exec('1'))
console.log('2: ',reg.exec('2'))
console.log('12: ',reg.exec('12'))
console.log('34: ',reg.exec('34'))
console.log('56: ',reg.exec('56'))
console.log('123456: ',reg.exec('123456'))
1和2没有匹配成功，说明“|”将表达式分成了左右两部分，就跟逻辑或一样，左右两部分是整体。
123456只匹配了12是因为匹配表达式的第一个分支12时已经匹配成功了，就不会再继续往后进行。
断言
使用正则解决一些常见问题
匹配0~255之间的数
匹配0~255之间的数不能直接简单使用/\d\d\d/、/[0-2]\d\d/等方法进行表示，要考虑个位、十位、百位的数值，分步骤进行：
1.先匹配0~9 [0-9]或者\d
2.匹配10~99 [1-9][0-9]或者[1-9]\d
3.匹配100~199 1[0-9][0-9]或者1\d\d
4.匹配200~249 2[0-4][0-9]或者2[0-4]\d
5.匹配250~255 25[0-5]
所以正则表达式为：
const reg = /25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d/测试：
console.log('0: ', reg.exec('0'))
console.log('9: ', reg.exec('9'))
console.log('10: ', reg.exec('10'))
console.log('99: ', reg.exec('99'))
console.log('100: ', reg.exec('100'))
console.log('199: ', reg.exec('199'))
console.log('200: ', reg.exec('200'))
console.log('250: ', reg.exec('250'))
console.log('255: ', reg.exec('255'))结果：
7577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
