正则表达式是常见常忘，所以还是记下来比较保险，于是就有了这篇笔记。

Regex

Target String

Description

test

This is a test

会匹配test，testcase等

Symbol

Description

/cx

匹配由x指明的控制字符。例如， /cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。

/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。

Symbol

Description

$

匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '/n' 或 '/r'。要匹配 $ 字符本身，请使用 /$。

( )

标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 /( 和 /)。

*

匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 /*。

+

匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 /+。

.

匹配除换行符 /n之外的任何单字符。要匹配 .，请使用 /。

[

标记一个中括号表达式的开始。要匹配 [，请使用 /[。

?

匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 /?。

/

将下一个字符标记为或特殊字符、或原义字符、或反向引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'/n' 匹配换行符。序列 '//' 匹配 "/"，而 '/(' 则匹配 "("。

^

匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 /^。

{

标记限定符表达式的开始。要匹配 {，请使用 /{。

|

指明两项之间的一个选择。要匹配 |，请使用 /|。

Regex

String

Description

[x^]

A string with x and ^.

匹配x或者“^”

Regex

String

Description

[]x]

A string with x and ]

匹配x或者“]”

[^]x]

A string with x and ]

匹配除了x和”] ”以外的所有字符

Regex

String

Description

[//x]

A string with x and /

匹配x或者“/”

Regex

String

Description

[-x]

A string with x and -

匹配x或者“-”

[x-]

A string with x and -

匹配x或者“-”

Regex

Meaning

Description

/d

[0-9]

所有数字

/w

[a-zA-Z]

表示所有的字符，和文化字体有关

/s

[ /t/r/n]

空格，回车和tab。和文化字体有关

Regex

String

Description

/s/d

1<space>+<space>2<space>=<space>3

匹配后面紧跟着一个数字的空白符

[/s/d]

1<space>+<space>2<space>=<space>3

匹配一个单独的字符或者一个数字或者一个空白符

Regex

Meaning

Description

/D

[^/d]

非数字

/W

[^/w]

非字符，和文化字体有关

/S

[^/s]

非空格，回车和tab。和文化字体有关

Symbol

Description

Description

?

0次获1次

*

0次或n次

+

1次或n次

{min, max}

最少min次，最多max次

Max必须大于等于min。

{min，<不指定> }

最少min次，或者n次

{min}

精确的重复min次

Regex

String

意义

[0-9]+

846，111

匹配数字

([0-9))+

846，111

匹配数字相同的数字

Regex

Function

Description

^

第一个字符之前的位置

包含换行符

$

最后一个字符后面的位置

包含换行符

/A

总是匹配string的第一个位置

不包含换行符

/Z

总是匹配string的最后一个位置

不包含换行符

Regex

String

意义

^

Abc

匹配A之前的位置

$

Abc

匹配c后面的位置

^A

Abc

匹配A

^b

Abc

不能匹配

c$

Abc

匹配c

A$

Abc

不能匹配

Symbol

Function

Memo

/

转义符

(), (?:), (?=), []

括号

*, +, ?, {n}, {n,}, {n,m}

限定符

^, $, /anymetacharacter

定位符

|

或

Symbol

Function

Memo

i

区分大小写

前面加“-”表示关闭选项

s

单行模式匹配

M

多行模式匹配

Characters

Character

Description

Example

Any character except [/^$.|?*+()

All characters except the listed special characters match a single instance of themselves.

a matches a

/ (backslash) followed by any of [/^$.|?*+()

A backslash escapes special characters to suppress their special meaning.

/+ matches +

/xFF where FF are 2 hexadecimal digits

Matches the character with the specified ASCII/ANSI value, which depends on the code page used. Can be used in character classes.

/xA9 matches © when using the Latin-1 code page.

/n, /r and /t

Match an LF character, CR character and a tab character respectively. Can be used in character classes.

/r/n matches a DOS/Windows CRLF line break.

Character Classes or Character Sets [abc]

Character

Description

Example

[ (opening square bracket)

Starts a character class. A character class matches a single character out of all the possibilities offered by the character class. Inside a character class, different rules apply. The rules in this section are only valid inside character classes. The rules outside this section are not valid in character classes, except /n, /r, /t and /xFF

Any character except ^-]/ add that character to the possible matches for the character class.

All characters except the listed special characters.

[abc] matches a, b or c

/ (backslash) followed by any of ^-]/

A backslash escapes special characters to suppress their special meaning.

[/^/]] matches ^ or ]

- (hyphen) except immediately after the opening [

Specifies a range of characters. (Specifies a hyphen if placed immediately after the opening [)

[a-zA-Z0-9] matches any letter or digit

^ (caret) immediately after the opening [

Negates the character class, causing it to match a single character not listed in the character class. (Specifies a caret if placed anywhere except after the opening [)

[^a-d] matches x (any character except a, b, c or d)

/d, /w and /s

Shorthand character classes matching digits 0-9, word characters (letters and digits) and whitespace respectively. Can be used inside and outside character classes

[/d/s] matches a character that is a digit or whitespace

/D, /W and /S

Negated versions of the above. Should be used only outside character classes. (Can be used inside, but that is confusing).)

/D matches a character that is not a digit

Dot

Character

Description

Example

. (dot)

Matches any single character except line break characters /r and /n. Most regex flavors have an option to make the dot match line break characters too.

. matches x or (almost) any other character

Anchors

Character

Description

Example

^ (caret)

Matches at the start of the string the regex pattern is applied to. Matches a position rather than a character. Most regex flavors have an option to make the caret match after line breaks (i.e. at the start of a line in a file) as well.

^. matches a in abc/ndef. Also matches d in "multi-line" mode.

$ (dollar)

Matches at the end of the string the regex pattern is applied to. Matches a position rather than a character. Most regex flavors have an option to make the dollar match before line breaks (i.e. at the end of a line in a file) as well. Also matches before the very last line break if the string ends with a line break.

.$ matches f in abc/ndef. Also matches c in "multi-line" mode.

/A

Matches at the start of the string the regex pattern is applied to. Matches a position rather than a character. Never matches after line breaks.

/A. matches a in abc

/Z

Matches at the end of the string the regex pattern is applied to. Matches a position rather than a character. Never matches before line breaks, except for the very last line break if the string ends with a line break.

./Z matches f in abc/ndef

/z

Matches at the end of the string the regex pattern is applied to. Matches a position rather than a character. Never matches before line breaks.

./z matches f in abc/ndef

Word Boundaries

Character

Description

Example

/b

Matches at the position between a word character (anything matched by /w) and a non-word character (anything matched by [^/w] or /W) as well as at the start and/or end of the string if the first and/or last characters in the string are word characters.

./b matches c in abc

/B

Matches at the position between two word characters (i.e the position between /w/w) as well as at the position between two non-word characters (i.e. /W/W).

/B./B matches b in abc

Alternation

Character

Description

Example

| (pipe)

Causes the regex engine to match either the part on the left side, or the part on the right side. Can be strung together into a series of options.

abc|def|xyz matches abc, def or xyz

| (pipe)

The pipe has the lowest precedence of all operators. Use grouping to alternate only part of the regular expression.

abc(def|xyz) matches abcdef or abcxyz

Quantifiers

Character

Description

Example

? (question mark)

Makes the preceding item optional. Greedy, so the optional item is included in the match if possible.

abc? matches ab or abc

??

Makes the preceding item optional. Lazy, so the optional item is excluded in the match if possible. This construct is often excluded from documentation because of its limited use.

abc?? matches ab or abc

* (star)

Repeats the previous item zero or more times. Greedy, so as many items as possible will be matched before trying permutations with less matches of the preceding item, up to the point where the preceding item is not matched at all.

".*" matches "def" "ghi" in abc "def" "ghi" jkl

*? (lazy star)

Repeats the previous item zero or more times. Lazy, so the engine first attempts to skip the previous item, before trying permutations with ever increasing matches of the preceding item.

".*?" matches "def" in abc "def" "ghi" jkl

+ (plus)

Repeats the previous item once or more. Greedy, so as many items as possible will be matched before trying permutations with less matches of the preceding item, up to the point where the preceding item is matched only once.

".+" matches "def" "ghi" in abc "def" "ghi" jkl

+? (lazy plus)

Repeats the previous item once or more. Lazy, so the engine first matches the previous item only once, before trying permutations with ever increasing matches of the preceding item.

".+?" matches "def" in abc "def" "ghi" jkl

{n} where n is an integer >= 1

Repeats the previous item exactly n times.

a{3} matches aaa

{n,m} where n >= 1 and m >= n

Repeats the previous item between n and m times. Greedy, so repeating m times is tried before reducing the repetition to n times.

a{2,4} matches aa, aaa or aaaa

{n,m}? where n >= 1 and m >= n

Repeats the previous item between n and m times. Lazy, so repeating n times is tried before increasing the repetition to m times.

a{2,4} matches aaaa, aaa or aa

{n,} where n >= 1

Repeats the previous item at least n times. Greedy, so as many items as possible will be matched before trying permutations with less matches of the preceding item, up to the point where the preceding item is matched only n times.

a{2,} matches aaaaa in aaaaa

{n,}? where n >= 1

Repeats the previous item between n and m times. Lazy, so the engine first matches the previous item n times, before trying permutations with ever increasing matches of the preceding item.

a{2,}? matches aa in aaaaa

Grouping and Backreferences

Syntax

Description

Example

(regex)

Round brackets group the regex between them. They capture the text matched by the regex inside them that can be reused in a backreference, and they allow you to apply regex operators to the entire grouped regex.

(abc){3} matches abcabcabc. First group matches abc.

(?:regex)

Non-capturing parentheses group the regex so you can apply regex operators, but do not capture anything and do not create backreferences.

(?:abc){3} matches abcabcabc. No groups.

/1 through /9

Substituted with the text matched between the 1st through 9th pair of capturing parentheses. Some regex flavors allow more than 9 backreferences.

(abc|def)=/1 matches abc=abc or def=def, but not abc=def or def=abc.

Modifiers

Syntax

Description

Example

(?i)

Turn on case insensitivity for the remainder of the regular expression. (Older regex flavors may turn it on for the entire regex.)

te(?i)st matches teST but not TEST.

(?-i)

Turn off case insensitivity for the remainder of the regular expression.

(?i)te(?-i)st matches TEst but not TEST.

(?s)

Turn on "dot matches newline" for the remainder of the regular expression. (Older regex flavors may turn it on for the entire regex.)

(?-s)

Turn off "dot matches newline" for the remainder of the regular expression.

(?m)

Caret and dollar match after and before newlines for the remainder of the regular expression. (Older regex flavors may apply this to the entire regex.)

(?-m)

Caret and dollar only match at the start and end of the string for the remainder of the regular expression.

(?i-sm)

Turns on the options "i" and "m", and turns off "s" for the remainder of the regular expression. (Older regex flavors may apply this to the entire regex.)

(?i-sm:regex)

Matches the regex inside the span with the options "i" and "m" turned on, and "s" turned off.

(?i:te)st matches TEst but not TEST.

Atomic Grouping and Possessive Quantifiers

Syntax

Description

Example

(?>regex)

Atomic groups prevent the regex engine from backtracking back into the group (forcing the group to discard part of its match) after a match has been found for the group. Backtracking can occur inside the group before it has matched completely, and the engine can backtrack past the entire group, discarding its match entirely. Eliminating needless backtracking provides a speed increase. Atomic grouping is often indispensable when nesting quantifiers to prevent a catastrophic amount of backtracking as the engine needlessly tries pointless permutations of the nested quantifiers.

x(?>/w+)x is more efficient than x/w+x if the second x cannot be matched.

?+, *+, ++ and {m,n}+

Possessive quantifiers are a limited yet syntactically cleaner alternative to atomic grouping. Only available in a few regex flavors. They behave as normal greedy quantifiers, except that they will not give up part of their match for backtracking.

x++ is identical to (?>x+)

Lookaround

Syntax

Description

Example

(?=regex)

Zero-width positive lookahead. Matches at a position where the pattern inside the lookahead can be matched. Matches only the position. It does not consume any characters or expand the match. In a pattern like one(?=two)three, both two and three have to match at the position where the match of one ends.

t(?=s) matches the second t in streets.

(?!regex)

Zero-width negative lookahead. Identical to positive lookahead, except that the overall match will only succeed if the regex inside the lookahead fails to match.

t(?!s) matches the first t in streets.

(?<=text)

Zero-width positive lookbehind. Matches at a position to the left of which text appears. Since regular expressions cannot be applied backwards, the test inside the lookbehind can only be plain text. Some regex flavors allow alternation of plain text options in the lookbehind.

(?<=s)t matches the first t in streets.

(?<!text)

Zero-width negative lookbehind. Matches at a position if the text does not appear to the left of that position.

(?<!s)t matches the second t in streets.

Continuing from The Previous Match

Syntax

Description

Example

/G

Matches at the position where the previous match ended, or the position where the current match attempt started (depending on the tool or regex flavor). Matches at the start of the string during the first match attempt.

/G[a-z] first matches a, then matches b and then fails to match in ab_cd.

Conditionals

Syntax

Description

Example

(?(?=regex)then|else)

If the lookahead succeeds, the "then" part must match for the overall regex to match. If the lookahead fails, the "else" part must match for the overall regex to match. Not just positive lookahead, but all four lookarounds can be used. Note that the lookahead is zero-width, so the "then" and "else" parts need to match and consume the part of the text matched by the lookahead as well.

(?(?<=a)b|c) matches the second b and the first c in babxcac

Comments

Syntax

Description

Example

(?#comment)

Everything between (?# and ) is ignored by the regex engine.

a(?#foobar)b matches ab

简单验证电子邮件地址

表达式

(/w[-._/w]*/w@/w[-._/w]*/w/./w{2,3})

