Perl中的正则表达式使用示例

m//修饰符

LVALUE =~ m/PATTERN/;
LVALUE =~ /PATTERN/;

s///操作符（替换）

tr///操作符（转换）

LVALUE =~ tr/SEARCHLIST/REPLACEMENTLIST/cds;
RVALUE =~ tr/SEARCHLIST/REPLACEMENTLIST/csdr;
RVALUE =~ tr/SEARCHLIST//c;

s/PATTERN/REPLACEMENT/modifiers;
LVALUE =~ s/PATTERN/REPLACEMENT/modifiers;
RVALUE =~ s/PATTERN/REPLACEMENT/rmodifiers;

元符号表

正则表达式量词

扩展正则表达式序列

字母数字正则表达式元符号

/c使用示例

这里之所以加一个g修饰符是因为perl在进行全局匹配时，会记住匹配的位置，以便下一次继续从匹配的位置继续往下匹配。
为了清晰的查看它的运行原理，可以配合pos函数来获取当前文本匹配的位置。

my $test_str = "my1342daw2";
$test_str =~ m/\d\d/gp;
say "The match part is ${^MATCH} and the position is ",pos $test_str; # 4

$test_str =~ m/\d\d/gp;
say "The match part is ${^MATCH} and the position is ",pos $test_str; # 6

$test_str =~ m/\d\d/gp;
say "The match part is ${^MATCH} and the position is ",pos $test_str; # undef, 匹配失败以后，指针位置重置

$test_str =~ m/\d\d/gp;
say "The match part is ${^MATCH} and the position is ",pos $test_str; # 4，又回到了最初匹配的位置

$test_str =~ m/\d\d\d/gpc;
say "The match part is ${^MATCH} and the position is ",pos $test_str; # 匹配失败，但是指针位置依然在之前匹配到的位置

\G使用示例

可以指定\G，使得本次匹配强制从位移处进行匹配，不允许跳过任何匹配失败的字符。
如果本次\G全局匹配成功，位移指针自然会后移
如果本次\G全局匹配失败，且没有加上c修饰符，那么位移指针将重置
如果本次\G全局匹配失败，且加上了c修饰符，那么位移指针将卡在那不动

配合/g修饰符来使用\G

my $txt="1234ab56";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n"; # 12, 2
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n"; # 34, 4

$txt =~ /\G\d/g;     # 强制从位移4开始匹配，无法匹配字母a，但又不允许跳过
                     # 所以本次\G全局匹配失败，由于没有修饰符c，指针重置
print "matched $&: ",pos $txt,"\n";

$txt =~ /\G\d/g;     # 指针回到0，强制从0处开始匹配，数值1能匹配成功
print "matched $&: ",pos $txt,"\n"; # 1, 1

配合/gc修饰符来使用\G

my $txt="1234ab56";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n"; # matched:12, pos: 2
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n"; # matched:34, pos: 4
$txt =~ /\G\d/gc;        # 匹配失败，指针卡在原地 
print "matched $&: ",pos $txt,"\n"; # 依然保留着之前匹配成功的值，matched:34, pos: 4
$txt =~ /\G\d/gc;        # 匹配失败，指针继续卡在原地
print "matched $&: ",pos $txt,"\n";
$txt =~ /\G\d/gc;        # 匹配失败，指针继续卡在原地
print "matched $&: ",pos $txt,"\n";

环视锚定(断言)

