正则表达式_字符匹配/可选字符集

正则表达式(Regular Expression)也叫匹配模式(Pattern),用来检验字符串是否满足特 定规则,或从字符串中捕获满足特定规则的子串。

字符匹配

最简单的正则表达式由"普通字符"和"通配符"组成。比如"Room\d\d\d"就这样 的正则表达式。 这些位置是普通字符 R o o m \d \d \d 20 这 3 个位置各匹配一个数字 其中"Room"是普通字符,而"\d"是通配符,表示该位置上有一个数字。该表达式 共占用了 7 个位置,第一个位置上是字母"R",第二个位置和第三个位置上都是字母"o", 第四个位置上是字母"m",而第五到第七个位置上是三个数字。所以正则表达式 "Room\d\d\d"代表着"以Room开头,以三个数字结尾"的那一类字符串。比如字符串 "Room101"、"Room415"、"Room888"等都与"Room\d\d\d"匹配① 。

用于正则表达式的通配符如下 所示,每个通配符都代表一类字符

.NET 提供了一批与正则表达式相关的类,它们都位于 System.Text.RegularExpressions 命名空间,现在我们来学习最主要的 Regex 类,并用它来匹配正则表达式。 Regex 类的部分方法如表 20-2 所示

现在假设某份文件里包含着 Kitty 的房间号码(格式为 RoomXXX),档案很长,人 工查阅很耗时间,那么如何通过计算机帮我们找到房间号码呢?

cs 复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
//注意在文件头引用命名空间 System.Text.RegularExpressions。

namespace Pattern202405
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string text = "The Colony is a beautiful town...Kitty lives in Room415...";
            //正则表达式
            Regex expression = new Regex(@"Room\d\d\d");
            //找出所有匹配的字符串,放入集合中
            MatchCollection matches = expression.Matches(text);
            //输出匹配的字符串
            foreach (Match match in matches)
            {
                Console.WriteLine("She lives in {0}", match);
                Console.ReadKey();
            }

        }
    }
}

可选字符集

除了通配符外,我们还可以把某个位置上允许出现的字符写在方括号[]内,组成可选字符集,比如

[abc]表示该位置可以出现字母 a、b、c

[A-D]表示该位置可以出现字母 A、B、C、D

[A-DM-P]表示该位置可以出现字母 A 到 D 或 M 到 P

[A-Da-d]表示该位置可以出现字母 A 到 D 或 a 到 d

[12] 表示该位置可以出现数字 1 或数字 2

[1-5]表示该位置可以出现数字 1 到 5

[0-57-9]表示该位置可以出现除 6 外的所有数字

[\s\S]表示该位置可以出现任何字符,包括任何可见字符和不可见字符(如空格、制表符、换行等)

如果想从字符串中找出名字以 V 或 R 开头,出生于 80~90 年代的男孩,可以用下面

的正则表达式:

[VR] [a-z] [a-z] [a-z] [a-z] - 1 9 [89] [0-9]

它匹配的字符串包含 10 个字符,第 1 个字符为"V 或 R",第 2~5 个字符为"a 到 z 的某个小写字母",第 6~8 个字符为"-19",第 9 个字符为"数字 8 或 9",第 10 个字 符为"0 到 9 之间的某个数字"。 注意,不管中括号看起来有多长,它都只代表一个字符。表达式中的[VR]、[a-z]、[89]、 [0-9]都是一个字符,不能看作多个字符。

cs 复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Pattern202405_2
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string boys = "Vitor-1979 Verne-1982 Regan-1998 Robin-2008";
            //string text = "Vitor-1970 Verne-1982 Regan-1998 Robin2008";
            //正则表达式
            Regex expression = new Regex(@"[VR][a-z][a-z][a-z][a-z]-19[89][0-9]");
            //获取并输出匹配的字符串
            foreach (Match match in expression.Matches(boys))
            {
                Console.WriteLine(match);
               
            }
            Console.ReadKey();
        }
    }
}

启动程序:

反向字符集

在中括号表达式中用符号"^"表示"非"。比如

[^x] 匹配除 x 以外的所有字符

[^abc] 匹配除 a、b、c 以外的所有字符

