RegExp語法（包含ES2018標準）

注意：本次所有程式碼都僅在Chrome 70中進行測試

1. 正則表示式是什麼？

   正則表示式是用於匹配字串中字元組合的模式。（mdn）

   簡單來說，正則表示式是用來提取、捕獲文字（匹配字元）的。

2. 建立：

   • 字面量：let regex = / pattern / flags

     let regex1 = /foo/i;

   • 建構函式：let regex = new RegExp(pattern, falgs);

     let regex2 = new RegExp('bar', ig); // ES5
     let regex3 = new RegExp(/bat/im); // ES5
     let regex4 = new RegExp(/cat/ig, 'g'); // ES6
     /* regex4 建立方法在ES5中會丟擲TypeError,因為第一個引數已經是一個正則表示式，而ES5不允許此時再使用第二個引數新增修飾符。ES6則允許這種寫法，但第二個引數會作為修飾符覆蓋第一個引數中的修飾符。*/
     console.log(regex4); // /cat/g
      
     

3. 例項屬性：

   每個正則表示式例項都擁有下面的屬性，以便獲取例項模式的資訊。

   • global：布林值，表示是否設定了 g（全域性匹配）標誌。

   • ignoreCase：布林值，表示是否設定了 i（忽略大小寫）標誌。

   • multiline：布林值，表示是否設定了 m（多行）標誌。

   • unicode：布林值，表示是否設定了 u（識別 unicode 字元中大於\uFFFF的 unicode 字元）標誌。

   • sticky：布林值，表示是否設定了 y（粘連）標誌。

   • lastIndex：上次成功匹配後的索引位置，會成為下次匹配的開始索引位置，只在全域性匹配或粘滯匹配模式下可用。

   • source：正則表示式中pattern

     （模式）的字串表示，與呼叫toString()或者valueOf()方法得到的結果並不一樣。

   • flags：返回正則表示式中flags（修飾符）的字串表示。

   • dotAll：返回一個布林值，表示是否設定了 s（dotAll）標誌。

     let str2 = 'batfoocat';
     let pattern2 = /at/g;
     
     pattern2.global;  // true
     pattern2.sticky;  // false
     pattern2.source; // at
     pattern2.flags; // g
     pattern2.toString(); // /at/g
     pattern2.valueOf(); // /at/g
     pattern2.lastIndex; // 0
     
     let matches = pattern2.exec(str2); // 第一次
     matches[0]; // at
     matches.index; // 1
     pattern2.lastIndex; // 3
     
     matches = pattern2.exec(str2); // 第二次
     matches[0]; // at
     matches.index; // 7
     pattern2.lastIndex; // 9
     
     /*第三次會出現報錯，是因為已經沒有匹配項了，exec()方法返回了null，再執行第四次就會返回第一次匹配的結果，即重新開始匹配*/
     matches = pattern2.exec(str2); // 第三次
     matches[0]; // error
     matches.index); // error
     pattern2.lastIndex; // 0
      
     

     補充：已經廢棄的屬性（https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features）

     這些廢棄的特性仍然可以使用,但你要保持謹慎,因為它們很可能會在未來的某個時候被刪除.（mdn）

