开发者社区> 汤高> 正文

JavaScript正则表达式

简介:
+关注继续查看

什么是正则表达式?

正则表达式也叫做匹配模式(Pattern),它由一组具有特定含义的字符串组成,通常用于匹配和替换文本。
在JavaScript脚本中,利用正则表达式可以很容易的实现文本字符串的检测、替换等功能。
正则表达式是字符串,它定义了一个用来搜索匹配字符串的模式。定义模式:/表达式/


JavaScript脚本语言中引入正则表达式主要作用:
验证字符串格式
查找字符串
替换文本


创建方式:
1、采用RegExp对象的显式构造函数构造
var regObj = new RegExp(“pattern”,[,”flags”]);
pattern:必选项,正则表达式的字符串(模式字符串);
flags:可选项,一些标志组合。
2、采用RegExp对象的隐式构造函数构造
var regObj = /pattern/[flags];该方式不能用引号将pattern和flags括起来


flags标志信息项
i 忽略大小写标志
g 表示在全文中查找出现的所有参数
m 多行标志


显示创建正则表达式:
var myregx=new RegExp(“abc”);
可以加标志信息,如忽略大小写:
var myregx=new RegExp(“abc”,”i”);


隐式创建正则表达式:
var myregx=/tanggao/;
可以加标志信息,如全文搜索且忽略大小写:
var myregx=/tanggao/ig;
两种构造方式效果是一样的,但仍有小差别,隐式构造在脚本执行时进行编译,一般常用到这个正则表达式式时,用隐式构造法;显式构造法遇到正则表达式时才进行编译,在这个表达式使用较少下使用显式构造法。



正则表示对象RegExp对象的方法:


exec:检索字符中是正则表示的匹配,返回找到的值,并确定其位置。
eg:
语法:reg.exec(str);

<script>
var reg=/tanggao/;
var str='istanggao'
var result=reg.exec(str)//成功返回tanggao 失败返回null
alert(result)
</script>

将会输出tanggao,因为正则表达式reg会匹配str(‘istanggao’)中的’tanggao’子字符串,并且将其返回。
使用函数匹配方式

<script> 
function  execReg(reg,str){  
var result =  reg.exec(str);  
alert(result); } 
var reg = /tanggao/; 
var str = 'istanggao';
 execReg(reg,str);
</script>

test:检索字符串中指定的值,返回true或false。
eg:

 <script>
            var reg=/tanggao/;          
            var str='isTanggao istanggao'
            var result=reg.test(str)//成功返回true 失败返回false
            alert(result)
 </script>  //结果 false  因为区分大小写

<script>
            var reg=/tanggao/i;         //i表示忽略大小写
            var str='isTanggao istanggao'
            var result=reg.test(str)//成功返回true 失败返回false
            alert(result)   //结果true

            var reg=/tanggao/ig;            //i表示忽略大小写  g表示开启全局
            var str='isTanggao istanggao'
            var result=reg.test(str)//成功返回true 失败返回false
            alert(result)
</script> 

compile( )方法:更换RegExp对象实例所使用的表达式模式
compile()既可以改变检索模式,也可以添加或删除第二个参数

    <script>
            var reg=/tanggao/;

      var str='isTanggao ';
      var result1=reg.test(str);
      alert(result1);//结果返回false  区分大小写
      reg.compile("i");   //添加i 区分大小写的标志信息项
      var result2=reg.test(str) 
      alert(result2); //结果为true

    reg.compile("tg");//模式字符串改为tg   >>reg=/tanggao/
        var result=reg.test(str);//成功返回true 失败返回false
        alert(result)   //结果为false 因为模式字符串reg已经用compile改为tg了

    reg.compile("Tanggao","i");
        var result=reg.test(str);//成功返回true 失败返回false
        alert(result)   //结果为true 因为模式字符串reg已经用compile改为Tanggao了 并且添加了 i 区分大小写的标志信息项
    </script>

