Files
reference/source/_posts/regex.md
T
Fechin 172342c8a3 feat: modernize development toolchain
- Add comprehensive development tooling:
  * ESLint configuration with modern JavaScript rules
  * Prettier for consistent code formatting
  * Husky for Git hooks automation
  * lint-staged for pre-commit checks
  * Conventional Commits with commitlint
  * Stylelint for CSS code quality

- Fix CSS issues:
  * Resolve duplicate selectors in layout_note.css
  * Merge duplicate selectors in layout_list.css
  * Ensure stylelint compliance

- Apply consistent code formatting:
  * Format all JavaScript, CSS, and Markdown files
  * Standardize code style across the project
  * Fix console statement warnings in main.js

- Update project documentation:
  * Enhance README with modern development practices
  * Update package.json with new scripts and dependencies

This modernization establishes a robust development environment with
automated code quality checks, consistent formatting~
2025-06-18 14:09:17 +08:00

897 lines
33 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
---
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
---
<!-- Editor's note: this page uses <yel> (yellow tailwind spans) to color matching text and <red> to color non-matching
text -->
## 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: <yel>a</yel>, <yel>b</yel> or <yel>c</yel> |
| `[^abc]` | A character except: <yel>a</yel>, <yel>b</yel> or <yel>c</yel> |
| `[a-z]` | A character in the range: <yel>a-z</yel> |
| `[^a-z]` | A character not in the range: <red>a-z</red> |
| `[0-9]` | A digit in the range: <yel>0-9</yel> |
| `[a-zA-Z]` | A character in the range: <yel>a-z</yel> or <yel>A-Z</yel> |
| `[a-zA-Z0-9]` | A character in the range: <yel>a-z</yel>, <yel>A-Z</yel> or <yel>0-9</yel> |
{.style-list}
### 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
| Pattern | Description |
| ------- | :----------------------------------------------------------- | -------------------------------------------- |
| `^` | Matches the start of a string. |
| `{` | Starts a quantifier for the number of occurrences. |
| `+` | Matches one or more of the preceding element. |
| `<` | Not a standard regex meta character (commonly used in HTML). |
| `[` | Starts a character class. |
| `*` | Matches zero or more of the preceding element. |
| `)` | Ends a capturing group. |
| `>` | Not a standard regex meta character (commonly used in HTML). |
| `.` | Matches any character except a newline. |
| `(` | Starts a capturing group. |
| ` | ` | Acts as a logical OR within a regex pattern. |
| `$` | Matches the end of a string. |
| `\` | Escapes a meta character, giving it literal meaning. |
| `?` | Matches zero or one of the preceding element. |
{.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<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 |
| <code>(a\|b)</code> | Match either a or b |
| `(?:...)` | Match everything enclosed |
| `(?>...)` | Atomic group (non-capturing) |
| <code>(?\|...)</code> | Duplicate subpattern group number |
| `(?#...)` | 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
| - | - |
| ------------------------------- | :------------------------------ |
| <code>(?(1)yes\|no)</code> | Conditional statement |
| <code>(?(R)yes\|no)</code> | Conditional statement |
| <code>(?(R#)yes\|no)</code> | Recursive Conditional statement |
| <code>(?(R&name\yes\|no)</code> | Conditional statement |
| <code>(?(?=...)yes\|no)</code> | Lookahead conditional |
| <code>(?(?<=...)yes\|no)</code> | 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 {.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:]]` | <code>[!"#$%&’()\*+,-./:;<=>?@[]^\_\`{\|}~]</code> | Visible punctuation characters |
| `[[:space:]]` | <code>[\t\n\v\f\r ]</code> | 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 <yel>ring</yel> sp<yel>ring</yel>board etc. |
| `. ` | Match <yel>a</yel>, <yel>9</yel>, <yel>+</yel> etc. |
| `h.o ` | Match <yel>hoo</yel>, <yel>h2o</yel>, <yel>h/o</yel> etc. |
| `ring\? ` | Match <yel>ring?</yel> |
| `\(quiet\) ` | Match <yel>(quiet)</yel> |
| `c:\\windows ` | Match <yel>c:\windows</yel> |
Use `\` to search for these special characters: <br> `[ \ ^ $ . | ? * + ( ) { }`
### Alternatives
| Pattern | Matches |
| ------------------------- | :----------------------------------------- |
| <code>cat\|dog</code> | Match <yel>cat</yel> or <yel>dog</yel> |
| <code>id\|identity</code> | Match <yel>id</yel> or <yel>id</yel>entity |
| <code>identity\|id</code> | Match <yel>id</yel> or <yel>identity</yel> |
Order longer to shorter when alternatives overlap
### Character classes
| Pattern | Matches |
| ----------------- | :--------------------------------------------------------------------- |
| `[aeiou]` | Match any vowel |
| `[^aeiou]` | Match a NON vowel |
| `r[iau]ng` | Match <yel>ring</yel>, w<yel>rang</yel>le, sp<yel>rung</yel>, etc. |
| `gr[ae]y` | Match <yel>gray</yel> or <yel>grey</yel> |
| `[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 <br>_(letter, digit, or underscore)_ |
| `\d ` | Digit |
| `\s ` | Whitespace <br>_(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 <yel>color</yel> or <yel>colour</yel> |
| `[BW]ill[ieamy's]*` | Match <yel>Bill</yel>, <yel>Willy</yel>, <yel>William's</yel> 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,}`<br>_greedy_ | Match as much as possible |
| `<.+> ` | Finds 1 big match in <yel>\<b>bold\<\/b></yel> |
| `*? +? {n,}?`<br>_lazy_ | Match as little as possible |
| `<.+?>` | Finds 2 matches in \<<yel>b</yel>>bold\<<yel>\/b</yel>> |
### Scope {.col-span-2}
| Pattern | Meaning |
| ------------------ | :-------------------------------------------------------------------------------------- |
| `\b ` | "Word" edge (next to non "word" character) |
| `\bring ` | Word starts with "ring", ex <yel>ringtone</yel> |
| `ring\b ` | Word ends with "ring", ex <yel>spring</yel> |
| `\b9\b ` | Match single digit <yel>9</yel>, not <red>19</red>, <red>91</red>, <red>99</red>, etc.. |
| `\b[a-zA-Z]{6}\b ` | Match 6-letter words |
| `\B ` | Not word edge |
| `\Bring\B ` | Match <yel>springs</yel> and <yel>wringer</yel> |
| `^\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)` | <yel>^</yel> & <yel>$</yel> 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 |
| ------------------------- | :------------------------------------------ |
| <code>(in\|out)put</code> | Match <yel>input</yel> or <yel>output</yel> |
| `\d{5}(-\d{4})?` | US zip code _("+ 4" optional)_ |
Parser tries EACH alternative if match fails after group. <br> Can lead to catastrophic backtracking.
### Back references
| Pattern | Matches |
| ------------------------ | :-------------------------------------------------------------------------- |
| `(to) (be) or not \1 \2` | Match <yel>to be or not to be</yel> |
| `([^\s])\1{2}` | Match non-space, then same twice more &nbsp; <yel>aaa</yel>, <yel>...</yel> |
| `\b(\w+)\s+\1\b` | Match doubled words |
### Non-capturing group
| Pattern | Meaning |
| ------------------------------ | :--------------------------------- |
| <code>on(?:click\|load)</code> | Faster than: <br>`on(click\|load)` |
Use non-capturing or atomic groups when possible
### Atomic groups
| Pattern | Meaning |
| --------------------------------- | :----------------------------------------------- |
| <code>(?>red\|green\|blue)</code> | Faster than non-capturing |
| <code>(?>id\|identity)\b</code> | Match <yel>id</yel>, but not <red>id</red>entity |
"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 |
| `(?<! )` | Lookbehind, if you can NOT find behind |
| `\b\w+?(?=ing\b)` | Match <yel>warbl</yel>ing, <yel>str</yel>ing, <yel>fish</yel>ing, ... |
| `\b(?!\w+ing\b)\w+\b` | Words NOT ending in <red>ing</red> |
| `(?<=\bpre).*?\b ` | Match pre<yel>tend</yel>, pre<yel>sent</yel>, pre<yel>fix</yel>, ... |
| `\b\w{3}(?<!pre)\w*?\b` | Words NOT starting with <red>pre</red> |
| `\b\w+(?<!ing)\b` | Match words NOT ending in <red>ing</red> |
### If-then-else
Match "Mr." or "Ms." if word "her" is later in string
```regex
M(?(?=.*?\bher\b)s|r)\.
```
requires lookaround for IF condition
## RegEx in Python
### Getting started
Import the regular expressions module
```python
import re
```
### Examples {.col-span-2 .row-span-3}
#### re.search()
```python
>>> 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)
<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()
```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<String> 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 <br>_(NOTE: Only MySQL 8.0+)_ |
| `REGEXP_LIKE() ` | Whether string matches regex <br>_(NOTE: Only MySQL 8.0+)_ |
| `REGEXP_REPLACE()` | Replace substrings matching regex <br>_(NOTE: Only MySQL 8.0+)_ |
| `REGEXP_SUBSTR() ` | Return substring matching regex <br>_(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
```