正则表达式特殊字符匹配,正则表达式匹配？

正则表达式特殊字符匹配,正则表达式匹配？详细介绍

本文目录一览： 正则表达式中一些特殊字符的用法？

分类: 电脑/网络 >> 程序设计 >> 其他编程语言
问题描述:

请问谁知道正则表示式中的特殊字符的用法？如：
[ ] \ ^ $ . | ? * + (
如果要想匹配它们怎么解决？
解析:

\

将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“n”匹配字符“n”。“\n”匹配一个换行符。序列“\\”匹配“\”而“\(”则匹配“(”。
^
匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。
$
匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。
*
匹配前面的子表达式零次或多次。例如，zo*能匹配“z”以及“zoo”。*等价于{0,}。
+
匹配前面的子表达式一次或多次。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
?
匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“do”或“does”中的“do”。?等价于{0,1}。
{n}
n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。
{n,}
n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。
{n,m}
m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
?
当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“oooo”，“o+?”将匹配单个“o”，而“o+”将匹配所有“o”。
.
匹配除“\n”之外的任何单个字符。要匹配包括“\n”在内的任何字符，请使用像“[.\n]”的模式。
(pattern)
匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches *** 得到，在VBScript中使用SubMatches *** ，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“\(”或“\)”。
(?:pattern)
匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用“或”字符(|)来组合一个模式的各个部分是很有用。例如，“industr(?:y|ies)就是一个比”industry|industries'更简略的表达式。
(?=pattern)
正向预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)
负向预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
x|y 匹配x或y。例如，“z|food”能匹配“z”或“food”。“(z|f)ood”则匹配“zood”或“food”。
[xyz]
字符 *** 。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。
[^xyz]
负值字符 *** 。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“p”。
[a-z]
字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。
[^a-z]
负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
\b
匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。
\B
匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。
\cx
匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。
\d
匹配一个数字字符。等价于[0-9]。
\D
匹配一个非数字字符。等价于[^0-9]。
\f
匹配一个换页符。等价于\x0c和\cL。
\n
匹配一个换行符。等价于\x0a和\cJ。
\r
匹配一个回车符。等价于\x0d和\cM。
\s
匹配任何空白字符，包括空格、制表符、换页符等等。等价于[\f\n\r\t\v]。
\S
匹配任何非空白字符。等价于[^\f\n\r\t\v]。
\t
匹配一个制表符。等价于\x09和\cI。
\v
匹配一个垂直制表符。等价于\x0b和\cK。
\w
匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]”。
\W
匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
\xn
匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“\x41”匹配“A”。“\x041”则等价于“\x04”&“1”。正则表达式中可以使用ASCII编码。.
\num
匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)\1”匹配两个连续的相同字符。
\n
标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字(0-7)，则n为一个八进制转义值。
\nm
标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式，则nm为向后引用。如果\nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字(0-7)，则\nm将匹配八进制转义值nm。
\nml
如果n为八进制数字(0-3)，且m和l均为八进制数字(0-7)，则匹配八进制转义值nml。
\un
匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（?）。
替换 :
|
竖直分隔符代表替换。例如"gray|grey"可以匹配grey或gray。
数量限定
某个字符后的数量限定符用来限定前面这个字符允许出现的个数。最常见的数量限定符包括+, ?,和*（不加数量限定则代表出现一次且仅出现一次）：
+
加号代表前面的字符必须至少出现一次。(1次，或多次)。例如，"goo+gle"可以匹配google，gooogle，goooogle等;
?
问号代表前面的字符最多只可以出现一次。(0次，或1次)。例如，"colou?r"可以匹配colour或者color;
*
星号代表前面的字符可以不出现，也可以出现一次或者多次。(0次，或1次，或多次)。例如，"0*42"可以匹配42，042，0042，00042等。
捕获 :
圆括号可以用来定义操作符的范围和优先度。例如，"gr(a|e)y"等价于"gray|grey"，"(grand)?father"匹配father和grandfather。
上述这些构造子都可以自由组合，因此，"H(ae?|?)ndel"和"H(a|ae|?)ndel"是相同的。
精确的语法可能因不同的工具或程序而异。

