JS 正则笔记

示例：C0753.0177.202303300002）

匹配不少于两个点的表达式

let regA = /.*\..*\.(\w+|\d+)/;

regA.test('A1.4322.123')  //true

regA.test('A1.43.22.123')  //true

=============

个人重点记忆：

* : 等价于 {0，}

?  : 等价于 {0，1}

+ : 等价于 {1，}

.  :点，匹配任意字符

正文部分：

RegExp （Regular Expression）

以下正则表达式等价： ​

var re = new RgExp("\w+"); ​

var re = /\w+/;

正则表达式，RegExp, exec, test, match, matchAll, replace, search, split exec 返回匹配的数据；test返回true或false;   eg: /^A/.test(fruit); 使用正则 /^A/ 选择 不是以‘A’开头的水果

/abc/能且只能匹配 “abc”

[aA] 表示字母 a 或 A

使用特殊字符： /ab*c/ *的意思是前一项出现零次或多次

断言（Assertions）表示一个匹配在某些条件下发生。分为先行、后行和条件表达式。

• 1.^ 匹配输入的开头。 eg: /^A/ 匹配字符开头的A
• 2.$ 匹配输入的结束。 eg: /t$/ 匹配以t结尾的
• 3.\b 匹配一个单词的边界。eg: /\bm/ 匹配m开头的 eg: /oon\b/ 匹配“oon”结尾的
• 4.\B 匹配非单词边界。 eg: /ye\B/ 匹配 "possibly yesterday"中"ye"

其他断言：(?条件)

• 1.x(?=y) 先行断言。 x 被 y 跟随时匹配 x。
• 2.x(?!y) 先行否定断言。 x没有被紧随，匹配x。 eg: /\d+(?!.)/ 数字后面没有跟随小数点时匹配。 对于/\d+(?!.)/.exec(3.141)，匹配‘141’而不是‘3’。
• 3.(?<=y)x 后行断言。 x 跟随 y 的情况下匹配 x。
• 4.(?<!y)x 后行否定断言。 x 不跟随 y 时匹配 x。 eg: /(?<!-)\d+/.exec(3) ，“3”得到匹配。eg: /(?<!-)\d+/.exec(-3)的结果无匹配，这是由于数字之前有 - 符号。

字符类 区分不同类型的字符，例如区分字母和数字。

• [a-c] 匹配a,b,c eg: [\w-] 与 [A-Za-z0-9_-] 相同

• [^a-c] 一个否定或补充的字符类。

• . 匹配除行终止符之外的任何单个字符。 eg: /.y/ 在“yes make my day”中匹配“my”和“ay”，而不是“yes”

  在字符内，与文字点匹配。

• \d 匹配任何数字，相当于[0-9]。

• \D 匹配任何非数字。 eg: /\D/ 或者 /[^0-9]/ 匹配“B2 is the suite number”中的“B”。

• \w 字母数字字符。相当于 [A-Za-z0-9_]。 匹配拉丁字母中的任何字母数字字符，下划线。

• \W 匹配非字母数字字符。 相当于 [^A-Za-z0-9_]。

• \s 匹配单个空白字符，包括空格、制表符、换页符、换行符和其他 Unicode 空格。相当于 [ \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]。例如，/\s\w*/ 匹配“foo bar”中的“bar”。

• \S 匹配除空格以外的单个字符。

• \t，\r, \n, \v, \f, [\b] 分别匹配水平制表符，回车符，换行符，垂直制表符，换页符，退格键。

• ...

• \ 指示应特殊处理或“转义”后面的字符。它表现为两种方式之一。 通常按字面处理的字符。eg: /b/ 匹配字符“b”。通过在“b”前面放置反斜杠，即使用 /\b/，字符变得特殊以表示匹配单词边界。 通常被特殊对待的字符。eg: /a*/ 示匹配 0 个或多个“a”。 eg:/a\*/ 匹配“a*”。 备注: 搜索\的时候需转义，写成 /\\/。

