正则表达式基本用法

时间 2020-01-13

原文原文链接

基本语法

单个字符：数字，数字或字母，非数字和字母，空格和tab，非空格和tab，任何字符javascript

数字： \d  等价于 [0-9]
数字或字母(下划线)： \w  等价于 [A-Za-z0-9_]
非数字和字母(下划线)：\W 等价于 [^A-Za-z0-9_]
空格和tab：\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [\f\n\r\t\v]
非空格和tab：\S  匹配任何非空白字符。等价于 [^\f\n\r\t\v]
任何字符： 点号 . ，匹配除换行符\n, \r以外的任何字符

数量：0个或1个，1个或更多个，在一个范围内，匹配出现n次html

0或屡次： 星号 * ,等价于{0,}
0或者1个： 问号 ? ,匹配前面的子表达式0或1次，等价于 {0,1}
1或者更多：加号 + ,匹配 前面的子表达式1次或屡次，等价于 {1,}
出现n次： {n}
出现至少n次： {n,}
最少n次，最多m次： {n,m}

位置：行开头，行结尾，单词的结界java

行开头： 上尖角符号 ^ 
行结尾： 美圆符号 $
单词的结界： \b，匹配的是单词和空格间的位置

字符分类（中括号符号[]）

基本用法：
中括号 []表示或逻辑，好比[abc]表示a或者b或者c,在方括号里，特殊字符是不须要转义的正则表达式
特殊语法：-,^和.数组
- -是第一个字符时，表示它自己，放在中间是表示区间。好比[a-z]表示从a到z。
- ^放在外面表示一行的开头，^放在[]里面，表示取反。好比 [^ab]，表示不是a且不是b。点符号.在[]里不须要转义，就是点号自己；在外面直接使用表示匹配任何字符；在外面表示点号自己，须要转义 \.
()和[]同样，也能够用于或语法，好比，(a|b)的意思是a或者b

分组捕获

匹配到的组。
好比/\d{3}-(\d{3})-(\d{4})/ 匹配 “212-555-1234” 时。markdown

Group0是"212-555-1234"函数

Group1是第一个括号555网站

Group2是第二个括号1234google
选择分组。
方法一：使用$符，$1表示555，$2表示1234 spa

方法二：使用反斜杠\，\1表示555，\2表示1234
美圆符$和反斜杠\的区别：

$ 是在替换的时候进行标志或选择。可是对于表达式自己，用\ 。这句话的意思是，对于正则表达式自己，用反斜杠\加数字来匹配子项。例如：匹配字符串语句中重复出现的单词。
```
reg = /\b(\w+)\s\1\b/
let str = "This is is some text. How old the the dog dog is?"
// 匹配到的结果是： is is、 the the 和 dog dog
```

JavaScript的string中的应用

reg.test()：正则表达式自身的test方法，是否包含，包含返回true，不包含返回false reg.test(str)
```
let reg = /\d{3}/
let str = "abc123"
reg.test(str) // true
```

str.match(reg)：正则表达式，返回的结果与两个因素相关：g修饰符；是否有分组。

无g修饰符，且无分组时，返回的是第一个匹配到的字符串

let reg = /\w+/
let str = "joy, I know something about you."
let value = str.match(reg)
// ["joy", index: 0, input: "joy, I know something about you.", groups: undefined]

有g修饰符，无分组时，返回全部匹配到的字符串，不含分组

let reg = /\w+/g
let str = "joy, I know something about you."
let value = str.match(reg)
// ["joy", "I", "know", "something", "about", "you"]

无g修饰符，有分组时，返回的是第一个匹配到的字符串和它的分组

let reg = /(\d{3})[-.](\d{4})/
let str = "These are two Phone Numbers 212-2345 and 211-3234"
let value = str.match(reg)
// ["212-2345", "212", "2345", index: 28, input: "These are two Phone Numbers 212-2345 and 211-32344", groups: undefined]

有g修饰符，有分组时，返回的是匹配全部字符串，不含分组

let reg = /(\d{3})[-.]\d{4}/g
let str = "These are two Phone Numbers 212-2345 and 211-3234"
let value = str.match(reg)
// ["212-2345", "211-3234"]
// 比照无分组有g时的结果，能够发现，有无分组时，结果彻底相同

reg.exec()方法 : 每执行一次，返回匹配序列和其子项的数组。直到返回的是null。若是返回nall后，还继续执行，将会从字符串开头从新执行一次（亲测如此）

仍是以电话号码为例：

有g修饰符，有分组

