Java正则表达式

正则表达式在处理文本方面用处非常大，最早像在Perl和awk语言中，提供了这种机制，Java在Java 2中也增加了正则表达式这个包java.util.regex。这个包为用户使用正则表达式，提供了易用而全面的支持。我的研究方向是web挖掘。从网页中提取内容,处理文本，当然需要正则表达式这个强大的工具了。
一、首先我们看一下怎么使用正则表达式的一个例子：
A Matcher examines the results of applying a pattern.
我们希望从这句话中找到所有开头为a的单词。
当然这只是一个简单的例子，你可以使用String提供的split方法，得到单词数组，然后
遍历各个单词看是否是否开头为a
我们现在看看怎么使用正则表达式来处理这个问题：

import java.util.regex.*;

public class FindA{
  public static void main(String args[])
  throws Exception{

    String candidate =
     "A Matcher examines the results of applying a pattern.";
    String regex = "//ba//w*//b";
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(candidate);
    String val = null;
    System.out.println("INPUT: " + candidate);
    System.out.println("REGEX: " + regex +"/r/n");
    while (m.find()){
      val = m.group();
      System.out.println("MATCH: " + val);
    }
    if (val == null) {
      System.out.println("NO MATCHES: ");
    }
  }
}

import java.util.regex.*;

public class FindA{
  public static void main(String args[])
  throws Exception{

    String candidate =
     "A Matcher examines the results of applying a pattern.";
    String regex = "//ba//w*//b";
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(candidate);
    String val = null;
    System.out.println("INPUT: " + candidate);
    System.out.println("REGEX: " + regex +"/r/n");
    while (m.find()){
      val = m.group();
      System.out.println("MATCH: " + val);
    }
    if (val == null) {
      System.out.println("NO MATCHES: ");
    }
  }
}

从这个例子我们可以看到正则表达式涉及到的两个类Matcher和Pattern,我们以后会专门讨论着连个类。现在主要看看使用正则表达式的流程：
首先使用　Pattern的一个静态的方法compile来创建Pattern对象，

Pattern p = Pattern.compile(regex);

Pattern p = Pattern.compile(regex);

然后调用Pattern的方法matcher

Matcher m = p.matcher(candidate);

 Matcher m = p.matcher(candidate);

得到了Matcher对象，Matcher对象保存了许多匹配信息，然后可以通过find()方法
查找匹配的部分，如果有匹配的部分，返回真，使用m.group方法得到匹配的各组值，
否则find返回false.
当然这只是一般的过程，还有许多更细的方法，在以后会陆续的总结，下面我们看一下

String regex = "//ba//w*//b";

String regex = "//ba//w*//b";

这个就是一个正则表达式，b,w,*都是正则表达式的meta character原字符，
/b表示单词的边界，w表示任意的可构成单词的字母数字，*表示前面的字母(当然可以
是更复杂的组之类的了东东)重复0次或0次以上，a当然还是a了。所以这个regex就
匹配单词开头为a的单词了。
二、下面总结一下基本的正则表达式的meta character以及它们含义：
. 匹配任意一个字符　$　匹配一行的结尾　^　匹配一行的开头(在[]里面表示否定)
{}　定义了一个范围　 [] 定义了一个字符类　() 定义了一个组
*前面出现0次以上 +　前面匹配一次以上　?前面出现0次或一次　　
/　后面的字符不会看作metacharacter /w 字母数字下划线　/W 非字母数字下划线
/d 单个数字　/D单个非数字　| 或，二者之一　&&与操作符 /b单词边界
下面看看几个简单的例子：
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
三、java.util.regex提供的操作接口：
java.util.regex包提供了操作正则表达式的模型，整个模型优雅而简洁，只有三个类：Pattern、Matcher和
PatternSyntaxException。下面将要总结他们提供的方法，以及如何灵活应用来处理文本。

我们还是从Pattern的静态工厂方法来扩展吧：

static Pattern compile(String regex)

static Pattern compile(String regex) 

将给定的正则表达式编译到模式中，并创建Pattern对象，这个方法通常是操作正则表达式的第一步，从前面那个例子
我们也可以看到整个的流程。
在看看一个重载的compile方法：

static Pattern compile(String regex, int flags)

 
static Pattern compile(String regex, int flags) 

将给定的正则表达式编译到具有给定标志的模式中。 这个方法参数flags提供了一些特殊的选项来用于特殊的处理，
我们下面看看可使用的选项：
UNIX_LINES：这个主要处理UNIX和其他的操作系统在行结束符不一样的问题，UNIX使用/n代表一行的终止，而Windows
则使用了/r/n,/n,/r,/u2028或者/u0085作为一行的结束符。
CASE_INSENSITIVE：当我们在匹配的时候要忽略字符大小写时
COMMENTS:允许我们在正则表达式中使用注释，例如

