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 锚除了匹配字符串的开头和结尾外还匹配每行的开头和结尾。 例如，模式 /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:/[1−9]\d4,8/ QQ : /^[1-9]\d{4,8}/
某种特殊金额：/^((\d{1,3}(,\d{3})*)|(\d+))(.\d{2})?$/ //说明：除“XXX XX,XXX XX,XXX.00”格式外
总结 ： 花了一天多的时间基本了解了正则表达式的相关知识点 进行了总结 应该非常详细了 各个知识点都涉及到了 有实例代码
腾讯云开发者
