三道測試題：
1， var str=“ abbbbacc”;
var rs=str.replace(“a”,”0”);???
(A)0bbbbacc (B)0bbbb0cc
2，var str=“ abbbbacc”;
var rs=str.replace(“/a/”,”0”);???
(A)0bbbbacc (B)0bbbb0cc
3，var str=“ abbbbacc”;
var rs=str.replace(“/a/g”,”0”);???
(A)0bbbbacc (B)0bbbb0cc
附注：String對象的replace方法簽名為：
replace(regx,str)

一，概述

1，正則表達式，可以說是任何一種編程語言都提供的機制，它主要是提供了對字符串的處理能力。
2，正則表達式在頁面處理中的使用場景：
1）表單驗證。驗證某些域符合某種規則，例如郵件輸入框必須輸入的是郵件、聯系電話輸入框輸入的必須是數字等等
2）處理DOM模型。例如通過表達式定位DOM中的一個對象或一系列對象，一個例子就是定位id屬性中含有某個特殊字符的div對象。
3）純編程邏輯。直接用于編程的邏輯之中。
3，說明：本部分所舉的正則表達式的代碼片斷，都是經過測試的，但有一點需要注意，對于換行的字符串的定義，我們在表述時使用的是類似如下的形式：
var str=“It’s is
?a? beautiful city”；
這種形式直接寫在JS代碼中是錯誤的，那如何獲取具有換行的字符串呢？簡單的辦法：在textarea中輸入文本并換行，然后將該值賦給JS變量即可。例如：
var str=document.forms[0].mytextarea.value;???? ????

二，語法與使用

1，定義正則表達式

1）定義正則表達式有兩種形式，一種是普通方式，一種是構造函數方式。
2）普通方式：var reg=/表達式/附加參數
表達式：一個字符串，代表了某種規則，其中可以使用某些特殊字符，來代表特殊的規則，后面會詳細說明。
附加參數：用來擴展表達式的含義，目前主要有三個參數：
g：代表可以進行全局匹配。
i：代表不區分大小寫匹配。
m：代表可以進行多行匹配。
上面三個參數，可以任意組合，代表復合含義，當然也可以不加參數。
例子：
var reg=/a*b/;
var reg=/abc+f/g;
3）構造函數方式：var reg=new RegExp(“表達式”,”附加參數”);
其中“表達式”與“附加參數”的含義與上面那種定義方式中的含義相同。
例子：
var reg=new RegExp(“a*b”);
var reg=new RegExp(“abc+f”,”g”);
4）普通方式與構造函數方式的區別
普通方式中的表達式必須是一個常量字符串，而構造函數中的表達式可以是常量字符串，也可以是一個js變量，例如根據用戶的輸入來作為表達式參數等等：
var reg=new RegExp(document.forms[0].exprfiled.value,”g”);

2，表達式模式

1）表達式模式，是指表達式的表達方式與樣式， 即 var reg=/表達式/附加參數 中的“表達式”怎樣去描述？
2）從規范上講，表達式模式分為簡單模式和復合模式。
3）簡單模式：是指通過普通字符的組合來表達的模式，例如
var reg=/abc0d/;
可見簡單模式只能表示具體的匹配。
4）復合模式：是指含有通配符來表達的模式，例如：
var reg=/a+b?\w/;
其中的+、?和\w都屬于通配符，代表著特殊的含義。因此復合模式可以表達更為抽象化的邏輯。
下面我們著重說一下復合模式中各個通配符的含義及其使用。
5)復合模式中特殊字符的講解：

1>\：在許多編程語言里面被用作轉義符，一般來說
\符號后面如果跟的是普通字符c，那么\c就代表特殊的含義，例如n本來代表字符n，但\n就代表換行。
\符號后面如果跟的是特殊字符c，那么\c就代表普通字符c，例如\一般用作轉義符，但\\則調表普通字符\。
Javascript的正則表達式中\的用法與上面相同，只是不同的編程語言，特殊字符表可能不太一樣罷了。

2>^：匹配輸入字符串的起始端，如果是多行匹配，即表達式的附加參數中含有m，則也在一個換行符后匹配。
例子：/^B/匹配 “Bab Bc ”中的第一個B
例子2：/^B/gm匹配
????????? “Badd B
????????? cdaf
????????? B dsfB”
????????? 中的第一行第一個B，第三行中的第一個B
?????????
3>$：匹配輸入字符創的尾端，如果是多行匹配，即表達式的附加參數中含有m，則也在一個換行符前匹配。
與^的用法相反。
例子：/t$/匹配“bat”中的t，但是不匹配“hate”中的t
例子2：/t$/匹配
“tag at
bat”
中第一行的最后一個t和第二行的t。

