\ | Marks the next character as either a special character or a literal. For example:
-
n matches the character n. "\n" matches a
newline character.
- The sequence
\\ matches \ and \( matches (.
|
^ | Matches the beginning of input. |
$ | Matches the end of input. |
* | Matches the preceding character zero or more times. For
example, "zo*" matches either z or zoo.
|
+ | Matches the preceding character one or more times. For
example, "zo+" matches zoo but not z.
|
? | Matches the preceding character zero or one time. For
example, a?ve? matches the ve in never.
|
. | Matches any single character except a newline character. |
(subexpression)
| Matches subexpression and remembers the match.
If a part of a regular expression is enclosed in parentheses, that part of the regular expression is grouped together.
Thus a regex operator can be applied to the entire group.
- If you need to use the matched substring within the same regular expression, you can retrieve it
using the backreference (
\num, where num = 1..n). - If you need to refer the matched substring somewhere outside the current regular expression (for
example, in another regular expression as a replacement string), you can retrieve it using the
dollar sign (
$num, where num = 1..n). - If you need to include the parentheses characters into a subexpression,
use
\( or \).
|
x |y | Matches either x or y. For example, z|wood
matches z or wood. (z|w)oo matches zoo or wood.
|
{n}
| n is a nonnegative integer. Matches exactly n
times. For example, o{2} does not match the o in Bob, but
matches the first two o's in foooood.
|
{n,} | n is a nonnegative integer. Matches at least n
times.
For example, o{2,} does not match the o in Bob and
matches all the o's in "foooood."
o{1,} is equivalent to o+. o{0,}
is equivalent to o*.
|
{
n
,
m
}
| m and n are nonnegative integers. Matches at least n
and at most m times. For example, o{1,3} matches
the first three o's in "fooooood." o{0,1} is equivalent to o?.
|
[xyz] | A character set. Matches any one of the enclosed
characters. For example, [abc] matches the a in plain.
|
[^
xyz
]
| A negative character set. Matches any character not
enclosed. For example, [^abc] matches the p in plain.
|
[
a-z
]
| A range of characters. Matches any character in the
specified range. For example, "[a-z]" matches any lowercase alphabetic
character in the range a through z.
|
[^
m-z
]
| A negative range characters. Matches any character not in
the specified range. For example, [^m-z] matches any character not in the
range m through z.
|
\b | Matches a word boundary, that is, the position between a
word and a space. For example, er\b matches the er in never but not
the er in verb.
|
\B | Matches a non-word boundary. ea*r\B matches the ear in
never early.
|
\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. |
\n | Matches a newline character. |
\r | Matches a carriage return character. |
\s | Matches any white space including space, tab, form-feed,
etc. Equivalent to [ \f\n\r\t\v].
|
\S | Matches any nonwhite space character. Equivalent to [^ \f\n\r\t\v].
|
\t | Matches a tab character. |
\v | Matches a vertical tab character. |
\w | Matches any word character including underscore. Equivalent to [A-Za-z0-9_].
|
\W | Matches any non-word character. Equivalent to [^A-Za-z0-9_].
|
\num | Matches num, where num is a positive integer, denoting a reference back to remembered matches.
For example, (.)\1 matches two consecutive identical characters.
|
\n | Matches n, where n is an octal escape value.
Octal escape values should be 1, 2, or 3 digits long.
For example, \11 and
\011 both match a tab character.
\0011 is the equivalent of \001
&1.
Octal escape values should not exceed 256. If they do, only the
first two digits comprise the expression. Allows ASCII codes to be used in
regular expressions.
|
\xn | Matches n, where n is a hexadecimal escape value. Hexadecimal escape values must
be exactly two digits long.
For example, \x41 matches A.
\x041 is equivalent to \x04 &1.
Allows ASCII codes to be used in regular expressions.
|
\\$ | Escapes $. |
\l | Changes the case of the next character to the lower case. |
\u | Changes the case of the next character to the upper case. |
\L | Changes the case of all the subsequent characters up to \E to the lower case. |
\U | Changes the case of all the subsequent characters up to \E to the upper case. |
