学习正则表达式 - 选择、分组和向后引用

已于 2023-06-05 15:46:22 修改
阅读量1k 收藏 2
点赞数 2
分类专栏： 用MySQL学正则 文章标签： 正则表达式 mysql
于 2023-05-02 12:52:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzy0623/article/details/130462759
版权

目录

一、选择操作

1. 选项和修饰符

2. 统计单词出现的行数

3. 查找重复出现的单词

二、子模式

三、捕获分组和后向引用

1. 多重替换

2. 命名分组

四、非捕获分组

1. 原子分组

2. 回溯

（1）量词导致回溯

（2）分支导致回溯

（3）回溯与性能

参考：

一、选择操作

        简单地说，选择操作可在多个可选模式中匹配一个。例如想找出 the 出现过多少次，包括THE、The 和 the 等形式。为此就可以使用选择操作 (the|The|THE) ：

mysql> select regexp_like('the','(the|The|THE)');
+------------------------------------+
| regexp_like('the','(the|The|THE)') |
+------------------------------------+
|                                  1 |
+------------------------------------+
1 row in set (0.00 sec)

1. 选项和修饰符

        可以使用一个选项来使分组更简短。借助选项，可以指定查找模式的方式。例如 (?i) 选项让模式不再区分大小写，因此原来带选择操作的模式可以简写成 (?i)the ：

mysql> select regexp_like('THE','(?i)the');
+------------------------------+
| regexp_like('THE','(?i)the') |
+------------------------------+
|                            1 |
+------------------------------+
1 row in set (0.00 sec)

        此时即便使用 regexp_like 函数的选项 c 也不会起到区分大小写的效果，因为正则表达式中的 (?i) 会匹配所有大小写组合。

mysql> select regexp_like('THE','the'),regexp_like('THE','the','c'),regexp_like('THE','(?i)the','c')\G
*************************** 1. row ***************************
        regexp_like('THE','the'): 1
    regexp_like('THE','the','c'): 0
regexp_like('THE','(?i)the','c'): 1
1 row in set (0.00 sec)

        下表中列出了各种选项和修饰符，MySQL支持除 (?J) 和 (?U) 以外的其它选项。

选项

描述

支持平台

(?d)

Unix中的行

Java

(?i)

不区分大小写

PCRE、Perl、Jave

(?J)

允许重复的名字

PCRE*

(?m)

多行

PCRE、Perl、Java

(?s)

单行（dotall）

PCRE、Perl、Java

(?u)

Unicode

Java

(?U)

默认最短匹配

PCRE

(?x)

忽略空格和注释

PCRE、Perl、Java

(?-…)

复原或关闭选项

PCRE

*参见http://www.pcre.org/pcre.txt中的“Named Subpatterns”（命名子模式）。

2. 统计单词出现的行数

        要对单词 the 出现一次或多次的行的数目进行统计，且不区分大小写。为了更切合数据库的实际应用场景，先给原表增加一个ID主键列。

alter table t_regexp add id int auto_increment primary key first;

        统计单词出现的行数的需求实现如下。

select id,sum(regexp_like(b,'\\bthe\\b(?i)'))
  from (
select id,substring_index(substring_index(a,char(10),lv),char(10),-1) b, lv
  from t_regexp,
(with recursive tab1(lv) as (
      select 1 lv union all select t1.lv + 1 from tab1 t1 where lv < 20 )
 select lv from tab1) t 
 where t.lv <= (length(a) - length(replace(a,char(10),''))) + 1) t
 group by id;

        MySQL正则表达式虽然提供了“多行模式”，但只能用于匹配时的比较，并未提供按行统计的接口。对于数据库来说，\n 只是一个普通字符，整个字符串还是一行。因此要实现 \n 分割的多行统计，需要将单行拆分为多行，再进行后续的匹配和汇总求和。按固定分隔符将一行分成多行的经典方法，就是先使用笛卡尔积连接制造出行，再用两个嵌套的substring_index函数取子串。MySQL 8提供了递归查询，可以轻松构造序列表，以进行笛卡尔积连接。

        最内层查询构造出1-20的数字序列表，其中的20是变量，为预估的最大 \n 个数：