4. 方法：

   • exec：在指定字串中進行匹配字元，每次只會返回一個匹配項的資訊。

     匹配成功，則返回一個數組，並更新正則表示式例項的屬性，否則返回 null。

     返回的陣列是 Arrary 例項，但包含了兩個屬性：index（匹配項在字串中的位置）和 input（正則表示式進行匹配的字串），陣列第一項（下標0）存放匹配到的文字。

     注意：如果使用了全域性匹配（g）,再次使用exec()方法會返回第二個匹配項的資訊，否則無論使用多少次exec()方法都只會返回第一個匹配項資訊。

     補充：ES2018在返回陣列中新增了一個屬性groups（命名捕獲組的資訊）

     let str1 = 'batfoocat';
     let pattern1 = /at/g;
     pattern1.exec(str1); // 第一次
     // ["at", index: 1, input: "batfoocat", groups: undefined]
     pattern1.exec(str1); // 第二次
     // ["at", index: 7, input: "batfoocat", groups: undefined]
     pattern1.exec(str1); // 第三次
     // null
     // 第四次會重新開始匹配，即返回第一次匹配的結果

   • test()：測試當前正則表示式是否能匹配目標字串，返回布林值。

     let str3 = 'batfoocat';
     let str4 = 'abcde';
     let pattern3 = /at/g;
     pattern3.test(str3); // true
     pattern3.test(str4); // false

   • String.prototype.search()：檢索與正則表示式相匹配的子字串，匹配成功返回第一個匹配項在字串中的下標，否則返回-1。

     let str5 = 'abcdea';
     str5.search(/a/g); // 0
     str5.search(/f/g); // -1

   • String.prototype.match()：檢索與正則表示式相匹配的子字串，匹配成功返回一個存放所有匹配項的陣列，否則返回null，如果正則表示式中沒有標誌 g（全域性標誌），那麼match()方法就只能執行一次匹配。

     注意：在全域性檢索模式下，match() 即不提供與子表示式匹配的文字的資訊，也不宣告每個匹配子串的位置。如果需要這些全域性檢索的資訊，可以使用RegExp.exec()。

     let str6 = 'abcdea';
     str6.match(/a/g);
     // ["a", "a"]
     str6.match(/a/);
     // ["a", index: 0, input: "abcdea", groups: undefined]
     str6.match(/f/g);
     // null

   • String.prototype.replace(regexp, replacement)：替換一個與正則表示式匹配的子串。

     let str7 = 'batfoocat';
     let a = str7.replace(/at/g, 'oo');
     // "boofoocoo"
     
     let b = str7.replace(/at/, 'oo');
     // "boofoocat"
     
     let c = str7.replace(/at/g, (value)=> {
         return  '!' + value;
     });
     // "b!atfooc!at"

   • String.prototype.split(separator [, howmany])：把一個字串分割成字串陣列，第二個引數為可選，該引數可指定返回的陣列的長度，不填則返回所有。

     let str8 = 'batfoocat';
     let a = str8.split(/at/g); // ["b", "fooc", ""]
     let b = str8.split(/at/); // ["b", "fooc", ""]
     let c = str8.split(/at/, 2); // ["b", "fooc"]

5. 修飾符（標誌 - flags）：

   • g：全域性匹配，找到所有匹配，而不是在發現第一個匹配項後立即停止。

     let str9 = 'batfoocat';
     str9.match(/at/);
     // ["at", index: 1, input: "batfoocat", groups: undefined]
     str9.match(/at/g);
     // ["at", "at"]

   • i：忽略大小寫。

     let str10 = 'AabbccDD';
     str10.match(/a/gi); // ["A", "a"]
     str10.match(/a/g); // ["a"]
     str10.match(/A/g); // ["A"]

   • m：執行多行匹配，和^和$搭配起來使用。

     多行; 將開始和結束字元（^和$）視為在多行上工作（也就是，分別匹配每一行的開始和結束（由 \n 或 \r 分割），而不只是只匹配整個輸入字串的最開始和最末尾處。（mdn）

     `
     abc
     def
     `.match(/def/);
     // ["def", index: 5, input: "↵abc↵def↵", groups: undefined]
     
     `
     abc
     def
     `.match(/def/m);
     // ["def", index: 5, input: "↵abc↵def↵", groups: undefined]
     
     `
     abc
     def
     `.match(/^def$/);
     // null
     
     `
     abc
     def
     `.match(/^defc$/m);
     // ["def", index: 5, input: "↵abc↵def↵", groups: undefined]

   • u：Unicode 模式，可以正確處理碼點大於\uFFFF的 Unicode 字元。

     /\u{20BB7}/.test('