摘要：今天我們來(lái)講一下正則表達(dá)式的基本使用正則表達(dá)式的修飾符執(zhí)行對(duì)大小寫(xiě)不敏感的匹配上面的第一個(gè)例子字符串帶有大寫(xiě)英文，而我們的匹配方式則為全部小寫(xiě)，我們會(huì)得到，第二個(gè)例子字符串全部為小寫(xiě)，而匹配方式則為大小寫(xiě)混合也是得到，第三個(gè)則是不使用修飾符

今天我們來(lái)講一下正則表達(dá)式的基本使用

i 執(zhí)行對(duì)大小寫(xiě)不敏感的匹配

   let a = "hEllo World"
   let reg = /hello/i
   console.log(reg.test(a)) // true
   
   let str = "hello"
   let reg1 = /Hello/i
   console.log(reg1.test(str)) // true
   
   let str1 = "hello"
   let reg2 = /Hello/
   console.log(reg2.test(str1)) // false

上面的第一個(gè)例子字符串a(chǎn)帶有大寫(xiě)英文，而我們的匹配方式則為全部小寫(xiě)，我們會(huì)得到true，第二個(gè)例子str字符串全部為小寫(xiě)，而匹配方式則為大小寫(xiě)混合也是得到true，第三個(gè)則是不使用修飾符i的，得到為false，所以i是對(duì)大小寫(xiě)不敏感的

g 執(zhí)行全局匹配（查找所有匹配而非在找到第一個(gè)匹配后停止）

   let a = "hello hello hello hello"
   let reg = /hello/g
   console.log(a.replace(reg, "*")) // * * * *

   let a1 = "hello Hello hello Hello"
   let reg1 = /Hello/g
   console.log(a1.replace(reg1, "*")) // hello * hello *

   let a2 = "hello Hello hello Hello"
   let reg2 = /Hello/gi
   console.log(a2.replace(reg2, "*"))
   
   let a3 = "hello _Hello hello Hello"
   let reg3 = /Hello/gi
   console.log(a3.replace(reg3, "*"))* _* * *

對(duì)于g全局的匹配，我對(duì)于它的理解就是能找到的都可以，只要符合的行，看上面的四個(gè)例子，最主要是看最后一個(gè)一個(gè)例子不管是不是一體只要符合你的規(guī)則就可以

m 多行匹配

   let a = "hello
 hello hello hello"
   let reg = /hello/m
   console.log(a.replace(reg, "*")) 
   // *
      hello hello hello
   let a1 = "hello Hello
 hello Hello"
   let reg1 = /Hello/m
   console.log(a1.replace(reg1, "*"))
   // hello *
             hello hello

   let a1 = "hello hello
 hello Hello"
   let reg1 = /Hello/m
   console.log(a1.replace(reg1, "*"))
   //hello hello
        hello *

通過(guò)上面的兩個(gè)例子，我們已經(jīng)知道m(xù)修飾符也算是查找全局的修飾符但是它匹配到一個(gè)就不會(huì)再進(jìn)行匹配了

es6新增修飾y,又叫做粘連修飾符，和g修飾符類似也是全局匹配

   let str = "anta"
   let y = /a/y
   console.log(str.replace(y, "&")) // &nta
   console.log(str.replace(y, "&")) // anta
   
   let str = "aanta"
   let y = /a/y
   console.log(str.replace(y, "&")) //&anta
   console.log(str.replace(y, "&")) //a&nta
   console.log(str.replace(y, "&")) //aanta

上面第一個(gè)例子使用了y修飾符，第一次執(zhí)行我們匹配到了a替換成功，第二次的時(shí)候沒(méi)有值被匹配到，這是因?yàn)閥修飾符匹配到一次后，會(huì)接著當(dāng)前匹配到位置的下一個(gè)位置開(kāi)始，所以在第一次替換的時(shí)候位置為0，第二次匹配的時(shí)候位置則變?yōu)榱?，y修飾符是具有位置屬性的位置匹配，下面我們就來(lái)看一下

   let str = "aanta"
   let y = /a/y
   y.lastIndex = 4
   console.log(str.replace(y, "&")) // aant&
   
   y.lastIndex = 1
   console.log(str.replace(y, "&")) // a&nta

