JS正则表达式

正则表达式
var box = new RegExp('Box'); //第一个参数是模式字符串
alert(box); // /Box/两个反斜杠是正则表达式的字面量表示法

var box = new RegExp('Box','ig'); //第二个参数可选，模式修饰符 i表示忽略大小写 g表示全局匹配 m表示多行匹配
alert(box);

var box = /Box/; //使用字面量的方式创建正则表达式
alert(box);

var box = /Box/ig; //使用字面量的方式 带修饰符的。
alert(box);

如何匹配正则表达式
使用test匹配是否存在，返回true或false
var pettern = new RegExp('Box'); //模式
var str = 'box'; //字符串
alert(pettern.test(str)); //返回false，大小写不一致

var pettern = new RegExp('Box','i'); //忽略大小写
var str = 'box';
alert(pettern.test(str)); //true,忽略大小写

alert(/Box/i.test('box')); //true,一条语句匹配

var pettern = /Box/i; //忽略大小写匹配
var str = 'This is a box!'; //一句英文字符串
alert(pettern.test(str)); //字符串中是否包含模式中的正则，也就是说This is a box中是否包含不区分大小写的Box

使用exec返回匹配数组
var pettern = /Box/i;
var str = 'box';
alert(pettern.exec(str)); //返回的是数组，有就返回数组的值，没有就返回null

var pettern = /Box/i;
var str = 'sss';
alert(pettern.exec(str)); //如果没有匹配到，就返回null

使用字符串的正则表达式方法
使用match方法获取匹配数组
var pettern = /Box/i; //没有开启全局
var str = 'This is a Box! That is a Box!';
alert(str.match(pettern));//匹配到第一个字符串返回数组

var pettern = /Box/i;
var str = 'This is a Box! That is a Box!';
var a = str.match(pettern);
alert(a[0]); //可打印出下标，证明是数组

