正则表达式-白红宇

正则表达式

阅读量：5222 次

发布时间：2019-06-14

本文共 47309 字，大约阅读时间需要 157 分钟。

作用：查找，替换，数据有效的验证

============================================

搜狗：zhengze(正则) zhengzebiaodashi(正则表达式) tanlanpipei(贪婪匹配)/feitanlanpipei(非贪婪匹配)

regexp weizhipipei(位置匹配)/bianjiepipei(边界匹配) replace

buhuoxingfenzu(捕获性分组)/fenzu(分组) qianzhanxingpipei(前瞻性匹配)

一，正则表达式总结

1，查找特定字符 pattern.exec/test(str) str.match/search(pattern)

2，替换文本（eg:敏感词过滤） str.replace(pattern);

3，数据有效性验证邮箱，QQ，密码等等

二，创建正则表达式的两种方式：

1，字面量或者直接量：

var pattern=/^\w{10,20}$/img;

2，构造函数：

var pattern=new RegExp("^\w{10,20}$","img");

var a="^\w{10,20}$";

var pattern=new RegExp(变量a,"img");

三，模式修饰符

1，g(global) 全局匹配

2，i(ignoreCase) 忽略大小写

exec方法：无论是否全局匹配，都会返回分组中匹配到的内容；

无论是否全局匹配，都只返回当前匹配到的一个内容，而不是所有。

只不过全局匹配时可以继续匹配下去(lastIndex，等于返回匹配到的字符串最后一个字符的索引加1)

match方法：只有非全局匹配，才会返回分组中匹配到的内容；

全局匹配会一次性返回所有匹配到的字符。

replace方法：非全局匹配，只替换第一个匹配到的内容

全局匹配会替换所有匹配到的内容。

其他 pattern.test(str) str.search/split(pattern);是否全局匹配，结果都是一样的。

3，m(multiple/multiply) 多行匹配

a,java java java

b,java java java

c,java java java

多行匹配必须符合两个条件：1，全局匹配，2，使用首(^...)(...$)尾匹配

四，转义字符

1，\n newline 换行符

2，\t tab 制表符

3，\xnn 由十六进制数nn指定的拉丁字符(eg.\x0A === \n) 可以查询：ASCII码对照表

4，\uxxxx 由十六进制数xxxx指定的Unicode字符(eg.\u0009 === \t) 可以查询：Unicode字符大全

此外，正则构造函数创建正则对象时，转义字符必须是双重转义

即：邮箱： var pattern=new RegExp("(\\w+\\.)*[a-z]+@([a-z]*[-_\\.])+[a-z]{2,4}")

还有 [\u4e00-\u9fa5]{2,4} 表示2到4个汉字

五，字符类

1，[...] 表示方括号里面的任意一个字符，

相反[^...]是除了方括号里面的字符外，其他任意字符

2，\. 除换行符外的任意一个字符

3，\w 表示任何字母，数字，下划线组成的一个字符 w = word

相反\W 表示除了字母，数字，下换线外，其他任意组成的字符。

4，\d 表示任何数字 \D 表示除了数字外的任何字符 d = digital 数字

5，\s 表示任何Unicode空白字符(eg,空格，制表符，\n)

\S 表示除了空白字符外的任意字符。 s = spancing

六，量词(重复)

1，{n,m} 表示：n <= x <= m

2，{n,} 表示：x >= n

3，{n} 表示：x = n

4，? 表示： {0,1} 表示： 0 <= x <= 1

5，+ 表示：{1,} 表示： x >= 1

6，* 表示：{0,} 表示： x >= 0

七，贪婪匹配和非贪婪匹配搜狗：tanlanpipei(贪婪匹配) feitanlanpipei(非贪婪匹配)

贪婪与非贪婪的概念只有当你使用量词的时候才有意义。

贪婪匹配即匹配允许次数的最多次数如{n,m} 即往实际可匹配的最大数进行匹配最多可匹配m次

非贪婪匹配即匹配允许次数的最少次数如{n,m} 即往实际可匹配的最小数进行匹配，最少匹配n次

1，{n,m}? 表示 n <= x <= m 非贪婪匹配匹配允许的最少次数n

2，{n,}? 表示 x >= n 非贪婪匹配匹配允许的最少次数n

3，{n}?==={n} 表示 x=n 贪婪匹配和非贪婪匹配结果都一样只能匹配n次

4，??==={0,1}? 表示非贪婪匹配匹配允许的最少次数0次

5，+?==={1,}? 表示非贪婪匹配匹配允许的最少次数1次

6，*?==={0,}? 表示非贪婪匹配匹配允许的最少次数0次

//注意str里面的空格也会匹配的，谨记

var str="html htmllllll html css css css java java java";

//默认贪婪匹配，匹配最多次数5次。

//str中htm后面的 l 最少匹配两次，最多匹配五次,而不是html整个。谨记。

var pattern=/html{2,5}/;

//返回：["htmlllll", index: 5,...]

console.log(pattern.exec(str));

//注意str里面的空格也会匹配的，谨记

var str="html htmllllll html css css css java java java";

//这里是非贪婪匹配，匹配最少的次数，两次。

//str中htm后面的 l 最少匹配两次，最多匹配五次,而不是html整个。谨记。

var pattern=/html{2,5}?/;

//返回：["htmll", index: 5,...]

console.log(pattern.exec(str));

//注意str里面的空格也会匹配的，谨记

var str="html htmllllll html css css css java java java";

//默认贪婪匹配，匹配最多次数1次。

//str中htm后面的 l 最少匹配0次，最多匹配1次,而不是html整个。谨记。

var pattern=/html??/;

//返回：["htm", index: 0, input:...]

console.log(pattern.exec(str));

//注意str里面的空格也会匹配的，谨记

var str="html htmllllll html css css css java java java";

//这里是非贪婪匹配，匹配最少的次数，0次。

//str中htm后面的 l 最少匹配0次，最多匹配1次,而不是html整个。谨记。

var pattern=/html?/;

//返回：["html", index: 0,...]

console.log(pattern.exec(str));

var str="htmlhtmlhtmlcsscsscssjavajavajava";

//即：使用(html)匹配1到3次，这里是贪婪匹配，所以允许的最多次数 3

//?: 不捕获分组

var pattern=/(?:html){1,3}/;

//返回：index.html:14 ["htmlhtmlhtml", index: 0, ...]

console.log(pattern.exec(str));

var str="htmlhtmlhtmlcsscsscssjavajavajava";

//即：使用(html)匹配1到3次，这里是非贪婪匹配，所以允许的最少次数 1

//?: 不捕获分组

var pattern1=/(?:html){1,3}?/;

//返回：["html", index: 0, ...]

console.log(pattern1.exec(str));

//注意str里面的空格也会匹配的，谨记

var str="html html html css css css java java java";

//这里是非贪婪匹配，匹配允许的最多次数

//等价于 /htm(l){1,3}/; 千万别理解错了

var pattern=/html{1,3}/;

//返回：["html", index: 0, ...]

console.log(pattern.exec(str));

</script>

八，选择，分组和引用搜狗：fenzu(分组) yinyon(引用)

1，| 选择，匹配该符号左边或者右边的内容

2，(...) 分组表示统一操作;捕获括号中的内容

3，(?:...) 非捕获性分组，不参与下面的引用计数

4，\n 第n个捕获性分组的引用 (eg. \1\2\3);

九，捕获到的内容

1，exec返回的数组，只返回第一个匹配到的字符

2，var pattern=/([a-z]+)@([0-9]+)@\1\2/; \1...\9引用分组只能用于pattern模式中

3，replace 的第二个参数中，$1

4，RegExp.$1

捕获性分组引用 $1的两种情况：

第一种：作为匿名函数的参数第二个参数：$1

var str="htmlss htmlss java script htmlss javascript htmlss";

var pattern=/html(ss)+/g;

str.replace(pattern,function(all,$1){

//上面可以匹配到4次，每次匹配一次 all=htmlss 连续匹配4次

//all并不是结果的集合，而是all等于每次匹配到的结果。

//console.log(all);会连续输出4次 htmlss

console.log(all);

//all 可以匹配到几次分组引用$1也可以匹配到几次

//因为 $1 属于 all 的子匹配。

//all 会输出几次，$1 也会输出几次。

console.log($1)

/*输出结果：

htmlss

ss*/

})

</script>

捕获性分组引用 $1的三种情况：

第二种：把引用分组$1直接发按在字符串中: "$1"

var str="htmlss htmlss java script Lovejavascript htmlss";

var pattern=/[A-Z][a-z]{3}(javascript)/g;

// $1 可以放到双引号中

// $1 代表 javascript

// 下面表达式：字符串str使用$1(javascript) 代替 pattern与str匹配得出的内容(Lovejavascript)

// 返回：htmlss htmlss java script javascript htmlss

console.log(str.replace(pattern,"$1"));//这里的 "$1" 一定要写在引号中，否则报错

</script>

捕获性分组引用 $1的三种情况：

第三种：使用构造函数创建正则表达式，并且运行 exec,replace,match,search等等

才能使用正则表达式对象：RegExp.$1 读取捕获性分组引用

var str="htmlss htmlss java script Lovejavascript htmlss";

var pattern=new RegExp("[A-Z][a-z]{3}(javascript)","g");

str.replace(pattern,"$1");

//返回：javascript

console.log(RegExp.$1);

</script>

搜狗：bianjiepipei 边界匹配 weizhipipei 位置匹配，

十，指定匹配位置

1，^ "^h[a-z]*" 首匹配：匹配以 h 开头的字符串

