目录
一、理解反向引用
要想理解为什么需要反向引用，最好的方法是看一个例子。HTML 程序员使用标题标签 <h1> 到 <h6>，以及配对的结束标签来定义和排版 Web 页面里的标题文字。假设现在需要把某个 Web 页面里的所有标题文字全都查找出来，不管是几级标题。
mysql> set @s:='<body>
'> <h1>Welcome to my Homepage</h1>
'> Content is divided into two sections:<br/>
'> <h2>SQL</h2>
'> Information about SQL.
'> <h2>RegEx</h2>
'> Information about Regular Expressions.
'> </body>';
Query OK, 0 rows affected (0.00 sec)
mysql> set @r:='<[hH][1-6]>.*?</[hH][1-6]>';
Query OK, 0 rows affected (0.00 sec)
mysql> select regexp_count(@s, @r, '') c, regexp_extract(@s, @r, '') s, regexp_extract_index(@s, @r, 0, '') i;
+------+-------------------------------------------------------------+----------+
| c | s | i |
+------+-------------------------------------------------------------+----------+
| 3 | <h1>Welcome to my Homepage</h1>,<h2>SQL</h2>,<h2>RegEx</h2> | 8,83,119 |
+------+-------------------------------------------------------------+----------+
1 row in set (0.00 sec)<[hH][1-6]> 匹配任意级别标题的开始标签，</[hH][1-6]> 匹配任意级别标题的结束标签。这里使用的是 .*? 懒惰型而不是 .* 贪婪型。所以模式 <[hH][1-6]>.*</[hH][1-6]> 可能会从第 2 行的起始 <h1> 标签开始，一直匹配到第 6 行的结束 </h2> 标签。使用懒惰型量词 .*? 可以解决这个问题。
之所以说“可能”（could）而不是“就会”（would），是因为在这个特定的例子里，即便是使用了贪婪型量词也不一定会有问题。元字符 . 通常无法匹配换行符，而上例中的每个标题都各自占据一行。但在这里使用懒惰型元字符没有任何坏处，事前小心总比事后后悔好。现在没问题了吗？未必。看看下面这个例子。
mysql> set @s:='<body>
'> <h1>Welcome to my Homepage</h1>
'> Content is divided into two sections:<br/>
'> <h2>SQL</h2>
'> Information about SQL.
'> <h2>RegEx</h2>
'> Information about Regular Expressions.
'> <h2>This is not valid HTML</h3>
'> </body>';
Query OK, 0 rows affected (0.00 sec)
mysql> select regexp_count(@s, @r, '') c, regexp_extract(@s, @r, '') s, regexp_extract_index(@s, @r, 0, '') i;
+------+---------------------------------------------------------------------------------------------+--------------+
| c | s | i |
+------+---------------------------------------------------------------------------------------------+--------------+
| 4 | <h1>Welcome to my Homepage</h1>,<h2>SQL</h2>,<h2>RegEx</h2>,<h2>This is not valid HTML</h3> | 8,83,119,173 |
+------+---------------------------------------------------------------------------------------------+--------------+
1 row in set (0.00 sec)有一处标题的标签是以 <h2> 开头、以 </h3> 结束的，这显然是一个无效的标题，但也能和使用的模式匹配上。问题在于匹配的第二部分（用来匹配结束标签的那部分）对匹配的第一部分（用来匹配开始标签的那部分）一无所知。这正是反向引用大显身手的地方了。
二、反向引用匹配
先来看一个比较简单的例子，这个问题如果不使用反向引用，根本无法解决。假设你有一段文本，想把这段文本里所有连续重复出现的单词找出来。显然，在搜索某个单词的第二次出现时，这个单词必须是已知的。反向引用允许正则表达式模式引用之前匹配的结果，具体到这个例子，就是前面匹配到的单词。理解反向引用的最好方法就是看看它的实际应用，下面这段文本中包含 3 组重复的单词。
mysql> set @s:='This is a block of of text,
'> several words here are are
'> repeated, and and they
'> should not be.';
Query OK, 0 rows affected (0.00 sec)
mysql> set @r:='[ ]+(\\w+)[ ]+\\1';
Query OK, 0 rows affected (0.00 sec)
mysql> select regexp_count(@s, @r, '') c, regexp_extract(@s, @r, '') s, regexp_extract_index(@s, @r, 0, '') i;
+------+--------------------------+----------+
| c | s | i |
+------+--------------------------+----------+
| 3 | of of, are are, and and | 16,47,65 |
+------+--------------------------+----------+
1 row in set (0.00 sec)该模式看起来奏效了。[ ]+ 匹配一个或多个空格，\w+ 匹配一个或多个字母数字字符，[ ]+ 匹配结尾的空格。注意，\w+ 是出现在括号里的，所以它是一个子表达式。该子表达式并不是用来进行重复匹配的，它只是对模式分组，将其标识出来以备后用。模式最后一部分是 \1，这是对前面那个子表达式的反向引用，\1 匹配的内容与第一个分组匹配的内容一样。因此，如果 (\w+) 匹配的是单词 of，那么 \1 也匹配单词 of；如果 (\w+) 匹配的是单词 and，那么 \1 也匹配单词 and。
术语“反向引用”指的是这些实体引用的是先前的子表达式。\1 它匹配模式中所使用的第一个子表达式，\2 匹配第二个子表达式、\3 匹配第三个，以此类推。所以在上面那个例子中，[ ]+(\w+)[ ]+\1 匹配连续两次重复出现的单词。可以把反向引用想象成变量。
看过反向引用的用法之后，再回到 HTML 标题的例子。利用反向引用，可以构造一个模式去匹配任何一级标题的开始标签以及相应的结束标签，忽略任何不配对的标签。
mysql> set @s:='<body>
'> <h1>Welcome to my Homepage</h1>
'> Content is divided into two sections:<br/>
'> <h2>SQL</h2>
'> Information about SQL.
'> <h2>RegEx</h2>
'> Information about Regular Expressions.
'> <h2>This is not valid HTML</h3>
'> </body>';
Query OK, 0 rows affected (0.00 sec)
mysql> set @r:='<[hH]([1-6])>.*?</[hH]\\1>';
Query OK, 0 rows affected (0.00 sec)
mysql> select regexp_count(@s, @r, '') c, regexp_extract(@s, @r, '') s, regexp_extract_index(@s, @r, 0, '') i;
+------+-------------------------------------------------------------+----------+
| c | s | i |
+------+-------------------------------------------------------------+----------+
| 3 | <h1>Welcome to my Homepage</h1>,<h2>SQL</h2>,<h2>RegEx</h2> | 8,83,119 |
+------+-------------------------------------------------------------+----------+
1 row in set (0.01 sec)又找到了 3 个匹配：1 个一级标题 <h1>...</h1> 和 2 个二级标题 <h2>...</h2>。<[hH]([1-6])> 匹配任意级别标题的开始标签，这次把 [1-6] 放进了 () 里，使它成为了一个子表达式。这样就可以在用来匹配标题结束标签的 </[hH]\1> 里用 \1 来引用这个子表达式了。子表达式 ([1-6]) 匹配数字 1~6，所以 \1 也只匹配与之相同的数字。<h2>This is not valid HTML</h3> 因而就不会被匹配到了。
反向引用只能用来引用括号里的子表达式。反向引用匹配通常从 1 开始计数（\1、\2等）。在许多实现里，第 0 个匹配 \0 可以用来代表整个正则表达式。
正如看到的那样，子表达式是按照其相对位置来引用的：\1 对应着第一个子表达式，\5 对应着第五个子表达式，等等。虽然受到普遍的支持，但这种语法存在着一个严重的不足：移动或编辑子表达式（子表达式的位置会因此改变）可能会使模式失效，删除或添加子表达式的后果甚至会更严重。为了弥补这一不足，一些比较新的正则表达式实现还支持“命名捕获”（named capture）：给某个子表达式起一个唯一的名称，随后用该名称（而不是相对位置）来引用这个子表达式。
mysql> set @r:='<[hH](?<n>[1-6])>.*?</[hH]\\k<n>>';
Query OK, 0 rows affected (0.00 sec)
mysql> select regexp_count(@s, @r, '') c, regexp_extract(@s, @r, '') s, regexp_extract_index(@s, @r, 0, '') i;
+------+-------------------------------------------------------------+----------+
| c | s | i |
+------+-------------------------------------------------------------+----------+
| 3 | <h1>Welcome to my Homepage</h1>,<h2>SQL</h2>,<h2>RegEx</h2> | 8,83,119 |
+------+-------------------------------------------------------------+----------+
1 row in set (0.00 sec)用 (?<n>[1-6]) 对 [1-6] 的分组命名为 n ，然后可以用 \k<n> 再次使用该分组，MySQL 只支持 \k<分组名> 这一种重用捕获分组的语法。在一个正则表达式中不能使用 ${分组名} 进行引用。
三、替换操作
搜索，也就是在一段文本里查找特定的内容，可能是正则表达式最常干的事，但并不是它的全部功能。正则表达式还可以用来完成各种强大的替换操作。简单的文本替换操作用不着正则表达式。比如说，把所有的CA替换成California，或把所有的MI替换成Michigan，用正则表达式来完成就未免大材小用了，事实上用普通的字符串处理功能反而会更容易（速度也更快）。当用到反向引用时，正则表达式的替换操作才会变得让人印象深刻。
假设想把文本里的电子邮件地址全都转换为可点击的链接。在 HTML 文档里，需要使用 <a href="mailto:[email protected]">[email protected]</a> 这样的语法来创建一个可点击的电子邮件地址。使用反向引用能很容易地把一个电子邮件地址转换为这种可点击的地址格式。
mysql> set @s:='Hello, [email protected] is my email address.';
Query OK, 0 rows affected (0.00 sec)
mysql> set @r:='(\\w+[\\w\\.]*@[\\w\\.]+\\.\\w+)';
Query OK, 0 rows affected (0.00 sec)
mysql> select regexp_replace(@s, @r, '<a href="mailto:$1">$1</a>') c;
+------------------------------------------------------------------------------+
| c |
+------------------------------------------------------------------------------+
| Hello, <a href="mailto:[email protected]">[email protected]</a> is my email address. |
+------------------------------------------------------------------------------+
1 row in set (0.00 sec)替换操作需要用到两个正则表达式：一个用来指定搜索模式，另一个用来指定替换模式。反向引用可以跨模式使用，在第一个模式里匹配的子表达式可以用在第二个模式里。这里使用的模式 (\w+[\w\.]*@[\w\.]+\.\w+) 写成了一个子表达式。这样一来，被匹配到的文本就可以用于替换模式了。<a href="mailto:$1">$1</a> 使用了两次已匹配的子表达式：一次是在 href 属性里用于指定mailto，另一次是作为可点击文本。
正如上面这个例子里看到的那样，同一个子表达式可以被多次引用，只需在用到的地方写出其反向引用形式即可。再来看一个例子。在一个保存用户信息的数据库里，电话号码的保存格式为313-555-1234。现在需要把电话号码的格式重新调整为(313) 555-1234。
mysql> set @s='313-555-1234
'> 248-555-9999
'> 810-555-9000';
Query OK, 0 rows affected (0.00 sec)
mysql> set @r:='(\\d{3})(-)(\\d{3})(-)(\\d{4})';
Query OK, 0 rows affected (0.00 sec)
mysql> select regexp_replace(@s, @r, '($1) $3-$5') c;
+----------------------------------------------+
| c |
+----------------------------------------------+
| (313) 555-1234
(248) 555-9999
(810) 555-9000 |
+----------------------------------------------+
1 row in set (0.00 sec)(\d{3})(-)(\d{3})(-)(\d{4}) 用来匹配一个电话号码，它被划分为彼此独立的 5 个子表达式：第一个子表达式 (\d{3}) 匹配前 3 位数字，第二个子表达式 (-) 匹配 - 字符，等等。最终的结果是一个电话号码被划分成了 5 个部分，每个部分对应着一个子表达式：区号、一个连字符、电话号码的前 3 位数字、又一个连字符、电话号码的后 4 位数字。这 5 个部分都可以单独拿出来使用，($1) $3-$5 只用到了其中 3 个子表达式就完成了格式调整，剩下的 2 个没有用到。
在调整文本格式的时候，把文本分解成多个子表达式的做法往往非常有用，这样可以更精细地控制文本。
四、大小写转换
需求是一级标签 <h1> 和 </h1> 的之间的字符串转为大写。
set @s:='<body>
<h1>Welcome to my Homepage</h1>
Content is divided into two sections:<br/>
<h2>SQL</h2>
Information about SQL.
<h2>RegEx</h2>
Information about Regular Expressions.
<h2>This is not valid HTML</h3>
</body>';
set @r:='(<[Hh]1>)(.*?)(</[Hh]1>)';模式 (<[Hh]1>)(.*?)(<\/[Hh]1>) 把一级标题分成了 3 个子表达式：开始标签、标题文字、结束标签。
以下两种写法都不行。
mysql> select regexp_replace(@s, @r, '$1\\U$2\\E$3') c;
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| c |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| <body>
<h1>UWelcome to my HomepageE</h1>
Content is divided into two sections:<br/>
<h2>SQL</h2>
Information about SQL.
<h2>RegEx</h2>
Information about Regular Expressions.
<h2>This is not valid HTML</h3>
</body> |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)
mysql> select regexp_replace(@s, @r, concat('$1',upper('$2'),'$3')) c;
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| c |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| <body>
<h1>Welcome to my Homepage</h1>
Content is divided into two sections:<br/>
<h2>SQL</h2>
Information about SQL.
<h2>RegEx</h2>
Information about Regular Expressions.
<h2>This is not valid HTML</h3>
</body> |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)第一种写法试图用 $1\\U$2\\E$3 把文本重新组合起来：$1包含开始标签，\U$2\E把第二个子表达式（标题文字）转换为大写，$3包含结束标签。遗憾的是 MySQL 不支持 \U、\E 等元字符，结果是原样输出了这些字符。
第二种写法失败的原因是，upper 函数是在正则表达式匹配之前执行，不会反向引用到子表达式的内容。输出结果是没有做任何替换。
下面是一种可能的实现方式。
mysql> set @r:='(?<=<[Hh]1>).*(?=</[Hh]1>)';
Query OK, 0 rows affected (0.00 sec)
mysql> select replace(@s, regexp_substr(@s,@r), upper(regexp_substr(@s,@r)));
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| replace(@s, regexp_substr(@s,@r), upper(regexp_substr(@s,@r))) |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| <body>
<h1>WELCOME TO MY HOMEPAGE</h1>
Content is divided into two sections:<br/>
<h2>SQL</h2>
Information about SQL.
<h2>RegEx</h2>
Information about Regular Expressions.
<h2>This is not valid HTML</h3>
</body> |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)使用环视子表达式，捕获一级标签的内容。然后外层使用 replace 函数，将原字符串中的一级标签内容转为大写。