C# 六十二、正则表达式

概念

正则表达式（Regular Expression），使用一种数学算法来解决计算机程序中的文本检索、匹配等问题。

正则表达式语言是一种专门用于字符串处理的语言。

通过正则表达式可以进行检索（从字符串中获取想要的部分）、匹配（判定给定的字符串是否符合正则表达式的过滤逻辑）。

正则表达式表述了一个字符串的书写规则。

正则表达式主要实现验证、提取、分割、替换字符的功能。

在正则表达式字符串前面加上@字符，可以不让编译器解析其中的转义字符，而作为正则表达式的语法（元字符）存在。

（以上来自siki）

组成 

正则表达式就是由普通字符以及特殊字符（元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。 

定位元字符	说明
\b	匹配单词的开始或结束
\B	匹配非单词的开始或结束——反义字符
^	匹配必须出现在字符串的开头或行的开头
$	匹配必须出现在以下位置：字符串结尾、字符串结尾处的\n之前、行的结尾
\A	指定匹配必须出现在字符串的开头（忽略Multiline选项）
\z	指定匹配必须出现在字符串的结尾（忽略Multiline选项）
\Z	指定匹配必须出现在字符串的结尾或字符串结尾处的\n之前（忽略Multiline选项）
\G	指定匹配必须出现在上一个匹配结束的地方，与Match.NextMatch()一起使用时，确保所有匹配都是连续的。基本

基本语法元字符	说明
.	匹配除换行符以外的任意字符
\w	匹配字母、数字、下划线、汉字
\W	\W的补集（\w不包含的）——反义字符
\s	匹配任意空白符（包括换行符/n、回车符/r、制表符/t、垂直制表符/v、换页符/f）
\S	\s的补集（\s不包含的）——反义字符
\d	匹配数字
\D	\d的补集（\d不包含的）——反义字符

字符	说明
[ab]	匹配中括号中的字符
[a-c]	匹配a到c之间的字符
[^x]	匹配除了x以外的任意字符
[^adwz]	匹配除了adwz以外的任意字符

重复描述字符	说明
{n}	匹配前面的字符n次
{n,}	匹配前面的字符n次或多于n次
{n,m}	匹配前面的字符n到m次
?	重复0次或1次
+	重复一次或更多次
*	重复零次或更多次

择一匹配字符	说明
|	将两个匹配条件进行逻辑或（Or）运算

分组	说明
（）	分组，指定子表达式

在正则表达式中，\是转义字符，*是元字符。如果要表达\使用\\  表达.使用\.  表达*使用\*

操作 

public static bool IsMatch(string input, string pattern); 

摘要:指示所指定的正则表达式在指定的输入字符串中是否找到了匹配项。
参数:

• input:要搜索匹配项的字符串。
• pattern: 要匹配的正则表达式模式。

返回结果:true 如果正则表达式找到匹配项，则否则为 false。 

 

public static bool IsMatch(string input, string pattern, RegexOptions options);

摘要:指示所指定的正则表达式是否使用指定的匹配选项在指定的输入字符串中找到了匹配项。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• options:枚举值的一个按位组合，这些枚举值提供匹配选项。
• RegexOptions是一个枚举类型，有以下枚举值：

返回结果:true 如果正则表达式找到匹配项，则否则为 false。 

 

public static bool IsMatch(string input, string pattern, RegexOptions options, TimeSpan matchTimeout); 

摘要:指示所指定的正则表达式是否使用指定的匹配选项和超时间隔在指定的输入字符串中找到了匹配项。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• options:枚举值的一个按位组合，这些枚举值提供匹配选项。
• matchTimeout:超时间隔，或 System.Text.RegularExpressions.Regex.InfiniteMatchTimeout 来指示方法应不会超时。

返回结果:true 如果正则表达式找到匹配项，则否则为 false。 

 

public static Match Match(string input, string pattern, RegexOptions options); 

摘要:使用指定的匹配选项在输入字符串中搜索指定的正则表达式的第一个匹配项。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• options:枚举值的一个按位组合，这些枚举值提供匹配选项。

返回结果:一个包含有关匹配的信息的对象。 

 

public static Match Match(string input, string pattern); 

摘要:在指定的输入字符串中搜索指定的正则表达式的第一个匹配项。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。

返回结果:一个包含有关匹配的信息的对象。 

 

public static Match Match(string input, string pattern, RegexOptions options, TimeSpan matchTimeout);

摘要:使用指定的匹配选项和超时间隔在输入字符串中搜索指定的正则表达式的第一个匹配项。