2，$ "[a-z]@$" 尾匹配: 匹配以 @ 结尾的字符串

3，如果需要验证QQ，密码，姓名，身份证等等，那么必须在头尾加上首尾匹配：[^...$]

4，\b (border) 表示单词边界。 \B 表示和 \b 相反：非单词边界，用于获取dom节点。即：\w 和 \W 之间的位置

5，前瞻性匹配和负向前瞻性匹配

java(?=script) 表示只匹配后面等于script的java字符串。

java(?!script) 表示只匹配后面不等于script的java字符串。

//-----\b 位置匹配之匹配单词边界-----

// \b 即是：border 边界，边框

var str="js html css";

var pattern1=/css\b/;

//返回：["css", index: 8, input: "js html css", groups: undefined]

console.log(pattern1.exec(str));

var pattern2=/\bjs/;

//返回：["js", index: 0, input: "js html css", groups: undefined]

console.log(pattern2.exec(str));

var pattern3=/\bhtml\b/;

//返回：["html", index: 3, input: "js html css", groups: undefined]

console.log(pattern3.exec(str));

var str="#_html#html55￥html3@#%@$html@!#";

var pattern=/\bhtml\b/;

//返回：["html", index: 24, input: "#_html#html55￥html3@#%@$html@!#", groups: undefined]

//注意这里匹配索引是从第24开始的，第一个_html，第二个html55,第三个html3 三个是匹配不成功的。

//即：\b 匹配单词边界某个单词的首尾边界的字符类一定不能是 [^\w]=[^a-zA-Z0-9_]，否则返回null

//说白了就是除了大小写字母，数字，下划线，其他字符类才能匹配的上。才能使用\b取到该单词

console.log(pattern.exec(str));

</script>

十一，RegExp对象的实例方法

1，test(字符串) pattern.test(str) 匹配成功返回true，否则返回false

2，exec(字符串) pattern.exec(str) 返回第一个匹配到的字符串，没匹配到返回null

3，继承的方法： toString() = toLocaleString() //很大程度上这两个相等

valueOf = pattern //valueOf 即等于正则本身

十二，RegExp对象的实例属性了解即可

1，global 是否设置了g 全局匹配

2，ignoreCase 是否设置了i 忽略大小写

3，multiline 是否设置了m 多行匹配

4，source 字面量形式对应的字符串，即：var pattern=/\w+\.[a-z]+/;

5，lastIndex 开始搜索下一个匹配项的字符位置，默认0

如果不是0，lastIndex的值等于当前匹配到的字符串最后一个字符的索引+1。

十二，RegExp对象的构造函数属性

1，input 匹配的字符串

2，lastMatch 最近一次的匹配项

3，lastParen 最近一次匹配的捕获组

4，leftContext 字符串中匹配到的内容之前的文本

5，rightContext 字符串中匹配到的内容之后的文本

6，$1-$9 第1-第9个匹配到的捕获组

十三，String对象和正则表达式相关方法

1，search(正则表达式或字符串) str.search(pattern/"[a-z]*\w*");

2，match(正则) str.match(pattern)

3，split(正则或字符串) str.split(pattern/"[a-z]+\.[a-z]+");

4，replace(正则或字符串，替换成的文本或者函数)

str.replace(pattern,"....");

str.replace(pattern,function(all,$1){});

=====================================

正则表达式简写字母的单词：

spacing :\s 空白字符

word :\w 英文字母，数字，下划线

newline :\n 换行

digital :\d 数字

/./ :除了换行符\n,其他字符都可以匹配的上

var pattern4=/\d?/;//匹配0次或者1次。 ?={0,1} 表示匹配0次或者1次

正则表达式的声明：

1，字面量

var a=[] 数组

var obj={} 对象

var fn=function(){}

/正则表达式/

如：/js/

2，构造函数

var a=new Array();

var obj=new Object();

var fn=new Function():

var reg=new RegExp('lar exp');//regular expression

正则中的普通字符有：字母、数字、下划线(_)、汉字、空格以及其他一些没有特殊含义的字符(!@,;等)。而”.”在正则中具有特殊含义

正则表达式有两种方法：一种是字面量，格式是写在/ /中，另一种是用构造方法，里面写字符串或者是字符串的变量。

正则表达式中有三种模式修饰符：

1，i ignoreCase 忽略大小写

2，g global 全局匹配

3，m multiply 多行匹配

A：不区分大小写，修饰符i。

B：行首行尾，修饰符m，两个要求：1，必须是全局匹配g 2，必须配合首尾匹配才行，否则不起作用

D：全局匹配，修饰符g，匹配所有元素，如有多个匹配时，返回数组。

修饰符多放在第二个斜杆后面如：

var pattern=/you/igm; //修饰符不分先后，可以是一个i，也可以是两个或者三个。

var pattern=/you/gim; //修饰符不分先后，可以是一个i，也可以是两个或者三个。

var pattern=/you/mig; //修饰符不分先后，可以是一个i，也可以是两个或者三个。

正则表达式表示法：

//字面量创建正则表达式： var pattern=/正则表达式/;

var str="I Love you I lOve you I LoVe you I love you";//匹配正则表达式的字符串

var pattern=/love/i;//表示正则表达式 pattern 模式

//pattern.test(str)，使用正则表达式pattern在字符串str中测试，是否存在。存在返回true，否则返回false。

console.log(pattern.test(str));//返回 true

//使用正则表达式pattern在字符串str中执行，存在返回数组，不存在返回null

console.log(pattern.exec(str));//只匹配第一个字符串，后面的忽略，返回["Love", index: 7, input: "I love you", groups: undefined]

//--------

var str="I love You I love You I love You I love You";//匹配正则表达式的字符串

var pattern1=/you/i;// i(ignoreCase)表示忽略大小写,这里的y是小写的，str的Y是大写的。

//使用正则表达式pattern1在字符串str中测试是否匹配的上，能，返回true，否则返回false.

console.log(pattern1.test(str));//true

//表示使用正则表达式pattern1匹配字符串str，匹配成功返回成功字符串的数组，否则返回null

console.log(pattern1.exec(str));//只匹配第一个字符串，后面的忽略，返回["You", index: 7, input: "I love You I love You I love You I love You", groups: undefined]

//构造函数创建正则表达式

var str="I love You I love You I love You I love You I love You ";

var pattern=new RegExp("you");

//使用正则表达式pattern在字符串str中进行匹配，匹配成功返回true，否则返回false

console.log(pattern.test(str));//test表示测试是否成功，成功true，否则false

//使用正则表达式pattern在字符串str中进行匹配，匹配成功返回数组，否则返回null

console.log(pattern.exec(str));// exec 表示是否匹配成功，成功返回数组，否则返回null

var str="I love You I love You I love You I love You I love You ";

var pattern=new RegExp("you","i");

console.log(pattern.test(str,"i"));//返回 true

//返回：["You", index: 7, input: "I love You I love You I love You I love You I love You ", groups: undefined]

console.log(pattern.exec(str,"i"));//匹配成功，只返回第一个字符串

</script>

//字面量和构造函数正则表达式，怎么选择：

//字面量正则表达式：固定死的，不可修改的，但是比较方法简单，好用。

var str="I love You";

var inp="love";

var pattern=/love/i;//正则表达式，这是固定死的，不可修改。

var pattern1="/"+inp+"/";

/*console.log(typeof pattern);//返回 object

console.log(typeof pattern1);//返回string，test exec两个方法属于正则表达式，字符串是不存在该方法的。

console.log(pattern1);//返回字符串：/love/ */

//构造函数正则表达式new RegExp(参数,"img") 构造函数方式正则表达式可以通过一个参数进行变更，比较灵活

//，但同时也比较复杂，笨重，效率低一些

var str="I love You";

var inp="love";

var pattern2=new RegExp(inp,"i");

console.log(pattern2.test(str));//返回 true

console.log(pattern2.exec(str));//返回 ["love", index: 2, input: "I love You", groups: undefined]

</script>

/*var s="//这是注释";

var pattern=/\/\//; //转义字符，加一个反斜杠就从特殊字符转换为普通字符

console.log(pattern.exec(s));

var str="\\\\";//字符串为两根反斜杠，需要进行转义。第1,3两根反斜杠是转义，2,4是字符串反斜杠

console.log(str);// 返回 \\

var pattern = /\\\\/;//第1,3反斜杠是转义字符，第2,4是字符串反斜杠

console.log(pattern.exec(str));//返回 ["\\", index: 0, input: "\\", groups: undefined]

var str="1.html\n2.css\n3.javascript";// \n 表示换行

console.log(str);//返回如下：

/*1.html

2.css

3.javascript*/

//textarea中的回车可以用\n来匹配，而\x0A和\u000A也可以表示\n ，一个是ASCII码，一个是unicode

var pattern=/\x0A/; // \n 表示换行换行使用十六进制：\x0A 0表示零

//返回：["↵", index: 6, input: "1.html↵2.css↵3.javascript", groups: undefined]

console.log(pattern.exec(str));

/*var a=" sj";

var pattern=/\t/; //特殊字符 \t表示制表符,两个或者四个空格，即：Tab键

//[" ", index: 0, input: " sj", groups: undefined]

console.log(pattern.exec(a));*/

</script>

//换行使用十六进制，unicode编码表示：\x0A \u000A

var str='a\nb';

var pattern=/\x61\x0A\x62/;

//ASCII码十六进制 \x61 = a \x62 = b

//返回：["a↵b", index: 0, input: "a↵b", groups: undefined]

console.log(pattern.exec(str));

console.log("\x62");//输出 b

console.log("\x40");//输出@

console.log("U+0C08");//