正则表达式中的常用特殊字符

字符：\ss

1.反斜杠表示下一个字符是特殊的

2.反斜杠也可以表示将其后的特殊字符，转义为字面量

字符：^

1. 表示字符串开头要以^后面的字符集合匹配 。匹配输入的开始。

字符：$

1.匹配输入的结束

字符：n*

1.匹配任何 ? 包含零个或多个 n 的字符串。。等价于 {0,}。

字符： n+

1.匹配任何包含至少一个 n?的字符串。。等价于 {1,}。

字符：n？

1.匹配任何 ? 包含零个或一个??n 的字符串。。等价于 {0,1}。

2.如果 紧跟在任何量词 *、 +、??或 {} 的后面 ，将会使量词变为 非贪婪 的（匹配尽量少的字符），和缺省使用的 贪婪模式 （匹配尽可能多的字符）正好相反。

字符：.

1.表示除换行符之外的单个任何字符

字符：（）? ，分组

字符： a | b，? ? ?| 或者，匹配a或者b 字符的字符串

字符：（？ ： x）

1.匹配包含 x （x代表 字符集合, 例如abc） 的字符串

字符：x（？：y）

匹配 x后面紧跟y（y代表 字符集合 ） 的字符串

字符：x（？! y）

匹配 x后面不跟这y（y代表 字符集合 ） 的字符串

\s : 空格

\S : 非空格

\d : 数字

\D : 非数字

\w : 字符 ( 字母 ，数字，下划线_ )

\W : 非字母、数组、下划线

字符：｛n｝

1.表示｛｝前面的字符要出现n次，才能成功匹配字符串

字符｛n , m｝

1.表示｛｝前面的字符至少出现n次，最多出现m次，才能成功匹配字符串

字符： [? ]?

1.[] 内是 一个字符 范围。例如? ?[ abcd ] 等价于=> [ a-d]

2.[ ^abc] 里^表示一个字符不再指定范围内。

\n 表示重复的某个子项

\1 重复的第一个子项

\2 重复的第二个子项

正则表达式，匹配特定字符后面的内容

(姓名：)(.*)(，)(.*)，这样取\2 得到的是：中国人，地址。
1.表达式内固定内容的字符串能不写尽量不写，能简写的尽量简化来写（如前面写的abc部分不能写死）
2.可以少量使用前瞻（正向），后瞻（反向）基本不学，学了还要研究那些浏览器支持，不敢用，太多了也学不动。
3.NoJS(Not Only JavaScript)；不仅仅是浏览器中的js；不过js的正则/exp/字面量写法简洁到没盆友（哪个语言），函数、对象、字符串统统不需要。
扩展资料：
在test.txt文件中的每一行中搜索正则表达式r.t，并打印输出匹配的行。正则表达式r.t匹配一个r接着任何一个字符再接着一个t。所以它将匹配文件中的rat和rut，而不能匹配Rotten中的Rot，因为正则表达式是大小写敏感的。
要想同时匹配大写和小写字母，应该使用字符区间元字符（方括号）。正则表达式[Rr]能够同时匹配R和r。所以，要想匹配一个大写或者小写的r接着任何一个字符再接着一个t就要使用这个表达式：[Rr].t。
要想匹配行首的字符要使用抑扬字符（^）——有时也被叫做插入符。例如，想找到text.txt中行首"he"打头的行，你可能会先用简单表达式he，但是这会匹配第三行的the，所以要使用正则表达式^he，它只匹配在行首出现的he。
有时候指定“除了×××都匹配”会比较容易达到目的，当抑扬字符（^）出方括号中时，它表示“排除”，例如要匹配he ，但是排除前面是t or s的情形（也就是the和she），可以使用：[^st]he。
参考资料：百度百科-正则表达式
(姓名：)(.*)(，)(.*)，这样取\2 得到的是：中国人，地址。
正则表达式对字符串（包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”））操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
正则表达式模式描述在搜索文本时要匹配的一个或多个字符串。
扩展资料：
在正则表达式中，放在圆括号中的是分组，按括号出现顺序可用\1，\2...\9(或$1,$2...$9)引用整个正则用\0或$0引用。因此替换中\1引用了括号中匹配的内容，然后加上要添加的字符。
其中：
\S: 表示匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\s: 表示匹配匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
*： 表示匹配前面的子表达式零次或多次。
[\s\S]： 表示出现空白和非空白中的任意一个字符，即是任意字符。
参考资料来源：百度百科 ——正则表达式
(姓名：)(.*)(，)(.*)
这样取\2 得到的是：中国人，地址
(姓名：)(.*)(，)(.*)(，)(.*)
这样\2 得到的是：中国人
如果前面是固定的“姓名：”的话，试试(?<=姓名：).*?(?=，\d{11})。
正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。
扩展资料：
正则表达式由一些普通字符和一些元字符（metacharacters）组成。普通字符包括大小写的字母和数字，而元字符则具有特殊的含义，我们下面会给予解释。
在最简单的情况下，一个正则表达式看上去就是一个普通的查找串。例如，正则表达式"testing"中没有包含任何元字符，它可以匹配"testing"和"testing123"等字符串，但是不能匹配"Testing"。
参考资料来源：百度百科-正则表达式

