正则表达式基础学习之个人学习总结

简介目录

正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等；
详细的教程可以参考完整讲解----菜鸟教程

普通字符

除了特殊字符以外的字符都是普通字符。比如 中文；
也就是 a-z 、A-Z 、 0-9、所有标点符号、空格，中文等；
常见的普通字符正则表达式：
案例：匹配一段字符里面的‘张三’

let reg = new RegExp(/张三/)
'张三居然还不会写正则表达式'.match(reg)
=> ["张三", index: 0, input: "张三居然还不会写正则表达式", groups: undefined]

特殊字符（元字符）

以下涉及到的名词解释：

元字符
元字符表示正则表达式功能的最小单位，如 * ^ $ \d 等等；
匹配元字符
要匹配元字符的时候，需要使用 转义符 \ 对元字符转义。例如：要匹配 . ，使用 '\. ’

基本元字符

包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。

1. .
   解释：匹配除换行符（\n、\r）之外的任何单个字符，相等于 [^\n\r]。要匹配 . ，使用 '\. '；
   案例:常用作匹配任意字符的场景

let reg = new RegExp(/./g)
// 匹配任意字符
'abcd'.match(reg)
// ["a", "b", "c", "d"]

2. |
   解释： 指明两项之间的一个选择。类似于逻辑或。
   案例:

let reg = new RegExp(/a|b/g)
// 匹配a或者b
'abcd'.match(reg)
// ["a", "b"]

3. []
   解释：
   [] 符号内部非内容被称作字符集合 ，也可做字符范围类表达；匹配 []中的所有字符。例如 [abcd] 匹配字符串 “hello word” 中所有的 a b c d 字母。

 注意：
 大多数特殊字符在中括号表达式内出现时失去它们的意义

案列：

let reg = new RegExp(/[ab]/g)
// 匹配a，b字符
'abcd'.match(reg)
// ["a", "b"]

• [^]
  解释：和 [] 相反；匹配 除了[…] 中的所有字符，例如 [^abcd] 匹配字符串 “hello word” 中除 a b c d 字母的所有字母。
  案例：

let reg = new RegExp(/[^ab]/g)
// 匹配 除a，b以外的字符
'abcd'.match(reg)
// ["c", "d"]

• -
  解释：定义一个区间；
  如： [A-Z] 匹配所有大写字母，[a-z] 表示所有小写字母。
  常见的表达式： [a-z],[0-9]， [A-Z] 等。
  案例：

let reg = new RegExp(/[a-z]/g)
// 匹配 a-z之间的字符
'abcd'.match(reg)
//  ["a", "b", "c", "d"]等同于 /[.]/g

• \ 对下一个字符进行转义 如 ( .）

特殊元字符

特殊字符细数一下，还是有点多的，所以呢，就只对部分使用场景比较多的进行介绍了。其他的特殊字符可以去全部元字符介绍详细阅读一下哈。

• \d 匹配任意数字字符。匹配一个数字字符。等价于 [0-9]
• \D \d 的反义。匹配一个非数字字符。等价于 [^0-9]。
• \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
• \S \s 反义 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]
• \w 匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。常用于密码的字符匹配校验
• \W \w 的反义。匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。

位置元字符

定位符用来描述字符串或单词的边界，^ 和 $ 分别指字符串的开始与结束。

• ^ 匹配输入字符串的开始位置
  除非在[]方括号表达式中使用，当该符号在[]中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^。
• $ 匹配输入字符串的结尾位置

数量限定元字符

• * 号【*前面的字符 】【可以不出现】，也可以出现一次或者多次（0次、或1次、或多次）。 匹配的字符出现次数 >=0

实例：o出现的次数 >0
 let reg = new RegExp(/hello*b/)
'hello1111'.match(reg)
=> null

'hellb'.match(reg)
=> ["hellb"]

'hellob'.match(reg)
=> ["hellob"]

等价于 {0,}

• + 号代表【前面的字符】必须至少出现一次（1次或多次）。 匹配的字符出现次数 >=1

实例： o出现的次数 >=1
 let reg = new RegExp(/hello+b/)
'hello1111'.match(reg)
=> null

'hellb'.match(reg)
=> null

'hellob'.match(reg)
=> ["hellob", index: 0, input: "hellob", groups: undefined]

等价于 {1,}

• ? 问号代表【前面的字符 】最多只可以出现一次（0次、或1次） 匹配的字符出现次数 <=1

实例：o出现的次数 <=1
 let reg = new RegExp(/hello+b/)
'hello1111'.match(reg)
=> null

'hellob'.match(reg)
=> ["hellob"]

'hellb'.match(reg)
=> ["hellb"]