console.log("\u0009");//输出空格

</script>

<!-- \n newline 换行

\t 一个Tab键(表示两个或者四个空格)，特殊符号的都是使用转义字符：\ 反斜杠 -->

var str = '/[a\nb]/';

var pattern=/\/\[a\nb\]\//

console.log(pattern.exec(str));

//输出 ["/[a↵b]/", index: 0, input: "/[a↵b]/", groups: undefined]

</script>

var str="sjavascript";

var pattern=/[js]/;//匹配返回js中的任意一个字符

//[sjs]表示：匹配[]中的任意一个字符，返回匹配到的第一个字符。

//且是用字符串str中的s去匹配pattern中的[js]，如果匹配返回匹配到的字符，

//否则使用str中的j去匹配pattern中的[js]，以此类推。

//返回：["s", index: 0, input: "sjavascript", groups: undefined]

console.log(pattern.exec(str));//返回返回数组，且只有一个数组元素： s

var str="sjavascript";

var pattern1=/[^js]/;//匹配返回除了js以外的任意字符。

//["a", index: 2, input: "sjavascript", groups: undefined]

console.log(pattern1.exec(str));//返回返回数组，且只有一个数组元素： a

var str="sjavascript";

//前面的一定要比后面的小即可,[c-d] [c-c]等等,否则报错。

var pattern2=/[a-z]/;//表示匹配返回 a 到 z 26个英文字母。

//返回数组：["s", index: 0, input: "sjavascript", groups: undefined]

console.log(pattern2.exec(str));//返回数组

var str1="Alex帅速度飞了数据库的";//匹配中文

//[\u4e00-\u9fa5]，有且只匹配第一个汉字。后面的汉字忽略

var pattern3=/[\u4e00-\u9fa5]/;//只要是汉字都被包括在unicode编码中：\u4e00-\u9fa5

//返回数组：["帅", index: 4, input: "Alex帅", groups: undefined]

console.log(pattern3.exec(str1));//返回数组

var str2="javaScript";

var pattern4=/[a-zA-Z]/;//匹配大小写a-z都可以，有且只匹配第一个字母。

//返回数组：["j", index: 0, input: "javaScript", groups: undefined]

console.log(pattern4.exec(str2));

var str2="javaScript";

var pattern5=/[A-Z]/;//匹配大写A-Z,有且只匹配第一个大写字母

//返回数组：["S", index: 4, input: "javaScript", groups: undefined]

console.log(pattern5.exec(str2));

var str3="javaScript3.9";

var pattern=/[0-9]/;//数字最小为0 最大为9 不能负数

//返回数组：["3", index: 10, input: "javaScript3.9", groups: undefined]

console.log(pattern.exec(str3));

var str3="JavaScript3.3";

var pattern=/[0-9a-zA-Z]/;//表示可以匹配 0-9 a-z A-Z 中的任意一个字符，且返回第一个字符的数组。

//返回数组：["J", index: 0, input: "JavaScript3.3", groups: undefined]

console.log(pattern.exec(str3));

var str="*_@#JavaScript_3.6.@qq.com";

// 除以上外，还可以：随便添加任意字符

