正则表达式

正则表达式：    java.util.Regex.Pattern类中

字符匹配：
abc            abc
[abc]         a、b、c之中任意一个
[a-zA-Z]     a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[^abc]         除了a、b、c之外的任意一个东西
^a            以a开头
^(abc)        以abc开头的东西中的abc
(abc)$        以abc结尾的东西中的abc


简短表达式：
\d             表示0到9的数字                相当于[0-9]
\D             非数字                         相当于[^0-9]
\s             空格(包括:\t\n\r\x0B\f)        
\S             非空格                        
\w             表示字母数字或下划线        相当于[a-zA-Z0-9_]
\W             非字母数字下划线            相当于[^a-zA-Z0-9_]
.            表示除\n之外的任意一个字符,如果要匹配.的话应写为\.


定位符：
\b            匹配在目标字符串的边界位置


出现次数：    贪婪匹配规则：当匹配字符串、数字等什么时，优先匹配最大长度的什么，万一不能匹配才匹配短长度的什么。
X?             X出现0次或1次
X*             出现0次或多次X,         
X+             出现一次或多次    
X{n}         出现了n次    
X{n,}         至少出现n次    
X{n,m}         至少n次至多m次        //优先匹配m，匹配不了时才匹配n

关系运算：
XY            X后面跟着Y
X|Y            X或Y
(X)            X或一个X表达式
X            X


正则表达式用法：
一、通过Pattern类
二、通过String类

一、
需要Pattern类制定正则表达式，
Matcher类来验证

Pattern类中的方法：
    public static Pattern compile(String regex){}    //通过此方法取得正则并
    public Matcher matcher(CharSequence input){}    //为谁匹配正则
    public String[] split(CharSequence input)        //字符串拆分
    public String pattern()                            //返回正则表达式
在此类中构造方法被隐藏起来，所以需要通过compile方法进行对象的实例化.
Pattern类用来进行正则对象的实例化和字符串的拆分工作

Matcher类中方法：
    public boolean matches()                        //根据正则去匹配
    public String replaceAll(String replacement)    //替换
    public String replaceFirst(String replacement)
    
字符串的验证：需要Pattern类指定验证的正则表达式，最终使用Matcher类进行匹配
字符串的替换：需要Pattern类指定验证的正则表达式，最终使用Matcher类进行匹配
    
二、jdk1.4之后加入了正则表达式并对String类进行了拓展，使得String类支持正则表达式
java.lang.String：
    public boolean matches(String regex)                        //通过正则规则验证
    public String replaceAll(String regex, String replacement)
    public String replaceFirst(String regex,String replacement)    
    public String[] split(String regex)
    
    
    

JS中的正则表达式：

创建正则表达式：

//隐式创建。
g代表全局,如果不加的话会循环去得到第一个匹配的内容,如果是alert的话会出现页面不断弹出第一个匹配的内容。
i表示忽略大小写。
m表示考虑换行模式，一般不用m也恩呢该考虑到换行
var regExp = /正则表达式/gim                   
//显示创建
var reg = new RegExp("正则表达式","gi");    //通过new RegExp()来显示创建。g代表全局,i表示忽略大小写。此时若正则表达式中有\需要再前面再加个\来转义


正则对象的方法：
regExp.exec(str)：        检索字符串中指定的值，没有值返回null，若有值返回一个数组并将数组里的值放入数组下标为0的元素里，可用for或while循环取出。
regExp.test(str)：          检索字符串中指定的值，返回true或false


String对象的方法：
stringObj.match(rgExp) ：                    如果 match 方法没有找到匹配，返回 null。如果找到匹配返回一个数组
stringObj.search(rgExp)：                    返回与正则表达式查找内容匹配的第一个子字符串的下标位置。如果没有找到匹配返回-1
stringObj.replace(rgExp, replaceStr)：        rgExp是被替换的正则表达式，replaceStr是要替换的字符串，返回替换后的字符串
stringObj.split([separator[, limit]])：        将一个字符串分割为子字符串，然后将结果作为字符串数组返回。limit为返回数组的个数


内置对象RegExp的属性：
index        :    当前匹配内容中的开始下标
leftContext    :    当前匹配内容左边的内容
rightContext:    当前匹配的右边内容


引用表达式：
如例：var regExp = /(\d)(\d)\2\1/gim;     其中第一个(\d)表示第1个表达式    ，第二个(\d)表示第2个表达式，\2表示引用第2个表达式里面的内容，\1表引用第1个表达式里的内容


转义：
在匹配时与转义相关的字符有：. * + ( ) $ / \ ? [ ] ^ { } ，就是单独去查找这些字符时需要用\来转义的。


