摘要：返回值一個(gè)新的對(duì)象，具有指定的模式和標(biāo)志。參數(shù)作用正則表達(dá)式規(guī)定匹配的類型。如果未找到匹配，則返回值為。返回值請(qǐng)注意，無(wú)論是否是全局模式，都會(huì)把完整的細(xì)節(jié)添加到它返回的數(shù)組中。字符串或正則表達(dá)式，從該參數(shù)指定的地方分割。

PS:2018/03/27 優(yōu)化文章格式,新增部分測(cè)試代碼
說(shuō)起正則其實(shí)大家都會(huì)經(jīng)常接觸到，前端小到校驗(yàn)，大到插件隨處可見，簡(jiǎn)單的方法也能實(shí)現(xiàn)需求，不過(guò)缺乏靈活性，一旦需要復(fù)雜化，沒(méi)有什么比正則更加合適的技術(shù)了。這也算是程序員的一道檻了。
以下資料截圖都來(lái)源于JavaScript RegExp 對(duì)象

表示正則表達(dá)式，它是對(duì)字符串執(zhí)行模式匹配的強(qiáng)大工具。

返回值：
一個(gè)新的 RegExp 對(duì)象，具有指定的模式和標(biāo)志。如果參數(shù) pattern 是正則表達(dá)式而不是字符串，那么 RegExp() 構(gòu)造函數(shù)將用與指定的 RegExp 相同的模式和標(biāo)志創(chuàng)建一個(gè)新的 RegExp 對(duì)象。
如果不用 new 運(yùn)算符，而將 RegExp() 作為函數(shù)調(diào)用，那么它的行為與用 new 運(yùn)算符調(diào)用時(shí)一樣，只是當(dāng) pattern 是正則表達(dá)式時(shí)，它只返回 pattern，而不再創(chuàng)建一個(gè)新的 RegExp 對(duì)象。

拋出：
SyntaxError - 如果 pattern 不是合法的正則表達(dá)式，或 attributes 含有 "g"、"i" 和 "m" 之外的字符，拋出該異常。
TypeError - 如果 pattern 是 RegExp 對(duì)象，但沒(méi)有省略 attributes 參數(shù)，拋出該異常。

用于在腳本執(zhí)行過(guò)程中編譯正則表達(dá)式,也可用于改變和重新編譯正則表達(dá)式(將正則表達(dá)式編譯為內(nèi)部格式，從而更快地執(zhí)行)。

實(shí)際上compile就是個(gè)修改編譯作用,不能直接用于匹配正則

var str1 = "Hello World",
  str2 = "Hello World",
  patt = /man/g;
//正常正則
console.time();
str1 = str1.replace(patt, "person");
console.timeEnd();
//編譯后的正則
console.time();
patt.compile(patt);
str2 = str2.replace(patt, "person");
console.timeEnd();

// default: 2.818ms
// default: 0.096ms

性能提升還是挺明顯的

用于檢索字符串中的正則表達(dá)式的匹配。

返回值： 返回一個(gè)數(shù)組，其中存放匹配的結(jié)果。如果未找到匹配，則返回值為 null。
說(shuō)明： 調(diào)用 RegExp 對(duì)象 r 的 test() 方法，并為它傳遞字符串 s，與這個(gè)表示式是等價(jià)的：r.exec(s) != null ---> r.test(s)。
重要事項(xiàng)： 如果在一個(gè)字符串中完成了一次模式匹配之后要開始檢索新的字符串，就必須手動(dòng)地把 lastIndex 屬性重置為 0。
返回值： 請(qǐng)注意，無(wú)論 RegExpObject 是否是全局模式，exec() 都會(huì)把完整的細(xì)節(jié)添加到它返回的數(shù)組中。這就是 exec() 與 match() 的不同之處，后者在全局模式下返回的信息要少得多。因此我們可以這么說(shuō)，在循環(huán)中反復(fù)地調(diào)用 exec() 方法是唯一一種獲得全局模式的完整模式匹配信息的方法。

var str = "Every man in the world! Every woman on earth!",
  patt = /man/g,
  result;

while ((result = patt.exec(str)) != null) {
  console.log(result);
  console.log(patt.lastIndex);
}

// [ "man",
//   index: 6,
//   input: "Every man in the world! Every woman on earth!",
//   groups: undefined ]
// 9
// [ "man",
//   index: 32,
//   input: "Every man in the world! Every woman on earth!",
//   groups: undefined ]
// 35

index 屬性聲明的是匹配文本的位置。input 屬性則存放的是被檢索的字符串 string。

用于檢測(cè)一個(gè)字符串是否匹配某個(gè)模式.

