介绍

这是开始使用正则表达式(Regex)的快速备忘单。

• Python 中的 Regex (Quick Reference)
• JavaScript 中的 Regex (Quick Reference)
• PHP 中的 Regex (Quick Reference)
• Java 中的 Regex (Quick Reference)
• MySQL 中的 Regex (Quick Reference)
• Vim 中的 Regex (Quick Reference)
• 在线 Regex 测试器 (regex101.com)
• 轻松学习 Regex (github.com)
• 正则表达式实例搜集 (jaywcjlove.github.io)

字符类

量词

常用元字符

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

使用 \ 转义这些特殊字符

元序列

锚点

替代

组构造

断言

递归

标志/修饰符

零宽度断言

零宽度断言 允许您在主模式之前（向后看）或之后（lookahead）匹配一个组，而不会将其包含在结果中。

POSIX 字符类

控制动词

正则表达式示例

字符串

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

速记类

出现次数

备择方案

当替代品重叠时，命令从长到短

字符类

在 [ ] 中总是转义 . \ ] 有时是 ^ - .

贪婪与懒惰

范围

修饰

组

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

反向引用

非捕获组

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

原子组

"id" 匹配，但 \b 在原子组之后失败， 解析器不会回溯到组以重试“身份”

如果替代品重叠，请从长到短命令。

零宽度断言 Lookaround(前后预查)

If-then-else

匹配 Mr. 或 Ms. 如果单词 her 稍后在字符串中

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

需要环顾 IF 条件

基础实例

基本匹配

由字母t开始，接着是h，再接着是e

点运算符.

表达式.ar匹配一个任意字符后面跟着是a和r的字符串

字符集

方括号的句号就表示句号。表达式 ar[.] 匹配 ar. 字符串

否定字符集

表达式 [^c]ar 匹配一个后面跟着 ar 的除了c的任意字符。

重复次数

*号

表达式 [a-z]* 匹配一个行中所有以小写字母开头的字符串。

+号

表达式 c.+t 匹配以首字母c开头以t结尾，中间跟着至少一个字符的字符串。

?号

表达式 [T]?he 匹配字符串 he 和 The。

{}号

(...)特征标群

表达式 (c|g|p)ar 匹配 car 或 gar 或 par。 注意 \ 是在 Markdown 中为了不破坏表格转义 |。

|或运算符

表达式 (T|t)he|car 匹配 (T|t)he 或 car

转码特殊字符

如果想要匹配句子中的 . 则要写成 \. 以下这个例子 \.? 是选择性匹配.

锚点

匹配指定开头或结尾的字符串就要使用到锚点。

^号 (符串的开头)

$号 (否是最后一个)

简写字符集

正则表达式提供一些常用的字符集简写。

?=...正先行断言

The 和 the 后面紧跟着 (空格)fat。

?!...负先行断言

匹配 The 和 the，且其后不跟着 (空格)fat。

?<= ...正后发断言

匹配 fat 和 mat，且其前跟着 The 或 the。

?

表达式	匹配示例
(?	The cat sat on cat.

匹配 cat，且其前不跟着 The 或 the。

忽略大小写 (Case Insensitive)

修饰语 i 用于忽略大小写，g 表示全局搜索。

全局搜索 (Global search)

表达式 /.(at)/g 表示搜索 任意字符（除了换行）+ at，并返回全部结果。

多行修饰符 (Multiline)

贪婪匹配与惰性匹配 (Greedy vs lazy matching)

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

re.compile()

>>> pet = re.compile(r'dog')
>>> type(pet)

>>> bool(pet.search('They bought a dog'))
True
>>> bool(pet.search('A cat crossed their path'))
False

函数

Flags 标志

JavaScript 中的正则表达式

RegExp

属性

方法

test()

let textA = 'I like APPles very much';
let textB = 'I like APPles';
let regex = /apples$/i
 
console.log(regex.test(textA)); // false
console.log(regex.test(textB)); // true

search()

let text = 'I like APPles very much';
let regexA = /apples/;
let regexB = /apples/i;

console.log(text.search(regexA)); // -1
console.log(text.search(regexB)); // 7

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

属性示例

/d/s.dotAll;             // => true
/d/g.global;             // => true
/d/ig.flags;             // => "gi"
/d/d.hasIndices;         // => true
/d/i.ignoreCase;         // => true

多行文本中使用正则表达式

let s = "Please yes\nmake my day!";

s.match(/yes[^]*day/);
// 返回 'yes\nmake my day'

replaceAll()

let regex = /apples/gi;
let text = 'Here are apples and apPleS';

text.replaceAll(regex, "mangoes");
// 返回: Here are mangoes and mangoes

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

第二种方式

boolean 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

• 模式编译 compile(字符串正则表达式 [,int flags])
• 布尔匹配 matches([字符串正则表达式,] CharSequence 输入)
• String[] 拆分 split(字符串正则表达式 [,int 限制])
• 字符串引用 quote(字符串 s)

匹配器

• int start([int group | 字符串名称])
• int end([int group | 字符串名称])
• 布尔 find([int start])
• 字符 group([int 组 | 字符串名称])
• 匹配器重置 reset()

String

• boolean matches(String regex)
• String replaceAll(String regex, 字符串替换)
• 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 matches = new ArrayList<>();
while (m.find()) {
    matches.add(m.group());
}
// Outputs: [sells, seashells, Seashore]
System.out.println(matches);

MySQL中的正则表达式

函数

REGEXP

expr REGEXP pat 

Examples

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

更多

github.com