[^0-9] 匹配除 0 到 9 以外的所有字符

[^#] 匹配除#以外的所有字符

[^\n] 匹配除换行符\n 以外的所有字符

string sentence = "bog dog fog hog log";
//正则表达式
Regex expression = new Regex(@"[^bd]og");
//输出匹配的字符串
foreach (Match match in expression.Matches(sentence ))
{
Console.WriteLine(match);
}

正则表达式"[^bd]og"匹配的字符串包含三个字符,第一个字符 是除 b 和 d 以外的字符,后两个字符为 og

或匹配

在正则表达式中用符号"|"表示"或"。比如

"x|y" 匹配 "x"或"y"

"good|ok" 匹配 "good"或"ok"

"(tr|b)ee" 匹配 "tree"或"bee"

"th(i|a)nk" 匹配 "think"或"thank"

"Book One|Two" 匹配 "Book One"或"Two"

"Book (One|Two)" 匹配 "Book One"或"Book Two"

数量限定符

假设我们要从一串人名中找出以 V 开头的人名,因为人名的长度不是固定的,所以用 一一对应的方法就无法实现,这时需要使用数量限定符

数量限定符"*"将前面的字符重复 0 次或多次。

string words = "lg log loog looog loooog looooog";
//正则表达式
Regex expression = new Regex("lo*g");
//获取并输出匹配的字符串
foreach (Match match in expression.Matches(words))
{
Console.WriteLine(match);
}

正则表达式"lo*g"表示字符串的第一个字符为 l,最后一个字符为 g,中间有零个或

多个字母 o。运行结果如图 所示

数量限定符"+"将前面的字符重复 1 次或多次
//正则表达式 Regex expression = new Regex("lo+g");

数量限定符"?"将前面的字符重复 0 次或 1 次。
//正则表达式 Regex expression = new Regex("lo?g");

数量限定符{n,}表示把它前面的字符至少重复 n 遍
//正则表达式 Regex expression = new Regex("lo{3}g");

正则表达式"lo{3}g"表示字符串的第一个字符为 l,最 后一个字符为 g,中间有 3 个字母 o。

数量限定符{n,m}把前面的字符重复 n 至 m 遍
//正则表达式 Regex expression = new Regex("lo{2,4}g");

正则表达式"lo{2,4}g"表示字符串的第一个字符为 l,最后一个字符为 g,中间有 2 到 4 个字母 o。

正则表达式"l(eo)+g"表示字符串的第一个字符为 l,最后一个字符为 g,中间有一个 或多个 eo。

最奇妙的是这些数量限定符还可以与通配符组合。比如通配符"\w"匹配任意单词字 符,限定符"*"表示把前面的字符重复 0 次或多次,所以正则表达式"\w*"匹配由任意 单词字符组成的任意长度的字符串。

string girls = @"Van is 16; Vicky is 18; Vivien is 19; Vinvcent is 22";
Regex expression = new Regex(@"V\w* is \d\d");
foreach (Match match in expression.Matches(girls))
{
Console.WriteLine(match);
}

贪婪和懒惰 的限定符

"贪婪的"(Greedy),它们会匹配尽可能多的文本。如果在限定符后 加上?号,它就会变成"懒惰的"(Lazy),会匹配尽可能少的文本。

限定符"<.*>"和"<.*?>"都表示以"<"开头,以">"结尾,中间是若干个字符的字符串,

贪婪限定符尽量找到一个最长(保留中间可能的匹配)的结果,而懒惰限定符尽量找最短的结 果(忽略中间可能的匹配)。 在匹配以特定字符为首尾的字符串时,懒惰的限定符往往能轻松的达到目的。

cs 复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace 贪婪和懒惰
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string words = "ab<H1>Hello World</H1>c";
            //贪婪的限定符
            Regex expression1 = new Regex("<.*>");
            MatchCollection matchs1 = expression1.Matches(words);
            Console.WriteLine("There is {0} match with greedy quantifier:", matchs1.Count);
            foreach (Match match in matchs1)
            {
                Console.WriteLine(match);
            }
            //懒惰的限定符
            Regex expression2 = new Regex("<.*?>");
            MatchCollection matchs2 = expression2.Matches(words);
            Console.WriteLine("There are {0} matchs with lazy quantifier:", matchs2.Count);
            foreach (Match match in matchs2)
            {
                Console.WriteLine(match);
            }
            Console.ReadKey();
        }
    }
}