string对象的方法:
match:找到一个或多个正则表示的匹配,该方法类似 indexOf() 和 lastIndexOf(),但是它返回指定的值,而不是字符串的位置


var str="Hello world! world!"   //  match()   找到返回匹配字符串   找不到返回null
            document.write(str.match("world") + "<br />")//输出结果为world 因为match找到了 模式串中的world
            document.write(str.match("World") + "<br />")//输出结果为 null 因为区分大小写
            document.write(str.match("worlld") + "<br />")//输出结果为null
            document.write(str.match("world!") + "<br />"); //输出结果为world! 没有开启全局  只返回前一个匹配是的字符串
            document.write(str.match("world!","g")); //输出结果为world! world!   因为  开启了全局  

search:


检索与正则表达式相匹配的位置的值;如果没有找到任何匹配的子串,则返回 -1。search() 方法不执行全局匹配,它将忽略标志 g。它同时忽略 regexp 的 lastIndex 属性,并且总是从字符串的开始进行检索,这意味着它总是返回 stringObject 的第一个匹配的位置;对大小写敏感

 <script>
            var reg=/tanggao/gi;            //i表示忽略大小写  g表示开启全局 但是该方法屏蔽全局 就是忽略全局
            var str='is Tanggao Tanggao'
            var result=str.search(reg)//成功返回开始匹配的位置 从0开始 空格算一个位置  失败返回-1
            document.write(result)
     </script>

replace:替换与正则表达式匹配的字符串;第二个参数替换第一个参数

<script>
            var reg=/tanggao/;          
            var str='is Tanggao tanggao'
             var result=reg.test(str )// true
            document.write(result+"<br />")

            var s=str.replace(/tanggao/ig,"tg");  //i表示忽略大小写  g表示开启全局  用tg 替换tanggao  开了全局和不区分大小写 
             document.write(s+"<br />")  
             var result1=reg.test(s)  //结果为   is tg tg  

            document.write(result1)  //结果为false
     </script>

split:把字符串分隔为字符串数字;//结果为一个数组;


参数 描述
separator 必需。字符串或正则表达式,从该参数指定的地方分割 stringObject。
howmany 可选。该参数可指定返回的数组的最大长度。如果设置了该参数,返回的子串不会多于这个参数指定的数组。如果没有设置该参数,整个字符串都会被分割,不考虑它的长度。

<script type="text/javascript">

        var str="How are you doing today?"

        document.write(str.split(" ") + "<br />") // 结果  How,are,you,doing,today?
        document.write(str.split("") + "<br />")  // 结果 H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?
        document.write(str.split(" ",3))      //  以空格分割  数组长度为3   结果 How,are,you

</script>

注意:因为这四个方法是属于string 所以
语法:第二个参数.方法(第一个参数)
比如 上面中str.match(reg)


RegExp对象的属性:
静态属性
这里写图片描述


实例属性:
global:RegExp对象是否具有标志g;//全局查询,如果没有这个属性则在第一次匹配之后就结束操作;


ignorCase:RegExp对象是否具有标志i;//忽略大小写;


multiline:RegExp对象是否具有标志m;//多行查询;
它声明了给定的正则表达式是否以多行模式执行模式匹配。
在这种模式中,如果要检索的字符串中含有换行符,^ 和 /W3School/im 匹配 “w3school” 和 “W3School\nisgreat”。(\n 是换行符\u000A)。
如果 m 标志被设置,则该属性为 true,否则为 false。

  <script>
        var reg=/^\d+/gm    //限定了首匹配 并且开启了多行模式
        var str='1.baidu\n2.google\n3.bing'
        var result=str.replace(reg,'#')
        alert(result)   
  </script>

lastIndex – 整数,使用exec或test方法时被填入,表示下次匹配将会从哪个字符位置开始;
语法
stringObject.lastIndexOf(searchvalue,fromindex)
参数 描述
searchvalue 必需。规定需检索的字符串值。
fromindex 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数,则将从字符串的最后一个字符处开始检索。
如果要检索的字符串值没有出现,则该方法返回 -1。