"环视"锚定，即lookaround anchor，也称为"零宽断言"，它表示匹配的是位置，不是字符。
(?=...)：表示从左向右的顺序环视。例如(?=\d)表示当前字符的右边是一个数字时就满足条件
(?!...)：表示顺序环视的取反。如(?!\d)表示当前字符的右边不是一个数字时就满足条件
(?<=...)：表示从右向左的逆序环视。例如(?<=\d)表示当前字符的左边是一个数字时就满足条件
(?<!)...：表示逆序环视的取反。如(?<!\d)表示当前字符的左边不是一个数字时就满足条件
关于"环视"锚定，最需要注意的一点是匹配的结果不占用任何字符，它仅仅只是锚定位置。
例如"your name is longshuai MA"和"your name is longfei MA"。使用(?=longshuai)将能锚定第一个句子中单词"longshuai"前面的空字符，但它的匹配结果是"longshuai"前的空白字符，所以(?=longshuai)long才能代表"long"这几个字符串，所以仅对于此处的两个句子，long(?=shuai)和(?=longshuai)long是等价的。
一般为了方便理解，在顺序环视的时候会将匹配内容放在锚定括号的左边(如long(?=longshuai))，在逆序环视的时候会将匹配的内容放在锚定括号的右边(如(?<=long)shuai)。
另外，无论是哪种锚定，都是从左向右匹配再做回溯的(假设允许回溯)，即使是逆序环视。

例如：
$str="abc123abcc12c34";

# 顺序环视
$str =~ /a.*c(?=\d)/;     # abc123abcc12c
print "$&\n";

# 顺序否定环视
$str =~ /a.*c(?!\d)/;     # abc123abc
print "$&\n";

# 逆序环视，这里能逆序匹配成功，靠的是锚定括号后面的c
$str =~ /a.*(?<=\d)c/;    # abc123abcc12c
print "$&\n";

# 逆序否定环视
$str =~ /a.*(?<!\d)c/;    # abc123abcc
print "$&\n";
逆序环视的表达式必须只能表示固定长度的字符串。例如(?<=word)或(?<=word|word)可以，但(?<=word?)不可以，因为?匹配0或1长度，长度不定，它无法对左边是word还是wordx做正确判断。
1
2
3
$str="hello worlds Gaoxiaofang";
$str =~ /he.*(?<=worlds?) Gao/;         # 报错
$str =~ /he.*(?<=worlds|world) Gao/;    # 报错
在PCRE中，这种变长的逆序环视锚定可重写为(?<=word|words)，但perl中不允许，因为perl严格要求长度必须固定。

固化分组
首先固化分组不是一种分组，所以无法去引用它。它和"占有优先"匹配模式(贪婪匹配、惰性匹配、占有优先匹配三种匹配模式)是等价的除了这两种称呼，在不同的书、不同的语言里还有一种称呼：原子匹配。
它的表示形式类似于分组(?>)，所以有些地方将其称呼为"固化分组"。再次说明，固化分组不是分组，无法进行引用。如果非要将其看作是分组，可以将其理解为被限定的匿名分组：不捕获，只分组。
按照"占有优先"的字面意义来理解比较容易：只要匹配成功了，就绝不回溯。
如果按照固化分组的概念来理解，就是将匹配成功的内容放进分组后，将其固定，不允许进行回溯。但是需要注意，这里的不回溯是放进分组中的内容不会回溯给分组外面，而分组内部的内容是可以回溯的。
如果不知道什么是回溯，看完下面的例子就明白。
例如"hello world"可以被hel.* world成功匹配，但不能被hel(?>.*) world匹配。因为正常情况下，.*匹配到所有内容，然后往回释放已匹配的内容直到释放完空格为止，这种往回释放字符的行为在正则术语中称为"回溯"。而固化分组后，.已匹配后面所有内容，这些内容一经匹配绝不交回，即无法回溯。
但是，如果正则表达式是hel(?>. world)，即将原来分组外面的内容放进了分组内部，这时在分组内部是会回溯的，也就是说能匹配"hello world"。

