Regular Expression Syntax Quick Reference

Regular expressions, also known as regex, are a powerful text pattern matching method used to search, replace and control text. They primarily consist of letters from a to z and various special metacharacters. The application of regular expressions is extensive; originally popularized by Unix, they are now widely used in languages including Scala, PHP, C#, Java, C++, Objective-C, Perl, Swift, VBScript, JavaScript, Ruby, and Python. Learning regular expressions is, in fact, learning a highly flexible logical thought process, allowing manipulation of strings through simple and fast methods.

Regex Character	Description
\	Escapes the next character to interpret it as a special character, a literal character, a back reference, or an octal escape character. For example, "`n`" matches the character "`n`". "`\n`" matches a newline character. The sequence "`\\`" matches "`\`", while "`\(`" matches "`(`".
^	Matches the start position of the input string. If the multiline property of the RegExp object is set, ^ also matches positions following "`\n`" or "`\r`".
$	Matches the end position of the input string. If the multiline property of the RegExp object is set, $ also matches positions preceding "`\n`" or "`\r`".
*	Matches the preceding sub-expression zero or more times. For example, `zo` can match "`z`" and "`zoo`". is equivalent to {0,}.
+	Matches the preceding sub-expression one or more times. For example, `zo+` can match "`zo`" and "`zoo`", but not "`z`". + is equivalent to {1,}.
?	Matches the preceding sub-expression zero or one time. For example, `do(es)?` can match "`does`" or "`do`" in "`does`". ? is equivalent to {0,1}.
{n}	n is a non-negative integer. Matches exactly n times. For example, `o{2}` cannot match "`Bob`"'s "`o`", but can match both "o"s in "`food`".
{n,}	n is a non-negative integer. Matches at least n times. For example, `o{2,}` cannot match "`Bob`"'s "`o`", but can match all occurrences of "`o`" in "`foooood`". `o{1,}` is equivalent to `o+`. `o{0,}` is equivalent to `o*`.
{n,m}	m and n are both non-negative integers, with n<=m. Matches at least n times and at most m times. For example, `o{1,3}` matches at most three `o`s in "`fooooood`". `o{0,1}` is equivalent to `o?`. Note that there should be no spaces between the comma and the two numbers.
?	When this character follows any other quantifier (*,+,?, {n}, {n,}, {n,m}), the matching pattern is non-greedy. Non-greedy mode matches as few characters as possible, whereas the default greedy mode matches as many characters as possible. For example, for the string "`oooo`", "`o+?`" will match a single "`o`", whereas "`o+`" will match all "`o`s."
.	Matches any single character except for "`\n`". To match any character including "`\n`", use a pattern such as "`(.\|\n)`".
(pattern)	Matches the pattern and captures the match. The captured match can be obtained from the Matches collection produced, using the SubMatches collection in VBScript or the $0...$9 properties in JScript. To match parentheses characters, use "`$`" or "`$`".
(?:pattern)	Matches the pattern but does not capture the result, which means this is a non-capturing match and does not store for later use. This is useful when combining different parts of a pattern using the "or" character "`(\|)`". For example, "`industr(?:y\|ies)`" is a more succinct expression than "`industry\|industries`".
(?=pattern)	Positive lookahead, matches a string at the beginning where the pattern matches. This is a non-capturing match, meaning the match does not need to be captured for later use. For example, "`Windows(?=95\|98\|NT\|2000)`" matches "`Windows`" in "`Windows2000`", but does not match "`Windows`" in "`Windows3.1`". Lookaheads do not consume characters, meaning after a match occurs, the next search for a match begins immediately after the last match, rather than from the character following the lookahead.
(?!pattern)	Negative lookahead, matches a string at the beginning where the pattern does not match. This is a non-capturing match, meaning the match does not need to be captured for later use. For example, "`Windows(?!95\|98\|NT\|2000)`" matches "`Windows`" in "`Windows3.1`", but does not match "`Windows`" in "`Windows2000`". Lookaheads do not consume characters, meaning after a match occurs, the next search for a match begins immediately after the last match, rather than from the character following the lookbehind.
(?<=pattern)	Positive lookbehind, similar to positive lookahead, but in reverse direction. For example, "`(?<=95\|98\|NT\|2000)Windows`" can match "`Windows`" in "`2000Windows`", but will not match "`Windows`" in "`3.1Windows`".
(?<!pattern)	Negative lookbehind, similar to negative lookahead, but in reverse direction. For example, "`(?<!95\|98\|NT\|2000)Windows`" can match "`Windows`" in "`3.1Windows`", but will not match "`Windows`" in "`2000Windows`".
x\|y	Matches x or y. For example, "`z\|food`" can match "`z`" or "`food`". "`(z\|f)ood`" matches "`zood`" or "`food`".
[xyz]	Character set. Matches any character contained within. For example, "`[abc]`" can match the "`a`" in "plain".
[^xyz]	Negative character set. Matches any character not contained within. For example, "`[^abc]`" can match the "`p`" in "plain".
[a-z]	Character range. Matches any character within a specified range. For example, "`[a-z]`" can match any lowercase letter character from "`a`" to "`z`".
[^a-z]	Negative character range. Matches any character not in a specified range. For example, "`[^a-z]`" can match any character not in the range from "`a`" to "`z`".
\b	Matches a word boundary, which is the position between a word and a space. For example, "`er\b`" can match "`er`" in "`never`", but cannot match "`er`" in "`verb`".
\B	Matches a non-word boundary. "`er\B`" can match "`er`" in "`verb`", but cannot match "`er`" in "`never`".
\cx	Matches a control character specified by x. For example, \cM matches a Control-M or carriage return. x must be one of A-Z or a-z. Otherwise, treat c as a literal "`c`" character.
\d	Matches a digit character. Equivalent to [0-9].
\D	Matches a non-digit character. Equivalent to [^0-9].
\f	Matches a form feed character. Equivalent to \x0c and \cL.
\n	Matches a newline character. Equivalent to \x0a and \cJ.
\r	Matches a carriage return character. Equivalent to \x0d and \cM.
\s	Matches any whitespace character, including spaces, tabs, form feeds, etc. Equivalent to [ \f\n\r\t\v].
\S	Matches any non-whitespace character. Equivalent to [^ \f\n\r\t\v].
\t	Matches a tab character. Equivalent to \x09 and \cI.
\v	Matches a vertical tab character. Equivalent to \x0b and \cK.
\w	Matches any word character including underscores. Equivalent to "`[A-Za-z0-9_]`".
\W	Matches any non-word character. Equivalent to "`[^A-Za-z0-9_]`".
\xn	Matches n where n is a hexadecimal escape value. The hexadecimal escape value must be exactly two digits long. For example, `\x41` matches "`A`". `\x041` is equivalent to `\x04&1`. ASCII encoding can be used in regular expressions.
\num	Matches num where num is a positive integer. A reference to a captured match. For example, `(.)\1` matches two consecutive identical characters.
\n	Identifies an octal escape value or a backreference. If there have been at least n captured sub-expressions before n, n is a backreference. Otherwise, if n is an octal digit (0-7), n is an octal escape value.
\nm	Identifies an octal escape value or a backreference. If there have been at least nm captured sub-expressions before nm, it is a backreference. If n at least has n captures before it, and m follows it, it is a backreference. If neither condition is met and both n and m are octal digits (0-7), nm matches the octal escape value nm.
\nml	If n is an octal digit (0-3), and both m and l are octal digits (0-7), matches the octal escape value nml.
\un	Matches n where n is a Unicode character represented by four hexadecimal digits. For example, \u00A9 matches the copyright symbol (©).

