最近利用一周时间阅读了《精通正则表达式（第3版）》前6章，希望能够精通正则表达式，并且能够撰写《javascript深度理解正则表达式》这样的文章。一周时间太短，我自认为仅仅是达到了“不再畏惧”、“更有信心”的程度，因而本文的目标只能是帮助读者“掌握”正则表达式。

我想正则表达式之所以难，主要体现在以下几个方面：
1）正则表达式的符号晦涩难懂
2）不支持排版（至少javascript目前还不支持）
3）不能设置断点，不能跟踪调试
4）没有真正的标准，不同工具所支持的正则表达式有许多细节上的差异

下文中如涉及正则表达式符号含义不明，请参阅<<javascript正则表达式入门笔记（完整版）>>

正则表达式本质上是一整套的处理字符串的模型，帮助人们利用简短的表达式来实现复杂的算法。早期的正则表达式引擎只有三百多行代码，发展到后来也不到1万行代码。打一个不恰当的比喻，利用正则表达式处理字符串，就像是利用SQL处理数据。正如我们在处理数据时要避免使用复杂SQL，我们在处理字符串时也应当避免使用复杂的正则表达式。下面是一段判断IP地址合法性的代码，比单纯用正则表达式要简单：

1. var isIPAdress = function(IPStr){  
2.     var pttrn = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;  
3.     var IPObj = pttrn.exec(IPStr);  
4.     var bool_result = false;  
5.     if(IPObj){  
6.         //添加进一步的识别规则  
7.         if(IPStr==="0.0.0.0"){  
8.             bool_result = false;  
9.         }else if(IPStr==="1.1.1.1"){  
10.             bool_result = false;  
11.         }else if(IPObj[1]>=0 && IPObj[1]<=255 && IPObj[2]>=0 && IPObj[2]<=255 && IPObj[3]>=0 && IPObj[3]<=255 && IPObj[4]>=0 && IPObj[4]<=255){  
12.             bool_result = true;  
13.         }else{  
14.             bool_result = false;  
15.         }  
16.     }  
17.  
18.     return bool_result;  
19. } 

   调试信息: 
    isIPAdress("10.1.6.255")    true
    isIPAdress("1.1.1.1")    false
    isIPAdress("10.1.a.255")    false

浅议正则表达式的执行效率

执行下面这个javascript的正则表达式，比较ie/safari/firefox/chrome的执行效率，发现safari和firefox首次打开时较慢但是再刷新可做到瞬间完成，chrome和ie则是每次打开和刷新都慢，这说明javascript在ie和chrome上还是完全基于NFA算法做优化，safari和firefox则可能用到了DFA算法（也可能是缓存）。

1. var p1 = /X(?:.+)+X/;  
2. iJs.put(p1.exec("=XX==========================")); 

正则表达式对象：exec方法：

如果正则表达式使用了g作为后缀，则会记住上次执行的结果，执行时会找后面匹配。

如果正则表达式没有使用g作为后缀，则每次执行的结果相同，都是取第一个匹配上的。如果使用了捕获型括号，则匹配结果可通过1/2/3/...后缀获得，参见前面给出的判断IP地址合法性的代码。

1. var pttrn = /bb/;  
2. iJs.showObject(pttrn.exec("abaabbaaa"));  
3. iJs.showObject(pttrn.exec("abaabbaaa"));  
4. pttrn = /a+/g;  
5. iJs.showObject(pttrn.exec("abaabbaaa"));  
6. iJs.showObject(pttrn.exec("abaabbaaa")); 

调试信息:    

    [Object] bb
        |--[string] 0 ------------- bb
        |--[number] index ------------- 4
        |--[string] input ------------- abaabbaaa
        |--[number] lastIndex ------------- 6
    
    [Object] bb
        |--[string] 0 ------------- bb
        |--[number] index ------------- 4
        |--[string] input ------------- abaabbaaa
        |--[number] lastIndex ------------- 6
    
    [Object] a
        |--[string] 0 ------------- a
        |--[number] index ------------- 0
        |--[string] input ------------- abaabbaaa
        |--[number] lastIndex ------------- 1
    
    [Object] aa
        |--[string] 0 ------------- aa
        |--[number] index ------------- 2
        |--[string] input ------------- abaabbaaa
        |--[number] lastIndex ------------- 4

