一、正则表达式
1.1正则概述和体验
正则表达式是被用来匹配字符串中的字符组合的模式，常用来做表单验证。在JavaScript中，正则表达式也是对象，是一种引用类型。
案例：正确输入一个电话号码，010-12345678，用户输入正确返回“对”，错误返回“错”
var tel = prompt("请输入电话号码");
var reg = /^\d{3}-\d{8}$/;
if(reg.test(tel)){
alert("对");
}else{
alert("错");
}
字符串的方法：
split() 根据匹配把字符串分割为字符串数组。
match() 使用正则表达式与字符串相比较，返回一个包含匹配结果的数组。
search() 对正则表达式或指定字符串进行搜索，返回第一个出现的匹配项的下标。
replace() 替换与正则表达式匹配的字符串。
正则表达式方法：
exec() 检索字符串中指定的值。返回找到的值，并确定其位置。
test() 检索字符串中指定的值。返回 true 或 false。
注意：任何数据自己的方法，都要自己对应数据打点调用
字符串：打点调用字符串方法
正则：打点调用正则方法
1.2正则表达式
使用一个正则表达式字面量是最简单的方式，两个“//”是正则表达式的定界符。
正则表达式：Regular Expression，通常简写为：RegExp
语法：
|
/正则符号/ |
|
/abc/ 表示匹配的是一个abc三个字符，而且三个字符必须同时连在一起，顺序不能颠倒。 |
|
var reg = /abc/; //正则表达式字面量，尽量赋值给一个变量 |
|
console.log(typeof reg); //object |
正则表达式是一种对象数据类型，引用类型的其中一种，变量保存的是正则对象的地方。
1.3字符串方法
split()方法用于把字符串分割成数组（字符串→数组），从什么地方拆分，就是参数
|
var str = "aa bbb c dddd eeee ffff"; console.log(str.split(" ")); //如果用字符串方法进行分割，一个空格分割 console.log(str.split(/\s+/)); //正则表达式可匹配一个或多个空白字符 |
|
//用a当分割符 var str = "bbbbaaacccaaaddddaeeeeaaaafff"; console.log(str.split(/a+/)); //匹配a，+号表示并且出现一次或多次 |
match()使用正则表达式与字符串相比较，返回包含匹配结果的数组。
可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。默认：返回找到的第一个字符组成数组。
|
var str = "bbbbaaacccaaaddddaeeeeaaaafffbbb"; console.log(str.match(/a/)); //返回匹配第一次出现结果的字符 console.log(str.match(/a+/)); //返回匹配结果的多个字符 console.log(str.match(/a+/).index); //返回匹配结果的下标 |
|
var str = "aaa o o bbbb o o aaaa"; console.log(str.match(/o\s+o/g)); //g 全局匹配 |
使用正则表达式作为分隔符，可以进行模糊匹配
|
\s 表示匹配空白字符 + 表示前面的字符出现一次或多次 g 全局定界符，全局匹配 |
search()对正则表达式或指定字符串进行检索，返回第一个出现的匹配项下标位置。（无视全局定界符）
var str = "abcdefgcd";
console.log(str.search("cd")); //2，字符串匹配
console.log(str.search("cdf")); //-1，没有匹配返回-1
console.log(str.search(/cd/g)); //2，正则匹配，无视全局定界符g var str = "aaa o t o o bbbb o o aaaa";
console.log(str.search(/o\s+o/)); //10，字符串匹配
console.log(str.search(/o\so/g)); //-1,不能完全匹配
值为-1，表示字符串内没有匹配的项，或者不能完全匹配。
replace()替换与字符串匹配或正则表达式匹配的子串。
两个参数：
参数1：匹配原字符串的字符（可以是字符串、正则）
参数2：替换的新字符。产生新字符串，不影响原字符串。
//需求：将www.webqianduan.cn 替换乘www.iqianduan.cn
var str = "www.webqianduan.cn";
console.log(str.replace("webqianduan","iqianduan")); //字符串匹配替换
console.log(str.replace(/webqianduan/,"iqianduan")); //正则匹配替换
console.log(str); //不影响原字符串
replace第二参数还可以是函数，$1表示正则匹配到的第一个结果，$2是第二个结果，以此类推,如果同时更改两个匹配结果可以返回一个数组。
var str = "www.webqianduan.cn";
var arr = str.replace(/\.(\w+)\./,function(match,$1){
console.log(match,$1);
return ".iqianduan."
});
console.log(arr);
//如果没有（）匹配的话函数的参数分别为：当前匹配的字符(match)，当前匹配字符的位置(pos)，原始字符串(origin)
var text = 'cat,bat,sat,fat';
var result = text.replace(/cat,bat/, function (match, pos, originalText) {
console.log(match, pos, originalText);
return 'ond'//将匹配到的更换成ond
});
console.log(result);//ond,sat,fat
练习：过滤字符串中的空格
|
var str1 = "aa b c d e f"; console.log(str1.replace(/\s+/g,"")); |
1.4正则表达式方法
正则表达式方法：
exec() 检索字符串中指定的值。返回找到的值，并确定其位置。
test() 检索字符串中指定的值。返回 true 或 false。
exec()在字符串中去匹配正则表达式，如果有输出第一个到数组中。（无视全局定界符g）
可以通过index属性获取原字符串下标。
|
var str = "fuahndabcfnkandabc"; console.log(/abc/.exec(str)); console.log(/abc/.exec(str).index); //下标为6 |
var str = "oooooo 0 0 ooooo";
var reg = /o\s+0\s+0\s+o/;
console.log(reg.exec(str));
console.log(reg.exec(str).index); //下标为5
test() 检索字符串中指定的值（匹配正则表达式）。有返回 true，没有返回false。
var str = "aaddccccdddabcd";
var reg = /abc/; //精确匹配
console.log(reg.test(str)); //true
console.log(str.search(reg)); // //练习检测"a bc"和"abc"是否包含空格
var str1 = "a bc";
var str2 = "abc";
var reg = /\s+/;
console.log(reg.test(str1));//true
console.log(reg.test(str2));//false
二、正则的术语和操作符
正则表达式：
由一些普通字符和一些特殊字符（又叫元字符--metacharacters）组成。普通字符包括大小写的字母和数字，而元字符则具有特殊的含义。
特殊字符，javascript中常用特殊字符有：
( ) [ ] { } \ ^ $ | ? * + .
若想匹配这类字符必须用转义符号“\” 如：“\.”“\^” , “\\”
2.1精确匹配
精确匹配指的是要去匹配某一个固定值或常量，匹配abc，正则表达式里必须用精确的术语进行匹配。
正则表达式：/abc/ ，表示要匹配三个字符，分别是abc必须是顺序在一起。
精确匹配没有特殊符号：
2.2预定义特殊符号
预定义特殊字符：
\t /\t/ 制表符 eg: console.log(/\t/.test(' '))
\n /\n/ 回车符 eg: console.log(/\n/.test(`aaa
bbb`));
\f /\f/ 换页符
\t制表符：
\n回车符：
回车符：不能直接敲回车换行，使用``这对引号包裹可以直接换行。
2.3字符集
用正则表达式中的一类字符去匹配字符串中的一个字符。字符集用[]包括。
比如[abc]，表示可以匹配a，也可以匹配b，也可以匹配c，只要存在其中一个都是对的。
简单类：正则的多个字符对应一个字符，可以用[]把它们括起来，让[]这个整体对应一个字符。将所有可能性都列在[]内，不要出现其他字符，直接连写。
|
var str = "fiafiortfasoztfakoct"; console.log(str.match(/o[rzc]t/g)); |
范围类：有时候匹配的东西过多，而且类型又相同，全部输入太麻烦，我们可以在中间加个短横线。
[0-9] 查找任何从 0 至 9 的数字。
[a-z] 查找任何从小写 a 到小写 z 的字符。
[A-Z] 查找任何从大写 A 到大写 Z 的字符。
[A-z] 查找任何从大写 A 到小写 z 的字符。
var str = "oo1234abcdfABCDFAAE";
console.log(str.match(/o[0-9]/g)); //["o1"]
console.log(str.match(/o[a-z]/g)); //["o1"]
console.log(str.match(/a[a-z]c/g)); //["abc"]
console.log(str.match(/B[A-Z]D/g)); //["BCD"]
组合类：允许用中括号匹配不同类型的单个字符。
[0-9a-zA-Z]：表示匹配的可以是数字、小写字母、大写字母。
// o开头c结尾，中间任意一个字符
var str = "abc123a8c123aBca3c";
console.log(str.match(/a[0-9a-z]c/g));
console.log(str.match(/a[0-9a-zA-Z]c/g));
console.log(str.match(/a[5-9A-F]c/g));
console.log(str.match(/a[5-9abc]c/g));
负向类：[]前面加个元字符“^”进行取反，表示匹配不能为括号里面的字符 [^a]
var str = "abcortaaaaoctbbbo4toPt";
console.log(str.match(/o[^a-z]t/g));
console.log(str.match(/o[^A-Z]t/g));
console.log(str.match(/o[^0-9]t/g));
console.log(str.match(/o[^0-9abc]t/g));
2.4修饰符
g ：全局修饰符，修饰符用于执行全局匹配（查找所有匹配），一直到将所有可能性都匹配成功。
global：全局、全球。使用时的位置：在正则的字面量//后面。match、replace方法都可以使用g
var str = "01222a333b56c7890de";
console.log(str.match(/[0-9]+/));
console.log(str.match(/[0-9]+/g));
console.log(str.match(/a[0-9]+/g));
i ：修饰符，用于执行大小写不敏感匹配
|
var str = "aabbbcccAAcAaa"; console.log(str.match(/aa/g)); console.log(str.match(/aa/gi)); //大小写不敏感 |
注意：修饰符位置，都是//后面，修饰符可以同时使用，连写就可以了。
2.5边界
^ ：开头，不能写在[]中，如果写在[^]是取反的意思。
匹配的是字符串必须以什么开头。^后面的正则术语匹配的字符串必须是开头。
console.log(/^hello/.test("hello javascript")); //true
console.log(/^hello/.test("helo javascript")); //false
console.log(/^hello/.test("hhello javascript")); //false
console.log(/^hh/.test("hhello javascript")); //true
$ ：结尾，匹配的是必须以$前面的字符为结尾（必须完全匹配），$写在正则里面//的最后。
console.log(/javascript$/.test("hello javascript")); //true
console.log(/javascript$/.test("hello javascript$")); //false
console.log(/javascript$/.test("hello javascript@")); //false
console.log(/javascript@$/.test("hello javascript@")); //true
^和$可以同时使用，必须以他们中间的内容当做开头和结尾，字符串只能有中间的内容。
console.log(/^[0-9]+$/.test(8888888888888)); //true
console.log(/^[0-9]+$/.test("88888abc888")); //false
console.log(/^[0-9abc]+$/.test("88888abc888")); //true
console.log(/^[a-zA-Z][0-9a-zA-Z]+$/.test("88888abc888")); //false
console.log(/^[a-zA-Z][0-9a-zA-Z]+$/.test("abc888abc888")); //true
console.log(/^[a-zA-Z][0-9a-zA-Z]*$/.test("a1234aaa")); //true
console.log(/^[a-zA-Z][0-9a-zA-Z]+$/.test("a")); //true
console.log(/^[a-zA-Z]bbb[0-9a-zA-Z]+$/.test("abbba")); //true
\b 单词边界，用于查找位于单词的开头或结尾的匹配
限定匹配的字符必须位于单词的边界，配合其他的字符匹配时，\ba表示a字符必须匹配，而且a必须位于单词的开头，c\b表示c字符匹配必须位于单词的结尾。
console.log(/\ba/.test("apple")); //true
console.log(/\ba/.test("iapple")); //false
console.log(/\ba/.test("i apple")); //true
console.log(/ple\b/.test("i apple")); //true
console.log(/e\b/.test("i apple")); //true
var str = 'i love JavaScript very much@pei';
console.log(str.match(/\b[a-z]/gi));
console.log(str.match(/\b[a-z]+/gi));
\w，表示查找单词字符，包含数字、大小写字母、下划线
console.log("we are family no".match(/\w+/g));
console.log("we are family no".match(/\b\w+\b/g));
console.log("we are Family no".match(/\b[a-z]+\b/g));
console.log("We Are Family No".match(/\b[a-z]+\b/g));
console.log("We Are Family No".match(/[a-z]+\b/g));
\B 匹配非单词边界，用于查找不在单词的开头或结尾。
\B写在前面，表示后面那个字符匹配时必须不是一个单词的开始。
\B写在后面，表示前面那个字符匹配时必须不是一个单词的结尾。
var str = 'i love JavaScript very much@pei';
console.log(str.match(/\b[a-z]+\b/gi));
console.log(str.match(/\B[a-z]+\B/gi));
对比记忆：单词边界\b必须包含单词边界，非单词边界\B不能有单词边界。
2.6预定义类（元字符）
预定义类其实都是对一些字符集的简写。
.[^\n\r] 除了换行和回车之外的任意字符
console.log(/.+/.test("!@#$%#$%^gjsdhbf11222")); //true
console.log(/^.+$/.test(`!@#$%#$%^gjsdh
bf11222`)); //false
\d[0-9]只匹配数字字符，一个\d只能匹配一个数字
console.log(/^\d$/.test(0123456789888)); //false
console.log(/^\d+$/.test(0123456789888)); //true
console.log(/^\d+$/.test('0123456789a888')); //false
\D[^0-9]匹配非数字字符，只要不是数字都可以
console.log(/^\D+$/.test(0123456789888)); //false
console.log(/^\D+$/.test("0123457aa89888")); //false
console.log(/^\D+$/.test('abc@#$%^&你好abc')); //true
\s[\t\n\x0B\f\r]匹配空白字符、空格、缩进、换行、换页
console.log(/\s+/.test(`你好
啊！！`)); //true，匹配到换行
console.log(/\s+/.test('你好 ')); //true
console.log(/^\s+/.test('你好 '));//false
console.log(/^\s+/.test(' 你好 '));//true
\S[^\t\n\x0B\f\r]匹配非空白字符（除了空白符都可以）
console.log(/^\S+$/.test(" 你好 ")); //false
console.log(/^\S+$/.test(" 你好 ")); //false
console.log(/^\S+$/.test("!@#$%abc13")); //true
\w[a-zA-Z_0-9]单词字符(所有的大小写字母/数字/下划线)
console.log(/^\w+$/.test('abc12345ABC_dd')); //true
console.log(/^\w+$/.test('abc12345ABC_dd#@')); //false
console.log(/^\w+$/.test('abc12345ABC_dd文字')); //false
console.log(/^\w+$/.test('abc12345ABC_dd ')); //false
\W[^a-zA-Z_0-9]匹配非单词字符(非所有的大小写字母/数字/下划线)
console.log(/^\W+$/.test('abc12345ABC_dd')); //false
console.log(/^\W+$/.test('你好，#￥%……&&')); //true
console.log(/^\W+$/.test(' ')); //true
2.7量词
有一些字符进行匹配时，连续多个可能是相同的字符，提供量词去解决出现重复次数的书写方式。
规定数量：作用范围是量词前面的一个字符。
{n} 硬性量词，内部写对应重复次数。
console.log(/ab{3}c/.test('abbbc')); //true
console.log(/ab{3}c/.test('abbc')); //false
console.log(/ab{3}c/.test('abbbbc')); //false
{n,m} 软性量词，至少出现n次但不超过m次（中间不能有空格）。
大于等于n次，小于等于m次。
console.log(/ab{3,5}c/.test('abbc')); //false
console.log(/ab{3,5}c/.test('abbbc')); //true
console.log(/ab{3,5}c/.test('abbbbbc')); //true
console.log(/ab{3,5}c/.test('abbbbbbc')); //false
{n,} 软性量词，至少出现n次（+的升级版）。
可以出现n次或更多次，上不封顶，但不能小于n次
console.log(/ab{3,}c/.test('abbc')); //false
console.log(/ab{3,}c/.test('abbbc')); //true
console.log(/ab{3,}c/.test('abbbbbbbc'));//true
? 软性量词，出现零次或一次，等价于{0,1}
console.log(/ab?c/.test('ac')); //true
console.log(/ab?c/.test('abc')); //true
console.log(/ab?c/.test('abbbbc')); //false
* 软性量词，出现零次或多次 等于{0,}
console.log(/ab*c/.test('ac')); //true
console.log(/ab*c/.test('abc')); //true
console.log(/ab*c/.test('abbbbc')); //true
+ 软性量词，出现一次或多次（至少一次），等价于{1,}
console.log(/ab+c/.test('ac')); //false
console.log(/ab+c/.test('abc')); //true
console.log(/ab+c/.test('abbbbc')); //true
量词除了修饰前面的单个字符，还可以搭配预定义类使用。
2.8分组
虽然量词的出现，能帮我们处理一排紧密相连的同类字符，但这还不够，我们需要重复的字符不是一个或多个，就要用小括号对多个字符进行分组。
console.log(/(bye){2}/.test('bye')); //false
console.log(/(bye){2}/.test('byebye')); //true
console.log(/bye{2}/.test('byeee')); //true
2.9或操作符
可以使用竖线“|”字符表示或者的关系。
“|”前面或后面，如果没有限制，会将“或”前后分为两个整体，只要匹配成功一个就可以。
a|bcd：表示匹配的字符串，要么包括一个单独的a，要么包括一个整体bcd
console.log(/^12|abc$/.test('1abc')); //true
console.log(/^12|abc$/.test('abc')); //true
console.log(/^12|abc$/.test('12')); //true
console.log(/^12|abc$/.test('12abc'));//true
可以利用圆括号来分组，将“|”操作符包裹起来，就跟后面没关系
(a|b)cd;表示从a、b选其一，后面是cd
console.log(/^a(d|b)c$/.test('bc')); //false
console.log(/^a(d|b)c$/.test('abc')); //true
console.log(/^a(d|b)c$/.test('adc')); //true
console.log(/^a(d|b)c$/.test('ad')); //false
验证一个月31天内都为真：
|
console.log(/^((0?[1-9])|((1|2)[0-9])|30|31)$/.test(28)); |
2.10反向引用
反向引用标识是对正则表达式中的匹配组捕获的子字符串进行编号，通过“\编号(在表达式中)”，“$编号（在表达式外）”进行引用。从1开始计数。
正则表达式中一个分组的符号，会在字符串中找到匹配的结果，这个匹配这个可以用个一些特殊的书写反向引用。
在正则表达式中反向引用“\编码”，从1开始
在正则表达式外反向引用“$编码”，从1开始
console.log(/\w{3}/.test('bye')); //true
console.log(/(\w{3})\1/.test('byebye')); //true
console.log(/(\w{3})\1/.test('bye')); //false
console.log(/(\w{3})\1/.test('byehhh')); //false
console.log(/(\w{3})\1\1/.test('byebyebye')); //true
console.log("123*456".replace(/(\d{3})\*(\d{3})/,'$2==$1'));
除了直接反向引用之外，还可以对引用的字符做一些复杂的操作
replace()第二参数还可以是函数，$1表示正则匹配到的第一个结果，$2是第二个结果，以此类推
函数的参数分别为：当前匹配的字符(match)，当前匹配字符的位置(pos)，原始字符串(origin)
替换函数必须有返回值，它才会去替换新内容。
var reg = "123*456".replace(/(\d{3})\*(\d{3})/,function(match,$1,$2){
return $2 + '*****' + $1;
//return parseInt($1) + parseInt($2);
});
console.log(reg);
2.11中文匹配
匹配中文固定语法：[\u4e00-\u9fa5]
console.log(/^[\u4e00-\u9fa5]+$/.test("爱前端")); //true
console.log(/^[\u4e00-\u9fa5]+$/.test("爱前端iqianduan")); //flase
console.log(/^[\u4e00-\u9fa5]+$/.test("爱前端123")); //flase
console.log(/^[\u4e00-\u9fa5]+$/.test("愛前端繁體")); //true
var str = prompt("请输入用户名，必须是4-6位汉字！");
var reg = /^[\u4e00-\u9fa5]{4,6}$/;
if(reg.test(str)){
alert("对");
}else{
alert("错误");
}