正則表達式

時間 2019-11-08

標籤正則表達式欄目正則表達式简体版

原文原文鏈接

查看原文站點，更多擴展內容及更佳閱讀體驗！
查看原文：正則表達式

正則表達式

正則表達式是匹配模式，要麼匹配字符，要麼匹配位置。

字符匹配

兩種模糊匹配

正則表達式能實現模糊匹配
模糊匹配，有兩個方向上的模糊：橫向和縱向

橫向模糊匹配

橫向模糊指的是，一個正則可匹配的字符串的長度不是固定的
實現方式是使用量詞。{m,n}，表示連續出現最少m次，最多n次

/ab{2,5}c/匹配：第一個字符是 a，接下來是 2到 5個字符 b，最後是 c。

var regex = /ab{2,5}c/g;
var string = "abc abbc abbbc abbbbc abbbbbc abbbbbbc";
console.log(string.match(regex));
//[ 'abbc', 'abbbc', 'abbbbc', 'abbbbbc' ]

縱向模糊匹配

縱向模糊，一個正則匹配的字符串，具體到某一位字符時，它能夠不是某個肯定的字符，能夠有多種可能

實現方式是使用字符組。[abc]，表示該字符能夠是a、b、c中的任何一個。

var regex = /a[123]b/g;
var string = "a0b a1b a2b a3b a4b";
console.log(string.match(regex));
//[ 'a1b', 'a2b', 'a3b' ]

字符組

雖然叫字符組（字符類），但只是匹配其中一個字符。 [abc]表示匹配一個字符，它能夠是 a、 b、 c。

範圍表示法

字符組裏的字符比較多，可使用範圍表示法。

[123456abcdefGHIJKLM]能夠寫成[1-6a-fG-M]。用連字符-來省略和簡寫。
匹配a、-、z這三者中任意一個字符，能夠寫成[-az]或[a\-z]。要麼放在開頭，要麼放在結尾，要麼轉義。

排除字符組

縱向模糊匹配某位字符不能是a、b、c
[^abc]表示一個除a、b、c以外的任意一個字符。字符組的第一位放^（脫字符），表示求反的概念。

常見的簡寫形式

\d就是[0-9]。表示一位數字。digit
\D就是[^0-9]。表示除數字外的任意字符
\w就是[0-9a-zA-Z]。表示數字、大小寫字母和下劃線。word
\W就是[^0-9a-zA-Z]。非單詞字符
\s就是[\t\v\n\r\f]。表示空白符，包括空格、水平製表符、垂直製表符、換行符、回車符、換頁符。space
\S就是[^\t\v\n\r\f]。非空白符
.就是[^\n\r\u2028\u2029]。通配符，表示全部任意字符。

匹配任意字符，可使用 [\d\D]、 [\w\W]、 [\s\S]、 [^]中任意一個。

量詞

量詞也稱重複。 {m,n}

簡寫形式

{m,} 表示至少出現m次
{m} 等價於{m,m}，表示出現m次
? 等價於{0,1}，表示出現或不出現
+ 等價於{1,}，表示出現至少一次。
* 等價於{0,}，表示出現任意次，有可能不出現。

貪婪匹配和惰性匹配

var regex = /\d{2,5}/g;
var string = "123 1234 12345 123456";
console.log(string.match(regex));
//[ '123', '1234', '12345', '12345' ]

貪婪匹配，就會盡量多的匹配。
惰性匹配，就會盡量少的匹配。

var regex = /\d{2,5}?/g;
var string = "123 1234 12345 123456";
console.log(string.match(regex));
//[ '12', '12', '34', '12', '34', '12', '34', '56' ]

/\d{2,5}?/g 表示 2到 5次都行，當 2個就夠的時候，再也不往下匹配。

經過在量詞後面加?就能實現惰性匹配，全部的惰性匹配情形javascript
- {m,n}?
- {m,}?
- ??
- +?
- *?
.* 是貪婪模式
.*?是惰性模式

多選分支

一個模式能夠實現橫向和縱向模糊匹配。而多選分支能夠支持多個子模式任選其一。
(p1|p2|p3)其中p1、p2和p3是子模式，用|（管道符）分隔，表示其中任何一個。

var regex = /good|nice/g;
var string = "good idea, nice try.";
console.log(string.match(regex));
//[ 'good', 'nice' ]

