【JavaScript基礎筆記】RegExp對象 正則表達式

1、建立一個正則表達式

新建正則表達式有兩種方法

• 使用字面量    var regex = /asd/;
• 使用RegExp構造函數    var regex = new RegExp('asd');

兩種方法等價，但在實際應用中基本上都會使用第一種方法。由於第一種方法在引擎編譯代碼時就會新建正則表達式，後者是在運行時新建，因此前者效率更高，而且第一種方法在視覺上更直觀，寫法更簡潔。

 

正則表達式還能夠添加第二個參數，表示 修飾符：

var regex = /asd/i;
var regex = new RegExp('asd', 'i');

 

2、實例屬性

正則對象的實例屬性分爲兩類。

第一種，修飾符相關屬性

• RegExp.prototype.ignoreCase：返回一個布爾值，表示是否設置了i修飾符。
• RegExp.prototype.global：返回一個布爾值，表示是否設置了g修飾符。
• RegExp.prototype.multiline：返回一個布爾值，表示是否設置了m修飾符。

上面三個屬性都是隻讀的。

 

第二種，與修飾符無關的屬性。

RegExp.prototype.lastIndex：返回一個整數，表示下一次開始搜索的位置。該屬性可讀寫，可是隻在進行連續搜索時有意義。

RegExp.prototype.source：返回正則表達式的字符串形式（不包括反斜槓），該屬性只讀。

 

3、實例方法

3.1 RegExp.prototype.test()

正則實例對象的test方法返回一個布爾值，表示當前正則對象是否和test方法內的參數字符串相匹配。

若是test方法內的參數字符串包含正則實例對象，即返回true。

 

若是正則表達式帶有g修飾符，那麼表示將正則表達式在test參數中全局搜索，每當遇到匹配結果即在當前位置結束，隨後每一次test方法都從上一次結束的位置開始向後匹配。

 

帶有g修飾符時，能夠經過正則對象的lastIndex屬性指定開始搜索的位置。

var r = /x/g; var s = '_x_x'; r.lastIndex = 4; r.test(s) // false r.lastIndex // 0 r.test(s)

上面代碼指定從字符串的第五個位置開始搜索，這個位置爲空，因此返回false。同時，lastIndex屬性重置爲0，因此第二次執行r.test(s)會返回true。

 

注意，帶有g修飾符時，正則表達式內部會記住上一次的lastIndex屬性，若是在這個時候更換了匹配的字符串，會使正則實例從上一個test參數的lastIndex位置處開始向後搜索，很容易發生意想不到的錯誤。

 

若是正則模式是一個空字符串，則匹配全部字符串。

 

3.2RegExp.prototype.exec()

正則實例對象的exec方法，用來返回匹配結果。若是發現匹配，就返回一個數組，成員是匹配成功的子字符串，不然返回null。

var r = /a(b+)a/; var arr = r.exec('_abbba_aba_'); arr // ["abbba", "bbb"] arr.index // 1 arr.input // "_abbba_aba_"

若是正則表示式包含圓括號（即含有「組匹配」），則返回的數組會包括多個成員。第一個成員是整個匹配成功的結果，後面的成員就是圓括號對應的匹配成功的組。也就是說，第二個成員對應第一個括號，第三個成員對應第二個括號，以此類推。整個數組的length屬性等於組匹配的數量再加1。

 

exec方法的返回數組還包含如下兩個屬性：

input：整個原字符串。

index：整個模式匹配成功的開始位置（從0開始計數）。

 

4、字符串的實例方法

字符串的實例方法之中，有4種與正則表達式有關。

• String.prototype.match()：返回一個數組，成員是全部匹配的子字符串。
• String.prototype.search()：按照給定的正則表達式進行搜索，返回一個整數，表示匹配開始的位置。
• String.prototype.replace()：按照給定的正則表達式進行替換，返回替換後的字符串。
• String.prototype.split()：按照給定規則進行字符串分割，返回一個數組，包含分割後的各個成員。

 

4.1 String.prototype.match()

字符串實例對象的match方法對字符串進行正則匹配，返回匹配結果。和正則對象的exec方法返回的結果在沒有g修飾符的狀況下是同樣的。

若是正則表達式帶有g修飾符，那麼match()方法會一次性返回全部匹配的結果，而exec方法一次只會返回一個相匹配的結果。

