目錄

1. 正則表達式

1.1 創建

1.2 RegExp 對象屬性

1.3 RegExp 對象方法

1.4 RegExp 分組

2. 元字符和正則表達式規則

1正則表達式

正則表達式本身就是一種語言，由普通字符和特殊的元字符（metacharacters）組成。它描述了字符串的匹配模式，用于轉換和處理字符串。

其中，元字符（metacharacters）也是由普通字符組成，具有特殊意義。比如 {3} 代表了將前面的字符或分組重復匹配三次，$ 代表了匹配一行的結束位置。（更多的元字符請看下面的 表格。）

正則表達式常被用來執行復雜的 “搜索-替換” 、驗證字符串格式是否正確。

當今的大多數程序設計語言都包含正則表達式。甚至包括腳本語言、編輯器、應用程序、數據庫和一些命令行的工具也包含正則表達式工具。下面介紹 Javascript 中實現正則表達式的 Regex 對象。

1.1 創建

Regex 是 Javascript 的內置對象，描述一個字符串的匹配模式，為字符串操作提供了強大的匹配和替換方法。

和數組、對象差不多，Regex 對象的創建也有常量、構造函數、普通函數三種創建方式：

直接量語法

/pattern/attributes

構造函數

new RegExp( pattern , attributes ) ;

普通函數

RegExp( pattern , attributes ) ;

其中的 pattern 是正則表達式的匹配模式，由字符和元字符（表格）構成，attributes 是正則表達式的標記，可以是 "i"、"g"、"m" 三個字母或三個字符的任意組合：

• "i"：大小寫不敏感
• "g"：全局匹配（查找所有匹配而非在找到第一個匹配后停止）
• "m"：多行匹配

在使用函數創建正則表達式的時候，如果 pattern 不是一個字符串，而是一個正則表達式，則忽略第二個參數：

var a = /ch/ig ; var b = new RegExp( /ch/ig) ; var c = RegExp( "ch" , "ig" ) ;

1.2 對象屬性

• regexOjbect.source 屬性是一個只讀的字符串，包含了描述這個正則表達式的文本；
• regexOjbect.global 屬性是一個只讀的布爾值，表明這個正則表達式是否為具有標識 "g" ；
• regexOjbect.ignoreCase 屬性是一個只讀的布爾值，表明這個正則表達式是否為具有標識 "i" ；
• regexOjbect.multiline 屬性是一個只讀的布爾值，表明這個正則表達式是否為具有標識 "m" ；
• regexOjbect.lastIndex 屬性是一個數值，如果正則表達式有 “g” 標識，這個屬性表明下一次檢索的起始位置。

var reg = /ch/g ; var testString = "String type contains one char or a set of chars." alert( reg.source ) ; // "ch" alert( reg.global ) ; // true alert( reg.ignoreCase) ; // false alert( reg.multiline) ; // false alert( reg.lastIndex) ; // 0 reg.test( testString ) ; // true alert( reg.lastIndex) ; // 27 reg.test( testString ) ; // true alert( reg.lastIndex) ; // 44 reg.test( testString ) ; // false alert( reg.lastIndex) ; // 0

可以看到，當正則表達式匹配結束或失敗時，regexOjbect.lastIndex 被重置。

1.3 對象方法

test

Regex.test 方法測試正則表達式指定的模式是否出現在字符串中，返回 true 或 false 。

var a = /ch/ig ; a.test( "chinses " ) ; // true a.test( "abc") ; // false

compile

Regex.compile 方法可以在腳本執行過程中編譯正則表達式，也可以改變和重新編譯正則表達式。形式如下：

RegExpObject.compile( regexp , attributes ) ;

regexp 是一個正則表達式，用于替換 RegExpObject。

modifier 是正則表達式的匹配屬性（ "i" / "g" / "i" ）。

如果缺省參數，RegExpObject 被重置為一個空的正則表達式 //。

var reg = /man/ ; "I'm woman !".replace( reg , "child" ) ; // "I'm wochild !" reg.compile( /(wo)?man/ ) ; "I'm woman !".replace( reg , "child" ) ; // "I'm child !"

如果 regexp 是正則表達式本身，結果就是重新編譯并重置它的屬性，比如 lastIndex。

exec

Regex.exec 方法用于檢索字符串中正則表達式的匹配。形式如下：

