-
Notifications
You must be signed in to change notification settings - Fork 1.2k
Syntax
Regular expressions are a notation for describing sets of character strings. When a particular string is in the set described by a regular expression, we often say that the regular expression matches the string.
The simplest regular expression is a single literal character.
Except for the metacharacters like
*+?()|,
characters match themselves.
To match a metacharacter, escape it with
a backslash:
\+
matches a literal plus character.
Two regular expressions can be alternated or concatenated to form a new
regular expression:
if e1 matches
s
and e2 matches
t,
then e1|e2 matches
s
or
t,
and
e1e2
matches
st.
The metacharacters
*,
+,
and
?
are repetition operators:
e1*
matches a sequence of zero or more (possibly different)
strings, each of which match e1;
e1+
matches one or more;
e1?
matches zero or one.
The operator precedence, from weakest to strongest binding, is
first alternation, then concatenation, and finally the
repetition operators.
Explicit parentheses can be used to force different meanings,
just as in arithmetic expressions.
Some examples:
ab|cd
is equivalent to
(ab)|(cd);
ab*
is equivalent to
a(b*).
The syntax described so far is most of the traditional Unix egrep regular expression syntax. This subset suffices to describe all regular languages: loosely speaking, a regular language is a set of strings that can be matched in a single pass through the text using only a fixed amount of memory. Newer regular expression facilities (notably Perl and those that have copied it) have added many new operators and escape sequences, which make the regular expressions more concise, and sometimes more cryptic, but usually not more powerful.
This page lists the regular expression syntax accepted by RE2. Note that this syntax is a subset of that accepted by PCRE, roughly speaking, and with various caveats.
It also lists some syntax accepted by PCRE, PERL, and VIM.
| kinds of single-character expressions | examples |
|---|---|
| any character, possibly including newline (s=true) | . |
| character class | [xyz] |
| negated character class | [^xyz] |
| Perl character class (link) | \d |
| negated Perl character class | \D |
| ASCII character class (link) | [[:alpha:]] |
| negated ASCII character class | [[:^alpha:]] |
| Unicode character class (one-letter name) | \pN |
| Unicode character class | \p{Greek} |
| negated Unicode character class (one-letter name) | \PN |
| negated Unicode character class | \P{Greek} |
| Composites | |
|---|---|
xy |
x followed by y
|
x|y |
x or y (prefer x) |
| Repetitions | |
|---|---|
x* |
zero or more x, prefer more |
x+ |
one or more x, prefer more |
x? |
zero or one x, prefer one |
x{n,m} |
n or n+1 or ... or m x, prefer more |
x{n,} |
n or more x, prefer more |
x{n} |
exactly n x
|
x*? |
zero or more x, prefer fewer |
x+? |
one or more x, prefer fewer |
x?? |
zero or one x, prefer zero |
x{n,m}? |
n or n+1 or ... or m x, prefer fewer |
x{n,}? |
n or more x, prefer fewer |
x{n}? |
exactly n x
|
x{} |
(≡ x*) (NOT SUPPORTED) VIM
|
x{-} |
(≡ x*?) (NOT SUPPORTED) VIM
|
x{-n} |
(≡ x{n}?) (NOT SUPPORTED) VIM
|
x= |
(≡ x?) (NOT SUPPORTED) VIM
|
Implementation restriction: The counting forms x{n,m}, x{n,}, and x{n} reject forms that create a minimum or maximum repetition count above 1000. Unlimited repetitions are not subject to this restriction.
| Possessive repetitions | |
|---|---|
x*+ |
zero or more x, possessive (NOT SUPPORTED)
|
x++ |
one or more x, possessive (NOT SUPPORTED)
|
x?+ |
zero or one x, possessive (NOT SUPPORTED)
|
x{n,m}+ |
n or ... or m x, possessive (NOT SUPPORTED)
|
x{n,}+ |
n or more x, possessive (NOT SUPPORTED)
|
x{n}+ |
exactly n x, possessive (NOT SUPPORTED)
|
| Grouping | |
|---|---|
(re) |
numbered capturing group (submatch) |
(?P<name>re) |
named & numbered capturing group (submatch) |
(?<name>re) |
named & numbered capturing group (submatch) |
(?'name're) |
named & numbered capturing group (submatch) (NOT SUPPORTED) |
(?:re) |
non-capturing group |
(?flags) |
set flags within current group; non-capturing |
(?flags:re) |
set flags during re; non-capturing |
(?#text) |
comment (NOT SUPPORTED) |
(?|x|y|z) |
branch numbering reset (NOT SUPPORTED) |
(?>re) |
possessive match of re (NOT SUPPORTED)
|
re@> |
possessive match of re (NOT SUPPORTED) VIM
|
%(re) |
non-capturing group (NOT SUPPORTED) VIM |
| Flags | |
|---|---|
i |
case-insensitive (default false) |
m |
multi-line mode: ^ and $ match begin/end line in addition to begin/end text (default false) |
s |
let . match \n (default false) |
U |
ungreedy: swap meaning of x* and x*?, x+ and x+?, etc (default false) |
Flag syntax is xyz (set) or -xyz (clear) or xy-z (set xy, clear z).
| Empty strings | |
|---|---|
^ |
at beginning of text or line (m=true) |
$ |
at end of text (like \z not \Z) or line (m=true) |
\A |
at beginning of text |
\b |
at ASCII word boundary (\w on one side and \W, \A, or \z on the other) |
\B |
not at ASCII word boundary |
\g |
at beginning of subtext being searched (NOT SUPPORTED) PCRE |
\G |
at end of last match (NOT SUPPORTED) PERL |
\Z |
at end of text, or before newline at end of text (NOT SUPPORTED) |
\z |
at end of text |
(?=re) |
before text matching re (NOT SUPPORTED)
|
(?!re) |
before text not matching re (NOT SUPPORTED)
|
(?<=re) |
after text matching re (NOT SUPPORTED)
|
(?<!re) |
after text not matching re (NOT SUPPORTED)
|
re& |
before text matching re (NOT SUPPORTED) VIM
|
re@= |
before text matching re (NOT SUPPORTED) VIM
|
re@! |
before text not matching re (NOT SUPPORTED) VIM
|
re@<= |
after text matching re (NOT SUPPORTED) VIM
|