var s = 'abba'; var r = /a/g; s.match(r) // ["a", "a"] r.exec(s) // ["a"]

 

4.2 String.prototype.search() 

字符串對象的search方法，返回第一個知足條件的匹配結果在整個字符串中的位置。若是沒有任何匹配，則返回-1。

 

4.3String.prototype.replace()

字符串對象的replace方法能夠替換匹配的值。它接受兩個參數，第一個是正則表達式，表示搜索模式，第二個是替換的內容。

正則表達式若是不加g修飾符，就替換第一個匹配成功的值，不然替換全部匹配成功的值。

'aaa'.replace('a', 'b') // "baa" 'aaa'.replace(/a/, 'b') // "baa" 'aaa'.replace(/a/g, 'b') // "bbb"

 

【replace方法的一個應用，就是消除字符串首尾兩端的空格。】

var str = ' #id div.class '; str.replace(/^\s+|\s+$/g, '') // "#id div.class"

 

replace方法的第二個參數可使用美圓符號$，用來指代所替換的內容。

$&：匹配的子字符串。

$`：匹配結果前面的文本。

$'：匹配結果後面的文本。

$n：匹配成功的第n組內容，n是從1開始的天然數。

$$：指代美圓符號$。

'hello world'.replace(/(\w+)\s(\w+)/, '$2 $1') // "world hello" 'abc'.replace('b', '[$`-$&-$\']') // "a[a-b-c]c"

4.4String.prototype.split()

字符串對象的split方法按照正則規則分割字符串，返回一個由分割後的各個部分組成的數組。

該方法接受兩個參數，第一個參數是正則表達式，表示分隔規則，第二個參數是返回數組的最大成員數。

// 非正則分隔 'a, b,c, d'.split(',') // [ 'a', ' b', 'c', ' d' ] // 正則分隔，去除多餘的空格 'a, b,c, d'.split(/, */) // [ 'a', 'b', 'c', 'd' ] // 指定返回數組的最大成員 'a, b,c, d'.split(/, */, 2) [ 'a', 'b' ]

上面代碼使用正則表達式，去除了子字符串的逗號後面的空格。

// 例一 'aaa*a*'.split(/a*/) // [ '', '*', '*' ] // 例二 'aaa**a*'.split(/a*/) // ["", "*", "*", "*"]

上面代碼的分割規則是0次或屢次的a，因爲正則默認是貪婪匹配，因此例一的第一個分隔符是aaa，第二個分割符是a，將字符串分紅三個部分，包含開始處的空字符串。例二的第一個分隔符是aaa，第二個分隔符是0個a（即空字符），第三個分隔符是a，因此將字符串分紅四個部分。

 

若是正則表達式帶有括號，則括號匹配的部分也會做爲數組成員返回。

'aaa*a*'.split(/(a*)/) // [ '', 'aaa', '*', 'a', '*' ]

上面代碼的正則表達式使用了括號，第一個組匹配是aaa，第二個組匹配是a，它們都做爲數組成員返回。

 

5、匹配規則

 

字面量字符和元字符

大部分字符在正則表達式中，就是字面的含義，好比/a/匹配a，/b/匹配b。若是在正則表達式之中，某個字符只表示它字面的含義（就像前面的a和b），那麼它們就叫作「字面量字符」（literal characters）。

/dog/.test('old dog') // true 

上面代碼中正則表達式的dog，就是字面量字符，因此/dog/匹配old dog，由於它就表示d、o、g三個字母連在一塊兒。

除了字面量字符之外，還有一部分字符有特殊含義，不表明字面的意思。它們叫作「元字符」（metacharacters），主要有如下幾個。

（1）點字符（.)

點字符（.）匹配除回車（\r）、換行(\n) 、行分隔符（\u2028）和段分隔符（\u2029）之外的全部字符。注意，對於碼點大於0xFFFF字符，點字符不能正確匹配，會認爲這是兩個字符。

/c.t/ 

上面代碼中，c.t匹配c和t之間包含任意一個字符的狀況，只要這三個字符在同一行，好比cat、c2t、c-t等等，可是不匹配coot。

（2）位置字符

位置字符用來提示字符所處的位置，主要有兩個字符。

• ^ 表示字符串的開始位置
• $ 表示字符串的結束位置

// test必須出如今開始位置 /^test/.test('test123') // true // test必須出如今結束位置 /test$/.test('new test') // true // 從開始位置到結束位置只有test /^test$/.test('test') // true /^test$/.test('test test') // false 