描述

简单符合<name>@xxx.com即可。

粗略验证

匹配的例子

[foo@bar.com], [foobar@foobar.com.au]

不匹配的例子

[foo@bar], [$$$@bar.com]

标准验证电子邮件地址

表达式

^(([^<>;()[/]//.,;:@"]+(/.[^<>()[/]//.,;:@"]+)*)|(".+"))@((([a-z]([-a-z0-9]*[a-z0-9])?)|(#[0-9]+)|(/[((([01]?[0-9]{0,2})|(2(([0-4][0-9])|(5[0-5]))))/.){3}(([01]?[0-9]{0,2})|(2(([0-4][0-9])|(5[0-5]))))/]))/.)*(([a-z]([-a-z0-9]*[a-z0-9])?)|(#[0-9]+)|(/[((([01]?[0-9]{0,2})|(2(([0-4][0-9])|(5[0-5]))))/.){3}(([01]?[0-9]{0,2})|(2(([0-4][0-9])|(5[0-5]))))/]))$

描述

所有符合RFC 821（http://www.cis.ohio-state.edu/cgi-bin/rfc/rfc0821.html#page-30）规定的格式的邮件地址

匹配的例子

blah@[10.0.0.1]|||a@b.c

不匹配的例子

non@match@.

大于零的Decimal数字

表达式

(^/d*/.?/d*[1-9]+/d*$)|(^[1-9]+/d*/./d*$)

描述

大于零的Decimal数字

匹配的例子

0.050

5.0000

5000

不匹配的例子

0

0.0

.0

任何Decimal数字

表达式

^(/d|-)?(/d|,)*/.?/d*$

描述

匹配：

纯数字

负数

逗号分割的数字

点分割的decimal格式

匹配的例子

5,000

-5,000

100.044

.2

不匹配的例子

abc

1.3.4

0-99999999的带或不带逗号的数字

表达式

^(/d|-)?(/d|,)*/.?/d*$

描述

匹配：

0-99999999的带或不带逗号的数字

匹配的例子

5,000

100，044

不匹配的例子

123,888,888

1.1

0-65535的值

表达式

^([0-5]?/d?/d?/d?/d|6[0-4]/d/d/d|65[0-4]/d/d|655[0-2]/d|6553

[0-5])$

描述

0-65535数字

匹配的例子

5000

100

不匹配的例子

66666

-2

HTML和XML标记

表达式

<[^>]+>

描述

所有的html和xml标记

匹配的例子

<b>

</b>

5.0000

5000

不匹配的例子

http://www.regexlib.com/Add.aspx

ISBN格式的字符串

表达式

<[^>]+>

描述

ISBN格式的字符串。

详细定义：http://www.isbn.org/standards/home/isbn/international/html/usm4.htm

匹配的例子

ISBN 0 93028 923 4

ISBN 1-56389-668-0

ISBN 1-56389-016-X

不匹配的例子

http://www.regexlib.com/Add.aspx

GUID

表达式

^[{|/(]?[0-9a-fA-F]{8}[-]?([0-9a-fA-F]{4}[-]?){3}[0-9a-fA-F]{12}[/)|}]?$

描述

以下格式的32位GUID:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}

(xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)

匹配的例子

914D226A-2F5B-4944-934D-96BBE6571977

{914D226A-2F5B-4944-934D-96BBE6571977}

不匹配的例子

914D226A-2F5B-4944-XXXX-96BBE6571977

{914D226A-2F5B-4944-XXXX-96BBE6571977}

信用卡号

表达式

^[{|/(]?[0-9a-fA-F]{8}[-]?([0-9a-fA-F]{4}[-]?){3}[0-9a-fA-F]{12}[/)|}]?$

描述

16位数字

16位数字用连字符或者空格或者分割

匹配的例子

1234343425262837

1111-2323-2312-3434

1111 2323 2312 3434

不匹配的例子

1111 2323 2312-3434

连在一起的两个相同的单词

表达式

(/w+)/s+/1

描述

验证连在一起的两个相同的单词

匹配的例子

abc abc

不匹配的例子

abc abcd

双引号括起来的词

表达式

"((//")|[^"(//")])+"