var ResultArray = RegExpObject.exec( string ) ;

Regex.exec 方法返回一個數組：

• 數組的元素，就是匹配的結果；
• 數組的屬性 index 表示匹配發生的位置，input 表示原始字符串；
• 未找到匹配返回 null，而不是空數組 [ ]；

執行 exec 后：

• 如果匹配成功，正則表達式的屬性 lastIndex 設為匹配文本后面的位置；
• 如果匹配失敗，正則表達式的屬性 lastIndex 設為 0 。

非全局匹配的情況下，exec 的返回結果和 String.match 相同。

[ 匹配的結果 , 第 1 個子表達式匹配的結果 , 第二個..... , 第 n 個子表達式匹配的結果 ]

全局匹配的情況下，可以通過反復調用 exec 方法來遍歷字符串中的所有匹配文本。

var str = "30-AC-F6-B1-EC-14" ; var reg = /(\d{2})|([A-Z]{2})/g ; reg.exec( str ) ; // [ "30" , "30" , undefined ] alert( reg.lastIndex ) ; // 2 // 在 "30" 這個匹配結果中, \d{2} 匹配到了 "30", [A-Z]{2} 匹配失敗。 reg.exec( str ) ; // [ "AC" , undefined , "AC" ] alert( reg.lastIndex ) ; // 5

用 for 來遍歷：

var str = "30-AC-F6-B1-EC-14" ; var reg = /(\d{2})|([A-Z]{2})/g ; var match = reg .exec( str ) ; var numberArr = [ ] ; var literalArr = [ ] ; while( match ){if( match[ 1 ] )numberArr.push( match[ 1 ] );if( match[ 2 ] )literalArr.push( match[ 2 ] ); match = reg .exec( str ) ; } alert("數字："+ numberArr + " 字母：" + literalArr );

1.4 分組

正則表達式中，使用括號 ( ) 進行分組。

分組的正則表達式有兩個作用：一是可以讓重復的模式作用于整個組而不是單一字符，另一個是可以用特殊轉義序列對其進行引用。

var reg = /^(.).*\1$/ ; // 匹配開頭和結尾字符相同的字符串 reg.test( "seats" ) ; // true

其中使用 \n 引用前面第 n 個 捕獲子表達式 的捕獲結果。

分組的捕獲結果，還可以用 RegExp 的靜態屬性 $1...$9 引用。在 string.replace 方法中：

var reg = /(\d+)/g ; // 匹配數字 "var a = 98 + 23 ;".replace( reg , "<i>$1</i>") ; // "var a = <i>98</i> + <i>23</i> ;"

在 string.replace 的 replacement 參數中 "$1" ... "$9" 擁有特殊意義，引用模式匹配過程中 捕獲子表達式 捕獲的結果。

也可以在 replacement 外使用 RegExp.$1 ... RegExp.$9 訪問對應分組捕獲的結果。

var reg = /(\d+)/g ; // 匹配數字 "var a = 98 + 23 ;".replace( reg , "<i>" + RegExp.$1 + "</i>") ; // "var a = <i>98</i> + <i>23</i> ;" var reg = /(\d+)-(\d+)/g ; reg.exec( "021-88776655,010-99585960" ) ; // ["021-88776655", "021", "88776655"] alert( "區號：" + RegExp.$1 + " 號碼：" + RegExp.$2 ) ; // 區號：021 號碼：88776655 reg.exec( "021-88776655,010-99585960" ) ; // ["010-99585960", "010", "99585960"] alert( "區號：" + RegExp.$1 + " 號碼：" + RegExp.$2 ) ; // 區號：010 號碼：99585960

2元字符和正則表達式規則

CharacterDescription

