很多時候多會被正則表示式搞的暈頭轉向，最近抽出時間對正則表示式進行了系統的學習，整理如下：

正則表示式的建立

兩種方法，一種是直接寫，由包含在斜槓之間的模式組成；另一種是呼叫 RegExp 物件的建構函式。

兩種方法的建立程式碼如下：

// 直接建立
const regex1 = /ab+c/;
const regex2 = /^[a-zA-Z]+[0-9]*\W?_$/gi;

// 呼叫建構函式
const regex3 = new RegExp('ab+c');
const regex4 = new RegExp(/^[a-zA-Z]+[0-9]*\W?_$/, "gi");
const regex5 = new
 
 RegExp('^[a-zA-Z]+[0-9]*\W?_$', 'gi');
複製程式碼

可以看出，呼叫 RegExp 建構函式建立正則表示式時，第一個引數可以是字串，也可以是直接建立的正則表示式。

需要注意的是：RegExp 例項繼承的 toLocaleString() 和 toString)() 方法都會返回正則表示式的字面量，與建立正則表示式的方式無關。

例如：

const ncname = '[a-zA-Z_][\\w\\-\\.]*';
const qnameCapture = '((?:' + ncname + '\\:)?' + ncname + ')';
const startTagOpen = new
 
 RegExp('^<' + qnameCapture);
      
// '/^<((?:[a-zA-Z_][\w\-\.]*\:)?[a-zA-Z_][\w\-\.]*)/'
startTagOpen.toString();  
複製程式碼

正則表示式中的特殊字元

• \ (反斜槓)

  1. 在非特殊字元前加反斜槓表示下一個字元是特殊的；
  2. 將其後的特殊字元轉譯為字面量；

  注意：在使用 RegExp 建構函式時要將\轉譯，因為 \ 在字串裡也是轉譯字元。

• ^

  1. 匹配輸入的開始；
  2. 在 [] 中的第一位時表示反向字符集；

  例：

  /^A/.exec('an A')        // null
  /^A/.exec('An E')        // ["A", index: 0, input: "An E"]
  複製程式碼

• $

  匹配輸入的結束

  /t$/.exec('eater')        // null
  /t$/.exec('eat')          // ["t", index: 2, input: "eat"]
  複製程式碼

• *, + , .(小數點)

  *：匹配前一個表示式0次或多次。等價於 {0,}；

  +：匹配前面一個表示式1次或者多次。等價於 {1,}；

  .：匹配除換行符之外的任何單個字元；

• ? (問號)

  1. 匹配前面一個表示式0次或者1次。等價於 {0,1}；
  2. 如果緊跟在任何量詞 * + ? {} 的後面，將會使量詞變為非貪婪的（匹配儘量少的字元），和預設使用的貪婪模式正好相反；
  3. 運用於先行斷言；

  例子：

  /\d+/.exec('123abc')        // ["123", index: 0, input: "123abc"]
  /\d+?/.exec('123abc')       // ["1", index: 0, input: "123abc"]
  複製程式碼

• (x)

  匹配 x 並且記住匹配項，括號表示捕獲括號；

  例：

  /(foo) (bar) \1 \2/.test('bar foo bar foo');   // false
  /(bar) (foo) \1 \2/.test('bar foo bar foo');   // true
  /(bar) (foo) \1 \2/.test('bar foo');           // false
  /(bar) (foo) \1 \2/.test('bar foo foo bar');   // false
  /(bar) (foo) \2 \1/.test('bar foo foo bar');   // true
  
  'bar foo bar foo'.replace( /(bar) (foo)/, '$2 $1' );    // "foo bar bar foo"
  複製程式碼

  模式 /(foo) (bar) \1 \2/ 中的 (foo) 和 (bar) 匹配並記住字串 foo bar foo bar 中前兩個單詞。模式中的 \1 和 \2 匹配字串的後兩個單詞。

  注意：\1、\2、\n 是用在正則表示式的匹配環節，在正則表示式的替換環節，則要使用像 $1 、$2 、$n 這樣的語法。例如，'bar foo'.replace( /(...) (...)/, '$2 $1' )。

• (?:x)

  匹配 x 但是不記住匹配項，這種叫作非捕獲括號；

  例：

  'foo'.match(/foo{1,2}/)                // ["foo", index: 0, input: "foo"]
  'foo'.match(/(?:foo){1,2}/)            // ["foo", index: 0, input: "foo"]
  'foofoo'.match(/(?:foo){1,2}/)         // ["foofoo", index: 0, input: "foofoo"]
  'foofoo'.match(/foo{1,2}/)             // ["foo", index: 0, input: "foofoo"]
  複製程式碼

  使用場景：示例表示式 /(?:foo){1,2}/。如果表示式是 /foo{1,2}/，{1,2}將只對 foo 的最後一個字元 ’o‘ 生效。如果使用非捕獲括號，則 {1,2} 會匹配整個 foo 單詞。