懒惰限定符,有两个匹配模式值得注意。一个是"{n}?",它实际上与"{n}"是 等价的,因为不管是贪婪还是懒惰,都已经限定死了,只能重复 n 次。

另一个匹配模式是"??",我们知道"?"表示把前面的字符重复 0 到 1 次,而"??"又是什么意思呢?

string sentence = "Where bee is, there is honey.";
//用?限定
Regex expression1 = new Regex("be?");
foreach (Match match in expression1.Matches(sentence))
{
Console.WriteLine("be? = {0}", match);
}
//用??限定
Regex expression2 = new Regex("be??");
foreach (Match match in expression2.Matches(sentence))
{
Console.WriteLine("be?? = {0}", match);
}

运行结果如图

在正则表达式"be?"中,"?"并不是把整个单词 be 重复 0 到 1 次,而 是把"?"前面字母"e"重复 0 到 1 次。因为"be?"是贪婪的,能重复 1 次就不重复 0 次,所以结果中 e 出现了 1 次;

而"be??"是懒惰的,重复次数要尽量少,所 以它选择把 e 重复 0 次

所有限定符都可以和"?"组合

定位符

通过定位符可以在指定位置寻找匹配的子串。 若正则表达式中使用了定位符"^",则在整个字符串的头部寻找匹配的子串。

string words = "year1998 year2008 year2018";
//正则表达式
Regex expression = new Regex(@"^year\d\d\d\d");
//获取并输出匹配的字符串
foreach (Match match in expression.Matches(words))
{
Console.WriteLine(match);
}

"^"匹配字符串的开头位置,所以"^year\d\d\d\d"表示要从字符串的开头位置开始寻 找。运行结果如图

若正则表达式中使用了定位符"$",则在整个字符串的尾部寻找匹配的子串

//正则表达式 Regex expression = new Regex(@"year\d\d\d\d$");

""匹配字符串的结尾位置,所以"year\\d\\d\\d\\d"表示匹配的子串紧邻字符串的结尾 位置。运行结果如图 所示

若正则表达式中使用了定位符"\b",则在字符串中每个"单词"的边界①寻找匹配 的子串。

string words = "formfordfork";
Console.Write("None anchors:");
Regex expression = new Regex(@"for\w");
foreach (Match match in expression.Matches(words))
{
Console.Write(match + "\t");
}
Console.Write("\nAnchor start:");
expression = new Regex(@"\bfor\w");
foreach (Match match in expression.Matches(words))
{
Console.Write(match + "\t");
}
Console.Write("\n Anchor end:");

expression = new Regex(@"for\w\b");
foreach (Match match in expression.Matches(words))
{
Console.Write(match + "\t");
}

"\b"匹配单词的边界位置。运行结果如图 所示。由结果可以看出,当没有定位 符时,匹配单词中所有符合要求的子串;当定位符\b 在前面时,在单词的头部寻找匹配的子串;当定位符\b 在后面时,在单词的结尾寻找匹配的子串

常用正则表达式"\b\w+\b"找出一句话里的所有单词。

用于正则表达式的定位符如表

符号"^"和""在正则表达式中也有特殊用处,所以当要 匹配它们本身时也需使用它们的转义字符"\\\^"和"\\"。

分组和后向引用

如果没有括号,正则表达式"tr|bee"匹配"tr"或"bee",加了括号后,"(tr|b)ee"匹 配"tree"或"bee",这种带括号的形式称为括号表达式。

括号表达式并不简单的起着确 定范围的作用,它同时会创建子表达式,每个子表达式形成一个分组,并把捕获到的与子 表达式匹配的子串保存在分组中,以供将来使用

举一个例子,电子邮件地址通常由用户名、二级域名、一级域名三部分构成。比 如 waterwood @163.com,其中 waterwood 为用户名,163 为二级域名,com 为一级域名。 我们可以通过下面的正则表达式匹配这类电子邮件地址: "(\w+)@(\w+)\.(\w+)"