上面的兩個(gè)例子則是使用了位置，我們可以看到使用位置之后，會(huì)打亂y修飾符原有的粘連方式，會(huì)直接按照我們規(guī)定的位置1匹配

   let str = "aanta"
   let y = /a/gy
   console.log(str.replace(y, "&")) // &&nta

上面的例子是g和y修飾符配合使用，會(huì)得到我們意想不到的結(jié)果，因?yàn)樗鼤?huì)按照粘連規(guī)則檢驗(yàn)

RegExp.prototype.sticky 屬性檢驗(yàn)是否設(shè)置了y修飾符

   let y1 = /a/y
   console.log(y1.sticky) // true
   let y = /a/gy
   console.log(y.sticky) // true

RegExp.prototype.flags 屬性返回設(shè)置的修飾符

   let y1 = /^a/y
   console.log(y1.flags) // y
   let y = /a/gy
   console.log(y.flags) // gy

es6 新增修飾符s 符號(hào).匹配所有字符

    let str = "aa
nta"
    let reg = /a.n/s
    console.log(reg.test(str)，reg.dotAll) // true true
    
    let str = "aa
nta"
    let reg = /a.n/
    console.log(reg.test(str)，reg.dotAll) // false false

修飾符s匹配換行符n,我們會(huì)得到true，如果不用s修飾符的話會(huì)匹配不到的，上面的例子中都有檢測(cè)是否存在dotAll模式中，說(shuō)白了主要就是看你有沒(méi)有修飾符s

[] 匹配中括號(hào)內(nèi)規(guī)則的字符

  let str = "hello world"
  let reg = /[a-z]/
  console.log(reg.test(str)) // true
  
  let str = "hello world"
  let reg = /[a-h]/g
  console.log(str.replace(reg, "*")) // **llo worl*
  
  let str = "he1l3 wo4ld"
  let reg = /[0-9]/g
  console.log(str.replace(reg, "#")) // he#l# wo#ld

上面只是簡(jiǎn)單的兩個(gè)例子只是簡(jiǎn)單的測(cè)試下是否可以匹配到中括號(hào)內(nèi)的相關(guān)規(guī)則字符串

| 匹配多個(gè)規(guī)則相當(dāng)于||或

   let str = "he1l3 wo4ld"
   let reg = /[0-9|a-d]/g
   console.log(str.replace(reg, "#")) // he#l# wo#l#
   
   let str = "he1l3 wo4ldc@"
   let reg = /[0-9|a-d|c.]/sg
   console.log(str.replace(reg, "#")) // he#l# wo#l##@

上面第一個(gè)例子使用了g修飾符全局匹配0-9內(nèi)的數(shù)字和a-d的字母替換，第二個(gè)例子使用了s和g的修飾符

正則表達(dá)式元字符

我們按照順序?qū)憥讉€(gè)簡(jiǎn)單的例子

   匹配數(shù)字，只要是數(shù)字都能匹配到
   let str = "hello 1235"
   let reg = /d/g
   console.log(str.replace(reg, "*")) // hello ****
   
   查找空白字符
   let str = "hello 1235"
   let reg = /s/g
   console.log(str.replace(reg, "*")) // hello*1235
   
   匹配單詞邊界
   let str = "hello 1235"
   let reg = //g
   console.log(str.replace(reg, "*")) // *hello* *1235*
   
   匹配換行符
   let str = "hello
123
5"
   let reg = /
/g
   console.log(str.replace(reg, "*")) // hello*123*5
   
   /w匹配[a-zA-Z0-9_]
   let str = "Abv12_$"
   let reg = /w/g
   console.log(str.replace(reg, "*")) // ******
   

匹配結(jié)尾的$

    let str = "Abv12"
    let reg = /v$/g
    console.log(reg.exec(str)) // null
    
    let str = "Abv12v"
    let reg = /v$/g
    console.log(reg.exec(str)) // ["v", index: 5, input: "Abv12v", groups: undefined]
    
    ^匹配開(kāi)頭的
    let str = "Abv12v"
    let reg = /^v/g
    console.log(reg.exec(str)) // null
    
    let str = "vAbv12v"
    let reg = /v$/g
    console.log(reg.exec(str)) //["v", index: 0, input: "vAbv12v", groups: undefined]
    
    ^和$配合使用
    let str1 = "abcd 1"
    let reg1 = /^[a-z]+s+d+$/i
    console.log(str1.replace(reg1, "*")) // *