贪婪匹配、非贪婪匹配、占有优先匹配
在基础正则中，那些能匹配多次的量词都会匹配最长内容。这种尽量多匹配的行为称为"贪婪匹配"(greedy match)。
例如字符串"aa1122ccbb"，用正则表达式a.*c去匹配这个字符串，其中的.*将直接从第二个字母a开始匹配到最结尾的b，因为从第二个字母a开始到最后一个字母b都符合.*的匹配模式。再然后，去匹配字母c，但因为已经把所有字母匹配完了，只能回退一个字母一个字母地释放，每释放一个就匹配一次字母c，发现回退释放到倒数第三个字母就能满足匹配要求，于是这里的.*最终匹配的内容是"a1122cc"。
上面涉及到回溯的概念，也就是将那些已经被量词匹配的内容回退释放。
上面描述的是贪婪匹配行为，还有非贪婪匹配、占有优先匹配，以下简单描述下他们的意义：
非贪婪匹配：(lazy match,reluctant)尽可能少地匹配，也叫做懒惰匹配
占有优先匹配：(possessive)占有优先和固化分组是相同的，只要占有了就不再交换，不允许进行回溯。
有必要搞清楚这几种匹配模式在匹配机制上的区别：
贪婪匹配：对于那些量词，将一次性从左到右匹配到最大长度，然后再往回回溯释放
非贪婪匹配：对于那些量词，将从左向右逐字符匹配最短长度，然后直接结束这次的量词匹配行为
占有优先匹配：按照贪婪模式匹配，匹配后内容就锁住，不进行回溯(后文固化分组有具体示例)
除了上面描述的*量词会进行贪婪匹配，其他所有能进行多次匹配的量词可以选择贪婪匹配模式、非贪婪匹配模式和占有优先匹配模式，只需选择对应的量词元字符即可.

Perl正则表达式

2. 用正则表达式进行匹配

2.1 用 m// 进行匹配

到目前为止，我们都是讲正则表达式的内容写在一对斜线内，如/fred/。但其实这是 m// 的简写，其中m代表match，和之前看到的 qw// 类似，我么可以自行选择用于保卫内容的一堆字符作为边界，所以上面这个例子可以改写为m{fred},m[fred],m!fred!等。

• 在不冲突的情况下，建议使用双斜线 // 或 花括号 {}
• 冲突情况下建议使用其他字符串，如/http:\/\// -> m%http://%

2.2 模式匹配修饰符

正则表达式可以在末尾添加修饰符，这些修饰符有时候也被称作标志。
表2.2 常用模式匹配修饰符

2.3 锚位

默认情况下，如果字符串的开头不匹配给定模式，就会顺移到下一个字符位置继续尝试。为了让模式只匹配固定位置上的字符我们可以设置模式锚位。
表2.3 常用模式匹配锚位

2.4 绑定操作符 =~

正则表达式默认的匹配目标是$_，如果要制定匹配某个变量的文本，可以使用绑定操作符（binding operator） =~ ,左侧为变量，右侧为正则表达式。

#!/usr/bin/perl

my $some_other = "I dream of betty rubble.";
if ($some_other =~ /\brub/) {
    print "Aye, there is the rub.\n";
}
#虽然绑定操作符看起来像是某种赋值操作，但其实并非如此！

2.5 捕获变量

• 正则表达式中出现的圆括号一般都会触发正则引擎捕捉到匹配的字符串。
  • 捕获组会把匹配括号中模式的字符串保存到相应变量；
  • 如果不止一个括号，也就不只一个捕获组；
  • 每个捕获组存储的是原始字符串中的内容，而不是模式本身，可以反向引用取得这些内容，如(ab)\1。
• 捕获变量保存的是字符串，它实质上是标量变量。
  • 默认变量名称为$1,$2，其中n代表第几对括号中所捕获的字符串内容。
  • 匹配失败时，$3为空字符串，但是未定义$100的值为undef。

2.5.1 捕获变量的生命周期

捕获变量(如$1,$2)的生命周期是指捕获变量中的值可以保存多久；捕获变量中的内容一般会保持到下次成功匹配为止，即匹配失败的手不会改动上次成功匹配的内容，而成功匹配将会刷新捕获变量中的值。

• 捕获变量只应该在匹配成功时使用，否则得到的就是上次匹配成功的值，这可能不是我们想要的结果；
• 由于捕获变量的生命周期较短，当使用捕获变量时只应该在模式匹配成功后的数行内使用；
• 如果希望在数行之外使用，最好将其复制到某个普通变量中；如my $here = $1;

2.5.2 禁用捕获的括号

• 目前正则表达式中的括号都会自动捕获匹配的字符擦混，但是有些时候我们希望关闭这个功能；
• 只是用圆括号来分组，或者是使程序结构清晰，更容易读懂。
• 禁用捕获的括号(?:acbd)

