--- title: RegEX date: 2020-11-25 18:28:43 background: bg-[#e56d2d] tags: - regular expression - regexp - pattern categories: - Toolkit intro: | A quick reference for regular expressions (regex), including symbols, ranges, grouping, assertions and some sample patterns to get you started. plugins: - copyCode --- Getting Started -------- ### Introduction This is a quick cheat sheet to getting started with regular expressions. - [Regex in Python](#regex-in-python) _(cheatsheets.zip)_ - [Regex in JavaScript](#regex-in-javascript) _(cheatsheets.zip)_ - [Regex in PHP](#regex-in-php) _(cheatsheets.zip)_ - [Regex in Java](#regex-in-java) _(cheatsheets.zip)_ - [Regex in MySQL](#regex-in-mysql) _(cheatsheets.zip)_ - [Regex in Vim](/vim#search-and-replace) _(cheatsheets.zip)_ - [Regex in Emacs](/emacs#search) _(cheatsheets.zip)_ - [Online regex tester](https://regex101.com/) _(regex101.com)_ {.cols-2 .marker-round} ### Character Classes | Pattern | Description | |---------------|-----------------------------------------------| | `[abc]` | A single character of: a, b or c | | `[^abc]` | A character except: a, b or c | | `[a-z]` | A character in the range: a-z | | `[^a-z]` | A character not in the range: a-z | | `[0-9]` | A digit in the range: 0-9 | | `[a-zA-Z]` | A character in the range:
a-z or A-Z | | `[a-zA-Z0-9]` | A character in the range:
a-z, A-Z or 0-9 | ### Quantifiers | Pattern | Description | |---------|-------------------| | `a?` | Zero or one of a | | `a*` | Zero or more of a | | `a+` | One or more of a | |`[0-9]+` | One or more of 0-9| |`a{3}` | Exactly 3 of a| |`a{3,}` | 3 or more of a| |`a{3,6}` | Between 3 and 6 of a| |`a*` | Greedy quantifier| |`a*?` | Lazy quantifier| |`a*+` | Possessive quantifier| ### Common Metacharacters - \^ - \{ - \+ - \< - \[ - \* - \) - \> - \. - \( - \| - \$ - \\ - \? {.cols-3 .marker-none} Escape these special characters with `\` ### Meta Sequences {.row-span-4} | Pattern | Description | |--------------|-------------------------------------------------------------| | `.` | Any single character | | `\s` | Any whitespace character | | `\S` | Any non-whitespace character | | `\d` | Any digit, Same as [0-9] | | `\D` | Any non-digit, Same as [^0-9] | | `\w` | Any word character | | `\W` | Any non-word character | | `\X` | Any Unicode sequences, linebreaks included | | `\C` | Match one data unit | | `\R` | Unicode newlines | | `\v` | Vertical whitespace character | | `\V` | Negation of \v - anything except newlines and vertical tabs | | `\h` | Horizontal whitespace character | | `\H` | Negation of \h | | `\K` | Reset match | | `\n` | Match nth subpattern | | `\pX` | Unicode property X | | `\p{...}` | Unicode property or script category | | `\PX` | Negation of \pX | | `\P{...}` | Negation of \p | | `\Q...\E` | Quote; treat as literals | | `\k` | Match subpattern `name` | | `\k'name'` | Match subpattern `name` | | `\k{name}` | Match subpattern `name` | | `\gn` | Match nth subpattern | | `\g{n}` | Match nth subpattern | | `\g` | Recurse nth capture group | | `\g'n'` | Recurses nth capture group. | | `\g{-n}` | Match nth relative previous subpattern | | `\g<+n>` | Recurse nth relative upcoming subpattern | | `\g'+n'` | Match nth relative upcoming subpattern | | `\g'letter'` | Recurse named capture group `letter` | | `\g{letter}` | Match previously-named capture group `letter` | | `\g` | Recurses named capture group `letter` | | `\xYY` | Hex character YY | | `\x{YYYY}` | Hex character YYYY | | `\ddd` | Octal character ddd | | `\cY` | Control character Y | | `[\b]` | Backspace character | | `\` | Makes any character literal | ### Anchors | Pattern | Description | |---------|------------------------| | `\G` | Start of match | | `^` | Start of string | | `$` | End of string | | `\A` | Start of string | | `\Z` | End of string | | `\z` | Absolute end of string | | `\b` | A word boundary | | `\B` | Non-word boundary | ### Substitution | Pattern | Description | |------------|---------------------------------| | `\0` | Complete match contents | | `\1` | Contents in capture group 1 | | `$1` | Contents in capture group 1 | | `${foo}` | Contents in capture group `foo` | | `\x20` | Hexadecimal replacement values | | `\x{06fa}` | Hexadecimal replacement values | | `\t` | Tab | | `\r` | Carriage return | | `\n` | Newline | | `\f` | Form-feed | | `\U` | Uppercase Transformation | | `\L` | Lowercase Transformation | | `\E` | Terminate any Transformation | ### Group Constructs | Pattern | Description | |-----------|-----------------------------------| | `(...)` | Capture everything enclosed | | `(a|b)` | Match either a or b | | `(?:...)` | Match everything enclosed | | `(?>...)` | Atomic group (non-capturing) | | `(?|...)` | Duplicate subpattern group number | | `(?#...)` | Comment | |`(?'name'...)` | Named Capturing Group| |`(?...)` | Named Capturing Group| |`(?P...)` | Named Capturing Group| |`(?imsxXU)` | Inline modifiers| |`(?(DEFINE)...)` | Pre-define patterns before using them| ### Assertions | - | - | |---------------------|---------------------------------| | `(?(1)yes|no)` | Conditional statement | | `(?(R)yes|no)` | Conditional statement | | `(?(R#)yes|no)` | Recursive Conditional statement | | `(?(R&name)yes|no)` | Conditional statement | | `(?(?=...)yes|no)` | Lookahead conditional | | `(?(?<=...)yes|no)` | Lookbehind conditional | ### Lookarounds | - | - | |------------|---------------------| | `(?=...)` | Positive Lookahead | | `(?!...)` | Negative Lookahead | | `(?<=...)` | Positive Lookbehind | | `(?name)` | Recurse subpattern `name` | ### POSIX Character Classes {.col-span-2} | Character Class | Same as | Meaning | |-----------------|-------------------------|--------------------------------| | `[[:alnum:]]` | `[0-9A-Za-z]` | Letters and digits | | `[[:alpha:]]` | `[A-Za-z]` | Letters | | `[[:ascii:]]` | `[\x00-\x7F]` | ASCII codes 0-127 | | `[[:blank:]]` | `[\t ]` | Space or tab only | | `[[:cntrl:]]` | `[\x00-\x1F\x7F]` | Control characters | | `[[:digit:]]` | `[0-9]` | Decimal digits | | `[[:graph:]]` | `[[:alnum:][:punct:]]` | Visible characters (not space) | | `[[:lower:]]` | `[a-z]` | Lowercase letters | | `[[:print:]]` | `[ -~] == [ [:graph:]]` | Visible characters | | `[[:punct:]]` | [!"#$%&’()*+,-./:;<=>?@[]^_\`{\|}~] | Visible punctuation characters | | `[[:space:]]` | [\t\n\v\f\r ] | Whitespace | | `[[:upper:]]` | `[A-Z]` | Uppercase letters | | `[[:word:]]` | `[0-9A-Za-z_]` | Word characters | | `[[:xdigit:]]` | `[0-9A-Fa-f]` | Hexadecimal digits | | `[[:<:]]` | `[\b(?=\w)]` | Start of word | | `[[:>:]]` | `[\b(?<=\w)]` | End of word | {.show-header} ### Control verb | - | - | |------------------------|-----------------------| | `(*ACCEPT)` | Control verb | | `(*FAIL)` | Control verb | | `(*MARK:NAME)` | Control verb | | `(*COMMIT)` | Control verb | | `(*PRUNE)` | Control verb | | `(*SKIP)` | Control verb | | `(*THEN)` | Control verb | | `(*UTF)` | Pattern modifier | | `(*UTF8)` | Pattern modifier | | `(*UTF16)` | Pattern modifier | | `(*UTF32)` | Pattern modifier | | `(*UCP)` | Pattern modifier | | `(*CR)` | Line break modifier | | `(*LF)` | Line break modifier | | `(*CRLF)` | Line break modifier | | `(*ANYCRLF)` | Line break modifier | | `(*ANY)` | Line break modifier | | `\R` | Line break modifier | | `(*BSR_ANYCRLF)` | Line break modifier | | `(*BSR_UNICODE)` | Line break modifier | | `(*LIMIT_MATCH=x)` | Regex engine modifier | | `(*LIMIT_RECURSION=d)` | Regex engine modifier | | `(*NO_AUTO_POSSESS)` | Regex engine modifier | | `(*NO_START_OPT)` | Regex engine modifier | Regex examples{.cols-3} -------------- ### Characters | Pattern | Matches | |----------------|------------------------------------------------------------| | `ring ` | Match ring springboard etc. | | `. ` | Match a, 9, + etc. | | `h.o ` | Match hoo, h2o, h/o etc. | | `ring\? ` | Match ring? | | `\(quiet\) ` | Match (quiet) | | `c:\\windows ` | Match c:\windows | Use `\` to search for these special characters:
`[ \ ^ $ . | ? * + ( ) { }` ### Alternatives | Pattern | Matches | |----------------|--------------------------------------------| | `cat|dog ` | Match cat or dog | | `id|identity ` | Match id or identity | | `identity|id ` | Match id or identity | Order longer to shorter when alternatives overlap ### Character classes | Pattern | Matches | |-------------------|--------------------------------------------------------------------| | `[aeiou]` | Match any vowel | | `[^aeiou]` | Match a NON vowel | | `r[iau]ng` | Match ring, wrangle, sprung, etc. | | `gr[ae]y` | Match gray or grey | | `[a-zA-Z0-9]` | Match any letter or digit | | `[\u3a00-\ufa99]` | Match any [Unicode Hàn (中文)](https://unicode.org/charts/unihan.html) | In `[ ]` always escape `. \ ]` and sometimes `^ - .` ### Shorthand classes | Pattern | Meaning | |------------------|-------------------------------------------------------| | `\w ` | "Word" character
_(letter, digit, or underscore)_ | | `\d ` | Digit | | `\s ` | Whitespace
_(space, tab, vtab, newline)_ | | `\W, \D, or \S ` | Not word, digit, or whitespace | | `[\D\S] ` | Means not digit or whitespace, both match | | `[^\d\s] ` | Disallow digit and whitespace | ### Occurrences | Pattern | Matches | |---------------------|--------------------------------------------------------------------| | `colou?r` | Match color or colour | | `[BW]ill[ieamy's]*` | Match Bill, Willy, William's etc. | | `[a-zA-Z]+` | Match 1 or more letters | | `\d{3}-\d{2}-\d{4}` | Match a SSN | | `[a-z]\w{1,7}` | Match a UW NetID | ### Greedy versus lazy | Pattern | Meaning | |--------------------------|---------------------------------------------------------| | `* + {n,}`
_greedy_ | Match as much as possible | | `<.+> ` | Finds 1 big match in \bold\<\/b> | | `*? +? {n,}?`
_lazy_ | Match as little as possible | | `<.+?>` | Finds 2 matches in \<b>bold\<\/b> | ### Scope {.col-span-2} | Pattern | Meaning | |--------------------|--------------------------------------------------------| | `\b ` | "Word" edge (next to non "word" character) | | `\bring ` | Word starts with "ring", ex ringtone | | `ring\b ` | Word ends with "ring", ex spring | | `\b9\b ` | Match single digit 9, not 19, 91, 99, etc.. | | `\b[a-zA-Z]{6}\b ` | Match 6-letter words | | `\B ` | Not word edge | | `\Bring\B ` | Match springs and wringer | | `^\d*$ ` | Entire string must be digits | | `^[a-zA-Z]{4,20}$` | String must have 4-20 letters | | `^[A-Z] ` | String must begin with capital letter | | `[\.!?"')]$ ` | String must end with terminal puncutation | ### Modifiers | Pattern | Meaning | |---------------------|----------------------------------------------------------| | `(?i)`[a-z]*`(?-i)` | Ignore case ON / OFF | | `(?s)`.*`(?-s)` | Match multiple lines (causes . to match newline) | | `(?m)`^.*;$`(?-m)` | ^ & $ match lines not whole string | | `(?x)` | #free-spacing mode, this EOL comment ignored | | `(?-x)` | free-spacing mode OFF | | /regex/`ismx` | Modify mode for entire string | ### Groups | Pattern | Meaning | |------------------|---------------------------------------------| | `(in\|out)put ` | Match input or output | | `\d{5}(-\d{4})?` | US zip code _("+ 4" optional)_ | Parser tries EACH alternative if match fails after group.
Can lead to catastrophic backtracking. ### Back references | Pattern | Matches | |--------------------------|-----------------------------------------------------------------------------| | `(to) (be) or not \1 \2` | Match to be or not to be | | `([^\s])\1{2}` | Match non-space, then same twice more   aaa, ... | | `\b(\w+)\s+\1\b` | Match doubled words | ### Non-capturing group | Pattern | Meaning | |---------------------|------------------------------------| | `on(?:click\|load)` | Faster than:
`on(click\|load)` | Use non-capturing or atomic groups when possible ### Atomic groups | Pattern | Meaning | |------------------------|--------------------------------------------------| | `(?>red\|green\|blue)` | Faster than non-capturing | | `(?>id\|identity)\b` | Match id, but not identity | "id" matches, but `\b` fails after atomic group, parser doesn't backtrack into group to retry 'identity'

If alternatives overlap, order longer to shorter. ### Lookaround {.row-span-2 .col-span-2} | Pattern | Meaning | |-------------------------|-----------------------------------------------------------------------| | `(?= )` | Lookahead, if you can find ahead | | `(?! )` | Lookahead,if you can not find ahead | | `(?<= )` | Lookbehind, if you can find behind | | `(?warbling, string, fishing, ... | | `\b(?!\w+ing\b)\w+\b` | Words NOT ending in "ing" | | `(?<=\bpre).*?\b ` | Match pretend, present, prefix, ... | | `\b\w{3}(?>> sentence = 'This is a sample string' >>> bool(re.search(r'this', sentence, flags=re.I)) True >>> bool(re.search(r'xyz', sentence)) False ``` #### re.findall() ```python >>> re.findall(r'\bs?pare?\b', 'par spar apparent spare part pare') ['par', 'spar', 'spare', 'pare'] >>> re.findall(r'\b0*[1-9]\d{2,}\b', '0501 035 154 12 26 98234') ['0501', '154', '98234'] ``` #### re.finditer() ```python >>> m_iter = re.finditer(r'[0-9]+', '45 349 651 593 4 204') >>> [m[0] for m in m_iter if int(m[0]) < 350] ['45', '349', '4', '204'] ``` #### re.split() ```python >>> re.split(r'\d+', 'Sample123string42with777numbers') ['Sample', 'string', 'with', 'numbers'] ``` #### re.sub() ```python >>> ip_lines = "catapults\nconcatenate\ncat" >>> print(re.sub(r'^', r'* ', ip_lines, flags=re.M)) * catapults * concatenate * cat ``` #### re.compile() ```python >>> pet = re.compile(r'dog') >>> type(pet) >>> bool(pet.search('They bought a dog')) True >>> bool(pet.search('A cat crossed their path')) False ``` ### Functions | Function | Description | |---------------|-------------------------------------------------------------------| | `re.findall` | Returns a list containing all matches | | `re.finditer` | Return an iterable of match objects (one for each match) | | `re.search` | Returns a Match object if there is a match anywhere in the string | | `re.split` | Returns a list where the string has been split at each match | | `re.sub` | Replaces one or many matches with a string | | `re.compile` | Compile a regular expression pattern for later use | | `re.escape` | Return string with all non-alphanumerics backslashed | ### Flags | - | - | - | |--------|-----------------|----------------------------------------------| | `re.I` | `re.IGNORECASE` | Ignore case | | `re.M` | `re.MULTILINE` | Multiline | | `re.L` | `re.LOCALE` | Make `\w`,`\b`,`\s` _locale dependent_ | | `re.S` | `re.DOTALL` | Dot matches all _(including newline)_ | | `re.U` | `re.UNICODE` | Make `\w`,`\b`,`\d`,`\s` _unicode dependent_ | | `re.X` | `re.VERBOSE` | Readable style | Regex in JavaScript --------------- ### test() ```javascript let textA = 'I like APPles very much'; let textB = 'I like APPles'; let regex = /apples$/i // Output: false console.log(regex.test(textA)); // Output: true console.log(regex.test(textB)); ``` ### search() ```javascript let text = 'I like APPles very much'; let regexA = /apples/; let regexB = /apples/i; // Output: -1 console.log(text.search(regexA)); // Output: 7 console.log(text.search(regexB)); ``` ### exec() ```javascript let text = 'Do you like apples?'; let regex= /apples/; // Output: apples console.log(regex.exec(text)[0]); // Output: Do you like apples? console.log(regex.exec(text).input); ``` ### match() ```javascript let text = 'Here are apples and apPleS'; let regex = /apples/gi; // Output: [ "apples", "apPleS" ] console.log(text.match(regex)); ``` ### split() {.col-span-2} ```javascript let text = 'This 593 string will be brok294en at places where d1gits are.'; let regex = /\d+/g // Output: [ "This ", " string will be brok", "en at places where d", "gits are." ] console.log(text.split(regex)) ``` ### matchAll() ```javascript let regex = /t(e)(st(\d?))/g; let text = 'test1test2'; let array = [...text.matchAll(regex)]; // Output: ["test1", "e", "st1", "1"] console.log(array[0]); // Output: ["test2", "e", "st2", "2"] console.log(array[1]); ``` ### replace() ```javascript {.wrap} let text = 'Do you like aPPles?'; let regex = /apples/i // Output: Do you like mangoes? let result = text.replace(regex, 'mangoes'); console.log(result); ``` ### replaceAll() ```javascript let regex = /apples/gi; let text = 'Here are apples and apPleS'; // Output: Here are mangoes and mangoes let result = text.replaceAll(regex, "mangoes"); console.log(result); ``` Regex in PHP ------------ ### Functions {.col-span-2} | - | - | |---------------------------|------------------------------------------------------------------| | `preg_match()` | Performs a regex match | | `preg_match_all()` | Perform a global regular expression match | | `preg_replace_callback()` | Perform a regular expression search and replace using a callback | | `preg_replace()` | Perform a regular expression search and replace | | `preg_split()` | Splits a string by regex pattern | | `preg_grep()` | Returns array entries that match a pattern | ### preg_replace ```php {.wrap} $str = "Visit Microsoft!"; $regex = "/microsoft/i"; // Output: Visit CheatSheets! echo preg_replace($regex, "CheatSheets", $str); ``` ### preg_match ```php $str = "Visit CheatSheets"; $regex = "#cheatsheets#i"; // Output: 1 echo preg_match($regex, $str); ``` ### preg_matchall {.col-span-2 .row-span-2} ```php $regex = "/[a-zA-Z]+ (\d+)/"; $input_str = "June 24, August 13, and December 30"; if (preg_match_all($regex, $input_str, $matches_out)) { // Output: 2 echo count($matches_out); // Output: 3 echo count($matches_out[0]); // Output: Array("June 24", "August 13", "December 30") print_r($matches_out[0]); // Output: Array("24", "13", "30") print_r($matches_out[1]); } ``` ### preg_grep ```php $arr = ["Jane", "jane", "Joan", "JANE"]; $regex = "/Jane/"; // Output: Jane echo preg_grep($regex, $arr); ``` ### preg_split {.col-span-2} ```php $str = "Jane\tKate\nLucy Marion"; $regex = "@\s@"; // Output: Array("Jane", "Kate", "Lucy", "Marion") print_r(preg_split($regex, $str)); ``` Regex in Java ------------- ### Styles {.col-span-2} #### First way ```java Pattern p = Pattern.compile(".s", Pattern.CASE_INSENSITIVE); Matcher m = p.matcher("aS"); boolean s1 = m.matches(); System.out.println(s1); // Outputs: true ``` #### Second way ```java boolean s2 = Pattern.compile("[0-9]+").matcher("123").matches(); System.out.println(s2); // Outputs: true ``` #### Third way ```java boolean s3 = Pattern.matches(".s", "XXXX"); System.out.println(s3); // Outputs: false ``` ### Pattern Fields | - | - | |--------------------|---------------------------------| | `CANON_EQ` | Canonical equivalence | | `CASE_INSENSITIVE` | Case-insensitive matching | | `COMMENTS` | Permits whitespace and comments | | `DOTALL` | Dotall mode | | `MULTILINE` | Multiline mode | | `UNICODE_CASE` | Unicode-aware case folding | | `UNIX_LINES` | Unix lines mode | ### Methods #### Pattern - Pattern compile(String regex [, int flags]) - boolean matches([String regex, ] CharSequence input) - String[] split(String regex [, int limit]) - String quote(String s) #### Matcher - int start([int group | String name]) - int end([int group | String name]) - boolean find([int start]) - String group([int group | String name]) - Matcher reset() #### String - boolean matches(String regex) - String replaceAll(String regex, String replacement) - String[] split(String regex[, int limit]) There are more methods ... ### Examples {.col-span-2} Replace sentence: ```java String regex = "[A-Z\n]{5}$"; String str = "I like APP\nLE"; Pattern p = Pattern.compile(regex, Pattern.MULTILINE); Matcher m = p.matcher(str); // Outputs: I like Apple! System.out.println(m.replaceAll("pple!")); ``` Array of all matches: ```java String str = "She sells seashells by the Seashore"; String regex = "\\w*se\\w*"; Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE); Matcher m = p.matcher(str); List matches = new ArrayList<>(); while (m.find()) { matches.add(m.group()); } // Outputs: [sells, seashells, Seashore] System.out.println(matches); ``` Regex in MySQL {.cols-2} ------------- ### Functions | Name | Description | |--------------------|--------------------------------------------------------------------------| | `REGEXP ` | Whether string matches regex | | `REGEXP_INSTR() ` | Starting index of substring matching regex
_(NOTE: Only MySQL 8.0+)_ | | `REGEXP_LIKE() ` | Whether string matches regex
_(NOTE: Only MySQL 8.0+)_ | | `REGEXP_REPLACE()` | Replace substrings matching regex
_(NOTE: Only MySQL 8.0+)_ | | `REGEXP_SUBSTR() ` | Return substring matching regex
_(NOTE: Only MySQL 8.0+)_ | ### REGEXP ```sql {.wrap} expr REGEXP pat ``` #### Examples ```sql mysql> SELECT 'abc' REGEXP '^[a-d]'; 1 mysql> SELECT name FROM cities WHERE name REGEXP '^A'; mysql> SELECT name FROM cities WHERE name NOT REGEXP '^A'; mysql> SELECT name FROM cities WHERE name REGEXP 'A|B|R'; mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A'; 1 0 ``` ### REGEXP_REPLACE ``` {.wrap} REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]]) ``` #### Examples ```sql mysql> SELECT REGEXP_REPLACE('a b c', 'b', 'X'); a X c mysql> SELECT REGEXP_REPLACE('abc ghi', '[a-z]+', 'X', 1, 2); abc X ``` ### REGEXP_SUBSTR ``` {.wrap} REGEXP_SUBSTR(expr, pat[, pos[, occurrence[, match_type]]]) ``` #### Examples ```sql mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+'); abc mysql> SELECT REGEXP_SUBSTR('abc def ghi', '[a-z]+', 1, 3); ghi ``` ### REGEXP_LIKE ``` REGEXP_LIKE(expr, pat[, match_type]) ``` #### Examples ```sql mysql> SELECT regexp_like('aba', 'b+') 1 mysql> SELECT regexp_like('aba', 'b{2}') 0 mysql> # i: case-insensitive mysql> SELECT regexp_like('Abba', 'ABBA', 'i'); 1 mysql> # m: multi-line mysql> SELECT regexp_like('a\nb\nc', '^b$', 'm'); 1 ``` ### REGEXP_INSTR ``` {.wrap} REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]]) ``` #### Examples ```sql mysql> SELECT regexp_instr('aa aaa aaaa', 'a{3}'); 2 mysql> SELECT regexp_instr('abba', 'b{2}', 2); 2 mysql> SELECT regexp_instr('abbabba', 'b{2}', 1, 2); 5 mysql> SELECT regexp_instr('abbabba', 'b{2}', 1, 3, 1); 7 ```