一.模糊匹配

横向模糊匹配

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

纵向模糊匹配

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

二.字符组

范围表示法

比如 [123456abcdefGHIJKLM]，可以写成 [1-6a-fG-M]。用连字符 - 来省略和简写。
要匹配 “a”、”-“、”z” 这三者中任意一个字符，不能写成 [a-z]，因为其表示小写字符中的任何一个字符。可以写成如下的方式：[-az] 或 [az-] 或 [a-z]。

排除字符组

例如 [^abc]，表示是一个除 “a”、”b”、”c”之外的任意一个字 符。字符组的第一位放 ^（脱字符），表示求反的概念。

常见简写形式

字符组 具体含义
\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 的首字母，空白符的单词是 white space。
\S
表示 [^ \t\v\n\r\f]。 非空白符。
.
表示 [^\n\r\u2028\u2029]。通配符，表示几乎任意字符。换行符、回车符、行分隔符和段分隔符 除外。 记忆方式：想想省略号 … 中的每个点，都可以理解成占位符，表示任何类似的东西。

三.量词

简写形式

量词 具体含义
{m,}
表示至少出现 m 次。
{m}
等价于 {m,m}，表示出现 m 次。
?
等价于 {0,1}，表示出现或者不出现。 记忆方式：问号的意思表示，有吗？
+
等价于 {1,}，表示出现至少一次。 记忆方式：加号是追加的意思，得先有一个，然后才考虑追加。
*
等价于 {0,}，表示出现任意次，有可能不出现。 记忆方式：看看天上的星星，可能一颗没有，可能零散有几颗，可能数也数不过来。

贪婪匹配与惰性匹配

贪婪匹配，尽可能多的匹配。

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

惰性匹配，尽可能少的匹配。

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

惰性量词 贪婪量词
{m,n}? {m,n}
{m,}? {m,}
?? ?
+? +
?

四.多选分支

  1. var regex = /good|nice/g;
  2. var string = "good idea, nice try."; 
  3. console.log( string.match(regex) ); 
  4. // => ["good", "nice"]
  1. var regex = /good|goodbye/g; 
  2. var string = "goodbye"; 
  3. console.log( string.match(regex) ); 
  4. // => ["good"]
  1. var regex = /goodbye|good/g; 
  2. var string = "goodbye"; 
  3. console.log( string.match(regex) ); 
  4. // => ["goodbye"]

五.案例分析

匹配16进制颜色值

要求匹配：
#ffbbad
#Fc01DF
#FFF
#ffE
分析：
表示一个 16 进制字符，可以用字符组 [0-9a-fA-F]。
其中字符可以出现 3 或 6 次，需要是用量词和分支结构。
使用分支结构时，需要注意顺序。
正则如下：

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

匹配时间

要求匹配：
23:59
02:07
分析：
共 4 位数字，第一位数字可以为 [0-2]。
当第 1 位为 “2” 时，第 2 位可以为 [0-3]，其他情况时，第 2 位为 [0-9]。
第 3 位数字为 [0-5]，第4位为 [0-9]。
正则如下：

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

正则中使用了 ^ 和 $，分别表示字符串开头和结尾。

匹配日期

要求匹配：
2017-06-10
分析：
年，四位数字即可，可用 [0-9]{4}。
月，共 12 个月，分两种情况 “01”、”02”、…、”09” 和 “10”、”11”、”12”，可用 (0[1-9]|1[0-2])。
日，最大 31 天，可用 (0[1-9]|[12][0-9]|3[01])。
正则如下：

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

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/]+)?。
最后拼接成了一个看起来比较复杂的正则：

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

匹配id

要求从

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

因为 . 是通配符，本身就匹配双引号的，而量词 * 又是贪婪的，当遇到 container 后面双引号时，是不会 停下来，会继续匹配，直到遇到最后一个双引号为止。
解决之道，可以使用惰性匹配：

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

当然，这样也会有个问题。效率比较低，因为其匹配原理会涉及到“回溯”这个概念，可以优化如下：

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