正则表达式

2. 正则表达式：规定字符串中字符出现的规则！

     何时使用：2种：

         1. *验证*一个字符串的规则：

         2. 使用关键字规则，在一段话中模糊*查找*关键字时

   如何定义正则表达式：

    1. 最简单的正则表达式：不带任何特殊符号的*原文*

         比如；/no/  /我草/

    2. 字符集：使用中括号包裹的备选字符的列表

       **如何使用：一个[]，仅匹配一位字符！

                   每次必须从[]中选一个匹配，不能不选

    比如：银行卡密码：6位数字

      [0123456789][0123456789]... ...[0123456789]

       如果备选字符集是连续的，可用-简写,-读作"到"：

      [0-9][0-9][0-9][0-9][0-9][0-9]

      [a-zA-Z]匹配所有字母

      [a-zA-Z0-9]匹配所有字母或数字

       排除字符集：[^要排除的字符]

    比如：4位房间号不能包含4或7

      [^47]

    2. 预定义字符集：对常用字符集的简化

      [0-9]-->d: 所有数字字符

      [0-9a-zA-Z_]-->w: 所有字母，数字或_

      s: 所有空字符：空格，制表符...

    比如：6位数字:dddddd

      强调：一个预定义字符集，仅能匹配一位字符

     

      大写字母：除了原字符集内容

      最特殊的预定义字符集：. 表示除换行外，所有字符

    3. 数量词：规定*前一个*相邻字符集出现的次数

         字符集{min,max}: 字符集至少出现min次

                                最多不能超过max次

    比如：6-8位数字密码：d{6,8}

         字符集{min,}: 字符集至少出现min次，多了不限

         字符集{n}: 字符集只能出现n次

    比如：身份证号前15位必须是数字 d{15} 

          后三位是2位数字+1位数字/xX dd[0-9xX]

          后三位可有可无：{0,1}==>?

    d{15}(dd[0-9xX])?

         特殊数量词：

          字符集? : 字符集{0,1} 可有可无，最多只能1次

          字符集* : 字符集{0,}  可有可无，次数不限制

          字符集+ : 字符集{1,}  至少一次，多了不限

比如:手机号：前三位可以是+86或0086,可有可无，最多只能1次

             若干个空字符

             1

             手机号部分的第二位在3,4,5,7,8中选其一

             之后是9位数字

    ((+86)|(0086))?s*1[34578]d{9}

    强调：如果正文中的内容和正则表达式特殊符号冲突

          可用转义

    指定匹配位置：

       ^表达式：表示必须以表达式匹配的内容开头

       表达式$：表示必须以表达式匹配的内容结尾

       ^表达式$：必须和表达式完全匹配！

            只要在程序中执行*验证*,都要前加^，后加$

       ^表达式1|表达式2$:

                 匹配以表达式1开头的部分

              同时匹配以表达式2结尾的部分

       比如：^s+|s+$ ： 匹配字符串开头或结尾的空字符

    

    用户名：6位以上，必须以字母开头，

           至少包含一位数字，以及一位大写字母

       先预匹配，再按表达式正常匹配

       首先，检查不全是字母:(?![a-zA-Z]+$)

          说明可能包含数字

          如果第一检查没通过，说明全是字母，就无效

       其次，检查不全是数字或小写字母：(?![0-9a-z]+$)

          说明可能包含大写字母

       最后，[a-zA-Z][0-9a-zA-Z]{5,}

(?![a-zA-Z]+$)(?![0-9a-z]+$)[a-zA-Z][0-9a-zA-Z]{5,}

1. RegExp:正则表达式对象：

     封装了一条正则表达式，提供了用正则表达式执行验证和查找的功能。

     创建RegExp对象：2种：

       1. 正则表达式固定的：

          var reg=/正则表达式/ig;

       2. 正则表达式可能发生变化：

          var reg=new RegExp("正则表达式","ig");

RegExp API:  

    1. 查找关键字：var arr=reg.exec(str); 

            reg对象中封装了关键字

            str指待检查的目标字符串

       功能：既返回关键字内容，又返回关键字位置。

       但每次仅返回一个关键字。需要while循环配合反复执行           arr[0]中保存关键字的内容。

          arr.index中保存关键字的位置

       强调：exec每次找完，自动将reg.lastIndex属性修改              为下次开始查找位置。不用程序员手工维护。

       *如果找不到，则返回null！*

    查找：找有没有：str.search(reg) 没有返回-1

          找个数/内容：str.match(reg) 没有返回null

          找每个关键字的位置：

       str.indexOf("关键字"[,lastIndex]) 没有返回-1

          即找内容，又找位置：reg.exec(str) 没有返回null

    2. 验证：var bool=reg.test(str)

         reg中封装了规则

         str中传入待验证的字符串

       如果字符串完全符合规则，则返回true，否则返回false

    比如：密码8位以上，只能包含字母，数字

          至少包含1位数字和一位大写字母

      首先：预判字符串不都是字母：可有还有数字或符号

          (?![a-zA-Z]+$)

  其次：预判字符串不都是小写字母和数字：可能有大写或符号

          (?![a-z0-9]+$)

      可有还有数字或符号,可能有大写或符号

      最后：限制字符必须是字母或数字:

           [a-zA-Z0-9]{8,}

   结果：(?![a-zA-Z]+$)(?![a-z0-9]+$)[a-zA-Z0-9]{8,}

   ***课后练习：

     问题1：贪婪模式：正则表达式默认匹配最长的字符串

     原因：(.*)  (.+)

     贪婪模式，改懒惰模式：(.*?) (.+?)

     懒惰模式：匹配最小的字符串

     问题2：获得正则表达式匹配结果中的部分子内容：2步：

        1.在正则表达式中用圆括号括出子部分对应的表达式

    2.在本次查找之后，使用RegExp.$n：获得表达式中第n个括号对应的子内容。

     RegExp.$n：获得正则表达式本次查找中的第n个括号内容

String中支持正则的API：

    1. 查找: str.search(reg)   str.match(reg)

    2. 替换: str.replace(reg,"替换内容")

      str.replace(/我[去草][去草]/g,"***");

      *在"替换内容"中，可使用$n,直接代替子内容*

    3. 分割: str.split(reg)

      var str="eric ,     rose,scott   ,  john";