4>*：匹配前一個字符0次或多次。
例子：/ab*/匹配“dddabbbbc”中的“abbbb”，也匹配“ddda”中的“a”

5>+：匹配前一個字符1次或多次。
例子：/ab+/匹配“dddabbbbc”中的“abbbb”，但不匹配“ddda”
與后面的{1,}（原型：{n,}）的用法類似

6>?：?的用法比較特殊，一般來說它用來對前一個字符做0次或1次匹配，但是它有另外兩種特殊的用法：
如果緊跟在*、+、?和{ }之后，則表示原始匹配的最小次數匹配，例如：
/ba*/本來匹配“bbbaaaa”中的“baaaa”，但是/ba*?/則匹配“bbbaaaa”中的“b”（因為*表示0次或多次匹配，而加?應該表示最少次數匹配，即0次匹配）。
同理：/ba+?/則匹配“baaaa”中的“ba”。
作為語法結構符號，使用于前置斷言中，即后面要說到的x(?=y)和x(?!=y)

7>.：小數點中的“.”號，匹配任何一個單獨的字符，但是換行符除外。
標準中總共有哪些字符？請參考：字符集
例如：/a.b/匹配“acbaa”中的“acb”，但是不匹配“abbb”。

8>(x)：表示匹配x(并非特指字符x或者特指一個字符，x表示一個字符串)，而且匹配會被記住，在語法中這種()被稱為“capturing parentheses ”，即捕捉用的小括號。
匹配會被記住，是因為在表達式提供的函數中，有些函數返回一個數組，該數組會保存所匹配的所有字符串，例如exec()函數。
另外還要注意()中的x被記住的前提是匹配x。
例子1：
var regx=/a(b)c/;
var rs=regx.exec(“abcddd”);
從上面可以看出,/a(b)c/匹配“abcddd”中的“abc”，因為()的原因，b也會記錄下來，因此rs返回的數字內容為：
{abc,b}
例子2：
?var regx=/a(b)c/;
?var rs=regx.exec(“acbcddd”);
?rs返回null，因為/a(b)c/不匹配“acbcddd”，所以()中的b不會被記錄下來（盡管字符串中含有b）
?
9>(?:x)：匹配x，但不會記住x，這種格式中的()被稱為“non-capturing parentheses ”，即非捕捉用的小括號。
例子：
var regx=/a(?:b)c/;
var rs=regx.exec(“abcddd”);
從上面可以看出,/a(?:b)c/匹配“abcddd”中的“abc”，因為(?:)的原因，b不會記錄下來，因此rs返回的數字內容為：
{abc}

10>X(?=y)：匹配x，僅當后面緊跟著y時。如果符合匹配，則只有x會被記住，y不會被記住。
例子：
var regx=/user(?=name)/;
var rs=regx.exec(“The username is Mary”);
結果：匹配成功，而且rs的值為{user}

11>X(?!y)：匹配x，僅當后面不緊跟著y時。如果符合匹配，則只有x會被記住，y不會被記住。
例子：
var regx=/user(?!name)/;
var rs=regx.exec(“The user name is Mary”);
結果：匹配成功，而且rs的值為{user}
例子2：
var regx=/\d+(?!\.)/;
var rs=regx.exec(“54.235”);
結果：匹配成果，rs的值為{5}，不匹配54是因為54后面跟著“.”號，當然235也匹配，但是由于exec方法的行為，235不會被返回

12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只記住x。
例子：
var regx=/beijing|shanghai/;
var rs=regx.exec(“I love beijing and shanghai”);
結果：匹配成功，rs的值為{beijing}，雖然shanghai也匹配，但不會被記住。

13>{n}：匹配前一個字符的n次出現。
n必須是一個非負數，當然如果是一個負數或小數也不會報語法錯誤。
例子：
var regx=/ab{2}c/;
var rs=regx.exec(“abbcd”);
結果：匹配成功，rs的值為：{abbc}。

14>{n,}：匹配前一個字符的至少n次出現。
例子：
var regx=/ab{2,}c/;
var rs=regx.exec(“abbcdabbbc”);
結果：匹配成功，rs的值為：{abbc}。注意為什么abbbc也符合條件為什么沒有被記住，這與exec方法的行為有關，后面會統一講解。

