js正規表示式基本語法學習

hndjknnjsnjd發表於2018-08-01
JS

  最近在處理字串時候莫名的被正規表示式按在地上一頓摩擦，決定好好補一補以前欠下的正則債。

查了查百度百科發現正規表示式在不同語言的支援方法語法略有不同，於是打算在js裡面試試深淺
            
            var  str = "hello world";

  • 1、在js中要引用正規表示式，則需要：/正規表示式/
  • 2、普通匹配符：能匹配 與之對應的字元。
            var  r = str.match(/o/);  //  js 中區分大小寫
            var R = str.match(/O/);   // null
            console.log(r);  //匹配的結果以陣列的方式展示

 

 

  • 3、預設正則區分大小寫

            console.log(R);   //  沒匹配成功則返回null    
            

  • 4、正則標記符 (引數) ： i,g ,m    i不區分大小寫 

            i ：不區分大小寫
            g ：全域性匹配
            m ：多行匹配
            

            var str4 =  "java jjjj   java ";
            var r4 = str4.match(/JAVA/i);
            console.log(r4);                                   //不區分大小寫匹配
            
            var r4 = str4.match(/JAVa/img);
            console.log(r4);                                   //多行匹配  併購且不區分大小寫
            

 

  •     5、 能夠匹配多個字元中的一個匹配符 、無空格

            \d :0~9
             \w : 字母、數字、下劃線 
             . 匹配 除換行的所有字元（\d   \w .   都只能匹配一個）      
            

            var str3 = "hello 2018";
            var r5 = str3.match(/\d/g);                              //全域性匹配數字
            console.log(r5);                                              // 匹配9個結果  
            
            r5 = str3.match(/\w\d/g);                                 //  全域性查詢 每個字元既要滿足\w\d  所以 公共匹配部分為    20 , 18
            
            console.log(r5);                                               //數字，字母匹配  20 , 18
            
            
            r5= str3.match(/\w.\d/g);   
            
            console.log(r5);                                                // o 2 , 018
            
            
            


            

  •     6、 能夠自定義規則的匹配符 []   [^] 代表取反
            
            str = "128";    //匹配手機號
            
            r6 = str.match(/1[345678]\d/);                        //[345678]代表匹配第二個數字   只能一個一個字元進行匹配
            
            console.log(r6);  //null
            
            str = "1，8";
            r6 = str.match(/1[3，4，5，6，7，8]\d/);     //[,] 也代表一個字元
            
            console.log(r6);    //1,8
            
            
            str = "1s8";
            r6 = str.match(/1[^32]\d/);                               //[^] 匹配除過32以外的所有字元   特殊符號也可以成功匹配
            console.log(r6);                                              //1s8
            
            str = "1&8";
            r6 = str.match(/1[^32]\d/);                               //[^] 匹配除過32以外的所有字元   特殊符號也可以成功匹配
            console.log(r6);                                              //1&8
            
            
            str = "1&ss8";
            r6 = str.match(/1[^32]\d/);                                //[^] 匹配除過32以外的所有字元   特殊符號也可以成功匹配
            console.log(r6);                                               //null     只能匹配三個字元，第三個字元匹配不滿足  返回null
            


            
            

  •          8 、 用來修飾匹配次數的匹配符  {n} :代表前面的匹配符出現n次 

            

            
            str = "13833344341";
            r8 = str.match(/1[345678]\d{9}/);                     //從第三個開始後面匹配9次
            console.log(r8);    
            


        
           {n,m}   出現的次數是n-m之間   {n,}  n - max   n到無限次    {,n} min-n  
 

            str = "13833344341";
            r8 = str.match(/1[345678]\d{3,11}/);                      //從第三個開始後面匹配9次
            console.log(r8);                                                     //null     只能匹配三個字元，第三個字元匹配不滿足  返回null
            
            
            str = "138333443412222";
            r8 = str.match(/1[345678]\d{3,}/);                        //從第三個開始後面匹配多次匹配成功但是不完全匹配 ，不符合手機號格式
            console.log(r8);                                                   //138333443412222


            str = "138122";
            r8 = str.match(/1[345678]\d{,9}/);                       //從第三個開始後面匹配多次 匹配成功但是不完全匹配 ，不符合手機號格式
            console.log(r8);                                                  //138333443412222

             +  : 1~max次

            

 

            str = "138122";
            r8 = str.match(/1[345678]\d+/);                         //從第三個開始， 最少匹配一次 ，後面匹配多次
            console.log(r8);                                                 //138122
            
            str = "13";
            r8 = str.match(/1[345678]\d+/);                           //+ 最少匹配一次  第三位沒有  返回null
            console.log(r8);    // null
            
              ? : 0~1次
             r8 = str.match(/1[345678]\d?/);                          //+ 最多匹配一次  第三位沒有 
             console.log(r8);                                                  // 13
             
             str = "1322222";
             r8 = str.match(/1[345678]\d?/);                            //+ 最多匹配一次  第4位沒有   只返回前三位
             console.log(r8);                                                    // 132
             
             
             str = "1322222";
            r8 = str.match(/1[345678]\d+/);                            //+ 最少匹配一次  
            console.log(r8);                                                    // 1322222


             
              * : 0~max次

              str = "1322222";
             r8 = str.match(/1[345678]\d*/);    //+ 最少匹配0次 
             console.log(r8);    // 1322222
            
              str = "13";
             r8 = str.match(/1[345678]\d*/);    //+ 最少匹配0次 
             console.log(r8);    // 13
            

 

  • 9 基於正規表示式的完整匹配 和特殊符號
            
            str = "t13888899900";
             r9 = str.match(/1[345678]\d{9}/);                             //匹配成功，但開頭格式不對
             console.log(r9);                                                      // 13888899900
            


             ^ 表示開始匹配                 [^] 表示取反      
 

             str = "t13888899900";
             r9 = str.match(/^1[345678]\d{9}/);                            //匹配失敗，從開頭開始匹配
             console.log(r9);                                                         // null
            
             str = "13888899900";
             r9 = str.match(/^1[345678]\d{9}/);                            //匹配成功
             console.log(r9);                                                        //13888899900
            
             
             str = "1388889990000999";
             r9 = str.match(/^1[345678]\d{9}/);                           //匹配成功  但是長度不對 
             console.log(r9);                                                      //1388889990000999       
             
             
             


            
             $ 持續匹配到結束
 

            
             str = "1388889990000999";
             r9 = str.match(/^1[345678]\d{9}$/);                          //匹配11位失敗  但是長度不對 
             console.log(r9);                                                       //null   
            
            
             str = "13888899999";
             r9 = str.match(/^1[345678]\d{9}$/);                            //匹配11位失敗  但是長度不對 
             console.log(r9);                                                         //13888899999   
            


            
            特殊符號匹配,在正規表示式中  "^" "."  "$" "[]" "\"   需要轉義字元 加  \
            
 

             str = "sss.....";
             r9 = str.match(/./g);                                        //匹配字元 數字 下劃線
             console.log(r9);                                             //匹配失敗    sss.....
            
             str = "sss.^$.[]";
             r9 = str.match(/.*\.\^\$\.\[\]$/);                            //匹配成功
             console.log(r9);   //sss.^$.[]

 

  •  9 正規表示式條件分支

              |  表示或者  ， () 表示一個整體一般和 | 連用 表示分組進行匹配


             var str = "a.jpeg";             
             var r = str.match(/\.jpeg$/);
             console.log(r);
             
             
            str = "12a$s.i";
            r = str.match(/\.[jpe?g|git]$/);
              console.info(r);                                  // .i    [] 裡邊每一個都作為一個整體 i 是可以匹配到的。  
            
            //所以該用一個獨立的
            str = "12a$s.jpg";
            r = str.match(/\.jpeg|jpg|png$/);
             console.log(r);                                    // jpg  " . " 沒有匹配到  .jpg ， jpg ,png 分別是一個獨立的整體
             
             
             str = "12a$s.jpeg";
            r = str.match(/\.jpeg|jpg|png$/);          // .jpeg是一個整體可以匹配到
             console.log(r);                                   //.jpeg  
            
            


            
            括號裡的內容成為一個獨立的整體！    括號裡的內容分組，單獨進行匹配，如果進位制次匹配則在前面加上（?:） 來              取消分組匹配； 設定了 ^ $   match() 整體沒有匹配 分組就不會去匹配了！


             str = "12a$s.jpeg";
             r = str.match(/\.(jpeg|jpg|png)$/);   
             console.log(r);                                            //.jpeg , jpeg   匹配結果是兩個  
            
             r = str.match(/\.(?:jpeg|jpg|png)$/);   
             console.log(r);                                            //.jpeg       ?: 禁止分組在進行匹配
             

 

  •              10 匹配數值型別

             str = "-12.123e-1";
             分析：符號|整形 | 小數點| 科學計算符
          
             當我們在匹配一個相對於複雜的資料時候，把資料分成幾個幾個階段，每個階段用?把它括起來，只要專注他的某                一個部分，只要每一個部分匹配成功了，整體是拼接起來的，最後結果肯定是成功的。

             r = str.match(/^(-?)(0|[1-9]\d*)(\.)?(\d+)([Ee])?([-\+])?([0-9]*)$/);    //細分情況
             r2 = str.match(/^(-?)(0|[1-9]\d*)(\.\d+)?([Ee][-\+]?[0-9]*)?$/);     
             console.log(r);                              
             console.log(r2);                                         
             


             

  •              11 匹配中文  

             匹配中文字元的正規表示式： [\u4e00-\u9fa5]

                 str = "a中文這種無公害";
                 r = str.match(/[\u4e00-\u9fa5]/g);   
                 console.log(r);
             

 

  •             12 貪婪與懶惰  ： 在正則中預設是貪婪模式（儘可能多的匹配）

            
   預設貪婪模式進行匹配

            str = "aaabab";
              r = str.match(/a.*b/);     //結果是：aaabab  ab 也滿足表示式但是沒有匹配，匹配到aaaba 預設是以貪婪模式匹配 
                 
                 console.log(r);
            


    懶惰匹配  在修飾數量的匹配符後面加? ，匹配數值符號( * + ? {} ) 後面新增？即可會以懶惰模式匹配（儘可能少的匹配）

            
                str = "aaabab";
                 r = str.match(/a.*?b/);    
                 console.log(r);   // aaab  為什麼是aaab？   而不是ab呢 ，因為最先匹配的優先順序高。

 

 

如需要請下載  https://download.csdn.net/download/weixin_38361347/10575812

相關文章