<script type="text/javascript">

        var str="Hello world!"
        document.write(str.lastIndexOf("Hello") + "<br />") // 0
        document.write(str.lastIndexOf("World") + "<br />")//-1
        document.write(str.lastIndexOf("world"))//6

    </script>

source – 正则表达式的元字符串形式。source 属性来获得用于模式匹配的文本
如 /\/的source将返回”\“。

<script type="text/javascript">
var str = "Visit W3School.com.cn";
var patt1 = new RegExp("W3S","g");

document.write("The regular expression is: " + patt1.source);//The regular expression is: W3S 
</script>

正则表达式的常用符号:
字符匹配符


/.../:代表一个模式的开始和结束;
    <script>
            var reg  = /.../; 
            var str = '维生素c';
            var result=reg.exec(str) 
             alert(result)//结果维生素
            var str = 'cainiao'; 

            var result=reg.exec(str)
              alert(result)//结果cai 
        </script>
s:任何空白字符;
S:任何非空白字符;
d:匹配一个数字字符,等级[^0-9];
D:除了数字之外的任何字符,等价于[^0-9];
w:匹配一个数字,下划线或者字母字符,等价于[A-Za-z0-9];
W:任何非单字字符,等价于[^a-zA-Z0-9];
.:除了换行符之外的任何字符;
<script>
            var reg  = /./; 
            var str = '维生素c';
            var result=reg.exec(str) 
             alert(result)//结果维
            var str = 'cainiao'; 

            var result=reg.exec(str)
              alert(result)//结果c 
   </script>

定位符
^ 与字符串的开始的地方匹配

<script>
            var reg  = /^c/; 
            var str = '维生素c';
            var result=reg.exec(str) 
             alert(result)//结果为null,字符串不是以“c”打头的 
            var str = 'cainiao'; 

            var result=reg.exec(str)
              alert(result)//返回c,匹配成功,字符串是以“c”打头的
      </script>

$ 与字符串结束的地方匹配

<script>
            var reg  = /c$/; 
            var str = '维生素c';
            var result=reg.exec(str) 
             alert(result)//结果c,字符串是以“c”结束的 
            var str = 'cainiao'; 

            var result=reg.exec(str)
              alert(result)//返回null,字符串不是以“c”结束的
        </script>

\b 匹配一个单词边界,就是单词和空格之间的位置 ,只有字符串的开头和结尾才算数(单个字符右边界前面必须有空格 左边界可以没有)

<script>
            var reg  = /\bc/; //以c开头
            var str = 'bcd c';
            var result=reg.exec(str) 
             alert(result)//c  中间有空格 空格后以C结尾

                var reg  = /\bb/; //以b开头
            var str = 'bbc'; 

            var result=reg.exec(str)
              alert(result)//结果b  zuo边界为b

             var str = 'sdbsds'; 

            var result=reg.exec(str)
              alert(result)//结果null

    </script>
<script>


        var reg=/google\b/ //以e结尾
        var str='google';   

        var result=reg.exec(str)
              alert(result)

        var reg=/\bgoogle/
        var result=reg.exec(str)
              alert(result)  //以g开头

        </script>

\B 就是\b取非,即匹配一个非单词边界

<script>
            var reg  = /\Bc/; 
            var str = 'b c';
            var result=reg.exec(str) 
             alert(result)//null   因为已c 为边界  而\B是\b取非            
                var reg  = /\Bb/; 
            var str = 'bc'; 

            var result=reg.exec(str)
              alert(result)//结果null  
             var reg  = /\Bd/;  
             var str = 'sdbsds'; 

            var result=reg.exec(str)
              alert(result)//结果d 因为不是以d 为边界

        </script>

限定符
{n}/匹配前一项n次