15>{n,m}：匹配前一個字符的至少n次最多m次的出現。
只要n與m為數字，而且m>=n就不會報語法錯誤。
例子：
var regx=/ab{2,5}c/;
var rs=regx.exec(“abbbcd”);
結果：匹配成功，rs的值為：{abbbc}。
例子2：
var regx=/ab{2,2}c/;
var rs=regx.exec(“abbcd”);
結果：匹配成功，rs的值為：{abbc}。
例子3：
var regx=/ab(2,5)/;
var rs=regx.exec(“abbbbbbbbbb”);
結果：匹配成功，rs的值為：{abbbbb}，這說明，如果前一個字符出現多于m次，則只匹配m次。另外：
var regx=/ab(2,5)c/;
var rs=regx.exec(“abbbbbbbbbbc”);
結果：匹配失敗，rs的值為：null，為什么匹配失敗，因為b多于5個則b(2,5)會匹配前5個b，，而表達式/ab(2,5)c/中b后面是c，但字符串中5個b之后還是b所以會報錯。

16>[xyz]：xyz表示一個字符串，該模式表示匹配[]中的一個字符，形式上[xyz]等同于[x-z]。
例子：
var regx=/a[bc]d/;
var rs=regx.exec(“abddgg”);
結果：匹配成功，rs的值為：{abd}
例子2：
var regx=/a[bc]d/;
var rs=regx.exec(“abcd”);
結果：匹配失敗，rs的值為：null，之所以失敗，是因為[bc]表示匹配b或c中的一個，但不會同時匹配。

17>[^xyz]：該模式表示匹配非[]中的一個字符，形式上[^xyz]等同于[^x-z]。
例子：
var regx=/a[^bc]d/;
var rs=regx.exec(“afddgg”);
結果：匹配成功，rs的值為：{afd}
例子2：
var regx=/a[^bc]d/;
var rs=regx.exec(“abd”);
結果：匹配失敗，rs的值為：。

18>[\b]：匹配退格鍵。

19>\b：匹配一個詞的邊界符，例如空格和換行符等等，當然匹配換行符時，表達式應該附加參數m。
例子：
var regx=/\bc./;
var rs=regx.exec(“Beijing is a beautiful city”);
結果：匹配成功，rs的值為：{ci}，注意c前邊的空格不會匹配到結果中，即{ ci}是不正確的。

20>\B：代表一個非單詞邊界。
例子：
var regx=/\Bi./;
var rs=regx.exec(“Beijing is a beautiful city”);
結果：匹配成功，rs的值為：{ij}，即匹配了Beijing中的ij。

21>\cX，匹配一個控制字符。例如， \cM 匹配一個 Control-M 或
回車符。 x 的值必須為 A-Z 或 a-z 之一。否則，將 c 視為一
個原義的 ’c’ 字符。（實際的例子還需補充）

21>\d：匹配一個數字字符，等同于[0-9]。
例子：
var regx=/user\d/;
var rs=regx.exec(“user1”);
結果：匹配成功，rs的值為：{user1}

22>\D：匹配一個非數字字符，等同于[^0-9]。
例子：
var regx=/user\D/;
var rs=regx.exec(“userA”);
結果：匹配成功，rs的值為：{userA}

23>\f：匹配一個換頁符。

24>\n：匹配一個換行符。因為是換行符，所以在表達式中要加入m參數。
例子：
var regx=/a\nbc/m;
?????? var str=“a
?????????????? bc”;
?????? var rs=regx.exec(str);
?????? 結果：匹配成功，rs的值為：{? }，如果表達式為/a\n\rbc/，則不會被匹配，因此在一般的編輯器中一個”Enter”鍵代表著“回車換行”，而非“換行回車”，至少在textarea域中是這樣的。??????
25>\r：匹配一個回車符

26>\s：匹配一個空格符，等同于[ \f\n\r\t\v\u00A0\u2028\u2029].
例子：
var regx=/\si/;
var rs=regx.exec(“Beijing is a city”);
結果：匹配成功，rs的值為：{ i}

27>\S：匹配一個非空格符，等同于[ ^\f\n\r\t\v\u00A0\u2028\u2029].
例子：
var regx=/\Si/;
var rs=regx.exec(“Beijing is a city”);
結果：匹配成功，rs的值為：{ei}

