【轉載】正則表達式基礎

### 基本語法

【基礎】

【界定符】 // #[]#

【原子】    原子：正則表達式中的最小匹配單位，一般它只是Unicode編碼表中的某一個字符。原子分爲2種，可見和不可見。
ASCII就是編碼英文的26個字母和一些常見的符號，以後擴展了一半。總之是一個字節來作編碼，大於128的部分是一些特殊符號。但ASCII是沒法編碼別的東西的，好比說是不存在「中文的ascii碼須要2個字符」這種說法的。ASCII就只有一個字節。
Unicode是足夠編碼地球上全部的語言了，因此ASCII中所能表示的，Unicode固然所有包括了。Unicode自己是隻有2個字節的，之因此出現UTF-8,UTF-16等等之類，那是爲了針對不一樣的應用環境，提升總體編碼效率，好比若是某篇文章裏絕大部分是英語（單字節就能表示），就比較適合使用utf-8，而若是絕大部分是中文（須要雙字節），utf-16

丨：匹配兩個或者多個分支選擇
[]：匹配方括號中的任意一個原子
[^]：匹配除方括號中的原子以外的任意字符
.：匹配除換行符以外的任意字符  [^\n]
\d：匹配任意一個十進制數字   [0-9]
\D：匹配任意一個非十進制數字     [^0-9]
\s：匹配一個不可見原子，例如空格、Tab、換行[\n\t\v]
\S：匹配一個可見原子  [^\n\t\v]
\w：匹配任意一個數字、字母或下劃線[0-9a-zA-z_]
\W：匹配任意一個非數字、非字母、非下劃線[^0-9a-zA-z_]
[\u4E00-\u9FA5]：匹配中文
【量詞】\w+(\.\w+)*@\w+(\.\w+)+$

{m}:表示其前面的原子剛好出現了n次
{n,}:表示其前面的原子最少出現了n次
{n,m}:表示其前面的原子最少出現n次，最多出現了m次
*：表示匹配0次、1次或者屢次其以前的原子，即{0,}
+:表示匹配1次或者屢次其以前的原子，即{1,}
?:匹配0次，或者1次其以前的原子，即{0,1}

【邊界控制】
^：匹配字符串開始的位置
$：匹配字符串結尾的位置
()：匹配其中的總體爲一個原子
【模式單元】
Duang|duang
[Dd]uang
(D|d)uang

http://regexpal.isbadguy.com/  正則調試
http://tool.oschina.net/encode Unicode轉碼


【進階】
【修正模式】
貪婪匹配與懶惰匹配
貪婪匹配 default
——匹配結果存在歧義時取其長
懶惰匹配  U
——匹配結果存在歧義時取其短

U 懶惰匹配
i 忽略大小寫
x 忽略空白
s 讓元字符‘.’匹配包含換行符在內的全部字符

### 正則匹配字符

正則表達式是匹配模式，要麼匹配字符，要麼匹配位置。請記住這句話。

然而關於正則如何匹配字符的學習，大部分人都以爲這塊比較雜亂。

畢竟元字符太多了，看起來沒有系統性，很差記。本文就解決這個問題。

內容包括：

1. 兩種模糊匹配

2. 字符組

3. 量詞

4. 分支結構

5. 案例分析
1. 兩種模糊匹配

若是正則只有精確匹配是沒多大意義的，好比/hello/，也只能匹配字符串中的"hello"這個子串。

var regex = /hello/;
console.log( regex.test("hello") ); // true

正則表達式之因此強大，是由於其能實現模糊匹配。

而模糊匹配，有兩個方向上的「模糊」：橫向模糊和縱向模糊。

1.1 橫向模糊匹配

橫向模糊指的是，一個正則可匹配的字符串的長度不是固定的，能夠是多種狀況的。