Pattern p =Pattern.compile("A    #matches uppercase US-ASCII char code 65",Pattern.COMMENTS);

Pattern p =Pattern.compile("A    #matches uppercase US-ASCII char code 65",Pattern.COMMENTS);

MULTILINE:表明要输入多行，他们有自己的终止字符。

Pattern p = Pattern.compile("^", Pattern.MULTILINE);

Pattern p = Pattern.compile("^", Pattern.MULTILINE);

如果你的输入的字符串是：This is a sentence./n So is this..
这样我们匹配的字符时This中的T和So中的S，如果不使用MULTILINE，则只会匹配T
DOTALL:使用这个选项之后metacharacter .就可以包括一行的终止字符了，如果没有这个选项，
一行的终止字符，并不会考虑在字符串之内的。
使用这个选项会降低效率

Pattern p = Pattern.compile(".", Pattern.DOTALL);

Pattern p = Pattern.compile(".", Pattern.DOTALL);

如果我们输入的是Test/n，则匹配的字符是5个。
UNICODE_CASE:处理UNICODE字符集，使用这个选项会降低效率
CANON_EQ：一个字符的实际存储形式是经过编码后的数字，使用CANON_EQ选项就可以匹配一个字母在各种编码了。
例如a可以匹配+00E0和U+0061U+0300
使用这个选项会降低效率
我们可以组合以上选项，只要使用|,进行按位或操作即可

Pattern p =
Pattern.compile("t # a compound flag example",Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE|
Pattern.COMMENT);

Pattern p =
Pattern.compile("t # a compound flag example",Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE|
Pattern.COMMENT);

我们还要注意点的时Java对转译字符/的处理，例如我们要匹配一个数字：
我们不能使用：

Pattern p = Pattern.compile("/d");

Pattern p = Pattern.compile("/d");

而是：

Pattern p = Pattern.compile("//d");

Pattern p = Pattern.compile("//d");

另外如果regex本身形式是错误的，compile方法会抛出java.util.regex.PatternSyntaxException异常。
下面我们总结一下public Matcher matcher(CharSequence input)方法：
当我们使用compile操作，创建了Pattern对象之后，我们就可以使用Pattern对象的matcher操作，生成
matcher对象了，Matcher对象包含了许多对匹配结果集的操作，我们在总结Matcher对象的时候再说。另外
顺便提一下参数CharSequence，CharBuffer, Segment, String, StringBuffer, StringBuilder 都实现了
这个接口，所以参数可以是这些中的任一种类型了。
下面我们看看：

public int flags()

public int flags()

这个方法返回了我们前面可以设置的并且已经设置的flags选项，我们通过按位与来判断是否设置了某个选项：

int flgs = myPattern.flags();
boolean isUsingCommentFlag =( Pattern.COMMENTS == (Pattern.COMMENTS & flgs)) ;

int flgs = myPattern.flags();
boolean isUsingCommentFlag =( Pattern.COMMENTS == (Pattern.COMMENTS & flgs)) ;

看看一个简化过程的方法：

public static boolean matches (String regex,CharSequence input)

public static boolean matches (String regex,CharSequence input)

这个方法实际上是：

Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(candidate);
m.matches()

 Pattern p = Pattern.compile(regex);
 Matcher m = p.matcher(candidate);
 m.matches()

过程的一个简化,我们在后面总结Matcher中的matches方法之后就会理解这个了。
想必我们经常使用把字符串提取出token变成字符串数组的String中的split方法吧，下面我们看看
类似的一个方法：
public String[] split(CharSequence input)
这个方法提供了强大的功能，因为它可以使用正则表达式来作为token的分割：

Pattern p = new Pattern.compile(",|and");
String fruits[] = p.split("apple,banana and orange");

 Pattern p = new Pattern.compile(",|and");
 String fruits[] = p.split("apple,banana and orange");

split的一个重载的版本：

public String[] split(CharSequence input, int limit)

public String[] split(CharSequence input, int limit)

它指定了划分的组数，有以下三种情况：
limit==0
这时候和没有limit参数的那个split效果一样
limit>0
如果你仅仅对前limit个感兴趣，你可以使用limit：

String[] tmp = pattern.split("Hello, Dolly, You, Are, My, Favorite",3);
//tmp[0] is  "Hello",
// tmp[1] is "Dolly";
//tmp[2] is  "You, Are, My, Favorite";

String[] tmp = pattern.split("Hello, Dolly, You, Are, My, Favorite",3);
//tmp[0] is  "Hello",
// tmp[1] is "Dolly";
//tmp[2] is  "You, Are, My, Favorite";