28>\t：匹配一個tab
例子：
var regx=/a\tb/;
var rs=regx.exec(“a?bc”);
結果：匹配成功，rs的值為： {a?????? bc}

29>\v：匹配一個豎向的tab

30>\w：匹配一個數字、_或字母表字符，即[A-Za-z0-9_ ]。
例子：
var regx=/\w/;
var rs=regx.exec(“$25.23”);
結果：匹配成功，rs的值為：{2}

31>\W：匹配一個非數字、_或字母表字符，即[^A-Za-z0-9_ ]。
例子：
var regx=/\w/;
var rs=regx.exec(“$25.23”);
結果：匹配成功，rs的值為：{$}

32>\n：注意不是\n，這里n是一個正整數，表示匹配第n個()中的字符。
例子：
var regx=/user([,-])group\1role/;
var rs=regx.exec(“user-group-role”);
結果：匹配成功，rs的值為：{user-group-role,-}，同樣對user,group,role的匹配也是成功的，但像user-group,role等就不對了。

33>\0：匹配一個NUL字符。

34>\xhh：匹配一個由兩位16進制數字所表達的字符。

35>\uhhhh：匹配一個由四位16進制數字所表達的字符。

3，表達式操作

1）表達式操作，在這里是指和表達式相關的方法，我們將介紹六個方法。
2）表達式對象（RegExp）方法：

1>exec(str)，返回str中與表達式相匹配的第一個字符串，而且以數組的形式表現，當然如果表達式中含有捕捉用的小括號，則返回的數組中也可能含有()中的匹配字符串，例如：
var regx=/\d+/;
var rs=regx.exec(“3432ddf53”);
返回的rs值為：{3432}
var regx2=new RegExp(“ab(\d+)c”);
var rs2=regx2.exec(“ab234c44”);
返回的rs值為：{ab234c,234}
另外，如果有多個合適的匹配，則第一次執行exec返回一個第一個匹配，此時繼續執行exec，則依次返回第二個第三個匹配。例如：
var regx=/user\d/g;
var rs=regx.exec(“ddduser1dsfuser2dd”);
var rs1=regx.exec(“ddduser1dsfuser2dd”);
則rs的值為{user1}，rs的值為{rs2}，當然注意regx中的g參數是必須的，否則無論exec執行多少次，都返回第一個匹配。后面還有相關內容涉及到對此想象的解釋。

2>test(str)，判斷字符串str是否匹配表達式，返回一個布爾值。例如：
var regx=/user\d+/g;
var flag=regx.test(“user12dd”);
flag的值為true。

3）String對象方法

1>match(expr)，返回與expr相匹配的一個字符串數組，如果沒有加參數g，則返回第一個匹配，加入參數g則返回所有的匹配
例子：
var regx=/user\d/g;
var str=“user13userddduser345”;
var rs=str.match(regx);
rs的值為：{user1,user3}

2>search(expr)，返回字符串中與expr相匹配的第一個匹配的index值。
例子：
var regx=/user\d/g;
var str=“user13userddduser345”;
var rs=str.search(regx);
rs的值為：0

3>replace(expr,str)，將字符串中匹配expr的部分替換為str。另外在replace方法中，str中可以含有一種變量符號$，格式為$n，代表匹配中被記住的第n的匹配字符串（注意小括號可以記憶匹配）。
例子：
var regx=/user\d/g;
var str=“user13userddduser345”;
var rs=str.replace(regx,”00”);
rs的值為：003userddd0045
例子2：
var regx=/u(se)r\d/g;
var str=“user13userddduser345”;
var rs=str.replace(regx,”$1”);
rs的值為：se3userdddse45
對于replace(expr,str)方法還要特別注意一點，如果expr是一個表達式對象則會進行全局替換（此時表達式必須附加參數g，否則也只是替換第一個匹配），如果expr是一個字符串對象，則只會替換第一個匹配的部分，例如：
var regx=“user”
var str=“user13userddduser345”;
var rs=str.replace(regx,”00”);
rs的值為： 0013userddduser345

4>split(expr)，將字符串以匹配expr的部分做分割，返回一個數組，而且表達式是否附加參數g都沒有關系，結果是一樣的。
例子：
var regx=/user\d/g;
var str=“user13userddduser345”;
var rs=str.split(regx);
rs的值為：{3userddd,45}

4，表達式相關屬性