var pattern=/[*&_@a-zA-Z0-9']/;

//返回数组：["*", index: 0, input: "*_@#JavaScript_3.6.@qq.com", groups: undefined]

console.log(pattern.exec(str));

</script>

注册网站时，一般都需要填写用户名。现要求用户名可以包含空格、中文、字母、数字以及下划线，请写出能与之匹配的正则表达式：

A，/[\u4e00-\u9fa5 a-zA-Z0-9_]/

B，/[\u4e00-\u9fa5 a-z0-9_]/i i表示:忽略大小写

C，/\u4e00-\u9fa5 a-zA-Z0-9_/ 里面所有项都要匹配

解析：

\u4e00-\u9fa5 表示所有汉字

正则范围的写法中，前面的要小于等于后面的。同时字母最小为a，最大为z；数字最小为0，最大为9；i表示不区分大小写的匹配 ; [ ]表示匹配其中的任意一个就可以匹配到，/ /中的话必须是每个字符都要匹配

正则表达式简写字母的单词：spacing word newline digital multiline的首个字母

[ ] 包含一系列字符，能够匹配其中任意一个字符。

/ / 写字符表示匹配其中每一个字符，

[^ ] 包含一系列字符，则能够匹配其中字符之外的任意一个字符。

\s 表示空格和其他空白字符 spacing 空格，空白字符

\S 表示匹配除了空格和其他空白字符外的其他所有字符中的一个。

\w 表示[a-zA-Z0-9_], 匹配a-zA-Z0-9_之间的任意一个字符。 word 英文单词+数字下划线

\W 表示[^a-zA-Z0-9_]，匹配除了a-zA-Z0-9_之外的字符。

. 表示匹配除了\n换行符外的其他所有字符，有且只匹配第一个。

[^\n] 匹配除了\n换行之外的所有字符有且只有第一个字符。 newline 换行

首先正则表达式要写在//中，

中文的表示是\u4e00-\u9fa5，\w表示[A-Za-z0-9_]，

\s表示空格和其他空白字符，\加上大写字母表示\加上其对应小写字母的相反含义，

所以包含空格、中文、字母、数字以及下划线的正则表达式应该是/[\u4e00-\u9fa5\s\w]/

var str="3.1415926";

var pattern=/./;//表示除了\n，其他所有字符都可以匹配到。

var pattern1=/[^\n]/;//匹配除了\n换行之外的所有字符。

var pattern2=/\./;//匹配小数点.

//返回数组：["3", index: 0, input: "3.1415926", groups: undefined]

console.log(pattern.exec(str));//等价下一行

//返回数组：["3", index: 0, input: "3.1415926", groups: undefined]

console.log(pattern1.exec(str));//等价上一行

//返回数组：[".", index: 1, input: "3.1415926", groups: undefined]

console.log(pattern2.exec(str));//返回数组 .

var str1="\n";//换行

var pattern=/./;//除了换行符，其他都可以匹配。

console.log(pattern.exec(str1));//匹配不到返回：null

// \w 等价于 [a-zA-Z0-9_] 只匹配 a-zA-Z0-9_ 内的字符串

// \W 等价于 [^a-zA-Z0-9_] 只匹配除了 a-zA-Z0-9_ 以外的字符串

// \大写字母一般表示 \小写字母匹配值的取反

var str="_@sdk";

var pattern=/\w/;//等价于下面一行

var pattern1=/[a-zA-Z0-9_]/;

//返回数组：["_", index: 0, input: "_@sdk", groups: undefined]

console.log(pattern.exec(str));

//返回数组：["_", index: 0, input: "_@sdk", groups: undefined]

console.log(pattern1.exec(str));

var str="JavaScript3.3";

var pattern=/[0-9]/;//表示只匹配0-9,且只返回第一个匹配字符

//返回数组：["3", index: 10, input: "JavaScript3.3", groups: undefined]

console.log(pattern.exec(str));

var pattern1=/\d/;//表示只匹配0-9,且只返回第一个匹配字符

//返回数组：["3", index: 10, input: "JavaScript3.3", groups: undefined]

console.log(pattern1.exec(str));

var pattern2=/[^0-9]/;//表示只匹配除了0-9之外的所有字符,且只返回第一个匹配字符

//返回数组：["J", index: 0, input: "JavaScript3.3", groups: undefined]

console.log(pattern2.exec(str));

var pattern3=/\D/;//表示只匹配除了0-9之外的所有字符,且只返回第一个匹配字符

//返回数组：["J", index: 0, input: "JavaScript3.3", groups: undefined]

console.log(pattern3.exec(str));

var str=" ";//这里是空格键的空格

var pattern=/\s/;// 表示匹配空格，Tab键，unicode等等空格

//返回数组：[" ", index: 0, input: " ", groups: undefined]

console.log(pattern.exec(str));

var str1=" ";//这里是Tab键的空格

var pattern1=/\s/;//匹配空格键空格，Tab键空格，unicode等等空格

//返回数组：[" ", index: 0, input: " ", groups: undefined]

console.log(pattern1.exec(str));

//这里第一个字符是空格，不管什么空格都可以用\s进行匹配，或者使用\S进行排除匹配

var str2=" #string";

var pattern3=/\S/;//表示匹配除了空格外的所有其他字符。

//返回数组：["#", index: 1, input: " #string", groups: undefined]

console.log(pattern3.exec(str2));

var str4=" 1234";//第一个字符是空格

// \s表示空格 \d 表示数字也可以写在中括号中[]

var pattern4=/[\s\d]/;//表示只匹配空格或者数字中的一个。

//返回数组：[" ", index: 0, input: " 1234", groups: undefined]

console.log(pattern4.exec(str4));

</script>

==================

-----正则的量词-----

<!-- 正则表达式中的量词：

? = {0,1} 表示匹配数目为0到1

+ = {1,} 表示匹配数目为最少一个

* = {0,} 表示匹配数目为可有可无，如果有则匹配最长的数目

. = {1,1} 如果只写一个.后面不跟量词，默认只匹配一个，如下例子：-->

var str="JavaScript is fun abcdad";

// . 表示除了换行符\n，其他所有字符类都匹配，没有写量词默认只匹配一个

var pattern=/a./;

//返回数组：(2) ["av", "aS"]

console.log(str.match(pattern));//都是匹配的意思，只是写法不一样

//上下两句都返回：["av", index: 1, input: "JavaScript is fun abcdad", groups: undefined]

console.log(pattern.exec(str));//都是匹配的意思，只是写法不一样

</script>

//匹配str中的 1.1@Admin

var str = '192.168.1.1@Admin';

/*此处写代码*/

var pattern=/[0-9]\.[0-9]@\w\w\w\w\w/;//等价于下一行

var pattern3=/[0-9]\.[0-9]@\w{5}/;//等价于上一行，正则量词表示法

var pattern1=/1\.1@Admin/;

var pattern2=/1\.1@admin/i;

//返回数组：以下四行输出都是：["1.1@Admin", index: 8, input: "192.168.1.1@Admin", groups: undefined]

console.log(pattern.exec(str));

console.log(pattern1.exec(str));

console.log(pattern2.exec(str));

console.log(pattern3.exec(str));

var str = '192.168.1.1@Admin';

var pattern=/\d{3}/;

//返回数组：["192", index: 0, input: "192.168.1.1@Admin", groups: undefined]

console.log(pattern.exec(str));

var pattern1=/\d{1,6}/;//匹配数字大于等于 1 小于等于 6

//返回全是数组，谨记。这里是匹配大于等于1，小于等于6，系统默认匹配最长的(贪婪匹配)，这里只能匹配到192三位数，后面是点。

console.log(pattern1.exec(str));//["192", index: 0, input: "192.168.1.1@Admin", groups: undefined]

var pattern2=/\d{3,6}/;//匹配数字大于等于 3 小于等于 6

//返回全是数组，谨记。这里是匹配大于等于3，小于等于6，系统默认匹配最长的(贪婪匹配)，这里只能匹配到192三位数，后面是点。

console.log(pattern2.exec(str));//["192", index: 0, input: "192.168.1.1@Admin", groups: undefined]

var pattern3=/\d{1,2}/;//匹配数字大于等于 1 小于等于 2

//返回全是数组，谨记。

console.log(pattern3.exec(str));//["19", index: 0, input: "192.168.1.1@Admin", groups: undefined]

//谨记一个容易放的错误：

//var pattern1=/\d{1, 6}/;这样写一定错了，大括号中一定不能有空格。

//var pattern1=/\d{1,6}/;

var str = '17891852019';

var pattern1=/\d{1,}/;//匹配最少一个数字

var pattern3=/\d{3,5}/;//匹配数字个数：大于等于3，小于等于5

console.log(pattern1.exec(str));

//返回数组：["17891", index: 0, input: "17891852019", groups: undefined]

console.log(pattern3.exec(str));

// var pattern2=/\d{,3}/;没有该种写法，报错

var str = '17891852019';

var pattern1=/\d?/;//匹配0次或者1次。 ?={0,1} 表示匹配0次或者1次

//返回数组：["1", index: 0, input: "17891852019", groups: undefined]

console.log(pattern1.exec(str));

//等价于：var pattern2=/\d{1,}/; 逗号后面不能有空格，否则返回null

var pattern2=/\d+/;//匹配数字个数：匹配最少一个数字，有多少匹配多少最少一次

//返回数组：["17891852019", index: 0, input: "17891852019", groups: undefined]

console.log(pattern2.exec(str));

//等价var pattern3=/\d{0,}/;逗号后面不能有空格，否则返回null

var pattern3=/\d*/;//匹配数字个数：匹配任意个数，有无都行

//返回数组：["17891852019", index: 0, input: "17891852019", groups: undefined]

console.log(pattern3.exec(str));

var str="麦当劳豪华午餐：115.8 RMB";

var pattern=/\d+\.?\d*/;

//返回数组：["115.8", index: 8, input: "麦当劳豪华午餐：115.8 RMB", groups: undefined]

console.log(pattern.exec(str));

//上下两行写法等价。

var pattern1=/\d{1,}\.{0,1}\d{0,}/;

//返回数组：["115.8", index: 8, input: "麦当劳豪华午餐：115.8 RMB", groups: undefined]

console.log(pattern1.exec(str));

var str="123456";

var pattern=/\d{0,1}/;//匹配数目为：0个或者1个

//返回数组：["1", index: 0, input: "123456", groups: undefined]

console.log(pattern.exec(str));

var pattern1=/\d{0,2}/;//匹配数目为：匹配数目可以是0,1,2。

//返回数组：["12", index: 0, input: "123456", groups: undefined]

console.log(pattern1.exec(str));

var pattern3=/\d{3,5}/;//匹配数目为：3到5个

//返回数组：["12345", index: 0, input: "123456", groups: undefined]

console.log(pattern3.exec(str));

</script>

1，贪婪与非贪婪的概念只有当你使用量词的时候才有意义。

2，正则表达式的模式匹配总是会寻找字符串中第一个可能匹配的位置。

3，要想将贪婪转换成非贪婪匹配，只需在量词后面加上?

//贪婪匹配，{a,b} 匹配的是最大数目，如果存在b个数目，则匹配b个数目

//非贪婪匹配，{a,b} 匹配的是最小数目，即匹配a个数目

var str="aaaab";

var pattern=/a{0,}/;//匹配任意个数目，默认匹配最大数目，即贪婪匹配。

//返回数组，["aaaa", index: 0, input: "aaaab", groups: undefined]

console.log(pattern.exec(str));//贪婪匹配，匹配最大数目

// 非贪婪匹配

var str="aaaab";

var pattern1=/a+?/;// + 表示{1,}； ?表示非贪婪匹配，只匹配量词第一个

//返回数组：["a", index: 0, input: "aaaab", groups: undefined]

console.log(pattern1.exec(str));//非贪婪匹配,只匹配一个

var str="aaaab";

var pattern2=/a{2}?/;// 第一个?表示{0,1}; 第二个?表示非贪婪匹配，只匹配量词第一个值

//返回数组：["aa", index: 0, input: "aaaab", groups: undefined]

console.log(pattern2.exec(str));//非贪婪匹配，只匹配一个

var str="bbbaaaaab";

//这里的a后面没有量词，即?表示{0,1}，而不是非贪婪匹配

var pattern2=/a?/;

//返回：["", index: 0, input: "bbbaaaaab", groups: undefined]

console.log(pattern2.exec(str));//这个为什么返回空

var str="aaaaab";

//这里的a后面没有量词，即?表示{0,1}，而不是非贪婪匹配

var pattern2=/a?/;

//返回：["a", index: 0, input: "aaaaab", groups: undefined]

console.log(pattern2.exec(str));//这个为什么返回a呢

var str="aaaab";

var pattern2=/a*?/;// * 表示{0,}; ?表示非贪婪匹配，只匹配量词中的第一个值，这里第一个是0，即匹配空""

//返回数组：["", index: 0, input: "aaaab", groups: undefined]

console.log(pattern2.exec(str));//非贪婪匹配，只匹配一个

var str="aaaab";

var pattern2=/a??/;// 第一个?表示{0,1}; 第二个?表示非贪婪匹配，只匹配0个

//返回数组：["", index: 0, input: "aaaab", groups: undefined]

console.log(pattern2.exec(str));//非贪婪匹配，只匹配量词中的第一个值，这里第一个是0，即匹配空""

var str="aaaab";

var pattern2=/a{3,4}?/;// 第一个?表示{3,4}; 第二个?表示非贪婪匹配，只匹配3个

//返回数组：["aaa", index: 0, input: "aaaab", groups: undefined]

console.log(pattern2.exec(str));//非贪婪匹配，只匹配一个

var str="aaaab";

//这是属于贪婪模式，即匹配最大数目

var pattern=/a+b/;

//返回数组：["aaaab", index: 0, input: "aaaab", groups: undefined]

console.log(pattern.exec(str));//贪婪匹配，匹配最多数目

var str="aaaab";

//正则表达式为：非贪婪匹配后面还有其他字符类，则会变成贪婪匹配。

var pattern=/a+?b/;

//返回数组：["aaaab", index: 0, input: "aaaab", groups: undefined]

console.log(pattern.exec(str));//贪婪匹配+字符类=贪婪匹配

var str="<td><p>aaa</p></td><td><p>ccc</p></td>";

//理解：把<td>...</td>理解为对象a,var str="aa";贪婪模式会匹配两个a

var pattern=/<td>.*<\/td>/;//默认贪婪模式

//返回数组：["<td><p>aaa</p></td><td><p>ccc</p></td>", index:...]

console.log(pattern.exec(str));//默认是贪婪模式，所以匹配最大数目

var str="<td><p>aaa</p></td><td><p>ccc</p></td>";

//整个td算一个对象，区别td的不同是td里面内容，所以在里面设置.*

var pattern=/<td>.*?<\/td>/;// . 表示除换行符，匹配其他所有字符类。 ?表示非贪婪匹配。

//返回数组：["<td><p>aaa</p></td>", index: 0, input:...]

console.log(pattern.exec(str));//非贪婪匹配，只返回一个数目。

</script>

// 注意贪婪匹配和非贪婪匹配

str = 'js[javascript];html[hyper text markup language];css[cascading style sheet]';

var pattern=/\[.*\]/;//默认是贪婪匹配，即会匹配多个[...];

//返回数组：["[javascript];html[hyper text markup language];css[cascading style sheet]", index: 2,...]

console.log(pattern.exec(str));

var pattern=/\[.*?\]/;//在内容添加?：表示非贪婪匹配

//返回数组：["[javascript]", index: 2...]

console.log(pattern.exec(str));

</script>

//-------选择--------

//匹配过程：

//1,读取str字符串和正则表达式pattern。

//2,读取str时会按照pattern中的选项在str中搜索，返回第一个出现在str中的pattern选项。

//3,一旦匹配成功，正则表达式pattern中的其他选项都会被忽略。

var str="htmlcssjszhengliang";

var pattern=/liang|js/;//在str中js第一个出现。所以返回js

//返回数组：["js",...]

console.log(pattern.exec(str));

var str1="cssjszhenglianghtml1";

var pattern=/html|cssjs|zheng/;//cssjs在str中第一个出现，所以返回cssjs

//返回数组：["cssjs",...]

console.log(pattern.exec(str1));

var str2="css html zheng";

var pattern=/zheng|html|css/;//css在str中第一个出现，所以返回css

//返回数组：["css",...]

console.log(pattern.exec(str2));

var str3="aaaaab";

var pattern=/a|ab/;//在str中匹配到的第一个项是a,所以忽略其他，即返回：a

var pattern=/ab|a/;//在str中匹配到的第一个项是ab，所以忽略其他，即返回：ab

//在str中匹配到的第一个项是aaa，所以忽略其他选项，因为pattern第一个选项是aaa,匹配选项相似时，哪个在前就匹配哪个。

var pattern=/aaa|aa|ab/;

//在str中匹配到的第一个项是aa，所以忽略其他选项，因为pattern第一个选项是aa,匹配选项相似时，哪个在前就匹配哪个。

var pattern=/aa|aaa|ab/;

console.log(pattern.exec(str3));

var str="13sdf345";

var pattern=/0|-?[1-9]\d*/;//匹配整数(0,正整数，负整数)

console.log(pattern.exec(str));

//-------分组--------

//捕获型分组，返回两个值：

// 1，pattern匹配返回的字符串，注意把所有括号看成一个整体，且忽略括号。

// 2，pattern中括号内的字符串再进行匹配返回的值

//非捕获型分组，返回一个值：

// 1，即只返回pattern匹配返回的字符串，注意把所有括号看成一个整体，且忽略括号

// 2，在括号内使用(?:...)

var str="abab";

var pattern=/ab+/;//等价于 var pattern=/ab{1,}/; +只对b进行最少一次匹配。

//返回数组：["ab", index: 0, input: "abab", groups: undefined]

console.log(pattern.exec(str));

//捕获型分组和非捕获型分组

//捕获型分组

var str="ababab";

var pattern=/(ab)+/;//匹配ab最少一个

//返回两个值的数组：["ababab", "ab", index: 0, input: "ababab", groups: undefined]

//第一个值：pattern整个变量匹配到的值。

//第二个值：pattern小括号中再进行匹配返回的值。

console.log(pattern.exec(str));

//捕获型分组

var str="abcd";

var pattern=/(ab)c/;

//返回两个值的数组：["abc", "ab", index: 0, input: "abcd", groups: undefined]

//第一个值：pattern匹配到的字符串，注意把所有括号看成一个整体，且忽略括号。

//第二个值：pattern中小括号中的匹配，即捕获型分组。

console.log(pattern.exec(str));

//非获型分组在括号里面添加 ?: 即可

var str="abcd";

var pattern=/(?:ab)c/;// ?:表示非捕获分组，不捕获pattern中括号中的字符串进行匹配返回

//返回数组：["abc", index: 0, input: "abcd", groups: undefined]

console.log(pattern.exec(str));

var str="abcde";

var pattern=/(ab)(c)(d)/;

//返回四个值的数组:(4) ["abcd", "ab", "c", "d", index: 0, ...]

//第一个值：pattern把所有括号看成一个整体，且忽略括号，匹配str返回的值。

//第二个，第三个，第四个，分别是(ab),(c),(d)匹配str所返回的值。

console.log(pattern.exec(str));

var str="abcde";

var pattern=/(a(b(cde)))/;

//返回四个值：(4) ["abcde", "abcde", "bcde", "cde", index: 0,...]

//第一个值：pattern把所有括号看成一个整体，且忽略括号，匹配str返回的值。

//第二个，第三个，第四个，分别是(a(b(cde))),(b(cde)),(cde)匹配str所返回的值。

console.log(pattern.exec(str));

//-------引用--------

// pattern中的第一个小括号表示第一分组 \1

// pattern中的第二个小括号表示第二分组 \2 以此类推。

var str="abcd 111 abcd 111defg";

//pattern中的空格也是匹配的，每一个括号表示一个分组。

var pattern=/(\w{4}) (\w{3}) \1 \2\w+/;

//返回数组：(3) ["abcd 111 abcd 111defg", "abcd", "111", index: 0,...]

//第一个值: pattern忽略括号，匹配str中返回的值

//第二个值: (\w{4}) 匹配 str 返回的值称为：第一分组

//第三个值: (\w{3}) 匹配 str 返回的值称为：第二分组

console.log(pattern.exec(str));

//匹配最外标签里面的内容，最外标签不确定

var str="<p><a>这是一个段落<a/></p><p><a>AAAAAAAA<a/></p>";

//([a-zA-Z]+) 表示第一分组：至少匹配a-zA-Z一次

//(.*?) 表示第二分组：匹配除换行符外的一切字符类，且是非贪婪匹配

//\1 表示第一分组，这样写保证了标签字母的一致性，一对标签字母一定相同，否则就有错了

var pattern=/<([a-zA-Z]+)>(.*?)<\/\1>/;

//返回：(3) ["<p><a>这是一个段落<a/></p>", "p", "<a>这是一个段落<a/>", index: 0,...]

//第一个值：patter忽略括号，匹配str返回的值

//([a-zA-Z]+) 第二个值：在pattern中第一个括号匹配str返回的值，第一分组

//(.*?) 第三个值：在pattern中第二个括号匹配str返回的值，第二分组

var result=pattern.exec(str)

console.log(result);

//返回：0 ，因为一开始就开始匹配了

console.log(result.index);//返回匹配str开始的索引值

//返回：<p><a>这是一个段落<a/></p><p><a>AAAAAAAA<a/></p>

console.log(result.input);//返回用来匹配的str的值。

//正则表达式验证上传文件的后缀名是否为图片：图片

// 1，var pattern=/\.(gif|jpg|jpeg|png)/i; 采用的是分组形式

// 2，var pattern=/\.gif|\.jpg|\.jpeg|\.png/i;

var str="Javascript is Js";

// \1 表示第一分组:（J) \2 表示第二分组：(S)

var pattern=/([Jj])ava([Ss])cript\sis\s(\1\2)/;

// var pattern=/([J]|[j])ava([S]|[s])cript\sis\s(\1\2)/;

console.log(pattern.exec(str));

/*我们要遵循一下原则：

（1）要运用分组和引用的方式来写要匹配的正则表达式。

（2）空格是他数字符，他的表示形式应该为\s。

（3）题目中包括的是js可能为大写，也可能为小写的匹配，所以要把这两种情况都包含进去。*/

</script>

// 首尾匹配

// 首匹配： var pattern=/^.../;

// 尾匹配： var pattern=/...$/;

// 取反： var pattern=/[^a-zA-Z/;

//因为首尾匹配是为了保证匹配的字符串从头到尾都符合条件，经常用在表单提交内容的验证中。

var str="javascript";

var pattern=/^java/;//位置匹配之首匹配

var pattern1=/script$/;//位置匹配之尾匹配

//返回数组：["java", index: 0, input: "javascript", groups: undefined]

console.log(pattern.exec(str));

//返回数组：["script", index: 4, input: "javascript", groups: undefined]

console.log(pattern1.exec(str));

//-------同一个正则表达式有多种写法：使用正向思维，和逆向思维---------

//方法一：

var str="12345f45646";

var pattern=/^\d+$/;//位置匹配之首尾匹配，匹配首尾都是数字。

//首尾都是数字，返回true，否则返回false

var result=pattern.test(str);

console.log(result);

if (result) {

console.log("全部是数字");

}else{

console.log("不全是数字");

}

//方法二：

var str="123d4545646";

//如果匹配到一个非数字，则不全是数字，否则全是数组

var pattern=/\D/;//\D表示非数字 \d表示数字

//如果匹配成功，返回true，则不全是数字，否则返回false，则全是数字

//同时也可以使用var result=pattern.exec(str);匹配成功返回非数字，否则返回null

var result=pattern.test(str);

console.log(result);

if (result) {

console.log("不全部是数字");

}else{

console.log("全是数字");

}

//-----\b 位置匹配之匹配单词边界-----

// \b 即是：border 边界，边框

var str="js html css";

var pattern1=/css\b/;

//返回：["css", index: 8, input: "js html css", groups: undefined]

console.log(pattern1.exec(str));

var pattern2=/\bjs/;

//返回：["js", index: 0, input: "js html css", groups: undefined]

console.log(pattern2.exec(str));

var pattern3=/\bhtml\b/;

//返回：["html", index: 3, input: "js html css", groups: undefined]

console.log(pattern3.exec(str));

var str="#_html#html55￥html3@#%@$html@!#";

var pattern=/\bhtml\b/;

//返回：["html", index: 24, input: "#_html#html55￥html3@#%@$html@!#", groups: undefined]

//注意这里匹配索引是从第24开始的，第一个_html，第二个html55,第三个html3 三个是匹配不成功的。

//即：\b 匹配单词边界某个单词的首尾边界的字符类一定不能是 [^\w]=[^a-zA-Z0-9_]，否则返回null

//说白了就是除了大小写字母，数字，下划线，其他字符类才能匹配的上。才能使用\b取到该单词

console.log(pattern.exec(str));

</script>

<body>

//封装document.getElementsByClassName

function ByClassName(className,parentNode){

//短路操作，如果有传parentNode,则parentNode=parentNode,否则parentNode=document;

parentNode=parentNode||document;

if (document.getElementsByClassName) {//如果支持getElementsByClassName方法，则直接使用

return parentNode.getElementsByClassName(className);

}else{

alert( document.getElementsByClassName(className));

var allNode=document.getElementsByTagName("div");//获取所有div标签

var getNodes=[];//创建数组存放类名等于calssName的div标签

//首先，这里的正则表达式必须使用构造函数的形式创建，因为表达式是可变的。

//注意：使用构造函数创建正则表达式时，转义字符就变成了双重转义即：\\

//以下正则表达式表达六种情况：

//1，pattern=/^className/; 表示以className开头，前面没有空格。

//2，pattern=/className$/; 表示以className结尾，后面没有空

//3，pattern=/^calssName$/; 表示以className开头，也结尾，前后都没有空格。

//4，pattern=/\s+className/; 表示前面有一个或者多个空格

//5，pattern=/className\s+/; 表示后面有一个或者多个空格

//6，pattern=/\s+className\s+/; 表示前后都有有一个或者多个空格

var pattern=new RegExp('^|\\s+'+classNmae+'$|\\s+');

//等价于上面一行：

//var pattern=new RegExp('\\b'+className+'\\b');只要是一个单词，使用单词边界即可进行确认。简单方便

for (var i = 0; i < allNode.length; i++) {//循环遍历所有div标签获取类名为calssName的div标签

if (pattern.test(allNode[i])) {//使用正则表达式的test方法在每个div中检测是否存在className

getNodes.push(allNode[i]);

}

return getNodes;

}

var odd=ByClassName("odd");

var even=ByClassName("even");

for (var i = 0; i < odd.length; i++) {

odd[i].style.backgroundColor="#ff0";

}

for (var j = 0; j < even.length; j++) {

even[j].style.backgroundColor="#f0f";

}

</script>

</body>

前瞻性匹配和负向前瞻性匹配搜狗：qianzhanxingpipei

java(?=script) 表示只匹配后面等于script的java字符串。

java(?!script) 表示只匹配后面不等于script的java字符串。

//前瞻性匹配： var pattern=/java(?=script)/; 表示java后面等于sciprt时才匹配

//负向前瞻性匹配：var pattern=/java(?!script)/; 表示java后面不等于scirpt时才匹配

var str="javascript";//等价于：var str="javascript1234";

// ?= 表示 java后面跟的是script时就匹配，否则不匹配，返回null

var pattern=/java(?=script)/;

//返回：["java", index: 0, input: "javascript", groups: undefined]

console.log(pattern.exec(str));

var str="javascript";//等价于 var str="javascript1234"

// ?! 表示 java后面跟的不是script时就匹配，否则不匹配，返回null

var pattern=/java(?!script)/;

//返回：null

console.log(pattern.exec(str));

var str="java1234script";

// ?! 表示 java后面跟的不是script时就匹配，否则不匹配，返回null

var pattern=/java(?!script)/;

//返回：["java", index: 0, input: "java1234script", groups: undefined]

console.log(pattern.exec(str));

</script>

搜狗：regexp

// 正则表达式有两种实例化对象

var str="JavaScript"

//1,字面量方法

var pattern=/Java(?=Script)/;

//返回：["Java", index: 0, input: "JavaScript", groups: undefined]

console.log(pattern.exec(str));

var str="JavaScript";

var pat="java(?=script)";

//2，构造函数方法

var patter=new RegExp(pat,"i");//i(ignoreCase) 忽略大小写

console.log(patter.exec(str));

//在构造函数中，一定记住是双重转义

console.log(new RegExp("\\b"));//返回：/\b/

//返回一个反斜杠是注意，一定要使用四个反斜杠来进行转义

console.log(new RegExp("\\\\"));// 返回：/\\/

//具体RegExp对象的实例方法

//------pattern.exec(str)-------

//使用g(global) 关键字是进行的全局匹配过程解析：

var str="html js js js css";

var pattern=/js/g;

console.log(pattern.lastIndex);//开始匹配时，默认pattern.lastIndex=0

console.log(pattern.exec(str));//匹配第一个js，索引值是{5,6}，下一个索引值是7

console.log(pattern.lastIndex);//返回下一个索引值是7

console.log(pattern.exec(str));//从索引值7的地方开始匹配下一个js,索引值是{8,9},下一个索引值是10.

console.log(pattern.lastIndex);//返回下一个索引值是10

console.log(pattern.exec(str));//从索引值10的地方开始匹配下一个js,索引值是{11,12},下一个索引值是13.

console.log(pattern.lastIndex);//返回下一个索引值13

//总而言之，当匹配一圈到最后匹配不上时，返回null,立马重置pattern.lastIndex=0;然后重新循环匹配。

console.log(pattern.exec(str));//从索引值13开始向后匹配，即从 css中，匹配不到js，所以返回null

console.log(pattern.lastIndex);//返回因为匹配不到js，所以不存在下一个索引值，系统就直接重置pattern.lastIndex=0;

console.log(pattern.exec(str));//从pattern.lastIndex=0 索引值为0开始重新进行上面的循环匹配，匹配第一个js

console.log(pattern.lastIndex);//返回下一个索引值7

console.log(pattern.exec(str));//从索引值7开始向后匹配下一个js，pattern.lastIndxe=10

console.log(pattern.lastIndex);//返回下一个索引值10

//------pattern.test(str) 和 exec的执行原理一毛一样-------

//在没有使用g(global)全局匹配/检测时pattern.lastIndex的值永远都是0

//使用g(global)进行的全局匹配过程的解析：

var str="html js js js css";

var pattern=/js/g;

console.log(pattern.lastIndex);//开始检测时，默认pattern.lastIndex=0

console.log(pattern.test(str));//检测存在第一个js，索引值是{5,6}，下一个索引值是7

console.log(pattern.lastIndex);//返回下一个索引值是7

console.log(pattern.test(str));//从索引值7的地方开始检测下一个js,索引值是{8,9},下一个索引值是10.

console.log(pattern.lastIndex);//返回下一个索引值是10

console.log(pattern.test(str));//从索引值10的地方开始检测下一个js,索引值是{11,12},下一个索引值是13.

console.log(pattern.lastIndex);//返回下一个索引值13

//总而言之，当检测一圈到最后检测不存在，返回false,立马重置pattern.lastIndex=0;然后重新循环检测。

console.log(pattern.test(str));//从索引值13开始向后检测，即从 css中，检测不到js，所以返回false

console.log(pattern.lastIndex);//返回因为检测不到js，所以不存在下一个索引值，系统就直接重置pattern.lastIndex=0;

console.log(pattern.test(str));//从pattern.lastIndex=0 索引值为0开始重新进行上面的循环检测，检测第一个js

console.log(pattern.lastIndex);//返回下一个索引值7

console.log(pattern.test(str));//从索引值7开始向后检测下一个js，pattern.lastIndxe=10

console.log(pattern.lastIndex);//返回下一个索引值10

//------使用while循环，遍历str字符串中每次进行匹配的字符串的信息-------

var str="html js js js css";

var pattern=/js/g

total=0,//记录总共匹配几次

result="";//接受每次匹配的结果

// pattern.exec(str)这里已经执行了，while里面不能再执行了，否则每次循环都执行了两次。

// 千万注意上面一注释

while ((result=pattern.exec(str))!=null) {

console.log(result);//输出每次匹配的结果

total++;

//result.index 返回当前开始匹配的第一个字母的索引值

//(pattern.lastIndex-1) 返回当前匹配字符串最后一个字母的索引值

//pattern.lastIndex 返回的是当前匹配字符串的下面一个字符类的索引值

console.log("第"+total+"次匹配，匹配到："+result+"，当前位置是：{"+result.index+","+(pattern.lastIndex-1)+"}");

}

/*结果返回：

["js", index: 5, input: "html js js js css", groups: undefined]

第1次匹配，匹配到：js，当前位置是：{5,6}

["js", index: 8, input: "html js js js css", groups: undefined]

第2次匹配，匹配到：js，当前位置是：{8,9}

["js", index: 11, input: "html js js js css", groups: undefined]

第3次匹配，匹配到：js，当前位置是：{11,12}*/

//下面属于继承的方法，用的相对较少

var pattern=new RegExp("a\\nb");

console.log(pattern.toString());//返回 /a\nb/ 把pattern对象变成字符串

console.log(pattern.toLocaleString());//返回 /a\nb/ 把pattern对象变成本机特色字符串，正常和上面一行一样

console.log(pattern.valueOf());//返回 /a\nb/ 即返回pattern本身。

console.log(pattern.valueOf()===pattern); //返回pattern本身，即正则表达式对象。

console.log(typeof pattern);//返回的是一个object对象，正则表达式对象

console.log(pattern instanceof Object);//返回：true 正则表达式 pattern 是 Object对象的实例

</script>

//-------正则表达式 pattern的属性，常用pattern.lastIndex，其他了解即可-------

/*var str="aaa js js js bbb";

var pattern=new RegExp("\\bjs\\b","igm");

console.log(pattern.ignoreCase);//返回 true

console.log(pattern.global);//返回 true

console.log(pattern.multiline);//返回 false

console.log(pattern.source);//返回 \bjs\b 返回正则表达式的值

//默认如果已经匹配成功，那么lastIndex返回匹配成功字符类的下一个索引值。

console.log(pattern.lastIndex);//返回默认值为0。*/

//-------构造函数的属性，了解即可-------

/*var str="js js js";

var pattern=new RegExp("(j)s","ig");

var result=pattern.exec(str);

console.log(RegExp.input);//返回 str 字符串。

//上下等价： RegExp.input = RegExp.$_ = RegExp["$_"]。 $_ 就是别名

console.log(RegExp.$_);//返回 str 字符串。

console.log(RegExp.lastMatch);//返回最近一次匹配到的字符类 js

//上下等价： RegExp.lastMatch = RegExp["$&"] $&就是别名 &是特殊符号，不能使用RegExp.$&,报错

console.log(RegExp["$&"]);//返回最近一次匹配到的字符类 js*/

/*var str="aaa js js js bbb";

var pattern=new RegExp("\\bj(s)\\b","i");

var result=pattern.exec(str);//这里匹配的是第一个js 位置：{4,5}

console.log(RegExp.leftContext);//返回:aaa (最后一个a后面是有空格的),即：匹配字符类成功的左边内容

console.log(RegExp["$`"]);//返回:aaa (最后一个a后面是有空格的),即：匹配字符类成功的左边内容

console.log(RegExp.rightContext);//返回: js js bbb(第一个js前面是有空格的),即：匹配字符类成功的右边内容

console.log(RegExp["$'"]);//返回: js js bbb(第一个js前面是有空格的),即：匹配字符类成功的右边内容

console.log(RegExp.lastParen);//返回:s，匹配的是上一次捕获的分组内容：s

console.log(RegExp["$+"]);//返回:s，匹配的是上一次捕获的分组内容：s*/

/*var str="aaa js js js bbb";

var pattern=new RegExp("\\b(j)(s)\\b","i");

pattern.test(str);//必须执行才能获得RegExp实例对象，也可以pattern.exec(str);

console.log(RegExp.$1+","+RegExp.$2);//返回:j,s*/

//------获取RegExp的属性分组：$1-$9

//正则表达式的分组：\1 \2 \3...见下面字面/构造函数分组

var str="<p><a>我是一个兵</a></p><(p)><a>牛c的人物002</a></p>"

//字面量：var pattern=/<([a-zA-Z]+)>(.*?)<\/\1>/;

//下面是构造函数，谨记构造函数所有转义字符都要双重转义才行，所有。

var pattern1=new RegExp("<([a-zA-Z]+)>(.*?)<\\/\\1>");

//返回：(3) ["<p><a>我是一个兵</a></p>", "p", "<a>我是一个兵</a>", index: 0,...]

console.log(pattern1.exec(str));

//想要蝴蝶RegExp的任意属性，切记一定要执行pattern1.exec(str);否则返回空

console.log(RegExp.$1);//返回:p

console.log(RegExp.$2);//返回:<a>我是一个兵</a>

</script>

var str="html css ja1vaa";

var pattern=/java/;

//返回数组:["java", index: 9, input: "html css java", groups: undefined]

//未匹配到返回：null

console.log(pattern.exec(str));

//返回查找到字符类第一个字母的索引值：9，未找到返回-1

console.log(str.search(pattern));

//不写正则表达式，

var str="html css java";

//返回查找到字符类第一个字母的索引值：9，未找到返回-1

//默认隐式转换，通过正则构造函数进行转换成正则表达式

//即: var pattern=new RegExp("java");

// var result=pattern.exec(str);

// var index=result.index;

// console.log(index); //返回 9

console.log(str.search("java")); //返回 9

//------match 和 exec 方法的区别--------

//写法完全相反 str.match(pattern) 和 pattern.exec(str)

//match 在全局匹配下，是一次性全部匹配出来的内容存放于数组中，且不会进行分组匹配，可以使用for循环遍历

// 在非全局匹配下才会返回分组匹配的内容，且只匹配第一个字符类

//exec 不论是否是全局匹配，每次执行只返回一个匹配成功的字符类，且会进行分组匹配

//非全局匹配

var str="html css css css java";

var pattern=/(cs)s/;//这里的(cs)是第一个分组匹配

console.log(str.match(pattern));

//在非全局匹配情况：上下两句都是返回：(2) ["css", "cs", index: 5, ...]

console.log(pattern.exec(str));

//在全局匹配情况：

var str="html css css css java";

var pattern=/(cs)s/g;

var result=str.match(pattern);

//全局匹配下的两种情况：

//返回：(3) ["css", "css", "css"]

console.log(result);

//在全局匹配情况：返回：(2) ["css", "cs", index: 5, input: "html css css css java", groups: undefined]

console.log(pattern.exec(str));

//match在全局匹配下，可以使用for遍历匹配成功的字符类集循环文本输出： css css css

for (var i = 0; i < result.length; i++) {

document.write(result[i]+"\n");

}

//match在全局匹配下，可以使用for遍历匹配成功的字符类集，如下例子：

var str = '110报警120急救119火警114查询';

/*此处写代码*/

var pattern=/\d{3}/g;

var result=str.match(pattern);

for (var i = 0; i < result.length; i++) {

console.log(result[i]);

}

/*返回：

110

120

119

114*/

</script>

//multiline 表示多行匹配

//多行匹配的前提：

//1，必须是全局匹配

//2，必须是m多汗匹配

//3，必须使用首匹配^ 或者尾匹配$

//下面是全局多行尾匹配

var str="HtmlaaabbbJavaScript\nHtmlaaabbbJavaScript\nHtmlaaabbbJavaScript";

var pattern=/Script$/mg;

/*返回：下面被系统认为是三行，每行都进行匹配

HtmlaaabbbJavaScript //匹配每一行末尾的Script

console.log(str);

//返回：(3) ["Script", "Script", "Script"]

console.log(str.match(pattern));

//下面是全局单行尾匹配

var str="HtmlaaabbbJavaScript\nHtmlaaabbbJavaScript\nHtmlaaabbbJavaScript";

var pattern=/Script$/g;//如果这里不加m多行匹配，系统默认是一行，则只返回最后一个Script

/*返回：下面被系统认为是一整行

HtmlaaabbbJavaScript

HtmlaaabbbJavaScript //默认三行为一行，只匹配最后一行的Script

console.log(str);

//返回数组：["Script"]

console.log(str.match(pattern));

//下面是全局多行首匹配

var str="HtmlaaabbbJavaScript\nHtmlaaabbbJavaScript\nHtmlaaabbbJavaScript";

var pattern=/^html/img;

/*返回：下面被系统认为是三行，每行都进行匹配

HtmlaaabbbJavaScript //匹配每一行末尾的Script

console.log(str);

//返回：(3) ["Html", "Html", "Html"]

console.log(str.match(pattern));

//下面是全局单行首匹配

var str="HtmlaaabbbJavaScript\nHtmlaaabbbJavaScript\nHtmlaaabbbJavaScript";

var pattern=/^html/ig;

/*返回：下面被系统认为是一整行

HtmlaaabbbJavaScript

HtmlaaabbbJavaScript //匹配每一行末尾的Script

console.log(str);

//返回数组：["Html"]

console.log(str.match(pattern));

//正则表达式中：split方法 join方法

var str="html,css,java";

//返回数组：(3) ["html", "css", "java"]

console.log(str.split(","));

var arr=["html","css","java"];

//返回字符串：html,css,java

console.log(arr.join(","));

//字符串str中没有空格。

var str="html,css,java";

var pattern=/,/;//这里加不加全局匹配g，结果都是一样的，因为都是一行。

//返回数组：(3) ["html", "css", "java"]

console.log(str.split(pattern));

//字符串str中存在很多空格。空格会被保留

var str=" html , css, java ";//相比上面多了很多空格，那么结果输出也保留这些空格

var pattern=/,/;//这里加不加全局匹配g，结果都是一样的，因为都是一行。

//返回数组：(3) [" html ", " css", " java "]

console.log(str.split(pattern));

//字符串str中存在很多空格。正常我们都是需要清楚空格的，做法如下：

var str=" html , css, java ";//相比上面多了很多空格，那么结果输出也保留这些空格

var pattern=/\s*,\s;//这里加不加全局匹配g，结果都是一样的，因为都是一行。

//返回数组：(3) [" html", "css", "java "]

console.log(str.split(pattern));*/

</script>

var str = '110报警120急救119火警114查询119火警119火警';

/*此处写代码*/

var pattern=/\d{3}/g;//必须添加模式修饰符全局匹配g(global)

//普通字符串replace的替换操作

//返回：110报警120急救---警察---火警114查询119火警119火警

console.log(str.replace("119","---警察---"));//只能替换一个

//添加模式修饰符全局匹配g(global) 符合正则表达式patter的全部替换掉了

//返回：==报警==急救==火警==查询==火警==火警

console.log(str.replace(pattern,"=="));

var str="2019-6-20";

//全部替换-,必须使用模式修饰符g(global)全局匹配

var pattern=/-/g;

//返回：2019:6:20

console.log(str.replace(pattern,":"));//全部替换-为：

//replace 最强大

var str="I Love You I Love You I Love You";

var pattern=/(You)/ig;

//var result=str.replace(pattern,"<strong style='color:red;background-color:#0ff;'>You</strong>");

//上下等价，且下面用了第一个分组$1，用于非正则表达式的分组 $1-$9

//注意 \1 \2 \3 这样的分组用于正则表达式中。

var result=str.replace(pattern,"<strong style='color:red;background-color:#0ff;'>$1</strong>");

//返回：I Love You I Love You I Love You

//且所有You 颜色变成 red 背景色变为：#0ff

document.write(result);

var str="中国军队最牛逼，打倒美帝国主义，杀杀杀，打倒日本帝国主义，杀杀！";

var pattern=/最牛逼|美帝国主义|杀杀杀|日本/g;

console.log(str.replace(pattern,function($0){

//$0 表示母匹配，即返回pattern中的所有单个值。都是string类型的值

//等价于var arr=["最牛逼","美帝国主义","杀杀杀","日本"];这个数组通过for循环遍历里面的每个值

//这里的 $0 代表的是里面的每一个值。

console.log($0);//返回：pattern里面的每一个子匹配项

//console.log(typeof $0);//返回 string类型

var result="";

//$0.length代表的就是pattern里面每个子匹配字符串的长度

for (var i = 0; i < $0.length; i++) {

result+="*";

}

return result;//返回用于代替子匹配字符串的星星数目。

}))

</script>

搜狗：zhengzebiaodashi

//正则表达式进行精确匹配时，一定要加上首尾匹配

//即：/^...$/

/*QQ

1,5到11位

2，第一位不能为0

3，全部都是数字*/

var pattern=/^[1-9]\d{4,10}$/;

/*密码

1，区分大小写

2，6-16位

3，不能用空格*/

var pattern=/^\S[\w&^%$F#@\[\]]{6-16}$/;//全部列举出来的方法叫：穷举法

/*昵称

1，中文，数字，下划线，英文

2，2-18*/

var pattern=/[\u4e00-\u9fa5\w]{2,18}/;

</script>

//消除字符串首尾空白字符的方法有两种：

//1，组合复杂的正则表达式，效率相对低，不易理解

var str=" love ";

var pattern=/^\s+|\s+$/g;//组合正则表达式

console.log("|"+str.replace(pattern,'')+"|");

//2，分解成多个正则表达式，效率相对高，易于理解

var str=" love ";

//下面是简单化的正则表达式

var patternLeft=/^\s+/;//剔除字符串左边空格

var patternRight=/\s+$/;//剔除字符串右边空格

console.log("|"+str.replace(patternLeft,'').replace(patternRight,'')+"|");

//清除字符串首尾空格进行封装：

function trim(str){

return str.replace(/^\s+/,'').replace(/\s+$/,'');

}

var str=" love ";

console.log(trim(str));

//使用模式修饰符：全局匹配，替换所有空白字符

var str=" love ";

var pattern=/\s/g;//组合正则表达式

console.log("|"+str.replace(pattern,"")+"|");

</script>

var str="background-color-red";

var pattern=/-([a-z])/ig;

console.log(str.replace(pattern,function(all,param){

return param.toUpperCase();

}));

//封装该方法 toCamelCase

var str="background-color-red";

function toCamelCase(str){

//谨记：外面要用return 里面也必须使用 return

//第一个return是 replace()方法的返回值

//第二个return是匿名函数的返回值，如果只写匿名函数的返回值，那么replace就没有返回值，

// 那么toCamelCase方法的返回值就是undefined

return str.replace(/-([a-z])/ig,function(all,param){

return param.toUpperCase();

})

}

console.log(toCamelCase(str));

</script>

//------使用正则表达式进行匹配-------

//两种思路思路：

//正向思维：匹配的内容有什么共同特点

// 1，穷举法把多个对象看成一个对象进行匹配

//逆向思维：不匹配的内容有什么特别之处。

// 1，把要匹配和不要匹配的看成两个大的对象。

// 2，要匹配是以<开始，以>结束，排除掉结束字符[^>](内容中必须没有结束特别字符)

// 再加上特别字符，匹配中间要匹配的内容即可。

var str="<p id='odd' class='zheng'>我爱你sdfasdf一万年</p>";

var pattern=/<[^>]*>/g;

// 3，不要匹配的是以什么开始，以什么结束，排除掉不要匹配的就是剩下要匹配的。

//匹配HTML标签

var str="<p id='odd' class='zheng' name='<>'>我爱你一万年</p>";

var str1='<span id="love" class="liang" name="xiaom">love you forever </span>';

// 第一种方法：穷举法，要匹配的所有项一一给列出来

// \/? 一个反斜杠或者没有

// [a-zA-Z]+ 在a-zA-Z中选择一个或者多个字母

// ()* 0个或者多个括号中的内容

// (\s+[a-zA-Z]+=['"].*['"])* 把括号里面看做一个对象

// \s+ 一个或者多个空格

// [a-zA-Z]+ 一个或者多个字母

// = 即必须匹配

// ['"] 只选其中一个

// .* 除了换行符\n的内容人选0个或者多个

// g 表示全局匹配(global)

var pattern=/<\/?[a-zA-Z]+(\s+[a-zA-Z]+=['"].*['"]>)*/g;

console.log(str.match(pattern));

console.log(str1.match(pattern));

var str="<p id='odd' class='zheng' name='<>'>我爱你一万年</p>";

var str1='<span id="love" class="liang" name="xiaom">love you forever </span>';

var pattern=/<([a-zA-Z])+(?:\s+[a-zA-Z]+=['"].*['"]>)*|<\/[a-zA-Z]>/g;

console.log(str.match(pattern));

var str="<a> html cssasdfjasdfkjasldksdfjs </a>";

// var pattern=/<(?:[a-zA-Z])>+|<\/\1>/g; //这个分组为什么不行？

var pattern=/<([a-zA-Z])+>|<\/[a-zA-Z]>/g;

console.log(str.match(pattern));

// 第二种方法：逆向思维法：除掉不要匹配的，剩下就是要匹配的，使用[^..]

var str="<p id='odd' class='zheng'>我爱你sdfasdf一万年</p>";

//思路：

//正向思维：匹配的内容有什么共同特点

//逆向思维：不匹配的内容有什么共同特点这里使用的是逆向思维

//首先，匹配的内容： <p id='odd' class='zheng' name='xiaom'> 和 </p> 看成一个整体

//其次，不匹配内容：我爱你sdfasdf一万年即：从str开头开始匹配，到右尖括号(>)结束

//逆向思维的思路：

//1，< 以左尖括号开头 >右尖括号结束

//2，[^>] 内容里面除了不能有右尖括号的都可以匹配

//如果str中p的属性值中有 < > 那么下面的正则表达式就不成立了。

//var str="<p id='odd' class='<>'>我爱你sdfasdf一万年</p>";

var pattern=/<[^>]*>/g;

console.log(str.match(pattern));

var str="<input type='text' id='name' class='love' value='>'/>";

var pattern=/^<.*>$/g;

console.log(str.match(pattern));

var str="<input type='text' id='name' class='love' value='>'/>";

// var pattern=/<([^'">]|'[^"]*'|'[^']*')*>/g;

// 分为三个部分

// 1，<input type=

// 2，引号里面的值

// 3，/>

var pattern=/([^'">]|"[^"]*"|'[^']*')*>/g;

console.log(str.match(pattern));

</script>

var regexp={

"chainese":/[\u4e00-\u9fa5]*/,

'qq':/^[1-9][0-9]{4,}$/,

'id':/^[1-9]{1}[0-9]{14}$|^[1-9]{1}[0-9]{16}([0-9]|[xX])$/,

'name':/^[\u4e00-\u9fa5]{2,4}$/,

'email':/^[a-zA-Z0-9]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/,

'password':/^[\w|@|!|&|*|#|$|^|?|!|~|+|=|-|\.|,]{6,18}$/,

'phone':/^(13)[0-9]{9}|(147)[0-9]{8}|(15)[0,1,2,3,5,6,7,8,9]{1}[0-9]{8}$|(18)[0,2,5,6,7,8,9]{1}[0-9]{8}$/

}

var str="啥砥砺奋进",

qq="2341356",

name="郑良",

email="23423@qq.com",

phone="13112343212";

console.log(str.match(regexp.chainese));

console.log(qq.match(regexp.qq));

console.log(name.match(regexp.name));

console.log(email.match(regexp.email));

console.log(phone.match(regexp.phone));

</script>

常用的正则表达式

1、"^\d+$" //非负整数（正整数 + 0）

2、"^[0-9]*[1-9][0-9]*$" //正整数

3、"^((-\d+)|(0+))$” //非正整数(负数 + 0)

4、"^-[0-9]*[1-9][0-9]*$" //负整数

5、"^-?\d+$" //整数

6、"^\d+(\.\d+)?$" //非负数(正整数，正浮点数 + 0)

7、"^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$"//正数

8、"^((-\d+(\.\d+)?)|(0+(\.0+)?))$" //非正数（负数 + 0）

9、"^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$" //负数

10、"^(-?\d+)(\.\d+)?$" //实数

11、"^[A-Za-z]+$" //由 26 个英文字母组成的字符串

12、"^[A-Z]+$" //由 26 个英文字母的大写组成的字符串

13、"^[a-z]+$" //由 26 个英文字母的小写组成的字符串

14、"^[A-Za-z0-9]+$" //由数字和 26 个英文字母组成的字符串

15、"^\w+$" //由数字、26 个英文字母或者下划线组成的字符串

16、"^[a-zA-Z0-9]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$" //email 地址

17、^(13)[0-9]{9}|(147)[0-9]{8}|(15)[0,1,2,3,5,6,7,8,9]{1}[0-9]{8}$|

(18)[0,2,5,6,7,8,9]{1}[0-9]{8}$ 十一位手机号码

18，^[\w|@|!|&|*|#|$|^|?|!|~|+|=|-|\.|,]{6,18}$ //密码6-18位，包括字母数字或符号

19，^[\u4e00-\u9fa5]{2,4}$ //中文名字，2-4个字

20，^[1-9]{1}[0-9]{14}$|^[1-9]{1}[0-9]{16}([0-9]|[xX])$ 身份证

21，^[1-9][0-9]{4,}$ //匹配腾讯QQ号

22，[1-9]\d{5}(?!\d) //匹配中国邮政编码

转载于:https://www.cnblogs.com/Knowledge-is-infinite/p/11028471.html

你可能感兴趣的文章

树莓派进阶之路 (001) - 常用镜像高速下载

查看>>