mirror of
https://github.com/Fechin/reference.git
synced 2026-11-20 21:23:11 +03:00
- 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~
897 lines
33 KiB
Markdown
897 lines
33 KiB
Markdown
---
|
||
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 <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
|
||
```
|