• x|y 匹配x或y。eg: /green|red/ 匹配“green apple”中的“green”和“red apple”中的“red”。 备注：析取是指定“一组选择”的另一种方式，但它不是字符类。eg: [abc] 在功能上等同于 (?:a|b|c)。

组和范围 区分

字符集	含义
x|y	匹配 "x" 或 "y" 任意一个字符。例如， /green|red/ 在 "green apple" 里匹配 "green"，且在 "red apple" 里匹配 "red" 。
[xyz] [a-c]	字符集。 匹配任何一个包含的字符。您可以使用连字符来指定字符范围，但如果连字符显示为方括号中的第一个或最后一个字符，则它将被视为作为普通字符包含在字符集中的文字连字符。也可以在字符集中包含字符类。 例如，[abcd] 是与[a-d].一样的，它们会 在"brisket" 中匹配 "b",在 "chop" 中匹配 "c" . 例如，[abcd-] 和[-abcd] 将会在 "brisket" 匹配 "b" , 在 "chop" 匹配 "c" , 并且匹配 "non-profit" 中的 "-" (连字符) 例如，[\w-] 是字符集 \w 和 “-”（连字符）的并集，与这种写法一样： [A-Za-z0-9_-].。他们都会 在 "brisket"中匹配“b”, 在 "chop"中匹配“c”, 在 "non-profit" 中匹配 "n"。
[^xyz] [^a-c]	一个否定的或被补充的字符集。也就是说，它匹配任何没有包含在括号中的字符。可以通过使用连字符来指定字符范围，但是如果连字符作为方括号中的第一个或最后一个字符出现，那么它将被视为作为普通字符包含在字符集中。例如，[^abc] 和 [^a-c] 一样。它们最初匹配“bacon”中的“o”和“chop”中的“h”。 备注： ^ 字符也可以表示 输入的起始
(x)	捕获组：匹配 x 并记住匹配项。例如，/(foo)/匹配并记住“foo bar”中的“foo” 正则表达式可以有多个捕获组。结果，匹配通常在数组中捕获的组，该数组的成员与捕获组中左括号的顺序相同。这通常只是捕获组本身的顺序。当捕获组被嵌套时，这一点非常重要。使用结果元素的索引 ([1], ..., [n]) 或从预定义的 RegExp 对象的属性 ($1, ..., $9). 捕获组会带来性能损失。如果不需要收回匹配的子字符串，请选择非捕获括号 (见下面)。 String.match() 不会返回组，如果设置了 /.../g 标志。但是，您仍然可以使用 String.matchAll() to get all matches. match() 不会返回组，如果/…但是，您仍然可以使用 String.matchAll() 来获取所有匹配项。
\n	其中 n 是一个正整数。对正则表达式中与 n 括号匹配的最后一个子字符串的反向引用 (计算左括号)。例如，/apple(,)\sorange\1/ 匹配“apple，orange，cherry，peach”中的 "apple，orange，"，其中 \1 引用了 之前使用 （） 捕获的 ，
(?<Name>x)	具名捕获组：匹配"x"并将其存储在返回的匹配项的 groups 属性中，该属性位于<Name>指定的名称下。尖括号 (< 和 >) 用于组名。 例如，使用正则 /-(?<customName>\w)/ 匹配“web-doc” 中的“d” 'web-doc'.match(/-(?<customName>\w)/).groups //{customName: "d"}
(?:x)	非捕获组：匹配 “x”，但不记得匹配。不能从结果数组的元素中收回匹配的子字符串 ([1], ..., [n]) or from the predefined RegExp object's properties ($1, ..., $9).

量词 表示要匹配的字符或表达式的数量。

