正则表达式备忘单

正则表达式 (regex) 的快速参考，包括符号、范围、分组、断言和一些帮助您入门的示例模式。

字符类

量词

常见元字符

• ^
• {
• +
• <
• [
• *
• )
• >
• .
• (
• |
• $
• \
• ?

转义这些特殊字符 \

元序列

锚

替换

组构造

断言

环视

Lookaround 允许您在主模式之前 (lookbehind) 或之后 (lookahead) 匹配一个组，而不将其包含在结果中。

标志/修饰符

递归

POSIX 字符类

控制动词

正则表达式示例

字符匹配

使用\搜索这些特殊字符：
[ \ ^ $ . | ? * + ( ) { }

可替代方案

当备选方案重叠时，从长到短排序

字符块匹配

在[ ]总是逃避. \ ]有时^ - .

特殊字符匹配

事件匹配

贪婪匹配和懒惰匹配

匹配范围

修饰匹配

组匹配

如果组后匹配失败，解析器会尝试每个替代方案。
可能导致灾难性的回溯。

反向引用

非捕获组

尽可能使用非捕获或原子组

原子组

“id”匹配，但\b在原子组之后失败，解析器不会回溯到组以重试“身份”
如果替代品重叠，则从长到短排序。

周围匹配

If-then-else

匹配 "Mr." 或者 "Ms."  如果单词“her”在字符串后面

M(?(?=.*?\bher\b)s|r)\.

需要环视 if 条件

Python 中的正则表达式

入门

导入正则表达式模块

import re

例子

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

重新编译（）

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

方法

Flags

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

search（）

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

PHP 中的正则表达式

方法

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

Java 中的正则表达式

样式

第一种方式

Pattern p = Pattern.compile(".s", Pattern.CASE_INSENSITIVE); Matcher m = p.matcher("aS");   boolean s1 = m.matches();   System.out.println(s1);   // Outputs: true

第二种方式

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

第三种方式

boolean s3 = Pattern.matches(".s", "XXXX");   System.out.println(s3);   // Outputs: false

模式字段

方法

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

还有更多的方法...

例子

替换语句：

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!"));

所有匹配项的数组：

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

MySQL 中的正则表达式

方法

REGEXP

expr REGEXP pat

例子

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

REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])

例子

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

REGEXP_SUBSTR(expr, pat[, pos[, occurrence[, match_type]]])

例子

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

例子

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

REGEXP_INSTR(expr, pat[, pos[, occurrence[, return_option[, match_type]]]])

例子

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