mysql> with recursive tab1(lv) as (
    ->     select 1 lv union all select t1.lv + 1 from tab1 t1 where lv < 20 )
    ->  select lv from tab1;
+------+
| lv   |
+------+
|    1 |
|    2 |
|    3 |
|    4 |
|    5 |
|    6 |
|    7 |
|    8 |
|    9 |
|   10 |
|   11 |
|   12 |
|   13 |
|   14 |
|   15 |
|   16 |
|   17 |
|   18 |
|   19 |
|   20 |
+------+
20 rows in set (0.00 sec)

        中间层的查询，将一行按换行符 \n 分割成多行；

mysql> select id,substring_index(substring_index(a,char(10),lv),char(10),-1) b, lv
    ->   from t_regexp,
    -> (with recursive tab1(lv) as (
    ->       select 1 lv union all select t1.lv + 1 from tab1 t1 where lv < 20 )
    ->  select lv from tab1) t 
    ->  where t.lv <= (length(a) - length(replace(a,char(10),''))) + 1;
+----+---------------------------------------------------------------------------------+------+
| id | b                                                                               | lv   |
+----+---------------------------------------------------------------------------------+------+
|  1 | THE RIME OF THE ANCYENT MARINERE, IN SEVEN PARTS.                               |    1 |
|  1 | ARGUMENT.                                                                       |    2 |
|  1 | How a Ship having passed the Line was driven by Storms to the cold Country      |    3 |
|  1 | towards the South Pole; and how from thence she made her course to the tropical |    4 |
|  1 | Latitude of the Great Pacific Ocean; and of the strange things that befell;     |    5 |
|  1 | and in what manner the Ancyent Marinere came back to his own Country.           |    6 |
|  1 | I.                                                                              |    7 |
|  1 | 1       It is an ancyent Marinere,                                              |    8 |
|  1 | 2          And he stoppeth one of three:                                        |    9 |
|  1 | 3       "By thy long grey beard and thy glittering eye                          |   10 |
|  1 | 4          "Now wherefore stoppest me?                                          |   11 |
|  2 | THE RIME OF THE ANCYENT MARINERE, IN SEVEN PARTS.                               |    1 |
|  3 | ARGUMENT.                                                                       |    1 |
|  4 | How a Ship having passed the Line was driven by Storms to the cold Country      |    1 |
|  5 | towards the South Pole; and how from thence she made her course to the tropical |    1 |
|  6 | Latitude of the Great Pacific Ocean; and of the strange things that befell;     |    1 |
|  7 | and in what manner the Ancyent Marinere came back to his own Country.           |    1 |
|  8 | I.                                                                              |    1 |
|  9 | 1       It is an ancyent Marinere,                                              |    1 |
| 10 | 2          And he stoppeth one of three:                                        |    1 |
| 11 | 3       "By thy long grey beard and thy glittering eye                          |    1 |
| 12 | 4          "Now wherefore stoppest me?                                          |    1 |
+----+---------------------------------------------------------------------------------+------+
22 rows in set (0.00 sec)

        最外层按行ID分组求和，统计每数据库行中，单词 the 出现的以 \n 分割的行数：

mysql> select id,sum(regexp_like(b,'\\bthe\\b(?i)'))
    ->   from (
    -> select id,substring_index(substring_index(a,char(10),lv),char(10),-1) b, lv
    ->   from t_regexp,
    -> (with recursive tab1(lv) as (
    ->       select 1 lv union all select t1.lv + 1 from tab1 t1 where lv < 20 )
    ->  select lv from tab1) t 
    ->  where t.lv <= (length(a) - length(replace(a,char(10),''))) + 1) t
    ->  group by id;
