正则的理解

　　元字符、量词的合写　　　

　　　/d+/　　至少有一个数字

　　在字符串中查找与正则匹配的字符；

　　n+案例　

　　var st="heoollo"

　　var reg=/o+/g　　在字符串中至少有一个o

　　console.log(st.match(reg))　结果为["oo","o"]

　　n*案例

　　var st="heoollo";

　　var reg=/o*/g　　在字符串中匹配包含0个或多个o

　　console.log(st.match(reg))　　结果为["","","oo","","","o"];

　　显然这不是我们想要的结果；

　　所以另一种写法：在前面添加相邻的字母 

　　案例

　　var st="heloollo"

　　var reg=/lo*/g　 匹配 l 之后带0个或多个0的字符

　　console.log(st.match(reg))　　结果为["loo","l","lo"]

　　n?

　　var st="hellohlool"

　　var reg=/lo?/g　　包含 l 之后带0个或1个o的字符

　　console.log(st.match(reg))　　结果为["l","lo","lo","l"];

　　n{x}　　x个n

　　var st="helloohoo"

　　var reg=/lo{2}/g　　翻译为：var reg=/loo/g

　　console.log(st.match(reg));　　结果为["loo"]

　　?=n　　指定一个后面必须跟着n的字符串，返回结果不带n，使用过程中加()

　　var st="hellohho"

　　var reg=/h(?=o)/g　　全局匹配找一个h后面找o的h

　　console.log(st.match(reg));　　结果为["h"]

　　/ln+/　　l后面至少有一个n；

　　/ln*/　　l后面有0个或多个n；

　　/ln?/　　l后面有0个或1个n；

　　/l(?=n)/　　l后面紧跟着n，返回的是l，如果l后面没有n，返回的是null；

　　正则RegExp（类）

　　概念：用来检验字符串的规则；

　　定义：通过这两种方法定义一个正则；

　　　　1.var reg=/格式/

　　　　2.var reg=new RegExp

　　其本质都是一个对象

　　方法：

　　　　1.test()　　匹配的方法

　　　　2.exec()　　捕获的方法

　　修饰符：　i　　m　　g

　　[ ]

　　元字符：

　　量词　　（详情见上一章）

　　正则的理解：

　　1.正则的懒惰性：

　　2.正则的贪婪性；

　　懒惰性；

　　　　每一次在exec()中捕获的时候，只捕获第一次匹配的内容，而不往下捕获了，我们把这种方式叫正则的懒惰性；

　　捕获开始的位置都是从0开始；

　　解决正则的懒惰性

　　　　修饰符：g 全局匹配；

　　案例：　　

　　　　var st="hello45612world12345"

　　　　var reg=/d+/g

　　　　console.log(reg.exec(st));　　结果为：45612　　这就是正则的懒惰性，每次只输出第一次匹配上的

　　　　console.log(reg.exec(st));　　结果为：12345　　再次输出的话，就发现他捕获的位置从第一次输出后就开始捕获，不再从零捕获（正是因为g的全局捕获）

　　　　正则的实例对象reg有一个lastlndex的属性，捕获的起始位置；

　　　　如何将捕获的内容汇聚在一起：

　　　　console.log(st.match(reg))；　　利用字符换中match的方法即可

　　正则的贪婪性：

　　　　正则每次捕获都是按照最长的结果，我们把这种功能叫正则的贪婪性；

　　案例：

　　　　var st="hello12345"

　　　　var reg=/d+/g;

　　　　console.log(reg.exec(st));　　结果为["12345"]　　只捕获到最长的数字 不会是1，或1，2直接就是1，2，3，4，5

　　怎样处理正则的贪婪性：

　　　　在元字符量词的后面加？

　　　　案例：

　　　　var st="hello456121245"

　　　　var reg=/d+?/g

　　　　console.log(st.match(reg))

　　分组捕获，正则里面带（），就是分组捕获；

　　/(a)(b)/　　解析：外面一个大正则，里面带了两个小正则； 　　　　（先算（））

　　分组捕获的优点：1.可以改变优先级；

　　　　　　　　　　2.可以分组引用；

　　分组引用1,2　　1代表和第一个分组出现的一模一样，2和第二个分组出现的一模一样

　　在数分组的个数时，从左往右；

　　/(a)(b)/　　　　　　（分组也是一个整体）

　　第一组：（ab）

　　第二组：（a）　　　　　　

　　第三组：（b）

　　案例：

　　　　var reg=/(w)1(w)2/

　　　　var st="ssdd";

　　　　console.log(reg.test(reg))　　只有这样才会返回true

　　案例二：

　　　　var reg=/(a)1(b)2/

　　　　var st="aabb"

　　　　console.log(reg.test(reg))　　只用这样才会返回true

　　　　解析这种写法的意思：

　　　　　　第一个是分组，且是一个单词字符，第二个是个分组引用，要求和第一组一模一样，第三个是第二个分组且是一个单词字符，第四个是一个分组引用，要求和第二组一模一样

　　分组捕获：

　　　　分组捕获的前提是正则存在分组，不仅把大正则的内容捕获到把小正则的内容捕获到；

　　　　案例：

　　　　　　var st="absd";

　　　　　　var reg=/(a)(b)/;

　　　　　　console.log(reg.exec(st))　　结果为["ab","a","b"]

　　怎么解除分组捕获，如果你不想捕获某一个分组的内容，在分组前面加一个?:就可以了；

　　　　案例：

　　　　　　var st="absd";

　　　　　　var reg=/(a)(?:b)/

　　　　　　console.log(reg.exec(st))　　结果为["ab","a"]