| 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 | xfollowed byy | 
| x|y | xory(preferx) | 
|  | 
| 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} | norn+1 or ... ormx, prefer more | 
| x{n,} | nor morex, prefer more | 
| x{n} | exactly nx | 
| x*? | zero or more x, prefer fewer | 
| x+? | one or more x, prefer fewer | 
| x?? | zero or one x, prefer zero | 
| x{n,m}? | norn+1 or ... ormx, prefer fewer | 
| x{n,}? | nor morex, prefer fewer | 
| x{n}? | exactly nx | 
| 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}+ | nor ... ormx, possessive | 
| x{n,}+ | nor morex, possessive | 
| x{n}+ | exactly nx, 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 reVIM | 
| %(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*andx*?,x+andx+?, etc (default false) | 
| Flag syntax is xyz(set) or-xyz(clear) orxy-z(setxy, clearz). | 
|  | 
| 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 ( \wto left and\Wto 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 reVIM | 
| re@= | before text matching reVIM | 
| re@! | before text not matching reVIM | 
| re@<= | after text matching reVIM | 
| re@<! | after text not matching reVIM | 
| \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 mposition  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 \001etc) | 
| \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 | \iexcept digits  VIM | 
| \k | keyword character  VIM | 
| \K | \kexcept digits  VIM | 
| \f | file name character  VIM | 
| \F | \fexcept digits  VIM | 
| \p | printable character  VIM | 
| \P | \pexcept digits  VIM | 
| \s | whitespace character (≡ [ \t])  VIM | 
| \S | non-white space character (≡ [^ \t])  VIM | 
| \d | digits (≡ [0-9]) VIM | 
| \D | not \dVIM | 
| \x | hex digits (≡ [0-9A-Fa-f])  VIM | 
| \X | not \xVIM | 
| \o | octal digits (≡ [0-7])  VIM | 
| \O | not \oVIM | 
| \w | word character VIM | 
| \W | not \wVIM | 
| \h | head of word character  VIM | 
| \H | not \hVIM | 
| \a | alphabetic  VIM | 
| \A | not \aVIM | 
| \l | lowercase  VIM | 
| \L | not lowercase  VIM | 
| \u | uppercase  VIM | 
| \U | not uppercase  VIM | 
| \_x | \xplus newline, for anyxVIM | 
|  | 
| 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 | 
|  |