+----+-------------------------------------+
| id | sum(regexp_like(b,'\\bthe\\b(?i)')) |
+----+-------------------------------------+
|  1 |                                   5 |
|  2 |                                   1 |
|  3 |                                   0 |
|  4 |                                   1 |
|  5 |                                   1 |
|  6 |                                   1 |
|  7 |                                   1 |
|  8 |                                   0 |
|  9 |                                   0 |
| 10 |                                   0 |
| 11 |                                   0 |
| 12 |                                   0 |
+----+-------------------------------------+
12 rows in set (0.00 sec)

3. 查找重复出现的单词

mysql> set @s:='abc abc abcde <b><tag>
    '> abcde dfjs flskj
    '> fsdlk fdslkjf fsl;dfjs';
Query OK, 0 rows affected (0.00 sec)

mysql> set @r:='\\b([a-z]+)((?:\\s|<[^>]+>)+)+(\\1\\b)';
Query OK, 0 rows affected (0.00 sec)

mysql> select regexp_count(@s, @r, '') c, regexp_extract(@s, @r, '') s;
+------+------------------------------+
| c    | s                            |
+------+------------------------------+
|    2 | abc abc,abcde <b><tag>
abcde |
+------+------------------------------+
1 row in set (0.00 sec)

二、子模式

        多数情况下，提到正则表达式中的子模式（subpattern），就是指分组中的一个或多个分组。子模式就是模式中的模式。多数情况下，子模式中的条件能得到匹配的前提是前面的模式得到匹配，但也有例外。子模式的写法可以有很多种，这里我们主要关注括号中的子模式，如之前所见的模式 (the|The|THE) 有三个子模式：the 是第一个子模式，The 是第二个，而 THE 是第三个。但是这种情况下，匹配第二个子模式不依赖于是否匹配第一个。（最左边的模式会首先匹配。）而在以下的模式中，子模式依赖于前面的模式：

(t|T)h(e|eir)

         这个模式会匹配字面值 t 或 T，然后是一个 h，接下来就是一个 e 或者是 eir。相应地，这个模式会匹配以下四种情况：the、The、their、Their。

        在以上情况中，第二个子模式 (e|eir) 依赖于第一个子模式 (t|T)。括号对于子模式不是必需的。下面是一个使用字符组的子模式示例：

\b[tT]h[ceinry]*\b

        这个模式会匹配 the 或 The 还有th、thee、thy 以及 thence 等单词。两个单词边界（\b）表示该模式只匹配整个单词，而不会匹配单词中的某几个字母。

mysql> set @r:='\\b[tT]h[ceinry]*\\b';
Query OK, 0 rows affected (0.00 sec)

mysql> select regexp_like('th',@r),regexp_like('thee',@r),regexp_like('thy',@r),regexp_like('thence',@r);
+----------------------+------------------------+-----------------------+--------------------------+
| regexp_like('th',@r) | regexp_like('thee',@r) | regexp_like('thy',@r) | regexp_like('thence',@r) |
+----------------------+------------------------+-----------------------+--------------------------+
|                    1 |                      1 |                     1 |                        1 |
+----------------------+------------------------+-----------------------+--------------------------+
1 row in set (0.00 sec)

        以下是对这个模式的解析。

  • \b匹配单词起始边界。
  • [tT] 是字符组，它匹配小写字母 t 或者大写字母 T。可以将其看做是第一个子模式。
  • 然后匹配（或尝试匹配）小写字母 h。
  • 第二个也就是最后一个子模式也表示为字符组 [ceinry]，其后用量词 * 表示零个或多个。
  • 最后，该模式以另外一个 \b 结束。

        正则表达式的术语经常是含义相近但使用范围迥异，也有人认为字符组不是子模式。这里的观点是它们与子模式起到的作用一样，所以两者可以归为一类。

三、捕获分组和后向引用

        当一个模式的全部或者部分内容由一对括号分组时，它就对内容进行捕获并临时存储于内存中。可以通过后向引用引用捕获的内容，形式为 \1 或 $1 。这里 \1 或 $1 引用的是第一个捕获的分组，而 \2 或 $2 引用第二个捕获的分组，以此类推。MySQL只接受 $1 这种形式。

        下面再展示一下后向引用的使用方法。我们将使用它来重新排序诗文中的一行词。