1）表達式相關屬性，是指和表達式相關的屬性，如下面的形式：
var regx=/myexpr/;
var rs=regx.exec(str);
其中，和表達式自身regx相關的屬性有兩個，和表達式匹配結果rs相關的屬性有三個，下面將逐一介紹。
2）和表達式自身相關的兩個屬性：

1>lastIndex，返回開始下一個匹配的位置，注意必須是全局匹配（表達式中帶有g參數）時，lastIndex才會有不斷返回下一個匹配值，否則該值為總是返回第一個下一個匹配位置，例如：
var regx=/user\d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var lastIndex1=regx.lastIndex;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var lastIndex2=regx.lastIndex;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var lastIndex3=regx.lastIndex;
上面lastIndex1為9，第二個lastIndex2也為9，第三個也是9；如果regx=/user\d/g，則第一個為9，第二個為18，第三個為0。

2>source，返回表達式字符串自身。例如：
var regx=/user\d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var source=regx.source;
source的值為user\d
3）和匹配結果相關的三個屬性：

1>index，返回當前匹配的位置。例如：
var regx=/user\d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var index1=rs.index;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var index2=rs.index;
rs=regx.exec(“sdsfuser1dfsfuser2”);
var index3=rs.index;
index1為4，index2為4，index3為4，如果表達式加入參數g，則index1為4，index2為13，index3會報錯（index為空或不是對象）。

2>input，用于匹配的字符串。例如：
var regx=/user\d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var input=rs.input;
input的值為sdsfuser1dfsfuser2。

3>[0]，返回匹配結果中的第一個匹配值，對于match而言可能返回一個多值的數字，則除了[0]外，還可以取[1]、[2]等等。例如：
var regx=/user\d/;
var rs=regx.exec(“sdsfuser1dfsfuser2”);
var value1=rs[0];
rs=regx.exec(“sdsfuser1dfsfuser2”);
var value2=rs[0];
value1的值為user1,value2的值為user2

5，實際應用

