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*$";