limit<0
会尽可能的划分所有的组，即使分割符后面是个空字符，也要单独生成一个token:""

Pattern p = Pattern.compile(",");
String temp[] = p.split("Hello,Dolly,", -1);
//temp[]={"Hello","Dolly",""}

Java正则表达式(二)

关键字: java regex, regular expression

Matcher类:
使用Matcher类,最重要的一个概念必须清楚: 组(Group),在正则表达式中
()定义了一个组,由于一个正则表达式可以包含很多的组,所以下面先说说怎么划分组的,
以及这些组和组的下标怎么对应的.
下面我们看看一个小例子,来说明这个问题

引用

/w(/d/d)(/w+)

这个正则表达式有三个组:
整个/w(/d/d)(/w+) 是第0组 group(0)
(/d/d)是第1组 group(1)
(/w+)是第2组 group(2)
我们看看和正则表达式匹配的一个字符串x99SuperJava，
group(0)永远都是匹配整个表达式的字符串的那部分x99SuperJava
group(1)是第1组(/d/d)匹配的部分:99
group(2)是第二组(/w+)匹配的那部分SuperJava
下面我们写一个程序来验证一下：

package edu.jlu.fuliang;

import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class RegexTest {
    public static void main(String[] args) {
        String regex = "//w(//d//d)(//w+)";
        String candidate = "x99SuperJava";

        Pattern p = Pattern.compile(regex);
        Matcher matcher = p.matcher(candidate);
        if(matcher.find()){
            int gc = matcher.groupCount();
            for(int i = 0; i <= gc; i++)
                System.out.println("group " + i + " :" + matcher.group(i));
        }
    }
}

package edu.jlu.fuliang;

import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class RegexTest {
	public static void main(String[] args) {
		String regex = "//w(//d//d)(//w+)";
		String candidate = "x99SuperJava";
		
		Pattern p = Pattern.compile(regex);
		Matcher matcher = p.matcher(candidate);
		if(matcher.find()){
			int gc = matcher.groupCount();
			for(int i = 0; i <= gc; i++)
				System.out.println("group " + i + " :" + matcher.group(i));
		}
	}
}

输出结果:

引用

group 0 :x99SuperJava
group 1 :99
group 2 :SuperJava

下面我们看看Matcher类提供的方法：
public Pattern pattern()
这个方法返回了，创建Matcher的那个pattern对象。
下面我们看看一个小例子来说明这个结果

import java.util.regex.*;

public class MatcherPatternExample{
  public static void main(String args[]){
      test();
  }

  public static void test(){
     Pattern p = Pattern.compile("//d");
     Matcher m1 = p.matcher("55");
     Matcher m2 = p.matcher("fdshfdgdfh");

     System.out.println(m1.pattern() == m2.pattern());
     //return true
  }
}

import java.util.regex.*;

public class MatcherPatternExample{
  public static void main(String args[]){
      test();
  }

  public static void test(){
     Pattern p = Pattern.compile("//d");
     Matcher m1 = p.matcher("55");
     Matcher m2 = p.matcher("fdshfdgdfh");

     System.out.println(m1.pattern() == m2.pattern());
     //return true
  }
}

public Matcher reset()
这个方法将Matcher的状态重新设置为最初的状态。
public Matcher reset(CharSequence input)
重新设置Matcher的状态，并且将候选字符序列设置为input后进行Matcher,
这个方法和重新创建一个Matcher一样，只是这样可以重用以前的对象。
public int start()
这个方法返回了，Matcher所匹配的字符串在整个字符串的的开始下标：
下面我们看看一个小例子

public class MatcherStartExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
     //create a Matcher and use the Matcher.start() method
     String candidateString = "My name is Bond. James Bond.";
     String matchHelper[] =
      {"          ^","                      ^"};
     Pattern p = Pattern.compile("Bond");
     Matcher matcher = p.matcher(candidateString);

     //Find the starting point of the first 'Bond'
      matcher.find();
      int startIndex = matcher.start();
      System.out.println(candidateString);
      System.out.println(matchHelper[0] + startIndex);

     //Find the starting point of the second 'Bond'
      matcher.find();
      int nextIndex = matcher.start();
      System.out.println(candidateString);
      System.out.println(matchHelper[1] + nextIndex);
}

public class MatcherStartExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
     //create a Matcher and use the Matcher.start() method
     String candidateString = "My name is Bond. James Bond.";
     String matchHelper[] =
      {"          ^","                      ^"};
     Pattern p = Pattern.compile("Bond");
     Matcher matcher = p.matcher(candidateString);

     //Find the starting point of the first 'Bond'
      matcher.find();
      int startIndex = matcher.start();
      System.out.println(candidateString);
      System.out.println(matchHelper[0] + startIndex);

     //Find the starting point of the second 'Bond'
      matcher.find();
      int nextIndex = matcher.start();
      System.out.println(candidateString);
      System.out.println(matchHelper[1] + nextIndex);
}