'helloob'.match(reg_3)
=> null

? 等价于 {0,1}
！！！！注意：
当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的

• {n} n 是一个非负整数。匹配 【前面的表达式】确定的 n 次。 匹配的字符出现次数 =n
  实例：/o{2}/ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o
• {n,} n 是一个非负整数。 【前面的表达式】至少匹配的 n 次。 匹配的字符出现次数 >=n
  实例：/o{2,}/
  ‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’
• {n.m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。匹配 【前面的表达式】确定的 n-m 次。n<= 匹配的字符出现次数 <=m
  实例：/o{1，2}/ 能匹配 “Bob” 中的 ‘o’，也能匹配 “food” 中的两个 o
  注意： 请注意在逗号和两个数之间不能有空格
  贪婪模式： 尽可能多的匹配
  * 和 + ,{n,}限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个 ? 就可以实现非贪婪或最小匹配。

回溯引用和前后查找

主要有?=,?<=,?!,?<! ；因为概念理解起来比较绕。所以就用案例说明他们的区别。案例在菜鸟教程上可查阅。菜鸟教程案例入口

• 零宽正向先行断言 (？=)
  ？= exp1(?=exp2)：查找 exp2 前面的 exp1。
  案例：hello(?=[\d+]) 匹配数字前面的 hello；匹配后面是数字的 hello
  
• 零宽负向先行断言 (?<=)
  (?<=exp2)exp1：查找 exp2 后面的 exp1。
  案例：(?<=[\d+])hello 匹配数字后面是的hello；也是匹配前面是数字的hello
  
  -零宽正向先后行断言 (?!)
  exp1(?!exp2)：查找后面不是 exp2 的 exp1。
  案例：hello(?![\d+]) 匹配后面不是数字的hello
  
• 零宽负向后行断言 (?<!)
  (?<!exp2)exp1：查找前面不是 exp2 的 exp1。
  案例： (?<![\d+])hello 匹配前面不是数字的hello
  
  注意： ES2018才支持 ?!,?<!特性。

String 涉及到正则表达式的方法

String.prototype.match()

检索返回一个字符串匹配正则表达式子的结果。
唯一参数：
一个正则表达式对象，如果传入一个非正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp 。如果你没有给出任何参数并直接使用match() 方法 ，你将会得到一 个包含空字符串的 Array ：[""] 。
返回值：返回一个数组。

如果正则表达式不包含g标志，str.match() 将返回与 RegExp.exec(). 相同的结果。
match() 和 exec() 的区别 ：
如果正则表达式使用g标志，则将返回与完整正则表达式匹配的所有结果，但不会返回捕获组。

String.prototype.replace()

字符串的替换方法，替换为指定字符。第一个参数是一个RegExp 对象或者其字面量。该正则所匹配的内容会被第二个参数的返回值替换掉。
返回一个部分或全部匹配由替代模式所取代的新的字符串。
注意：
该方法并不改变调用它的字符串本身，而只是返回一个新的替换后的字符串。
在进行全局的搜索替换时，正则表达式需包含 g 标志。

String.prototype.search()

执行正则表达式和 String 对象之间的一个搜索匹配。
参数：
一个正则表达式（regular expression）对象
如果传入一个非正则表达式对象 regexp，则会使用 new RegExp(regexp) 隐式地将其转换为正则表达式对象
返回值：
如果匹配成功，则 search() 返回正则表达式在字符串中首次匹配项的索引;否则，返回 -1

String.prototype.split()

方法使用指定的分隔符字符串将一个String对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置。
参数可以是一个字符串或是正则表达式。
返回值：
返回源字符串以分隔符出现位置分隔而成的一个 Array

RegExp 原型方法

RegExp.prototype.exec()

在一个指定字符串中执行一个搜索匹配。返回一个结果数组或 null。
返回字符串的匹配成功的捕获组，相比str.match()的返回结果，exec 返回结果更详细。
返回结果捕获组 的附加属性 ：

• groups: 一个捕获组数组 或 undefined（如果没有定义命名捕获组）。
• index: 匹配的结果的开始位置
• input: 搜索的字符串.

RegExp.prototype.test()

执行一个检索，用来查看正则表达式与指定的字符串是否匹配。返回 true 或 false。

当你想要知道一个正则表达式是否与指定的字符串匹配时，就可以使用 test()（类似于 String.prototype.search() 方法），差别在于test返回一个布尔值，而 search 返回索引（如果找到）或者-1（如果没找到）

最后

以上就是正则表达式全部内容。很多同志都是看见正则表达式就绕道走的，在实际的开发中正则表达式使用场景不是很多。也是一项必备技能。建议大家收藏学习哦