正则表达式
var str1 = "zheng liang xing yu ZHU ZHu zhu";
//在String对象原型链添加方法：replaceAll()
//全局搜索变量search忽略大小写，并使用replaceMent进行代替
String.prototype.replaceAll = function(search,replaceMent){
return this.replace(new RegExp(search, 'gi'),replaceMent);
}
//全局匹配并忽略大小写搜索指定字符串：searchMent
String.prototype.searchAll = function(searchMent){
return this.search(new RegExp(searchMent,'gi'));
}
console.log(str1.replaceAll('zhu','xiao'));
console.log(str1.searchAll('zhu'));
</script>
输出结果：
zheng liang xing yu xiao xiao xiao
20 //匹配第一个起始索引
var str="That is all si red is blue is hob sis all isall"; var patt1=/b..e/g;//. 读做元字符，即 . 元字符用于查找单个字符，除了换行和行结束符。 console.log(str.match(patt1)); // 输出：["blue"] // ?=n 匹配任何其后紧接指定字符串 n 的字符串。 //这里是匹配is后面紧跟all的字符(is all 中间一定有空格) console.log(str.match(/is(?=all)/g)); // 输出：["is"] // ?!n 匹配任何其后没有紧接指定字符串 n 的字符串。 // 这里是匹配is后面紧跟的不是all 字符 console.log(str.match(/is(?!=all)/g)) // 输出：(5) ["is", "is", "is", "is", "is"]
作用：查找，替换 ，数据有效的验证
============================================
搜狗：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次
<script>
//注意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
<script>
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
htmlss
ss
htmlss
ss
htmlss
ss*/
})
</script>
捕获性分组引用 $1的三种情况：
第二种：把引用分组$1直接发按在字符串中: "$1"
<script>
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 读取捕获性分组引用
<script>
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字符串。
<script>
//-----\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，也可以是两个或者三个。
正则表达式表示法：
<script>
//字面量创建正则表达式： 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>
//字面量和构造函数正则表达式，怎么选择：
<script type="text/javascript">
//字面量正则表达式：固定死的，不可修改的，但是比较方法简单，好用。
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>
<!-- 转义字符反斜杠 \ 的使用 -->
<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>
<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键(表示两个或者四个空格)，特殊符号的都是使用转义字符：\ 反斜杠 -->
<script type="text/javascript">
var str = '/[a\nb]/';
var pattern=/\/\[a\nb\]\//
console.log(pattern.exec(str));
//输出 ["/[a↵b]/", index: 0, input: "/[a↵b]/", groups: undefined]
</script>
<!-- [abcd...] 字符类，只匹配方括号中的第一个即返回。 -->
<script type="text/javascript">
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]/
<script type="text/javascript">
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} 如果只写一个.后面不跟量词，默认只匹配一个，如下例子：-->
<script type="text/javascript">
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>
<script type="text/javascript">
//匹配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，要想将贪婪转换成非贪婪匹配，只需在量词后面加上?
<script type="text/javascript">
//贪婪匹配，{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>
<script type="text/javascript">
// 注意贪婪匹配和非贪婪匹配
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>
<!-- 正则表达式中的选择，分组，引用 -->
<script type="text/javascript">
//-------选择--------
//匹配过程：
//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>
<!-- 位置匹配之首尾匹配 -->
<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>
<!-- 使用正则表达式封装document.getElementsByClassName -->
<body>
<div class="off2d odd off2d">1</div>
<div class="even">2</div>
<div class="odd">3</div>
<div class="even">4</div>
<!-- 位置匹配之首位匹配 -->
<script>
//封装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字符串。
<!-- 位置匹配之前瞻性匹配 负向前瞻性匹配 -->
<script>
//前瞻性匹配： 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对象的实例方法属性等等 --> 搜狗：regexp
<script type="text/javaScript">
// 正则表达式有两种实例化对象
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>
<!-- RegExp对象的实例属性 -->
<script type="text/javaScript">
//-------正则表达式 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>
<!-- String对象与正则表达式相关的方法 -->
<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遍历匹配成功的字符类集，如下例子：
<script type="text/javascript">
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>
<script>
//multiline 表示多行匹配
//多行匹配的前提：
//1，必须是全局匹配
//2，必须是m多汗匹配
//3，必须使用首匹配^ 或者 尾匹配$
//下面是全局多行尾匹配
var str="HtmlaaabbbJavaScript\nHtmlaaabbbJavaScript\nHtmlaaabbbJavaScript";
var pattern=/Script$/mg;
/*返回：下面被系统认为是三行，每行都进行匹配
HtmlaaabbbJavaScript //匹配每一行末尾的Script
HtmlaaabbbJavaScript //匹配每一行末尾的Script
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
HtmlaaabbbJavaScript //默认三行为一行，只匹配最后一行的Script
*/
console.log(str);
//返回数组：["Script"]
console.log(str.match(pattern));
//下面是全局多行首匹配
var str="HtmlaaabbbJavaScript\nHtmlaaabbbJavaScript\nHtmlaaabbbJavaScript";
var pattern=/^html/img;
/*返回：下面被系统认为是三行，每行都进行匹配
HtmlaaabbbJavaScript //匹配每一行末尾的Script
HtmlaaabbbJavaScript //匹配每一行末尾的Script
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
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>
<!-- 正则表达式中的replace -->
<script type="text/javascript">
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
<script>
//正则表达式进行精确匹配时，一定要加上首尾匹配
//即：/^...$/
/*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>
<!-- 清除字符串首尾空白 -->
<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>
<!-- 把连字符的字符串改成驼峰命名的方式 -->
<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，不要匹配的是以什么开始，以什么结束，排除掉不要匹配的就是剩下要匹配的。
<script>
//匹配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>
<!-- 常用的正则表达式封装类库 -->
<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) //匹配中国邮政编码
