正則表達式基本用法

時間 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>
```
懶惰限定符以下：