Characters	Meaning
x*	将前面的项“x”匹配 0 次或更多次。例如，/bo*/匹配“A ghost booooed”中的“boooo”和“A bird warbled”中的“b”，但在“A goat grunt”中没有匹配。
x+	将前一项“x”匹配 1 次或更多次。等价于{1,}。例如，/a+/匹配“candy”中的“a”和“caaaaaaandy”中的“a”。
x?	将前面的项“x”匹配 0 或 1 次。例如，/e?le?/匹配 angel 中的 el 和 angle 中的 le。 如果立即在任何量词*、+、?或{}之后使用，则使量词是非贪婪的 (匹配最小次数)，而不是默认的贪婪的 (匹配最大次数)。
x{n}	其中“n”是一个正整数，与前一项“x”的 n 次匹配。例如，/a{2}/ 不匹配“candy”中的“a”，但它匹配“caandy”中的所有“a”，以及“caaandy”中的前两个“a”。
x{n,}	其中，“n”是一个正整数，与前一项“x”至少匹配“n”次。例如，/a{2，}/不匹配“candy”中的“a”，但匹配“caandy”和“caaaaaaandy”中的所有 a。
x{n,m}	其中，“n”是 0 或一个正整数，“m”是一个正整数，而 m > n 至少与前一项“x”匹配，最多与“m”匹配。例如，/a{1,3}/不匹配“cndy”中的“a”，“candy”中的“a”，“caandy”中的两个“a”，以及“caaaaaaandy”中的前三个“a”。注意，当匹配“caaaaaaandy”时，匹配的是“aaa”，即使原始字符串中有更多的“a”。
x*? x+? x?? x{n}? x{n,}? x{n,m}?	默认情况下，像 * 和 + 这样的量词是“贪婪的”，这意味着它们试图匹配尽可能多的字符串。?量词后面的字符使量词“非贪婪”：意思是它一旦找到匹配就会停止。例如，给定一个字符串“some <foo> <bar> new </bar> </foo> thing”: /<.*>/ will match "<foo> <bar> new </bar> </foo>" /<.*?>/ will match "<foo>"

Unicode 属性转义 (Unicode Property Escapes)

1. Unicode 属性转移 vs. 字符类

   ......

---

正则表达式中的特殊字符