mysql> select regexp_replace('It is an ancyent Marinere','(It is) (an ancyent Marinere)','\\2 \\1') c1,
    ->        regexp_replace('It is an ancyent Marinere','(It is) (an ancyent Marinere)','$2 $1') c2;
+------+---------------------------+
| c1   | c2                        |
+------+---------------------------+
| 2 1  | an ancyent Marinere It is |
+------+---------------------------+
1 row in set (0.00 sec)

        使用 regexp_replace 正则替换函数，将原文分成两个捕获分组用作正则表达式，替换字符串引用两个捕获分组并颠倒顺序。要用sed得到相同结果，可以这样做

sed -En 's/(It is) (an ancyent Marinere)/\2 \1/p' rime.txt

        输出为：

1       an ancyent Marinere It is,

        下面我们来分析一下这个 sed 命令。

  • -E选项仍然是调用ERE（扩展的正则表达式），因此，括号可以直接当成字面值来使用了。
  • -n选项覆盖打印每一行的默认设置。
  • 替换命令搜索与文本“It is an ancyent Marinere”匹配的内容，再将其捕获放入两个分组中。
  • 替换命令还将捕获的文本重排为先是后向引用 \2 的内容再是 \1 的内容，再将匹配的文本替换为重排后的内容并输出。
  • 替换命令结尾处的 p 表示要打印该行。

1. 多重替换

        有时还可以利用捕获分组和向后引用实现类似 Oracle translate 函数的多重替换功能。下面来看一个简单的例子：将字符串中的纯数字串加一个前缀0，纯字母串前加一个前缀减号。例如对于输入字符串 '12 ab 345 cde 6789'，输出为 '012 -ab 0345 -cde 06789'。用捕获组及其向后引用就可以轻易实现。

mysql> set @s:='12 ab 345 cde 6789';
Query OK, 0 rows affected (0.00 sec)

mysql> set @r1:='(\\b\\d+\\b)';
Query OK, 0 rows affected (0.00 sec)

mysql> set @r2:='(\\b[a-zA-Z]+\\b)';
Query OK, 0 rows affected (0.00 sec)

mysql> 
mysql> select regexp_replace(regexp_replace(@s,@r1,'0$1'),@r2,'-$1');
+--------------------------------------------------------+
| regexp_replace(regexp_replace(@s,@r1,'0$1'),@r2,'-$1') |
+--------------------------------------------------------+
| 012 -ab 0345 -cde 06789                                |
+--------------------------------------------------------+
1 row in set (0.00 sec)

2. 命名分组

        命名分组（named group）就是有名字的分组。这样，就可以通过名字（而不是数字）来引用分组。下面展示一下MySQL中如何使用命名分组：

mysql> select regexp_replace('It is an ancyent Marinere','(?<one>It is) (?<two>an ancyent Marinere)','${two} ${one}') c2;
+---------------------------+
| c2                        |
+---------------------------+
| an ancyent Marinere It is |
+---------------------------+
1 row in set (0.00 sec)

        在括号内添加 ?<one> 和 ?<two> 将分组分别命名为 one 和 two ；${one} 引用名为 one 的分组，而 ${two} 则引用名为 two 的分组。如果在一个模式中有分组被命名，那么还可以重用该命名分组。这里说的是“重用”而不是前面所说的“引用”，简单说重用指的是在一个正则表达式中的引用。解释一下这句话的意思，假设要查找含有连续六个0的字符串：

mysql> select regexp_like('000000','(?<z>0{3})\\k<z>');
+------------------------------------------+
| regexp_like('000000','(?<z>0{3})\\k<z>') |
+------------------------------------------+
|                                        1 |
+------------------------------------------+
1 row in set (0.00 sec)

        用 (?<z>0{3}) 对连续三个0的分组命名为 z ，然后可以用 \k<z> 再次使用该分组，MySQL只支持 \k<分组名> 这一种重用捕获分组的语法。在一个正则表达式中不能使用 ${分组名} 进行引用。