var regex = /good|goodbye/g;
var string = "goodbye";
console.log( string.match(regex) ); 
// => ["good"]

var regex = /goodbye|good/g;
var string = "goodbye";
console.log( string.match(regex) ); 
// => ["goodbye"]

以上獲得的結果各不相同，分支結構也是惰性的，即當前面的匹配好了，後面的再也不嘗試。css

案例分析

匹配`16`進制顏色值

要求匹配html

#ffbbad
#Fc01DF
#FFF
#ffE

分析java

表示一個16進制字符，能夠用字符組[0-9a-fA-F]
其中字符能夠出現3或6次，須要是用量詞和分支結構
使用分支結構時，須要注意順序

var regex = /#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})/g;
var string = "#ffbbad #Fc01DF #FFF #ffE";
console.log(string.match(regex));
//[ '#ffbbad', '#Fc01DF', '#FFF', '#ffE' ]

匹配時間

要求匹配git

23:59
02:07

分析github

共4位數字，第一位數字能夠是[0-2]
當第1位是2時，第2位能夠是[0-3]，其餘狀況第2位是[0-9]
第3位數字是[0-5]，第4位是[0-9]

var regex = /^([01][0-9]|[2][0-3]):[0-5][0-9]$/g;

要求匹配 7:9，時分前面的 0能夠省略。

var regex = /^(0?[0-9]|1[0-9]|2[0-3]):(0?[0-9]|[1-5][0-9])$/g;
var string = "7:9";
console.log(regex.test(string));
//true

匹配日期

要求匹配 2017-06-10正則表達式

分析算法

年，四位數字便可[0-9]{4}
月，共12個月，分兩種狀況0一、0二、...和十、十一、12，(0[1-9]|1[0-2])
年，最大31天，可用(0[1-9]|[12][0-9]|3[01])

var regex = /^[0-9]{4}-(0[0-9]|1[0-2])-(0[0-9]|[12][0-9]|3[01])$/g;
console.log(regex.test("2017-10-20"));
//true

window操做系統文件路徑

F:\study\javascript\regex\regular expression.pdf
F:\study\javascript\regex\
F:\study\javascript
F:\

分析express