<script>
        var reg=/t{2}/   //表示连续匹配2个t
        var str='ttang'

        var result=reg.exec(str);
        alert(result); //结果为tt

        var str='tantg'
        var result=reg.exec(str);
        alert(result);   结果为null

  </script>

{n,}:匹配前一项n次,或者多次;

   <script>
        var reg=/t{2,}/   //表示连续匹配2个t 或者2个以上
        var str='ttang'

        var result=reg.exec(str);
        alert(result); //结果为tt

        var str='tttantg'
        var result=reg.exec(str);
        alert(result);   结果为ttt

    </script>

{n,m}:匹配前一项至少n次,但是不能超过m次;(区间n-m次)

<script>     
   var reg = /google{3,4}$/g; 
   var str = 'googleee'; 
    var result=reg.test(str);
        alert(result); //返回结果true
   var str = 'ccTest'; 
    var result=reg.test(str);
        alert(result); //返回结果false

     var str = 'googleeeee'; 
    var result=reg.test(str);
        alert(result); //返回结果false
</script>
*:匹配前一项0次或者多次,等价于{0,};
+:匹配前一项1次或者多次,等价于{1,};
?:匹配前一项0次或者1次,等价于{0,1};

选择匹配符
|:表示或者的意思;eg:[0-9]|[a-z];

<script>
            var reg  = /b|c/; 
            var str = '维生素b';
            var result=reg.exec(str) 
             alert(result)//结果c
            var str = 'cainiao'; 

            var result=reg.exec(str)
              alert(result)//结果c


              var str= 'bbs.blueidea.com'; 
              var result=reg.exec(str)
              alert(result)//结果只有一个b 第一个成立就不会输出c.com  第一个不成立才输出c

                var str= 's.lueidea.com'; 
              var result=reg.exec(str)
              alert(result)//结果c   第一个不成立才输出c
     </script>

/[abc]/可以匹配a、b、c中任意一个字符

     <script>
            var reg  = /[abc]/; 
            var str = '维生素b';
            var result=reg.exec(str) 
             alert(result)//结果b
            var str = 'cainiao'; 

            var result=reg.exec(str)
              alert(result)//结果c



     </script>

反向类:[^]用来匹配不在括号内的任意字符。
如:/[^abc]/可匹配除a、b、c外的其他任意字符

<script>
            var reg  = /[^abc]/; 
            var str = 'bc';
            var result=reg.exec(str) 
             alert(result)//结果null
            var str = 'ca'; 

            var result=reg.exec(str)
              alert(result)//结果null

             var str = 'sdsds'; 

            var result=reg.exec(str)
              alert(result)//结果s

   </script>

范围类:[0-9]表示匹配从0-9任意的数字

( ):用于分组;

<script>
        var reg=/^([a-z]+)\s([0-9]{4})$/  //使用了分组 这个是捕获性分组 所有的分组都要返回 结果返回一个数组
        var str='tanggao 1994'
        var result=reg.exec(str)
        alert(result) //返回整个数组  tanggao 1994,tanggao,1994
        alert(result[0])// 返回匹配到的整个字符串 tanggao 1994
        alert(result[1])//返回匹配到的第一个分组的字符串   tanggao 
        alert(result[2])//返回匹配到的第二个分组的字符串  1994

 </script>
<script>
        var reg=/^(?:[a-z]+)\s([0-9]{4})$/  //使用了分组 这个是非捕获性分组 只要在不需要返回的分组加上?:
        var str='tanggao 1994'
        var result=reg.exec(str)
        alert(result) //不返回第一个分组tanggao   结果为 tanggao 1994,1994   少了 tnaggao


</script>
<script>

        var reg=/(a?(b?(c?)))/    //使用嵌套分组   从外往内获取  ?表示一个或0个
        var str='abc'
        var result=reg.exec(str)

        alert(result[0]) //整个匹配到的字符串abc
        alert(result[1]) //匹配到的第一个分组(a?(b?(c?))) abc
        alert(result[2]) //匹配到的第二个分组(b?(c?))  bc
        alert(result[3]) //匹配到的第三个分组(c?)  c