#!/usr/bin/perl
if (/(bronto)?saurus (stack|burger)/) {
	print "Fred wants a $2\n";
}
#有时候尽管bronto不存在，仍然需要把$1留给它，perl只看左圆括号(决定捕获变量名称，因此我们只能使用$2来取得我们想要的结果。
if (/(?:bronto)?saurus (stack|burger)/) {
	print "Fred wants a $1\n";
}
#使用(?:)关闭第一个模式分组的捕获功能，这样我们可以是使用$1来引用第二个分组中的内容；
if (/(bronto)?saurus (stack|burger)/n) {
	print "Fred wants a $1\n";
}
#使用//n关闭全部正则表达式中的捕获功能，此时$1和$2的值均为undef

2.5.3 命名捕获

• 有时候，我么不希望使用$1，$2这些意义不明的捕获变量，我们希望自己给捕获变量命名；
• 可以使用捕获标签，(?<name1>\w+)
  • 当这个模式分组匹配成功后，可以使用$name1取得匹配的字符串。
• 使用捕获标签后，可以随意移动位置并且加入更多地捕获括号;
• 使用捕获标签后，标签-匹配字符 作为 key-value对存储哈希 %+ 中，取字符串时应使用哈希的方式 $+{label}；

#!/usr/bin/perl
my $name = "fred or barney";
if (/(fred) and (barney)/) {
	say "I saw $1 and $2";                                     #匹配失败，不打印
}
if (/(fred) (and|or) (barney)/) {
	say "I saw $1 and $2";                                     #匹配成功，打印 I saw fred and or
}
if (/(？<name1>fred) (and|or) (?<name2>barney)/) {
	say "I saw $+{name1} and $+{name2}";                       #匹配成功，打印 I saw fred and barney
}
if (/(？P<name1>fred) (and|or) (?P<name2>barney)/) {           #支持python风格的写法
	say "I saw $+{name1} and $+{name2}";                       #匹配成功，打印 I saw fred and barney
}
my $name = "fred Flint and barney Flint";
if (/fred (?<lastname>\w+) (and|or) barney (\g{lastname})/) {  #使用\g{label}反向引用
	say "I saw $+{lastname}";                                  #匹配成功，打印 I saw Flint
}
if (/fred (?<lastname>\w+) (and|or) barney (\k<lastname>)/) {  #使用\k<label>反向引用
	say "I saw $+{lastname}";                                  #匹配成功，打印 I saw Flint
}

2.5.4 自动捕获变量

• perl提供三个不加捕获括号也能使用的变量，但是为了防止和用户定义名称重复，他们的名字有点诡异。
• 虽然这三个变量可以免费使用，但是一旦使用自动捕获变量，其他正则表达式的运行速度也会跟着变慢。
  Perl 5.10之后，为了防止自动捕获变量拖慢程序速度，我们可以指定自动捕获变量的作用范围。修饰符/p只针对当前表达式开启自动捕获变量，但是他们的名字不是$` $& $’ 而是作了相应修改，见下表：

表2.5 自动捕获变量及说明

#!/usr/bin/perl
if ("Hello there, neighbor" =~ /\s(\w+),/) {                      #使用自动捕获变量
	print "That was ($`)($&)($').\n";                             #打印： That was (Hello)( there,)( neighbor).
}
if ("Hello there, neighbor" =~ /\s(\w+),/p) {                     #使用修饰符/p提升程序速度
	print "That was (${^PREMATCH})(${MATCH})(${^POSTMATCH}).\n";  #打印： That was (Hello)( there,)( neighbor).
}

2.6 regex中的优先级

正则表达式的优先级只有5个级别，见表2.6：
表2.6 正则表达式的优先级(上面优先级高)

• 在理解相当复杂的正则表达式时，就得按照perl的优先级按部就班的分析；
• /\Afred|barney\z/ 表示以fred开头，或者以barney结尾的字符串。
• 在更复杂的正则表达式中，建议增加圆括号，使得意义清晰。

2.7 模式测试程序