返回值： 如果字符串 string 中含有與 RegExpObject 匹配的文本，則返回 true，否則返回 false。
說(shuō)明： 調(diào)用 RegExp 對(duì)象 r 的 test() 方法，并為它傳遞字符串 s，與這個(gè)表示式是等價(jià)的：r.exec(s) != null ---> r.test(s)。

var str = "Every man in the world! Every woman on earth!",
  patt = /man/g;

console.log(patt.test(str)); // true

用于檢索字符串中指定的子字符串，或檢索與正則表達(dá)式相匹配的子字符串。

返回值： stringObject 中第一個(gè)與 regexp 相匹配的子串的起始位置，如果沒(méi)有找到任何匹配的子串，則返回 -1。
說(shuō)明： search() 方法不執(zhí)行全局匹配，它將忽略標(biāo)志 g。它同時(shí)忽略 regexp 的 lastIndex 屬性，并且總是從字符串的開始進(jìn)行檢索，這意味著它總是返回 stringObject 的第一個(gè)匹配的位置。

var str = "How Are you doing today?How Are you doing today?"
console.log(str.search(/are/gi)); // 4

可在字符串內(nèi)檢索指定的值，或找到一個(gè)或多個(gè)正則表達(dá)式的匹配。

返回值： 存放匹配結(jié)果的數(shù)組。該數(shù)組的內(nèi)容依賴于 regexp 是否具有全局標(biāo)志 g。
說(shuō)明： match() 方法將檢索字符串 stringObject，以找到一個(gè)或多個(gè)與 regexp 匹配的文本。這個(gè)方法的行為在很大程度上有賴于 regexp 是否具有標(biāo)志 g。
如果 regexp 沒(méi)有標(biāo)志 g，那么 match() 方法就只能在 stringObject 中執(zhí)行一次匹配。如果沒(méi)有找到任何匹配的文本， match() 將返回 null。否則，它將返回一個(gè)數(shù)組，其中存放了與它找到的匹配文本有關(guān)的信息。該數(shù)組的第 0 個(gè)元素存放的是匹配文本，而其余的元素存放的是與正則表達(dá)式的子表達(dá)式匹配的文本。除了這些常規(guī)的數(shù)組元素之外，返回的數(shù)組還含有兩個(gè)對(duì)象屬性。index 屬性聲明的是匹配文本的起始字符在 stringObject 中的位置，input 屬性聲明的是對(duì) stringObject 的引用。
如果 regexp 具有標(biāo)志 g，則 match() 方法將執(zhí)行全局檢索，找到 stringObject 中的所有匹配子字符串。若沒(méi)有找到任何匹配的子串，則返回 null。如果找到了一個(gè)或多個(gè)匹配子串，則返回一個(gè)數(shù)組。不過(guò)全局匹配返回的數(shù)組的內(nèi)容與前者大不相同，它的數(shù)組元素中存放的是 stringObject 中所有的匹配子串，而且也沒(méi)有 index 屬性或 input 屬性。
注意： 在全局檢索模式下，match() 即不提供與子表達(dá)式匹配的文本的信息，也不聲明每個(gè)匹配子串的位置。如果您需要這些全局檢索的信息，可以使用 RegExp.exec()。

var str = "How are you doing today?How are you doing today?"
console.log(str.match(/ a/));
console.log(str.match(/a.e/g));
// [ " a",
//   index: 3,
//   input: "How are you doing today?How are you doing today?",
//   groups: undefined ]
// [ "are", "are" ]

用于在字符串中用一些字符替換另一些字符，或替換一個(gè)與正則表達(dá)式匹配的子串。

返回值： 一個(gè)新的字符串，是用 replacement 替換了 regexp 的第一次匹配或所有匹配之后得到的。

var str = "How are you doing today?"
console.log(str.replace(/ /g, "|"));
console.log(str.replace(/ /g, function () {
  return "-----"
}));
console.log(str.replace(/a.e/g, "were"));

// How|are|you|doing|today?
// How-----are-----you-----doing-----today?
// How were you doing today?

用于把一個(gè)字符串分割成字符串?dāng)?shù)組。

返回值： 一個(gè)字符串?dāng)?shù)組。該數(shù)組是通過(guò)在 separator 指定的邊界處將字符串 stringObject 分割成子串創(chuàng)建的。返回的數(shù)組中的字串不包括 separator 自身。

            但是，如果 separator 是包含子表達(dá)式的正則表達(dá)式，那么返回的數(shù)組中包括與這些子表達(dá)式匹配的字串（但不包括與整個(gè)正則表達(dá)式匹配的文本）。

var str = "How are you doing today?"
console.log(str.split(" ", 3));
console.log(str.split(" "));
console.log(str.split("are"));