let reg = /(\d{3})[-.]\d{4}/g
let str = "These are two Phone Numbers 212-2345 and 211-3234"
reg.exec(str) // ["212-2345", "212", index: 28, input: "These are two Phone Numbers 212-2345 and 211-3234", groups: undefined]
reg.exec(str) // ["211-3234", "211", index: 41, input: "These are two Phone Numbers 212-2345 and 211-3234", groups: undefined]
reg.exec(str) // null
reg.exec(str) // ["212-2345", "212", index: 28, input: "These are two Phone Numbers 212-2345 and 211-3234", groups: undefined]

无g修饰符，有分组

let reg = /(\d{3})[-.]\d{4}/
let str = "These are two Phone Numbers 212-2345 and 211-3234"
reg.exec(str)  // ["212-2345", "212", index: 28, input: "These are two Phone Numbers 212-2345 and 211-3234", groups: undefined]
// 无论执行多少次，执行结果都同样，输出第一个匹配到的字符串和它的子项

有g修饰符，无分组

let reg = /\d{3}[-.]\d{4}/g
let str = "These are two Phone Numbers 212-2345 and 211-3234"
reg.exec(str) // ["212-2345", index: 28, input: "These are two Phone Numbers 212-2345 and 211-3234", groups: undefined]
reg.exec(str) // ["211-3234", index: 41, input: "These are two Phone Numbers 212-2345 and 211-3234", groups: undefined]
reg.exec(str) // null
reg.exec(str) // ["212-2345", index: 28, input: "These are two Phone Numbers 212-2345 and 211-3234", groups: undefined]
// 和有g修饰符，有分组的区别只是结果里没有分组的内容输出

无g修饰符，无分组

let reg = /\d{3}[-.]\d{4}/
let str = "These are two Phone Numbers 212-2345 and 211-3234"
reg.exec(str) // ["212-2345", index: 28, input: "These are two Phone Numbers 212-2345 and 211-3234", groups: undefined]
reg.exec(str) // ["212-2345", index: 28, input: "These are two Phone Numbers 212-2345 and 211-3234", groups: undefined]
// 无论执行多少次，执行结果都同样，和无g修饰符，有分组的区别只是结果里没有分组的内容输出

下面是一个有分组、无g修饰符的例子

let str = "{{name}}"
let reg = /\{\{(.*)\}\}/
reg.exec(str) 
// 无论执行多少次，获得的结果永远是： ["{{name}}", "name", index: 0, input: "{{name}}", groups: undefined]

str.split()方法

split的参数除了是字符串，也能够是正则表达式

// 将一段话按照连续的空格和逗号拆开
let str = "how are you, I am here"
let arr = str.split(/[\s,]+/)
// ["how", "are", "you", "I", "am", "here"]

str.replace(reg, replaceStr|function)方法

第一个参数是正则表达式，是匹配的内容，第二个参数是替换的字符串或回调函数。

不会修改原字符串，只会返回修改后的字符串；

let reg = /\ba(\w+)\b/g
let str = "how are you, I am here"
// 将a开头的单词，去掉，后面单词重复
let newStr = str.replace(reg, "$1-$1")  // 子项是在正则表达式外，用反斜杠的话获得的将不是但愿的结果
// newStr : how re-re you, I m-m here
// str: how are you, I am here

在用replace的时候，replaceStr是字符串，用 $加数字的方式匹配子项，注意第一个子项是1，不是0，第0个是 reg 匹配到的完整序列

正则reg若是没有用g，和match同样，只会替换第一个

let reg = /\ba(\w+)\b/     // 没有用g修饰符，newStr只会匹配第一个a开头的单词are，am没有匹配到
let str = "how are you, I am here"
// 将a开头的单词，去掉，后面单词重复
let newStr = str.replace(reg, "$1-$1")
// how re-re you, I am here

function(match,group1,index,str)

参数：function的参数个数是不固定的。

1，回调函数的第一个参数是匹配到的内容
 2，(若是进行分组匹配了 )后面的参数依次是子项1，子项2（一直到子项n）
 3，而后是 匹配到的字符串对应的索引位置
 4，最后是 原始字符串。因此，function的参数个数是不固定的。

返回值：

let reg = /\ba(\w+)\b/g
 let str = "how are you, I am here"
 let newStr = str.replace(reg, (p1,p2,p3,p4) => {
   // 当只有1个子项时，replace的回调函数有四个参数： 匹配的字符串、子项1，子项的index，str
   return p1.toUpperCase()
 })

练习：

匹配电话号码

915-134-3122   
 643.123.3355  
 (120)867-5509

