|
.
|
Any single character.
|
|
^
|
Anchor character, matches the start of a line.
|
|
$
|
Anchor character, matches the end of a line.
|
|
()
|
Sub-expression. Separates the expression within the
brackets allowing it to be subjected to the repeating metacharacters or
referenced with the back reference function.
See below for details of these functions.
|
|
|
|
Or operator. Matches either the expression preceding
or succeeding the operator.
For example, “a|b” matches either “a” or “b”.
|
|
*
|
Zero or more occurrences of the preceding atom.
For example, “ab*c”
matches “ac”, “abc”, “abbbbbbbbc”
etc... “(he)*” matches “he”, “hehehehehehe”
etc...
|
|
+
|
One or more occurrences of the preceding atom.
|
|
?
|
Zero or one occurrences of the preceding atom.
|
|
{x}
|
Bounded repeat. Matches exactly ‘x’ occurrences of the
preceding atom.
|
|
{x,y}
|
Matches between ‘x’ and ‘y’ (inclusive) occurrences
of the preceding atom.
|
|
{x,}
|
Matches ‘x’ or more (inclusive) occurrences of the preceding
atom.
|
|
x?
|
Non greedy repeat of repeating metacharacter ‘x’.
The repeating functions above attempt to match as much
as possible (they are greedy). Following any of the repeating metacharacters
with a “?” causes the repeat to be non greedy. That is, the match is as
short as possible.
For example, in the string “It went on and on and on.",
“went.{2,}on” matches “went on and on and on” whereas “went.{2,}?on” only
matches “went on and on”.
|
|
\n
|
Back reference. Matches the string that was matched
by sub-expression ‘n’. Where 'n' is a number from 1 to 9.
For example, “(.+)-\1” matches “abc-abc”
and “1234-1234” but not “abc-1234”.
|
|
\x
|
Where ‘x’ is a metacharacter this syntax indicates that
‘x’ is to be treated literally and not as a metacharacter. For example,
‘\$’ matches ‘$’. ‘\\’ matches ‘\’.
Where ‘x’ is a predefined escape sequence character
(or sequence of characters) match the character or character class defined
by that escape sequence.
For more information about escape sequences, see the
table below.
|
|
[]
|
Character set. Matches any one character from the list.
For example, “[abc]” matches either “a” or “b” or “c”.
The whole character set may be subjected to the repeating
metacharacters. For example, ‘[abc]*’ matches ‘aabcac’
but not ‘abcdcba’.
|
|
[^]
|
Negated character set. Matches any one character which
is not in the character set.
For example, “[^bc]”
matches “a” and “d”
but not “b” or “c”.
|
|
[x-y]
|
Character range. Matches one character in the range
‘x’ to ‘y’. For example, “[a-c]” matches “a”, “b” or “c”.
The range endpoints must be in the correct order. That
is, the first endpoint must precede the second endpoint in the Unicode
codepoint sequence. To include a literal ‘-’ character in a character
set enter it as the first or last character.
|
|
[:x:]
|
Character class. A predefined set of characters. Character
classes may only be used within a character set. For example, “[[:digit:]]”
matches any numeric character.
See below for a table of available character classes.
|
|
[.x.]
|
Collating element. A single character or sequence of
characters that collates as a single element. Collating elements may only
be used within a character set. For example, “[[.ae.]]”.
(This assumes that ‘ae’
is a collating element in the current system locale.
Collating elements may also be used as a form of escape
character as most special characters lose their special significance when
used within a character set. For example, to specify a ‘-‘ as a range
endpoint, it can be declared as a collating element such as “[!-[.-.]]”.
Additionally some characters can be declared in a collating element by
referring to the characters symbolic name.
See below for a table of available symbolic names.
|
|
[=x=]
|
Equivalence class. A character set of all characters
with the same primary sort key as character ‘x’. An equivalence class
may only be used within a character set. For example, “[[=e=]]”
would match any of the following characters. “eÈÉÊËèéêëĒēĔĕĖėĘęĚě”.
Note: This function
is locale specific so should be used with caution. Different locales or
platforms may result in different behaviour.
|
|
(?#comment)
|
Comment. Text between the ‘#’ and the closing ‘)’ are
ignored. This can be used to explain how the expression works for future
reference. For example, “(?#3 letters)[[:alpha:]]{3}(?#followed by 5 digits)[[:digit:]]{5}”.
|
|
(?=pattern)
|
Positive lookahead. Returns a match if ‘pattern’ matches.
The current point of reference is not moved so subsequent expressions
match from the same point. This can be used to logically ‘and’ two or
more regular expressions. For example, “(?=.*[[:lower:]])(?=.*[[:upper:]])”
confirms that there are upper and lower case characters in the string.
|
|
(?!pattern)
|
Negative lookahead. Returns a match if ‘pattern’ does
not match. The current point of reference is not moved so subsequent expressions
match from the same point.
|
|
(?<=pattern)
|
Positive lookbehind. Returns a match if ‘pattern’ matches
immediately before the current point of reference. The current point of
reference is not moved so subsequent expressions match from the same point.
|
|
(?<!pattern)
|
Negative lookbehind. Returns a match if ‘pattern’ does
not match immediately before the current point of reference. The current
point of reference is not moved so subsequent expressions match from the
same point.
|
|
(?>pattern)
|
Independent sub-expression. A sub expression that does
not allow backtracking into ‘pattern’ in order to try and satisfy the
larger expression. This function can be used to achieve significant performance
improvements. For example, “([ab]+)[bc]+”
matches “abb”.
But “(?>[ab]+)[bc]+”
does not match “abb”.
It does however match “abc”.
|
|
(?(condition)true|false)
|
Conditional expression. If ‘condition’ is true, attempts
to match the ‘true’ pattern. If ‘condition’ is false, attempts to match
the ‘false’ pattern. The condition may be either a lookahead or the index
of a marked sub-expression.
|
|
(?(condition)true)
|
Conditional expression. If ‘condition’ is true, attempts
to match the ‘true’ pattern. If ‘condition’ is false the expression returns
no match. The condition may be either a lookahead or the index of a marked
sub-expression.
|
Terminology used in this topic