mysql> select regexp_like('000000','(?<z>0{3})${z}');
ERROR 3692 (HY000): Incorrect description of a {min,max} interval.

四、非捕获分组

        还有一种分组是非捕获分组（Non-Capturing Group）。非捕获分组不会将其内容存储在内存中，即非捕获分组根本不保存匹配项的值。在并不想引用分组的时候，可以使用它。由于不存储内容，非捕获分组就会带来较高的性能。非捕获分组的语法是在分组中加上 ?: 前缀。

mysql> select regexp_like('the','(?:the|The|THE)'), 
    ->        regexp_like('the','(?i)(?:the)'),
    ->        regexp_like('the','(?:(?i)the)'),
    ->        regexp_like('the','(?i:the)')\G
*************************** 1. row ***************************
regexp_like('the','(?:the|The|THE)'): 1
    regexp_like('the','(?i)(?:the)'): 1
    regexp_like('the','(?:(?i)the)'): 1
       regexp_like('the','(?i:the)'): 1
1 row in set (0.00 sec)

        上面语句中四个 regexp_like 中的正则表达式等价，都是匹配不区分大小写的单词 the 。注意最后一种写法，选项 i 可以放在问号和冒号之间。

1. 原子分组

        另一种非捕获分组是原子分组（atomic group），原子分组禁用回溯。如果使用的正则表达式引擎进行回溯操作，这种分组就可以将回溯操作关闭，但它只针对原子分组内的部分，而不针对整个正则表达式。其语法为 (?>the)： 

mysql> select regexp_like('THE','(?>the)');
+------------------------------+
| regexp_like('THE','(?>the)') |
+------------------------------+
|                            1 |
+------------------------------+
1 row in set (0.00 sec)

2. 回溯

        正则表达式匹配目标字符串时，它从左到右逐个测试表达式的组成部分，看是否能找到匹配项。在遇到量词时，需要决定何时尝试匹配更多字符。在遇到分支时，必须从可选项中选择一个尝试匹配。每当正则做类似的决定时，如果有必要，都会记录其他选择，以便匹配不成功时进行回溯，到最后一个决策点，再重新进行匹配。

（1）量词导致回溯

        考虑正则表达式 ab?c 匹配字符串 ac。

  1. 首先从 a 开始，匹配到了，跳到 a 后面的位置（即一个零宽断言的位置）。
  2. 然后字符 b 后面有一个量词修饰符 ?，代表0或1次，匹配 b，没有出现 b 的情况先记录下来，放到备用状态里面。如果后面的匹配不成功，那么就回溯，到备用状态里面选择一个重新匹配。现在我们可以暂时认为这个量词要匹配，那么便是出现 1 次，此时的正则其实相当于 abc，b和c不一样，匹配失败。
  3. 注意，现在就要回溯了，到备用状态里面拿出来，此时正则表达式相当于ac，匹配ac，c和c一样，匹配成功。
mysql> select regexp_like('ac','ab?c');
+--------------------------+
| regexp_like('ac','ab?c') |
+--------------------------+
|                        1 |
+--------------------------+
1 row in set (0.00 sec)

        使用原子分组时，如果完整的正则表达式与给定的字符串不匹配，则正则表达式引擎不会回退进一步的排列。还以本例来分析。

  1. 首先从 a 开始，匹配到了，跳到 a 后面的位置（即一个零宽断言的位置）。
  2. 然后字符 b 后面有一个量词修饰符 ?，代表0或1次，匹配 b，如果后面的匹配不成功，则匹配失败。现在我们可以认为这个量词要匹配，那么便是出现 1 次，此时的正则其实相当于 abc，b和c不一样，匹配失败。
mysql> select regexp_like('ac','ab?>c');
+---------------------------+
| regexp_like('ac','ab?>c') |
+---------------------------+
|                         0 |
+---------------------------+
1 row in set (0.00 sec)