输出结果：
My name is Bond. James Bond.
^11
My name is Bond. James Bond.
^23
public int start(int group)
这个方法可以指定你感兴趣的sub group,然后返回sup group匹配的开始位置。
public int end()
这个和start()对应，返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
其实start和end经常是一起配合使用来返回匹配的子字符串。
public int end(int group)
和public int start(int group)对应，返回在sup group匹配的子字符串最后一个字符在整个字符串下标加一
public String group()
返回由以前匹配操作所匹配的输入子序列。
这个方法提供了强大而方便的工具，他可以等同使用start和end,然后对字符串作substring(start,end)操作。
看看下面一个小例子：

import java.util.regex.*;

public class MatcherGroupExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
      //create a Pattern
      Pattern p = Pattern.compile("Bond");

      //create a Matcher and use the Matcher.group() method
      String candidateString = "My name is Bond. James Bond.";
      Matcher matcher = p.matcher(candidateString);
      //extract the group
      matcher.find();
      System.out.println(matcher.group());
  }
}

import java.util.regex.*;

public class MatcherGroupExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
      //create a Pattern
      Pattern p = Pattern.compile("Bond");

      //create a Matcher and use the Matcher.group() method
      String candidateString = "My name is Bond. James Bond.";
      Matcher matcher = p.matcher(candidateString);
      //extract the group
      matcher.find();
      System.out.println(matcher.group());
  }
}

public String group(int group)
这个方法提供了强大而方便的工具，可以得到指定的group所匹配的输入字符串
应为这两个方法经常使用，同样我们看一个小例子：

import java.util.regex.*;

public class MatcherGroupParamExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
     //create a Pattern
      Pattern p = Pattern.compile("B(ond)");

     //create a Matcher and use the Matcher.group(int) method
     String candidateString = "My name is Bond. James Bond.";
     //create a helpful index for the sake of output
     Matcher matcher = p.matcher(candidateString);
     //Find group number 0 of the first find
      matcher.find();
      String group_0 = matcher.group(0);
      String group_1 = matcher.group(1);
      System.out.println("Group 0 " + group_0);
      System.out.println("Group 1 " + group_1);
      System.out.println(candidateString);

     //Find group number 1 of the second find
      matcher.find();
      group_0 = matcher.group(0);
      group_1 = matcher.group(1);
      System.out.println("Group 0 " + group_0);
      System.out.println("Group 1 " + group_1);
      System.out.println(candidateString);
  }
}

import java.util.regex.*;

public class MatcherGroupParamExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
     //create a Pattern
      Pattern p = Pattern.compile("B(ond)");

     //create a Matcher and use the Matcher.group(int) method
     String candidateString = "My name is Bond. James Bond.";
     //create a helpful index for the sake of output
     Matcher matcher = p.matcher(candidateString);
     //Find group number 0 of the first find
      matcher.find();
      String group_0 = matcher.group(0);
      String group_1 = matcher.group(1);
      System.out.println("Group 0 " + group_0);
      System.out.println("Group 1 " + group_1);
      System.out.println(candidateString);

     //Find group number 1 of the second find
      matcher.find();
      group_0 = matcher.group(0);
      group_1 = matcher.group(1);
      System.out.println("Group 0 " + group_0);
      System.out.println("Group 1 " + group_1);
      System.out.println(candidateString);
  }
}

public int groupCount()
这个方法返回了，正则表达式的匹配的组数。
public boolean matches()
尝试将整个区域与模式匹配。这个要求整个输入字符串都要和正则表达式匹配。
和find不同， find是会在整个输入字符串查找匹配的子字符串。
public boolean find()
find会在整个输入中寻找是否有匹配的子字符串，一般我们使用find的流程：

while(matcher.find()){
   //在匹配的区域，使用group,replace等进行查看和替换操作
}

 while(matcher.find()){
    //在匹配的区域，使用group,replace等进行查看和替换操作
 }

public boolean find(int start)
从输入字符串指定的start位置开始查找。
public boolean lookingAt()
基本上是matches更松约束的一个方法，尝试将从区域开头开始的输入序列与该模式匹配
public Matcher appendReplacement (StringBuffer sb, String replacement)
你想把My name is Bond. James Bond. I would like a martini中的Bond换成Smith

StringBuffer sb = new StringBuffer();
String replacement = "Smith";
Pattern pattern = Pattern.compile("Bond");
Matcher matcher =pattern.matcher("My name is Bond. James Bond. I would like a martini.");
while(matcher.find()){
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith
}