这里有三个括号,形成三个子表达式,就会出现三个分组。默认情况下,每个分组会 自动拥有一个组号,规则是:从左向右,按分组左括号的出现顺序进行编号,第一个分组 的组号为 1,第二个为 2,以此类推。在正则表达式里引用分组的语法为"\number",比如 "\1"代表与分组 1 匹配的子串,"\2"代表与分组 2 匹配的字串,等等

如果出现嵌套的分组,它们的编号也按左括号的出现顺序排列。

存储起来的分组有什么作用呢?下面我们通过一个例子来说明。很多句子里会有 重复的单词,下面我们就通过正则表达式找出这些重复的单词。

string text = "you are very very good";
foreach (Match match in Regex.Matches(text, @"\b(\w+)\b \1\b"))
{
Console.WriteLine(match);
}

运行结果如图 所示

我们前面已经知道"\b(\w+)\b"匹配一个单词,因为这里面有一个括号,所以会捕获 一个以 1 为组号的分组,后面的"\1"就代表这个分组,表示这个位置上出现和分组 1 一 样的内容。所以两者连起来就表示两个重复的单词。这种在后面的表达式中引用前面的分组的方式就叫做后向引用

除了匹配重复的单词,后向引用还有一个较为常见的应用,那就是匹配有效的 HTML 标签。我们知道,HTML 标签大多是成对出现的

string words = "<h0>not valid</h1> <h2>valid</h2> <h3>not valid</h4>";
foreach (Match match in Regex.Matches(words, @"<(.*?)>.*?</\1>"))
{
Console.WriteLine(match);
}

运行结果如图

string phonebook = "(010)88665987 (020)23658945 (021)88965222";
string pattern = @"\((\d{3,4})\)(\d{7,8})";
string result = Regex.Replace(phonebook, pattern, "$1-$2");
Console.WriteLine(result);

替换文本

通过Regex类的Replace() 方法就能以特定字符串替换原字符串中与正则表达式匹配的子串。

在大部分语言的正则表达式中,查找时,使用后向引用的语法为"\number";而在替 换时,其语法为"$number"。例子中的 Regex.Replace ()方法把与正则表达式匹配的子串替 换为"$1-$2",其中$1 对应与分组 1(即区号),$2 对应分组 2(即电话号码)。运行结果 如图 所示

正则表达式 \((\d{3,4})\)(\d{7,8}) 用于匹配一个特定的电话号码格式,其中电话号码由两部分组成:一个括号内的区号(可能是3位或4位数字),以及一个紧跟在括号后的7位或8位数字。

这里是该正则表达式的分解:

  • \(: 匹配左括号 ( 字符。因为在正则表达式中括号是特殊字符,所以需要使用反斜杠 \ 进行转义。
  • (\d{3,4}): 这是一个捕获组(因为它被括号包围),它匹配3位或4位的数字。\d 是数字的简写,{3,4} 表示前面的 \d 可以出现3次或4次。
  • \): 匹配右括号 ) 字符,同样也需要转义。
  • (\d{7,8}): 这是另一个捕获组,它匹配7位或8位的数字。

在.NET 中使用正则表达式进行替换时,分组的命名方式为:(?<name> subexpression),

后向引用的语法是:${name}。所以上例也可以写为:

string phonebook = "(010)88665987 (020)23658945 (021)88965222";
string pattern = @"\((?<areacode>\d{3})\)(?<number>\d{8})";
string result = Regex.Replace(phonebook, pattern, "{areacode}-{number}");
Console.WriteLine(result);

正向预查?= / 反向预查?<= / 负正向预查?!

有这样一段文本,它包含了六个员工的电话号码,如何能匹配到所有微软员工的

电话号码而不匹配其它公司的电话号码呢?
Jack boy 29 010-88127631 Microsoft, Sally 22 girl 010-88127632 Microsoft,
Ben boy 26 020-65423541 Google,Merry 23 girl 020-65423542 Google,
Alan boy 27 021-23456851 Apple,Kitty girl 18 021-23456852 Apple.

在正则表达式中,正向预查能帮我们解决这个问题,其语法为在分组中添加元字符