</script>

<script>
    var reg=/tang(?=gao)/    //使用前瞻性捕获 ?=
    var str='tanggao'
    var result=reg.exec(str)

    alert(result) //返回tang  这是前瞻性捕获  
</script>

 <script>
        var pattern=/8(.*)8/;  //
        var str='this is a 8baidu8';   
        document.write(str.replace(pattern,'<strong>$1</strong>'));

        //$1表示分组获取字符串匹配到的内容


            var reg=/(.*)\s(.*)/
            var str='baidu google'
            alert(str.replace(reg,'$2,$1'))  //交换baidu google顺序 得到 google baidu



        </script>

这里写图片描述


关于贪婪和惰性模式.

所谓的贪婪模式就是这样.在整个表达式匹配成功的前提下,尽可能多的匹配
所谓的惰性模式就是,在整个表达式匹配成功的前提下,尽可能少的匹配.
实例:

var pattern=/[a-z]+/; //使用了贪婪模式
var str='abcdef';
alert(str.replace(pattern,'1'));   //所有的字符串变成了1

//运行结果就是1


var pattern=/[a-z]+?/;   //使用惰性模式
var str='abcdef';
alert(str.replace(pattern,'1'));   //只有第一个字符变成了1,后面没有匹配

//运行结果就是1bcdef

var pattern=/8(.*)8/;  //使用了贪婪模式
var str='8google8  8google8 8google8';   
document.write(str.replace(pattern,'<strong>$1</strong>'));

//结果是google8 8googlr8 8google

var pattern=/8(.*?)8/;  //使用了惰性
var str='8google8  8google8 8google8';   //匹配到了goole  8googlr8 8google
document.write(str.replace(pattern,'<strong>$1</strong>'));

//结果是google 8google8 8google8

不管是贪婪还是惰性模式,在遇到全局开启的情况下会怎样呢??
全局匹配模式:使用了’g’标识符.在全局匹配下,会对指定查找的字符串进行多次匹配.

var pattern=/[a-z]+/g; //使用了贪婪模式
var str='abcdef';
alert(str.replace(pattern,'1'));   //所有的字符串变成了1

//运行结果就是111111

var pattern=/[a-z]+?/g;   //使用惰性模式,开启全局
var str='abcdef';
alert(str.replace(pattern,'1'));   //所有的字符串变成了1 因为开启了全局 都匹配

//运行结果就是111111

var pattern=/8(.*)8/g;  //使用了贪婪模式,全局开启
var str='8google8  8google8 8google8';   //匹配到了goole8  8googlr8 8google
document.write(str.replace(pattern,'<strong>$1</strong>'));

//结果是google8 8googlr8 8google

var pattern=/8(.*?)8/g;  //使用了惰性,开启全局
var str='8google8  8google8 8google8';   //匹配到了goole  google google
document.write(str.replace(pattern,'<strong>$1</strong>'));

//结果是google google google

<script>

        var pattern=/8(.*?)8/;  //使用了惰性,关闭全局 
        var str='8google8  8google8 8google8';   //匹配到了goole
        document.write(str.replace(pattern,'<strong>$1</strong>')); //结果是google 8google8 8google8

</script>

贪婪模式,在开启全局和不开启全局下的结果是一样的.因为贪婪模式就是贪婪到底,和全局匹配要多次匹配是一样的道理.
而惰性模式,在开启全局的时候,就会进行多次匹配.得到的结果也是不一样的.


实际应用 验证
全是字母:
var reg = /^[a-zA-Z]+$/;至少有一个字母;


四个字母:
var reg = /^[a-zA-Z]{4}$/;加上’^’避免了”3dedf”这类的也匹配上去;


11位qq号,第一位不能为0:
/^[1-9]{1}d{10}$/


