| This page lists the regular expression syntax accepted by RE2. |
| It also lists syntax accepted by PCRE, PERL, and VIM. |
| Grayed out expressions are not supported by RE2. |
| See http://go/re2 and http://go/re2quick. |
|
| Single characters: |
. | any character, including newline (s=true) |
[xyz] | character class |
[^xyz] | negated character class |
\d | Perl character class |
\D | negated Perl character class |
[:alpha:] | ASCII character class |
[:^alpha:] | negated ASCII character class |
\pN | Unicode character class (one-letter name) |
\p{Greek} | Unicode character class |
\PN | negated Unicode character class (one-letter name) |
\P{Greek} | negated Unicode character class |
|
| 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*) VIM |
x{-} | (≡ x*?) VIM |
x{-n} | (≡ x{n}?) VIM |
x= | (≡ x?) VIM |
|
| Possessive repetitions: |
x*+ | zero or more x, possessive |
x++ | one or more x, possessive |
x?+ | zero or one x, possessive |
x{n,m}+ | n or ... or m x, possessive |
x{n,}+ | n or more x, possessive |
x{n}+ | exactly n x, possessive |
|
| Grouping: |
(re) | numbered capturing group |
(?P<name>re) | named & numbered capturing group |
(?<name>re) | named & numbered capturing group |
(?'name're) | named & numbered capturing group |
(?:re) | non-capturing group |
(?flags) | set flags until outer paren closes; non-capturing |
(?flags:re) | set flags during re; non-capturing |
(?#text) | comment |
(?|x|y|z) | branch numbering reset |
(?>re) | possessive match of re |
re@> | possessive match of re VIM |
%(re) | non-capturing group VIM |
|
| Flags: |
i | case-insensitive (default false) |
m | multi-line mode (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 or line (m=true) |
\A | at beginning of text |
\b | at word boundary (\w to left and \W to right or vice versa) |
\B | not a word boundary |
\G | at beginning of subtext being searched PCRE |
\G | at end of last match PERL |
\Z | at end of text, or before newline at end of text |
\z | at end of text |
(?=re) | before text matching re |
(?!re) | before text not matching re |
(?<=re) | after text matching re |
(?<!re) | after text not matching re |
re& | before text matching re VIM |
re@= | before text matching re VIM |
re@! | before text not matching re VIM |
re@<= | after text matching re VIM |
re@<! | after text not matching re VIM |
\zs | sets start of match (= \K) VIM |
\ze | sets end of match VIM |
\%^ | beginning of file VIM |
\%$ | end of file VIM |
\%V | on screen VIM |
\%# | cursor position VIM |
\%'m | mark m position VIM |
\%23l | in line 23 VIM |
\%23c | in column 23 VIM |
\%23v | in virtual column 23 VIM |
|
| Escape sequences: |
\a | bell (≡ \007) |
\f | form feed (≡ \014) |
\t | horizontal tab (≡ \011) |
\n | newline (≡ \012) |
\r | carriage return (≡ \015) |
\v | vertical tab character (≡ \013) |
\* | literal *, for any punctuation character * |
\123 | octal character code (up to three digits) |
\x7F | hex character code (exactly two digits) |
\x{10FFFF} | hex character code |
\C | match a single byte even in UTF-8 mode |
\Q...\E | literal text ... even if ... has punctuation |
|
\1 | backreference |
\b | backspace (use \010) |
\cK | control char ^K (use \001 etc) |
\e | escape (use \033) |
\g1 | backreference |
\g{1} | backreference |
\g{+1} | backreference |
\g{-1} | backreference |
\g{name} | named backreference |
\g<name> | subroutine call |
\g'name' | subroutine call |
\k<name> | named backreference |
\k'name' | named backreference |
\lX | lowercase X |
\ux | uppercase x |
\L...\E | lowercase text ... |
\K | reset beginning of $0 |
\N{name} | named Unicode character |
\R | line break |
\U...\E | upper case text ... |
\X | extended Unicode sequence |
|
\%d123 | decimal character 123 VIM |
\%xFF | hex character FF VIM |
\%o123 | octal character 123 VIM |
\%u1234 | Unicode character 0x1234 VIM |
\%U12345678 | Unicode character 0x12345678 VIM |
|
| Character class elements: |
x | single character |
A-Z | character range (inclusive) |
\d | Perl character class |
[:foo:] | ASCII character class foo |
\p{Foo} | Unicode character class Foo |
\pF | Unicode character class F (one-letter name) |
|
| Named character classes as character class elements: |
[\d] | digits (≡ \d) |
[^\d] | not digits (≡ \D) |
[\D] | not digits (≡ \D) |
[^\D] | not not digits (≡ \d) |
[[:name:]] | named ASCII class inside character class (≡ [:name:]) |
[^[:name:]] | named ASCII class inside negated character class (≡ [:^name:]) |
[\p{Name}] | named Unicode property inside character class (≡ \p{Name}) |
[^\p{Name}] | named Unicode property inside negated character class (≡ \P{Name}) |
|
| Perl character classes: |
\d | digits (≡ [0-9]) |
\D | not digits (≡ [^0-9]) |
\s | whitespace (≡ [\t\n\f\r ]) |
\S | not whitespace (≡ [^\t\n\f\r ]) |
\w | word characters (≡ [0-9A-Za-z_]) |
\W | not word characters (≡ [^0-9A-Za-z_]) |
|
\h | horizontal space |
\H | not horizontal space |
\v | vertical space |
\V | not vertical space |
|
| ASCII character classes: |
[:alnum:] | alphanumeric (≡ [0-9A-Za-z]) |
[:alpha:] | alphabetic (≡ [A-Za-z]) |
[:ascii:] | ASCII (≡ [\x00-\x7F]) |
[:blank:] | blank (≡ [\t ]) |
[:cntrl:] | control (≡ [\x00-\x1F\x7F]) |
[:digit:] | digits (≡ [0-9]) |
[:graph:] | graphical (≡ [!-~] == [A-Za-z0-9!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]) |
[:lower:] | lower case (≡ [a-z]) |
[:print:] | printable (≡ [ -~] == [ [:graph:]]) |
[:punct:] | punctuation (≡ [!-/:-@[-`{-~]) |
[:space:] | whitespace (≡ [\t\n\v\f\r ]) |
[:upper:] | upper case (≡ [A-Z]) |
[:word:] | word characters (≡ [0-9A-Za-z_]) |
[:xdigit:] | hex digit (≡ [0-9A-Fa-f]) |
|
| Unicode character class names--general category: |
C | other |
Cc | control |
Cf | format |
Cn | unassigned code points |
Co | private use |
Cs | surrogate |
L | letter |
LC | cased letter |
L& | cased letter |
Ll | lowercase letter |
Lm | modifier letter |
Lo | other letter |
Lt | titlecase letter |
Lu | uppercase letter |
M | mark |
Mc | spacing mark |
Me | enclosing mark |
Mn | non-spacing mark |
N | number |
Nd | decimal number |
Nl | letter number |
No | other number |
P | punctuation |
Pc | connector punctuation |
Pd | dash punctuation |
Pe | close punctuation |
Pf | final punctuation |
Pi | initial punctuation |
Po | other punctuation |
Ps | open punctuation |
S | symbol |
Sc | currency symbol |
Sk | modifier symbol |
Sm | math symbol |
So | other symbol |
Z | separator |
Zl | line separator |
Zp | paragraph separator |
Zs | space separator |
|
| Unicode character class names--scripts: |
Arabic | Arabic |
Armenian | Armenian |
Balinese | Balinese |
Bengali | Bengali |
Bopomofo | Bopomofo |
Braille | Braille |
Buginese | Buginese |
Buhid | Buhid |
Canadian_Aboriginal | Canadian Aboriginal |
Carian | Carian |
Cham | Cham |
Cherokee | Cherokee |
Common | characters not specific to one script |
Coptic | Coptic |
Cuneiform | Cuneiform |
Cypriot | Cypriot |
Cyrillic | Cyrillic |
Deseret | Deseret |
Devanagari | Devanagari |
Ethiopic | Ethiopic |
Georgian | Georgian |
Glagolitic | Glagolitic |
Gothic | Gothic |
Greek | Greek |
Gujarati | Gujarati |
Gurmukhi | Gurmukhi |
Han | Han |
Hangul | Hangul |
Hanunoo | Hanunoo |
Hebrew | Hebrew |
Hiragana | Hiragana |
Inherited | inherit script from previous character |
Kannada | Kannada |
Katakana | Katakana |
Kayah_Li | Kayah Li |
Kharoshthi | Kharoshthi |
Khmer | Khmer |
Lao | Lao |
Latin | Latin |
Lepcha | Lepcha |
Limbu | Limbu |
Linear_B | Linear B |
Lycian | Lycian |
Lydian | Lydian |
Malayalam | Malayalam |
Mongolian | Mongolian |
Myanmar | Myanmar |
New_Tai_Lue | New Tai Lue (aka Simplified Tai Lue) |
Nko | Nko |
Ogham | Ogham |
Ol_Chiki | Ol Chiki |
Old_Italic | Old Italic |
Old_Persian | Old Persian |
Oriya | Oriya |
Osmanya | Osmanya |
Phags_Pa | 'Phags Pa |
Phoenician | Phoenician |
Rejang | Rejang |
Runic | Runic |
Saurashtra | Saurashtra |
Shavian | Shavian |
Sinhala | Sinhala |
Sundanese | Sundanese |
Syloti_Nagri | Syloti Nagri |
Syriac | Syriac |
Tagalog | Tagalog |
Tagbanwa | Tagbanwa |
Tai_Le | Tai Le |
Tamil | Tamil |
Telugu | Telugu |
Thaana | Thaana |
Thai | Thai |
Tibetan | Tibetan |
Tifinagh | Tifinagh |
Ugaritic | Ugaritic |
Vai | Vai |
Yi | Yi |
|
| Vim character classes: |
\i | identifier character VIM |
\I | \i except digits VIM |
\k | keyword character VIM |
\K | \k except digits VIM |
\f | file name character VIM |
\F | \f except digits VIM |
\p | printable character VIM |
\P | \p except digits VIM |
\s | whitespace character (≡ [ \t]) VIM |
\S | non-white space character (≡ [^ \t]) VIM |
\d | digits (≡ [0-9]) VIM |
\D | not \d VIM |
\x | hex digits (≡ [0-9A-Fa-f]) VIM |
\X | not \x VIM |
\o | octal digits (≡ [0-7]) VIM |
\O | not \o VIM |
\w | word character VIM |
\W | not \w VIM |
\h | head of word character VIM |
\H | not \h VIM |
\a | alphabetic VIM |
\A | not \a VIM |
\l | lowercase VIM |
\L | not lowercase VIM |
\u | uppercase VIM |
\U | not uppercase VIM |
\_x | \x plus newline, for any x VIM |
|
| Vim flags: |
\c | ignore case VIM |
\C | match case VIM |
\m | magic VIM |
\M | nomagic VIM |
\v | verymagic VIM |
\V | verynomagic VIM |
\Z | ignore differences in Unicode combining characters VIM |
|
| Magic: |
(?{code}) | arbitrary Perl code PERL |
(??{code}) | postponed arbitrary Perl code PERL |
(?n) | recursive call to regexp capturing group n |
(?+n) | recursive call to relative group +n |
(?-n) | recursive call to relative group -n |
(?C) | PCRE callout PCRE |
(?R) | recursive call to entire regexp (≡ (?0)) |
(?&name) | recursive call to named group |
(?P=name) | named backreference |
(?P>name) | recursive call to named group |
(?(cond)true|false) | conditional branch |
(?(cond)true) | conditional branch |
(*ACCEPT) | make regexps more like Prolog |
(*COMMIT) | |
(*F) | |
(*FAIL) | |
(*MARK) | |
(*PRUNE) | |
(*SKIP) | |
(*THEN) | |
(*ANY) | set newline convention |
(*ANYCRLF) | |
(*CR) | |
(*CRLF) | |
(*LF) | |
(*BSR_ANYCRLF) | set \R convention PCRE |
(*BSR_UNICODE) | PCRE |
|