\	\ 標志著下一個字符是一個特殊的字符。元字符擁有特殊的意義，如果想使用這些字符，需用 \ 轉義： var reg1 = /\{/ ; // 匹配大括號 var reg2 = /\(/ ; // 匹配分組符號 var reg3 = /\[/ ; // 匹配中括號 var reg4 = /\\/ ; // 匹配反斜杠 var reg5 = /\n/ ; // 匹配換行符
^	^ 匹配字符串的開始位置。如果進行多行（Multiline）匹配，^ 也會匹配 \n、\r 后面的位置。 var reg = /^a/ ; reg.test( "ab" ) ; // true reg.test( "ba" ) ; // false reg = "abc\ndef\rghi" ; reg.replace( /^/gm , "-" ) ; //"-abc\n-def\r-ghi"
$	$ 匹配字符串的結束位置。如果進行多行（Multiline）匹配，$ 也會匹配 \n、\r 前面的位置。 var reg = /a$/ ; reg.test( "ab" ) ; // false reg.test( "ba" ) ; // true reg = "abc\ndef\rghi" ; reg.replace( /$/gm , "-" ) ; //"abc-\ndef-\rghi-"
*	* 匹配前面的字符或者分組 0 次或多次。如 zo* 匹配 “zo” 和 “zoo”，甚至是 “z”。 ? + 等價于 {1,} var reg = /zo*/ ; // 或者 /zo{0,}/ reg.test( "zoo" ) ; // true reg.test( "zo" ) ; // true reg.test( "z" ) ; // true reg.test( "loo" ) ; // false
+	+ 匹配前面的字符或者分組 1 次或多次。如 zo+ 匹配 “zo” 和 “zoo”，但不匹配 “z”。 ? + 等價于 {1,} var reg = /zo+/ ; // 或者 /zo{1,}/ reg.test( "zoo" ) ; // true reg.test( "zo" ) ; // true reg.test( "z" ) ; // false reg.test( "loo" ) ; // false
?	? 匹配前面的字符或者分組 1 次或多次。如 do(es)? 匹配 “do” 和 “does” 。 ? ? 等價于 {0,1} var reg = /do(es)?/ ; // 或者 /do(es){0,1}/ reg.test( "do" ) ; // true reg.test( "does" ) ; // true reg.test( "to" ) ; // false
{n}	{n} 匹配前面的字符或者分組 n 次。其中 n 是非負整數。如 o{2} 匹配 "food" 的 2 個 "o" ，不匹配 "do" 中的 1 個 "o" 。 var reg = /o{2}/ ; reg.test( "too" ) ; // true reg.test( "food" ) ; // true reg.test( "to do" ) ; // false
{n,}	{n,} 匹配前面的字符或者分組至少 n 次。其中 n 是非負整數。如 o{1} 匹配 "yahoo" 的 2 個 "o" ，也匹配 "yahooooooooo"中的所有 "o" 。 ? {1,} 等價于 +。 var reg = /o{2}/ ; reg.test( "google" ) ; // true reg.test( "yahooooo" ) ; // true reg.test( "to do" ) ; // false
{n,m}	{n,m} 匹配前面的字符或者分組至少 n 次、至多 m 次。其中 n 和 m 都是非負整數。如 o{1,3} 匹配 "yahoo" 的前 3 個 "o" ，也匹配 "yahooooooooo"中的前 3 個 "o" 。 ? {0,1} 等價于 ?。 注意：數字和逗號之間不能有空格。 var reg = /o{2}/ ; reg.test( "google" ) ; // true reg.test( "yahooooo" ) ; // true reg.test( "to do" ) ; // false
?	其實 ? 有兩個用途。 ? 第一個用途上面提到了，用來匹配前面字符或分組 0 次或 1 次。 第二個用途，用在其他量詞（比如 * , + , ? , {n} , {n,} , {n,m}）的后面，指示匹配模式為 “非貪婪匹配”，與之相反，默認匹配規則是 “貪婪匹配”，即盡量匹配更多的字符。比如，o+ 匹配 “ooooo” 中的全部 “o”，而 o+? 匹配第一個 “o”。 var reg = /o+?/ ; reg.test( "google" ) ; // true reg.test( "yahooooo" ) ; // true reg.test( "to do" ) ; // true
.	. 匹配除了 "\n" 外的任何字符。 ? 想要匹配 "\n" 可以使用 [\s\S]。 var reg = /^a.*a$/ ; // 匹配一行首尾都是 a 的字符串 reg.test( "abcdefga" ) ; // true reg.test( "abc") ; // false
(pattern)	(pattern) 匹配模式 pattern 并捕獲結果。 ? RegExp.exec 返回的數組中： 第一個元素是整個正則表達式匹配到的字符串； 后面的元素，依次是針對該次匹配的子表達式 pattern 匹配結果。 想要子表達式捕獲結果，需要用 ( ) 包圍起來。 var reg = /ch/ ; // 沒有子表達式 reg.exec( "chese" ) ; // [ "ch" ] reg = /(c)(h)/ ; reg.exec( "chese" ) ; // [ "ch" , "c" , "h" ] reg = /(ch)/ ; reg.exec( "chese" ) ; // [ "ch" , "ch" ] reg = /(ch)|(ese)|(en)/ ; reg.exec( "chese" ) ; // [ "ch" , "ch" , undefined , undefined ]
(?:pattern)	(?:pattern) 匹配模式 pattern 并但不捕獲結果。 ? 加 ( ) 有時并不是為了捕獲，而僅僅為了 “分組”，這時可以用這個元字符。 var reg = /^.*(?:\.|。)$/ ; 匹配以句號結尾的字符串 reg.exec( "Hello !" ) ; // null reg.exec( "To be continued ." ) ; // ["To be continued ."]
(?=pattern)	(?=pattern) 零寬正向預測先行斷言。斷言此位置的后面匹配 pattern ，不捕獲結果（零寬）。 ? 先行斷言 (?=pattern) 不會消耗字符，也就是說，下一次匹配是從上一次匹配之后的位置開始的，而不是在pattern 之后。 var reg = /Windows (?=2008|7)/g ; // 匹配 "Windows" ，后面必須死 "2008" 或 "7" var str = "最低配置 Windows 2008 ，推薦 Windows 7 。" ; alert( reg.exec( str ) ) ; // [ "Windows" ] alert( reg.lastIndex ) ; // 13 , 第 1 個 "Windows" 后面的位置 alert( reg.exec( str ) ) ; // [ "Windows" ] alert( reg.lastIndex ) ; // 30 , 第 2 個 "Windows" 后面的位置
(?!pattern)	(?!pattern) 零寬負向預測先行斷言，斷言此位置的后面不匹配 pattern ，不捕獲結果（零寬）。 ? 先行斷言 (?!pattern) 不會消耗字符，同上。 var reg = /Windows (?!2000|xp)/g ; // 匹配 "Windows" ，后面不能是 "2000" 或 "xp" var str = "最低配置 Windows 2008 ，推薦 Windows 7 。" ; alert( reg.exec( str ) ) ; // [ "Windows" ] alert( reg.lastIndex ) ; // 13 , 第 1 個 "Windows" 后面的位置 alert( reg.exec( str ) ) ; // [ "Windows" ] alert( reg.lastIndex ) ; // 30 , 第 2 個 "Windows" 后面的位置
x|y	x|y 匹配 x 或 匹配 y 。 ? 比如 see|saw 匹配 "see"，也可以匹配 "saw" var reg = /hello|hi/i ; // 匹配問候語 hello , hi , 忽略大小寫 reg.test( "Hello" ) ; // true reg.test( "Hi, are you ok !") ; // true
[xyz]	[xyz] 代表一個字符集（字符集中的元字符不需要轉義）。匹配任何出現在中括號 [ ] 中的字母 。 ? 比如 [abc] 匹配 "plain" 中的 “a”。 可以使用 - 表示字符的范圍： 英文字母： [a-zA-Z] ； 阿拉伯數字： [0-9] ； 羅馬數字： [Ⅰ-Ⅻ] ； 希臘字母、拼音字母…… ； Unicode 字符編碼：[udddd-udddd]，其中 d 代表一個 16 進制的數字； Latin-1 字符編碼：[xdd-xdd]，其中 d 代表一個 16 進制的數字； var reg = /[a-zA-Z-_]+/g ; // 匹配英文單詞 "I wanna be a scientist .".match( reg ) ; // ["I", "wanna", "be", "a", "scientist"]
[^xyz]	[^xyz] 代表一個排除字符集，不匹配任何出現在中括號 [ ] 中的字母 。 ? 比如 [^abc] 匹配 "see" 中的 “s”。 var reg = /[<][^>].*?[>]/g ; // 匹配帶尖括號的內容 "<div></div>".match( reg ) ; // [ "<div>" , "</div>" ]
\b	\b 匹配單詞邊界。 ? 比如 er\b 匹配 "her" 中的 “er”，但不匹配 “verb” 中的 “er” 。 \b通常用于查找位于單詞的開頭或結尾的匹配。 var reg = /\b[a-zA-Z-_]+(es|s)\b/g ; // 匹配以 "es" 或 "s" 結尾的單詞 "I bought 1 cup, 5 apples, and 6 dozens of eggs".match( reg ) ; // [ "apples" , "dozens" , "eggs" ]
\B	\B 匹配非單詞邊界的位置。 ? 匹配位置的上一個和下一個字符的類型是相同的：即必須同時是單詞字符，或必須同時是非單詞字符； 字符串的開頭和結尾處被視為非單詞字符。 比如 er\B 不匹配 "her" 中的 “er”，匹配 “verb” 中的 “er” 。 \B通常用于排除位于單詞的開頭或結尾的匹配。 var reg = /[a-z-_]*\Boo\B[a-z-_]*/ig ; //匹配內部出現 "oo" 的單詞。 "I like reading book in the room too !".match( reg ) ; // [ "book" , "room" ]
\cx	\cx 匹配由 x 字符表示的控制字符。 ? 如 \cM 表示 Ctl+M 或回車字符 "\r"，\cJ 表示換行符 "\n"。 /td>
\d	\d 匹配一個數字，相當于 [0-9] 。 var reg = /\d\d/g ; // 匹配兩個連續的數字 "[55,25,2422,579]".match( reg ) ; // ["55", "25", "24", "22", "57"]
\D	\D 匹配一個非數字的字符，相當于 [^0-9] 。
\f	\f 匹配一個換頁符，相當于 \x0c 或 \cL 。
\n	\n 匹配一個換行符，相當于 \x0a 或 \cJ 。
\r	\r 匹配一個回車符，相當于 \x0d 或 \cM 。
\s	\s 匹配空白字符，包括空格 " "、制表符 "\t"、翻頁符 "\f"、換行符 "\n"、垂直制表符 "\t"。 ? 相當于 [\f\n\r\t\v]
\S	\S 匹配非空白字符，相當于 [\f\n\r\t\v]
\t	\t 匹配制表符，相當于 \x09、\cI。
\v	\v 匹配垂直制表符，相當于 \x0b 、\cK。
\w	\w 匹配任何單詞字符，包括下劃線，相當于 [A-Za-z0-9_] 。
\W	\w 匹配任何非單詞字符，相當于 [^A-Za-z0-9_] 。
\xn	\xn 匹配 Latin-1 字符，其中的 n 為 16 位的數字。 。 ? 所有的 ASCII 字符都可以用 \xn 來表示，如 \x41 匹配 “A” 。
\num	\num 引用前面第 num 個 捕獲子表達式 捕獲到的字符串。num 是一個正整數。 ? 如 (.)\1 同一個字符匹配兩次。 var reg = /(.)\2/g ; "book、see".match( reg ) ; // ["oo", "ee"]
\n	\n n 代表一個數字。 ? 如果 \n 前面有至少 n 個 捕獲子表達式 ，那么它就作為 “后向引用”，等同于上面的 \num 。 如果不滿足上面的條件，n 又是一個八進制（0-7），那么它作為八進制轉義碼。 /\2/.test("") ; // true
\nm	\nm n 、 m 代表一個數字。 ? 如果 \nm 前面是一個捕獲字表達式： 如果 \nm 至少有 nm 個捕獲字表達式，則將 \nm 視作后向引用； 如果 \nm 至少有 n 個捕獲字表達式，則將 \n 視作后向引用，m 作為一個普通數字； 如果不滿足上面的條件，n、m 又是八進制（0-7），那么 \nm 作為八進制轉義碼。
\nml	\nmlnm 當 n 在 0 - 3 間，m、l 在 0 - 7 間， 匹配八進制轉義碼 nml 。
\un	\un 匹配編碼為 n 的 Unicode 字符 。 /\u00A9/.test("?") ; // true

相關文章

• Javascript – 字符串
• Javascript – 集合
• JavaScript Scope Chains and Closures
• Javascript – 對象
• Javascript – 控制語句
• Javascript – 表達式和運算符
• Javascript – Explaining JavaScript scope and closures
• Javascript – 常量和變量

轉載于:https://www.cnblogs.com/kangzhibao/p/4085140.html

總結

以上是生活随笔為你收集整理的Javascript – 正则表达式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。