Common Regular Expressions

Username	/^[a-z0-9_-]{3,16}$/
Password	/^[a-z0-9_-]{6,18}$/
Password 2	(?=^.{8,}$)(?=.\d)(?=.\W+)(?=.[A-Z])(?=.[a-z])(?!.\n).$ (Must include digits/uppercase/lowercase/punctuation, all four types, minimum 8 characters)
Hexadecimal Value	/^#?([a-f0-9]{6}\|[a-f0-9]{3})$/
Email Address	/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/ /^[a-z\d]+(\.[a-z\d]+)@([\da-z](-[\da-z])?)+(\.{1,2}[a-z]+)+$/ or \w+([-+.]\w+)@\w+([-.]\w+)\.\w+([-.]\w+)
URL	/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-])\/?$/ or [a-zA-z]+://[^\s]*
IP Address	/((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)/ /^(?:(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)$/ or ((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)
HTML Tag	/^<([a-z]+)([^<]+)(?:>(.)<\/\1>\|\s+\/>)$/ or <(.)(.)>.<\/\1>\|<(.) \/>
Remove Code\\Comments	(?<!http:\|\S)//.*$
Match Double-byte Characters (including Chinese Characters)	[^\x00-\xff]
Chinese Characters	[\u4e00-\u9fa5]
Range of Chinese Characters in Unicode Encoding	/^[\u2E80-\u9FFF]+$/
Chinese and Full-width Punctuation Characters	[\u3000-\u301e\ufe10-\ufe19\ufe30-\ufe44\ufe50-\ufe6b\uff01-\uffee]
Date (Year-Month-Day)	(\d{4}\|\d{2})-((0?([1-9]))\|(1[1\|2]))-((0?[1-9])\|([12]([1-9]))\|(3[0\|1]))
Date (Month/Day/Year)	((0?[1-9]{1})\|(1[1\|2]))/(0?[1-9]\|([12][1-9])\|(3[0\|1]))/(\d{4}\|\d{2})
Time (Hour:Minute, 24-hour format)	((1\|0?)[0-9]\|2[0-3]):([0-5][0-9])
Mainland China Landline Number	(\d{4}-\|\d{3}-)?(\d{8}\|\d{7})
Mainland China Mobile Number	1\d{10}
Mainland China Postal Code	[1-9]\d{5}
Mainland China ID Card Number (15 or 18 digits)	\d{15}(\d\d[0-9xX])?
Non-negative Integer (Positive Integer or Zero)	\d+
Positive Integer	[0-9][1-9][0-9]
Negative Integer	-[0-9][1-9][0-9]
Integer	-?\d+
Decimal	(-?\d+)(\.\d+)?
Blank Line	\n\s\r or \n\n(editplus) or ^[\s\S ]\n
QQ Number	[1-9]\d{4,}
Words Not Containing abc	\b((?!abc)\w)+\b
Match Leading and Trailing Whitespace Characters	^\s\|\s$
Regular Editing	Below are some replacements for specific Chinese characters (editplus) ^[0-9].\n ^[^第].\n ^[习题].\n ^[\s\S ]\n ^[0-9]\. ^[\s\S ]\n <p[^<>]> href="javascript:if$confirm\('(.?)'$\)window\.location='(.?)'" <span style=".[^"]rgb$255,255,255$">.[^<>]</span> <DIV class=xs0>[\s\S]?</DIV>

Regex Syntax Quick Reference - Common Regex Techniques and Syntax

Regular expressions are a powerful text processing tool. This page provides a regular expression syntax quick reference to help you quickly understand the basic syntax, modifiers, sub-expressions, greedy and non-greedy modes, and more.

Basic Syntax of Regular Expressions

Regular expressions are used to describe rules for string patterns. Common basic syntax includes:

Dot (.): Matches any single character (except newline).
Character Set ([ ]): Matches any character contained within the brackets. For example: [a-z] matches all lowercase letters.
Character Set Exclusion ([^ ]): Matches any character not contained within the brackets. For example: [^0-9] matches any non-digit character.
Quantifiers (*, +, ?): Indicate the number of matches. For example: a* indicates matching zero or more a's.
Anchors (^, $): ^ indicates the start of the string, $ indicates the end of the string.

Common Regular Expression Modifiers

Regular expression modifiers change the matching rules, common modifiers include:

g (global match): Matches all matching strings, not just the first one.
i (ignore case): Matches characters case-insensitively.
m (multi-line): Makes ^ and $ match the beginning and end of each line.

Greedy and Non-Greedy Modes

In regular expressions, quantifiers are greedy by default, matching as many characters as possible. Non-greedy mode can be used by adding a ? after the quantifier, as shown below:

Greedy Mode: a.*b will match all characters between a and b (including multiple b's).
Non-Greedy Mode: a.*?b will match the fewest characters between a and b.

Sub-Expressions and Grouping

Sub-expressions in regular expressions are defined using parentheses (()), commonly used to extract matching parts. Grouping is achieved using the "|" symbol. For example:

Sub-Expression: (abc) matches and captures the string "abc".
Grouping: (abc|def) matches either "abc" or "def".

Quick Reference for Regular Expressions

Below is a quick query for common regular expressions:

Function	Regular Expression
Match Digits	\d
Match Non-Digits	\D
Match Letters	[a-zA-Z]
Match Any Character	.
Match Whitespace Characters	\s

Applications of Regular Expressions

Regular expressions are widely used in the following scenarios:

Data validation: For example, verifying the format of email addresses, phone numbers, IP addresses, etc.
Text search: Finding matching strings within text.
Data cleaning: Using regular expressions to delete or replace specific characters or patterns.
Log analysis: Extracting information from log files, filtering specific log entries.

Tips for Learning Regular Expressions

Start Simple: First master the basic match symbols and syntax, then gradually learn more complex regular expressions.
Practice Often: Deepen your understanding of regular expressions through practical applications.
Use Regular Expression Tools: Use regex testing tools to validate and debug regular expressions.

Start using our Regular Expression Syntax Quick Reference now to enhance your efficiency while writing regular expressions and improve your text processing capabilities!