在编写perl程序的时候，每个程序员都避免不了要使用正则表达式，但有时候很难轻易看出一个模式能够做什么，下面这个程序非常实用，可以用于检测某些字符串是否能够被指定模式匹配以及在什么为止匹配，在将正则表达式写入主程序之前，不妨先用以下程序测试一番，检验是否复合预期要求；

#!/usr/bin/perl
#可以用以下程序调试正则表达式，验证是否符合我们期望的匹配结果
while (<>) {
	chomp;
	if(/YOUR_PATTERN_GOES_HERE/) {
		say "Matched: |$`<$&>$'|";         #打印：Matched： |before<match>fafter|
	} else {
		say "No match: |$_|";              #打印：No match： |beforematchafter|
	}
}

正则表达式除了判断字符串是否匹配某个模式之外，也可以将匹配到的字符串进行替换.

1. 正则替换语法

• 默认正则表达式只替换一次
• 默认正则表达式返回替换的次数

1.1 简写语法

• 简写方式就是对于内置变量$_ 进行正则替换操作
• 简写方式常用语数组遍历中
• 简写方式无须借助于绑定操作符 =~

# 设置内置变量的值
$_ = "hi,perl";

# 对内置变量$_ 进行替换
s/hi/hello/;

print "$_\n";

1.2 标准语法

# 定义普通字符串
$str = "hi,perl";

# 对字符串进行替换
$str =~ s/hi/hello/;

# 输出替换后的字符串
print "$str\n";

1.3 自定义定界符

正则替换也支持自定义定界符, 但是又有些不同，因为替换操作符需要用到三个符号。

• 非成对的定界符: #匹配模式#替换内容#
• 成对的定界符: {匹配模式}{替换内容}

# 定义普通字符串
$str = "http://www.baidu.com";

# 对字符串进行替换
#str =~ s{http://}{https://};
$str =~ s#http://#https://#;

# 输出替换后的字符串
print "$str\n";

2. 替换修饰符

2.1 正则修饰符

正则替换表达式除了支持/s,/i,/x 修饰符之外，还支持 g, r 修饰符

2.2 替换模式特殊符号

正则替换表达式除了支持正则匹配表达式中定义的元字符之外，还有一些额外的字符.

3. 返回结果

• 对于正则替换, 默认返回替换的次数, 并会修改原字符串.
• 对于添加修饰符/r的, 返回替换后的字符串, 不会修改原字符串

3.1 返回替换数量

$str = "hello,world";

$cnt = $str =~ s/l/L/g;

# 输出结果- 替换次数: 3, 原字符串:heLLo,worLd
print "替换次数: $cnt, 原字符串:$str \n";

3.2 返回新字符串

$str = "hello,world";

$new = $str =~ s/l/L/gr;

# 输出结果- 原字符串: hello,world, 新字符串:heLLo,worLd
print "原字符串: $str, 新字符串:$new \n";

4. 综合示例

4.1 正则返回全局替换次数

# 定义普通字符串
$str = "Hello, I am a good boy!";

# 全局替换， 将小写o替换为大写O
$cnt = $str =~ s/o/O/g;

print "替换次数: $cnt \n";
print "替换后内容: $str \n";

4.2 正则返回替换内容

# 定义普通字符串
$str = "Hello, I am a good boy!";

# 正则替换, 不改变原串
$new = $str =~ s/Hello/hi/;

print "原字符串: $str \n";
print "新字符串: $new \n";

4.3 正则大小写替换

# 定义普通字符串
$_ = "HELLO, I am a good boy!";

# 匹配值, 首字母小写。 替换结果：hELLO, I am a good boy! 
$str1 = s/(HELLO)/\l$1/r;

# 匹配值, 全部小写。 替换结果：hello, I am a good boy!
$str2 = s/(HELLO)/\L$1/r;

# 匹配值, 首字母大写。 替换结果：HELLO, I am a Good boy! 
$str3 = s/(good)/\u$1/r;

# 匹配值, 全部大写。 替换结果：HELLO, I am a GOOD boy!
$str4 = s/(good)/\U$1/r;