JavaScript 正则表达式（转自 mozilla）

时间 2019-11-22

标签 javascript 正则表达式 mozilla 栏目 JavaScript 繁體版

原文原文链接

正则表达式是被用来匹配字符串中的字符组合的模式。在JavaScript中，正则表达式也是对象。javascript

这种模式能够被用于 RegExp 的 exec 和 test 方法以及 String 的 match、replace、search 和 split 方法。本章介绍的是 Javascript 的正则表达式。html

建立一个正则表达式

你能够经过下面两种方法建立一个正则表达式：html5

使用一个正则表达式字面量，以下所示：java

var re = /ab+c/;

正则表达式字面量在脚本加载后编译。若你的正则表达式是常量，使用这种方式能够得到更好的性能。git

调用RegExp对象的构造函数，以下所示：正则表达式

var re = new RegExp("ab+c");

使用构造函数，提供了对正则表达式运行时的编译。当你知道正则表达式的模式会发生改变，或者你事先并不了解它的模式或者是从其余地方（好比用户的输入），获得的代码这时比较适合用构造函数的方式。express

编写一个正则表达式的模式

一个正则表达式模式是由简单的字符所构成的，好比/abc/, 或者是简单和特殊字符的组合，好比/ab*c/ 或 /Chapter (\d+)\.\d*/。后者用到了括号，它在正则表达式中能够被用做是一个记忆设备。这一部分正则所匹配的字符将会被记住，在后面能够被利用。正以下面章节所示：使用括号的子字符串匹配。数组

使用简单的模式

简单的模式是有你找到的直接匹配所构成的。好比，/abc/这个模式就匹配了在一个字符串中，仅仅字符 'abc' 同时出现并按照这个顺序。在 "Hi, do you know your abc's?" 和 "The latest airplane designs evolved from slabcraft." 就会匹配成功。在上面的两个实例中，匹配的是子字符串 'abc'。在字符串 "Grab crab" 中将不会被匹配，由于它不包含任何的 'abc' 子字符串。app

使用特殊字符

当你须要搜索一个比直接匹配须要更多条件的匹配时，好比寻找一个或多个 'b'，或者寻找空格，那么这时模式将要包含特殊字符。好比，模式/ab*c/匹配了一个单独的 'a' 后面跟了零个或者多个 'b'（*的意思是前面一项出现了零个或者多个），且后面跟着 'c' 的任何字符组合。在字符串 "cbbabbbbcdebc" 中，这个模式匹配了子字符串 "abbbbc"。下面的表格列出了一个咱们在正则表达式中能够利用的特殊字符的完整列表和描述。ide