参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• options:枚举值的一个按位组合，这些枚举值提供匹配选项。
• matchTimeout:超时间隔，或 System.Text.RegularExpressions.Regex.InfiniteMatchTimeout 来指示方法应不会超时。

返回结果:一个包含有关匹配的信息的对象。 

 

public static MatchCollection Matches(string input, string pattern, RegexOptions options, TimeSpan matchTimeout);

摘要:使用指定的匹配选项和超时间隔在指定的输入字符串中搜索指定的正则表达式的所有匹配项。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• options:枚举值的按位组合，这些枚举值指定用于匹配的选项。
• matchTimeout:超时间隔，或 System.Text.RegularExpressions.Regex.InfiniteMatchTimeout 来指示方法应不会超时。

返回结果:一套 System.Text.RegularExpressions.Match 搜索操作找到的对象。 如果未找到匹配项，则此方法将返回一个空集合对象。 

 

public static MatchCollection Matches(string input, string pattern, RegexOptions options); 

摘要:使用指定的匹配选项在指定的输入字符串中搜索指定的正则表达式的所有匹配项。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• options:枚举值的按位组合，这些枚举值指定用于匹配的选项。

返回结果:一套 System.Text.RegularExpressions.Match 搜索操作找到的对象。 如果未找到匹配项，则此方法将返回一个空集合对象。

 

public static MatchCollection Matches(string input, string pattern); 

摘要:在指定的输入字符串中搜索指定的正则表达式的所有匹配项。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。

返回结果:一套 System.Text.RegularExpressions.Match 搜索操作找到的对象。 如果未找到匹配项，则此方法将返回一个空集合对象。

 

public static string Replace(string input, string pattern, MatchEvaluator evaluator, RegexOptions options, TimeSpan matchTimeout);

摘要:在指定的输入字符串中，使用由 System.Text.RegularExpressions.MatchEvaluator 委托返回的字符串替换与指定的正则表达式匹配的所有子字符串。如果未找到匹配项，则其他参数指定修改匹配操作的选项和超时间隔。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• evaluator:一个自定义方法，该方法检查每个匹配项，然后返回原始的匹配字符串或替换字符串。
• options:枚举值的一个按位组合，这些枚举值提供匹配选项。
• matchTimeout:超时间隔；若要指示该方法不应超时，则为 System.Text.RegularExpressions.Regex.InfiniteMatchTimeout。

返回结果:一个与输入字符串基本相同的新字符串，唯一的差别在于，其中的每个匹配字符串已被替换字符串代替。 如果 pattern 与当前实例不匹配，则此方法返回未更改的当前实例。

 

 public static string Replace(string input, string pattern, string replacement, RegexOptions options);

public static string Replace(string input, string pattern, string replacement, RegexOptions options);
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• replacement:替换字符串。
• options:枚举值的一个按位组合，这些枚举值提供匹配选项。

返回结果:一个与输入字符串基本相同的新字符串，唯一的差别在于，其中的每个匹配字符串已被替换字符串代替。 如果 pattern 与当前实例不匹配，则此方法返回未更改的当前实例。

 

public static string Replace(string input, string pattern, string replacement);

摘要:
在指定的输入字符串内，使用指定的替换字符串替换与指定正则表达式匹配的所有字符串。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• replacement:替换字符串。

返回结果:一个与输入字符串基本相同的新字符串，唯一的差别在于，其中的每个匹配字符串已被替换字符串代替。 如果 pattern 与当前实例不匹配，则此方法返回未更改的当前实例。

 

public static string Replace(string input, string pattern, MatchEvaluator evaluator);

摘要:在指定的输入字符串中，使用由 System.Text.RegularExpressions.MatchEvaluator 委托返回的字符串替换与指定的正则表达式匹配的所有字符串。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• evaluator:一个自定义方法，该方法检查每个匹配项，然后返回原始的匹配字符串或替换字符串。

返回结果:一个与输入字符串基本相同的新字符串，唯一的差别在于，其中的每个匹配字符串已被一个替换字符串代替。 如果 pattern 与当前实例不匹配，则此方法返回未更改的当前实例。

 

public static string Replace(string input, string pattern, MatchEvaluator evaluator, RegexOptions options);

 摘要:在指定的输入字符串中，使用由 System.Text.RegularExpressions.MatchEvaluator 委托返回的字符串替换与指定的正则表达式匹配的所有字符串。指定的选项将修改匹配操作。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• evaluator:一个自定义方法，该方法检查每个匹配项，然后返回原始的匹配字符串或替换字符串。
• options:枚举值的一个按位组合，这些枚举值提供匹配选项。

返回结果:一个与输入字符串基本相同的新字符串，唯一的差别在于，其中的每个匹配字符串已被一个替换字符串代替。 如果 pattern 与当前实例不匹配，则此方法返回未更改的当前实例。

 

