【C#进阶二】C#中的正则表达式知识总结（字符转义/字符类/ 定位点/ 分组构造 /数量词/反向引用构造/替换构造/替代/正则表达式选项）（理论篇）

智能建造小硕

已于 2023-03-30 23:09:37 修改

阅读量1.2k

点赞数 1

分类专栏： C#进阶笔记文章标签：正则表达式 c# 开发语言

于 2022-08-16 21:14:04 首次发布

本文链接：https://blog.csdn.net/QH2107/article/details/126374466

版权

C#进阶笔记专栏收录该内容

15 篇文章 20 订阅

订阅专栏

在这里插入图片描述

文章目录

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。C# 中正则表达式提供了功能强大、灵活而又高效的方法来处理文本。

使用场景

查找特定字符模式。
验证文本以确保它匹配预定义模式（如电子邮件地址）。
提取、编辑、替换或删除文本字符串。
将提取的字符串添加到集合中，以便进一步使用。

例如：查找重复的单词

public static void Main()
   {
      string pattern = @"\b(\w+?)\s\1\b";
      string input = "This this is a nice day. What about this? This tastes good. I saw a a dog.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("{0} (重复 '{1}') 在索引 {2}处",
                           match.Value, match.Groups[1].Value, match.Index);
   }

结果：

This this (重复 'This') 在索引 0处
a a (重复 'a') 在索引 66处

0. 正则表达式网站推荐

这里介绍一个正则表达式的网站（方便边写正则表达式边查看正则表达式结果，适合新手）：

https://regex101.com/
https://tool.oschina.net/regex/
第一个网站的页面

具体使用教程可以看我的另一篇博客：【正则表达式】regex101超好用的正则表达式正则表达式测试和学习工具（内含使用教程、Python和C#正则表达式代码示例）

1.字符转义

正则表达式中的反斜杠字符 () 指示其后跟的字符是特殊字符