（3）選擇符（|）

豎線符號（|）在正則表達式中表示「或關係」（OR），即cat|dog表示匹配cat或dog。

/11|22/.test('911') // true 

上面代碼中，正則表達式指定必須匹配11或22。

多個選擇符能夠聯合使用。

// 匹配fred、barney、betty之中的一個 /fred|barney|betty/ 

選擇符會包括它先後的多個字符，好比/ab|cd/指的是匹配ab或者cd，而不是指匹配b或者c。若是想修改這個行爲，可使用圓括號。

/a( |\t)b/.test('a\tb') // true 

上面代碼指的是，a和b之間有一個空格或者一個製表符。

其餘的元字符還包括\、\*、+、?、()、[]、{}等，將在下文解釋。

轉義符

正則表達式中那些有特殊含義的元字符，若是要匹配它們自己，就須要在它們前面要加上反斜槓。好比要匹配+，就要寫成\+。

/1+1/.test('1+1') // false /1\+1/.test('1+1') // true 

上面代碼中，第一個正則表達式之因此不匹配，由於加號是元字符，不表明自身。第二個正則表達式使用反斜槓對加號轉義，就能匹配成功。

正則表達式中，須要反斜槓轉義的，一共有12個字符：^、.、[、$、(、)、|、*、+、?、{和\。須要特別注意的是，若是使用RegExp方法生成正則對象，轉義須要使用兩個斜槓，由於字符串內部會先轉義一次。

(new RegExp('1\+1')).test('1+1') // false (new RegExp('1\\+1')).test('1+1') // true 

上面代碼中，RegExp做爲構造函數，參數是一個字符串。可是，在字符串內部，反斜槓也是轉義字符，因此它會先被反斜槓轉義一次，而後再被正則表達式轉義一次，所以須要兩個反斜槓轉義。

特殊字符

正則表達式對一些不能打印的特殊字符，提供了表達方法。

• \cX 表示Ctrl-[X]，其中的X是A-Z之中任一個英文字母，用來匹配控制字符。
• [\b] 匹配退格鍵(U+0008)，不要與\b混淆。
• \n 匹配換行鍵。
• \r 匹配回車鍵。
• \t 匹配製表符 tab（U+0009）。
• \v 匹配垂直製表符（U+000B）。
• \f 匹配換頁符（U+000C）。
• \0 匹配null字符（U+0000）。
• \xhh 匹配一個以兩位十六進制數（\x00-\xFF）表示的字符。
• \uhhhh 匹配一個以四位十六進制數（\u0000-\uFFFF）表示的 Unicode 字符。

字符類

字符類（class）表示有一系列字符可供選擇，只要匹配其中一個就能夠了。全部可供選擇的字符都放在方括號內，好比[xyz] 表示x、y、z之中任選一個匹配。

/[abc]/.test('hello world') // false /[abc]/.test('apple') // true 

上面代碼中，字符串hello world不包含a、b、c這三個字母中的任一個，因此返回false；字符串apple包含字母a，因此返回true。

有兩個字符在字符類中有特殊含義。

（1）脫字符（^）

若是方括號內的第一個字符是[^]，則表示除了字符類之中的字符，其餘字符均可以匹配。好比，[^xyz]表示除了x、y、z以外均可以匹配。

/[^abc]/.test('hello world') // true /[^abc]/.test('bbc') // false 

上面代碼中，字符串hello world不包含字母a、b、c中的任一個，因此返回true；字符串bbc不包含a、b、c之外的字母，因此返回false。

若是方括號內沒有其餘字符，即只有[^]，就表示匹配一切字符，其中包括換行符。相比之下，點號做爲元字符（.）是不包括換行符的。

var s = 'Please yes\nmake my day!'; s.match(/yes.*day/) // null s.match(/yes[^]*day/) // [ 'yes\nmake my day'] 

上面代碼中，字符串s含有一個換行符，點號不包括換行符，因此第一個正則表達式匹配失敗；第二個正則表達式[^]包含一切字符，因此匹配成功。

注意，脫字符只有在字符類的第一個位置纔有特殊含義，不然就是字面含義。

（2）連字符（-）

某些狀況下，對於連續序列的字符，連字符（-）用來提供簡寫形式，表示字符的連續範圍。好比，[abc]能夠寫成[a-c]，[0123456789]能夠寫成[0-9]，同理[A-Z]表示26個大寫字母。

/a-z/.test('b') // false /[a-z]/.test('b') // true 

上面代碼中，當連字號（dash）不出如今方括號之中，就不具有簡寫的做用，只表明字面的含義，因此不匹配字符b。只有當連字號用在方括號之中，才表示連續的字符序列。

如下都是合法的字符類簡寫形式。

[0-9.,] [0-9a-fA-F] [a-zA-Z0-9-] [1-31] 

上面代碼中最後一個字符類[1-31]，不表明1到31，只表明1到3。

連字符還能夠用來指定 Unicode 字符的範圍。

var str = "\u0130\u0131\u0132"; /[\u0128-\uFFFF]/.test(str) // true 

上面代碼中，\u0128-\uFFFF表示匹配碼點在0128到FFFF之間的全部字符。

另外，不要過度使用連字符，設定一個很大的範圍，不然極可能選中意料以外的字符。最典型的例子就是[A-z]，表面上它是選中從大寫的A到小寫的z之間52個字母，可是因爲在 ASCII 編碼之中，大寫字母與小寫字母之間還有其餘字符，結果就會出現意料以外的結果。

/[A-z]/.test('\\') // true 

上面代碼中，因爲反斜槓（'\'）的ASCII碼在大寫字母與小寫字母之間，結果會被選中。

預約義模式

預約義模式指的是某些常見模式的簡寫方式。

• \d 匹配0-9之間的任一數字，至關於[0-9]。
• \D 匹配全部0-9之外的字符，至關於[^0-9]。
• \w 匹配任意的字母、數字和下劃線，至關於[A-Za-z0-9_]。
• \W 除全部字母、數字和下劃線之外的字符，至關於[^A-Za-z0-9_]。
• \s 匹配空格（包括換行符、製表符、空格符等），相等於[ \t\r\n\v\f]。
• \S 匹配非空格的字符，至關於[^ \t\r\n\v\f]。
• \b 匹配詞的邊界。
• \B 匹配非詞邊界，即在詞的內部。

下面是一些例子。

// \s 的例子 /\s\w*/.exec('hello world') // [" world"] // \b 的例子 /\bworld/.test('hello world') // true /\bworld/.test('hello-world') // true /\bworld/.test('helloworld') // false // \B 的例子 /\Bworld/.test('hello-world') // false /\Bworld/.test('helloworld') // true 

上面代碼中，\s表示空格，因此匹配結果會包括空格。\b表示詞的邊界，因此world的詞首必須獨立（詞尾是否獨立未指定），纔會匹配。同理，\B表示非詞的邊界，只有world的詞首不獨立，纔會匹配。

一般，正則表達式遇到換行符（\n）就會中止匹配。

var html = "<b>Hello</b>\n<i>world!</i>"; /.*/.exec(html)[0] // "<b>Hello</b>" 

上面代碼中，字符串html包含一個換行符，結果點字符（.）不匹配換行符，致使匹配結果可能不符合原意。這時使用\s字符類，就能包括換行符。

var html = "<b>Hello</b>\n<i>world!</i>"; /[\S\s]*/.exec(html)[0] // "<b>Hello</b>\n<i>world!</i>" 

上面代碼中，[\S\s]指代一切字符。

重複類

模式的精確匹配次數，使用大括號（{}）表示。{n}表示剛好重複n次，{n,}表示至少重複n次，{n,m}表示重複很多於n次，很少於m次。

/lo{2}k/.test('look') // true /lo{2,5}k/.test('looook') // true 

上面代碼中，第一個模式指定o連續出現2次，第二個模式指定o連續出現2次到5次之間。

量詞符

量詞符用來設定某個模式出現的次數。

• ? 問號表示某個模式出現0次或1次，等同於{0, 1}。
• * 星號表示某個模式出現0次或屢次，等同於{0,}。
• + 加號表示某個模式出現1次或屢次，等同於{1,}。

// t 出現0次或1次 /t?est/.test('test') // true /t?est/.test('est') // true // t 出現1次或屢次 /t+est/.test('test') // true /t+est/.test('ttest') // true /t+est/.test('est') // false // t 出現0次或屢次 /t*est/.test('test') // true /t*est/.test('ttest') // true /t*est/.test('tttest') // true /t*est/.test('est') // true 

貪婪模式

上一小節的三個量詞符，默認狀況下都是最大可能匹配，即匹配直到下一個字符不知足匹配規則爲止。這被稱爲貪婪模式。

var s = 'aaa'; s.match(/a+/) // ["aaa"] 

上面代碼中，模式是/a+/，表示匹配1個a或多個a，那麼到底會匹配幾個a呢？由於默認是貪婪模式，會一直匹配到字符a不出現爲止，因此匹配結果是3個a。

若是想將貪婪模式改成非貪婪模式，能夠在量詞符後面加一個問號。

var s = 'aaa'; s.match(/a+?/) // ["a"] 

上面代碼中，模式結尾添加了一個問號/a+?/，這時就改成非貪婪模式，一旦條件知足，就再也不往下匹配。

除了非貪婪模式的加號，還有非貪婪模式的星號（*）和非貪婪模式的問號（?）。

• +?：表示某個模式出現1次或屢次，匹配時採用非貪婪模式。
• *?：表示某個模式出現0次或屢次，匹配時採用非貪婪模式。
• ??：表格某個模式出現0次或1次，匹配時採用非貪婪模式。

'abb'.match(/ab*b/) // ["abb"] 'abb'.match(/ab*?b/) // ["ab"] 'abb'.match(/ab?b/) // ["abb"] 'abb'.match(/ab??b/) // ["ab"] 

修飾符

修飾符（modifier）表示模式的附加規則，放在正則模式的最尾部。

修飾符能夠單個使用，也能夠多個一塊兒使用。

// 單個修飾符 var regex = /test/i; // 多個修飾符 var regex = /test/ig; 

（1）g 修飾符

默認狀況下，第一次匹配成功後，正則對象就中止向下匹配了。g修飾符表示全局匹配（global），加上它之後，正則對象將匹配所有符合條件的結果，主要用於搜索和替換。

var regex = /b/; var str = 'abba'; regex.test(str); // true regex.test(str); // true regex.test(str); // true 

上面代碼中，正則模式不含g修飾符，每次都是從字符串頭部開始匹配。因此，連續作了三次匹配，都返回true。

var regex = /b/g; var str = 'abba'; regex.test(str); // true regex.test(str); // true regex.test(str); // false 

上面代碼中，正則模式含有g修飾符，每次都是從上一次匹配成功處，開始向後匹配。由於字符串abba只有兩個b，因此前兩次匹配結果爲true，第三次匹配結果爲false。

（2）i 修飾符

默認狀況下，正則對象區分字母的大小寫，加上i修飾符之後表示忽略大小寫（ignoreCase）。

/abc/.test('ABC') // false /abc/i.test('ABC') // true 

上面代碼表示，加了i修飾符之後，不考慮大小寫，因此模式abc匹配字符串ABC。

（3）m 修飾符

m修飾符表示多行模式（multiline），會修改^和$的行爲。默認狀況下（即不加m修飾符時），^和$匹配字符串的開始處和結尾處，加上m修飾符之後，^和$還會匹配行首和行尾，即^和$會識別換行符（\n）。

/world$/.test('hello world\n') // false /world$/m.test('hello world\n') // true 

上面的代碼中，字符串結尾處有一個換行符。若是不加m修飾符，匹配不成功，由於字符串的結尾不是world；加上之後，$能夠匹配行尾。

/^b/m.test('a\nb') // true 

上面代碼要求匹配行首的b，若是不加m修飾符，就至關於b只能處在字符串的開始處。加上b修飾符之後，換行符\n也會被認爲是一行的開始。

組匹配

（1）概述

正則表達式的括號表示分組匹配，括號中的模式能夠用來匹配分組的內容。

/fred+/.test('fredd') // true /(fred)+/.test('fredfred') // true 

上面代碼中，第一個模式沒有括號，結果+只表示重複字母d，第二個模式有括號，結果+就表示匹配fred這個詞。

下面是另一個分組捕獲的例子。

var m = 'abcabc'.match(/(.)b(.)/); m // ['abc', 'a', 'c'] 

上面代碼中，正則表達式/(.)b(.)/一共使用兩個括號，第一個括號捕獲a，第二個括號捕獲c。

注意，使用組匹配時，不宜同時使用g修飾符，不然match方法不會捕獲分組的內容。

var m = 'abcabc'.match(/(.)b(.)/g); m // ['abc', 'abc'] 

上面代碼使用帶g修飾符的正則表達式，結果match方法只捕獲了匹配整個表達式的部分。這時必須使用正則表達式的exec方法，配合循環，才能讀到每一輪匹配的組捕獲。

var str = 'abcabc'; var reg = /(.)b(.)/g; while (true) { var result = reg.exec(str); if (!result) break; console.log(result); } // ["abc", "a", "c"] // ["abc", "a", "c"] 

正則表達式內部，還能夠用\n引用括號匹配的內容，n是從1開始的天然數，表示對應順序的括號。

/(.)b(.)\1b\2/.test("abcabc") // true 

上面的代碼中，\1表示第一個括號匹配的內容（即a），\2表示第二個括號匹配的內容（即c）。

下面是另一個例子。

/y(..)(.)\2\1/.test('yabccab') // true 

括號還能夠嵌套。

/y((..)\2)\1/.test('yabababab') // true 

上面代碼中，\1指向外層括號，\2指向內層括號。

組匹配很是有用，下面是一個匹配網頁標籤的例子。

var tagName = /<([^>]+)>[^<]*<\/\1>/; tagName.exec("<b>bold</b>")[1] // 'b' 

上面代碼中，圓括號匹配尖括號之中的標籤，而\1就表示對應的閉合標籤。

上面代碼略加修改，就能捕獲帶有屬性的標籤。

var html = '<b class="hello">Hello</b><i>world</i>'; var tag = /<(\w+)([^>]*)>(.*?)<\/\1>/g; var match = tag.exec(html); match[1] // "b" match[2] // " class="hello"" match[3] // "Hello" match = tag.exec(html); match[1] // "i" match[2] // "" match[3] // "world" 

（2）非捕獲組

(?:x)稱爲非捕獲組（Non-capturing group），表示不返回該組匹配的內容，即匹配的結果中不計入這個括號。

非捕獲組的做用請考慮這樣一個場景，假定須要匹配foo或者foofoo，正則表達式就應該寫成/(foo){1, 2}/，可是這樣會佔用一個組匹配。這時，就可使用非捕獲組，將正則表達式改成/(?:foo){1, 2}/，它的做用與前一個正則是同樣的，可是不會單獨輸出括號內部的內容。

請看下面的例子。

var m = 'abc'.match(/(?:.)b(.)/); m // ["abc", "c"] 

上面代碼中的模式，一共使用了兩個括號。其中第一個括號是非捕獲組，因此最後返回的結果中沒有第一個括號，只有第二個括號匹配的內容。

下面是用來分解網址的正則表達式。

// 正常匹配 var url = /(http|ftp):\/\/([^/\r\n]+)(\/[^\r\n]*)?/; url.exec('http://google.com/'); // ["http://google.com/", "http", "google.com", "/"] // 非捕獲組匹配 var url = /(?:http|ftp):\/\/([^/\r\n]+)(\/[^\r\n]*)?/; url.exec('http://google.com/'); // ["http://google.com/", "google.com", "/"] 

上面的代碼中，前一個正則表達式是正常匹配，第一個括號返回網絡協議；後一個正則表達式是非捕獲匹配，返回結果中不包括網絡協議。

（3）先行斷言

x(?=y)稱爲先行斷言（Positive look-ahead），x只有在y前面才匹配，y不會被計入返回結果。好比，要匹配後面跟着百分號的數字，能夠寫成/\d+(?=%)/。

「先行斷言」中，括號裏的部分是不會返回的。

var m = 'abc'.match(/b(?=c)/); m // ["b"] 

上面的代碼使用了先行斷言，b在c前面因此被匹配，可是括號對應的c不會被返回。

（4）先行否認斷言

x(?!y)稱爲先行否認斷言（Negative look-ahead），x只有不在y前面才匹配，y不會被計入返回結果。好比，要匹配後面跟的不是百分號的數字，就要寫成/\d+(?!%)/。

/\d+(?!\.)/.exec('3.14') // ["14"] 

上面代碼中，正則表達式指定，只有不在小數點前面的數字纔會被匹配，所以返回的結果就是14。

「先行否認斷言」中，括號裏的部分是不會返回的。

var m = 'abd'.match(/b(?!c)/); m // ['b'] 

上面的代碼使用了先行否認斷言，b不在c前面因此被匹配，並且括號對應的d不會被返回。

 

本文整理摘抄於阮一峯《JavaScript教程》