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

今天我們來講一下正則表達式的基本使用

i 執行對大小寫不敏感的匹配

   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

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

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, "*"))* _* * *

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

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 *

通過上面的兩個例子，我們已經知道m修飾符也算是查找全局的修飾符但是它匹配到一個就不會再進行匹配了

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

上面第一個例子使用了y修飾符，第一次執行我們匹配到了a替換成功，第二次的時候沒有值被匹配到，這是因為y修飾符匹配到一次后，會接著當前匹配到位置的下一個位置開始，所以在第一次替換的時候位置為0，第二次匹配的時候位置則變為了1，y修飾符是具有位置屬性的位置匹配，下面我們就來看一下

   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

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

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

上面的例子是g和y修飾符配合使用，會得到我們意想不到的結果，因為它會按照粘連規則檢驗

RegExp.prototype.sticky 屬性檢驗是否設置了y修飾符

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

RegExp.prototype.flags 屬性返回設置的修飾符

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

es6 新增修飾符s 符號.匹配所有字符

    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,我們會得到true，如果不用s修飾符的話會匹配不到的，上面的例子中都有檢測是否存在dotAll模式中，說白了主要就是看你有沒有修飾符s

[] 匹配中括號內規則的字符

  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

上面只是簡單的兩個例子只是簡單的測試下是否可以匹配到中括號內的相關規則字符串

| 匹配多個規則相當于||或

   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修飾符全局匹配0-9內的數字和a-d的字母替換，第二個例子使用了s和g的修飾符

正則表達式元字符

我們按照順序寫幾個簡單的例子

   匹配數字，只要是數字都能匹配到
   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, "*")) // ******
   

匹配結尾的$

    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]
    
    ^匹配開頭的
    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,需要對應的規則分別是abcd ^[a-z] 空格s d數字$

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

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

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

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

說到貪婪模式和非貪婪模式，首先我要介紹一下量詞，因為非貪婪模式要用在量詞后面

n{X}匹配包含X個n的序列的字符串

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

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

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

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

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

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

上面的例子則為貪婪模式它會匹配到最大的那個位數

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

上面的例子則為非貪婪模式，只會去匹配最少的位數

先行斷言？=

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

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

先行否定斷言？！

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

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

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

compile
編譯正則表達式

    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
上面的第一個例子使用了表達式方法compile它會使表達式重新編譯或是修改，所以第一次匹配的是123，第二次則是456，是因為改變了匹配機制，第二個例子使用用到了替換的方法并且會發現你替換的參數多的話會修改字符串的長度

exec
根據正則表達試查找對應的字符和位置

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]
上面的例子是查找帶有-數字不超過2位，返回的是數組，并且把匹配到的第一個在最前面的位置

test
根據正則表達試是否匹配到布爾值

正則表達式的 String 對象的方法

search
檢索與正則表達式相匹配的值

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

match
找到一個或多個正則表達式的匹配

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

replace
替換

replace替換我們上面已經使用過很多次了，大家可以仔細閱讀看

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

es6的正在提案的一個方法，它可以摒棄全局的修飾符，達到全局的匹配，它會返回一個遍歷器，然后可以通過結構賦值拿到想要的結果
上面我們學習了那么多，那我們就運用所學寫一些表達式
    /^1[3|4|5|7|8][0-9]{9}$/ 匹配手機號開頭必須有1，34578其中的一個，結尾必須9位數而且是0-9的數字
    /^0315(-?)[0-9]{7}$/  判斷電話區號和-可有可無
    /^[0-9]{4}(-?)[0-9]{7}$/ 匹配1-9的數字必須是四位，可有可無-，匹配7位數字
都是幾個比較簡單的表達式，還需多學習，多練習才能寫出更廣泛更精準的表達式