【转载】正则表达式基础

### 基本语法

【基础】

【界定符】 // #[]#

【原子】    原子：正则表达式中的最小匹配单位，一般它只是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 三者都有

后记

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

感谢你看到这里，本文也要结束了。

若是有更好的例子，也能够帮我补充补充。

最后，咱们该想到，陆游诗人对前端作的最大贡献是：

纸上得来终觉浅，绝知此事要躬行。

本文完。