其實現的方式是使用量詞。表示譬如{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"]

注意：案例中用的正則是/ab{2,5}c/g，後面多了g，它是正則的一個修飾符。表示全局匹配，即在目標字符串中按順序找到知足匹配模式的全部子串，強調的是「全部」，而不僅是「第一個」。g是單詞global的首字母。

1.2 縱向模糊匹配

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

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

好比/a[123]b/能夠匹配以下三種字符串："a1b"、"a2b"、"a3b"。測試以下：

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

以上就是本文講的主體內容，只要掌握橫向和縱向模糊匹配，就能解決很大部分正則匹配問題。

接下來的內容就是展開說了，若是對此都比較熟悉的話，能夠跳到最後，直接看案例那節。
2. 字符組

須要強調的是，雖叫字符組（字符類），但只是其中一個字符。例如[abc]，表示匹配一個字符，它能夠是「a」、「b」、「c」之一。

2.1 範圍表示法

若是字符組裏的字符特別多的話，怎麼辦？可使用範圍表示法。

好比[123456abcdefGHIJKLM]，能夠寫成[1-6a-fG-M]。用連字符"-"來省略和簡寫。

由於連字符有特殊用途，那麼要匹配「a」、「-」、「z」這三者中任意一個字符，該怎麼作呢？

不能寫成[a-z]，由於其表示小寫字符中的任何一個字符。

能夠寫成以下的方式：[-az]或[az-]或[a\-z]。即要麼放在開頭，要麼放在結尾，要麼轉義。總之不會讓引擎認爲是範圍表示法就好了。

2.2 排除字符組

縱向模糊匹配，還有一種情形就是，某位字符能夠是任何東西，但就不能是"a"、"b"、"c"。

此時就是排除字符組（反義字符組）的概念。例如[^abc]，表示是一個除"a"、"b"、"c"以外的任意一個字符。字符組的第一位放"^"（脫字符），表示求反的概念。

固然，也有相應的範圍表示法。

2.3 常見的簡寫形式

有了字符組的概念後，一些常見的符號咱們也就理解了。由於它們都是系統自帶的簡寫形式。

    \d 就是[0-9]。表示是一位數字。記憶方式：其英文是digit（數字）。

    \D 就是[^0-9]。表示除數字外的任意字符。

    \w 就是[0-9a-zA-Z_]。表示數字、大小寫字母和下劃線。記憶方式：w是word的簡寫，也稱單詞字符。

    \W 就是[^0-9a-zA-Z_]。非單詞字符。

    \s 就是[ \t\v\n\r\f]。表示空白符，包括空格、水平製表符、垂直製表符、換行符、回車符、換頁符。記憶方式：s是space character的首字母。

    \S 就是[^ \t\v\n\r\f]。 非空白符。

    . 就是[^\n\r\u2028\u2029]。通配符，表示幾乎任意字符。換行符、回車符、行分隔符和段分隔符除外。記憶方式：想一想省略號...中的每一個點，均可以理解成佔位符，表示任何相似的東西。

若是要匹配任意字符怎麼辦？可使用[\d\D]、[\w\W]、[\s\S]和[^]中任何的一個。
3. 量詞

量詞也稱重複。掌握{m,n}的準確含義後，只須要記住一些簡寫形式。

3.1 簡寫形式

    {m,} 表示至少出現m次。

    {m} 等價於{m,m}，表示出現m次。

    ? 等價於{0,1}，表示出現或者不出現。記憶方式：問號的意思表示，有嗎？

    + 等價於{1,}，表示出現至少一次。記憶方式：加號是追加的意思，得先有一個，而後才考慮追加。

    * 等價於{0,}，表示出現任意次，有可能不出現。記憶方式：看看天上的星星，可能一顆沒有，可能零散有幾顆，可能數也數不過來。

3.2 貪婪匹配和惰性匹配

看以下的例子：

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

其中正則/\d{2,5}/，表示數字連續出現2到5次。會匹配2位、3位、4位、5位連續數字。

可是其是貪婪的，它會盡量多的匹配。你能給我6個，我就要5個。你能給我3個，我就3要個。反正只要在能力範圍內，越多越好。

咱們知道有時貪婪不是一件好事（請看文章最後一個例子）。而惰性匹配，就是儘量少的匹配：

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}?/表示，雖然2到5次都行，當2個就夠的時候，就不在往下嘗試了。

經過在量詞後面加個問號就能實現惰性匹配，所以全部惰性匹配情形以下：

    {m,n}?
    {m,}?
    ??
    +?
    *?

對惰性匹配的記憶方式是：量詞後面加個問號，問一問你滿足了嗎，你很貪婪嗎？
4. 多選分支

一個模式能夠實現橫向和縱向模糊匹配。而多選分支能夠支持多個子模式任選其一。