匹配abcd 1,需要對(duì)應(yīng)的規(guī)則分別是abcd ^[a-z] 空格s d數(shù)字$

    {n} 匹配n個(gè)
    {n，} 最少n個(gè)
    {n, n} 最少匹配n個(gè)，最大匹配n個(gè)
    
    （）捕獲性分組使用
    
    let str = "2018-03-02"
    let reg = /^(d{4})-(d{2})-(d{2})$/
    console.log(str.replace(reg, "$1/$2/$3")) // 2018/03/02

上面的例子使用了（）和{}配合使用，分成了三個(gè)組，第一個(gè)組匹配四個(gè)數(shù)字，第二個(gè)和第三個(gè)匹配兩位數(shù)字，然后利用了^開(kāi)始匹配的四位數(shù)字開(kāi)始和$匹配兩位數(shù)字結(jié)束，將-替換/

    （）非捕獲性使用 非捕獲性分組通過(guò)將子表達(dá)式放在"?:"符號(hào)后，我理解的非捕獲性分組就是（）有根沒(méi)有都一樣
        let str = "2018-03-02"
        let reg = /^(?:d{4})-(?:d{2})-(?:d{2})$/
        console.log(str.replace(reg, "$1/$2/$3")) // $1/$2/$3

上面的例子就是一個(gè)非捕獲性的例子，在子表達(dá)式前面加上？：就可以解除小括號(hào)的分組模式所以匹配不到

說(shuō)到貪婪模式和非貪婪模式，首先我要介紹一下量詞，因?yàn)榉秦澙纺Ｊ揭迷诹吭~后面

n{X}匹配包含X個(gè)n的序列的字符串

n{X,Y}匹配包含X至Y個(gè)n的序列的字符串

n{X,}匹配至少包含 X 個(gè) n 的序列的字符串

n*匹配任何包含零個(gè)或多個(gè) n 的字符串

n?匹配任何包含零個(gè)或一個(gè) n 的字符串

n+匹配任何至少包含一個(gè) n 的字符串

貪婪模式就是盡可能多的匹配
let str = "abcdefghijk123"
let reg = /w{1,4}/
console.log(str.replace(reg, "*")) // *efghijk123

上面的例子則為貪婪模式它會(huì)匹配到最大的那個(gè)位數(shù)

let str = "abcdefghijk123"
let reg = /w{1,4}?/
console.log(str.replace(reg, "*")) // *bcdefghijk123

上面的例子則為非貪婪模式，只會(huì)去匹配最少的位數(shù)

先行斷言？=

let str = "abcdefghijk123asd456"
let reg = /w+(?=123)/g
console.log(str.match(reg)) // ["abcdefghijk"]

上面的例子為先行斷言的例子reg規(guī)則必須是后面帶有123的匹配到

先行否定斷言？！

let str = "bbb123 bbbbb456"
let reg = /b{3,}(?!123)/g
console.log(str.match(reg)) // ["bbbbb"]

 后行斷言查找匹配表達(dá)式匹配到后面的
 
 let str = "abcdefghijk123asd456"
 let reg = /(?<=123)[a-z]/g
 console.log(str.match(reg)) // ["a"]
 
 后行否定斷言，匹配不屬于123的，后面的[a-z]的字符
 let str = "abcdefghijk123asd"
 let reg = /(?
我感覺(jué)先行斷言像后行否定斷言，先行否定斷言像后行斷言
RegExp 構(gòu)造函數(shù)對(duì)象
 new RegExp(pattern,modifiers)
 pattern 則為表達(dá)式
 modifiers 則為修飾符
 
 let reg1 = new RegExp("[a-z]","g")
 console.log(reg1) // /[a-z]/g
上面的例子我們會(huì)得到這個(gè)結(jié)果是因?yàn)镽egExp對(duì)象會(huì)將第二個(gè)參數(shù)修飾符與第一個(gè)參數(shù)表達(dá)式進(jìn)行合并
let reg1 = new RegExp(/[a-z]/,"g")
console.log(reg1) // /[a-z]/g
上面這個(gè)例子我們也會(huì)得到我們想要匹配全局的一個(gè)表達(dá)式，但是在es5中如果這樣寫(xiě)就會(huì)出現(xiàn)報(bào)錯(cuò)
let reg1 = new RegExp(/[a-z]/,"g")
console.log(reg1.flags) // g