• x(?=y) , x(?!y) , x|y

  x(?=y)：匹配'x'僅僅當'x'後面跟著'y'；

  x(?!y)：匹配'x'僅僅當'x'後面不跟著'y'；

  x|y: 匹配x或y；

  這兩種匹配的結果都不包含y。

  例：

  'JackSprat'.match(/Jack(?=Sprat)/)            // ["Jack", index: 0, input: "JackSprat"]
  'JackWprat'.match(/Jack(?=Sprat)/)            // null
  'JackWprat'.match(/Jack(?=Sprat|Wprat)/)      // ["Jack", index: 0, input: "JackWprat"]
  /\d+(?!\.)/.exec("3.141")                     // ["141", index: 2, input: "3.141"]
  複製程式碼

• {n} , {n,m} :

  {n} ：匹配了前面一個字元剛好發生了n次；

  {n,m} ：匹配前面的字元至少n次，最多m次。如果 n 或者 m 的值是0， 這個值被忽略；

  例：

  /a{2}/.exec('candy')         // null
  /a{2}/.exec('caandy')        // ["aa", index: 1, input: "caandy"]
  /a{2}/.exec('caaandy')       // ["aa", index: 1, input: "caaandy"]
  
  /a{1,3}/.exec('candy')       // ["a", index: 1, input: "candy"]
  /a{1,3}/.exec('caandy')      // ["aa", index: 1, input: "caandy"]
  /a{1,3}/.exec('caaandy')     // ["aaa", index: 1, input: "caaandy"]
  /a{1,3}/.exec('caaaandy')    // ["aaa", index: 1, input: "caaaandy"]
  複製程式碼

• [xyz], [^xyz]

  [xyz]：一個字元集合。匹配方括號的中任意字元;

  [^xyz]：一個反向字符集。匹配任何沒有包含在方括號中的字元；

  這兩種匹配都可以使用破折號（-）來指定一個字元範圍，特殊符號在字符集中沒有了特殊意義。

  例：

  function escapeRegExp(string){
      return string.replace(/([.*+?^=!:${}()|[\]\/\\])/g, "\\$&"); 
      //$&表示整個被匹配的字串
  }
  複製程式碼

  例子中的 .*+?^=!:${}() 都表示字面量，並沒有特殊意義

• 其他

  \b：匹配一個詞的邊界。一個匹配的詞的邊界並不包含在匹配的內容中。換句話說，一個匹配的詞的邊界的內容的長度是0；

  \B ： 匹配一個非單詞邊界；

  例：

      /\bm/.exec('moon')                        // ["m", index: 0, input: "moon"]
      /\bm/.exec('san moon')                    // ["m", index: 4, input: "san moon"]
      /oo\b/.exec('moon')                       // null
      /\B../.exec('noonday')                    // ["oo", index: 1, input: "noonday"]
      /y\B../.exec('possibly yesterday')        // /y\B../.exec('possibly yesterday')
  複製程式碼

  \d ：匹配一個數字，等價於 [0-9]；

  \D ：匹配一個非數字字元，等價於 [^0-9]；

  \f ：匹配一個換頁符 (U+000C)；

  \n ：匹配一個換行符 (U+000A)；

  \r ：匹配一個回車符 (U+000D)；

  \s ：匹配一個空白字元，包括空格、製表符、換頁符和換行符，等價於 [ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]；

  \S ：匹配一個非空白字元，等價於 [^ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]；

  \w ：匹配一個單字字元（字母、數字或者下劃線），等價於[A-Za-z0-9_]；

  \W ：匹配一個非單字字元，等價於[^A-Za-z0-9_]；

正則表示式標誌

g：全域性搜尋；

i：不區分大小寫；

m：多行搜尋；

正則表示式使用

RegExp 有 exec() 和 test() 方法；

exec 匹配的結果為：匹配結果、捕獲結果，index 和 input 。

test 匹配的結果為 true 或 false，效率比 exec 要高。

String 有 match() ，replace() ，search() ，split() 方法；

match 匹配的結果同 RegExp 的 exec ，replace 根據正則表示式替換，search 查詢所以位置，split 根據正則表示式分割字串。

其中，當 replace 有 function 時，引數說明如下：

• 匹配項
• 記憶項（括號裡面的項）
• ...
• 匹配的 index
• input 輸入項

後面的話

本文只針對前端正則表示式的簡單概括，要用好表示式還需要具體的經驗。