StringBuffer sb = new StringBuffer();
String replacement = "Smith";
Pattern pattern = Pattern.compile("Bond");
Matcher matcher =pattern.matcher("My name is Bond. James Bond. I would like a martini.");
while(matcher.find()){
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith
}

Matcher对象会维护追加的位置，所以我们才能不断地使用appendReplacement来替换所有的匹配。
public StringBuffer appendTail(StringBuffer sb)
这个方法简单的把为匹配的结尾追加到StringBuffer中。在上一个例子的最后再加上一句：
matcher.appendTail(sb);
结果就会成为My name is Smith. James Smith. I would like a martini.
public String replaceAll(String replacement)
这个是一个更方便的方法，如果我们想替换所有的匹配的话，我们可以简单的使用replaceAll就ok了。
是：

while(matcher.find()){
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith
}
matcher.appendTail(sb);

while(matcher.find()){
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith
}
matcher.appendTail(sb);

的更便捷的方法。

public String replaceFirst(String replacement)

public String replaceFirst(String replacement)

这个与replaceAll想对应很容易理解，就是只替换第一个匹配的。

 

[size = 12px] 1 。 ^ /d + $　　 // 匹配非负整数（正整数 + 0）
2 。 ^ [ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * $　　 // 匹配正整数
3 。 ^ (( - /d + ) | ( 0 + ))$　　 // 匹配非正整数（负整数 + 0）
4 。 ^- [ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * $　　 // 匹配负整数
5 。 ^-? /d + $　　　　 // 匹配整数
6 。 ^ /d + (/./d + ) ? $　　 // 匹配非负浮点数（正浮点数 + 0）
7 。 ^ (([ 0 - 9 ] + /.[ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * ) | ([ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * /.[ 0 - 9 ] + ) | ([ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * ))$　　 // 匹配正浮点数
8 。 ^ (( - /d + (/./d + ) ? ) | ( 0 + (/. 0 + ) ? ))$　　 // 匹配非正浮点数（负浮点数 + 0）
9 。 ^ ( - (([ 0 - 9 ] + /.[ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * ) | ([ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * /.[ 0 - 9 ] + ) | ([ 0 - 9 ] * [ 1 - 9 ][ 0 - 9 ] * )))$　　 // 匹配负浮点数
10 。 ^ ( -? /d + )(/./d + ) ? $　　 // 匹配浮点数
11 。 ^ [A - Za - z] + $　　 // 匹配由26个英文字母组成的字符串
12 。 ^ [A - Z] + $　　 // 匹配由26个英文字母的大写组成的字符串
13 。 ^ [a - z] + $　　 // 匹配由26个英文字母的小写组成的字符串
14 。 ^ [A - Za - z0 - 9 ] + $　　 // 匹配由数字和26个英文字母组成的字符串
15 。 ^ /w + $　　 // 匹配由数字、26个英文字母或者下划线组成的字符串
16 。 ^ [/w - ] + (/.[/w - ] + ) * @[/w - ] + (/.[/w - ] + ) + $　　　　 // 匹配email地址
17 。 ^ [a - zA - z] + : // 匹配(/w+(-/w+)*)(/.(/w+(-/w+)*))*(/?/S*)?$　　 // 匹配url
18 。匹配中文字符的正则表达式： [/u4e00 - /u9fa5]
19 。匹配双字节字符(包括汉字在内)：[ ^ /x00 - /xff]
20 。应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
String.prototype.len = function(){ return this .replace([ ^ /x00 - /xff] / g, " aa " ).length;}
21 。匹配空行的正则表达式：/n[/s | ] * /r
22 。匹配HTML标记的正则表达式： /< (. * ) > . *< / / / 1 >|< (. * ) / />/
23 。匹配首尾空格的正则表达式：( ^ /s * ) | (/s * $)

* 正则表达式用例
  * 1 、 ^ /S + [a - z A - Z]$ 不能为空 不能有空格  只能是英文字母
  * 2 、/S{ 6 ,}         不能为空 六位以上
  * 3 、 ^ /d + $          不能有空格 不能非数字
  * 4 、(. * )(/.jpg | /.bmp)$ 只能是jpg和bmp格式
  * 5 、 ^ /d{ 4 }/ - /d{ 1 , 2 } - /d{ 1 , 2 }$ 只能是2004 - 10 - 22格式
  * 6 、 ^ 0 $            至少选一项
  * 7 、 ^ 0 { 2 ,}$        至少选两项
  * 8 、 ^ [/s | /S]{ 20 ,}$ 不能为空 二十字以上
  * 9 、 ^ / +? [a - z0 - 9 ](([ -+ .] | [_] + ) ? [a - z0 - 9 ] + ) * @([a - z0 - 9 ] + (/. | / - )) + [a - z]{ 2 , 6 }$邮件
  * 10 、/w + ([ -+ .]/w + ) * @/w + ([ - .]/w + ) * /./w + ([ - .]/w + ) * ([,;]/s * /w + ([ -+ .]/w + ) * @/w + ([ - .]/w + ) * /./w + ([ - .]/w + ) * ) * 输入多个地址用逗号或空格分隔邮件
  * 11 、 ^ (/([ 0 - 9 ] + /)) ? [ 0 - 9 ]{ 7 , 8 }$电话号码7位或8位或前面有区号例如（ 022 ） 87341628
  * 12 、 ^ [a - z A - Z 0 - 9 _] + @[a - z A - Z 0 - 9 _] + (/.[a - z A - Z 0 - 9 _] + ) + (/,[a - z A - Z 0 - 9 _] + @[a - z A - Z 0 - 9 _] + (/.[a - z A - Z 0 - 9 _] + ) + ) * $
  *      只能是字母、数字、下划线；必须有@和.同时格式要规范 邮件
  * 13 ^ /w + @/w + (/./w + ) + (/,/w + @/w + (/./w + ) + ) * $上面表达式也可以写成这样子，更精练。
    14    ^ /w + (( - /w + ) | (/./w + )) * /@/w + ((/. |- )/w + ) * /./w + $ [ / size]

 

21。匹配空行的正则表达式：/n[/s ¦ ]*/r
21。匹配空行的正则表达式：/^/s*$/m

22。匹配HTML标记的正则表达式：/ <(.*)>.* <///1> ¦ <(.*)//>/
22。匹配HTML标记的正则表达式：/ <([^>]+)>[^ <>]* <///1> ¦ <([^>]+)//>/
这个实际上作用不大，因为正则表达式不能支持嵌套匹配，仅 .NET 的表达式引擎有这个功能。

23。匹配首尾空格的正则表达式：(^/s*) ¦(/s*$)
23。匹配首尾空格的正则表达式：^/s+ ¦/s+$
    为 JavaScript 的 String 增加 trim() 函数：
    String.prototype.trim = function() {
      return this.replace(/^/s+/, '').replace(//s+$/, '');
  }

* 4、(.*)(/.jpg ¦/.bmp)$ 只能是jpg和bmp格式

* 8、^[/s ¦/S]{20,}$ 不能为空 二十字以上
匹配中文字符的正则表达式： [/u4e00-/u9fa5] 
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了 
 
匹配双字节字符(包括汉字在内)：[^/x00-/xff] 
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1） 
 
匹配空白行的正则表达式：/n/s*/r 
评注：可以用来删除空白行 
 
匹配HTML标记的正则表达式： <(/S*?)[^>]*>.*? ¦ <.*? /> 
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力 
 
匹配首尾空白字符的正则表达式：^/s* ¦/s*$ 
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式 
 
匹配Email地址的正则表达式：/w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)* 
评注：表单验证时很实用 
 
匹配网址URL的正则表达式：[a-zA-z]+://[^/s]* 
评注：网上流传的版本功能很有限，上面这个基本可以满足需求 
 
匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$ 
评注：表单验证时很实用 
 
匹配国内电话号码：/d{3}-/d{8} ¦/d{4}-/d{7} 
评注：匹配形式如 0511-4405222 或 021-87888822 
 
匹配腾讯QQ号：[1-9][0-9]{4,} 
评注：腾讯QQ号从10000开始 
 
匹配中国邮政编码：[1-9]/d{5}(?!/d) 
评注：中国邮政编码为6位数字 
 
匹配身份证：/d{15} ¦/d{18} 
评注：中国的身份证为15位或18位 
 
匹配ip地址：/d+/./d+/./d+/./d+ 
评注：提取ip地址时有用 
 
匹配特定数字： 
^[1-9]/d*$　 　 //匹配正整数 
^-[1-9]/d*$ 　 //匹配负整数 
^-?[1-9]/d*$　　 //匹配整数 
^[1-9]/d* ¦0$　 //匹配非负整数（正整数 + 0） 
^-[1-9]/d* ¦0$　　 //匹配非正整数（负整数 + 0） 
^[1-9]/d*/./d* ¦0/./d*[1-9]/d*$　　 //匹配正浮点数 
^-([1-9]/d*/./d* ¦0/./d*[1-9]/d*)$　 //匹配负浮点数 
^-?([1-9]/d*/./d* ¦0/./d*[1-9]/d* ¦0?/.0+ ¦0)$　 //匹配浮点数 
^[1-9]/d*/./d* ¦0/./d*[1-9]/d* ¦0?/.0+ ¦0$　　 //匹配非负浮点数（正浮点数 + 0） 
^(-([1-9]/d*/./d* ¦0/./d*[1-9]/d*)) ¦0?/.0+ ¦0$　　//匹配非正浮点数（负浮点数 + 0） 
评注：处理大量数据时有用，具体应用时注意修正 
 
匹配特定字符串： 
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串 
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串 
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串 
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串 
^/w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串 
"^[//w-]+(//.[//w-]+)*@[//w-]+(//.[//w-]+)+___FCKpd___0quot;　　　　//email地址   
"^[a-zA-z]+://(//w+(-//w+)*)(//.(//w+(-//w+)*))*(//?//S*)?___FCKpd___0quot;　　//url 

匹配中文字符的正则表达式： [/u4e00-/u9fa5]
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了

匹配双字节字符(包括汉字在内)：[^/x00-/xff]
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

匹配空白行的正则表达式：/n/s*/r
评注：可以用来删除空白行

匹配HTML标记的正则表达式： <(/S*?)[^>]*>.*? ¦ <.*? />
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力

匹配首尾空白字符的正则表达式：^/s* ¦/s*$
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式

匹配Email地址的正则表达式：/w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*
评注：表单验证时很实用

匹配网址URL的正则表达式：[a-zA-z]+://[^/s]*
评注：网上流传的版本功能很有限，上面这个基本可以满足需求

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
评注：表单验证时很实用

匹配国内电话号码：/d{3}-/d{8} ¦/d{4}-/d{7}
评注：匹配形式如 0511-4405222 或 021-87888822

匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始

匹配中国邮政编码：[1-9]/d{5}(?!/d)
评注：中国邮政编码为6位数字

匹配身份证：/d{15} ¦/d{18}
评注：中国的身份证为15位或18位

匹配ip地址：/d+/./d+/./d+/./d+
评注：提取ip地址时有用

匹配特定数字：
^[1-9]/d*$　 　 //匹配正整数
^-[1-9]/d*$ 　 //匹配负整数
^-?[1-9]/d*$　　 //匹配整数
^[1-9]/d* ¦0$　 //匹配非负整数（正整数 + 0）
^-[1-9]/d* ¦0$　　 //匹配非正整数（负整数 + 0）
^[1-9]/d*/./d* ¦0/./d*[1-9]/d*$　　 //匹配正浮点数
^-([1-9]/d*/./d* ¦0/./d*[1-9]/d*)$　 //匹配负浮点数
^-?([1-9]/d*/./d* ¦0/./d*[1-9]/d* ¦0?/.0+ ¦0)$　 //匹配浮点数
^[1-9]/d*/./d* ¦0/./d*[1-9]/d* ¦0?/.0+ ¦0$　　 //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]/d*/./d* ¦0/./d*[1-9]/d*)) ¦0?/.0+ ¦0$　　//匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正

匹配特定字符串：
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
^/w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串
"^[//w-]+(//.[//w-]+)*@[//w-]+(//.[//w-]+)+___FCKpd___0quot;　　　　//email地址
"^[a-zA-z]+://(//w+(-//w+)*)(//.(//w+(-//w+)*))*(//?//S*)?___FCKpd___0quot;　　//urlview plaincopy to clipboardprint?
正则几个基本概念： 

正则几个基本概念：view plaincopy to clipboardprint?
1.贪婪：+,*,?,{m,n}等默认是贪婪匹配，即尽可能多匹配，也叫最大匹配 
如果后面加上?，就转化为非贪婪匹配，需要高版本支持 

1.贪婪：+,*,?,{m,n}等默认是贪婪匹配，即尽可能多匹配，也叫最大匹配
如果后面加上?，就转化为非贪婪匹配，需要高版本支持view plaincopy to clipboardprint?
2.获取：默认用(x ¦y)是获取匹配，很多时候只是测试，不一定要求得到所匹配的数据，尤其在嵌套匹配或大数据中就要用非获取匹配(?:x ¦y)，这样提高了效率，优化了程序。 

2.获取：默认用(x ¦y)是获取匹配，很多时候只是测试，不一定要求得到所匹配的数据，尤其在嵌套匹配或大数据中就要用非获取匹配(?:x ¦y)，这样提高了效率，优化了程序。view plaincopy to clipboardprint?
3.消耗：默认是消耗匹配，一般在预查中是非消耗匹配。 
举个例子，2003-2-8要变为2003-02-08 
如果用/-(/d)-/第二次匹配将从8开始，从而只替换第一个2，错误 
如果用/-(/d)(?=-)/则第二次匹配从第二个-开始，即不消耗字符- 

3.消耗：默认是消耗匹配，一般在预查中是非消耗匹配。
举个例子，2003-2-8要变为2003-02-08
如果用/-(/d)-/第二次匹配将从8开始，从而只替换第一个2，错误
如果用/-(/d)(?=-)/则第二次匹配从第二个-开始，即不消耗字符-view plaincopy to clipboardprint?
4.预查：js中分为正向预查和负向预查 
如上面的(?=pattern)是正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。还有(?!pattern)是负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。负向预查有时会用在对[^]的扩充，[^]只是一些字符，而?!可以使整个字符串。 

4.预查：js中分为正向预查和负向预查
如上面的(?=pattern)是正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。还有(?!pattern)是负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。负向预查有时会用在对[^]的扩充，[^]只是一些字符，而?!可以使整个字符串。view plaincopy to clipboardprint?
5.回调：一般用在替换上，即根据不用的匹配内容返回不用的替换值，从而简化了程序，需要高版本支持 

5.回调：一般用在替换上，即根据不用的匹配内容返回不用的替换值，从而简化了程序，需要高版本支持view plaincopy to clipboardprint?
6.引用：/num 对所获取的第num个匹配的引用。 
例如，'(.)/1/1' 匹配AAA型。'(.)(.)/2/1' 匹配ABBA型。 

6.引用：/num 对所获取的第num个匹配的引用。
例如，'(.)/1/1' 匹配AAA型。'(.)(.)/2/1' 匹配ABBA型。view plaincopy to clipboardprint?
正则表达式保留字 
^ (carat)   
. (period)   
[ (left bracket}   
$ (dollar sign)   
( (left parenthesis)   
) (right parenthesis)   
¦ (pipe)   
* (asterisk)   
+ (plus symbol)   
? (question mark)   
{ (left curly bracket, or left brace)   
/ backslash 

正则表达式保留字
^ (carat)
. (period)
[ (left bracket}
$ (dollar sign)
( (left parenthesis)
) (right parenthesis)
¦ (pipe)
* (asterisk)
+ (plus symbol)
? (question mark)
{ (left curly bracket, or left brace)
/ backslash view plaincopy to clipboardprint?
构造 匹配于 

构造 匹配于 view plaincopy to clipboardprint?
字符   
x 字符 x   
// 反斜线字符   
/0n 八进制值的字符0n (0 <= n <= 7)   
/0nn 八进制值的字符 0nn (0 <= n <= 7)   
/0mnn 八进制值的字符0mnn 0mnn (0 <= m <= 3, 0 <= n <= 7)   
/xhh 十六进制值的字符0xhh   
/uhhhh 十六进制值的字符0xhhhh   
/t 制表符('/u0009')   
/n 换行符 ('/u000A')   
/r 回车符 ('/u000D')   
/f 换页符 ('/u000C')   
/a 响铃符 ('/u0007')   
/e 转义符 ('/u001B')   
/cx T对应于x的控制字符 x 

字符
x 字符 x
// 反斜线字符
/0n 八进制值的字符0n (0 <= n <= 7)
/0nn 八进制值的字符 0nn (0 <= n <= 7)
/0mnn 八进制值的字符0mnn 0mnn (0 <= m <= 3, 0 <= n <= 7)
/xhh 十六进制值的字符0xhh
/uhhhh 十六进制值的字符0xhhhh
/t 制表符('/u0009')
/n 换行符 ('/u000A')
/r 回车符 ('/u000D')
/f 换页符 ('/u000C')
/a 响铃符 ('/u0007')
/e 转义符 ('/u001B')
/cx T对应于x的控制字符 x view plaincopy to clipboardprint?
字符类   
[abc] a, b, or c (简单类)   
[^abc] 除了a、b或c之外的任意 字符（求反）   
[a-zA-Z] a到z或A到Z ，包含（范围)   
[a-z-[bc]] a到z，除了b和c ： [ad-z]（减去）   
[a-z-[m-p]] a到z，除了m到 p： [a-lq-z]   
[a-z-[^def]] d, e, 或 f 

字符类
[abc] a, b, or c (简单类)
[^abc] 除了a、b或c之外的任意 字符（求反）
[a-zA-Z] a到z或A到Z ，包含（范围)
[a-z-[bc]] a到z，除了b和c ： [ad-z]（减去）
[a-z-[m-p]] a到z，除了m到 p： [a-lq-z]
[a-z-[^def]] d, e, 或 f view plaincopy to clipboardprint?
预定义的字符类   
. 任意字符（也许能与行终止符匹配，也许不能）   
/d 数字: [0-9]   
/D 非数字: [^0-9]   
/s 空格符: [ /t/n/x0B/f/r]   
/S 非空格符: [^/s]   
/w 单词字符: [a-zA-Z_0-9]   
/W 非单词字符: [^/w]