"?="。
string text = @"Jack boy 29 010-88127631 Microsoft, Sally girl 22 010-88127632
Microsoft,Ben boy 26 020-65423541 Google,Merry girl 23
020-65423542 Google,Alan boy 27 021-23456851 Apple,Kitty girl
18 021-23456852 Apple.";
Console.WriteLine("The Telephone numbers of Microsoft are:");

如果仅仅使用正则表达式"\d{3}-\d{8}",它就会匹配文本里所有的电话号码,那么如 何让它只匹配微软的电话号码呢?这时就需要在它后面加上限制条件"(?= Microsoft)"。

需要强调的是正向预查表达式只是用来筛选查询目标,并不属于查询目标本身,不包 含在最终结果中。运行结果如图

反向预查?<=

正向预查用来筛选查询目标,限制条件在查询目标的后面,反向预查也用来筛选查询 目标,但限制条件在查询目标的前面,其语法是在分组中添加元字符"?<="。

正则表达式"(?<=girl \d\d )\d{3}-\d{8}"匹配这样的电话号码,它们前面的文本必须 与"girl \d\d "匹配。

负正向预查?!

负正向预查与正向预查相反,查询目标后面不能跟指定的字符串,其语法为在分组中 添加元字符"?!"

正则表达式"\d{3}-\d{8}(?! Microsoft)"匹配那些后面不跟" Microsoft"的电话号码

负反向预查?

负反向预查与反向预查相反,查询目标前面不能跟指定字符串,其语法是在分组中添 加元字符"?

正则表达式"(?<!girl \d\d )\d{3}-\d{8}"匹配这样的电话号码,它们前面的文本不能与

"girl \d\d "匹配。

正则表达式的选项

通过 Regex 类的 Options 属性可以设置正则表达式的选项,表 20-5 是.Net 中常用 的正则表达式选项

正则表达式默认是区分大小写的,可以通过 IgnoreCase 选项设置为不区分大小写。

string words = "ROOM215 Room315 room415";
string pattern = @"Room\d{3}";
Regex expression = new Regex(pattern, RegexOptions.IgnoreCase);
foreach (Match match in expression.Matches(words))
{
Console.WriteLine(match);
}

运行结果如图

如果想同时设置多个选项,可以把它们用按位或"|"连接起来。

new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Multiline);

注释#

遇到复杂的、比较难理解的正则表达式时,我们可以通过添加注释的方式进行解释说

明。在正则表达式中添加注释的语法为:(?#注释内容)。比如

@"\((\d{3,4})(?#该分组匹配区号)\)(\d{7,8})(?#该分组匹配电话号码)"

编译器把以"?#"开头的分组当作注释,这些注释在编译时都会被忽略掉

练习:验证用户输入

private void btnOK_Click(object sender, EventArgs e)
{
string pattern = @"^SN\w{2}-\d{4}-[abc]{4}-[@#]{4}$";
if (Regex.IsMatch(TextBox.Text, pattern))
{
MessageBox.Show("注册成功!");
}
else
{
MessageBox.Show("注册码错误,请重新输入");
}
}

当单击"确定"按钮时,Regex.IsMatch()方法会检验用户输入的字符串是否满足规则, 如果满足规则,则提示注册成功;如果不满足规则,则提示用户重新输入。

相关推荐
zwjapple3 小时前
typescript里面正则的使用
开发语言·javascript·正则表达式
licy__1 天前
正则表达式语法详解(python)
数据库·mysql·正则表达式
风动也无爱1 天前
Java的正则表达式和爬虫
java·爬虫·正则表达式
运维小文2 天前
linux中的特殊符号
linux·正则表达式·shell·linux命令
南暮思鸢2 天前
强大的正则表达式——Hard
web安全·网络安全·正则表达式·交互式·write up·ctf比赛·hackergame 2024
赶紧回家去2 天前
正则表达式常用字符
正则表达式
白萝卜弟弟2 天前
【JAVA】正则表达式中的正向肯定预查
java·正则表达式
高锰酸钾_2 天前
Java 正则表达式详解及实用案例
java·正则表达式
追梦不止~3 天前
正则表达式
正则表达式
shidouyu3 天前
前端框架主要做些什么工作
javascript·css·ajax·正则表达式·json·firefox·jquery