C# 正则表达式详解（学习心得 25）_正则 c# \1+

正则表达式 是一种匹配输入文本的模式。

.Net 框架提供了允许这种匹配的正则表达式引擎。

使用以下字符，运算符，结构，来定义正则表达式：

• 转义字符
• 字符类
• 定位点
• 分组构造
• 限定符
• 反向引用构造
• 备用构造
• 替换
• 杂项构造

一、转义字符

转义字符列表：

二、字符类

关于 \p{ name } ：

使用 \p{ name } 匹配语言：

三、定位点

四、分组构造

4.1 (?= subexpression) 详解

这里实际上是这样的：

1. 首先查看下 subexpression 在原来字符串中是否存在

2. 如果存在，则记录下 subexpression 在原来字符串中的初始位置：

   比如我要在 “abcdefg” 中查询 “bc”，那位置就是 1

3. 然后这个 subexpression 并不会进行返回：

   所以 a(?=bc) 在 “abcdefg” 中返回的是 “a”，而不是 “abc”

4. 最重要的是，由于返回的是位置，所以如果要再后面添加继续匹配的内容：

   比如 a(?=bc)d 在 “abcdefg” 中是比配不到的，需要写成 a(?=bc)b，最终匹配成功的是 “ab”

4.2 (?! subexpression) 详解

这里同样是匹配到一个不满足 subexpression 的位置：

比如 “unsure sure unity used” 中匹配 \b(?!un)\w+\b

1. 首先匹配 \b ，可以看到 4 个单词都可以匹配上
2. 然后匹配 (?!un)，也就是单词边界后面跟着的不能是 un，也就是这个单词不能是 un 开头，所以 unsure 和 unity 就被排除了
3. 之后再匹配 \w，其实并不是从单词的第 2 个字母开始匹配（序号从 0 开始算），而是从第 0 个字母开始匹配，所以我们得到的是 sure 和 used，而不是 re 和 ed

4.3 (?<=subexpression) 详解

对照前面来看， (?= subexpression) 取得的是匹配到的 subexpression 在原字符串中的起始位置，这里 (?<=subexpression) 取得的是匹配到的终点位置。

比如在 “1851 1999 1950 1905 2003” 匹配 (?<=19)\d{2}\b：

1. 首先匹配 (?<=19)，找到了 3 个 “19”
2. 然后我们得到的是这 3 个 “19” 的结束位置：6，11，16
3. 然后从 3 个位置往后去寻找 \d{2}\b，所以找到了 “99”，“50”，“05”

另一种理解思路：

1. 先匹配 \d{2}\b，找到 “51”，“99”，“50”，“05”，“03”
2. 然后往前匹配 (?<=19)，匹配到了也不显示，所以结果是 “99”，“50”，“05”

4.4 (?<!subexpression) 详解

首先在原字符串中匹配 subexpression，匹配到以后记录下终点位置，后面的从终点位置往后进行匹配。

比如在 “Hi woman Hi man” 中匹配 (?<!wo)man\b：

1. 首先匹配 man\b，找到 2 个地方
2. 然后往前看 (?<!wo)，只有一个地方满足，最后返回 “man”

4.5 (?> subexpression) 详解

官方文档的解释是，这里用 (?> subexpression) 这种表示不回溯。

比如：在 “aaaaa” 中匹配 (?>(\w)\1+)a\b 就不会匹配成功，而使用回溯机制即匹配 (\w)\1+a\b，就可以匹配成功得到 “aaaaa”。

这里其实遇到个问题：

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "aaaaa aaaad";
        string pattern = @"(\w)\1+.\b";

        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine(match.Value);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果：

回溯情况：
aaaaa 
aaaad
不回溯情况：
aaaaa 
aaaad
1
2
3
4
5
6

但是按照官方文档的意思，由于不回溯，所以 “aaaaa” 不会匹配成功才对。

尝试如下：

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "aaaaa";
        string noback_pattern = @"(\w)\1+.\b";

        Console.WriteLine("回溯情况：");
        foreach (Match match in Regex.Matches(input, noback_pattern))
            Console.WriteLine(match.Value);

        string back_pattern = @"(?>(\w)\1+).\b";
        Console.WriteLine("不回溯情况：");
        foreach (Match match in Regex.Matches(input, back_pattern))
            Console.WriteLine(match.Value);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果：

回溯情况：
aaaaa
不回溯情况：

1
2
3
4

始终搞不明白为什么以上两个例子中的结果会有这种差异！有待研究！

后记：总算搞明白了，这里不是 “回溯/不回溯”出了问题，而是 “\b” 的问题

1. 在 “aaaaa aaaad” 中匹配 (\w)\1+.\b
2. 首先 (\w) 匹配到所有的字母
3. 然后 \1 表示再匹配一次，说明是两个重复的字母
4. 然后 + 表示前面的匹配 一次或多次，说明至少 2 个重复字母
5. 到这里，我们匹配上的是 “aaaaa” 和 “aaaa”
6. 然后 . 匹配任何字符（包含空格），匹配上 “aaaaa ” 和 “aaaad”
7. 然后 \b 匹配单词边界（包含前边界和后边界），匹配上 “aaaaa (\b为后面aaaad的前边界)” 和 “aaaad(\b单词后边界)”

五、限定符

六、反向引用构造

以前匹配到的，方便后面继续匹配

比如：“seeeke” 中我们要匹配 “eke”，则可以写成 (?<c>\w)k\k<c>

1. 首先通过 (?<c>\w)，要匹配一个 \w，同时把这个匹配规则存储到 <c> 中
2. 后面再匹配一个 k
3. 然后，后面再通过 \k<c> 反引用存储在 <c> 中的 \w（需要和前面 \w 匹配到的字符相同）
4. 最终得到了 eke

通过 \ number 的方式，(\w)k\1，可以得到同样的效果：

1. 首先通过 (\w) 匹配一个 \w，同时存储到 1 位置
2. 然后在匹配一个 k
3. 然后通过 \1，再次匹配一个 \w（需要和前面 \w 匹配到的字符相同）

七、备用构造

备用构造用于修改正则表达式以启用 either/or 匹配。

八、替换

替换是替换模式中使用的正则表达式。

九、杂项构造

十、Regex 类

Regex 类用于表示一个正则表达式。

常用方法：

10.1 例：匹配以 ‘S’ 开头的单词

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "A Thousand Splendid Suns";

         Console.WriteLine("Matching words that start with 'S': ");
         showMatch(str, @"\bS\S*");
         Console.ReadKey();
      }
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

运行结果：

Matching words that start with 'S':
The Expression: \bS\S*
Splendid
Suns
1
2
3
4

10.2 例：匹配以 ‘m’ 开头以 ‘e’ 结尾的单词

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "make maze and manage to measure it";

         Console.WriteLine("Matching words start with 'm' and ends with 'e':");
         showMatch(str, @"\bm\S*e\b");
         Console.ReadKey();
      }
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

运行结果：

Matching words start with 'm' and ends with 'e':
The Expression: \bm\S*e\b
make
maze
manage
measure
1
2
3
4
5
6

10.3 例：替换掉多余的空格

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         string input = "Hello   World   ";
         string pattern = "\\s+";
         string replacement = " ";
         Regex rgx = new Regex(pattern);
         string result = rgx.Replace(input, replacement);

         Console.WriteLine("Original String: {0}", input);
         Console.WriteLine("Replacement String: {0}", result);    
         Console.ReadKey();
      }
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：

Original String: Hello   World   
Replacement String: Hello World   
1
2