RegEX 备忘清单

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

入门

介绍

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

字符类

范例说明
[abc]单个字符:abc
[^abc]一个字符,除了:abc
[a-z]范围内的字符:a-z
[^a-z]不在范围内的字符:a-z
[0-9]范围内的数字:0-9
[a-zA-Z]范围内的字符:
a-zA-Z
[a-zA-Z0-9]范围内的字符:
a-zA-Z0-9

量词

范例说明
a?零个或一个a
a*零个或多个 a
a+一个或多个a
[0-9]+0-9中的一个或多个
a{3}正好 3a
a{3,}3个或更多的a
a{3,6}a36 之间
a*贪心量词
a*?惰性量词
a*+占有量词

常用元字符

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

使用 \ 转义这些特殊字符

元序列

范例说明
.任何单个字符
\s任何空白字符
\S任何非空白字符
\d任何数字,与 [0-9] 相同
\D任何非数字,与 [^0-9] 相同
\w任何单词字符
\W任何非单词字符
\X任何 Unicode 序列,包括换行符
\C匹配一个数据单元
\RUnicode 换行符
\v垂直空白字符
\V\v 的否定 - 除了换行符和垂直制表符之外的任何内容
\h水平空白字符
\H\h 的否定
\K重置匹配
\n匹配第 n 个子模式
\pXUnicode 属性 X
\p{...}Unicode 属性或脚本类别
\PX\pX 的否定
\P{...}\p 的否定
\Q...\E引用;视为文字
\k<name>匹配子模式name
\k'name'匹配子模式name
\k{name}匹配子模式name
\gn匹配第 n 个子模式
\g{n}匹配第 n 个子模式
\g<n>递归第 n 个捕获组
\g'n'递归第 n 个捕获组。
\g{-n}匹配第 n 个相对前一个子模式
\g<+n>递归第 n 个相对即将到来的子模式
\g'+n'匹配第 n 个相对即将到来的子模式
\g'letter'递归命名捕获组 字母
\g{letter}匹配先前命名的捕获组 字母
\g<letter>递归命名捕获组 字母
\xYY十六进制字符 YY
\x{YYYY}十六进制字符 YYYY
\ddd八进制字符ddd
\cY控制字符 Y
[\b]退格字符
\使任何字符文字

锚点

范例说明
\G比赛开始
^字符串的开始
$字符串结束
\A字符串的开始
\Z字符串结束
\z字符串的绝对结尾
\b一个词的边界
\B非单词边界

替代

范例说明
\0完整的比赛内容
\1捕获组 1 中的内容
$1捕获组 1 中的内容
${foo}捕获组 foo 中的内容
\x20十六进制替换值
\x{06fa}十六进制替换值
\t标签
\r回车
\n新队
\f换页
\U大写转换
\L小写转换
\E终止任何转换

组构造