字符	含义
\	依照下列规则匹配：在非特殊字符之前的反斜杠表示下一个字符是特殊字符，不能按照字面理解。例如，前面没有 "" 的 "b" 通常匹配小写字母 "b"，即字符会被作为字面理解，无论它出现在哪里。但如果前面加了 ""，它将不再匹配任何字符，而是表示一个字符边界。在特殊字符之前的反斜杠表示下一个字符不是特殊字符，应该按照字面理解。详情请参阅下文中的 "转义（Escaping）" 部分。如果你想将字符串传递给 RegExp 构造函数，不要忘记在字符串字面量中反斜杠是转义字符。所以为了在模式中添加一个反斜杠，你需要在字符串字面量中转义它。/[a-z]\s/i 和 new RegExp("[a-z]\\s", "i") 创建了相同的正则表达式：一个用于搜索后面紧跟着空白字符（\s 可看后文）并且在 a-z 范围内的任意字符的表达式。为了通过字符串字面量给 RegExp 构造函数创建包含反斜杠的表达式，你需要在字符串级别和正则表达式级别都对它进行转义。例如 /[a-z]:\\/i 和 new RegExp("[a-z]:\\\\","i") 会创建相同的表达式，即匹配类似 "C:" 字符串。
^	匹配输入的开始。如果多行标志被设置为 true，那么也匹配换行符后紧跟的位置。例如，/^A/ 并不会匹配 "an A" 中的 'A'，但是会匹配 "An E" 中的 'A'。当 '^' 作为第一个字符出现在一个字符集合模式时，它将会有不同的含义。反向字符集合 一节有详细介绍和示例。
$	匹配输入的结束。如果多行标志被设置为 true，那么也匹配换行符前的位置。例如，/t$/ 并不会匹配 "eater" 中的 't'，但是会匹配 "eat" 中的 't'。
*	匹配前一个表达式 0 次或多次。等价于 {0,}。例如，/bo*/ 会匹配 "A ghost boooooed" 中的 'booooo' 和 "A bird warbled" 中的 'b'，但是在 "A goat grunted" 中不会匹配任何内容。
+	匹配前面一个表达式 1 次或者多次。等价于 {1,}。例如，/a+/ 会匹配 "candy" 中的 'a' 和 "caaaaaaandy" 中所有的 'a'，但是在 "cndy" 中不会匹配任何内容。
?	匹配前面一个表达式 0 次或者 1 次。等价于 {0,1}。例如，/e?le?/ 匹配 "angel" 中的 'el'、"angle" 中的 'le' 以及 "oslo' 中的 'l'。如果紧跟在任何量词 *、 +、? 或 {} 的后面，将会使量词变为非贪婪（匹配尽量少的字符），和缺省使用的贪婪模式（匹配尽可能多的字符）正好相反。例如，对 "123abc" 使用 /\d+/ 将会匹配 "123"，而使用 /\d+?/ 则只会匹配到 "1"。还用于先行断言中，如本表的 x(?=y) 和 x(?!y) 条目所述。
.	（小数点）默认匹配除换行符之外的任何单个字符。例如，/.n/ 将会匹配 "nay, an apple is on the tree" 中的 'an' 和 'on'，但是不会匹配 'nay'。如果 s ("dotAll") 标志位被设为 true，它也会匹配换行符。
(x)	像下面的例子展示的那样，它会匹配 'x' 并且记住匹配项。其中括号被称为捕获括号。模式 /(foo) (bar) \1 \2/ 中的 '(foo)' 和 '(bar)' 匹配并记住字符串 "foo bar foo bar" 中前两个单词。模式中的 \1 和 \2 表示第一个和第二个被捕获括号匹配的子字符串，即 foo 和 bar，匹配了原字符串中的后两个单词。注意 \1、\2、...、\n 是用在正则表达式的匹配环节，详情可以参阅后文的 \n 条目。而在正则表达式的替换环节，则要使用像 $1、$2、...、$n 这样的语法，例如，'bar foo'.replace(/(...) (...)/, '$2 $1')。$& 表示整个用于匹配的原字符串。
(?:x)	匹配 'x' 但是不记住匹配项。这种括号叫作非捕获括号，使得你能够定义与正则表达式运算符一起使用的子表达式。看看这个例子 /(?:foo){1,2}/。如果表达式是 /foo{1,2}/，{1,2} 将只应用于 'foo' 的最后一个字符 'o'。如果使用非捕获括号，则 {1,2} 会应用于整个 'foo' 单词。更多信息，可以参阅下文的 Using parentheses 条目。
x(?=y)	匹配'x'仅仅当'x'后面跟着'y'.这种叫做先行断言。例如，/Jack(?=Sprat)/会匹配到'Jack'仅当它后面跟着'Sprat'。/Jack(?=Sprat|Frost)/匹配‘Jack’仅当它后面跟着'Sprat'或者是‘Frost’。但是‘Sprat’和‘Frost’都不是匹配结果的一部分。
(?<=y)x	匹配'x'仅当'x'前面是'y'.这种叫做后行断言。例如，/(?<=Jack)Sprat/会匹配到' Sprat '仅仅当它前面是' Jack '。/(?<=Jack|Tom)Sprat/匹配‘Sprat ’仅仅当它前面是'Jack'或者是‘Tom’。但是‘Jack’和‘Tom’都不是匹配结果的一部分。
x(?!y)	仅仅当'x'后面不跟着'y'时匹配'x'，这被称为正向否定查找。例如，仅仅当这个数字后面没有跟小数点的时候，/\d+(?!.)/ 匹配一个数字。正则表达式/\d+(?!.)/.exec("3.141") 匹配‘141’而不是‘3.141’
(?<!*y*)*x*	仅仅当'x'前面不是'y'时匹配'x'，这被称为反向否定查找。例如，仅仅当这个数字前面没有负号的时候，/(?<!-)\d+/ 匹配一个数字。 /(?<!-)\d+/.exec('3') 匹配到 "3". /(?<!-)\d+/.exec('-3') 因为这个数字前有负号，所以没有匹配到。
x|y	匹配‘x’或者‘y’。例如，/green|red/匹配“green apple”中的‘green’和“red apple”中的‘red’
{n}	n 是一个正整数，匹配了前面一个字符刚好出现了 n 次。 比如， /a{2}/ 不会匹配“candy”中的'a',但是会匹配“caandy”中所有的 a，以及“caaandy”中的前两个'a'。
{n,}	n 是一个正整数，匹配前一个字符至少出现了 n 次。例如，/a{2,}/ 匹配 "aa", "aaaa" 和 "aaaaa" 但是不匹配 "a"。
{n,m}	n 和 m 都是整数。匹配前面的字符至少 n 次，最多 m 次。如果 n 或者 m 的值是 0，这个值被忽略。例如，/a{1, 3}/ 并不匹配“cndy”中的任意字符，匹配“candy”中的 a，匹配“caandy”中的前两个 a，也匹配“caaaaaaandy”中的前三个 a。注意，当匹配”caaaaaaandy“时，匹配的值是“aaa”，即使原始的字符串中有更多的 a。
[xyz\]	一个字符集合。匹配方括号中的任意字符，包括转义序列。你可以使用破折号（-）来指定一个字符范围。对于点（.）和星号（*）这样的特殊符号在一个字符集中没有特殊的意义。他们不必进行转义，不过转义也是起作用的。 例如，[abcd] 和 [a-d] 是一样的。他们都匹配"brisket"中的‘b’,也都匹配“city”中的‘c’。/[a-z.]+/ 和/[\w.]+/与字符串“test.i.ng”匹配。
[^xyz\]	一个反向字符集。也就是说， 它匹配任何没有包含在方括号中的字符。你可以使用破折号（-）来指定一个字符范围。任何普通字符在这里都是起作用的。例如，abc 和 a-c 是一样的。他们匹配"brisket"中的‘r’，也匹配“chop”中的‘h’。
[\b\]	匹配一个退格 (U+0008)。（不要和\b混淆了。）
\b	匹配一个词的边界。一个词的边界就是一个词不被另外一个“字”字符跟随的位置或者前面跟其他“字”字符的位置，例如在字母和空格之间。注意，匹配中不包括匹配的字边界。换句话说，一个匹配的词的边界的内容的长度是 0。（不要和 [\b] 混淆了）使用"moon"举例： /\bm/匹配“moon”中的‘m’； /oo\b/并不匹配"moon"中的'oo'，因为'oo'被一个“字”字符'n'紧跟着。 /oon\b/匹配"moon"中的'oon'，因为'oon'是这个字符串的结束部分。这样他没有被一个“字”字符紧跟着。 /\w\b\w/将不能匹配任何字符串，因为在一个单词中间的字符永远也不可能同时满足没有“字”字符跟随和有“字”字符跟随两种情况。备注： JavaScript 的正则表达式引擎将特定的字符集定义为“字”字符。不在该集合中的任何字符都被认为是一个断词。这组字符相当有限：它只包括大写和小写的罗马字母，十进制数字和下划线字符。不幸的是，重要的字符，例如“é”或“ü”，被视为断词。
\B	匹配一个非单词边界。匹配如下几种情况：字符串第一个字符为非“字”字符字符串最后一个字符为非“字”字符两个单词字符之间两个非单词字符之间空字符串例如，/\B../匹配"noonday"中的'oo', 而/y\B../匹配"possibly yesterday"中的’yes‘
\c*X*	当 X 是处于 A 到 Z 之间的字符的时候，匹配字符串中的一个控制符。例如，/\cM/ 匹配字符串中的 control-M (U+000D)。
\d	匹配一个数字。``等价于 [0-9]。例如， /\d/ 或者 /[0-9]/ 匹配"B2 is the suite number."中的'2'。
\D	匹配一个非数字字符。``等价于 [^0-9]。例如， /\D/ 或者 /[^0-9]/ 匹配"B2 is the suite number."中的'B' 。
\f	匹配一个换页符 (U+000C)。
\n	匹配一个换行符 (U+000A)。
\r	匹配一个回车符 (U+000D)。
\s	匹配一个空白字符，包括空格、制表符、换页符和换行符。等价于 [ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]。例如，/\s\w*/ 匹配"foo bar."中的' bar'。经测试，\s不匹配"\u180e"，在当前版本 Chrome(v80.0.3987.122) 和 Firefox(76.0.1) 控制台输入/\s/.test("\u180e") 均返回 false。
\S	匹配一个非空白字符。等价于 [^\f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]。例如，/\S\w*/ 匹配"foo bar."中的'foo'。
\t	匹配一个水平制表符 (U+0009)。
\v	匹配一个垂直制表符 (U+000B)。
\w	匹配一个单字字符（字母、数字或者下划线）。等价于 [A-Za-z0-9_]。例如，/\w/ 匹配 "apple," 中的 'a'，"$5.28,"中的 '5' 和 "3D." 中的 '3'。
\W	匹配一个非单字字符。等价于 [^A-Za-z0-9_]。例如，/\W/ 或者 /[^A-Za-z0-9_]/ 匹配 "50%." 中的 '%'。
\*n*	在正则表达式中，它返回最后的第 n 个子捕获匹配的子字符串 (捕获的数目以左括号计数)。比如 /apple(,)\sorange\1/ 匹配"apple, orange, cherry, peach."中的'apple, orange,' 。
\0	匹配 NULL（U+0000）字符，不要在这后面跟其它小数，因为 \0<digits> 是一个八进制转义序列。
\xhh	匹配一个两位十六进制数（\x00-\xFF）表示的字符。
\uhhhh	匹配一个四位十六进制数表示的 UTF-16 代码单元。
\u{hhhh}或\u{hhhhh}	（仅当设置了 u 标志时）匹配一个十六进制数表示的 Unicode 字符。