var pettern = /Box/ig; //开启了全局
var str = 'This is a Box! That is a Box!';
alert(str.match(pettern); //将所有匹配的字符串组合成数组返回

使用search来查找匹配数据
var pettern = /Box/i; //search方法查找到即返回，也就是说无需g全局
var str = 'This is a Box! That is a Box!';
alert(str.search(pettern)); //返回的第一个匹配的位置

var pettern = /xox/i;
var str = 'This is a Box! That is a Box!';
alert(str.search(pettern)); //如果匹配不到，则返回-1

使用replace替换匹配到的数据
var pettern = /Box/i; //没有开启全局
var str = 'This is a Box! That is a Box!';
alert(str.replace(pettern,'Tom')); //返回替换后的字符串只限第一个

var pettern = /Box/ig; //开启全局
var str = 'This is a Box! That is a Box!';
alert(str.replace(pettern,'Tom')); //所有匹配都会被替换

使用split拆分成字符串数组
var pettern = /!/i;
var str = 'This is a Box! That is a Box!';
alert(str.split(pettern));
alert(str.split(pettern).length);

RegExp对象的静态属性
var pattern = /google/i;
var str = 'This is a google!';
pattern.test(str); //必须执行以下，静态属性才有效
//alert(RegExp.input); //当前被匹配的字符串
//alert(RegExp.leftContext); //最后一次匹配前的子串
//alert(RegExp.rightContext); //在上次匹配之后的子串
//alert(RegExp.lastMatch); //最后一个匹配字符串
//alert(RegExp.lastParen); //最后一对圆括号内的匹配子串
//alert(RegExp.multiline); //用于指定是否所有的表达式都用于多行的布尔值

RegExp对象的实例属性
var pattern = /google/;
var str = 'google google google';
alert(pattern.global); //是否开启全局
alert(pattern.ignoreCase); //是否开启区分大小写
alert(pattern.multiline); //是否多行匹配
alert(pattern.source); //源字符串
pattern.test(str);
pattern.lastIndex = 100; //lastIndex还可以手动赋值
alert(pattern.lastIndex); //下次匹配的位置。必须要开启全局。

获取控制
var pattern = /g.gle/; //点符号表示匹配任意除了换行符外的任意字符
var str = 'g^gle';
alert(pattern.test(str)); //true

var pattern = /go*gle/; //o*,星号表示0个，1个，或者多个o
var str = 'gooooooooooogle';
alert(pattern.test(str));

var pattern = /go+gle/; //o+,表示1个，或者多个o，不可以是0个
var str = 'gooooooooooogle';
alert(pattern.test(str));

var pattern = /go?gle/; //o?,表示1个，或者0个o，但不可以是多个
var str = 'gogle';
alert(pattern.test(str));

var pattern = /g.?gle/; //.?,表示1个，或者0个任意的字符
var str = 'gogle';
alert(pattern.test(str));

var pattern = /go{2,4}gle/; //o{2,4}表示匹配o2-4次，包含2和4,大于或小于区间都会返回false
var str = 'goooogle';
alert(pattern.test(str));

var pattern = /go{3}gle/; //o{3}表示只能限定3个o
var str = 'goooogle';
alert(pattern.test(str));

var pattern = /go{3,}gle/; //o{3}加个逗号表示3个o或3个以上
var str = 'goooogle';
alert(pattern.test(str));

使用字符类匹配
var pattern = /[a-z]oogle/; //[a-z]表示26个小写字母，任意一个都可以匹配
var str = 'boogle';
alert(pattern.test(str));

var pattern = /[A-Z]oogle/; //[A-Z]表示26个大写字母，任意一个都可以匹配
var str = 'boogle';
alert(pattern.test(str));

var pattern = /[A-Z]oogle/i; //[A-Z]表示26个大写字母，任意一个都可以匹配。加上i区分大小写无论大写小写都匹配
var str = 'boogle';
alert(pattern.test(str));

var pattern = /[0-9]oogle/; //[0-9]表示0到9任何的数字，只匹配最后一个数字
var str = '4oogle';
alert(pattern.test(str));

var pattern = /[0-9]*oogle/; //[0-9]*表示0次，一次，或者多次.无论有多少数字都可以匹配到
var str = '5555555555555oogle';
alert(pattern.test(str));

复合式匹配
var pattern = /[a-zA-Z0-9]oogle/; //[a-zA-Z0-9]表示匹配大小写的a-z和0-9都可以匹配
var str = 'b4oogle';
alert(pattern.test(str));

var pattern = /[^0-9]oogle/; //[^0-9]^符号表示非0-9的任意字符,但可以是字母或其他的符号
var str = '6oogle';
alert(pattern.test(str));

var pattern = /^[0-9]oogle/; //^[0-9]这个^符号，是加在/后面的而不是[]里面的。这样就只能匹配到一个数字。
var str = '6666666666666666666666666oogle';
alert(pattern.test(str)); //false

var pattern = /^[0-9]+oogle/; //^[0-9] +号可以匹配一个或者多个。
var str = '6666666666666666666666666oogle';
alert(pattern.test(str)); //true

var pattern = /\woogle/; // \w匹配数字字母及下划线
var str = '6oogle';
alert(pattern.test(str));

var pattern = /\Woogle/; // \W匹配非数字字母及下划线
var str = '6oogle';
alert(pattern.test(str));

var pattern = /\doogle/; // \d匹配0-9之间
var str = '6oogle';
alert(pattern.test(str));

var pattern = /\Doogle/; // \D非匹配0-9之间
var str = '6oogle';
alert(pattern.test(str));

var pattern = /^[a-z]oogl[0-9]&/; //行首和行尾，必须是指定的正则。^强制首匹配，$强制尾匹配
var str = 'googl5';
alert(pattern.test(str));

var pattern = /goo gle/; //直接使用空格匹配
var str = 'goo gle';
alert(pattern.test(str));

var pattern = /goo\sgle/; // \s表示空格匹配
var str = 'google';
alert(pattern.test(str));

var pattern = /google\b/; // \b表示是否到达边界
var str = 'google';
alert(pattern.test(str));

var pattern = /google|baidu|bing/; // |表示匹配或选择模式，匹配三种其中一种的字符串
var str = 'baidu'; //匹配概念不是相等，包含的意思
alert(pattern.test(str));

var pattern = /google{4,8}$/; //表示e的4-8次
var str = 'googleeeeeeeeeeeeeeeeeee';
alert(pattern.test(str));

var pattern = /(google){4,8}$/; //分组可以看成一个字符
var str = 'googlegooglegooglegooglegooglegoogle';//表示google4-8次
alert(pattern.test(str));

var pattern = /8.*8/; //获取8..8之间的任意字符
var str = 'This is a 8google8';
alert(pattern.test(str));

var pattern = /8(.*)8/;
var str = 'This is a 8google8';
pattern.test(str);
alert(RegExp.$1);
//RegExp.$1表示获取模式中第一个分组对应的匹配字符串

var pattern = /8(.*)8/;
var str = 'This is a 8google8';
document.write(str.replace(pattern,'<strong>$1</strong>')); //$1表示分组获取字符串匹配到的内容

var pattern = /(.*)\s(.*)/;
var str = 'google baidu';
alert(str.replace(pattern,'$2 $1')); //位置交换

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

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

var pattern = /[a-z]+?/g; //开启全局并且使用惰性模式
var str = 'abcdefj';
alert(str.replace(pattern,'1')); //每一个字母替换成了1

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

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

var pattern = /8([^8]*)8/g; //另一种惰性，屏蔽了8的匹配，也就是两边包含字符
var str = '8google8 8google8 8google8';
document.write(str.replace(pattern,'<strong>$1</strong>'));

使用exec返回数组
var pattern = /^[a-z]+\s[0-9]{4}$/;
var str = 'google 2012';
alert(pattern.exec(str)); //返回一个包含字符串的数组

var pattern = /^[a-z]+/; //只匹配到字母
var str = 'google 2012';
alert(pattern.exec(str)); //只返回google的字符串数组

var pattern = /^([a-z]+)\s([0-9]{4})$/; //使用了分组
var str = 'google 2012';
var a = pattern.exec(str);
alert(a[0]); //a[0],返回匹配到的整个字符串
alert(a[1]); //a[1],返回匹配到的第一个分组的字符串
alert(a[2]); //a[2],返回匹配到的第二个分组的字符串

var pattern = /(\d+)([a-z])/; //这个叫做捕获性分组，所有的分组都捕获返回
var str = '123abc';
var a = pattern.exec(str);
// a[0]返回123a
// a[1]返回123
// a[2]返回a

var pattern = /(\d+)(?:[a-z])/; //非捕获性分组，只要在不需要捕获返回的分组加上?:
var str = '123abc';
alert(pattern.exec(str));

使用exec返回数组
var pattern = /^[a-z]+\s[0-9]{4}$/; //花括号中的数字4表示限定4位数
var str = 'google 2012';
alert(typeof pattern.exec(str)); //返回一个包含字符串的数组

var pattern = /^[a-z]+/; //只匹配到字母
var str = 'google 2012';
alert(pattern.exec(str)); //只返回google的字符串数组

var pattern = /^([a-z]+)\s([0-9]{4})$/; //使用了分组
var str = 'google 2012';
var a = pattern.exec(str);
alert(a[0]); //a[0]，返回匹配到的整个字符串
alert(a[1]); //a[1]，返回匹配到的第一个分组的字符串
alert(a[2]); //a[2]，返回匹配到的第二个分组的字符串

捕获性分组和非捕获性分组
var pattern = /(\d+)([a-z])/; //这个叫做捕获性分组，所有的分组都捕获返回
var str = '123abc';
alert(pattern.exec(str));

var pattern = /(\d+)(?:[a-z])/; //非捕获性分组，只要在不需要捕获返回的分组加上?:
var str = '123abc';
alert(pattern.exec(str));

使用分组嵌套
var pattern = /(a?(b?(c?)))/; //嵌套分组，从外往内获取
var str = 'abc';
alert(pattern.exec(str));
//第一步：a[0]，整个匹配到的字符串abc
//第二步：a[1]，匹配第一个分组(a?(b?(c?)))，abc
//第三步：a[2]，匹配第二个分组(b?(c?)),bc
//第四步：a[3]，匹配第三个分组(c?)c

前瞻性捕获
var pattern = /goo(?=gle)/; //goo后面必须是gle才能返回goo，这里一定要注意，返回的是goo，而不是google
var str = 'google';
alert(pattern.exec(str));

使用特殊字符匹配
var pattern = /\[/; //用\符号来转义正则里的特殊字符，才能匹配
var str = '[';
alert(pattern.exec(str));

使用换行模式
var pattern = /^\d+/gm; //限定了首匹配，并且开启换行
var str = '1.baidu\n2.google\n3.bing';
alert(str.replace(pattern,'#'));

四，常用的正则
检查邮政编码
var pattern = /[1-9][0-9]{5}/; //必须是6位，必须是数字，第一位不能为0
var str = 'This is 224000 !';
alert(pattern.test(str));

检查文件的压缩包
var pattern = /^[\w\-]+\.zip|gz|rar/;
var str = '2-13.zip'; //文件名：字母——数字，后缀：zip,gz,rar,7z
alert(pattern.test(str));

删除多余空格
var pattern = /\s/g;
var str = '111 222 333 555';
alert(str.replace(pattern,''));

删除首尾空格
var pattern = /^\s+/;
var str = ' goo gle ';
var result = str.replace(pattern,'');
pattern = /\s+$/;
result = result.replace(pattern,'');
alert('|'+result+'|');

var pattern = /^\s+(.+?)\s+$/; //使用了非贪婪捕获
var str = ' goo gle ';
var result = pattern.exec(str)[1];
alert('|'+result+'|');

var pattern = /^\s+(.+?)\s+$/;
var str = ' goo gle ';
var result = str.replace(pattern,'$1'); //使用分组
alert('|'+result+'|');

验证电子邮件
var pattern = /^([\w\.\-]+)@([\w\-]+)\.([a-zA-Z]{2,4})$/;
var str = 'yc60.com@gmail.com';
alert(pattern.test(str));

转载于:https://www.cnblogs.com/zhengfuheidao/p/6740985.html