正则表达式对象：test方法

返回true或false

 调试信息: 
    pttrn.test("abaabbaaa")    true
    pttrn.test("ababab")    false

字符串对象：match方法

match方法返回一个对象，需注意如果正则表达式使用了后缀g，则捕获型括号会失效。

1. var pttrn = /a(b)+/;  
2. var pttrn_g = /a(b)+/g;  
3. var myStr = "abaabbaaa";  
4. var matchObj = myStr.match(pttrn);//捕获b  
5. var matchObj_g = myStr.match(pttrn_g); //捕获失效 
6.  
7. iJs.pt("pttrn");  
8. iJs.pt("pttrn_g");  
9. iJs.pt("myStr");  
10. iJs.showObject("matchObj");  
11. iJs.showObject("matchObj_g"); 

 调试信息: 
    pttrn    /a(b)+/
    pttrn_g    /a(b)+/g
    myStr    abaabbaaa
    
    [Object] matchObj
        |--[string] 0 ------------- ab
        |--[string] 1 ------------- b
        |--[number] index ------------- 0
        |--[string] input ------------- abaabbaaa
        |--[number] lastIndex ------------- 2
    
    [Object] matchObj_g
        |--[string] 0 ------------- ab
        |--[string] 1 ------------- abb
        |--[number] index ------------- 3
        |--[string] input ------------- abaabbaaa
        |--[number] lastIndex ------------- 6

字符串对象：replace方法

1. var myStr = "abaabbaaabbb";  
2. var searchValue = "a";  
3. var searchRegExp = /a+/;  
4. var searchRegExp_g = /a+/g;  
5. var replaceValue = "X";  
6. iJs.pt("myStr");  
7. iJs.pt("searchValue");  
8. iJs.pt("replaceValue");  
9. iJs.pt("myStr.replace(searchValue,replaceValue)");  
10. iJs.put("");  
11.  
12. iJs.pt("myStr");  
13. iJs.pt("searchRegExp");  
14. iJs.pt("replaceValue");  
15. iJs.pt("myStr.replace(searchRegExp,replaceValue)");  
16. iJs.put("");  
17.  
18. iJs.pt("myStr");  
19. iJs.pt("searchRegExp_g");  
20. iJs.pt("replaceValue");  
21. iJs.pt("myStr.replace(searchRegExp_g,replaceValue)");  
22. iJs.put("");  
23.  
24. var myStr_f = "a2aa22aaa222________";  
25. var searchRegExp_g2 = /(a+)2/g;  
26. var args;//全局变量便于iJs1捕获对象  
27. var replaceFunction = function(a,b){  
28.     var slice = Array.prototype.slice;  
29.     args = slice.apply(arguments);  
30.     iJs1.showObject("args");  
31.     return args[0]+"+";  
32. };  
33. iJs.pt("myStr_f.replace(searchRegExp_g2,replaceFunction)"); 

 调试信息: 
    myStr    abaabbaaabbb
    searchValue    a
    replaceValue    X
    myStr.replace(searchValue,replaceValue)    Xbaabbaaabbb
    
    myStr    abaabbaaabbb
    searchRegExp    /a+/
    replaceValue    X
    myStr.replace(searchRegExp,replaceValue)    Xbaabbaaabbb
    
    myStr    abaabbaaabbb
    searchRegExp_g    /a+/g
    replaceValue    X
    myStr.replace(searchRegExp_g,replaceValue)    XbXbbXbbb
    
    myStr_f.replace(searchRegExp_g2,replaceFunction)    a2+aa2+2aaa2+22________

字符串对象：search方法

search方法和indexOf方法类似，但是接受的是正则表达式对象，如果能够匹配，则返回首次匹配的首字符位置，如果不能匹配，则返回-1。此方法会忽略g标志。

1. var myStr = "abaabbaaabbb";  
2. var searchRegExp1 = /aaa/;  
3. iJs.pt("myStr.search(searchRegExp1)");  
4. var searchRegExp2 = /aXa/;  
5. iJs.pt("myStr.search(searchRegExp2)"); 

调试信息: 
    myStr.search(searchRegExp1)    6
    myStr.search(searchRegExp2)    -1

 本文转自 hexiaini235 51CTO博客，原文链接：http://blog.51cto.com/idata/1113805，如需转载请自行联系原作者