分析：数字一共是10位，数字中间夹杂着点号 . , 短线- 和括号 ()

let str = "643.123.3355"
let reg = /^\(?\d{3}[-.)]\d{3}[-.]\d{4}/
let result = reg.test(str)  // true

以.net,.edu,.com结尾的邮箱

xiaokeke@126.com  
ytxwz@google.net 
gg.s.ddy@sjtu.edu

分析：邮箱是数字或字母\w开头，接@,而后继续数字或字母 \w，而后.net等结尾。

let reg = /^\w[\w.]+@\w+\.(edu|net|com)/
let str = "gg.sd.dy@sjtu.edu"
let result = reg.test(str)  // true

有个名单列表，名和姓是反的，交换过来
```
shiffina, Danial
shifafl, Danial
shquer, Danny
```
分析：交换过来，就是对str作替换操做

分两步：正则匹配到姓、名、姓名中间的部分; replace方法调换子项的顺序
```
let str = "shiffina, Danial"
let reg = /\b(\w+)([,\s]+)(\w+)\b/g
let newStr = str.replace(reg, '$3$2$1')
```

匹配markdown中的link标签，替换为html标签

[google](http://google.com)
[itp](http://itp.nyu.edu)
[Coding Rainbow](http://codingrainbow.com)

分析：把方括号[]里的字符串找出来，做为a标签之间的内容。把括号 () 中的字符串找出来，做为a的href标签的内容。

match方法实现

let str = "[itp](http://itp.nyu.edu)"
let reg = /\[(\w+)\]\((http:\/\/[\w.]+\.\w+)\)/
let result = str.match(reg)
let html = ""
if(result && Array.isArray(result)){
  let [,name, hrefData] = result
  html =  `<a href=${hrefData}>${name}</a>`  
}
// html:  <a href=http://itp.nyu.edu>itp</a>

replace方法实现

由计算的结果可知

replaceFunction的返回值会替换掉匹配到的字符串totalStr

reg加g时，会匹配整个字符串；不加g，只会匹配第一个字符串

let str = "这是百度的地址：[baidu](http://www.baidu.com)， 我常常访问这个网站。同时，我也常常去[taobao](http://www.taobao.com)"
let reg = /\[(\w+)\]\((http:\/\/[\w.]+\.\w+)\)/g
let newStr =  str.replace(reg, (totalStr, name, address) => {
  return `<a href=${address}>${name}</a>`
})
// 这是百度的地址：<a href=http://www.baidu.com>baidu</a>， 我常常访问这个网站。同时，我也常常去<a href=http://www.taobao.com>taobao</a>
// 若是reg没有g修饰符： 这是百度的地址：<a href=http://www.baidu.com>baidu</a>， 我常常访问这个网站。同时，我也常常去[taobao](http://www.taobao.com)

匹配连续序列

This is is a dog dog under the tree tree, do you know?

匹配其中的is is, dog dog, tree tree

let str = "This is is a dog dog under the tree tree, do you know?"
let reg = /\b(\w+)\b\s+\1/g
let result = str.match(reg)   // [ 'is is', 'dog dog', 'tree tree']

match有g修饰符时，返回的是匹配出来的全部字符串。

提取英文单词，存到数组

"unicorns and rainbows And, Cupcakes"

match方法：

let str =  "unicorns and rainbows And, Cupcakes"
let reg = /\w+/g
let result = str.match(reg)
// [ 'unicorns', 'and', 'rainbows', 'And', 'Cupcakes' ]

split 方法：

let str =  "unicorns and rainbows And, Cupcakes"
let reg = /[\s,]+/g
let result = str.split(reg)
// [ 'unicorns', 'and', 'rainbows', 'And', 'Cupcakes' ]

将下列句子中aeiou替换成大写字母

how old are you .

let str = "how old are you ."
let reg = /([aeiou])/g
let result = str.replace(reg, (p1, p2) => {
  return p2.toUpperCase()
})
// hOw Old ArE yOU .

练习题4的扩展

方括号和圆括号中的内容不限定死，能够是任意形式，好比中文。怎么匹配呢？

用点号 .和星号 *一块儿。可是因为点号是贪婪匹配， \[(.*)\]会把整个str都匹配出来，所以不能使用贪婪匹配。将问号放在数量的后面，可去掉贪婪属性。
```
let str = "[百度](http://www.baidu.com)[baidu]" 
let reg = /\[(.*?)\]$(.*?)$\[.*?\]/
let result = str.replace(reg, `<a href='$2'>$1</a>`)
// <a href='http://www.baidu.com'>百度</a>
```
懒惰限定符以下：