描述

验证用双引号括起来的词

匹配的例子

“Abc”

“abc”sff”

不匹配的例子

“sdfsdfsdf

验证html中的16位颜色值

表达式

^#?([a-f]|[A-F]|[0-9]){3}(([a-f]|[A-F]|[0-9]){3})?$

描述

验证html中的16进制的颜色值

#是可选的。

匹配的例子

#00ccff

ffffcc

不匹配的例子

blue

0x000000

验证包含JSP事件的html代码

表达式

<[a-zA-Z][^>]*/son/w+=(/w+|'[^']*'|"[^"]*")[^>]*>

描述

验证包含JSP事件的html代码

匹配的例子

<IMG οnmοuseοver="window.close()">

不匹配的例子

IMG src="star.gif"

验证一对封闭的xml标记

表达式

^#?([a-f]|[A-F]|[0-9]){3}(([a-f]|[A-F]|[0-9]){3})?$

描述

验证一对括起来的xml标记。

匹配的例子

<body> text<br/>More Text </body>

<a href="link.html">Link</a>

不匹配的例子

blue

0x000000

验证HTML中所有合法的on事件

表达式

(?i:on(blur|c(hange|lick)|dblclick|focus|keypress|(key|mouse

)(down|up)|(un)?load|mouse(move|o(ut|ver))|reset|s(elect|ubm

it)))