字符或序列	说明
除以下字符外的所有字符： . $ ^ { [ ( \| ) * + ? \	“字符或序列”列中未包含的字符在正则表达式中没有特殊含义；此类字符与自身匹配。 “字符或序列”列中包括的字符均为特殊的正则表达式语言元素。例如，正则表达式 `\$\d+` 或 `[$]\d+` 匹配“$1200”。
`\a`	匹配响铃（警报）字符，`\u0007`。
`\b`	在 `[`character_group`]` 字符类中，匹配退格，`\u0008`。
`\t`	匹配制表符，`\u0009`。
`\r`	匹配回车，`\u000D`。`\r` 不等同于换行符\n`。
`\v`	匹配垂直制表符，`\u000B`。
`\f`	匹配换页，`\u000C`。
`\n`	匹配换行，`\u000A`。
`\e`	匹配转义，`\u001B`。
`\` nnn	匹配 ASCII 字符，其中 nnn 包含表示八进制字符代码的两位数或三位数。例如，`\040` 表示空格字符。如果此构造仅包含一个数字（如 `\2`）或者它对应捕获组的编号，则将它解释为向后引用。
`\x` nn	匹配 ASCII 字符，其中 nn 是两位数的十六进制字符代码。
`\c` X	匹配 ASCII 控制字符，其中 X 是控制字符的字母。例如，`\cC` 为 CTRL-C。
`\u` nnnn	匹配的 UTF-16 代码单元，单元值是 nnnn 十六进制。注意：.NET 不支持用于指定 Unicode 的 Perl 5 字符转义。 Perl 5 字符转义采用以下格式 `\x{`####`…}`，其中 ####`…` 是一系列十六进制数字。改用 `\u`nnnn。
`\`	后接字符未识别为转义字符时，将匹配此字符。例如，`\` 匹配星号 () 并等同于 `\x2A`。

代码示例：

制表符 (\t) 或垂直条（| 或 \u007c）将每个城市名与其人口数量分开，使用回车符和换行符分隔各个城市及其人口。

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string regex = @"\G(.+)[\t\u007c](.+)\r?\n";  //正则表达式
        string input = "Mumbai, India|13,922,125\t\n" +
                              "Shanghai, China\t13,831,900\n" +
                              "Karachi, Pakistan|12,991,000\n" +
                              "Delhi, India\t12,259,230\n" +
                              "Istanbul, Turkey|11,372,613\n";
        Console.WriteLine(input);
        Console.WriteLine("正则化后");
        Console.WriteLine("{0,-20} {1,10}", "City", "Population");
        //-20 使用 - 用于左对齐内容，例如：{0，-5},20表示间距
        //打印时还可使用： $“{插值，n：f}”，其中 n 是可选对齐方式（如上所述），f 是可选格式字符串
        foreach (Match match in Regex.Matches(input, regex))
            Console.WriteLine("{0,-20} {1,10}", match.Groups[1].Value, 
                                               match.Groups[2].Value); 
    }
}

字符串@"\G(.+)[\t\u007c](.+)\r?\n"解释：

模式	说明
`\G`	从上次匹配结束处开始匹配。
`(.+)`	一次或多次匹配任何字符。这是第一个捕获组。
`[\t\u007c]`	匹配制表符 (`\t`) 或垂直条 (\|)。
`(.+)`	一次或多次匹配任何字符。这是第二个捕获组。
`\r?\n`	匹配零或一个出现回车符后接新行的次数。

//结果
Mumbai, India|13,922,125
Shanghai, China 13,831,900
Karachi, Pakistan|12,991,000
Delhi, India    12,259,230
Istanbul, Turkey|11,372,613

正则化后
City                 Population
Mumbai, India        13,922,125
Shanghai, China      13,831,900
Karachi, Pakistan    12,991,000
Delhi, India         12,259,230
Istanbul, Turkey     11,372,613

2.字符类

字符类与一组字符中的任何一个字符匹配。.NET 正则表达式中的字符类 | Microsoft Docs

注：以下部分的描述列的例子部分，冒号前的一部分表示正则表达式。如：[ae]， “lane” 中的 “a” 和 “e”。[ae]即为正则表达式，后面的是输入字符串及匹配结果。

字符类	描述
`[` character_group`]`	匹配`[` character_group`]`，默认情况下，匹配区分大小写。例如：`[ae]`， `"lane"` 中的 `"a"` 和 `"e"`
`[^` character_group`]`	求反：不匹配`[` character_group`]`。默认情况下， character_group 中的字符区分大小写。例如：`[^aei]`，`"reign"` 中的 `"r"`、`"g"` 和 `"n"`
`[` first`-`last`]`	字符范围：与从第一个至最后一个的范围内的任何单个字符匹配。例如：`[A-Z]`，`"AB123"` 中的 `"A"` 和 `"B"`
`.`	通配符：与除 `\n` 之外的任何单个字符匹配（若要匹配文本句点字符，必须在该字符前面加上转义符 (`\.`)。例如：`a.e`，`"water"` 中的 `"ate"`
`\p{` name`}``	与 name 指定的 Unicode 通用类别或命名块中的任何单个字符匹配。例如：`\p{Lu}` `\p{IsCyrillic}`，`"City Lights"` 中的 `"C"` 和 `"L"`
`\P{` name`}`	与不在 name 指定的 Unicode 通用类别或命名块中的任何单个字符匹配。例如：`\P{Lu}` `\P{IsCyrillic}`，`"City"` 中的 `"i"`、`"t"` 和 `"y"`
`\w`	与任何单词字符匹配。例如：`\w`，`"ID A1.3"` 中的 `"I"`、`"D"`、`"A"`、`"1"` 和 `"3"`
`\W`	与任何非单词字符匹配。例如：`\W`，`"ID A1.3"` 中的 `" "` 和 `"."`
`\s`	与任何空白字符匹配。例如：`"ID A1.3"` 中的 `"D "`，例如：`\w\s`，`"ID A1.3"` 中的 `"D "`
`\S`	与任何非空白字符匹配。例如：`\s\S`，`"int __ctr"` 中的 `" _"`
`\d`	与任何十进制数字匹配。例如：`\d`，`"4 = IV"` 中的 `"4"`
`\D`	与任何不是十进制数的字符匹配。例如：`\D`，`"4 = IV"` 中的 `" "`、`"="`、`" "`、`"I"` 和 `"V"`

代码示例：

public static void Main()
    {
        string regex1 = @"^\D\d{1,5}\D*$"; //正则表达式
        string[] inputs1 = { "A1039C", "AA0001", "C18A", "Y938518" };

        foreach (string input in inputs1)
        {
            if (Regex.IsMatch(input, regex1))
                Console.WriteLine(input + ": 匹配成功");
            else
                Console.WriteLine(input + ": 匹配失败");
        }
  		Console.WriteLine()
        //新建一个数组
        string[] inputs2 = { "123", "13579753", "3557798", "335599901" };
        string regex2 = @"^[0-9-[2468]]+$"; //正则表达式
        
        foreach (string input in inputs2)
        {
            Match match = Regex.Match(input, regex2); 
            if (match.Success) //判断是否匹配
                Console.WriteLine(match.Value);
        }
    }

正则表达式 ^[0-9-[2468]]+$解释

元素	说明
`^`	从输入字符串的开头部分开始匹配。
`\D`	匹配非数字字符。
`\d{1,5}`	匹配一到五个十进制数字。
`\D*`	匹配零个、一个或多个非十进制字符。
`[0-9-[2468]]+`	匹配任意字符（从 0 到 9，除了 2、4、6 和 8 之外）的一个或多个匹配项。换句话说，匹配零或奇数的一个或多个匹配项。
$	在输入字符串末尾结束匹配。

//结果
A1039C: 匹配成功
AA0001: 匹配失败
C18A: 匹配成功
Y938518: 匹配失败

13579753
335599901

3. 定位点

定位点或原子零宽度断言会使匹配成功或失败，具体取决于字符串中的当前位置，但它们不会使引擎在字符串中前进或使用字符。

断言	说明
`^`	默认情况下，必须从字符串的开头开始匹配；在多行模式中，必须从该行的开头开始。例如：`^\d{3}`，`"901-333-"` 中的 `"901"`。
`$`	默认情况下，匹配必须出现在字符串的末尾，或在字符串末尾的 `\n` 之前；在多行模式中，必须出现在该行的末尾之前，或在该行末尾的 `\n` 之前。例如：`-\d{3}$`，`"-901-333"` 中的 `"-333"`
`\A`	匹配必须出现在字符串的开头。例如：`\A\d{3}`，`"901-333-"` 中的 `"901"`
`\Z`	匹配必须出现在字符串的末尾或出现在字符串末尾的 `\n` 之前。例如：`-\d{3}\Z`，`"-901-333"` 中的 `"-333"`
`\z`	匹配必须出现在字符串的末尾。例如：`-\d{3}\z`，`"-901-333"` 中的 `"-333"`
`\G`	匹配必须在上一个匹配结束的位置进行；如果以前没有匹配项，则从开始进行匹配的字符串中的位置开始。例如：`\G$\d$`，`"(1)(3)(5)[7](9)"` 中的 `"(1)"`、`"(3)"` 和 `"(5)"`
`\b`	匹配必须出现在 `\w` （字母数字）和 `\W` （非字母数字）字符之间的边界上。例如：`\b\w+\s\w+\b`，`"them theme them them"` 中的 `"them theme"` 和 `"them them"`
`\B`	匹配不得出现在 `\b` 边界上。例如：`\Bend\w*\b`，`"end sends endure lender"` 中的 `"ends"` 和 `"ender"`

代码示例：

 public static void Main()
    {
        string input1 = "equity queen equip acquaint quiet";
       
        string regex1 = @"\bqu\w+";
        string regex2 = @"\Bqu\w+";

        foreach (Match match in Regex.Matches(input1, regex1))
            Console.WriteLine("'{0}' 在索引 {1}处",
                              match.Value, match.Index);
        Console.WriteLine();
        foreach (Match match in Regex.Matches(input1, regex2))
            Console.WriteLine("'{0}' 在索引 {1}处",
                              match.Value, match.Index);
    }

正则表达式解释:

模式	描述
`\b`	在单词边界处开始匹配。
`are`	匹配子字符串“are”。
`\w*`	匹配零个或多个单词字符。
`\b`	在单词边界处结束匹配。
`\B`	不在单词边界处开始匹配。

//结果
'queen' 在索引 7处
'quiet' 在索引 28处

'quity' 在索引 1处
'quip' 在索引 14处
'quaint' 在索引 21处

4. 分组构造

分组构造描述了正则表达式的子表达式，通常用于捕获输入字符串的子字符串。

分组构造	描述
`(` subexpression`)`	捕获匹配的子表达式并将其分配到一个从 1 开始的序号中。例如：`(\w)\1`
`(?<` name`>`subexpression`)` 或 `(?'` name`'`subexpression`)`	将匹配的子表达式捕获到一个命名组中。例如：`(?<double>\w)\k<double>`
`(?<` name1`-`name2`>`subexpression`)` 或 `(?'` name1`-`name2`'`subexpression`)`	定义平衡组定义。例如：`(((?'Open'$)[^\($])+((?'Close-Open'\))[^])+)(?(Open)(?!))$`，`"3+2^((1-3)(3-1))"` 中的 `"((1-3)*(3-1))"`
`(?:` subexpression`)`	定义非捕获组，不将匹配的文本分配给捕获的组。例如：`Write(?:Line)?`，`"Console.Write(value)"` 中的 `"Write"`
`(?imnsx-imnsx:` subexpression`)`	应用或禁用子表达式中指定的选项，正则表达式的选项 Microsoft Docs。例如：`A\d{2}(?i:\w+)\b`，`"A12xl A12XL a12xl"` 中的 `"A12xl"` 和 `"A12XL"`
`(?=` subexpression`)`	零宽度正预测先行断言，输入字符串必须匹配子表达式中的正则表达式模式，尽管匹配的子字符串未包含在匹配结果中。零宽度正预测先行断言不会回溯。例如：`\b\w+\b(?=.+and.+)`，`"cats, dogs and some mice."`中的`"cats"`, `"dogs"` 。（`(?=\sis\b)`确定单词字符是否后接空白字符和字符串“is”，其在单词边界处结束）
`(?!` subexpression`)`	零宽度负预测先行断言。输入字符串不得匹配子表达式中的正则表达式模式。例如：`\b\w+\b(?!.+and.+)`，`"and"`, `"some"`, `"mice"` in `"cats, dogs and some mice."`
`(?<=` subexpression`)`	零宽度正回顾后发断言，子表达式不得在输入字符串当前位置的左侧出现。例如：`\b\w+\b(?<=.+and.+)` ，`"some"`, `"mice"` in `"cats, dogs and some mice."`
`(?<!` subexpression`)`	零宽度负回顾后发断言，子表达式不得在输入字符串当前位置的左侧出现。但是，任何不匹配 `subexpression` 的子字符串不包含在匹配结果中。。例如：`\b\w+\b(?<!.+and.+)` ，`"cats"`, `"dogs"`, `"and"` in `"cats, dogs and some mice."`
`(?>` subexpression`)`	原子组。例如：`(?>a

代码示例一：

 public static void Main()
    {
        string pattern = @"(?:\b(?:\w+)\W*)+\."; //(?:\w+),非捕获组，不包含在
        string input = "This is a short sentence.";
        Match match = Regex.Match(input, pattern);
        Console.WriteLine("Match: {0}", match.Value);
        if (match.Groups.Count>1)
        {
            for (int ctr = 1; ctr < match.Groups.Count; ctr++)
                Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
        }
        else
        {
            Console.WriteLine("捕获组数量不超过1");
        }
    }

//结果
Match: This is a short sentence.
捕获组数量不超过1

代码示例二：

 public static void Main()
    {
        string pattern = @"\b\w+(?=\sis\b)"; //零宽度正预测先行断言:(?=\sis\b) 确定单词字符是否后接空白字符和字符串“is”，其在单词边界处结束
        string[] inputs = { "The dog is a Malamute.",
                          "The island has beautiful birds.",
                          "The pitch missed home plate.",
                          "Sunday is a weekend day." };

        foreach (string input in inputs)
        {
            Match match = Regex.Match(input, pattern);
            if (match.Success)
                Console.WriteLine("'{0}' precedes 'is'.", match.Value);
            else
                Console.WriteLine("'{0}' does not match the pattern.", input);
        }
    }

//结果
'dog' precedes 'is'.
'The island has beautiful birds.' does not match the pattern.
'The pitch missed home plate.' does not match the pattern.
'Sunday' precedes 'is'.

分组构造和正则表达式对象

集合中的第一个 Group 对象（位于索引零的对象）表示整个匹配

下一组 Group对象表示未命名（编号）的捕获组。它们以在正则表达式中定义的顺序出现，从左至右。这些组的索引值范围从 1 到集合中未命名捕获组的数目。（特定组的索引相当于其编号的向后引用。有关向后引用的详细信息。）

最后的 Group对象组表示命名的捕获组。它们以在正则表达式中定义的顺序出现，从左至右。第一个名为捕获组的索引值是一个大于最后一个未命名的捕获组的索引。如果正则表达式中没有未命名捕获组，则第一个命名的捕获组的索引值为 1。

5.数量词

限定符指定在输入字符串中必须存在上一个元素（可以是字符、组或字符类）的多少个实例才能出现匹配项。后面加了问号的是惰性限定符，没加的是贪婪限定符（正则表达式引擎匹配尽可能多的特定模式实例）。

限定符	描述
`*`	匹配上一个元素零次或多次，相当于{0，}。例如：`a.*c`，`"abcbc"` 中的 `"abcbc"`
`+`	匹配上一个元素一次或多次，相当于{1，}。例如：`"be+"`，`"been"` 中的 `"bee"`、`"bent"` 中的 `"be"`
`?`	匹配上一个元素零次或一次相当于{0，1}。例如：`"rai?"`，`"rain"` 中的 `"rai"`
`{`n`}`	匹配上一个元素恰好 n 次。例如：`",\d{3}"`，`"9,876,543,210"` 中的 `",876"`、`",543"` 和 `",210"`
`{`n`,}`	匹配上一个元素至少 n 次。例如：`"\d{2,}"`，`"166"`, `"29"`, `"1930"`。例如：`"\d{2,}"`，`"166"`, `"29"`, `"1930"`
`{` n`,`m`}`	匹配上一个元素至少 n 次，但不多于 m 次。例如：`"\d{3,5}"`，`"166"`, `"17668"` `"193024"` 中的 `"19302"`
`*?`	匹配上一个元素零次或多次，但次数尽可能少。例如：`a.*?c`，`"abcbc"` 中的 `"abc"`
`+?`	匹配上一个元素一次或多次，但次数尽可能少。例如：`"be+?"`，`"bent"` 中的 `"be"`
`??`	匹配上一个元素零次或一次，但次数尽可能少。例如：`"rai??"`，`"rain"` 中的 `"ra"`
`{`n`}?`	匹配前面的元素恰好 n 次。例如：`",\d{3}?"`，`"9,876,543,210"` 中的 `",876"`、`",543"` 和 `",210"`
`{`n`,}?`	匹配上一个元素至少 n 次，但次数尽可能少。例如：`"\d{2,}?"`，`"166"`, `"29"`, `"1930"`
`{` n`,`m`}?`	匹配上一个元素的次数介于 n 和 m 之间，但次数尽可能少。例如：`"\d{3,5}?"`，`"166"`, `"17668"` `"193024"` 中的 `"193"` 和 `"024"`

代码示例：

public static void Main()
    {
        string regex1 = @"\b9{1,2}1?9*\b";
        string regex2 = @"\b9*1{3,}?9+\b";
        string input = "99 95 919 929 9119 9219 999 9919 91119 9911119 991111";
        foreach (Match match in Regex.Matches(input, regex1))
            Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
        Console.WriteLine();
        foreach (Match match in Regex.Matches(input, regex2))
            Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
    }

'99' found at position 0.
'919' found at position 6.
'999' found at position 24.
'9919' found at position 28.

'91119' found at position 33.
'9911119' found at position 39.

限定符和空匹配项

规则会在最大可能组捕获数是无限或接近无限时，阻止限定符在空的子表达式匹配项上进入无限循环。

模式	描述
`(a\1`	匹配“a”以及第一个捕获组的值…
`	(?(1)`
`\1))`	如果第一个捕获组存在，则匹配其值。如果组不存在，组会匹配 String.Empty。

 public static void Main()
    {
        string reagex, input;

     //‘\1’ 匹配的是 所获取的第1个()匹配的引用。例如，’(\d)\1’ 匹配两个连续数字字符。
     //如33aa 中的33‘\2’ 匹配的是 所获取的第2个()匹配的引用。
        reagex = @"(a\1|(?(1)\1)){0,2}";  //空匹配导致量符停止重复运行
        input = "aaabbb";

        Console.WriteLine($"正则表达式：{reagex}");
        Match match = Regex.Match(input, reagex);
        Console.WriteLine("匹配: '{0}'在索引 {1}处.",
                          match.Value, match.Index);
        if (match.Groups.Count > 1)
        {
            for (int groupCtr = 1; groupCtr <= match.Groups.Count - 1; groupCtr++)
            {
                Group group = match.Groups[groupCtr];
                Console.WriteLine("   Group: {0}: '{1}'在索引{2}处.",
                                  groupCtr, group.Value, group.Index);
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    captureCtr++;
                    Console.WriteLine("      Capture: {0}: '{1}' 在索引 {2}处.",
                                      captureCtr, capture.Value, capture.Index);
                }
            }
        }
        Console.WriteLine();

        reagex = @"(a\1|(?(1)\1)){2}";
        Console.WriteLine($"正则表达式：{reagex}");
        match = Regex.Match(input, reagex);
        Console.WriteLine("Matched '{0}' 在索引 {1}处.",
                          match.Value, match.Index);
        if (match.Groups.Count > 1)
        {
            for (int groupCtr = 1; groupCtr <= match.Groups.Count - 1; groupCtr++)
            {
                Group group = match.Groups[groupCtr];
                Console.WriteLine("   Group: {0}: '{1}' 在索引 {2}处.",
                                  groupCtr, group.Value, group.Index);
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    captureCtr++;
                    Console.WriteLine("      Capture: {0}: '{1}' 在索引 {2}处.",
                                      captureCtr, capture.Value, capture.Index);
                }
            }
        }
    }

//结果
正则表达式(a\1|(?(1)\1)){0,2}
匹配: ''在索引 0处.  //String.Empty导致匹配停止
   Group: 1: ''在索引0处.
      Capture: 1: '' 在索引 0处.

正则表达式(a\1|(?(1)\1)){2} //必须要有两次匹配
Matched 'a' 在索引 0处.
   Group: 1: 'a' 在索引 0处.
      Capture: 1: '' 在索引 0处.
      Capture: 2: 'a' 在索引 0处.

拓展知识：

’(\d)(a)\1’ 匹配第一是数字第二是字符a,第三\1必须匹配第一个一样的数字重复一次，也就是被引用一次。如9a9 被匹配，但9a8不会被匹配，因为第三位的\1必须是9才可以。

‘(\d)(a)\2’ 匹配第一个是一个数字，第二个是a，第三个\2必须是第二组（）中匹配一样的，如，8aa被匹配，但8ab，7a7不会被匹配，第三位必须是第二组字符的复制版，也是就引用第二组正则的匹配内容。

6.反向引用构造

反向引用允许在同一正则表达式中随后标识以前匹配的子表达式。

反向引用构造	描述
`\` number`\`	后向引用。匹配编号子表达式的值。例如：`(\w)\1`
`\k<` name`>\k<`	命名后向引用。匹配命名表达式的值。例如：`(?<char>\w)\k<char>`

代码示例1：

public static void Main()
    {
        string pattern1 = @"(\w)\1";
        string pattern2 = @"(?<char>\w)\k<char>";
        string input = "trellis llama webbing dresser swagger";
        foreach (Match match in Regex.Matches(input, pattern1))
            Console.WriteLine("Found '{0}' at position {1}.",
                              match.Value, match.Index);
        Console.WriteLine();
        foreach (Match match in Regex.Matches(input, pattern2))
            Console.WriteLine("Found '{0}' at position {1}.",
                              match.Value, match.Index);
    }

//结果
Found 'll' at position 3.
Found 'll' at position 8.
Found 'bb' at position 16.
Found 'ss' at position 25.
Found 'gg' at position 33.

Found 'll' at position 3.
Found 'll' at position 8.
Found 'bb' at position 16.
Found 'ss' at position 25.
Found 'gg' at position 33.

7.替换构造

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

替换构造	描述
`	`
`(?(` expression`)`yes`	`no`)`或`(?( `expression`)`yes`)`
`(?(` name`)`yes`	`no`)`或`(?( `name`)`yes`)`

 public static void Main()
    {
        //捕获组未命名
        string pattern1 = @"\b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b";
        //捕获组命名
        string pattern2 = @"\b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b";
        string input = "01-9999999 020-333333 777-88-9999";
        Console.WriteLine("Matches for {0}:", pattern1);
        Console.WriteLine("Matches for {0}:", pattern2);
        foreach (Match match in Regex.Matches(input, pattern1))
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
        foreach (Match match in Regex.Matches(input, pattern1))
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
    }

//结果
Matches for \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b:
Matches for \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b:
   01-9999999 at position 0
   777-88-9999 at position 22
   01-9999999 at position 0
   777-88-9999 at position 22

8.替代

替换是替换模式中支持的正则表达式语言元素。

字符	说明	模式	替换模式	输入字符串	结果字符串
`$` number`$`	替换按组 number匹配的子字符串。	`\b(\w+)(\s)(\w+)\b`	`$3$2$1`	`"one two"`	`"two one"`
`${` name`}`${	替换按命名组 name匹配的子字符串。	`\b(?<word1>\w+)(\s)(?<word2>\w+)\b`	`${word2} ${word1}`	`"one two"`	`"two one"`
`$$`	替换字符"$"。	`\b(\d+)\s?USD`	`$$$1`	`"103 USD"`	`"$103"`
`$&`	替换整个匹配项的一个副本。	`\$?\d*\.?\d+`	`$&`	`"$1.30"`	`"$1.30"`
$`	替换匹配前的输入字符串的所有文本。	`B+`	$`	`"AABBCC"`	`"AAAACC"`
`$'`	替换匹配后的输入字符串的所有文本。	`B+`	`$'`	`"AABBCC"`	`"AACCCC"`
`$+`	替换最后捕获的组。	`B+(C+)`	`$+`	`"AABBCCDD"`	`"AACCDD"`
`$_`	替换整个输入字符串。	`B+`	`$_`	`"AABBCC"`	`"AAAABBCCCC"`

9.正则表达式选项

可以指定控制正则表达式引擎如何解释正则表达式模式的选项。

选项	说明
`i`	使用不区分大小写的匹配。例如：`\b(?i)a(?-i)a\w+\b`，`"aardvark AAAuto aaaAuto Adam breakfast"` 中的 `"aardvark"` 和 `"aaaAuto"`
`m`	使用多行模式。 `^` 和 `$` 匹配行的开头和结尾，但不匹配字符串的开头和结尾。
`n`	不捕获未命名的组。
`s`	使用单行模式。
`x`	忽略正则表达式模式中的非转义空白。例如：`\b(?x) \d+ \s \w+`，`"1 aardvark 2 cats IV centurions"` 中的 `"1 aardvark"` 和 `"2 cats"`

代码示例：

 public static void Main()
    {
        string pattern = @"\bthe\w*\b";
        string input = "The man then told them about that event.";
        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

        Console.WriteLine();
        foreach (Match match in Regex.Matches(input, pattern,
                                              RegexOptions.IgnoreCase)) // RegexOptions.IgnoreCase方法不区分大小写
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
    }

//结果
Found then at index 8.
Found them at index 18.

Found The at index 0.
Found then at index 8.
Found them at index 18.

以上九个部分就是C#正则表达式的基本规则，后面会有实践部分。

了解更多请查看官方文档.NET 正则表达式 | Microsoft Docs。

C#正则表达式实践篇已更新，可以继续学习了！
【C#进阶三】C#正则表达式的使用及常用案例（Regex.IsMatch、Regex.Match，match.NextMatch、Regex.Matches、Regex.Replace等）（实践篇)

参考：.NET 正则表达式 | Microsoft Docs
欢迎关注个人公众号【智能建造小硕】（分享计算机编程、人工智能、智能建造、日常学习和科研经验等，欢迎大家关注交流。）

智能建造小硕

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录