Files
reference/regex.md
T
2020-12-19 21:40:24 +08:00

18 KiB
Raw Blame History

title, date, icon, background, tags, categories, intro
title date icon background tags categories intro
RegEX 2020-11-25 18:28:43 icon-regex bg-yellow-500
Regular expressions
regexp
pattern
Toolkit
A quick reference guide for regular expressions (regex), including symbols, ranges, grouping, assertions and some sample patterns to get you started. This cheat sheet was made for [PCRE](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions).

Get Started

Introduction

This is a quick cheat sheet to getting started with regular expressions.

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 .style-none}

Escape these special characters with \

Meta Sequences

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<name> Match subpattern name
\k'name' Match subpattern name
\k{name} Match subpattern name
\gn Match nth subpattern
\g{n} Match nth subpattern
\g<n> 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<letter> 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 everything enclosed
(?>...) Atomic group (non-capturing)
`(? ...)`
(?#...) Comment

|(?'name'...) | Named Capturing Group| |(?<name>...) | Named Capturing Group| |(?P<name>...) | 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| |(?<!...) | Negative Lookbehind| Lookaround lets you match a group before (lookbehind) or after (lookahead) your main pattern without including it in the result.

Flags/Modifiers

Pattern Description
g Global
m Multiline
i Case insensitive
x Ignore whitespace
s Single line
u Unicode
X eXtended
U Ungreedy
A Anchor
J Duplicate group names

Recurse

|------------|--------------------------------------| |(?R) | Recurse entire pattern| |(?1) | Recurse first subpattern| |(?+1) | Recurse first relative subpattern| |(?&name) | Recurse subpattern name| |(?P=name) | Match subpattern name| |(?P>name) | Recurse subpattern name|

POSIX Character Classes

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 in Python

Getting started

Import the regular expressions module

import re

Example

re.search()

>>> 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()

>>> 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()

>>> 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()

>>> re.split(r'\d+', 'Sample123string42with777numbers')
['Sample', 'string', 'with', 'numbers']

re.sub()

>>> ip_lines = "catapults\nconcatenate\ncat"
>>> print(re.sub(r'^', r'* ', ip_lines, flags=re.M))
* catapults
* concatenate
* cat

re.compile()

>>> pet = re.compile(r'dog')
>>> type(pet)
<class '_sre.SRE_Pattern'>
>>> 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()

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));
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()

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()

let text = 'Here are apples and apPleS';
let regex = /apples/gi;
 
// Output: [ "apples", "apPleS" ]
console.log(text.match(regex));

split()

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()

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()

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()

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

|---------------------------|------------------------------------------------------------------| | 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

$str = "Visit Microsoft!";
$regex = "/microsoft/i";

// Output: Visit QuickRef!
echo preg_replace($regex, "QuickRef", $str); 

preg_match

$str = "Visit QuickRef";
$regex = "#quickref#i";

// Output: 1
echo preg_match($regex, $str);

preg_matchall

$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

$arr = ["Jane", "jane", "Joan", "JANE"];
$regex = "/Jane/";

// Output: Jane
echo preg_grep($regex, $arr);

preg_split

$str = "Jane\tKate\nLucy Marion";
$regex = "@\s@";

// Output: Array("Jane", "Kate", "Lucy", "Marion")
print_r(preg_split($regex, $str));

Regex in Java

Styles

First way

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

boolean s2 = Pattern.compile("[0-9]+").matcher("123").matches();  
System.out.println(s2);   // Outputs: true

Third way

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

Replace sentence:

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:

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<String> matches = new ArrayList<>();
while (m.find()) {
    matches.add(m.group());
}

// Outputs: [sells, seashells, Seashore]
System.out.println(matches);