public static string Replace(string input, string pattern, string replacement, RegexOptions options, TimeSpan matchTimeout);

摘要:在指定的输入字符串内，使用指定的替换字符串替换与指定正则表达式匹配的所有字符串。 如果未找到匹配项，则其他参数指定修改匹配操作的选项和超时间隔。
参数:

• input:要搜索匹配项的字符串。
• pattern:要匹配的正则表达式模式。
• replacement:替换字符串。
• options:枚举值的一个按位组合，这些枚举值提供匹配选项。
• matchTimeout:超时间隔；若要指示该方法不应超时，则为 System.Text.RegularExpressions.Regex.InfiniteMatchTimeout。

返回结果:一个与输入字符串基本相同的新字符串，唯一的差别在于，其中的每个匹配字符串已被替换字符串代替。 如果 pattern 与当前实例不匹配，则此方法返回未更改的当前实例。

public static string[] Split(string input, string pattern, RegexOptions options, TimeSpan matchTimeout);

摘要:在由指定正则表达式模式定义的位置将输入字符串拆分为一个子字符串数组。 如果未找到匹配项，则其他参数指定修改匹配操作的选项和超时间隔。
参数:

• input:要拆分的字符串。
• pattern:要匹配的正则表达式模式。
• options:枚举值的一个按位组合，这些枚举值提供匹配选项。
• matchTimeout:超时间隔，或 System.Text.RegularExpressions.Regex.InfiniteMatchTimeout 来指示方法应不会超时。

返回结果:字符串数组。

public static string[] Split(string input, string pattern, RegexOptions options);

摘要:在由指定正则表达式模式定义的位置将输入字符串拆分为一个子字符串数组。 指定的选项将修改匹配操作。
参数:
input:要拆分的字符串。
pattern:要匹配的正则表达式模式。
options:枚举值的一个按位组合，这些枚举值提供匹配选项。
返回结果:字符串数组。

public static string[] Split(string input, string pattern);

摘要:在由正则表达式模式定义的位置将输入字符串拆分为一个子字符串数组。
参数:
input:要拆分的字符串。
pattern:要匹配的正则表达式模式。
返回结果:字符串数组。

 

示例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace TestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "World";

            string st = Regex.Replace(s,"^","Hello");

            Console.WriteLine(st);

            Console.ReadKey();
        }
    }
}

--->
HelloWorld

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace TestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "World";

            string st = Regex.Replace(s,"$","Hello");

            Console.WriteLine(st);

            Console.ReadKey();
        }
    }
}

--->
WorldHello

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace TestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入号码（只能是数字）：");
            string s = Console.ReadLine();
            string pattern = @"^\d*$";//正则表达式
            bool b= Regex.IsMatch(s, pattern);
            Console.WriteLine(b);
            Console.ReadKey();
        }
    }
}

--->
请输入号码（只能是数字）：
520
True

--->
请输入号码（只能是数字）：
888aaa
False

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace TestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            string s1 = "aaa 111 bbb ccc";
            string s2 = Regex.Replace(s1,@"[^ab]","*");
            Console.WriteLine(s2);

            Console.ReadKey();
        }
    }
}

--->
aaa*****bbb****

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace TestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 3; i++)
            {
                string s1 = Console.ReadLine();
                string pattern = @"^\d{5,15}$";
                Console.WriteLine(Regex.IsMatch(s1, pattern));
            }

            Console.ReadKey();
        }
    }
}

--->
a1516461464
False
515684154
True
15684184643584468431854
False

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace TestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 3; i++)
            {
                string s = Console.ReadLine();
                string pattern = @"\d|[a-z]";
                MatchCollection matchCollection = Regex.Matches(s,pattern);
                foreach (Match item in matchCollection)
                {
                    Console.WriteLine(item.ToString());
                }
            }

            Console.ReadKey();
        }
    }
}

--->
asd123
a
s
d
1
2
3
aaa啵啵啵
a
a
a
11111啊啊啊
1
1
1
1
1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace TestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "aaa;bbb,ccc:ddd";
            string pattern = @"[;,:]";
            string[]arr = Regex.Split(s,pattern);
            foreach (var item in arr)
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();
        }
    }
}

--->
aaa
bbb
ccc
ddd

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace TestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "aaa;bbb,ccc:ddd";
            //string pattern = @"[;,:]";
            string pattern = @"[;]|[,]|[:]";
            string[]arr = Regex.Split(s,pattern);
            foreach (var item in arr)
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();
        }
    }
}

--->
aaa
bbb
ccc
ddd