Regular expression

Regular expression 用RegExp类表示正则表达式.

正则表达式主要用来验证客户端的输入.填写完以后,发送给服务器.
正则表达式:匹配和文本检索替换的函数.

一,创建正则表达式,提供了2种方法.new和字面量
(1)new 方式创建
var box = new RegExp(‘box‘);    //box 是必须填入的字符串参数.
document.write(box + "<br/>");    //打印出 /box/ //也是正则的边界

var box = new RegExp(‘box‘, ‘igm‘);    //第二个参数是模式修饰符
document.write(box + "<br/>");

模式修饰符:
i     代表忽略大小写
g     全局作用域
m     多行匹配

(2)字面量方式创建
var box = /box/;        //使用字面量方式的正则
alert(box);
//如果想加入修饰符的话,直接加入就可以
var box = /box/igm;
alert(box);

二,匹配正则表达式
pattern用test和exec方法来匹配
RegExp 对象的方法
方法            功能
test         在字符串中测试模式匹配，返回true 或false
exec         在字符串中执行匹配搜索，返回结果数组.

例子
(1)使用new运算符的test正则表达式
var patten = new RegExp(‘Box‘);
var str = ‘box‘;
alert(patten.test(str));        //false 区分大小写

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

(2)使用字面量方式test的正则表达式
var box = /box/;
var str = ‘box‘;
alert(box.test(str));

(3)使用一条语句实现正则表达式 pattern.test(str)
alert(/box/img.test("this is a Box, that is a pox!"));

(4)使用exec来检测
var pattern = /box/img;
var str = ‘this is a box,and that is a Box.‘;
alert(pattern.exec(str));    //box
alert(typeof pattern.exec(str));    

三,使用字符串的正则表达式的方法
除了test和exec方法,String对象也提供了四个使用正则表达是的方法.
(1)match(pattern)                        返回pattern中的子串或null.
(2)replace(pattern, replacement)     用replacement替换pattern
(3)Seach(pattern)                        返回字符串中的pattern开始位置
(4)Split(pattern)                        返回字符串指定pattern拆分的数组

例子:
(1)使用match 方法获取获取匹配数组
var pattern =/box/ig;                    //忽略大小写并且全局搜素
var str =‘this is a box! that is a box.‘;
alert(str.match(pattern));                //box,box
alert(str.match(pattern).length);        //数组长度是2

(2)使用search进行查找
var pattern =/box/ig;
var str =‘this is a box! that is a box.‘;
alert(str.search(pattern));        //10
由于search方法查找的就返回,所以不存在全局g这个模式的概念.
var pattern =/xxxx/ig;
var str =‘this is a box! that is a box.‘;
alert(str.search(pattern));        //找不到返回-1

(3)使用replace替换
var pattern = /box/i;
var str = ‘this is a box, that is a box too‘;
alert(str.replace(pattern, ‘tom‘));
由于不是全局的,所以this is a tom, that is a box too.
var pattern = /box/ig;
var str = ‘this is a box, that is a box too‘;
alert(str.replace(pattern, ‘tom‘));
全局的,所以this is a tom, that is a tom too.

(5)使用split差分字符串成数组
var pattern = / /ig;
var str = ‘this is a box, that is a box too‘;
document.write(str.split(pattern));     //长度是9个
输出  this, is, a, box,, that, is, a, box, too