總體模式是：盤符：\文件夾\文件夾\文件夾\
其中匹配F:\，須要使用[a-zA-Z]:\\，其中盤符不區分大小寫，注意\字符須要轉移
文件名或文件夾名，不能包含一些字符字符，此時須要排除字符組[^\\:*<s>|"?\r\n/]來表示合法字符。不能爲空名，至少有一個字符，也就是要使用量詞+。編程
- 匹配文件夾\，可用[^\\:*<>|"?\r\n/]+\\
另外文件夾\，能夠出現任意次。也就是([^\\:*<>|"?\r\n/]+\\)*。其中括號提供子表達式。
路徑的最後一部分能夠是文件夾，沒有\，所以須要添加([^\\:*<>|"?\r\n/]+)?

var regex = /^[a-zA-Z]:\\([^\\:*<>|"?\r\n/]+\\)*([^\\:*<>|"?\r\n/]+)?$/g;

匹配id

要求從 <div id="container" class="main"></div>中提取出 id="container"

var regex = /id=".*?"/;
var string = '<div id="container" class="main"></div>';
console.log(string.match(regex)[0]);
//id="container"

位置匹配

在ES5中共有 6個錨字符

^$\b\B(?=p)(?!p)

`$`和`^`

^（脫字符）匹配開頭，在多行匹配中匹配行開頭
$（美圓符號）匹配結尾，在多行匹配中匹配結尾

把字符串的開頭和結尾用 #替換

var result = "hello".replace(/^|$/g, '#');
console.log(result);
//#hello#

多行匹配模式

var result = "I\nlove\njavascript".replace(/^|$/gm, '#');
console.log(result);
//#I#
// #love#
// #javascript#

`\b`和`\B`

\b是單詞邊界，具體就是 \w和 \W之間的位置，也包括 \w和 \W之間的位置，也包括 \w和 $之間的位置

文件名是[JS] Lesson_01.mp4中的\b

var result = "[JS] Lesson_01.mp4".replace(/\b/g, '#');
console.log(result);
//[#JS#] #Lesson_01#.#mp4#

`(?=p)`和`(?!p)`

(?=p)，其中p是一個子模式，即p前面的位置
(?=l)，表示l字符前面的位置

var result = "hello".replace(/(?=l)/g, '#');
console.log(result);
//he#l#lo

(?!p)是 (?=p)的反向操做

var result = "hello".replace(/(?!l)/g, '#');
console.log(result);
//#h#ell#o#

分別是正向先行斷言和反向先行斷言，具體是 (?<=p)和 (?<!p)

(?=p)就是p前面的那個位置

位置的特性

var result = /^^hello$$$/.test("hello");
console.log(result); 
// => true

案例

不匹配任何東西的正則

/.^/

數字的千位分隔符表示法

把12345678，變成12,345,678

使用 (?=\d{3}$)

var result = "12345678".replace(/(?=\d{3}$)/g, ',');
console.log(result);
//12345,678

逗號出現的位置，要求後面 3個數字一組，也就是 \d{3}至少出現一次

可使用量詞+

var result = "12345678".replace(/(?=(\d{3})+$)/g, ',');
console.log(result);
//12,345,678

匹配其餘案例

匹配位置不是開頭(?!^)

var string1 = "12345678";
var string2 = "123456789";
var reg = /(?!^)(?=(\d{3})+$)/g;
var result1 = string1.replace(reg, ',');
console.log(result1);
//12,345,678
var result2 = string2.replace(reg, ',');
console.log(result2);
//123,456,789

驗證密碼問題

密碼長度6-12位，由數字、小寫字符和大寫字母組成，但必須至少包括2種字符。

簡化

不考慮「但至少包括2種字符」這個條件

var reg = /^[0-9A-Za-z]{6,12}$/;

判斷是否含有某一種字符

若是要求必須包含數字，可使用 (?=.*[0-9])

var reg = /(?=.*[0-9])^[0-9A-Za-z]{6,12}$/;

同時包含具備兩種字符

同時包含數字和小寫字母，能夠用 (?=.*[0-9](?=.*[a-z]))

var reg = /(?=.*[0-9])(?=.*[a-z])^(0-9A-Za-z){6,12}$/;

同時包含數字和小寫字母
同時包含數字和大寫字母
同時包含小寫字母和大寫字母
同時包含數字、小寫字母和大寫字母

var reg = /((?=.*[0-9])(?=.*[a-z])|(?=.*[0-9])(?=.*[A-Z])|(?=.*[a-z])(?=.*[A-Z]))^[0-9A-Za-z]{6,12}$/;

括號的做用

括號提供分組
引用某個分組，有兩種情形：在JS中引用，在正則表達式中應用

分組和分支結構

分組

/a+/匹配連續出現的a，要匹配連續出現的ab時，須要使用/(ab)+/
括號提供分組功能，使量詞+做用於ab這個總體

var regex = /(ab)+/g;
var string = "ababa abbb ababab";
console.log(string.match(regex));
//[ 'abab', 'ab', 'ababab' ]

分支結構

多選分支結構(p1|p2)中括號的做用是提供了子表達式的全部可能

I love JavaScript
I love Regular Expression

var regex = /^I love (JavaScript|Regular Expression)$/;
console.log( regex.test("I love JavaScript") );
console.log( regex.test("I love Regular Expression") );
// => true
// => true

引用分組

括號的重要做用，能夠進行數據提取，以及更強大的替換操做

匹配日期yyyy-mm-dd

提取數據

提取出年、月、日

var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2018-06-18";
console.log(string.match(regex));
//[ '2018-06-18', '2018', '06', '18', index: 0, input: '2018-06-18' ]

match返回的一個數組，第一個元素是總體匹配結果，而後是各個分組（括號）匹配的內容，而後是匹配下標，最後是輸入的文本。（正則是否有修飾符 g， match返回的數組格式是不同）

可使用正則對象的exec方法

可使用構造函數的全局屬性 $1至 $9來獲取

var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";

regex.test(string); // 正則操做便可，例如
//regex.exec(string);
//string.match(regex);

console.log(RegExp.$1); // "2017"
console.log(RegExp.$2); // "06"
console.log(RegExp.$3); // "12"

替換

把 yyyy-mm-dd格式，替換成 mm/dd/yyyy

var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";
var result = string.replace(regex, "$2/$3/$1");
console.log(result); 
// => "06/12/2017"

其中 replace中第二個參數用 $1、 $2、 $3指代相應的分組。等價於 var regex=/(\d{4})-(\d{2})-(\d{2})/

反向引用

寫一個正則支持匹配如下三種格式：

2016-06-12
2016-06-12
2016.06.12

要求分割符先後一致，使用反向引用

var regex = /\d{4}(-|\/|\.)\d{2}\1\d{2}/;
var string1 = "2017-06-12";
var string2 = "2017/06/12";
var string3 = "2017.06.12";
var string4 = "2016-06/12";
console.log( regex.test(string1) ); // true
console.log( regex.test(string2) ); // true
console.log( regex.test(string3) ); // true
console.log( regex.test(string4) ); // false

\1，表示的引用以前的分組(-|\/|\.)。無論它匹配到什麼（好比-），\1都匹配那個一樣的具體某個字符
\2和\3分別指代第二個和第三個分組

括號嵌套

以左括號（開括號）爲準

var regex = /^((\d)(\d(\d)))\1\2\3\4$/;
var string = "1231231233";
console.log( regex.test(string) ); // true
console.log( RegExp.$1 ); // 123
console.log( RegExp.$2 ); // 1
console.log( RegExp.$3 ); // 23
console.log( RegExp.$4 ); // 3

正則匹配模式

第一個字符是數字，好比說1，
第二個字符是數字，好比說2，
第三個字符是數字，好比說3，
接下來的是1，是第一個分組內容，那麼看第一個開括號對應的分組是什麼，是123，
接下來的是2，找到第2個開括號，對應的分組，匹配的內容是1，
接下來的是3，找到第3個開括號，對應的分組，匹配的內容是23，
最後的是4，找到第3個開括號，對應的分組，匹配的內容是3。

引用不存在的分組

反向引用，引用前面的分組，在正則裏引用了不存在的分組，正則不會報錯，只是匹配反向引用的字符自己

非捕獲分組

前面出現的分組，都會捕獲它們匹配的數據，以便後續引用，所以也稱它們是捕獲型分組
非捕獲分組?:p

var regex = /(?:ab)+/g;
var string = "ababa abbb ababab";
console.log(string.match(regex));
//[ 'abab', 'ab', 'ababab' ]

案例

字符串`trim`方法模擬

trim方法是去掉字符串的開頭和結尾的空白符

第一種，匹配到開頭和結尾的空白符，而後替換成空白符

function trim(str) {
    return str.replace(/^\s+|\s+$/g, '')
}

第二種，匹配整個字符串，而後用引用來提取出相應的數據

function trim(str) {
    return str.replace(/^\s*(.*?)\s*$/g, "$1");
}

這裏使用了惰性匹配 *?，否則也會匹配最後一個空格以前的全部空格

將每一個單詞的首字母轉換成大寫

function titleize(str) {
    return str.toLowerCase().replace(/(?:^|\s)\w/g, function (c) {
        return c.toUpperCase();
    })
}
console.log(titleize('my name is epeli'));
//My Name Is Epeli

思路是找到每一個單詞的首字母，這裏不適用非捕獲匹配也是能夠的

駝峯化

function camelize(str) {
    return str.replace(/[-_\s]+(.)?/g, function (match, c) {
        return c ? c.toUpperCase() : '';
    })
}
console.log(camelize('-moz-transform'));
//MozTransform

其中分組 (.)表示首字母。單詞的界定是，前面的字符能夠是多個連字符、下劃線以及空白符。
正則後面的？的目的，是爲了應對str尾部的字符可能不是單詞字符。

中劃線化

駝峯化的逆過程

function dasherize(str) {
    return str.replace(/([A-Z])/g,'-$1').replace(/[-_\s]+/g,'-').toLowerCase();
}
console.log(dasherize('MozTransform'));
//-moz-transform

`html`轉義和反轉義

匹配成對標籤

要求匹配

<title>regular expression</title>
<p>laoyao bye bye</p>

不匹配

<title>wrong!</p>

匹配一個開標籤，使用正則<[^>]+>
匹配一個閉標籤，使用<\/[^>]+>

要求匹配成對標籤，須要使用反向引用

var regex = /<([^>]+)>[\d\D]*<\/\1>/;
var string1 = "<title>regular expression</title>";
var string2 = "<p>laoyao bye bye</p>";
var string3 = "<title>wrong!</p>";
console.log(regex.test(string1)); // true
console.log(regex.test(string2)); // true
console.log(regex.test(string3)); // false

其中開標籤<[^>]+>改爲<([^>]+)>，使用括號的目的是爲了後面使用反向引用，而提供分組
閉標籤使用了反向引用<\/\1>
[\d\D]這個字符是數字或不是數字，也就是匹配任意字符

正則表達式回溯法

沒有回溯的匹配

當目標字符串是 abbbc時，就沒有所謂的「回溯」。

有回溯的匹配

若是目標字符串是 abbc，中間就有回溯

常見的回溯形式

回溯法也稱試探法，基本思想：從問題的某一種狀態（初始狀態）出發，搜索從這種狀態出發所能達到的全部「狀態」，當一條路走到「盡頭」的時候，再後退一步或若干步，從另外一種可能狀態出發，繼續搜索，直到全部的路徑（狀態）都試探過。這種不斷前進、不斷回溯尋找解的方法，稱做「回溯法」。
本質上就是深度優先搜索算法。其中退到以前的某一步這個過程，成爲「回溯」。

正則表達式產生回溯的地方

貪婪量詞

var string = "12345";
var regex = /(\d{1,3})(\d{1,3})/;
console.log(string.match(regex));
//[ '12345', '123', '45', index: 0, input: '12345' ]

前面的 \d{1,3}匹配的是 123，後面的 \d{1,3}匹配的是 45

惰性量詞

惰性量詞就是在貪婪量詞後面加個問好。表示儘量少的匹配。

var string = "12345";
var regex = /(\d{1,3}?)(\d{1,3})/;
console.log( string.match(regex) );
// => ["1234", "1", "234", index: 0, input: "12345"]

其中\d{1,3}?只匹配到一個字符1，然後面的\d{1,3}匹配了234
雖然惰性量詞不貪婪，但也會有回溯現象。

分支結構

分支也是惰性的，好比 /can|candy/，去匹配字符串 candy，獲得的結果是 can，由於分支會一個一個嘗試，若是前面的知足，後面就不會再試驗。
分支結構，可能前面的子模式會造成了局部匹配，若是接下來表達式總體不匹配，仍會繼續嘗試剩下的分支。

正則表達式的拆分

結構和操做符

在正則表達式中，操做符都體如今結構中，即由特殊字符和匹配字符所表明的一個特殊總體。

JS正則表達式中，都有哪些結構？

字符字面量、字符組、量詞、錨字符、分組、選擇分支、反向引用

具體含義

字面量，匹配一個具體字符，包括不用轉義的和須要轉義的。
- 好比a匹配字符a，\n匹配換行符，\.匹配小數點
字符組，匹配一個字符，能夠是多種可能之一，
- 好比[0-9]，表示匹配一個數字，\d是簡寫形式。
- 另外還有反義字符組，表示能夠是除了特定字符以外任何一個字符，好比[^0-9]表示一個非數字字符，也有\D的簡寫形式
量詞，表示一個字符連續出現，好比a{1,3}表示a字符連續出現3次。
- 常見簡寫形式，a+表示a字符連續出現至少一次
錨點，匹配一個位置，而不是字符。
- 好比^匹配字符串的開頭，
- 好比\b匹配單詞邊界
- 好比(?=\d)表示數字前面的位置
分組，用括號表示一個總體，
- 好比(ab)+表示ab兩個字符連續出現屢次，也可使用非捕獲分組(?:ab)+
分支，多個子表達式多選一
- 好比abc|bcd表示式匹配abc或bcd字符子串
反向引用，好比\2表示引用第2個分組

其中涉及到的操做符有

轉義符 \
括號和方括號 (...)、(?:...)、(?=...)、(?!...)、[...]
量詞限定符 {m}、{m,n}、{m,}、?、*、+
位置和序列 ^、$、\元字符、通常字符
管道符 |

操做符的優先級從上至下，由高到低

/ab?(c|de*)+|fg/

因爲括號的存在，(c|de*)是一個總體結構
在(c|de*)中注意其中的量詞，所以e是一個總體結構
由於分支結構|優先級最低，所以c是一個總體，而de*是另外一個總體
同理，整個正則分紅了a、b?、(...)+、f、g。而因爲分支的緣由，又能夠分紅ab?(c|de*)+和fg兩部分

注意要點

匹配字符串總體問題

要匹配整個字符串，在正則先後中加上錨字符^和$

量詞連綴問題

每一個字符爲a、b、c任選其一
字符串的長度是3的倍數

/([abc]{3})/

元字符轉義問題

元字符，就是正則中特殊含義的字符
全部結構裏，用到的元字符：
- ^、$、.、*、+、?、|、|、/、()、[]、{}、=、!、:、-、,

當匹配上面的字符自己時，能夠一概轉義：

var string = "^$.*+?|\\/[]{}=!:-,";
var regex = /\^\$\.\*\+\?\|\\\/\[\]\{\}\=\!\:\-\,/;
console.log(regex.test(string));
// => true

其中string中的\字符也要轉義
另外在string中也能夠把每一個字符轉義，轉義後的結果仍然是自身

字符組中的元字符

跟字符組相關的元字符有[] `、^ 、- ，須要在會引發歧義的地方進行轉義。例如開頭的^`必須轉義，否則會把整個字符組，當作反義字符組。

var string = "^$.*+?|\\/[]{}=!:-,";
var regex = /[\^$.*+?|\\/\[\]{}=!:\-,]/g;
console.log( string.match(regex) );

案例分析

身份證

/^(\d{15}|\d{17}[\dxX])$/

由於 |的優先級最低，因此正則分紅了兩部分 \d{15}和 \d{17}[\dxX]

\d{15}表示15位連續數字
\d{17}[\dxX]表示17位連續數字，最後一位能夠是數字或大小寫字母x

IPV4地址

(0{0,2}\d|0?\d{2}|1\d{2}|2[0-4]\d|25[0-5])(0{0,2}\d|0?\d{2}|1\d{2}|2[0-4]\d|25[0-5])

它是一個多選結構，分紅5部分

0{0-2}\d，匹配一位數，包括0補齊。好比9、09、009
0?\d{2}，匹配兩位數，包括0補齊，也包括一位數
1\d{2}，匹配100到199
2[0-4]\d，匹配200-249
25[0-5]，匹配250-255

正則表達式編程

四種操做

驗證

驗證時正則表達式最直接的應用，好比表單驗證

判斷一個字符串中是否有數字

使用search

var regex = /\d/;
var string = "abc123";
console.log(!!~string.search(regex));
//true

使用test

var regex = /\d/;
var string = "abc123";
console.log( regex.test(string) );
// => true

使用match

var regex = /\d/;
var string = "abc123";
console.log( !!string.match(regex) );
// => true

使用exec

var regex = /\d/;
var string = "abc123";
console.log( !!regex.exec(string) );
// => true

其中，最經常使用的是 test

切分

切分，就是把目標字符串切成段，例如JS中的split
- 好比目標字符串html,css,javascript，按逗號來切分

var regex = /,/;
var string = "html,css,javascript";
console.log(string.split(regex));
//[ 'html', 'css', 'javascript' ]

日期格式

2018/06/20
2018.06.20
2018-06-20

可使用split切出年月日

var regex = /\D/;
console.log("2018/06/20".split(regex));
console.log("2018.06.20".split(regex));
console.log("2018-06-20".split(regex));
// [ '2018', '06', '20' ]
// [ '2018', '06', '20' ]
// [ '2018', '06', '20' ]

提取

此時正則一般要使用分組引用（分組捕獲）功能

match

var regex = /^(\d{4})\D(\d{2})\D(\d{2})$/;
var string = "2018-06-20";
console.log(string.match(regex));
//[ '2018-06-20', '2018', '06', '20', index: 0, input: '2018-06-20' ]

exec

var regex = /^(\d{4})\D(\d{2})\D(\d{2})$/;
var string = "2018-06-20";
console.log(regex.exec(string));
//[ '2018-06-20', '2018', '06', '20', index: 0, input: '2018-06-20' ]

test

var regex = /^(\d{4})\D(\d{2})\D(\d{2})$/;
var string = "2018-06-20";
regex.test(string);
console.log(RegExp.$1, RegExp.$2, RegExp.$3);
//2018 06 20

search

var regex = /^(\d{4})\D(\d{2})\D(\d{2})$/;
var string = "2018-06-20";
string.search(regex);
console.log(RegExp.$1, RegExp.$2, RegExp.$3);
//2018 06 20

replace

var regex = /^(\d{4})\D(\d{2})\D(\d{2})$/;
var string = "2018-06-20";
var date = [];
string.replace(regex, function (match, year, month, day) {
    date.push(year, month, day);
});
console.log(date);
//[ '2018', '06', '20' ]

其中最經常使用的是 match

替換

把日期格式，從 yyyy-mm-dd替換成 yyyy/mm/dd：

var string = "2018-06-20";
var today = new Date(string.replace(/-/g, "/"));
console.log(today);
//2018-06-19T16:00:00.000Z

用於正則操做的方法，共有 6個，字符串實例 4個，正則實例 2個

string#search
string#split
string#match
string#replace
RegExp#test
RegExp#exec

search和match的參數問題

字符串實例的4個方法參數都支持正則和字符串
但search和match把字符串轉換爲正則

var string = "2018.06.20";

console.log(string.search("."));//0
//須要修改爲下列形式之一
console.log(string.search("\\."));//4
console.log(string.search(/\./));//4

console.log(string.match("."));
//[ '2', index: 0, input: '2018.06.20' ]
//須要修改爲下列形式之一
console.log(string.match("\\."));
//[ '.', index: 4, input: '2018.06.20' ]
console.log(string.match(/\./));
//[ '.', index: 4, input: '2018.06.20' ]

console.log(string.split("."));
//[ '2018', '06', '20' ]

console.log(string.replace(".", "/"));
//2018/06.20

match返回結果的格式問題

match返回結果的格式，跟正則對象是否有修飾符 g有關

var string = "2018.06.20";
var regex1=/\b(\d+)\b/;
var regex2=/\b(\d+)\b/g;
console.log(string.match(regex1));
//[ '2018', '2018', index: 0, input: '2018.06.20' ]
console.log(string.match(regex2));
//[ '2018', '06', '20' ]

沒有g，返回的是標準匹配格式，數組的第一個元素時總體匹配的內容，接下來是分組捕獲的內容，而後是總體匹配的第一個下標，最後的輸入的目標字符串
有g，返回的是全部匹配的內容
當沒有匹配時，無論有沒有g都返回null

exec比match更強大

當正則沒有 g時，使用 match返回的信息比較多。可是有 g後，就沒有關鍵信息 index
而 exec方法就能解決這個問題，它能接着上一次匹配後繼續匹配

var string = "2018.06.20";
var regex = /\b(\d+)\b/g;
console.log(regex.exec(string));
//[ '2018', '2018', index: 0, input: '2018.06.20' ]
console.log(regex.lastIndex);//4
console.log(regex.exec(string));
// [ '06', '06', index: 5, input: '2018.06.20' ]
console.log(regex.lastIndex);//7
console.log(regex.exec(string));
//[ '20', '20', index: 8, input: '2018.06.20' ]
console.log(regex.lastIndex);//10
console.log(regex.exec(string));//null
console.log(regex.lastIndex);//0

test總體匹配時須要使用^和$

test是看目標字符串中是否有子串匹配正則，即有部分匹配便可。

要總體匹配，正則先後須要添加開頭和結尾

console.log( /123/.test("a123b") );
// => true
console.log( /^123$/.test("a123b") );
// => false
console.log( /^123$/.test("123") );
// => true

split相關注意事項

第一，它能夠有第二個參數，表示結果數組的最大長度

var string = "html,css,javascript";
console.log( string.split(/,/, 2) );
// =>["html", "css"]

第二，正則使用分組時，結果數組中是包含分隔符的

var string = "html,css,javascript";
console.log( string.split(/(,)/) );
// =>["html", ",", "css", ",", "javascript"]

replace是很強大的

replace有兩種使用形式，它的第二個參數，能夠是字符串，也能夠是函數。

當第二個參數是字符串時，以下的字符有特殊的含義：

$1,$2,...,$99 匹配第1~99個分組裏捕獲的文本
$& 匹配到的子串文本
$` 匹配到的子串的左邊文本
$' 匹配到的子串的右邊文本
$$ 美圓符號

例如，把"2,3,5"，變成"5=2+3"：

var result = "2,3,5".replace(/(\d+),(\d+),(\d+)/, "$3=$1+$2");
console.log(result);
// => "5=2+3"

當第二個參數是函數時，該回調函數的參數具體：

"1234 2345 3456".replace(/(\d)\d{2}(\d)/g, function(match, $1, $2, index, input) {
    console.log([match, $1, $2, index, input]);
});
// => ["1234", "1", "4", 0, "1234 2345 3456"]
// => ["2345", "2", "5", 5, "1234 2345 3456"]
// => ["3456", "3", "6", 10, "1234 2345 3456"]

修飾符