// [ "How", "are", "you" ]
// [ "How", "are", "you", "doing", "today?" ]
// [ "How ", " you doing today?" ]

var str = "abcdaabc164984616464646464AAWEGAWGAG";

console.log(str.match(/[a-f]/g).join(""));
console.log(str.match(/[A-F]/g).join(""));
console.log(str.match(/[A-z]/g).join(""));
console.log(str.match(/[0-9]/g).join(""));
console.log(str.match(/[adgk]/g).join(""));
console.log(str.match(/[^a-z]/g).join(""));
console.log(str.match(/(r|b|g)/g).join(""));

// abcdaabc
// AAEAA
// abcdaabcAAWEGAWGAG
// 164984616464646464
// adaa
// 164984616464646464AAWEGAWGAG
// bb

首先看看通用并且簡(jiǎn)單的幾個(gè)元字符.

var str = "Every man in the world! 1, 2, 3, Let"s go!!";

console.log(str.match(/m.n/g).join(""));
console.log(str.match(/w/g).join(""));
console.log(str.match(/W/g).join(""));
console.log(str.match(/d/g).join(""));
console.log(str.match(/D/g).join(""));
console.log(str.match(/s/g).join(""));
console.log(str.match(/S/g).join(""));

// man
// Everymanintheworld123Letsgo
//     ! , , , " !!
// 123
// Every man in the world! , , , Let"s go!!
         
// Everymanintheworld!1,2,3,Let"sgo!!

b 和 B元字符匹配單詞邊界與否意思是在單詞邊界匹配的位置，單詞字符后面或前面不與另一個(gè)單詞字符直接相鄰。請(qǐng)注意，匹配的單詞邊界并不包含在匹配中。換句話說(shuō)，匹配的單詞邊界的長(zhǎng)度為零。（不要與 [b] 混淆。）

var str = "If you love yourself, you can jump into your life from a springboard of self-confidence. If you love yourself, you can say what you want to say, go where you want to go.";

console.log(str.match(/your/));//->里面的your
console.log(str.match(/yourB/));//->里面的yourself,yourself

// [ "your",
//   index: 40,
//   input: "If you love yourself, you can jump into your life from a springboard of self-confidence. If you love yourself, you can say what you want to say, go where you want to go.",
//   groups: undefined ]
// [ "your",
//   index: 12,
//   input: "If you love yourself, you can jump into your life from a springboard of self-confidence. If you love yourself, you can say what you want to say, go where you want to go.",
//   groups: undefined ]

進(jìn)制數(shù)我沒(méi)用,不太了解,下面都是指W

var str = "If you love yourself, you can jump into your life from a springboard of self-confidence. If you love yourself, you can say what you want to say, go where you want to go.";

console.log(str.match(/127/gi));//以八進(jìn)制數(shù) xxx 規(guī)定的字符。
console.log(str.match(/x57/gi));//以十六進(jìn)制數(shù) dd 規(guī)定的字符
console.log(str.match(/u0057/gi));//以十六進(jìn)制數(shù) xxxx 規(guī)定的 Unicode 字符。

其他就字面意思,不解釋了.

var str = "n, On, Oon, Ooon";

console.log(str.match(/o+n/gi));
console.log(str.match(/o*n/gi));
console.log(str.match(/o?n/gi));

console.log(str.match(/o{1}n/gi));
console.log(str.match(/o{1,2}n/gi));
console.log(str.match(/o{3,}n/gi));

console.log(str.match(/^n/gi));
console.log(str.match(/on$/gi));

console.log(str.match(/O(?=on)/));
console.log(str.match(/O(?!on)/));

// [ "On", "Oon", "Ooon" ]
// [ "n", "On", "Oon", "Ooon" ]
// [ "n", "On", "on", "on" ]
// [ "On", "on", "on" ]
// [ "On", "Oon", "oon" ]
// [ "Ooon" ]
// [ "n" ]
// [ "on" ]
// [ "O", index: 7, input: "n, On, Oon, Ooon", groups: undefined ]
// [ "O", index: 3, input: "n, On, Oon, Ooon", groups: undefined ]

正則表達(dá)式一個(gè)最重要的特性就是將匹配成功的模式的某部分進(jìn)行存儲(chǔ)供以后使用這一能力。 對(duì)一個(gè)正則表達(dá)式模式或部分模式兩邊添加圓括號(hào)()可以把這部分表達(dá)式存儲(chǔ)到一個(gè)臨時(shí)緩沖區(qū)中。所捕獲的每個(gè)子匹配都按照在正則表達(dá)式模式中從左至右所遇到的內(nèi)容按順序存儲(chǔ)。 存儲(chǔ)子匹配的緩沖區(qū)編號(hào)從1開始，連續(xù)編號(hào)至最大99個(gè)子表達(dá)式。 每個(gè)緩沖區(qū)都可以使用"n"(或用"$n")訪問(wèn)，其中n為1至99的阿拉伯?dāng)?shù)字，用來(lái)按順序標(biāo)識(shí)特定緩沖區(qū)(子表達(dá)式)。

