摘要：返回值是被找到的值。序列匹配，而則匹配。還有關(guān)于如何選擇一個(gè)這里的，轉(zhuǎn)換成文本后，只表示一個(gè)就是說這段待執(zhí)行文本內(nèi)含一個(gè)構(gòu)建正則思考一下創(chuàng)建正則的幾種方式并且多認(rèn)識一個(gè)正則方法匹配前面的子表達(dá)式一次或多次。和均為非負(fù)整數(shù)，其中。

通過 new 關(guān)鍵詞來定義 RegExp 對象。

test() 方法檢索字符串中的指定值。返回值是 true 或 false。

        var r = new RegExp("e");
        var str = "hello world!";
        alert(r.test(str))            // true

exec() 方法檢索字符串中的指定值。返回值是被找到的值。如果沒有發(fā)現(xiàn)匹配，則返回 null。

        var r = new RegExp("e");
        var str = "hello world!";
        alert(r.exec(str));            // "e"

這些是JS RegExp提供的一些方法，簡單介紹下；

        var reg = /is/;

這就是一個(gè)簡單的字面量正則賦值

例如， "n" 匹配字符 "n"。" " 匹配換行符。序列 "" 匹配 ""，而 "(" 則匹配 "("。

還有關(guān)于如何選擇一個(gè)？

        var str1 = "aaaAAA";            // 這里的，轉(zhuǎn)換成文本后，只表示一個(gè),就是說這段待執(zhí)行文本內(nèi)含一個(gè)
        console.log(str1);                // "aaaAAA"
        var r = new RegExp(//);         // 構(gòu)建正則
        console.log(str1.replace(r,"R")); // "aaaRAAA"

        var s = "ffffdffffdffffdd";
        
        var r = /d/;                // "Sffffdffffdffffd"
        var r1 = new RegExp("d");    // "Sffffdffffdffffd"
        var r2 = new RegExp(/d/);    // "Sffffdffffdffffd"
        var r3 = new RegExp("d");    // "Sffffdffffdffffd"
        
        var R = /d+/;                // "S"
        var R1 = new RegExp("d+")    // "S"
        var R2 = new RegExp(/d+/);    // "S"
        var R3 = new RegExp("d+"); // "S"
        //    console.log(s.replace(rX,"S"))

        var reg = /is/;
        var str = "He is a boy. This is a dog. Where is she?";
        console.log(
            str.replace(reg,"IS")
        );
        // "He IS a boy. This is a dog. Where is she?" 
        // 使用replace方法，將按照正則規(guī)則選擇到的字符串（... is ...）替換為"IS",但是我們發(fā)現(xiàn)只有第一句被替換

只有第一句被替換？引出我們的：

在一段字符串中，可能存在若干符合正則的選擇，不執(zhí)行全局g，只會選擇第一個(gè)，執(zhí)行全局g，所有符合的都會被選擇到。
另一種說法：global可選標(biāo)志，帶這個(gè)標(biāo)志表示替換將針對行中每個(gè)匹配的串進(jìn)行，否則則只替換行中第一個(gè)匹配串

   reg = /is/g;
   console.log(str.replace(reg,"IS"));     // "He IS a boy. This IS a dog. Where IS she?"

例如，zo* 能匹配 "z" 以及 "zoo"。* 等價(jià)于{0,}。

PS：.*連在一起就意味著任意數(shù)量的不包含換行的字符

        var str = "ffffdffffd
dfdf";
        console.log(str);        // "ffffdffffd 
                                 // dfdf"        這里文本排列錯(cuò)誤，但是知道里面存在一個(gè)換行符就對了
        var reg = /.*/;                    
        console.log(str.replace(reg,"X"));      // "X
                                                // dfdf"    選擇了換行符前面的任意字符（這里重復(fù)任意次）

這里要提到一個(gè)中括號：

        var str = "a1b2c3d4";
        
        var reg = /d/;                            // 選擇一個(gè)數(shù)字字符（而已）哪怕有更多選擇只選擇第一個(gè)遇到的
        console.log(str.replace(reg,"X"));        // "aXb2c3d4"
        reg = /d/g;                            // 在全局中，選擇數(shù)字字符，并返回多個(gè)（如果存在）符合規(guī)則的字串
        console.log(str.replace(reg,"X"));        // "aXbXcXdX"
        reg = /[a-z]d/g                        // 一個(gè)a-z任意字符和一個(gè)數(shù)字字符，并返回多個(gè)（如果存在）符合規(guī)則的字串
        console.log(str.replace(reg,"X"));        // "XXXX"
        reg = /[a-z]d/                            // 一個(gè)a-z任意字符和一個(gè)數(shù)字字符
        console.log(str.replace(reg,"X"));        // "Xb2c3d4"
        // D 匹配一個(gè)非數(shù)字字符，與d相反
        str = "123ABC"
        reg = /D/;
        console.log(str.replace(reg,"0"));        // "1230BC"
        reg = /D/g;                            // 一個(gè)非數(shù)字字符，并返回多個(gè)（如果存在）符合規(guī)則的字串
        console.log(str.replace(reg,"0"));        // "123000"
        reg = /D{3}/;                            // 三個(gè)連續(xù)的非數(shù)字字符
        console.log(str.replace(reg,"456"));    // "123456"
        
        // 區(qū)分大小寫
        str = "A1B2C3d4"
        reg = /[A-Z]/g;                            // 選擇A-Z大寫字母任意一個(gè)，并返回多個(gè)（如果存在）符合規(guī)則的字串
        console.log(str.replace(reg,"O"))        // "O1O2O3d4"
        reg = /[A-Z]d/;                        // 選擇A-Z大寫字母任意一個(gè)和一個(gè)數(shù)字
        console.log(str.replace(reg,"O"))        // "OB2C3d4"
        reg = /[A-Z]d/g;                        // 選擇A-Z大寫字母任意一個(gè)和一個(gè)數(shù)字，并返回多個(gè)（如果存在）符合規(guī)則的字串
        console.log(str.replace(reg,"O"))        // "OOOd4"

和大括號：

還有之前的：

以上5種在正則中被成為限定符，很好理解，限制匹配次數(shù)嘛

        var str = "A1234B123C123456";
        
        var reg = /d{4}/;                        // {4}之前的d重復(fù)匹配4次
        console.log(str.replace(reg,"&"));        // "A&B123C123456"
        reg = /d{6}/                            // 重復(fù)6次
        console.log(str.replace(reg,"&"));        // "A1234B123C&"
        reg = /[A-Z]d{6}/                        // 一個(gè)A-Z任意字母，和一個(gè)連續(xù)6個(gè)任意數(shù)字
        console.log(str.replace(reg,"&"))        // "A1234B123&"
        
        str = "000&1111&222222&55555555&";
        reg = /d{4,}/;                            // 一個(gè)數(shù)字，至少匹配4次
        console.log(str.replace(reg,"——"));        // "000&——&222222&55555555&"
        reg = /d{4,}/g;                        // （一個(gè)數(shù)字，至少匹配4次），并返回多個(gè)符合規(guī)則的匹配串
        console.log(str.replace(reg,"——"));        // "000&——&——&——&"
        reg = /d{4,6}/g;                        // (一個(gè)數(shù)字，至少4次，至多6次)
        console.log(str.replace(reg,"——"));        // "000&——&——&——55&"

        reg = /d?/g;                            // 等價(jià)于：{0,1}
        console.log(str.replace(reg,"？"));        //　"？？？？&？？？？？&？？？？？？？&？？？？？？？？？&？"

        reg = /d+/;                            // 等價(jià)于：{1,}
        console.log(str.replace(reg,"+"));        // "+&1111&222222&55555555&"
        reg = /d+/g;                            
        console.log(str.replace(reg,"+"));        // "+&+&+&+&"
        
        reg = /d*/g;
        console.log(str.replace(reg,"+"));        // "++&++&++&++&+"            

正則表達(dá)式30分鐘入門教程

正則表達(dá)式語言

正則表達(dá)式

正則表達(dá)式全部符號解釋