四,正则表达式的静态属性和实例属性
静态表达式直接调用,无需声明,而实例属性需创建正则表达式.
属性            短名        含义
input             $_         当前被匹配的字符串
lastMatch         $&         最后一个匹配字符串
lastParen         $+         最后一对圆括号内的匹配子串
leftContext     $`         最后一次匹配前的子串
multiline         $*         用于指定是否所有的表达式都用于多行的布尔值
rightContext     $‘         在上次匹配之后的子串

var pattern = /(g)oogle/;
var str = ‘This is google！‘;
pattern.test(str);                    //执行一下
alert(RegExp.input);                 //This is google！
alert(RegExp.leftContext);             //This is
alert(RegExp.rightContext);         //！
alert(RegExp.lastMatch);             //google
alert(RegExp.lastParen);             //g
alert(RegExp.multiline);             //false
PS：Opera 不支持input、lastMatch、lastParen 和multiline 属性。IE 不支持multiline 属性。导致就不用了.

RegExp对象的实例属性
属性                    含义
global                 Boolean 值，表示g 是否已设置
ignoreCase            Boolean 值，表示i 是否已设置
lastIndex             整数，代表下次匹配将从哪里字符位置开始
multiline             Boolean 值，表示m 是否已设置
Source                 正则表达式的源字符串形式
PS：以上基本没什么用。并且lastIndex 在获取下次匹配位置上IE 和其他浏览器有偏差，主要表现在非全局匹配上。lastIndex 还支持手动设置，直接赋值操作。

五.获取控制
正则表达是的元字符是包含特殊含义的字符,它们会有一些特殊的功能,可以控制匹配的模式的方式.反斜杠后的元字符将失去其特殊意义.

(1)字符类:单个字符和数字
元字符/元符号                        匹配情况
.                        匹配出换行符意外的任意字符
[a-z0-9]                    匹配括号中的字符集中的任意字符
[^a-z0-9]                    匹配任意不在括号中的字符集中的字符
\d                            匹配数字
\D                            匹配非数字,同[^0-9]相同
\w                            匹配字母和数字及_
\W                            匹配非字母和数字及_
\d                            匹配0-9之间的数字
\D                            匹配非0-9之间的数字 类似[^0-9]

(2)字符类：重复字符
元字符/元符号                            匹配情况
x?                                     匹配0 个或1 个x
x*                                     匹配0 个或任意多个x
x+                                     匹配至少一个x
(xyz)+                             匹配至少一个(xyz)
x{m,n}                             匹配最少m 个、最多n 个x

(3)字符类：空白字符
元字符/元符                            号匹配情况
\0                                     匹配null 字符
\b                                     匹配空格字符
\f                                     匹配进纸字符
\n                                     匹配换行符
\r                                     匹配回车字符
\t                                     匹配制表符
\s                                     匹配空白字符、空格、制表符和换行符
\S                                     匹配非空白字符

(4)字符类：替代字符
元字符/元符                            号匹配情况
this|where|logo                 匹配this 或where 或logo 中任意一个

(5)字符类：记录字符
元字符/元符                            号匹配情况
(string)                             用于反向引用的分组
\1 或$1                             匹配第一个分组中的内容
\2 或$2                             匹配第二个分组中的内容
\3 或$3                             匹配第三个分组中的内容

例子:
(1)点可以代替除换行符意外的任意字符.
var pattern = /g..gle/ig;
var str = ‘this is a g0agle‘;
alert(pattern.test(str));        //true
如果没有字符,或者为\n就是错误的.
var pattern = /g..gle/ig;
var str = ‘this is a g\nagle‘;        //有换行符
alert(pattern.test(str));        //false

var pattern = /g..gle/ig;
var str = ‘this is a gagle‘;        //缺少一个字符
alert(pattern.test(str));        //false

var pattern = /g..gle/ig;
var str = ‘this is a ga00gle‘;        //多了一个
alert(pattern.test(str));        //false

(2)重复匹配 * 匹配0个或者多个
var pattern = /go*gle/ig;        //o* 代表 匹配0个或多个o.
var str = ‘this is a ggle‘;        //0个是可以的
alert(pattern.test(str));        //true

(3)重复匹配 + 匹配至少一个或者多个
var pattern = /go+gle/ig;            //匹配至少1个或者多个o
var str = ‘this is a ggle‘;
alert(pattern.test(str));            //false,因为没有o

var pattern = /go+gle/ig;
var str = ‘this is a google‘;        //有2个,可以
alert(pattern.test(str));            //true

(4)匹配一个或者0个 ? 问号
var pattern = /go?gle/ig;
var str = ‘this is a google‘;        //2个o就错了
alert(pattern.test(str));            //false

var pattern = /go?gle/ig;
var str = ‘this is a gogle‘;        //一个o是对的
alert(pattern.test(str));            //true

var pattern = /go?gle/ig;
var str = ‘this is a ggle‘;            //没有也可以
alert(pattern.test(str));            //true

组合:
例如:  .?   代表任意字符,一个或者0个

(5)区间  x{m, n}        匹配最少m 个、最多n 个x
var pattern = /go{2,4}gle/ig;        //匹配2到4个o
var str = ‘this is a google‘;        //2个o
alert(pattern.test(str));            //true

绝对限定几次 比如 {2} 2次
{3,} 表示3或者3个以上

(6)字符类匹配
[a-z] 表示26个小写字母都匹配
var pattern = /go[a-z]gle/ig;
var str = ‘this is a google‘;    //o属于[a-z]
alert(pattern.test(str));        //true

var pattern = /go[a-z]gle/ig;
var str = ‘this is a go1gle‘;    //1不属于[a-z]
alert(pattern.test(str));        //false

[A-Z]    大写的A到Z
[0-9]    0到9

例如: [0-9]*        代表0次1次,或者多次的0-9的数字
var pattern = /go[a-z]*gle/ig;
var str = ‘this is a godfdsfdsgle‘;    //有很多次字符属于a-z
alert(pattern.test(str));

[^a-z]        ^符号就是取反,匹配不在括号里面的任意字符
var pattern = /go[^a-z]gle/ig;
var str = ‘this is a go1gle‘;        //1不是a-z
alert(pattern.test(str));            //true

(7)锚元素匹配
^    行首匹配
$    行尾匹配

var pattern = /^[0-9]oogle/ig;
var str = ‘9oogle‘;
alert(pattern.test(str));    //true
注意:这是一个在中括号[],外面添加的^,表示从行首匹配,放在里面是取反.
var pattern = /^[0-9]oogle/ig;
var str = ‘39oogle‘;
alert(pattern.test(str));    //false
这是因为,需要从头开始匹配,第二字符不是o,就返回错误.

var pattern = /[\W]oogle$/ig;    //结尾必须是[\W]oogle
var str = ‘!oogle is good‘;
alert(pattern.test(str));        //false

(8)\w         字母数字和下划线
var pattern = /[\w]oogle/ig;
var str = ‘_oogle‘;
alert(pattern.test(str));    //true
注意:只是下划线,除此之外都不是,比如点(.)或则斜杠等.

\W         除了字符数字和下划线以外的字符
var pattern = /[\W]oogle/ig;
var str = ‘!oogle‘;                //!不是字母,也不是数字和下划线
alert(pattern.test(str));        //true

(9)\s 匹配空白字符、空格、制表符和换行符, (一个空格)
var parrent = /go\sgle/ig;
var str = ‘go gle‘;            //一个空格
alert(parrent.test(str));    //true

var parrent = /go\sgle/ig;
var str = ‘go  gle‘;            //2个空格
alert(parrent.test(str));    //false

(10)\b 表示到达边界或者空格
var parrent = /g\sogle\b/ig;
var str = ‘g ogle‘;            //e在边界
alert(parrent.test(str));    //true

var parrent = /g\sogle\b/ig;
var str = ‘g ogle is not do‘;        //g ogle在边界.空格.
alert(parrent.test(str));

(11)      | 是或,选择模式.
var parrent = /google|baidu|bing/;        //匹配三种模式
var str = ‘www.baidu.com‘;
alert(parrent.test(str));        //true
var str1 = ‘www.bing.com‘;
alert(parrent.test(str1));        //true

(12)分组匹配 用括号括起来,代表一个字符 ()
var parrent = /google{4,8}$/img;
var str = ‘this is a google‘;
alert(parrent.test(str));        //false
错误的原因是要匹配e字母的4到8次,才可以.因为$限定了结尾.

var parrent = /(google){4,8}/img;
var str = ‘this is a google‘;
alert(parrent.test(str));    //false
错误的原因是分组之后,google代表一个字符,要4到8次google才可以.

var parrent = /goog(le){4,8}/img;
var str = ‘this is a googlelelele‘;
alert(parrent.test(str));    //true

var parrent = /goog(le){4,8}/img;
var str = ‘this is a googlelelele‘;
parrent.test(str);
alert(RegExp.$1);         //le
注意:RegExp.$1表示获取模式中第一个分组对应的匹配字符串

var parrent = /goog(le){4,8}/img;
var str = ‘this is a googlelelele‘;
document.write(str.replace(parrent, ‘<strong>$1<strong>‘));        //this is a le
$1表示匹配的第一个分组的内容,给html加粗.

var parrent = /(.*)\s(.*)/img;
var str = ‘baidu google‘;
document.write(str + "<br/>");    //baidu google
document.write(str.replace(parrent, ‘$2 $1‘));//google baidu
这段正则将分组$1和分组$2进行了交换.
贪婪                惰性
+                     +?
?                     ??
*                     *?
{n}                 {n}?
{n,}                 {n,}?
{n,m}                 {n,m}?

(13)贪婪
var parrent = /[a-z]/img;
var str = ‘baidu google‘;
document.write(str.replace(parrent, ‘1‘));    //11111 111111
这是常规替换,将每一个符合规则的字符都替换为1

var parrent = /[a-z]+/img;
var str = ‘baidu google‘;
document.write(str.replace(parrent, ‘1‘));    //1 1
这里是贪婪,将符合规则的字符串全替换为1个1.

var parrent = /[a-z]+?/;
var str = ‘baidu google‘;
document.write(str.replace(parrent, ‘1‘));    //1aidu google
这个是惰性模式,但是开启全局的模式,那么即使开启惰性模式,也要都全是1

var parrent = /8(.*)8/;
var str = ‘8google8 8google8 8google8‘;
document.write(str.replace(parrent, ‘<strong>$1</strong>‘));
//结果是google8 8google8 8google

开启了懒惰模式
var parrent = /8(.*?)8/;
var str = ‘8google8 8google8 8google8‘;
document.write(str.replace(parrent, ‘<strong>$1</strong>‘));
//结果是google 8google8 8google8,只有第一个被匹配了.

var parrent = /8(.*?)8/g;
var str = ‘8google8 8google8 8google8‘;
document.write(str.replace(parrent, ‘<strong>$1</strong>‘));
//结果是 google google google

(14) exec 返回数组
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‘;
alert(pattern.exec(str));    //google2012

var pattern = /^([a-z]+)\s([0-9]{4})$/;
var str = ‘google 2012‘;
document.write(pattern.exec(str));    //google 2012, google, 2012
//array[0]是整个字符串
//array[1]是第一个分组的字符串google
//array[2]是返回分组的第二个字符串:2012.

(15)捕获性分组,就是所有的分组都返回
var pattern = /^(\d+)([a-z])/;
var str = ‘123abc‘;
document.write(pattern.exec(str));    //123a,123,a
//a[0] 123a
//a[1] 123
//a[2] a

(16)非捕获性分组,只要在不需要捕获返回的分组前加上    ?: 就不会返回
var pattern = /^(\d+)(?:[a-z])/;    //a就没有返回
var str = ‘123abc‘;
document.write(pattern.exec(str));    //123a, 123

var pattern = /(a?(b?(c?)))/;
var str = ‘abc‘;
document.write(pattern.exec(str));
//第一步 a[0], 整个匹配到的字符串abc
//第二步 a[1], 匹配第一个分组 (a?(b?(c?))), abc
//第三步 a[2], 匹配第二个分组 (b?(c?)),        bc
//第四步 a[3], 匹配第三个分组 (c?),         c

(17)前瞻捕获(特定捕获,后面接着特定的字符)

var pattern = /goo(?=gle)/;        //goo后面必须跟着gle才可以
var str = ‘google‘;
alert(pattern.exec(str));        //返回goo,而不是google

var pattern = /goo(?=gle)/;        //goo后面必须跟着gle才可以
var str = ‘googge‘;
alert(pattern.exec(str));        //返回 null

(18)使用特殊字符进行捕获,用反斜杠转义,才可以匹配
var pattern = /\/\?/;        // / 和 ? 都转义了.
var str = ‘12//3d/?.!ef‘;
alert(pattern.exec(str));    

(19)换行模式
var pattern = /\d+/ig;
var str = ‘121331\n324234\n3d323432ef‘;
alert(str.replace(pattern, ‘#‘));    //都替换了

如果限定首部,那么必须开启换行模式---m
var pattern = /^\d+/igm;
var str = ‘121331\n324234\n3d323432ef‘;
alert(str.replace(pattern, ‘#‘));

五,常用的正则表达式
1.检查邮政编码 规则:6位,并且第一位不为0
var pattern = /[1-9][0-9]{5}/;
var post = 123124;
alert(pattern.test(post));

2.文件压缩包 股则:后缀名zip rar.gz,文件名是字母数字下划线
var str = ‘2-z.zip‘;
var pattren = /^[\w\-]+\.zip|rar|gz/;
alert(str.match(pattren));

3.删除多余空格
var str = ‘this is a  boy, that is   a girl.‘;
var pattern = /\s/img;
alert(str.replace(pattern, ‘‘));

4.删除首尾空格
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 = ‘ google ‘;
alert(‘|‘ + pattern.exec(str)[1] + ‘|‘);
var pattern = /^\s*(.+?)\s*$/;
var str = ‘ google ‘;
alert(‘|‘ + str.replace(pattern, ‘$1‘) + ‘|‘); //使用了分组获取
5.简单的电子邮件验证
var pattern = /^([a-zA-Z0-9_\.\-]+)@([a-zA-Z0-9_\.\-]+)\.([a-zA-Z]{2,4})$/;
var str = ‘[email protected]‘;
alert(pattern.test(str));
var pattern = /^([\w\.\-]+)@([\w\.\-]+)\.([\w]{2,4})$/;
var str = ‘[email protected]‘;
alert(pattern.test(str));