具體形式以下：(p1|p2|p3)，其中p一、p2和p3是子模式，用「|」（管道符）分隔，表示其中任何之一。

例如要匹配"good"和"nice"可使用/good|nice/。測試以下：

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

但有個事實咱們應該注意，好比我用/good|goodbye/，去匹配"goodbye"字符串時，結果是"good"：

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

而把正則改爲/goodbye|good/，結果是

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

也就是說，分支結構也是惰性的，即當前面的匹配上了，後面的就再也不嘗試了。
5. 案例分析

匹配字符，無非就是字符組、量詞和分支結構的組合使用罷了。

下面找幾個例子演練一下（其中，每一個正則並非只有惟一寫法）：

5.1 匹配16進制顏色值

要求匹配：

    #ffbbad

    #Fc01DF

    #FFF

    #ffE

分析：

表示一個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"]

5.2 匹配時間

以24小時製爲例。

要求匹配：

    23:59

    02:07

分析：

共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]$/;
console.log( regex.test("23:59") ); // true
console.log( regex.test("02:07") ); // true

若是也要求匹配7:9，也就是說時分前面的0能夠省略。

此時正則變成：

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

5.3 匹配日期

好比yyyy-mm-dd格式爲例。

要求匹配：

    2017-06-10

分析：

年，四位數字便可，可用[0-9]{4}。

月，共12個月，分兩種狀況0一、0二、……、09和十、十一、12，可用(0[1-9]|1[0-2])。

日，最大31天，可用(0[1-9]|[12][0-9]|3[01])。

正則以下：

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

5.4 window操做系統文件路徑

要求匹配：

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

    F:\study\javascript\regex\

    F:\study\javascript

    F:\

分析：

總體模式是: 盤符:\文件夾\文件夾\文件夾\

其中匹配F:\，須要使用[a-zA-Z]:\\，其中盤符不區分大小寫，注意\字符須要轉義。

文件名或者文件夾名，不能包含一些特殊字符，此時咱們須要排除字符組[^\\:*<>|"?\r\n/]來表示合法字符。另外不能爲空名，至少有一個字符，也就是要使用量詞+。所以匹配「文件夾\」，可用[^\\:*<>|"?\r\n/]+\\。

