js正则表达式基本语法学习

44 阅读5分钟

  最近在处理字符串时候莫名的被正则表达式按在地上一顿摩擦,决定好好补一补以前欠下的正则债。

查了查百度百科发现正则表达式在不同语言的支持方法语法略有不同,于是打算在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[345678]\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呢 ,因为最先匹配的优先级高。

 

 

如需要请下载  download.csdn.net/download/we…