（2）分支导致回溯

        考虑正则表达式 a(bc|b)c 匹配字符串 abc。

  1. 首先从 a 开始，匹配到了，跳到 a 后面的位置（即一个零宽断言的位置）。
  2. 继续走遇到了分支，先用左边的（分支选择是从左到右），abbc 与 abc 匹配失败。
  3. 要回溯，从开始的那个 a 后面的位置，abc 与 abc 匹配成功。

        如果使用原子分组：

  1. 首先从 a 开始，匹配到了，跳到 a 后面的位置（即一个零宽断言的位置）。
  2. 继续走遇到了分支，先用左边的（分支选择是从左到右），abbc 与 abc 匹配失败，则整个匹配失败，不再回溯其他分支。
mysql> select regexp_like('abc','a(bc|b)c'),
    ->        regexp_like('abc','a(?:bc|b)c'),
    ->        regexp_like('abc','a(?:b|bc)c'),
    ->        regexp_like('abc','a(?>bc|b)c'),
    ->        regexp_like('abc','a(?>b|bc)c')\G
*************************** 1. row ***************************
  regexp_like('abc','a(bc|b)c'): 1
regexp_like('abc','a(?:bc|b)c'): 1
regexp_like('abc','a(?:b|bc)c'): 1
regexp_like('abc','a(?>bc|b)c'): 0
regexp_like('abc','a(?>b|bc)c'): 1
1 row in set (0.00 sec)

        当使用分支（也叫替换）时，如果匹配成功，则正则表达式将立即尝试匹配表达式的其余部分，但会跟踪可能进行其他替换的位置。如果表达式的其余部分不匹配，则正则表达式将返回到先前记录的位置并尝试其他组合。如果使用了原子分组，则正则表达式引擎将不会跟踪先前的位置，而只会放弃匹配。

（3）回溯与性能

        上面的示例清楚地表明原子分组消除了回溯，并可能改变匹配的结果，但并没有真正说明使用原子分组的目的。什么时候会想使用原子分组呢？正则表达式处理过程缓慢的一个因素就是回溯操作。其原因就是回溯操作会尝试每一种可能性，这会消耗时间和计算资源，有时它会占用大量时间。回溯有可能产生巨大的负面效应，这被称为灾难性回溯。来看下面的例子。

mysql> select regexp_like('11ab11111111111111111111111','(a(.+)+b)');
ERROR 3699 (HY000): Timeout exceeded in regular expression match.

        查询直接报错退出。MySQL 8用两个系统变量控制匹配引擎的资源消耗。regexp_stack_limit 控制匹配使用的最大内存，缺省为 8000000 字节。regexp_time_limit 控制引擎执行的最大步骤数，缺省为 32。因为这个限制是用步骤数表示的，所以它只会间接影响执行时间。通常匹配引擎执行时间的数量级为毫秒。

mysql> show variables like 'regexp%';
+--------------------+---------+
| Variable_name      | Value   |
+--------------------+---------+
| regexp_stack_limit | 8000000 |
| regexp_time_limit  | 32      |
+--------------------+---------+
2 rows in set (0.00 sec)

        在贪婪量词模式下，正则表达式会尽可能长地去匹配符合规则的字符串，且会回溯。这种情况下原子分组会显著提高查询性能。

mysql> select regexp_like('11ab11111111111111111111111','(a(.+)+b)');
+----------------------------------------------------------+
| regexp_like('11ab11111111111111111111111','(a(?>.+)+b)') |
+----------------------------------------------------------+
|                                                        0 |
+----------------------------------------------------------+
1 row in set (0.00 sec)

参考：

https://www.codenong.com/6488944/
https://zhuanlan.zhihu.com/p/52889281
https://dev.mysql.com/blog-archive/new-regular-expression-functions-in-mysql-8-0/
https://stackoverflow.com/questions/56858176/mysql-error-3699-timeout-exceeded-in-regular-expression-match/58404086
https://www.regular-expressions.info/atomic.html
https://learnbyexample.github.io/python-regex-possessive-quantifier/