描述

验证HTML中所有合法的on事件

匹配的例子

onclick

onmouseover

不匹配的例子

Click

Move

查找html中的注释

表达式

<!/-/-.*?/-/->

描述

查找html中的注释

匹配的例子

<!-- <h1>this text has been removed</h1> -->

不匹配的例子

<h1>this text has been removed</h1>

查找html中的特定文件（swf.jpg.gif…）

表达式

<[^>]*/n?.*=("|')?(.*/.jpg)("|')?.*/n?[^<]*>

描述

查找html中的特定文件（swf.jpg.gif…）

把jpg换为gif，即是查找所有的gif文件。

匹配的例子

<td background="../img/img.jpg" >

不匹配的例子

= img.jpg

日期验证

表达式

^(?:(?:(?:(?:(?:1[6-9]|[2-9]/d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))(//|-|/.)(?:0?2/1(?:29)))|(?:(?:(?:1[6-9]|[2-9]/d)?/d{2})(//|-|/.)(?:(?:(?:0?[13578]|1[02])/2(?:31))|(?:(?:0?[1,3-9]|1[0-2])/2(29|30))|(?:(?:0?[1-9])|(?:1[0-2]))/2(?:0?[1-9]|1/d|2[0-8]))))$

描述

验证格式为y/m/d的日期从1600/1/1 - 9999/12/31的日期

匹配的例子

04/2/29

2002-4-30

02.10.31

不匹配的例子

2003/2/29

02.4.31

00/00/00

日期和时间验证

表达式

^(?=/d)(?:(?:(?:(?:(?:0?[13578]|1[02])(//|-|/.)31)/1|(?:(?:0?[1,3-9]|1[0-2])(//|-|/.)(?:29|30)/2))(?:(?:1[6-9]|[2-9]/d)?/d{2})|(?:0?2(//|-|/.)29/3(?:(?:(?:1[6-9]|[2-9]/d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))|(?:(?:0?[1-9])|(?:1[0-2]))(//|-|/.)(?:0?[1-9]|1/d|2[0-8])/4(?:(?:1[6-9]|[2-9]/d)?/d{2}))($|/ (?=/d)))?(((0?[1-9]|1[012])(:[0-5]/d){0,2}(/ [AP]M))|([01]/d|2[0-3])(:[0-5]/d){1,2})?$

描述

验证所有合法的日期和时间

匹配的例子

20:20

04/2/29

02.4.31

02.10.312002-4-30

02.10.31

不匹配的例子

2003/2/29

00/00/00

标准ANSI SQL日期验证

表达式

^((/d{2}(([02468][048])|([13579][26]))[/-///s]?((((0?[13578])|(1[02]))[/-///s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[/-///s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[/-///s]?((0?[1-9])|([1-2][0-9])))))|(/d{2}(([02468][1235679])|([13579][01345789]))[/-///s]?((((0?[13578])|(1[02]))[/-///s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[/-///s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[/-///s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))(/s(((0?[1-9])|(1[0-2]))/:([0-5][0-9])((/s)|(/:([0-5][0-9])/s))([AM|PM|am|pm]{2,2})))?$

描述

匹配ANSI SQL的日期格式：YYYY-mm-dd hh:mi:ss am/pm

包括检查从1901-2099是否是闰年。

匹配的例子

2004-2-29

2004-02-29 10:29:39 pm

2004/12/31

不匹配的例子

04-2-29

04-02-29 10:29:39 pm

04/12/31

匹配字体

表达式

^(/d)(/d)*( )*(px|PX|Px|pX|pt|PT|Pt|pT|)$

描述

查找字体的后缀

匹配的例子

1px

100 PT

20Px

不匹配的例子

1abc

px

1 sdfs

匹配MD5哈西字符串

表达式

^(/d)(/d)*( )*(px|PX|Px|pX|pt|PT|Pt|pT|)$

描述

^([a-z0-9]{32})$

匹配的例子

790d2cf6ada1937726c17f1ef41ab125

不匹配的例子

790D2CF6ADA1937726C17F1EF41AB125

Class

Description

Regex

不可变的(只读)的正则表达式的实例，包括一些静态方法

Capture

包含单个子表达式匹配的结果，不能实例化，必须通过Group和Match来访问。

CaptureCollection

Capture的序列

Group

一组表达式匹配的结果，由Capture继承而来

GroupCollection

Group的序列

Match

一个正则表达式的匹配结果，由Group继承而来

MatchCollection

Match的序列

Regex

Result

(gr[ae]y)+

Graygrey

(gray)+

Gray

(grey)+

Grey