范例说明
(...)捕获所有封闭的东西
(a|b)匹配 ab
(?:...)匹配随附的所有内容
(?>...)原子组(非捕获)
(?|...)重复的子模式组号
(?#...)注解
(?'name'...)命名捕获组
(?<name>...)命名捕获组
(?P<name>...)命名捕获组
(?imsxXU)内联修饰符
(?(DEFINE)...)在使用它们之前预定义模式

断言

:--
(?(1)yes|no)条件语句
(?(R)yes|no)条件语句
(?(R#)yes|no)递归条件语句
(?(R&name)yes|no)条件语句
(?(?=...)yes|no)有条件的前瞻
(?(?<=...)yes|no)有条件的往后看

递归

:--
(?R)递归整个模式
(?1)递归第一个子模式
(?+1)递归第一个相对子模式
(?&name)递归子模式name
(?P=name)匹配子模式name
(?P>name)递归子模式name

标志/修饰符

:--
g全部
m多行
i不区分大小写
x忽略空格
s单线
u统一码
X扩展
U不贪心
A
J重复的组名
d结果包含捕获组子字符串开始和结束的索引

零宽度断言

:--
(?=...)正先行断言
(?!...)负先行断言
(?<=...)正后发断言
(?<!...)负后发断言
?=正先行断言-存在
?!负先行断言-排除
?<=正后发断言-存在
?<!负后发断言-排除

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

POSIX 字符类

字符类如同意义
[[:alnum:]][0-9A-Za-z]字母和数字
[[:alpha:]][A-Za-z]字母
[[:ascii:]][\x00-\x7F]ASCII 码 0-127
[[:blank:]][\t ]仅空格或制表符
[[:cntrl:]][\x00-\x1F\x7F]控制字符
[[:digit:]][0-9]十进制数字
[[:graph:]][[:alnum:][:punct:]]可见字符(不是空格)
[[:lower:]][a-z]小写字母
[[:print:]][ -~] == [ [:graph:]]可见字符
[[:punct:]][!"#$%&’()*+,-./:;<=>[email protected][]^_`{|}~]可见标点符号
[[:space:]][\t\n\v\f\r ]空白
[[:upper:]][A-Z]大写字母
[[:word:]][0-9A-Za-z_]单词字符
[[:xdigit:]][0-9A-Fa-f]十六进制数字
[[:<:]][\b(?=\w)]词的开头
[[:>:]][\b(?<=\w)]词尾

控制动词

:--
(*ACCEPT)控制动词
(*FAIL)控制动词
(*MARK:NAME)控制动词
(*COMMIT)控制动词
(*PRUNE)控制动词
(*SKIP)控制动词
(*THEN)控制动词
(*UTF)图案修饰符
(*UTF8)图案修饰符
(*UTF16)图案修饰符
(*UTF32)图案修饰符
(*UCP)图案修饰符
(*CR)换行修饰符
(*LF)换行修饰符
(*CRLF)换行修饰符
(*ANYCRLF)换行修饰符
(*ANY)换行修饰符
\R换行修饰符
(*BSR_ANYCRLF)换行修饰符
(*BSR_UNICODE)换行修饰符
(*LIMIT_MATCH=x)正则表达式引擎修饰符
(*LIMIT_RECURSION=d)正则表达式引擎修饰符
(*NO_AUTO_POSSESS)正则表达式引擎修饰符
(*NO_START_OPT)正则表达式引擎修饰符

正则表达式示例

字符串

范例说明
ring匹配 ring springboard 等。
.匹配 a9+ 等。
h.o匹配 hooh2oh/o 等。
ring\?匹配 ring?
\(quiet\)匹配(安静)
c:\\windows匹配 c:\windows

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

速记类

范例说明
\w“单词”字符
(字母、数字或下划线)
\d数字
\s空格
(空格、制表符、vtab、换行符)
\W, \D, or \S不是单词、数字或空格
[\D\S]表示不是数字或空格,两者都匹配
[^\d\s]禁止数字和空格

出现次数

范例说明
colou?r匹配 colorcolor
[BW]ill[ieamy's]*匹配 BillWillyWilliam's 等。
[a-zA-Z]+匹配 1 个或多个字母
\d{3}-\d{2}-\d{4}匹配 SSN
[a-z]\w{1,7}匹配 UW NetID

备择方案

范例说明
cat|dog匹配 catdog
id|identity匹配 ididentity
identity|id匹配 ididentity

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

字符类

范例说明
[aeiou]匹配任何元音
[^aeiou]匹配一个非元音
r[iau]ng匹配ring、wrangle、sprung等。
gr[ae]y匹配 graygrey
[a-zA-Z0-9]匹配任何字母或数字

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

贪婪与懒惰

范例说明
* + {n,}
greedy
尽可能匹配
<.+><b>bold</b> 中找到 1 个大匹配项
*? +? {n,}?
lazy
尽可能少匹配
<.+?>在 <b>bold</b> 中找到 2 个匹配项

范围

范例说明
\b“单词”边缘(非“单词”字符旁边)
\bring单词以“ring”开头,例如 ringtone
ring\b单词以“ring”结尾,例如 spring
\b9\b匹配单个数字 9,而不是 19、91、99 等。
\b[a-zA-Z]{6}\b匹配 6 个字母的单词
\B不是字边
\Bring\B匹配 springswringer
^\d*$整个字符串必须是数字
^[a-zA-Z]{4,20}$字符串必须有 4-20 个字母
^[A-Z]字符串必须以大写字母开头
[\.!?"')]$字符串必须以终端标点结尾

修饰

范例说明
(?i)[a-z]*(?-i)忽略大小写开/关
(?s).*(?-s)匹配多行(导致 . 匹配换行符)
(?m)^.*;$(?-m)^ & $ 匹配行不是整个字符串
(?x)#free-spacing 模式,此 EOL 注释被忽略
(?-x)自由空间模式关闭
/regex/ismx修改整个字符串的模式

范例说明
(in|out)put匹配 inputoutput
\d{5}(-\d{4})?美国邮政编码 (“+ 4”可选)

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

反向引用

范例说明
(to) (be) or not \1 \2匹配 to be or not to be
([^\s])\1{2}匹配非空格,然后再相同两次   aaa, ...
\b(\w+)\s+\1\b匹配双字

非捕获组

范例说明
on(?:click|load)快于:on(click|load)

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

原子组

范例说明
(?>red|green|blue)比非捕获更快
(?>id|identity)\b匹配 id,但不匹配 identity

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

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

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

范例说明
(?= )向前看,如果你能提前找到
(?! )向前看,如果你找不到前面
(?<= )向后看,如果你能找到后面
(?<! )向后看,如果你找不到后面
\b\w+?(?=ing\b)匹配 warbling, string, fishing, ...
\b(?!\w+ing\b)\w+\b不以“ing”结尾的单词
(?<=\bpre).*?\b匹配 pretend、present、prefix、...
\b\w{3}(?<!pre)\w*?\b不以“pre”开头的词
\b\w+(?<!ing)\b匹配不以“ing”结尾的单词

If-then-else

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

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

需要环顾 IF 条件

基础实例

基本匹配

表达式匹配示例
theThe fat cat sat on the mat.
TheThe fat cat sat on the mat.

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

点运算符 .

表达式匹配示例
.arThe car parked in the garage.

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

字符集

表达式匹配示例
.arThe car parked in the garage.
ar[.]A garage is a good place to park a car.

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

否定字符集

表达式匹配示例
[^c]arThe car parked in the garage.

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

重复次数

*

表达式匹配示例
[a-z]*The car parked in the garage #21.
\s*cat\s*The fat cat sat on the concatenation.

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

+

表达式匹配示例
c.+tThe fat cat sat on the mat.

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

?

表达式匹配示例
[T]heThe car is parked in the garage.
[T]?heThe car is parked in the garage.

表达式 [T]?he 匹配字符串 heThe

{}

表达式匹配示例
[0-9]{2,3}The number was 9.9997 but we rounded it off to 10.0.
[0-9]{2,}The number was 9.9997 but we rounded it off to 10.0.
[0-9]{3}The number was 9.9997 but we rounded it off to 10.0.

(...) 特征标群

表达式匹配示例
(c|g|p)arThe car is parked in the garage.

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

| 或运算符

表达式匹配示例
(T|t)he|carThe car is parked in the garage.

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

转码特殊字符

表达式匹配示例
(f|c|m)at\.?The fat cat sat on the mat.

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

锚点

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

^ 号 (符串的开头)

表达式匹配示例
(T|t)heThe car is parked in the garage.
^(T|t)heThe car is parked in the garage.

$ 号 (否是最后一个)

表达式匹配示例
(at\.)The fat cat. sat. on the mat.
(at\.)$The fat cat. sat. on the mat.

简写字符集

简写描述
.除换行符外的所有字符
\w匹配所有字母数字
等同于 [a-zA-Z0-9_]
\W匹配所有非字母数字,即符号
等同于: [^\w]
\d匹配数字: [0-9]
\D匹配非数字: [^\d]
\s匹配所有空格字符
等同于:[\t\n\f\r\p{Z}]
\S匹配所有非空格字符: [^\s]
\f匹配一个换页符
\n匹配一个换行符
\r匹配一个回车符
\t匹配一个制表符
\v匹配一个垂直制表符
\p匹配 CR/LF(等同于 \r\n)
用来匹配 DOS 行终止符

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

?=... 正先行断言

表达式匹配示例
(T|t)he(?=\sfat)The fat cat sat on the mat.

Thethe 后面紧跟着 (空格)fat

?!... 负先行断言

表达式匹配示例
(T|t)he(?!\sfat)The fat cat sat on the mat.

匹配 Thethe,且其后不跟着 (空格)fat

?<= ... 正后发断言

表达式匹配示例
(?<=(T|t)he\s)(fat|mat)The fat cat sat on the mat.

匹配 fatmat,且其前跟着 Thethe

?<!... 负后发断言

表达式匹配示例
(?<!(T|t)he\s)(cat)The cat sat on cat.

匹配 cat,且其前不跟着 Thethe

忽略大小写 (Case Insensitive)

表达式匹配示例
TheThe fat cat sat on the mat.
/The/giThe fat cat sat on the mat.

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

表达式匹配示例
/.(at)/The fat cat sat on the mat.
/.(at)/gThe fat cat sat on the mat.

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

多行修饰符 (Multiline)

表达式匹配示例
/.at(.)?$/The fat
cat sat
on the mat.
/.at(.)?$/gmThe fat
cat sat
on the mat.

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

表达式匹配示例
/(.*at)/The fat cat sat on the mat.
/(.*?at)/The fat cat sat on the mat.

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)
<class '_sre.SRE_Pattern'>
>>> bool(pet.search('They bought a dog'))
True
>>> bool(pet.search('A cat crossed their path'))
False

函数

函数说明
re.findall返回包含所有匹配项的列表
re.finditer返回一个可迭代的匹配对象
(每个匹配一个)
re.search如果字符串中的任何位置存在匹配项,则返回 Match 对象
re.split返回一个列表,其中字符串在每次匹配时被拆分
re.sub用字符串替换一个或多个匹配项
re.compile编译正则表达式模式供以后使用
re.escape返回所有非字母数字反斜杠的字符串

Flags 标志

:---
re.Ire.IGNORECASE忽略大小写
re.Mre.MULTILINE多行
re.Lre.LOCALE使 \w\b\s locale 依赖
re.Sre.DOTALL点匹配所有 (包括换行符)
re.Ure.UNICODE使 \w\b\d\s unicode 依赖
re.Xre.VERBOSE可读风格

JavaScript 中的正则表达式

RegExp

属性

:-:-
dotAll是否使用了 s 修饰符
flags返回标志的字符串
global是否使用了 g (全部)修饰符
hasIndices是否使用了 d 修饰符
ignoreCase匹配文本的时候是否忽略大小写 i
multiline是否进行多行搜索 m
lastIndex该索引表示从哪里开始下一个匹配
source正则表达式的文本
sticky搜索是否是 sticky
unicodeUnicode 功能是否开启

方法

:-:-
match()获取匹配结果
matchAll()所有匹配项
replace()替换所有符合正则模式的匹配项
search()搜索以取得匹配正则模式的项
split()切割字符串返回字符串数组
compile()(重新)编译正则表达式
exec()指定字符串中执行一个搜索匹配
test()正则表达式与指定的字符串是否匹配
toString()返回该正则表达式的字符串

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
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_match()执行正则表达式匹配
preg_match_all()执行全局正则表达式匹配
preg_replace_callback()使用回调执行正则表达式搜索和替换
preg_replace()执行正则表达式搜索和替换
preg_split()按正则表达式模式拆分字符串
preg_grep()返回与模式匹配的数组条目

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 = "@\[email protected]";
// 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

模式字段

:--
CANON_EQ规范等价
CASE_INSENSITIVE不区分大小写的匹配
COMMENTS允许空格和注释
DOTALL圆点模式
MULTILINE多行模式
UNICODE_CASEUnicode 感知大小写折叠
UNIX_LINESUnix 行模式

方法

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

MySQL中的正则表达式

函数

函数名称说明
REGEXP字符串是否匹配正则表达式
REGEXP_INSTR()匹配正则表达式的子字符串的起始索引
(注意:仅限 MySQL 8.0+)
REGEXP_LIKE()字符串是否匹配正则表达式
(注意:仅 MySQL 8.0+)
REGEXP_REPLACE()替换匹配正则表达式的子字符串
(注意:仅限 MySQL 8.0+)
REGEXP_SUBSTR()返回匹配正则表达式的子字符串
(注意:仅 MySQL 8.0+)

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

也可以看看