正则表达式

正则表达式就是匹配模式，要么匹配字符，要么匹配位置，接下来从这两个方面来说明基本的正则表达式。

正则匹配基础

创建正则的两种方式：构造函数和字面量

var rgx1 = new RegExp("hello");
var rgx2 = /hello/;

使用修饰符

• i，忽略大小写
• g，全局匹配
• m，多行匹配

var rgx1 = new RegExp("hello", "gi");
var rgx2 = /hello/gi;

使用RegExp#test方法

判断正则是否匹配一个字符串：

var rgx = /hello/;
console.log( rgx.test("hello") );
console.log( rgx.test("world") );
console.log( rgx.test("hello world") );

\\ result
console.log: true
console.log: false
console.log: true

使用RegExp#exec方法

获取匹配的相关信息：

var rgx = /world/;
console.log( rgx.exec("world !!") );
console.log( rgx.exec("hello world") );
console.log( rgx.exec("hello") );

\\ result
console.log: ["world", index: 0, input: "world !!"]
console.log: ["world", index: 6, input: "hello world"]
console.log: null

使用String#replace方法

字符串替换方法。
比如替换第一个foo为qux：

var str = "foo foo";
console.log( str.replace("foo", "qux") );

\\ result
console.log: "qux foo"

使用String#search方法

获取第一个匹配的下标：

var str = "hello world";
console.log( str.search(/world/) );

\\ result
console.log: 6

使用String#match方法

获取匹配的相关信息（注意有没有g修饰符，返回的格式是不一样的）：

var str = "abcabc";
console.log( str.match(/b/) );
console.log( str.match(/b/g) );

\\ result 
console.log: ["b", index: 1, input: "abcabc"]
console.log: ["b", "b"]

字符匹配

通常在正则中，精确匹配是非常少的情形。
比如/hello/，用来匹配字串中的hello子串。
通常的是模糊匹配。虽是“模糊”，但通常都有约束的存在。
所谓“约束”，也就是规则，在有规则下的模糊，才有意义。
本章将讨论两种常见的模糊，足以覆盖正则中80%的情形。
1.在纵向尺度上的模糊，一个字符可以是数字、字母等，而不是某一个具体的字符。
2.在横向尺度上的模糊，一个字符出现的次数可以定制，不是只是一次。
实现前者需要使用字符组，而要实现后者需要使用量词。

通配符匹配

比如要匹配这样一个序列，先是1，然后某个字符，再是3。也就是像123，1b3，1 3，133等等这样的字符。针对这种情形我们可以使用.来匹配。

var str = "123 1b3 1 3 133 321";
console.log( str.match(/1.3/g) );

匹配数字

通配符不是唯一的模糊匹配。例如前面的例子我们可以要求1和3之间的字符是数字。我们可以使用\d匹配符。

var str = "123 1b3 1 3 133 321";
console.log( str.match(/1\d3/g) );

\\ result
console.log: ["123", "133"]

匹配字母数字

此时我们要求1和3直接的字符是字母或数字。此时可以用单词匹配符\w。“单词”具体的含义是数字0-9、小写字母a-z、大写字母A-Z以及下划线_。

var str = "123 1b3 1 3 133 321";
console.log( str.match(/1\w3/g) );

\\ result
console.log: ["123", "1b3", "133"]

反义

\D是\d的反义版本，\D表示此字符是任何字符，但不是数字。即0-9之外的任意一个字符。\W与\w也是类似的关系。

范围表示法

有时，要匹配的东西，不像\w那么多种可能。比如要找bicycle中所有的a、b、c字母，正则可以用/[abc]/g，其中[abc]匹配一个字符，此字符可以是abc中的任何一个。

var str = "bicycle";
console.log( str.match(/[abc]/g) );

\\ result
console.log: ["b", "c", "c"]

注意：[abc]只是三个字母倒好说，但是26个字母呢？不能一一写下吧。还好我们有范围表示法，例如[a-z]表示所有小写字母。可以举个小场景。一堆长度为3个字母的英文名字，要判断格式是否正确。即首字母大写，其余俩字母小写，可以使用正则/[A-Z][a-z][a-z]/g：

var str = "Tim sam Bob maC Guy";
console.log( str.match(/[A-Z][a-z][a-z]/g) );

\\ result
console.log: ["Tim", "Bob", "Guy"]

匹配出现至少一次

用+表示出现的次数至少一次。比如匹配英文名字，首字母大写，至少两个字母，可以使用/[A-Z][a-z]+/g：

var str = "Timothy Dave max Bob Greg T";
console.log( str.match(/[A-Z][a-z]+/g) );

\\ result
console.log: ["Timothy", "Dave", "Bob", "Greg"]

匹配出现0次或者1次

用?表示出现的次数0次或者一次。比如匹配苹果的单复数，可以使用/apples?/gi：

var str = "Apple Apples Applse";
console.log( str.match(/apples?/gi) );

\\ result
console.log: ["Apple", "Apples"]

匹配出现0次或者任意次

用*表示出现的次数0次或者任意次。比如查找日志中的update单词，其后可能有感叹号，也可能没有感叹号，甚至可能有多个，如updata!!!!!!!!，可以使用正则/update!*/g:

var str = "update update!!! update!!!!!!!!";
console.log( str.match(/update!*/g) );

\\ result
console.log: ["update", "update!!!", "update!!!!!!!!"]

匹配出现n次

有时，你需要自定定义次数。比如匹配电话号码123-4567，你可能会把正则写成/\d\d\d-\d\d\d\d/，其实改写成/\d{3}-\d{4}/，这样可读性比较高。{n}表示出现n次。

匹配至少出现n次

比如，``{n,}\``表示至少出现n次。例如你希望密码的长度最小为6，可以用```/\w{6,}/g```:

var str = "pass password long\_password";  
console.log\( str.match\(/\w{6,}/g\) \);

console.log: \["password", "long\_password"\]

匹配出现n到m次

比如：{n,m}表示出现n到m次。比如一般评论都是15到140字。可以用/.{15,140}/。

匹配分支

有时匹配规则并不是一个字符多选一，而是另外一种多选一情形。比如匹配yes和no。可以按照之前的思路，可能会把正则写成/[yn][eo]s?/g。虽然匹配了yes和no，但也匹配了其他情形，比如nos。

显然上面的结果不是我们想要的。此时需要使用分支结构，使用管道符“|”，如/yes|no/g，下面我们会看到也会匹配nos中的no，下一章会解决该问题。

var str = "yes no nos ne nes yos ye yo";  
console.log\( str.match\(/yes\|no/g\) \);

\ result  
console.log: \["yes", "no", "no"\]

匹配位置

什么是位置

位置是相邻字符之间的位置。比如，下图中箭头所指的地方：

如何匹配位置

在ES5中，共有6个锚字符：

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

^和$

^（脱字符）匹配开头，在多行匹配中匹配行开头。
$（美元符号）匹配结尾，在多行匹配中匹配行结尾。
比如我们把字符串的开头和结尾用"#"替换（位置可以替换成字符的！）：

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

\\ result
console.log: "#hello#"

\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#"

\\ result
console.log: "[#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的。
具体说来就是\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"

\\ result
console.log: "#[J#S]# L#e#s#s#o#n#_#0#1.m#p#4"

(?=p)和(?!p)

(?=p)，其中p是一个子模式，即p前面的位置。
比如(?=l)，表示'l'字符前面的位置，例如：

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

位置的特性

对于位置的理解，我们可以理解成空字符""。
比如"hello"字符串等价于如下的形式：

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

也等价于：

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

正则速查表