正则表达式匹配？

你可以使用以下正则表达式来提取满足条件的内容：
\${[^{}]+}
解析：
\${ 匹配 ${，匹配 $ 和 { 字符。
[^{}]+ 匹配中间内容，其中 [^{}] 表示除了 { 和 } 之外的任意字符，+ 表示匹配一个或多个。
这个正则表达式可以匹配所有以 ${ 开头和 } 结尾的中间内容，并且将内容本身里的 {} 符号也作为一部分提取出来。
使用该正则表达式进行匹配时，可能需要根据你使用的编程语言或工具的要求进行适当的转义或调整。
希望对你有所帮助，望给予采纳，谢谢！
要提取以${开头和}结尾的中间内容，并包括内容本身中的{}，可以使用以下正则表达式：
\$\{(.*?)\}
这个正则表达式的含义是：
\$\{：匹配以${开头的字符串。
(.*?)：使用非贪婪模式，匹配任意字符，直到遇到下一个}为止。
\}：匹配以}结尾的字符串。
在正则表达式中使用了()来创建一个捕获组，这样就可以提取匹配到的内容。
请注意，不同的编程语言和工具可能对正则表达式的语法有所差异，以上示例适用于大多数常见的正则表达式实现。
以下是Python语言中，使用re模块来进行正则表达式的匹配和提取。
运行以上代码，输出import re
# 待匹配的字符串
text = '${User.Name} ${Match(User.Gender,"\\d{2}")} ${Match(User.Birthday,"\\d{2,3}")} ${Match(User.Address,"\\d{2,}")}'
# 正则表达式pattern = r'\$\{(.*?)\}'
# 使用正则表达式进行匹配matches = re.findall(pattern, text)
# 输出匹配到的内容
for match in matches:
print(match)结果为：
User.Name
Match(User.Gender,"\d{2}")
Match(User.Birthday,"\d{2,3}")
Match(User.Address,"\d{2,}")
思路是re.findall()函数来进行正则表达式的匹配，将匹配到的内容存储在matches列表中。然后，遍历matches列表，输出每个匹配到的内容。
正则中\是一个特殊字符，需要使用\\来转义。因此，正则表达式中的\$\{(.*?)\}实际上表示的是${(.*?)}，即匹配以${开头和}结尾的中间内容。
希望以上回答能满足你的需求。如果有任何疑问，请随时提问我。谢谢你！
要提取表达式中以${开头、以}结尾的内容，并包括内容本身中的{}，可以使用以下正则表达式进行匹配：
\$\{[^{}]+\}
在C#代码中，可以使用Regex.Matches方法来匹配并提取符合正则表达式的内容。以下是一个示例代码：
using System;
using System.Text.RegularExpressions;
class Program{ static void Main()
{ string expression = "${User.Name} ${Match(User.Gender,\"\\d{2}\")} ${Match(User.Birthday,\"\\d{2,3}\")} ${Match(User.Address,\"\\d{2,}\")}"; string pattern = @"\$\{[^{}]+\}";
Regex regex = new Regex(pattern);
MatchCollection matches = regex.Matches(expression); foreach (Match match in matches)
{ string extractedContent = match.Value;
Console.WriteLine(extractedContent);
}
}
}
运行上述代码，将会输出匹配到的内容：
${User.Name}${Match(User.Gender,"\d{2}")}${Match(User.Birthday,"\d{2,3}")}${Match(User.Address,"\d{2,}")}
这样就能提取表达式中符合规则的内容，并将{}作为内容的一部分进行提取。
请注意，在正则表达式中，{}是具有特殊意义的元字符，需要进行转义，因此在表达式中出现{}时，需要使用\进行转义，即\"\\d{2}\"和\"\\d{2,3}\"。
希望这个例子能对您有所帮助。如有其他问题，请随时提问。
正则表达式是一种用于描述字符串模式的工具，通过使用特定的语法规则，可以方便地进行字符串匹配、查找、替换等操作。
在正则表达式中，常用的匹配模式包括：
1.普通字符：可以直接匹配对应的字符，例如字符"a"可以匹配字符串中的"a"。
2.字符类：用方括号([])表示，可以匹配方括号中包含的任意一个字符。例如，"[aeiou]"可以匹配任意一个元音字母。
3.
元字符：具有特殊含义的字符，例如点号(.)可以匹配任意一个字符，星号(*)表示前面的元素可以出现任意次（包括0次），加号(+)表示前面的元素至少出现一次。
4.边界匹配：用于限定匹配的位置，例如^表示匹配字符串的开头，$表示匹配字符串的结尾。
5.
量词：用于指定匹配的次数，例如{3}表示前面的元素必须出现3次，{3,5}表示前面的元素可以出现3到5次。
6.
转义字符：用于匹配特殊字符本身，例如"."可以匹配点号本身。
正则表达式的具体语法规则较为复杂，可以根据具体的匹配需求进行学习和使用。在编程语言中，通常提供了正则表达式的相关函数或方法，可以方便地进行字符串匹配操作。

写个可以匹配一下各种特殊字符的正则表达式。

((?=[\x21-\x7e]+)[^A-Za-z0-9])
这个匹配所有键盘上可见的非字母和数字的符号
var patrn = /[`~!@#$%^&*()_\-+=<>?:"{}|,.\/;'\\[\]·~！@#￥%……&*（）——\-+={}|《》？：“”【】、；‘’，。、]/im; if (!patrn.test(str)) {// 如果包含特殊字符返回false return false; } return true;这个是输入框防止特殊字符勿输入验证，包括键盘上所有特殊字符的英文和中文状态。需要者可以根据自身需求而定！谢谢！
[^\w\s]+
匹配非空 非字母 非数字 即可
1、定义一个正则表达式，用来测试字符串is的匹配。
2、接着，使用定义的正则表达式，测试单词this的匹配结果。
3、运行程序，可以看到匹配的结果为true，即以上定义的正则表达式不能实现严格的匹配。
4、如果要实现正则表达式严格的匹配，则要在表达式中加入\b符号。
5、运行程序，可以看到结果为false，即正则表达式严格匹配字符串了。

正则表达式必须包含字母数字和特殊字符

正则表达式要实现必须包含字母数字和特殊字符，那么，我们就必须判断该字符串中：

1. 包含字母

2. 包含数字

3. 包含特殊字符

为了简化问题，这里对特殊字符做下限定，指：_-@&=，大家在实际应用中，可以自行扩充这个限定的字符区间。

因此，我们的正则可以写成：

^(?=.*?[a-z])(?=.*?[0-9])(?=.*?[_\-@&=])[a-z0-9_\-@&=]+$

当然，如果需要限定字符串长度，我们后面的[a-z0-9_\-@&=]+可以改为一个长度范围，如6-16：[a-z0-9_\-@&=]{6,16}

下面我们来解读一下上面的正则：

正则以^开始，限定匹配字符串是从开始位置进行匹配，(?=.*?[a-z])是肯定型顺序 环视 ，限定当前位置的后面，能匹配.*?[a-z]，也就是，能够匹配到一个字母，同理，(?=.*?[0-9])表示限定当前位置的后面，能匹配一个数字，(?=.*?[_\-@&=])表示限定当前位置的后面，能匹配一个特殊字符，而[a-z0-9_\-@&=]+就是前面那些环视限定的位置，即表示[a-z0-9_\-@&=]+中，至少匹配一个字母、一个数字、一个特殊字符，最终匹配到达字符串结束位置$。

正则表达式：匹配中间有特定字符串字符串

\[+2014+\]
贪婪匹配即可，唯一需要注意的是方括号要转译。
"\w+\[1234\]\w+"
^.*\[2014\].*$
只要含有[2014]，字符串就会验证通过 ，中括号是正则的元字符，需要用\转义
前后的XXXX是任意字符，没有限制，因此只要含有[2014]，整个单行的字符串会被匹配

c++中使用正则表达式匹配字符串

c++的正则表达式在regex头文件中，【#include

】

首先，正则表达式常用的字符匹配方法，需要记住的特殊字符有：

遇到的问题：accountID是14个数字组成的字符串，匹配以“80”结尾的accountID，不能直接用‘80$’和'[8][0]$'，必须14个全部匹配才行，正确匹配模板为”[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][8][0]“。regex_match(accountID,r)需要accountID整个字符串与模板r匹配才会返回True.

正则表达式字符匹配

正则表达式是匹配模式，要么匹配字符，要么匹配位置
本文所用图示化工具： Regulex
横向模糊指的是，一个正则可匹配的字符串的长度不是固定的，可以是多种情况的
其实现的方式是使用量词。譬如 {m,n} ，表示连续出现最少 m 次，最多 n 次
纵向模糊指的是，一个正则匹配的字符串，具体到某一位字符时，它可以不是某个确定的字符，可以有多种 可能
其实现的方式是使用字符组。譬如 [abc] ，表示该字符是可以字符 a 、 b 、 c 中的任何一个
需要强调的是，虽叫字符组（字符类），但只是其中一个字符
例如 [ abc] ，表示匹配一个字符，它可以是 a 、 b 、 c 之一
如果字符组里的字符特别多的话，怎么办？可以使用范围表示法。
比如 [123456abcdefGHIJKLM] ，可以写成 [ 1-6a-fG-M] 。用连字符 - 来省略和简写
因为连字符有特殊用途，那么要匹配 a 、 - 、 z 这三者中任意一个字符，该怎么做呢？
不能写成 [a-z] ，因为其表示小写字符中的任何一个字符
可以写成如下的方式： [-az] 或 [az-] 或 [a\-z]
即要么放在开头，要么放在结尾，要么转义。总之不会让引擎认为是范围表示法就行了
纵向模糊匹配，还有一种情形就是，某位字符可以是任何东西，但就不能是 a 、 b 、 c
此时就是排除字符组（反义字符组）的概念。例如 [^abc] ，表示是一个除 a 、 b 、 c 之外的任意一个字符。字符组的第一位放 ^ （脱字符），表示求反的概念。
当然，也有相应的范围表示法
如果要匹配任意字符怎么办？可以使用 [\d\D] 、 [\w\W] 、 [\s\S] 和 [^] 中任何的一个
量词也称重复。掌握 {m,n} 的准确含义后，只需要记住一些简写形式
其中正则 /\d{2,5}/ ，表示数字连续出现 2 到 5 次。会匹配 2 位、 3 位、 4 位、 5 位连续数字。
但是其是贪婪的，它会尽可能多的匹配。你能给我 6 个，我就要 5 个。你能给我 3 个，我就要 3 个
反正只要在能力范围内，越多越好
我们知道有时贪婪不是一件好事（请看文章最后一个例子）。而惰性匹配，就是尽可能少的匹配：
其中 /\d{2,5}?/ 表示，虽然 2 到 5 次都行，当 2 个就够的时候，就不再往下尝试了
通过在量词后面加个问号就能实现惰性匹配，因此所有惰性匹配情形如下：
一个模式可以实现横向和纵向模糊匹配。而多选分支可以支持多个子模式任选其一
具体形式如下： (p1|p2|p3) ，其中 p1 、 p2 和 p3 是子模式，用 | （管道符）分隔，表示其中任何之一
例如要匹配字符串 good 和 nice 可以使用 /good|nice/
但有个事实我们应该注意，比如我用 /good|goodbye/ ，去匹配 goodbye 字符串时，结果是 good ：
而把正则改成 /goodbye|good/ ，结果是：
也就是说，分支结构也是惰性的，即当前面的匹配上了，后面的就不再尝试了
匹配字符，无非就是字符组、量词和分支结构的组合使用罢了。
下面找几个例子演练一下（其中，每个正则并不是只有唯一写法）：
要求匹配：
分析： 表示一个 16 进制字符，可以用字符组 [0-9a-fA-F]
其中字符可以出现 3 或 6 次，需要是用量词和分支结构
使用分支结构时，需要注意顺序
正则如下：
以 24 小时制为例
要求匹配：
分析：
共 4 位数字，第一位数字可以为 [0-2]
当第 1 位为 2 时，第 2 位可以为 [0-3] ，其他情况时，第 2 位为 [0-9]
第 3 位数字为 [0-5] ，第 4 位为 [0-9]
正则如下：
如果也要求匹配 7:9 ，也就是说时分前面的 0 可以省略
此时正则变成：
比如 yyyy-mm-dd 格式为例
要求匹配：
分析：
年，四位数字即可，可用 [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])
正则如下：
要求匹配：
分析：
整体模式是：
其中匹配 F:\ ，需要使用 [a-zA-Z]:\\ ，其中盘符不区分大小写，注意 \ 字符需要转义
文件名或者文件夹名，不能包含一些特殊字符，此时我们需要排除字符组 [^\\:*<>|"?\r\n/] 来表示合法 字符
另外它们的名字不能为空名，至少有一个字符，也就是要使用量词 + 。因此匹配 文件夹 \ ，可用 [^\\:*<>|"?\r\n/]+\\
另外 文件夹```，可以出现任意次。也就是 ([^\\:*<>|"?\r\n/]+\\)* 。其中括号表示其内部正则是一个整体。具体详细请参考第三章
路径的最后一部分可以是 文件夹，没有 \ ，因此需要添加 ([^\\:*<>|"?\r\n/]+)?
最后拼接成了一个看起来比较复杂的正则：
其中，在 JavaScript 中字符串要表示字符 \ 时，也需要转义
要求从
提取出 id="container"
可能最开始想到的正则是：
因为 . 是通配符，本身就匹配双引号的，而量词 * 又是贪婪的，当遇到 container 后面双引号时，是不会停下来，会继续匹配，直到遇到最后一个双引号为止
解决之道，可以使用惰性匹配：
当然，这样也会有个问题。效率比较低，因为其匹配原理会涉及到“回溯”这个概念（这里也只是顺便提一 下，后面会详细说明）。可以优化如下：