var str = "I am the best of the best in the best place";
console.log(str.match(/(the best).*1/g)) //["the best of the best in the best"]

注意的是它只能匹配重復(fù)的規(guī)則

var str = "aa bb ab";
console.log(str.match(/(w)1/g))//["aa", "bb"]
console.log(str.match(/(?:w)1/g))//null

意思前面匹配到a后面只能也是a,哪怕它定制的規(guī)則的所有單詞
下面是或的簡(jiǎn)短寫法

var str = "better best";

console.log(str.match(/(better|best)/g));
console.log(str.match(/be(?:tter|st)/g));

貪婪模式,它會(huì)盡可能匹配多的字符
懶惰模式,它會(huì)盡可能匹配少的字符
寫法區(qū)別就是貪婪模式后面加上?就變成懶惰模式了

var str = "
123
abc
";

console.log(str.match(/
S*
/)); // ["
123
abc
", index: 0, input: "
123
abc
"]
console.log(str.match(/
S*?
/)); // ["
123
", index: 0, input: "
123
abc
"]

正則匹配還有很多強(qiáng)大的功能位,只講到這里一半是因?yàn)樗接邢?平常用到也就這些.另一半是在javascript里支持的功能也是有限,現(xiàn)階段講了也用不到就算了,

---------------------------------------------------實(shí)戰(zhàn)篇-----------------------------------------------------------------------------

現(xiàn)在開始來(lái)寫正題了.先寫個(gè)簡(jiǎn)單的日期匹配練手,最基礎(chǔ)的數(shù)字匹配

var str = "2017.04.10 2017-4-10 2017/04/1";

//基礎(chǔ)寫法
console.log(str.match(/[0-9]{4}(.|-|/)[0-9]{1,2}(.|-|/)[0-9]{1,2}/g));
//元字符寫法
console.log(str.match(/d{4}.d{1,2}.d{1,2}/g));
//量詞寫法
console.log(str.match(/d{4}(.d+){2}/g));

// [ "2017.04.10", "2017-4-10", "2017/04/1" ]
// [ "2017.04.10", "2017-4-10", "2017/04/1" ]
// [ "2017.04.10", "2017-4-10", "2017/04/1" ]

常見的支付金額校驗(yàn)，純數(shù)字大于0最多兩個(gè)小數(shù)

var reg = /^(0|[1-9]d*)?(.d{1,2})?$/g;

console.log("023".match(reg));
console.log(".5".match(reg));
console.log("255".match(reg));
console.log("255.1".match(reg));
console.log("255.31".match(reg));
console.log("255.313".match(reg));

// null
// [ ".5" ]
// [ "255" ]
// [ "255.1" ]
// [ "255.31" ]
// null

這個(gè)有點(diǎn)復(fù)雜,折騰很久,在網(wǎng)上找到好多的答案其實(shí)都是錯(cuò)漏百出的,例如
/^d*.?d{0,2}$/: 它能匹配012這種不正常格式
/(^1-9?(.[0-9]{1,2})?$)|(^(0){1}$)|(^[0-9].0-9?$)/: 這種不用細(xì)看都知道不是合適答案,也就相當(dāng)于分拆出每個(gè)可能,發(fā)揮不出正則的優(yōu)勢(shì),我都沒(méi)往下看了

逐步分析一下我自己寫的：
[1-9]d*：開頭衹能1-9,后面可不帶或帶多個(gè)數(shù)字
^(0|[1-9]d*)?: 或者0開頭,也能省略開頭
(.d{1,2})?$: 兩個(gè)小數(shù)可要可不要

之前還遇到一個(gè)面試題是替換字符串內(nèi)的變量,如下

var str = "Hello ${name},you are so ${praise}",
  obj = {
    name: "高圓圓",
    praise: "goodly"
  };

console.log(str.replace(/${([^{}]+)}/g, function (match, key) {
  return obj[key]
}))
// Hello 高圓圓,you are so goodly

---------------------------------------------------尾聲-----------------------------------------------------------------------------
其實(shí)應(yīng)該還有很多東西可以說(shuō),但是目前先熟悉掌握這些就夠了,過(guò)段時(shí)間我有時(shí)間再繼續(xù)寫些進(jìn)階知識(shí)