wzy0623
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
正则表达式：后向引用
弱智de克星
10-07 1723
预备知识replace()方法大家一定很熟悉了吧，stringObject.replace(regexp/substr,replacement)w3school里面有一段话相信大家也看过了： 注意：ECMAScript v3 规定，replace() 方法的参数 replacement可以是函数而不是字符串。在这种情况下，每个匹配都调用该函数，它返回的字符串将作为替换文本使用。该函数的第一个参数
linux系统shell正则表达式-练习工具和教材
01-04
3. regexcrossword.com：以填字游戏的形式学习正则表达式，寓教于乐。 四、推荐教材 1. 《Mastering Regular Expressions》：权威的正则表达式指南，深入浅出，适合初学者和进阶者。 2. 《正则表达式实战》：实例...
正则表达式 后向引用
满天星
08-11 2227
正则表达式一个最重要的特性就是将匹配成功的模式的某部分进行存储供以后使用这一能力。 对一个正则表达式模式或部分模式两边添加圆括号()可以把这部分表达式存储到一个临时缓冲区中。 所捕获的每个子匹配都按照在正则表达式模式中从左至右所遇到的内容按顺序存储。 存储子匹配的缓冲区编号从1开始，连续编号至最大99个子表达式。 每个缓冲区都可以使用'\n'(或用'$n')访问，其中n为1至99的阿拉
正则表达式_字符匹配/可选字符集
最新发布
m0_51648467的博客
05-05 420
就这样 的正则表达式。这些位置是普通字符 R o o m \d \d \d 20 这 3 个位置各匹配一个数字 其中“Room”是普通字符，而“\d”是通配符，表示该位置上有一个数字。该表达式 共占用了 7 个位置，第一个位置上是字母“R”，第二个位置和第三个位置上都是字母“o”， 第四个位置上是字母“m”，而第五到第七个位置上是三个数字。所以正则表达式 “Room\d\d\d”代表着“比如字符串 “Room101”、“Room415”、“Room888”等都与“Room\d\d\d”匹配①。
正则表达式
lenka的专栏
05-03 773
正则表达式修饰符 - 可选标志 正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志： 修饰符 描述 re.I 使匹配对大小写不敏感 re.L 做本地化识别（locale-aware）匹配 re.M 多行匹配，影响 ^ 和 $ re.S 使 . 匹配包括换行在内的所有字符 re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W,
oracle正则表达式分组替换,Oracle正则表达式函数-REGEXP_REPLACE使用例子
weixin_29544469的博客
04-02 2296
6个参数第一个是输入的字符串第二个是正则表达式第三个是替换的字符第四个是标识从第几个字符开始正则表达式匹配。(默认为1)第五个是标识第几个匹配组。(默认为全部都替换掉)第六个是是取值范围：i：大小写不敏感；c：大小写敏感；n：点号.不匹配换行符号；m：多行模式；x：扩展模式，忽略正则表达式中的空白字符。全部测试数据SQL> select * fromtest_reg_substr;A--...
正则表达式——子模式
weixin_30872867的博客
02-14 1048
import re# string = "this is a love1ly girl lovel1y"# pattern = re.compile(r"lovely")# ret = pattern.search(string)# print(ret.group())# # group()是返回匹配的整个表达式的字符串string = "额呵呵<span><div>床前明...
浅谈正则表达式中的分组和引用实现方法
12-13
其实我对正则表达式的学习基本完全来源于犀牛书的第10章，真正看懂这一章，我觉得操作正则表达式应该不在话下。 我的答案 先给出我的答案吧： ‘abbccddd’.match(/(\w)\1*/g) // [“a”, “bb”, “cc”, “ddd”]...
精通正则表达式-Jeffery E.F.Fridel著
04-18
以上只是正则表达式基础知识的一部分，实际上，正则表达式还有更多高级特性，如递归、条件表达式等，这些都需要通过实践和学习才能完全掌握。《精通正则表达式》这本书深入细致地讲解了这些内容，对于想深入了解正则...
正则表达式-01.zip
11-08
正则表达式是一种强大的文本处理工具，用于匹配、查找、替换和分析字符串模式。在C#编程语言中，正则表达式是通过`...在实际应用中，应根据需求灵活运用上述知识点，同时不断学习和实践，提升正则表达式的运用技巧。
EXCEL-VBA-正则表达式-从实例开始.docx
10-11
要深入学习正则表达式，可以参考所提供的教程链接。 2. VBA中的正则表达式应用： 在VBA中使用正则表达式，首先需要引用Microsoft VBScript Regular Expressions 5.5库。有两种方法创建正则表达式对象： - 前期...
正则表达式-子模式
weixin_30709061的博客
05-25 318
子模式： <?php /* 子模式： 作用：作为大原子使用 改变优先级，加上括号可以提高优先级 作为子模式使用，正则表达式不先对一个字符串 可以取消子模式的使用，就将它作为大原子或者改变优先级使用 在括号中最前面使用"?:"就可以取消他的子模式只用来改变优先级使用 */ $string="today is 2016-05-25 14:38 pm"; $P...
正则表达式分组
m0_73357410的博客
05-03 193
在正则表达式中用（）进行分组如"(\\w|\\d){2,5}[2345]\\d+(\\w&&[^._])"而每一个分组都有自己的序号以左括号为标准第一个出现的为第一组其中（\\w|\\d）是第一组，(\\w&&[^._])是二组类似嵌套的正则(a*|(b+{9})其中该正则整体为第一组，(b+{9})为第二组。
java正则表达式 分组引用_正则表达式之分组(捕获)、后向引用
weixin_34493827的博客
02-13 400
分组正则表达式中的分组又称为子表达式，就是把一个正则表达式的全部或部分当做一个整体进行处理，分成一个或多个组。其中分组是使用“()”表示的。进行分组之后“()”里面的内容就会被当成一个整体来处理。先看看一个具体的例子吧： 同时我们可以使用“()”限制替换的范围 分组可以分为捕获组和非捕获组.捕获组可以通过从左到右通过其括号对其进行编号: 需要注意的是组零永远代表的是整个正则式,通过这样命名保...
js正则表达式的选择、分组、引用
qq_34356563的博客
09-04 3857
分组：字符串“|”用于分隔供选择的字符 选择的尝试匹配次序是从左到右，直到发现了匹配项，就忽略右边的匹配项，即使它产生了更好的匹配。 "ab".match(/a|ab/) //["a", index: 0, input: "ab"] 上面的匹配即便ab更合适但还是只会匹配a 分组：使用（）把单独的项组合成子表达式，以便可以像处理一个独立的单元那样用“|”、“*”、“+”、“？”等来对单元内
正则表达式 - - 选择运算 | & 匹配 ip 地址
Lhy_JL的博客
05-23 305
正则表达式一、 选择或者关系运算 ： |1.1、匹配 ip：192.168.1.35 地址呢？二、匹配 ip 一、 选择或者关系运算 ： | 规则： 自左向右匹配，一旦匹配上，就不会回头 直接上代码： console.log(/12|34|56/.exec('1')); console.log(/12|34|56/.exec('3')); console.log(/12|34|56/.exec('12')); console.log(/12|34|56/.exec('56')); consol
[跟我学正则表达式] 8. 使用后向引用
searun的专栏
05-16 351
前一章中介绍了如何使用子表达式将字符分成组。这种分组的主要用途之一是可以控制组的重复次数（在前一章中已经演示过）。本章中将介绍子表达式一个更重要的用法——使用后向引用。   理解后向引用 理解后向引用需求的最好办法是看一个例子。 HTML 开发者经常使用段落标签（ &lt;H1&gt; 到 &lt;H6&gt; ，包括相应的结束标签）来定义 Web 页面的提纲。假设你需...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值