另外「文件夾\」，能夠出現任意次。也就是([^\\:*<>|"?\r\n/]+\\)*。其中括號提供子表達式。

路徑的最後一部分能夠是「文件夾」，沒有\，所以須要添加([^\\:*<>|"?\r\n/]+)?。

最後拼接成了一個看起來比較複雜的正則：

var regex = /^[a-zA-Z]:\\([^\\:*<>|"?\r\n/]+\\)*([^\\:*<>|"?\r\n/]+)?$/;
console.log( regex.test("F:\\study\\javascript\\regex\\regular expression.pdf") ); // true
console.log( regex.test("F:\\study\\javascript\\regex\\") ); // true
console.log( regex.test("F:\\study\\javascript") ); // true
console.log( regex.test("F:\\") ); // true

其中，JS中字符串表示「\」時，也要轉義。

5.5 匹配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" class="main"

由於.是通配符，自己就匹配雙引號的，而量詞*又是貪婪的，當遇到container後面雙引號時，不會停下來，會繼續匹配，直到遇到最後一個雙引號爲止。

解決之道，可使用惰性匹配：

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

固然，這樣也會有個問題。效率比較低，由於其匹配原理會涉及到「回溯」這個概念（這裏也只是順便提一下，後續文章會說明）。能夠優化以下：

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

後記

字符匹配相關的案例，挺多的，不一而足。

掌握字符組和量詞就能解決大部分常見的情形，也就是說，當你會了這兩者，JS正則算是入門了。

感謝你看到這裏，本文也要結束了。

若是有更好的例子，也能夠幫我補充補充。

也歡迎關注本系列，不妨看看下一篇《正則表達式位置匹配攻略》。

最後，咱們該想到，陸游詩人對前端作的最大貢獻是：

紙上得來終覺淺，絕知此事要躬行。

本文完。

### 正則匹配位置

正則表達式是匹配模式，要麼匹配字符，要麼匹配位置。請記住這句話。

然而大部分人學習正則時，對於匹配位置的重視程度沒有那麼高。

本文講講正則匹配位置的總總。

內容包括：

1. 什麼是位置？

2. 如何匹配位置？

3. 位置的特性

4. 幾個應用實例分析
1. 什麼是位置呢？

位置是相鄰字符之間的位置。好比，下圖中箭頭所指的地方：
2. 如何匹配位置呢？

在ES5中，共有6個錨字符：

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

2.1 ^和$

^（脫字符）匹配開頭，在多行匹配中匹配行開頭。

$（美圓符號）匹配結尾，在多行匹配中匹配行結尾。

好比咱們把字符串的開頭和結尾用"#"替換（位置能夠替換成字符的！）：

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

console.log(result); // "#hello#"

多行匹配模式時，兩者是行的概念，這個須要咱們的注意：

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

console.log(result);

/*

#I#

#love#

#javascript#

*/

2.2 \b和\B

\b是單詞邊界，具體就是\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#"

爲何是這樣呢？這須要仔細看看。

首先，咱們知道，\w是字符組[0-9a-zA-Z_]的簡寫形式，即\w是字母數字或者下劃線的中任何一個字符。而\W是排除字符組[^0-9a-zA-Z_]的簡寫形式，即\W是\w之外的任何一個字符。

此時咱們能夠看看"[#JS#] #Lesson_01#.#mp4#"中的每個"#"，是怎麼來的。

第一個"#"，兩邊是"["與"J"，是\W和\w之間的位置。

第二個"#"，兩邊是"S"與"]"，也就是\w和\W之間的位置。

第三個"#"，兩邊是空格與"L"，也就是\W和\w之間的位置。

第四個"#"，兩邊是"1"與"."，也就是\w和\W之間的位置。

第五個"#"，兩邊是"."與"m"，也就是\W和\w之間的位置。

第六個"#"，其對應的位置是結尾，但其前面的字符"4"是\w，即\w和$之間的位置。

知道了\b的概念後，那麼\B也就相對好理解了。

\B就是\b的反面的意思，非單詞邊界。例如在字符串中全部位置中，扣掉\b，剩下的都是\B的。

具體說來就是\w與\w、\W與\W、^與\W，\W與$之間的位置。

好比上面的例子，把全部\B替換成"#"：

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

console.log(result); // "#[J#S]# L#e#s#s#o#n#_#0#1.m#p#4"

2.3 (?=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#"

兩者的學名分別是positive lookahead和negative lookahead。

中文翻譯分別是正向先行斷言和負向先行斷言。

ES6中，還支持positive lookbehind和negative lookbehind。

具體是(?<=p)和(?<!p)。

也有書上把這四個東西，翻譯成環視，即看看左邊或看看右邊。

但通常書上，沒有很好強調這四者是個位置。

好比(?=p)，通常都理解成：要求接下來的字符與p匹配，但不能包括p的那些字符。

而在本人看來(?=p)就與^同樣好理解，就是p前面的那個位置。
3. 位置的特性

對於位置的理解，咱們能夠理解成空字符""。

好比"hello"字符串等價於以下的形式：

"hello" == "" + "h" + "" + "e" + "" + "l" + "" + "l" + "o" + "";

也等價於：

"hello" == "" + "" + "hello"

所以，把/^hello$/寫成/^^hello$$$/，是沒有任何問題的：

var result = /^^hello$$$/.test("hello");

console.log(result); // true

甚至能夠寫成更復雜的:

var result = /(?=he)^^he(?=\w)llo$\b\b$/.test("hello");

console.log(result); // true

也就是說字符之間的位置，能夠寫成多個。

把位置理解空字符，是對位置很是有效的理解方式。
4. 相關案例

4.1 不匹配任何東西的正則

讓你寫個正則不匹配任何東西

easy，/.^/

由於此正則要求只有一個字符，但該字符後面是開頭。

4.2 數字的千位分隔符表示法

好比把"12345678"，變成"12,345,678"。

可見是須要把相應的位置替換成","。

思路是什麼呢？

4.2.1 弄出最後一個逗號

使用(?=\d{3}$)就能夠作到：

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

console.log(result); // "12345,678"

4.2.2 弄出全部的逗號

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

此時可使用量詞+：

var result = "12345678".replace(/(?=(\d{3})+$)/g, ',')

console.log(result); // "12,345,678"

4.2.3 匹配其他案例

寫完正則後，要多驗證幾個案例，此時咱們會發現問題：

var result = "123456789".replace(/(?=(\d{3})+$)/g, ',')

console.log(result); // ",123,456,789"

由於上面的正則，僅僅表示把從結尾向前數，一可是3的倍數，就把其前面的位置替換成逗號。所以纔會出現這個問題。

怎麼解決呢？咱們要求匹配的到這個位置不能是開頭。

咱們知道匹配開頭可使用^，但要求這個位置不是開頭怎麼辦？

easy，(?!^)，你想到了嗎？測試以下：

var string1 = "12345678",

string2 = "123456789";

reg = /(?!^)(?=(\d{3})+$)/g;

var result = string1.replace(reg, ',')

console.log(result); // "12,345,678"

result = string2.replace(reg, ',');

console.log(result); // "123,456,789"

4.2.4 支持其餘形式

若是要把"12345678 123456789"替換成"12,345,678 123,456,789"。

此時咱們須要修改正則，把裏面的開頭^和結尾$，替換成\b：

var string = "12345678 123456789",

reg = /(?!\b)(?=(\d{3})+\b)/g;

var result = string.replace(reg, ',')

console.log(result); // "12,345,678 123,456,789"

其中(?!\b)怎麼理解呢？

要求當前是一個位置，但不是\b前面的位置，其實(?!\b)說的就是\B。

所以最終正則變成了：/\B(?=(\d{3})+\b)/g

4.3 驗證密碼問題

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

此題，若是寫成多個正則來判斷，比較容易。但要寫成一個正則就比較困難。

那麼，咱們就來挑戰一下。看看咱們對位置的理解是否深入。

4.3.1 簡化

不考慮「但必須至少包括2種字符」這一條件。咱們能夠容易寫出：

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

4.3.2 判斷是否包含有某一種字符

假設，要求的必須包含數字，怎麼辦？此時咱們可使用(?=.*[0-9])來作。

所以正則變成：

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

4.3.3 同時包含具體兩種字符

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

所以正則變成：

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

4.3.4 解答

咱們能夠把原題變成下列幾種狀況之一：

1.同時包含數字和小寫字母

2.同時包含數字和大寫字母

3.同時包含小寫字母和大寫字母

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

以上的4種狀況是或的關係（實際上，能夠不用第4條）。

最終答案是：

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

console.log( reg.test("1234567") ); // false 全是數字

console.log( reg.test("abcdef") ); // false 全是小寫字母

console.log( reg.test("ABCDEFGH") ); // false 全是大寫字母

console.log( reg.test("ab23C") ); // false 不足6位

console.log( reg.test("ABCDEF234") ); // true 大寫字母和數字

console.log( reg.test("abcdEF234") ); // true 三者都有

4.3.5 解惑

上面的正則看起來比較複雜，只要理解了第二步，其他就所有理解了。

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

對於這個正則，咱們只須要弄明白(?=.*[0-9])^便可。

分開來看就是(?=.*[0-9])和^。

表示開頭前面還有個位置（固然也是開頭，即同一個位置，想一想以前的空字符類比）。

(?=.*[0-9])表示該位置後面的字符匹配.*[0-9]，即，有任何多個任意字符，後面再跟個數字。

翻譯成大白話，就是接下來的字符，必須包含個數字。

4.3.6 另一種解法

「至少包含兩種字符」的意思就是說，不能所有都是數字，也不能所有都是小寫字母，也不能所有都是大寫字母。

那麼要求「不能所有都是數字」，怎麼作呢？(?!p)出馬！

對應的正則是：

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

三種「都不能」呢？

最終答案是：

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

console.log( reg.test("1234567") ); // false 全是數字

console.log( reg.test("abcdef") ); // false 全是小寫字母

console.log( reg.test("ABCDEFGH") ); // false 全是大寫字母

console.log( reg.test("ab23C") ); // false 不足6位

console.log( reg.test("ABCDEF234") ); // true 大寫字母和數字

console.log( reg.test("abcdEF234") ); // true 三者都有

後記

位置匹配相關的案例，挺多的，不一而足。

感謝你看到這裏，本文也要結束了。

若是有更好的例子，也能夠幫我補充補充。

最後，咱們該想到，陸游詩人對前端作的最大貢獻是：

紙上得來終覺淺，絕知此事要躬行。

本文完。