18位身份证号:
/^d{17}(d{1}|[a-zA-Z}{1})$/


邮箱:
/^w{2,}@w{2,}(.[a-zA-Z]{2,4}){1,2}$/;这样就可以匹配xx@yy.com.cn;


//判断输入内容是否为空

function IsNull(){    
    var str = document.getElementById('str').value.trim();    
    if(str.length==0){    
        alert('对不起,文本框不能为空或者为空格!');//请将“文本框”改成你需要验证的属性名称!    
    }    
}    

//判断日期类型是否为YYYY-MM-DD格式的类型

function IsDate(){     
    var str = document.getElementById('str').value.trim();    
    if(str.length!=0){    
        var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2})$/;     
        var r = str.match(reg);     
        if(r==null)    
            alert('对不起,您输入的日期格式不正确!'); //请将“日期”改成你需要验证的属性名称!    
        }    
}     

//判断日期类型是否为YYYY-MM-DD hh:mm:ss格式的类型

function IsDateTime(){     
    var str = document.getElementById('str').value.trim();    
    if(str.length!=0){    
        var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/;     
        var r = str.match(reg);     
        if(r==null)    
        alert('对不起,您输入的日期格式不正确!'); //请将“日期”改成你需要验证的属性名称!    
    }    
}     

//判断日期类型是否为hh:mm:ss格式的类型

function IsTime()     
{     
    var str = document.getElementById('str').value.trim();    
    if(str.length!=0){    
    reg=/^((20|21|22|23|[0-1]\d)\:[0-5][0-9])(\:[0-5][0-9])?$/     
        if(!reg.test(str)){    
            alert("对不起,您输入的日期格式不正确!");//请将“日期”改成你需要验证的属性名称!    
        }    
    }    
}     

//判断输入的字符是否为英文字母

function IsLetter()     
{     
        var str = document.getElementById('str').value.trim();    
        if(str.length!=0){    
        reg=/^[a-zA-Z]+$/;     
        if(!reg.test(str)){    
            alert("对不起,您输入的英文字母类型格式不正确!");//请将“英文字母类型”改成你需要验证的属性名称!    
        }    
        }    
}     

//判断输入的字符是否为整数

function IsInteger()     
{       
        var str = document.getElementById('str').value.trim();    
        if(str.length!=0){    
        reg=/^[-+]?\d*$/;     
        if(!reg.test(str)){    
            alert("对不起,您输入的整数类型格式不正确!");//请将“整数类型”要换成你要验证的那个属性名称!    
        }    
        }    
}     

//判断输入的字符是否为双精度

function IsDouble(val)     
{     
        var str = document.getElementById('str').value.trim();    
        if(str.length!=0){    
        reg=/^[-\+]?\d+(\.\d+)?$/;    
        if(!reg.test(str)){    
            alert("对不起,您输入的双精度类型格式不正确!");//请将“双精度类型”要换成你要验证的那个属性名称!    
        }    
        }    
}     

//判断输入的字符是否为:a-z,A-Z,0-9

function IsString()     
{     
        var str = document.getElementById('str').value.trim();    
        if(str.length!=0){    
        reg=/^[a-zA-Z0-9_]+$/;     
        if(!reg.test(str)){    
            alert("对不起,您输入的字符串类型格式不正确!");//请将“字符串类型”要换成你要验证的那个属性名称!    
        }    
        }    
}     

//判断输入的字符是否为中文

function IsChinese()     
{     
        var str = document.getElementById('str').value.trim();    
        if(str.length!=0){    
        reg=/^[\u0391-\uFFE5]+$/;    
        if(!reg.test(str)){    
            alert("对不起,您输入的字符串类型格式不正确!");//请将“字符串类型”要换成你要验证的那个属性名称!    
        }    
        }    
}     

//判断输入的EMAIL格式是否正确