let reg1 = new RegExp(/[a-z]/,"i")
console.log(reg1.flags) // i
我們還可以檢測(cè)表達(dá)式是否使用了修飾符，并且可以知道使用了什么修飾符
正則表達(dá)式的方法
RegExp 對(duì)象方法

compile
編譯正則表達(dá)式

    let str = "123.jpg456.png"
    let reg = /[123]/g
    console.log(str.replace(reg, "x")) // xxx.jpg456.png
    reg.compile(/[456]/g)
    console.log(str.replace(reg, "x")) // 123.jpgxxx.png
    
    let str = "123.jpg456.png"
    let reg = /[123]/g
    console.log(str.replace(reg, "xx")) // xxxxxx.jpg456.png
上面的第一個(gè)例子使用了表達(dá)式方法compile它會(huì)使表達(dá)式重新編譯或是修改，所以第一次匹配的是123，第二次則是456，是因?yàn)楦淖兞似ヅ錂C(jī)制，第二個(gè)例子使用用到了替換的方法并且會(huì)發(fā)現(xiàn)你替換的參數(shù)多的話會(huì)修改字符串的長(zhǎng)度

exec
根據(jù)正則表達(dá)試查找對(duì)應(yīng)的字符和位置

let str = "2018-02-13"
let reg = /-d{1,2}/g
console.log(reg.exec(str)) // ["-02", index: 4, input: "2018-02-13", groups: undefined]
上面的例子是查找?guī)в?數(shù)字不超過(guò)2位，返回的是數(shù)組，并且把匹配到的第一個(gè)在最前面的位置

test
根據(jù)正則表達(dá)試是否匹配到布爾值

正則表達(dá)式的 String 對(duì)象的方法

search
檢索與正則表達(dá)式相匹配的值

let str = "2018-02-13"
let reg = /-d{1,2}/g
console.log(str.search(reg)) // 4
它會(huì)返回你表達(dá)式匹配到第一個(gè)字符的位置返回，它會(huì)對(duì)大小寫(xiě)敏感如果查找不到會(huì)返回-1，無(wú)視g

match
找到一個(gè)或多個(gè)正則表達(dá)式的匹配

 let str = "this is 1 or 2"
let reg = /d/g
console.log(str.match(reg)) // [1,2]
它會(huì)找出所有與你表達(dá)式匹配到的字符放入數(shù)組中

replace
替換

replace替換我們上面已經(jīng)使用過(guò)很多次了，大家可以仔細(xì)閱讀看

matchAll
匹配所有，表達(dá)式不用使用全局修飾符

es6的正在提案的一個(gè)方法，它可以摒棄全局的修飾符，達(dá)到全局的匹配，它會(huì)返回一個(gè)遍歷器，然后可以通過(guò)結(jié)構(gòu)賦值拿到想要的結(jié)果
上面我們學(xué)習(xí)了那么多，那我們就運(yùn)用所學(xué)寫(xiě)一些表達(dá)式
    /^1[3|4|5|7|8][0-9]{9}$/ 匹配手機(jī)號(hào)開(kāi)頭必須有1，34578其中的一個(gè)，結(jié)尾必須9位數(shù)而且是0-9的數(shù)字
    /^0315(-?)[0-9]{7}$/  判斷電話區(qū)號(hào)和-可有可無(wú)
    /^[0-9]{4}(-?)[0-9]{7}$/ 匹配1-9的數(shù)字必須是四位，可有可無(wú)-，匹配7位數(shù)字
都是幾個(gè)比較簡(jiǎn)單的表達(dá)式，還需多學(xué)習(xí)，多練習(xí)才能寫(xiě)出更廣泛更精準(zhǔn)的表達(dá)式