1）實際應用一
描述：有一表單，其中有一個“用戶名”input域
要求：漢字，而且不能少于2個漢字，不能多于4個漢字。
實現：
<script>
function checkForm(obj){
???? var username=obj.username.value;
???? var regx=/^[\u4e00-\u9fa5]{2,4}$/g
???? if(!regx.test(username)){
?????????????? alert(“Invalid username!”);
?????????????? return false;
???? }
???? return true;
}
</script>
<form name=“myForm”onSubmit=“return checkForm(this)”>
??? <input type=“text” name=“username”/>
??? <input type=“submit” vlaue=“submit”/>
</form>
2）實際應用二
描述：給定一個含有html標記的字符串，要求將其中的html標記去掉。
實現：
<script>
function toPlainText(htmlStr){
???? var regx=/<[^>]*>|<\/[^>]*>/gm;
???? var str=htmlStr.replace(regx,"");
???? return str;
}
</script>
<form name=“myForm”>
??? <textarea id=“htmlInput”></textarea>
??? <input type=“button” value=“submit” onclick=“toPlainText(document.getElementById(‘htmlInput’).value”/>
</form>

三，小結

1，Javascript正則表達式，我想在一般的程序員之中，使用者應該不是很多，因為我們處理的頁面一般都不是很復雜，而復雜的邏輯一般我們都在后臺處理完成了。但是目前趨勢已經出現了扭轉，富客戶端已經被越來越多的人接受，而Javascript就是其中的關鍵技術，對于復雜的客戶端邏輯而言，正則表達式的作用也是很關鍵的，同時它也是Javascript高手必須要掌握的重要技術之一。?

2，為了能夠便于大家對前面講述的內容有一個更為綜合和深刻的認識，我將前面的一些關鍵點和容易犯糊涂的地方再系統總結一下，這部分很關鍵！
總結1：附件參數g的用法
表達式加上參數g之后，表明可以進行全局匹配，注意這里“可以”的含義。我們詳細敘述：
1）對于表達式對象的exec方法，不加入g，則只返回第一個匹配，無論執行多少次均是如此，如果加入g，則第一次執行也返回第一個匹配，再執行返回第二個匹配，依次類推。例如
var regx=/user\d/;
var str=“user18dsdfuser2dsfsd”;
var rs=regx.exec(str);//此時rs的值為{user1}
var rs2=regx.exec(str);//此時rs的值依然為{user1}
如果regx=/user\d/g；則rs的值為{user1}，rs2的值為{user2}
通過這個例子說明：對于exec方法，表達式加入了g，并不是說執行exec方法就可以返回所有的匹配，而是說加入了g之后，我可以通過某種方式得到所有的匹配，這里的“方式”對于exec而言，就是依次執行這個方法即可。
2）對于表達式對象的test方法，加入g于不加上g沒有什么區別。
3）對于String對象的match方法，不加入g，也只是返回第一個匹配，一直執行match方法也總是返回第一個匹配，加入g，則一次返回所有的匹配（注意這與表達式對象的exec方法不同，對于exec而言，表達式即使加上了g，也不會一次返回所有的匹配）。例如：
var regx=/user\d/;
var str=“user1sdfsffuser2dfsdf”;
var rs=str.match(regx);//此時rs的值為{user1}
var rs2=str.match(regx);//此時rs的值依然為{user1}
如果regx=/user\d/g，則rs的值為{user1,user2}，rs2的值也為{user1,user2}
4）對于String對象的replace方法，表達式不加入g，則只替換第一個匹配，如果加入g，則替換所有匹配。（開頭的三道測試題能很好的說明這一點）
5）對于String對象的split方法，加上g與不加g是一樣的，即：
var sep=/user\d/;
var array=“user1dfsfuser2dfsf”.split(sep);
則array的值為{dfsf, dfsf}
此時sep=/user\d/g，返回值是一樣的。
6）對于String對象的search方法，加不加g也是一樣的。
總結2：附加參數m的用法
附加參數m，表明可以進行多行匹配，但是這個只有當使用^和$模式時才會起作用，在其他的模式中，加不加入m都可以進行多行匹配（其實說多行的字符串也是一個普通字符串），我們舉例說明這一點
1）使用^的例子
var regx=/^b./g;
var str=“bd76 dfsdf
???????? sdfsdfs dffs
???????? b76dsf? sdfsdf”;
var rs=str.match(regx);
此時加入g和不加入g，都只返回第一個匹配{bd}，如果regx=/^b./gm，則返回所有的匹配{bd,b7}，注意如果regx=/^b./m，則也只返回第一個匹配。所以，加入m表明可以進行多行匹配，加入g表明可以進行全局匹配，綜合到一起就是可以進行多行全局匹配
2）使用其他模式的例子，例如
var regx=/user\d/;
var str=“sdfsfsdfsdf
???????? sdfsuser3 dffs
???????? b76dsf? user6”;
var rs=str.match(regx);
此時不加參數g，則返回{user3}，加入參數g返回{user3,user6}，加不加入m對此沒有影響。
3）因此對于m我們要清楚它的使用，記住它只對^和$模式起作用，在這兩種模式中，m的作用為：如果不加入m，則只能在第一行進行匹配，如果加入m則可以在所有的行進行匹配。我們再看一個^的例子
var regx=/^b./;
var str=“ret76 dfsdf
???????? bjfsdfs dffs
???????? b76dsf? sdfsdf”;
var rs=str.match(regx);
此時rs的值為null，如果加入g，rs的值仍然為null，如果加入m，則rs的值為{bj}（也就是說，在第一行沒有找到匹配，因為有參數m，所以可以繼續去下面的行去找是否有匹配），如果m和g都加上，則返回{bj,b7}（只加m不加g說明，可以去多行進行匹配，但是找到一個匹配后就返回，加入g 表明將多行中所有的匹配返回，當然對于match方法是如此，對于exec呢，則需要執行多次才能依次返回）
總結3：在HTML的textarea輸入域中，按一個Enter鍵，對應的控制字符為“\r\n”，即“回車換行”，而不是“\n\r”，即“換行回車”，我們看一個前面我們舉過的例子：
var regx=/a\r\nbc/;
var str=“a
???????? bc”;
var rs=regx.exec(str);
結果：匹配成功，rs的值為：{????? }，如果表達式為/a\n\rbc/，則不會被匹配，因此在一般的編輯器中一個”Enter”鍵代表著“回車換行”，而非“換行回車”，至少在textarea域中是這樣的。

四，應用案例

1，正則表達式使用場景：
1）登錄場景，檢查用戶輸入的用戶名，要求：
字符長度在6到18之間
字符必須為字母、數字或者下劃線的組合
2）購物場景，對于商品列表的描述（標簽、條形碼、單價）等有些用戶可能會提出下面需求：
希望可以對商品列表的某一列描述進行字號的自定義，而且下次登錄仍然保持用戶的修改