function IsEmail()     
{     
        var str = document.getElementById('str').value.trim();    
        if(str.length!=0){    
        reg=/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/;    
        if(!reg.test(str)){    
            alert("对不起,您输入的字符串类型格式不正确!");//请将“字符串类型”要换成你要验证的那个属性名称!    
        }    
        }    
}     

//判断输入的邮编(只能为六位)是否正确

function IsZIP()     
{     
        var str = document.getElementById('str').value.trim();    
        if(str.length!=0){    
        reg=/^\d{6}$/;    
        if(!reg.test(str)){    
            alert("对不起,您输入的字符串类型格式不正确!");//请将“字符串类型”要换成你要验证的那个属性名称!    
        }    
        }    
}     

//判断输入的数字不大于某个特定的数字

function MaxValue()     
{     
    var val = document.getElementById('str').value.trim();    
        if(str.length!=0){    
        reg=/^[-+]?\d*$/;     
        if(!reg.test(str)){//判断是否为数字类型    
            if(val>parseInt('123')) //“123”为自己设定的最大值    
            {     
                alert('对不起,您输入的数字超出范围');//请将“数字”改成你要验证的那个属性名称!    
            }     
        }    
    }    
}     

Phone : /^(((\d{2,3}))|(\d{3}-))?((0\d{2,3})|0\d{2,3}-)?[1-9]\d{6,7}(-\d{1,4})?$/


Mobile : /^(((\d{2,3}))|(\d{3}-))?13\d{9}$/
Url : /^http:\/\/[A-Za-z0-9]+.[A-Za-z0-9]+[\/=\?%-&_~`@[]\’:+!]([^<>\”\”])$/


IdCard : /^\d{15}(\d{2}[A-Za-z0-9])?/QQ:/[19]\d4,8/


某种特殊金额:/^((\d{1,3}(,\d{3})*)|(\d+))(.\d{2})?$/ //说明:除“XXX XX,XXX XX,XXX.00”格式外

总结 : 花了一天多的时间基本了解了正则表达式的相关知识点 进行了总结 应该非常详细了 各个知识点都涉及到了 有实例代码

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
C#正则表达式的完全匹配、部分匹配及忽略大小写的问题
原文:C#正则表达式的完全匹配、部分匹配及忽略大小写的问题 问题的提出 根据用户给定表达式,里面含有各种数学函数,如求绝对值,三角函数,平方、开方等,分别以类似ABS(表达式),Sin(表达式),ASin(表达式),POW(表达式)等形式表述。
1615 0
阿里云服务器怎么设置密码?怎么停机?怎么重启服务器?
如果在创建实例时没有设置密码,或者密码丢失,您可以在控制台上重新设置实例的登录密码。本文仅描述如何在 ECS 管理控制台上修改实例登录密码。
23526 0
JAVASCRIPT学习笔记之正则表达式
关于正则表达式的总结一直在草稿箱里躺了很久了,与本文原作者水墨寒湘( 呵呵,不是我水墨寒)类似,之前对于正则表达式也是一知半解,用到就谷娘的那种。直到哪天看了慕课网的《JavaScript正则表达式》的视频,豁然开朗啊,正好在掘金上看到这篇文章,顺手手动编辑转载了,用作复习。
2926 0
javascript使用栈结构将中缀表达式转换为后缀表达式并计算值
1.概念   你可能听说过表达式,a+b,a+b*c这些,但是前缀表达式,前缀记法,中缀表达式,波兰式,后缀表达式,后缀记法,逆波兰式这些都是也是表达式。   a+b,a+b*c这些看上去比较正常的是中缀表达式,就是运算符放在两个操作数之间。
1175 0
java正则表达式 前后查找
最近做软件 需要截取 一个 类似html标签内部的文本
105 0
+关注
汤高
学习,进步
49
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
JS零基础入门教程(上册)
立即下载
性能优化方法论
立即下载
手把手学习日志服务SLS,云启实验室实战指南
立即下载