script type="text/javascript">
        
        //正则的exec方法，隐式创建正则表达式
        function testRegex1(){                            //检查输入框中是否有连续4个数字
            var tex = ta.innerText;
            var regExp = /\d{4}/gi;                        //第一种隐式创建正则表达式方法
            while(regres = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert(regres[0]);                        //返回一个数组并将数组里的值循环放进regres[0]里面。不能将regres[0]写成regres因为这样有时不能正确显示。
            }
        }
    
        //正则的exec方法，显示地创建正则表达式
        function testRegex2(){                            //检查输入框中是否有连续4个数字
            var tex = ta.innerText;
            alert("1");
            var reg = new RegExp("\\d{4}","gi");        //第二种显示创建正则表达式方法
            alert("2");
            while(regres = reg.exec(tex)){                //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
            alert("3");
                alert(regres[0]);                        //返回一个数组并将数组里的值循环放进regres[0]里面
            }
        }
        
        //正则的exec方法,返回空或数组
        function testRegex3(){                            //检查输入框中是否有"啦啦啦"字符串
            var tex = ta.innerText;
            var regExp = /啦啦啦/gi;                        //查找字符串中的“啦啦啦”
            alert(tex);
            while(regres = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert(regres[0]);                        //返回一个数组并将数组里的值循环放进regres[0]里面
            }
        }
        
        //正则的exec方法
        function testRegex4(){                            //显示输入框中所有以abc开头的字符串
            var tex = ta.innerText;
            var regExp = /^(abc)/gim;                    //以什么开头匹配的情况下匹配，若不加m则只在第一行找相应的匹配
            while(regres = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert("找到："+regres[0]);                //返回一个数组并将数组里的值循环放进regres[0]里面
            }
        }
        
        //正则的test方法
        function testRegex5(){                            //检查输入文本是否有abc字符串
            var tex = ta.innerText;
            var regExp = /abc/gim;                    
            if(regExp.test(tex)){
                alert("有abc字符串");
            }else{
                alert("没有abc字符串");
            }
        }
        
        //String的search方法
        function SearchDemo(){                             //显示第一个匹配字符串的下标位置
               var r, re;                                   // 声明变量。
            var s = "The rain in Spain falls mainly in the plain.";
            re = /falls/i;                                 // 创建正则表达式模式。
            r = s.search(re);                            // 查找字符串。
               alert(r);                                     // 显示第一次匹配时的下标位置
        }
        
        //String的match方法
        function matchDemo(){                            //寻找输入文本中与abc匹配的字符串，返回数组
              var tex = ta.innerText;
            var reg = /abc/gim;
            regObj = tex.match(reg);
            for(var i=0;i<regObj.length;i++){
                alert("第"+(i+1)+"个"+regObj[i]);
            }    
        }
        
        //String的replace方法
        function ReplaceDemo(){                            //替换功能
            var r, re;                                    // 声明变量。
            var ss = "The man hit the ball with the bat.\n";
            ss += "while the fielder caught the ball with the glove.";
            re = /The/g;                                 // 创建正则表达式模式。
            r = ss.replace(re, "A");                    // 用 "A" 替换 "The"。
            alert(r);                                   // 返回替换后的字符串。
        }
        
        //String的split方法
        function SplitDemo(){                            //按空格分解字符串，返回数组
            var s, ss;
            var s = "The rain in Spain falls mainly in the plain.";
            // 在每个空格字符处进行分解。
            ss = s.split(" ");
            for(var i=0;i<ss.length;i++){
                alert("第"+(i+1)+"个元素："+ss[i]);
            }
        }
        
        //内置对象RegExp的index、leftContext、rightContext属性
        function testRegExp(){                            //查看内置对象RegExp的属性
            var tex = ta.innerText;
            var regExp = /\d{4}/gim;                    
            while(regres = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert("index:"+RegExp.index + "\tleft:"+RegExp.leftContext +"\tright:"+RegExp.rightContext);    //内置对象RegExp的属性
            }
        }
        
        //引用表达式
        function refersTo1(){                            //给定一个字符串，要求找出其中四个连在一起的数字，并且第二与第三位相同，第一与第四位相同。
            var tex = ta.innerText;
            var regExp = /(\d)(\d)\2\1/gim;                //此时\d必须用小括号()括起来表示一个表达式
                                                        //第一个(\d)表示第1个表达式    ，第二个(\d)表示第2个表达式，
                                                        //\2表示引用第2个表达式里面的内容，\1表引用第1个表达式
            while(result = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert(result[0]);
            }
        }
        
        //引用表达式
        function refersTo2(){                            //查询这样的号码：要求前面是任意5位数字，然后-符号，然后连续三位相同的9位数字，如：12345-111222333
            var tex = ta.innerText;
            var regExp = /(\d){5}-(\d)\2\2(\d)\3\3(\d)\4\4/gim;        //此时\d必须用小括号()括起来表示一个表达式
            while(result = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert(result[0]);
            }
        }
        
        //{n}正则元素个数的匹配规则
        function testNum1(){                            //从一个匹配完的字符串后面再次寻找匹配，测试中可以输入"1111"查看
            var tex = ta.innerText;
            var regExp = /1{2}/gim;                        
            while(result = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert(result[0]);
            }
        }
        
        //{n,m}正则元素个数的匹配规则
        function testNum2(){                            //先匹配最大长度，匹配不了时才匹配短的长度。所以它先匹配3个长度再匹配2个长度。
                                                        //测试中可以输入"11111"查看
            var tex = ta.innerText;
            var regExp = /1{2,3}/gim;                    
            while(result = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert(result[0]);
            }
        }
        
        //x*的匹配：0到无穷次。
        function testNum3(){                            //先匹配最大长度，匹配不了时才匹配短的长度。所以它先匹配3个长度再匹配2个长度。
                                                        //测试中可以输入"a11"查看
            var tex = ta.innerText;
            var regExp = /a1*/gim;                        //*对应的是1，不是a1.
            while(result = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert(result[0]);
            }
        }
        
        //[a-z]?的匹配：0到无穷次。                            //会得到5个结果,其中包括空的结果,因为?表示0到1,0的时候就有空的结果返回
        function testNum4(){                            //先匹配最大长度，匹配不了时才匹配短的长度。所以它先匹配3个长度再匹配2个长度。
                                                        //测试中可以输入"abcd"查看
            var tex = ta.innerText;
            var regExp = /[a-z]?/gim;                    
            while(result = regExp.exec(tex)){            //exec为正则表达式与什么匹配执行的方法，该方法返回数组，数组的第一个元素就是与正则匹配的内容
                alert(result[0]);
            }
        }
        
        //.    用来匹配除\n之外的任意一个字符                    //输入:abc.45,结果将abc.45六个字符循环输出
        function point1(){                                
            var tex = ta.innerText;
            var regExp = /./gim;                    
            while(result = regExp.exec(tex)){            
                alert(result[0]);
            }
        }
        
        //    \.用来匹配.字符                                //输入:abc.45,结果将输出.
        function point2(){                                
            var tex = ta.innerText;
            var regExp = /\./gim;                    
            while(result = regExp.exec(tex)){            //js中如果result的结果不为空，while中的result可以被当成true来使用
                alert(result[0]);
            }
        }
        
        //[\d]\1{2}的用法                                    //输入abc123aaa111，输出111
        function ts1(){                                    //匹配任意三个相同的数字
            var tex = ta.innerText;
            var regExp = /([\d])\1{2}/gim;                //三个相同的数字
            while(result = regExp.exec(tex)){            
                alert(result[0]);
            }
        }
        
        //^匹配在目标字符串的开始位置
        function ts2(){                                    //输入11 22得到11
            var tex = ta.innerText;
            var regExp = /^(\d){2}/gim;                    
            while(result = regExp.exec(tex)){            
                alert(result[0]);
            }
        }
        
        //$匹配在目标字符串的结束位置
        function ts3(){                                    //输入11 22得到22
            var tex = ta.innerText;
            var regExp = /((\d){2})$/gim;                    
            while(result = regExp.exec(tex)){            
                alert(result[0]);
            }
        }
        
        //$匹配在目标字符串的结束位置                        //匹配最后位置是abc的abc
        function ts4(){                                    //输入aaa中文得到中文
            var tex = ta.innerText;
            var regExp = /中文$/gim;                    
            while(result = regExp.exec(tex)){            
                alert(result[0]);
            }
        }
        
        //\b匹配在目标字符串的边界位置                        //匹配最后位置是abc的abc
        function ts5(){                                    //输入"aaa1 2aaa"得到1
            var tex = ta.innerText;
            var regExp = /\b\d/gim;                        
            while(result = regExp.exec(tex)){            
                alert(result[0]);
            }
        }
        
        //\b匹配在目标字符串的边界位置                        //匹配最后位置是abc的abc。边界指的是目标字符串之间的空格和结尾
        function ts6(){                                    //输入"aaa1 2aaa"得到2
            var tex = ta.innerText;
            var regExp = /\d\b/gim;                        
            while(result = regExp.exec(tex)){            
                alert(result[0]);
            }
        }
        
        
        //验证电子邮件格式是否正确                    //匹配最后位置是abc的abc。边界指的是目标字符串之间的空格和结尾
        function testEmail(){                                    //输入"aaa1 2aaa"得到2
            var tex = ta.innerText;
            var regExp = /^[a-zA-Z0-9_-]+@([a-zA-Z0-9]+\.)+(com|cn|net|org)$/g                
            if(result = regExp.test(tex)){            
                alert("是一封格式正确的邮件");
            }else{
                alert("不是一封正确的邮件");
            }
        }
    </script>