---

使用正则表达式

方法	描述
exec	一个在字符串中执行查找匹配的 RegExp 方法，它返回一个数组（未匹配到则返回 null）。
test	一个在字符串中测试是否匹配的 RegExp 方法，它返回 true 或 false。
match	一个在字符串中执行查找匹配的 String 方法，它返回一个数组，在未匹配到时会返回 null。
matchAll	一个在字符串中执行查找所有匹配的 String 方法，它返回一个迭代器（iterator）。
search	一个在字符串中测试匹配的 String 方法，它返回匹配到的位置索引，或者在失败时返回 -1。
replace	一个在字符串中执行查找匹配的 String 方法，并且使用替换字符串替换掉匹配到的子字符串。
split	一个使用正则表达式或者一个固定字符串分隔一个字符串，并将分隔后的子字符串存储到数组中的 String 方法。

通过标志进行高级搜索

标志	描述
g	全局搜索。
i	不区分大小写搜索。
m	多行搜索。
s	允许 . 匹配换行符。
u	使用 unicode 码的模式进行匹配。
y	执行“粘性 (sticky)”搜索，匹配从目标字符串的当前位置开始。

为了在正则表达式中包含标志，请使用以下语法：

var re = /pattern/flags;

或

var re = new RegExp("pattern", "flags");

更多参考：

  MDN: 正则表达式 - JavaScript | MDN

  W3C: JavaScript RegExp 参考手册

优秀文章：正则表达式不要背 - 掘金