字符	含义
`\`	匹配将依照下列规则：在非特殊字符以前的反斜杠表示下一个字符是特殊的，不能从字面上解释。例如，没有前面'\'的'b'一般匹配小写'b'，不管它们出如今哪里。若是加了'\',这个字符变成了一个特殊意义的字符，意思是匹配一个字符边界。反斜杠也能够将其后的特殊字符，转义为字面量。例如，模式 /a/ 表明会匹配 0 个或者多个 a。相反，模式 /a\/ 将 '' 的特殊性移除，从而能够匹配像 "a" 这样的字符串。使用 new RegExp("pattern") 的时候不要忘记将 \ 进行转义，由于 \ 在字符串里面也是一个转义字符。
`^`	匹配输入的开始。若是多行标志被设置为true，那么也匹配换行符后紧跟的位置。例如，/^A/ 并不会匹配 "an A" 中的 'A'，可是会匹配 "An E" 中的 'A'。当 '^' 做为第一个字符出如今一个字符集合模式时，它将会有不一样的含义。补充字符集合一节有详细介绍和示例。
`$`	匹配输入的结束。若是多行标示被设置为true，那么也匹配换行符前的位置。例如，/t$/ 并不会匹配 "eater" 中的 't'，可是会匹配 "eat" 中的 't'。
`*`	匹配前一个表达式0次或屡次。等价于 {0,}。例如，/bo*/会匹配 "A ghost boooooed" 中的 'booooo' 和 "A bird warbled" 中的 'b'，可是在 "A goat grunted" 中将不会匹配任何东西。
`+`	匹配前面一个表达式1次或者屡次。等价于 {1,}。例如，/a+/匹配了在 "candy" 中的 'a'，和在 "caaaaaaandy" 中全部的 'a'。
`?`	匹配前面一个表达式0次或者1次。等价于 {0,1}。例如，/e?le?/ 匹配 "angel" 中的 'el'，和 "angle" 中的 'le' 以及"oslo' 中的'l'。若是紧跟在任何量词 *、 +、? 或 {} 的后面，将会使量词变为非贪婪的（匹配尽可能少的字符），和缺省使用的贪婪模式（匹配尽量多的字符）正好相反。例如，对 "123abc" 应用 /\d+/ 将会返回 "123"，若是使用 /\d+?/,那么就只会匹配到 "1"。还能够运用于向前断言，在本表格的 x(?=y) 和 x(?!y) 中有描述。
`.`	（小数点）匹配除了换行符（`\n`）以外的任何单个字符。例如，/.n/将会匹配 "nay, an apple is on the tree" 中的 'an' 和 'on'，可是不会匹配 'nay'。
`(x)`	匹配 'x' 而且记住匹配项，就像下面的例子展现的那样。括号被称为捕获括号。模式 /(foo) (bar) \1 \2/ 中的 '(foo)' 和 '(bar)' 匹配并记住字符串 "foo bar foo bar" 中前两个单词。模式中的 \1 和 \2 匹配字符串的后两个单词。注意 \一、\二、\n 是用在正则表达式的匹配环节。在正则表达式的替换环节，则要使用像 $一、$二、$n 这样的语法，例如，'bar foo'.replace( /(...) (...)/, '$2 $1' )。
`(?:x)`	匹配 'x' 可是不记住匹配项。这种叫做非捕获括号，使得你可以定义为与正则表达式运算符一块儿使用的子表达式。来看示例表达式 /(?:foo){1,2}/。若是表达式是 /foo{1,2}/，{1,2}将只对 ‘foo’ 的最后一个字符 ’o‘ 生效。若是使用非捕获括号，则{1,2}会匹配整个 ‘foo’ 单词。
`x(?=y)`	匹配'x'仅仅当'x'后面跟着'y'.这种叫作正向确定查找。例如，/Jack(?=Sprat)/会匹配到'Jack'仅仅当它后面跟着'Sprat'。/Jack(?=Sprat\|Frost)/匹配‘Jack’仅仅当它后面跟着'Sprat'或者是‘Frost’。可是‘Sprat’和‘Frost’都不是匹配结果的一部分。
`x(?!y)`	匹配'x'仅仅当'x'后面不跟着'y',这个叫作正向否认查找。例如，/\d+(?!\.)/匹配一个数字仅仅当这个数字后面没有跟小数点的时候。正则表达式/\d+(?!\.)/.exec("3.141")匹配‘141’可是不是‘3.141’
`x\|y`	匹配‘x’或者‘y’。例如，/green\|red/匹配“green apple”中的‘green’和“red apple”中的‘red’
`{n}`	n是一个正整数，匹配了前面一个字符恰好发生了n次。好比，/a{2}/不会匹配“candy”中的'a',可是会匹配“caandy”中全部的a，以及“caaandy”中的前两个'a'。
`{n,m}`	n 和 m 都是正整数。匹配前面的字符至少n次，最多m次。若是 n 或者 m 的值是0，这个值被忽略。例如，/a{1, 3}/ 并不匹配“cndy”中得任意字符，匹配“candy”中得a，匹配“caandy”中得前两个a，也匹配“caaaaaaandy”中得前三个a。注意，当匹配”caaaaaaandy“时，匹配的值是“aaa”，即便原始的字符串中有更多的a。
`[xyz]`	一个字符集合。匹配方括号的中任意字符。你可使用破折号（-）来指定一个字符范围。对于点（.）和星号（*）这样的特殊符号在一个字符集中没有特殊的意义。他们没必要进行转义，不过转义也是起做用的。例如，[abcd] 和[a-d]是同样的。他们都匹配"brisket"中得‘b’,也都匹配“city”中的‘c’。/[a-z.]+/ 和/[\w.]+/都匹配“test.i.ng”中得全部字符。
`[^xyz]`	一个反向字符集。也就是说，它匹配任何没有包含在方括号中的字符。你可使用破折号（-）来指定一个字符范围。任何普通字符在这里都是起做用的。例如，[^abc] 和 [^a-c] 是同样的。他们匹配"brisket"中得‘r’，也匹配“chop”中的‘h’。
`[\b]`	匹配一个退格(U+0008)。（不要和\b混淆了。）
`\b`	匹配一个词的边界。一个词的边界就是一个词不被另一个词跟随的位置或者不是另外一个词汇字符前边的位置。注意，一个匹配的词的边界并不包含在匹配的内容中。换句话说，一个匹配的词的边界的内容的长度是0。（不要和[\b]混淆了）例子： /\bm/匹配“moon”中得‘m’； /oo\b/并不匹配"moon"中得'oo'，由于'oo'被一个词汇字符'n'紧跟着。 /oon\b/匹配"moon"中得'oon'，由于'oon'是这个字符串的结束部分。这样他没有被一个词汇字符紧跟着。 /\w\b\w/将不能匹配任何字符串，由于一个单词中的字符永远也不可能被一个非词汇字符和一个词汇字符同时紧跟着。
`\B`	匹配一个非单词边界。他匹配一个先后字符都是相同类型的位置：都是单词或者都不是单词。一个字符串的开始和结尾都被认为是非单词。例如，/\B../匹配"noonday"中得'oo', 而/y\B./匹配"possibly yesterday"中得’ye‘
`\cX`	当X是处于A到Z之间的字符的时候，匹配字符串中的一个控制符。例如，`/\cM/` 匹配字符串中的 control-M (U+000D)。
`\d`	匹配一个数字`。` `等价于[0-9]`。例如， `/\d/` 或者 `/[0-9]/` 匹配"B2 is the suite number."中的'2'。
`\D`	匹配一个非数字字符`。` `等价于[^0-9]`。例如， `/\D/` 或者 `/[^0-9]/` 匹配"B2 is the suite number."中的'B' 。
`\f`	匹配一个换页符 (U+000C)。
`\n`	匹配一个换行符 (U+000A)。
`\r`	匹配一个回车符 (U+000D)。
`\s`	匹配一个空白字符，包括空格、制表符、换页符和换行符。等价于[\f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]。例如, `/\s\w*/` 匹配"foo bar."中的' bar'。
`\S`	匹配一个非空白字符。等价于`[^` \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff`]`。例如， `/\S\w*/` 匹配"foo bar."中的'foo'。
`\t`	匹配一个水平制表符 (U+0009)。
`\v`	匹配一个垂直制表符 (U+000B)。
`\w`	匹配一个单字字符（字母、数字或者下划线）。等价于`[A-Za-z0-9_]`。例如, `/\w/` 匹配 "apple," 中的 'a'，"$5.28,"中的 '5' 和 "3D." 中的 '3'。
`\W`	匹配一个非单字字符。等价于`[^A-Za-z0-9_]`。例如, `/\W/` 或者 `/[^A-Za-z0-9_]/` 匹配 "50%." 中的 '%'。
`\n`	当 n 是一个正整数，一个返回引用到最后一个与有n插入的正值表达式(counting left parentheses)匹配的副字符串。好比 `/apple(,)\sorange\1/` 匹配"apple, orange, cherry, peach."中的'apple, orange,' 。
`\0`	匹配 NULL (U+0000) 字符，不要在这后面跟其它小数，由于 `\0<digits>` 是一个八进制转义序列。
`\xhh`	匹配带有两位小数代码（hh）的字符
`\uhhhh`	匹配带有四位小数代码（hh）的字符

有些转义用户输入被处理成含有一个正值表达式的字面字符串，这些输入能够被简单的替代值补充完整。

function escapeRegExp(string){
  return string.replace(/([.*+?^=!:${}()|[\]\/\\])/g, "\\$&"); //$&表示被匹配的字符串
}

使用插入语

任何正则表达式的插入语都会使这部分匹配的副字符串被记忆。一旦被记忆，这个副字符串就能够被调用于其它用途，如同使用括号的子字符串匹配之中所述。

好比， /Chapter (\d+)\.\d*/ 解释了额外转义的和特殊的字符，并说明了这部分pattern应该被记忆。它精确地匹配后面跟着一个以上数字字符的字符 'Chapter ' (\d 意为任何数字字符，+ 意为1次以上)，跟着一个小数点（在这个字符中自己也是一个特殊字符；小数点前的 \ 意味着这个pattern必须寻找字面字符 '.')，跟着任何数字字符0次以上。 (\d 意为数字字符， * 意为0次以上)。另外，插入语也用来记忆第一个匹配的数字字符。

此模式能够匹配字符串"Open Chapter 4.3, paragraph 6"，而且'4'将会被记住。此模式并不能匹配"Chapter 3 and 4"，由于在这个字符串中'3'的后面没有点号'.'。

括号中的"?:"，这种模式匹配的子字符串将不会被记住。好比，(?:\d+)匹配一次或屡次数字字符，可是不能记住匹配的字符。

使用正则表达式

正则表达式能够被用于RegExp的exec和test方法以及 String的match、replace、search和split方法。这些方法在JavaScript 手册中有详细的解释。

表 4.2 使用正则表达式的方法
方法	描述
`exec`	一个在字符串中执行查找匹配的RegExp方法，它返回一个数组（未匹配到则返回null）。
`test`	一个在字符串中测试是否匹配的RegExp方法，它返回true或false。
`match`	一个在字符串中执行查找匹配的String方法，它返回一个数组或者在未匹配到时返回null。
`search`	一个在字符串中测试匹配的String方法，它返回匹配到的位置索引，或者在失败时返回-1。
`replace`	一个在字符串中执行查找匹配的String方法，而且使用替换字符串替换掉匹配到的子字符串。
`split`	一个使用正则表达式或者一个固定字符串分隔一个字符串，并将分隔后的子字符串存储到数组中的String方法。

当你想要知道在一个字符串中的一个匹配是否被找到，你可使用test或search方法；想获得更多的信息（可是比较慢）则可使用exec或match方法。若是你使用exec或match方法而且匹配成功了，那么这些方法将返回一个数组而且更新相关的正则表达式对象的属性和预约义的正则表达式对象（详见下）。若是匹配失败，那么exec方法返回null（也就是false）。

在接下来的例子中，脚本将使用exec方法在一个字符串中查找一个匹配。

var myRe = /d(b+)d/g;
var myArray = myRe.exec("cdbbdbsbz");

若是你不须要访问正则表达式的属性，这个脚本经过另外一个方法来建立myArray：

var myArray = /d(b+)d/g.exec("cdbbdbsbz");

若是你想经过一个字符串构建正则表达式，那么这个脚本还有另外一种方法：

var myRe = new RegExp("d(b+)d", "g");
var myArray = myRe.exec("cdbbdbsbz");

经过这些脚本，匹配成功后将返回一个数组而且更新正则表达式的属性，以下表所示。

表 4.3 正则表达式执行返回信息
对象	属性或索引	描述	在例子中对应的值
`myArray`		匹配到的字符串和全部被记住的子字符串。	`["dbbd", "bb"]`
	`index`	在输入的字符串中匹配到的以0开始的索引值。	`1`
	`input`	初始字符串。	`"cdbbdbsbz"`
	`[0]`	匹配到的全部字符串（并非匹配后记住的字符串）。注：原文"The last matched characters."，应该是原版错误。匹配到的最后一个字符索引。	`"dbbd"`
`myRe`	`lastIndex`	下一个匹配的索引值。（这个属性只有在使用g参数时可用在经过参数进行高级搜索一节有详细的描述.)	`5`
`myRe`	`source`	模式文本。在正则表达式建立时更新，不执行。	`"d(b+)d"`

在这个例子中如第二种形式所示，你可使用一个正则表达式建立一个没有分配给变量的对象初始化容器。若是你这样作，那么，每一次使用时都比如在使用一个新的正则表达式。由于这个缘由，若是你使用这个未分配给一个变量的正则表达式，你将在随后不能访问这个正则表达式的属性。例如，假如你有以下脚本：

var myRe = /d(b+)d/g;
var myArray = myRe.exec("cdbbdbsbz");
console.log("The value of lastIndex is " + myRe.lastIndex);

这个脚本输出以下：

The value of lastIndex is 5

然而，若是你有以下脚本：

var myArray = /d(b+)d/g.exec("cdbbdbsbz");
console.log("The value of lastIndex is " + /d(b+)d/g.lastIndex);

它显示为：

The value of lastIndex is 0

当发生/d(b+)d/g使用两个不一样状态的正则表达式对象，lastIndex属性会获得不一样的值。若是你须要访问一个正则表达式的属性，则须要建立一个对象初始化生成器，你应该首先把它赋值给一个变量。

使用括号的子字符串匹配

一个正则表达式模式使用括号，将致使相应的子匹配被记住。例如，/a(b)c /能够匹配字符串“abc”，而且记得“b”。回调这些括号中匹配的子串，使用数组元素[1],……[n]。

使用括号匹配的子字符串的数量是无限的。返回的数组中保存全部被发现的子匹配。下面的例子说明了如何使用括号的子字符串匹配。

下面的脚本使用replace()方法来转换字符串中的单词。在匹配到的替换文本中，脚本使用替代的$ 1,$ 2表示第一个和第二个括号的子字符串匹配。

var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);

这个表达式输出 "Smith, John"。

经过标志进行高级搜索

正则表达式有四个可选参数进行全局和不分大小写搜索。这些参数既能够单独使用也能够一块儿使用在任何顺序和包含正则表达式的部分中。

正则表达式标志
标志	描述
g	全局搜索。
i	不区分大小写搜索。
m	多行搜索。
y	执行“粘性”搜索,匹配从目标字符串的当前位置开始，可使用y标志。

包含一个标志的正则表达式，使用这个表达式：

var re = /pattern/flags;

或者

var re = new RegExp("pattern", "flags");

值得注意的是，标志是一个正则表达式的一部分，它们在接下来的时间将不能添加或删除。

例如，re = /\w+\s/g 将建立一个查找一个或多个字符后有一个空格的正则表达式，或者组合起来像此要求的字符串。

var re = /\w+\s/g;
var str = "fee fi fo fum";
var myArray = str.match(re);
console.log(myArray);

这段代码将输出 ["fee ", "fi ", "fo "]。在这个例子中，你能够将：

var re = /\w+\s/g;

替换成：

var re = new RegExp("\\w+\\s", "g");

而且能获取到相同的结果。

m标志用于指定多行输入字符串应该被视为多个行。若是使用m标志，^和$匹配的开始或结束输入字符串中的每一行，而不是整个字符串的开始或结束。

例子

如下例子说明了一些正值表达式的用途。

改变输入字符串的顺序

如下例子解释了正值表达式的构成和 string.split() 以及 string.replace()的用途。它会整理一个只有粗略格式的含有全名（名字首先出现）的输入字符串，这个字符串被空格、换行符和一个分号分隔。最终，它会颠倒名字顺序（姓氏首先出现）和list的类型。

// 名字字符串包含多个空格和制表符，
// 而且名字和姓氏之间可能有多个空格。
var names = "Harry Trump ;Fred Barney ;  Helen Rigby; Bill　　Abel; Chris Hand ";

var output = ["---------- Original String\n", names + "\n"];

// 定义两个正则表达式模式和数组来存储
// 将字符串拆分红数组元素

// 模式1：包含0个或多个空格，而后是一个分号，后面再跟着0个或多个空格
var pattern = /\s*;\s*/;

// 把上面的正则表达式做为分隔符，对上面的字符串进行拆分，
// 并把分割的子字符串存储到 nameList 数组中            
var nameList = names.split(pattern);

// 新的正则表达式：一个或多个单字字符，等价于[A-Za-z0-9_]，而后是一个或多个空格，后面再跟着一个或多个单字字符
// 利用括号来保存模式匹配项
// 被保存的匹配项会在后面被引用
pattern = /(\w+)\s+(\w+)/;

// 定义新数组，用来保存正在处理的名字。
var bySurnameList = [];

//显示名字数组并将其填充到新的数组中
//用逗号做为名字和姓氏的分隔符，格式：姓氏，名字。
//
//用replace方法替换与正则表达式模式匹配的全部内容
//其替换为存储的第二记忆部分
//后跟逗号空格，而后跟着第一个记忆部分。
//
//即：变量$1和$2指代的部分
//在进行匹配模式时保存过的。

output.push("---------- After Split by Regular Expression");

var i, len;
for (i = 0, len = nameList.length; i < len; i++){
  output.push(nameList[i]);
  bySurnameList[i] = nameList[i].replace(pattern, "$2, $1");
}

// 显示新数组。
output.push("---------- Names Reversed");
for (i = 0, len = bySurnameList.length; i < len; i++){
  output.push(bySurnameList[i]);
}

// 按姓氏排序，而后显示排序的数组。
bySurnameList.sort();
output.push("---------- Sorted");
for (i = 0, len = bySurnameList.length; i < len; i++){
  output.push(bySurnameList[i]);
}

output.push("---------- End");

console.log(output.join("\n"));

运行结果：

用特殊字符检验输入

在如下例子中，咱们指望用户输入一个电话号码。当用户点击“Check”按钮，咱们的脚本开始检查这些数字是否合法。若是数字合法（匹配正值表达式所规定的字符序列），脚本显示一条感谢用户的信息并确认该数字。若是这串数字不合法，脚本提示用户电话号码不合法。.

包含非捕获括号 (?: 这个正值表达式寻找三个数字字符\d{3} 或者 | 一个左半括号$跟着三位数字\d{3}, 跟着一个封闭括号 $, (结束非捕获括号 ))，后跟着一个短破折号或左斜杠或小数点，随后跟随三个数字字符，当记忆字符 ([-\/\.])捕获并记住，后面跟着三位小数 \d{3}，再后面跟随记住的左斜杠、右斜杠或小数点 \1，最后跟着四位小数 \d{4}。

当用户按下Enter设置RegExp.input，这些变化也能被激活。

<!DOCTYPE html>
<html>  
  <head>  
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">  
    <meta http-equiv="Content-Script-Type" content="text/javascript">  
    <script type="text/javascript">  
      var re = /(?:\d{3}|\(\d{3}\))([-\/\.])\d{3}\1\d{4}/;  
      function testInfo(phoneInput){  
        var OK = re.exec(phoneInput.value);  
        if (!OK)  
          window.alert(RegExp.input + " isn't a phone number with area code!");  
        else
          window.alert("Thanks, your phone number is " + OK[0]);  
      }  
    </script>  
  </head>  
  <body>  
    <p>Enter your phone number (with area code) and then click "Check".
        <br>The expected format is like ###-###-####.</p>
    <form action="#">  
      <input id="phone"><button onclick="testInfo(document.getElementById('phone'));">Check</button>
    </form>  
  </body>  
</html>

标签：

此页面的贡献者： Jeff-Kook, ljy, maoxiaoke, falltodis, codetaro, simongfxu, fanyj1994, huaxiabuluo, lvhao96,luobotang, yisibl, ngtmuzi,

chen_wang, Ende93, sunshineMaria, snowsolf, sleep, Shimo, Frantic1048, Guanjinke, teoli,sablib, thesadboy, devqin, jpuncle, xiaoxiong, ziyunfei

最后编辑者: Jeff-Kook, Jan 20, 2017, 6:51:38 AM

补充贪婪模式、捕获括号例子：

//全局匹配
var str = "abc123 abcdef 123456"; //字符串
var re = /[abc123]+/; //局部匹配
var arr = str.match(re); //结果：["abc123"]
re = /[abc123]+/g; //全局匹配
arr = str.match(re); //结果：["abc123", "abc", "123"]

//贪婪模式
re = /[abc123]+?/; //非贪婪局部匹配
arr = str.match(re); //结果：["a"]
re = /[abc123]+?/g; //非贪婪全局匹配
arr = str.match(re); //匹配结果：["a", "b", "c", "1", "2", "3", "a", "b", "c", "1", "2", "3"]

//匹配括号
var str = "2008-1_3";
var re = /\d+(\D)\d+(\D)\d+/;
re.test(str); //结果：true
re = /\d+(\D)\d+\1\d+/; // \1 表示对前面的 (\D) 的内容的引用
re.test(str); //结果：false，缘由：\1 表示的内容和前面 (\D) 中的同样，都是 '-'

补充 C# 中的正则表达式：

       /// <summary>
       /// 显示Match内多个Group的例子
        /// </summary>
        public static void ShowStructure()
        {
            //要匹配的字符串
            string text = "1A 2B 3C 4D 5E 6F 7G 8H 9I 10J 11Q 12J 13K 14L 15M 16N ffee80 #800080";

            //正则表达式
            string pattern = @"((\d+)([a-z]))\s+";

            //使用RegexOptions.IgnoreCase枚举值表示不区分大小写
            Regex r = new Regex(pattern, RegexOptions.IgnoreCase);

            //使用正则表达式匹配字符串，仅返回一次匹配结果（有时只需判断是否匹配到，这时能够用 r.IsMatch(text) 来进行判断）
            Match m = r.Match(text);

            while (m.Success)
            {
                //显示匹配开始处的索引值和匹配到的值
                System.Console.WriteLine("Match=[" + m + "]");
                CaptureCollection cc = m.Captures;
                foreach (Capture c in cc)
                {
                    Console.WriteLine("\tCapture=[" + c + "]");
                }
                for (int i = 0; i < m.Groups.Count; i++)
                {
                    Group group = m.Groups[i];
                    System.Console.WriteLine("\t\tGroups[{0}]=[{1}]", i, group);
                    for (int j = 0; j < group.Captures.Count; j++)
                    {
                        Capture capture = group.Captures[j];
                        Console.WriteLine("\t\t\tCaptures[{0}]=[{1}]", j, capture);
                    }
                }
                //进行下一次匹配.
                m = m.NextMatch();
            }
        }

        /*
         * 类说明
         * 
        Regex 类表示不可变（只读）的正则表达式。
         * 它还包含各类静态方法，容许在不显式建立其余类的实例的状况下使用其余正则表达式类。

        Match 类表示正则表达式匹配操做的结果。
         * Match 类的 Match.Success 匹配是否成功。Match.Index 返回第一个匹配的位置。

        MatchCollection 类表示成功的【非重叠】匹配项的序列。
         * MatchCollection 的实例是由 Regex.Matches 方法返回的。

        GroupCollection 类表示被捕获的组的集合，并在单个匹配项中返回该捕获组的集合。
         * GroupCollection 的实例在 Match.Groups 属性返回的集合中返回。

        CaptureCollection 类表示捕获的子字符串的序列，并返回由单个捕获组所执行的捕获集。
         * 因为限定符，捕获组能够在单个匹配中捕获多个字符串。
         * Captures 属性（CaptureCollection 类的对象）做为 Match 和 Group 类的成员提供，
         * 目的是便于对捕获的子字符串的集合进行访问。

        Group 类表示来自单个捕获组的结果。
         * 由于 Group 能够在单个匹配中捕获零个、一个或更多的字符串（使用限定符），因此它包含 Capture 对象的集合。
         * 由于 Group 继承自 Capture，因此能够直接访问最后捕获的子字符串
         * （Group 实例自己等价于 Captures 属性返回的集合的最后一项）。

        Capture 类包含来自单个子表达式捕获的结果。
        */

原文地址：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Regular_Expressions

参考资源：http://www.cnblogs.com/aaronjs/archive/2012/06/30/2570970.html

http://www.cnblogs.com/nanphon/p/3602913.html?utm_source=tuicool&utm_medium=referral

Web 技术文档：https://developer.mozilla.org/zh-CN/docs/Web

https://www.w3.org/TR/html52/ Html5.2 草案

Java 经常使用正则表达式

/******************** 正则相关常量 ********************/
    /**
     * 正则：手机号（简单）
     */
    public static final String REGEX_MOBILE_SIMPLE = "^[1]\\d{10}$";
    /**
     * 正则：手机号（精确）
     * <p>移动：134(0-8)、13五、13六、13七、13八、13九、14七、150、15一、15二、15七、15八、15九、17八、18二、18三、18四、18七、188</p>
     * <p>联通：130、13一、13二、14五、15五、15六、17五、17六、18五、186</p>
     * <p>电信：13三、15三、17三、17七、180、18一、189</p>
     * <p>全球星：1349</p>
     * <p>虚拟运营商：170</p>
     */
    public static final String REGEX_MOBILE_EXACT  = "^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|(147))\\d{8}$";
    /**
     * 正则：电话号码
     */
    public static final String REGEX_TEL           = "^0\\d{2,3}[- ]?\\d{7,8}";
    /**
     * 正则：身份证号码15位
     */
    public static final String REGEX_ID_CARD15     = "^[1-9]\\d{7}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}$";
    /**
     * 正则：身份证号码18位
     */
    public static final String REGEX_ID_CARD18     = "^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}([0-9Xx])$";
    /**
     * 正则：邮箱
     */
    public static final String REGEX_EMAIL         = "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";
    /**
     * 正则：URL
     */
    public static final String REGEX_URL           = "[a-zA-z]+://[^\\s]*";
    /**
     * 正则：汉字
     */
    public static final String REGEX_ZH            = "^[\\u4e00-\\u9fa5]+$";
    /**
     * 正则：用户名，取值范围为a-z,A-Z,0-9,"_",汉字，不能以"_"结尾,用户名必须是6-20位
     */
    public static final String REGEX_USERNAME      = "^[\\w\\u4e00-\\u9fa5]{6,20}(?<!_)$";
    /**
     * 正则：yyyy-MM-dd格式的日期校验，已考虑平闰年
     */
    public static final String REGEX_DATE          = "^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$";
    /**
     * 正则：IP地址
     */
    public static final String REGEX_IP            = "((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)";

    /************** 如下摘自http://tool.oschina.net/regex **************/
    /**
     * 正则：双字节字符(包括汉字在内)
     */
    public static final String REGEX_DOUBLE_BYTE_CHAR     = "[^\\x00-\\xff]";
    /**
     * 正则：空白行
     */
    public static final String REGEX_BLANK_LINE           = "\\n\\s*\\r";
    /**
     * 正则：QQ号
     */
    public static final String REGEX_TENCENT_NUM          = "[1-9][0-9]{4,}";
    /**
     * 正则：中国邮政编码
     */
    public static final String REGEX_ZIP_CODE             = "[1-9]\\d{5}(?!\\d)";
    /**
     * 正则：正整数
     */
    public static final String REGEX_POSITIVE_INTEGER     = "^[1-9]\\d*$";
    /**
     * 正则：负整数
     */
    public static final String REGEX_NEGATIVE_INTEGER     = "^-[1-9]\\d*$";
    /**
     * 正则：整数
     */
    public static final String REGEX_INTEGER              = "^-?[1-9]\\d*$";
    /**
     * 正则：非负整数(正整数 + 0)
     */
    public static final String REGEX_NOT_NEGATIVE_INTEGER = "^[1-9]\\d*|0$";
    /**
     * 正则：非正整数（负整数 + 0）
     */
    public static final String REGEX_NOT_POSITIVE_INTEGER = "^-[1-9]\\d*|0$";
    /**
     * 正则：正浮点数
     */
    public static final String REGEX_POSITIVE_FLOAT       = "^[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*$";
    /**
     * 正则：负浮点数
     */
    public static final String REGEX_NEGATIVE_FLOAT       = "^-[1-9]\\d*\\.\\d*|-0\\.\\d*[1-9]\\d*$";