正则RegExp
正则：用来处理字符串的一个规则。
处理：
1）正则的匹配：判断一个字符串是否符合我们制定的规则->test
例如：reg.test(str)
/\d/->包含一个0-9之间的数字
var reg=/\d/;
console.log(reg.test("1"))->true
2）正则的捕获：把字符串符合我们正则规则的内容捕获到->exec
例如：reg.exec(str)
var reg=/\d/;
console.log(reg.exec("1"))->["1",index:0,input:"1"]
如何创建一个正则：
字面量方式：
var reg =/^\d+$/;
实例创建方式：
var reg =new RegExp("^\\d+$")
两种创建方式有区别：
1)在字面量方式中，我们//之间包起来的所有内容都是元字符，有的具有特殊的意义，大部分都是代表本身含义的普通的元字符，不能进行变量值的拼接
var name ="dali"
var reg =/^\d+"+name+"\d+$/g;
console.log(reg.test("18dali24"));->false
console.log(reg.test("18"""""nameeeee"24"));->true
对于字符串拼接这样的需求只能使用实例创建的方式.
var reg =new RegExp("^\\d+"+name+"\\d+$","g")
console.log(reg.test("18dali24"));->true
2)字面量方式中的\d在实例创建当中要写出\d,前面加一个转义符，因为在字符串当中\d没有被识别成元字符
如何学习正则：
console.dir(RegExp.prototype)
正则的组成：元字符
每一个正则表达式都是由元字符和修饰符组成的
元字符：在//之间具有意义的一些字符。
普通元字符：只要在正则出现的元字符（基于字面量方式创建），除了特殊和有量词意义的以外，其余的都是普通元字符
修饰符
g(global)：全局匹配
i(ignoreCase)：忽略大小写匹配
m(multiline)：多行匹配
1.具有特殊意义的元字符
\：转义字符。转义后面字符所代表的含义
^:以某一个元字符开始
$:以某一个元字符结束
.:除了\n以外的任意字符
():分组，把一个大正则本身划分为几个小正则。`可以改变x|y默认优先级`
(?:):只匹配不捕获
(?=):正向预查
(?!):负向预查
x|y：x或者y中的一个
[xyz]:x或者y或者z中的一个
[^xyz]除了x,y,z的任意一个字符。
[a-z]:a-z之间的任何一个字符
[^a-z]:除了a-z之间的任何一个字符
\d :一个0-9之间的数字
\D：除了0-9之间的数字以外的任何字符
\b:匹配一个边界符
\w:数字、字母、下划线中的任意一个字符[(0-9)(a-z)(A-Z)(_)]
\s：匹配一个空白字符，空格，一个制表符、换页符...
\n匹配一个换行符。
reg=/^\d/;指以0开头，以2结尾，中间可以是除了\n的任意字符。
var reg =/^0.2$/;指以0开头，以2结尾，中间只能是.。就是只能是0.2
2.代表出现次数的量词元字符
*：出现零到多次
+：出现一到多次
?：出现零次或者一次。
{n}：出现n次
{n,}：出现n次到多次
{n,m}：出现n到m次
例如：
var reg =/^\d+/;
[]
1.中括号中出现的所有字符都是代表本身意思的字符（没有特殊的含义）
2.中括号当中不识别两位数
var reg =/^[12]$/;
代表的是1或者2中的一个。
var reg =/^[12-68]$/;
代表的是1、2-6、8三个当中的一个
元字符详细解读
()：正则中的分组，也可以理解为一个大正则中的一个正则（包起来的部分是一个整体）；在正则中我们可以使用小括号改变一些默认的优先级；小分组还有第二个作用：
分组引用
小分组的第三个作用：分组捕获
//=>分组引用：\1 或者 \2 ...出现和第N个分组一模一样的内容
var reg = /^([a-z])([a-z])\2([a-z])$/; //=> 符合的字符串：foot、book、week、attr、http...
[]
[xyz] [^xyz] [a-z] [^a-z]
\w：数组字母下划线中的任意一个字符
var reg = /^[a-zA-Z0-9_]$/; //=>等价于\w
中括号中出现的元字符，一般都代表本身的含义
var reg = /^[.?+&]+$/; //=>里面的四个元字符都是本身含义，例如：点就是小数点了，不是所谓的任意字符...
需求：描述样式类名的规则（数字、字母、下划线、-），并且不能以-开头
//var reg = /^[\w-]+$/;
//var reg = /^[0-9a-zA-Z_-]+$/; //=>没有处理以-开头的情况
var reg = /^\w[\w-]*$/;
|或，操作较混乱
例如var reg =/^18|19$/;正常来说是18或者19.
但是实际中一下情况都是true
1）1开头9结尾
2）18或者19
3）含有18或者19，例如819也是true
可以用（）改变x|y的优先级。
正则案例
代表有效数字的正则（正数、负数、零、小数）
1）"."可以出现也可以不出现，但是一旦出现，后面必须跟着以为或者多位数字
2）最开始也可以有+/—也可以没有
3）整数部分，一位数可以是0-9，多位数不能以0开头
例如2）var reg=/^[+-]?$/；
例如3）var reg=/^(\d|([1-9]\d+))$/
所以可以写成：var reg=/^[+-]?(\d|([1-9]\d+))(\.\d+)?$/；
年龄介于18~65之间
可以把它分为三块18-19，20-59，60-65
var reg =/^(1[89]|[2-5]\d|6[0-5])$/;
验证邮箱正则（简易版）
左边部分：数字、字母、下划线、.
中间：@+数字、字母
右边：.字母（2到4位）出现一到两次。
var reg =/^[\w.-]+@[0-9a-zA-Z]+(\.[a-zA-Z]{2,4}){1,2}$/;
中国标准真实姓名
2-4位汉字
var reg =/^[\u4e00-\u9fa5]{2,4}$/;
身份证号码
17位加一位数字或者X
var reg =/^\d{17}(\d|x)$/;
也可以分为几块利于后期捕获，
var reg =/^(\d{2})(\d{4})(\d{4})(\d{2})(\d{2})(\d{2})(\d)(\d|x)$/;
正则的匹配
正则的匹配：判断一个字符串是否符合我们制定的规则->test
var reg=/\d/;
console.log(reg.test("1"))->true
正则的捕获
把当前字符串中符合正则的字符捕获到
RegExp.prototype：exec实现正则捕获的方法
var str = '珠峰培训2017扬帆起航2018';
var reg = /\d+/;
reg.exec(str);
/*
* 当正则捕获的时候：
* 1、先去验证当前字符串和正则是否匹配，如果不匹配返回的结果是null（没有捕获到任何的内容）
* 2、如果匹配，从字符串最左边开始，向右查找到匹配的内容，并且把匹配的内容返回
*
* exec捕获到结果的格式：
* -> 获取的结果是一个数组
* -> 数组中的第一项是当前本次大正则在字符串中匹配到的结果
* -> index：记录了当前本次捕获到结果的起始索引
* -> input：当前正则操作的原始字符串
* -> 如果当前正则中有分组，获取的数组中，从第二项开始都是每个小分组，本次匹配到的结果（通过exec可以把分组中的内容捕获到）
*
* 执行一次exec只能把符合正则规则条件中的一个内容捕获都，如果还有其它符合规则的，需要在次执行exec才有可能捕获到
*/
正则捕获存在懒惰性
执行一次exec捕获到第一个符合规则的内容，第二次执行exec，捕获到的依然是第一个匹配的内容，后面匹配的内容不管执行多少次exec都无法捕获到
解决正则捕获的懒惰性：
在正则的末尾加修饰符g（全局匹配）
//=>正则为什么会存在懒惰性?
/*
* 正则本身有一个属性：lastIndex（下一次正则在字符串中匹配查找的开始索引）
* 默认值：0，从字符串第一个字符开始查找匹配的内容
* 默认不管指定多少遍exec方法,正则的lastIndex值都不会变（也就是第二次以后查找的时候还是从第一个字符找，所以找到的结果永远都是第一个匹配的内容）
* 而且当我们手动把 lastIndex 进行修改的时候，不会起到任何的作用
*/
//=>为什么加修饰符g就解决了懒惰性?
/*
* 加了修饰符g，每一次exec结束后，浏览器默认会把lastIndex值进行修改，下一次从上一次结束的位置开始查找，所以可以得到后面匹配的内容了
*/
var reg = /\d+/g;
var str = '珠峰培训2017杨帆起航2018';
console.log(reg.lastIndex);//=>0
console.log(reg.exec(str)[0]);//=>'2017'
console.log(reg.lastIndex);//=>8
console.log(reg.exec(str)[0]);//=>'2018'
console.log(reg.lastIndex);//=>16
console.log(reg.exec(str));//=>null
console.log(reg.lastIndex);//=>0
console.log(reg.exec(str)[0]);//=>'2017'
exec有自己的局限性：执行一次exec只能捕获到一个和正则匹配的结果（即使加了修饰符g），如果需要都捕获到，我们需要执行N次exec方法才可以
下面封装的myExecAll方法，目的是执行一次这个方法，可以把当前正则匹配到的全部内容都捕获到
RegExp.prototype.myExecAll = function myExecAll() {
var str = arguments[0] || '',
result = [];
//=>首先判断THIS是否加了全局修饰符G,如果没有加,为了防止下面执行出现死循环,我们只让其执行一次EXEC即可,把执行一次的结果直接的返回
if (!this.global) {
return this.exec(str);
}
var ary = this.exec(str);
while (ary) {
result.push(ary[0]);
ary = this.exec(str);
}
return result;
};
var reg = /\d+/g;
console.log(reg.myExecAll('珠峰2017培训2018杨帆2019起航2020'));
使用字符串方法match实现捕获
var reg = /\d+/g;
var str = '珠峰2017培训2018杨帆2019起航2020';
str.match(reg); //=>["2017", "2018", "2019", "2020"]
使用字符串match捕获：
1、如果正则加了修饰符g，执行一次match会把所有正则匹配的内容捕获到
2、如果没有加修饰符g，执行一次match只能把第一个匹配的结果捕获到局限性：
在加了修饰符g的情况下，执行match方法只能把大正则匹配的内容捕获到，对于小分组捕获的内容方法给其自动忽略了
var str = 'my name is {0},i am {1} years old~，2017';
//=>需求：把{n}整体捕获到，而且还要把括号中的数字也获取到
var reg = /\{(\d+)\}/g;
// str.match(reg);//=>["{0}", "{1}"]
//=>想要获取小分组中的内容，我们只能使用EXEC处理了
function fn(reg,str){
var ary=reg.exec(str),
result=[];
while(ary){
result.push(ary);
ary=reg.exec(str);
}
return result;
}
使用test也可以实现正则的捕获
不管是正则的匹配还是正则的捕获，在处理时候的原理是没区别的：
从字符串的第一个字符向后查找，找到符合正则规则的字符，如果可以找到，说明正则和字符串匹配（test检测返回true、exec捕获返回捕获的内容），如果找到末尾都没有匹配的，说明正则和字符串不匹配（test检测返回false、exec捕获返回null）如果正则设置了修饰符g，不管使用test还是exec中的任何方法，都会修改lastIndex值（下一次查找是基于上一次匹配结果的末尾开始查找的）
//=>如果当前字符串和正则是匹配的，我们进行捕获
var reg = /\{(\d+)\}/g;
var str = 'my name is {0}~~';
if (reg.test(str)) {
//=>reg.test(str) : true
console.log(reg.lastIndex);//=>14
console.log(reg.exec(str));//=>null
}
var reg = /\{(\d+)\}/;
var str = 'my name is {0}~~';
if (reg.test(str)) {
//=>reg.test(str) : true
console.log(reg.lastIndex);//=>0
console.log(reg.exec(str));//=>['{0}','0'...]
}
使用test不仅可以找到匹配的内容，也能像exec一样把找到的内容获取到
test返回结果是 true/false，所以靠返回结果肯定不行
var reg = /\{(\d+)\}/g;
var str = 'my name is {0}~~,i am {1} years old~~';
reg.test(str);//=>true
console.log(RegExp.$1);//=>0 获取到当前本次匹配内容中第一个小分组捕获的内容
reg.test(str);//=>true
console.log(RegExp.$1);//=>1 TEST可以实现捕获,但是每一次只能获取到当前本次匹配结果中,第N个分组捕获的内容 $1第一个分组 $2第二个分组 ...
所有支持正则的方法都可以实现正则的捕获（一般都是字符串方法）
字符串中常用的支持正则的方法：
match
split
replace
...
var str = 'name=珠峰&age=8&lx=teacher';
str.split(/&|=/); //=>["name", "珠峰", "age", "8", "lx", "teacher"]
str.split(/(&|=)/); //=>["name", "=", "珠峰", "&", "age", "=", "8", "&", "lx", "=", "teacher"]
//=>在使用split进行字符串拆分的时候，如果正则中包含小分组，会把小分组中的内容都捕获到，放在最后的数组中
//=>本案例中的小括号仅仅是为了实现 改变默认的优先级 问题，但是我们不想把分组中的内容捕获到 => “只想匹配不想捕获” 我们可以使用 (?:)
str.split(/(?:&|=)/); //=>["name", "珠峰", "age", "8", "lx", "teacher"]
//=>只匹配不捕获：
//在当前一个分组中加了 ?: ，在正则检测匹配的时候，小分组可以起到自己应有的作用（例如：改变优先级...），但是在捕获的时候，遇到带?:的小分组，浏览器不会把当前这个分组中匹配的内容，单独去捕获了
var reg = /^(\d{6})(\d{4})(\d{2})(\d{2})(\d{2})(\d)(\d|X)$/;
reg.exec('130828199012040617'); //=>["130828199012040617", "130828", "1990", "12", "04", "06", "1", "7"...]
var reg = /^(\d{6})(\d{4})(\d{2})(\d{2})(?:\d{2})(\d)(?:\d|X)$/;
reg.exec('130828199012040617');//=> ["130828199012040617", "130828", "1990", "12", "04", "1"...]
var reg = /^-?(\d|([1-9]\d+))(\.\d+)?$/;//=>计算是第几个分组的时候，我们从左向右找 ( 即可
replace
replace：字符串中原有字符的替换
str.replace(old,new)
var str = '珠峰2017珠峰2018';
str = str.replace('珠峰','珠峰培训');
str = str.replace('珠峰','珠峰培训');
//=>'珠峰培训培训2017珠峰2018' 没有实现我们希望的效果
//=>在不使用正则的情况下，执行一次replace只能替换一个原有字符，第二次执行replace，还是从字符串的开始位置查找，把最新找到的字符替换为新字符（类似于正则捕获时候的懒惰性：每一次执行都是从字符串最开始的位置查找）
真实项目中，replace一般都是和正则搭配在一起使用的
var str = '珠峰2017珠峰2018';
str = str.replace(/珠峰/g,'珠峰培训');
//=>"珠峰培训2017珠峰培训2018"
replace原理：
1、当replace方法执行，第一项传递一个正则
正则不加g：把当前字符串中第一个和正则匹配的结果捕获到，替换成新的字符
正则加g：把当前字符串中所有和正则匹配的内容都分别的捕获到，而且每一次捕获，都会把当前捕获的内容替换为新字符2、当replace方法执行，第二个参数传递的是一个函数（回调函数）
首先用正则到字符串中进行查找匹配，匹配到一个符合规则的，就把传递的函数执行一次
不仅执行这个函数，而且还把正则本次捕获的结果（和执行exec捕获的结果一样：数组、大正则匹配、小分组匹配 都有）当做实参传递给这个函数（这样就可以在函数中获取这些值：而这些值就是正则每一次捕获的结果 ）
var str = 'my name is {0},i am {1} years old,i can {2}!';
var reg = /\{(\d+)\}/g;
str.replace(reg, function () {
//=>传递的函数一共被执行三次
//=>console.log(arguments) 每一次匹配捕获到结果,不仅把这个方法执行了,而且还会把当前捕获的结果当做实参传递给这个函数(ARG)
/*
* 第一次执行函数，获取的是ARG类数组
* 0:'{0}' 本次大正则匹配的结果
* 1:'0' 本次第一个小分组匹配的结果
* 2:11 本次大正则匹配结果在字符串中的索引 index
* 3:'my nam...' 原始字符串 input
*
* 和每一次执行exec实现捕获的结果非常类似
*/
//return xxx;//=>每一次执行函数，函数中RETURN的结果，都相当于把本次大正则匹配的内容替换掉（原始字符串不变）
});
exec
每一次捕获的时候都是先进行默认的匹配，如果没有匹配成功。捕获的结果是null;只有匹配的内容才能捕获到。
捕获的内容格式：
1）捕获的内容是一个数组，数组中的第一项是当前正则捕获的内容
index：捕获的内容在字符串中开始的索引位置
input：捕获的原始字符串
2）正则捕获的特点：
懒惰性
每一次执行exec只捕获第一个匹配的内容，在不进行任何处理的情况下，在执行多次捕获，捕获的还是第一个匹配的内容。
lastindex:是正则每一次捕获在字符串中开始查找的位置，默认的值是0.
如何解决懒惰性：在正则的末尾加一个修饰符“g”
原理：加了全局修饰符g，正则每一次捕获结束后，我们的lastindex的值都变为了最新的值，下一次捕获从最新的位置开始查找，这样的就可以把所有需要捕获的内容都捕获到。
var str="a134b";
var str2="cc123dd";
var reg=/\w+/g;
console.log(reg.exec(str));//a134b
conslole.log(reg.lastIndex);//5
console.log(reg.exec(str2));//dd
conslole.log(reg.lastIndex);//7
console.log(reg.exec(str2));//null
conslole.log(reg.lastIndex);//0
console.log(reg.exec(str));//a134b
自己编写程序获取正则捕获的所有内容，一定不能忘记加g
没有分组一般就是三个参数：content内容，index索引，input原始字符串
arguments[0]是大正则捕获的内容。
arguments[1]一般就是对应的第1个分组的捕获的内容
封装一个方法把匹配的内容一次性捕获到
var reg =/\d+/g;
var str ="d20a21l22i23";
var ary =[];
var res = reg.exec(str);
while(res){
ary.push(res[0]);
res = reg.exec(str);
}
console.log(ary)
----------//或者如下
RegExp.prototype.allExec=function () {
if(!this.global){return this.exec};
var ary=[];
var result;
while(result==this.exec(str)){
ary[ary.length]=result[0];
}
return ary;
};
console.log(reg.allExec(str));
正则的贪婪性
正则每一次捕获的都是按照匹配的最长的结果捕获的，例如2符合正则，20也符合正则，默认捕获的是20.
如何解决正则的贪婪性：在量词元字符后面添加一个？即可
?:在正则中有很多的作用：
1.放在一个普通的元字符后面代表出现0-1次。例如/\d?/数字可能出现也可能不出现。
2.放在一个量词的元字符后面是取消捕获时候的贪婪性。
3.（?：）在分组中?:的意思是只匹配不捕获。
字符串中的match方法 捕获匹配正则的字符
var reg =/\d+?/g;
var str ="d20a21l22i23";
var ary =str.match(reg);
console.log(ary);
局限性：在分组捕获的情况下，match只能捕获到大正则匹配的内容，小正则捕获的内容是无法获取的。
String.prototype.match = function(reg){
//this-->str我们想操作的那个字符串-->原型上的方法，里面的this都是我们想要操作的当前的实例
var ary =[];
var res =reg.exec(this);
while(res){
ary.pus(res[0]);
res =reg.exec(this);
}
return ary;
};
//str.match(reg);
正则的分组
1.改变优先级
2.分组引用
3.分组捕获,可以捕获大小正则里的内容
\2代表和第二个分组出现一模一样的内容；\1代表和一个分组出现一模一样的内容；
var reg =/^(\w)\1(\w)\2$/;
console.log(reg.test("zzff"));->true
console.log(reg.test("z1f_"));->false
var reg =/^(\d{2})(\d{4})(\d{4})(\d{2})(\d{2})(?:\d{2})(\d)(\d|x)$/;
var str ="654202199404233011";
console.log(reg.exec(str));
//ary=["654202199404233011","65","4202","1994","04","23","1","1",index:0,input:"654202199404233011"]
//ary[0]大正则捕获的内容
ary[1]第一个分组捕获的内容
...
（?:）：在分组中只匹配不捕获
replace用正则捕获
把原有的字符串替换成新的字符串，但是在不使用正则的情况下每当执行一次就只能替换一个字符。
var str ="name18name24";
str =str.replace(/name/g,"dali");
replace第一项的值是一个正则的实现原理
//首先我们把exec捕获一样，把所有和我们正则匹配的都捕获到，然后把捕获的内容替换为我们需要替换的新内容。原理如下
var str ="name18name24";
str =str.replace(/name/g,function(){
console.log(arguments)
return"dali"
}
);
//第二个参数换成一个函数
1.匿名函数执行多少次，取决于正则在字符串当中捕获多少次。
2. 每一次执行匿名函数，里面传递的参数值arguments和我们自己通过exec捕获到的结果是非常的类似的。（即使正则有分组我们同样可以通过arguments获取到分组捕获到的内容）这个函数默认会有三个参数：1）content:每一次捕获的内容。2） index：每一次捕获的开始索引。3）input：原始字符串。
3. return：你返回的结果是啥，就相当于把当前这次大正则捕获的内容替换成你返回的内容。
RegExp.$1获取第一个分组捕获的内容。
综合实例：
1.替换
var str ="name is {0},age is {1},from{2},love{4}~~";
var ary =["dali",24,"xj","JS"];
var reg =/{(\d+)}/g;
str = str.replace(reg,function(larCon,smallCon,index,input){
return ary[arguments[1]];
//也可以是return ary[RegExp.$1]但在IE是不兼容的。
});
console.log(str);
2.获取一个字符串中出现次数最多的字符，并且获取出现的次数
var str ="woshidaligegezhuzaiseveneleven";
//获取每一个字符出现次数最多次数,i是不区分大小写
var obj ={};
str.replace(/[a-z]/gi,function(){
var val =arguments[0];
obj[val]>=1?obj[val]+=1:obj[val]=1;
})
//获取最多出现的次数
var maxNum = 0;
for (var key in obj){
obj[key]>maxNum?maxNum=obj[key]:null;
}
//把所有符合maxNum次数的都捕获到
var ary =[];
for (var key in obj){
obj[key]===maxNum?ary.push(key):null;
}
3.用正则获取URL
var str ="http://www.baidu.com?name=dali&age=24&from=xinjiang;"
var reg =/([^?=&]+)=([^?=&]+)/g;
var obj={};
str.replace(reg,function(){
obj[arguments[1]]=arguments[2];
})
console.log(obj)
第二种
var url = "http://www.zhufengpeixun.cn?zhufeng=px&index=5
";
//1.获取？的索引
var index = url.indexOf("?");
//2.截取？后面的字符串
url = url.slice(index+1);//zhufeng=px&index=5
//3.通过&拆分字符串
var ary = url.split("&");//["zhufeng=px","index=5"]
//4.获取数组的每一项
var obj = {};
for(var i = 0;i["zhufeng", "px"] newAry[0] newAry[1]
//i = 1 ->["index", "5"]
console.log(newAry);
//6 存入对象中
var key = newAry[0];//属性名
var value = newAry[1];//属性值
obj[key] = value //属性名和属性值存入对象中
}
console.log(obj);
重置时间格式
var str = "2018-3-11 20:41:00",
//第一步：将指定格式的时间字符中的年月日等信息村入一个数组
reg =/^(\d{4})[-/](\d{1,2})[-/](\d{1,2}) +(\d{1,2}):(\d{1,2}):(\d{1,2})$/g,
ary ={};
str.replace(reg,function(){
ary = ([].slice.call(arguments)).slice(1,7);
});
//第二步：设定我们目标时间格式，把数组中对应的项替换成制定的区域内
var resStr ="{0}年{1}月{2}日 {3}时{4}分{5}秒"，
reg =/{(\d+)}/g;
resStr =resStr.replace(reg,function(){
var num = arguments[1],
val = ary[num];
val.length===1?val ="0"+val:void0;
return val;
});console.log（resStr）
常用的正则表达式编写
匹配中文字符
var reg=/^[\u4e00-\u9fa5]+$/;
//排除!-/之间的特殊字符排除
var reg=/^[^\u2100-\u2F00]+$/
验证是否为有效数字
/*
* 可能是正数，可能是负数 12 -12
* 整数或者小数 0 12 0.2 12.5 -12.3
* 只要出现小数点，后面至少要跟一位数字
* 小数点前面必须有数字
*/
var reg = /^-?(\d|([1-9]\d+))(\.\d+)?$/;
/*
* -? 负号可有可无
* (\d|([1-9]\d+))
* \d 一位数可以是任何值
* ([1-9]\d+) 多位数不能以零开头
* (\.\d+)? 小数部分可有可无，有的话点后面必须跟一位数字
*/
手机号码
/*
* 11位数字
* 1开头
*/
var reg = /^1\d{10}$/;
用户名：真实姓名
//=>/^[\u4E00-\u9FA5]$/ 中文汉字的正则
var reg = /^[\u4E00-\u9FA5]{2,10}(·[\u4E00-\u9FA5]{2,10})?$/;
邮箱
var reg = /^\w+((-\w+)|(\.\w+))*@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/;
/*
* 以数字字母下划线开头
* @前面可以是 数字、字母、下划线、-、. 这些符号
* 不能把 -和. 连续出现，出现一次后面必须跟数字字母下划线
*
* @后面的部分支持
* 企业邮箱
* .com.cn 多域名情况
*/
// [A-Za-z0-9]+
// ((\.|-)[A-Za-z0-9]+)*
// \.[A-Za-z0-9]+
// @163.com.cn
// @zhu-feng-pei-xun.com.cn
身份证号码
/*
* 18位
* 前17位必须是数字
* 最后一位可以是数字或者X(X代表数字10)
*
* 130828199012040617
* 前六位：省市县 130828
* 接下来八位 出生年+月+日
* 倒数第二位数字 奇数代表男 偶数代表女
*/
var reg = /^(\d{6})(\d{4})(\d{2})(\d{2})\d{2}(\d)(\d|X)$/;
//=>这样写不仅可以匹配，而且以后捕获的时候，不仅可以把大正则匹配的结果捕获到，里面每一个小分组(小正则)匹配的结果也可以单独的捕获到 “分组捕获”
//=>年 1950~2017
//=>第一段 1950~1999
//=>第二段 2000~2017
//==> 00~09
//==> 10~17
// /^((19[5-9]\d)|(20((0\d)|(1[0-7]))))$/