1.print用来输出信息 ，相当于shell中的echo命令，但需要手动输入换行符 \n 进行换行。

1
2
3

#!/usr/bin/perl

print "hello world\n";      # 注意每一句后面都使用分号结尾

保存后，执行它(假设脚本文件名为test.pl)：

1
2

$ chmod +x test.pl
$ perl test.pl

2.变量赋值

perl中的变量可以不用事先声明，可以直接赋值甚至直接引用。注意变量名前面总是需要加上$符号，无论是赋值的时候还是引用的时候，这和其它语言不太一样。

1
2
3
4
5

#!/usr/bin/perl

$name="longshuai";
$age=18;
print "$name $age \n";

3.if语句用来判断 ，语法格式为：

1
2
3
4
5

if(condition){
    body
}else{
    body
}

1
2
3
4
5
6

$age = 18;
if($age <= 20){
    print "age less than 20\n";
} else {
    print "age greate than 20\n";
}

4.默认参数变量

在perl中，对于需要参数的函数或表达式，但却没有给参数，这是将会使用perl的默认参数变量 $_ 。

例如，下面的print本来是需要参数的，但是因为没有给参数，print将输出默认的参数变量 $_ ，也就是输出 abcde 。

1
2

$_="abcde";
print ;

perl中使用 $_ 的地方非常多，后文还会出现，不过用到的时候我会解释。

5.读取标准输入

perl中使用一对尖括号格式的 <STDIN> 来读取来自非文件的标准输入，例如来自管道的数据，来自输入重定向的数据或者来自键盘的输入。需要注意的是， <STDIN> 读取的输入会自带换行符，所以print输出的时候不要加上额外的换行符。

例如，在test.pl文件中写入如下内容：

1
2
3
4

#!/usr/bin/perl

$data=<STDIN>;
print "$data";

然后用管道传递一行数据给perl程序：

1

echo "abcdefg" | perl test.pl

只是需要注意，将 <STDIN> 赋值给变量时，将只能读取一行(遇到换行符就结束读取)。例如下面的perl将读取不了 hijklmn 。

1

echo -e "abcdefg\nhijklmn" | perl test.pl

如果想要读取多行标准输入，就不能将其赋值给变量，而是使用foreach来遍历各行(此处不介绍其它方式)：

1
2
3

foreach $line (<STDIN>){
    print "$line";
}

以上就是foreach的语法：

可以省略 $line ，这时就采用默认的参数变量 ​$_ ，所以以下两个表达式是等价的：

1
2
3
4
5
6
7

foreach (<STDIN>){
    print "$_";
}

foreach $_ (<STDIN>){
    print "$_";
}

6.读取文件中的数据

正则强大的用处就是处理文本数据，所以必须要说明perl如何读取文件数据来做正则匹配。

我们可以将文件作为perl命令行的参数，perl会使用 <> 去读取这些文件中的内容。

1
2
3

foreach (<>){
    print "$_";
}

执行的时候，只要把文件作为perl命令或脚本文件的参数即可：

1

perl test.pl /etc/passwd

7.去掉行尾分隔符

由于 <> 和 <STDIN> 读取文件、读取标准输入的时候总是自带换行符，很多时候这个自带的换行符都会带来格式问题。所以，有必要在每次读取数据时将行尾的换行符去掉，使用chomp即可。

1
2
3
4

foreach $line (<STDIN>) {
    chomp $line;
    print "$line read\n";
}

以下是执行结果：

1
2

[root@xuexi ~]# echo -e "malongshuai gaoxiaofang" | perl 26.plx 
malongshuai gaoxiaofang read

如果上面的例子中不加上chomp，那么执行结果将像下面一样：

1
2
3

[root@xuexi perlapp]# echo -e "malongshuai gaoxiaofang" | perl 26.plx 
malongshuai gaoxiaofang
 read

显然，输出格式和print语句中期待的输出格式不一样。

前面说过，可以省略 $line ，让其使用默认的参数变量 $_ ，所以可以这样读取来自perl命令行参数文件的数据：

1
2
3
4

foreach (<>) {
    chomp;
    print "$_ read\n";
}

8.命令行的操作模式

其实就是一行式。perl命令行加上 -e 选项，就能在perl命令行中直接写perl表达式，例如：

1

echo "malongshuai" | perl -e '$name=<STDIN>;print $name;'

因为perl最为人所知的就是它应用了各种符号的组合，让人看着怪异无比，而这些符号放在命令行中很可能会被shell先解析，所以强烈建议 -e 后表达式使用单引号包围，而不是双引号。

更建议，如果可以，不要使用perl命令行的方式，调试起来容易混乱。

所以要匹配内容，有以下两种方式：

perl中匹配操作默认返回的是匹配成功与否，成功则返回真，匹配不成功则返回假。但是当使用了全局匹配修饰符 g ，则返回本次匹配成功的内容。此外，perl提供了特殊变量允许访问匹配到的内容，甚至匹配内容之前的数据、匹配内容之后的数据都提供了相关变量以便访问。见下面的示例。

1.匹配给定字符串内容

1
2
3
4

$name = "hello gaoxiaofang";
if ($name =~ m/gao/){
    print "matched\n";
}

或者，直接将字符串拿来匹配：

1

"hello gaoxiaofang" =~ m/gao/;

2.匹配来自管道的每一行内容，匹配成功的行则输出

1
2
3
4
5
6

foreach (<STDIN>){
    chomp;
    if (/gao/){
        print "$_ was matched 'gao'\n";
    }
}

上面使用了默认的参数变量 $_ ，它表示foreach迭代的每一行数据；上面还简写的正则匹配方式 /gao/ ，它等价于 $_ =~ m/gao/ 。

以下是执行结果：

1
2

[root@xuexi perlapp]# echo -e "malongshuai gaoxiaofang" | perl 26.plx  
malongshuai gaoxiaofang was matched 'gao'

3.匹配文件中每行数据

1
2
3
4
5
6

foreach (<>){
    chomp;
    if(/gao/){
        print "$_ was matched 'gao'\n";
    }
}

4.如果想要输出匹配到的内容，可以使用特殊变量 $& 来引用匹配到的内容，还可以使用 $` 引用匹配前面部分的内容， $' 引用匹配后面部分的内容

1

aAbBcC =~ /bB/

由于匹配的内容是bB，匹配内容之前的部分是aA，匹配之后的部分是cC，于是可以看作下面对应关系：

1
2
3

(aA)(bB)(cC)
|    |   |
$`   $&  $'

以下是使用这三个特殊变量的示例：

1
2
3
4
5
6

$name="aAbBcC";
if($name =~ /bB/){
    print "pre match: $` \n";
    print "match: $& \n";
    print "post match: $' \n";
}

需要注意的是，正则中一般都提供全局匹配的功能，perl中使用修饰符 /g 开启。当开启了全局匹配功能，这3个变量保存的值需要使用循环语句去遍历，否则将只保存第一次匹配的内容。例如：

1
2
3
4
5
6
7
8
9
10
11
12

$name="aAbBcCbB";
if($name =~ /bB/g){        # 匹配完第一个bB就结束
    print "pre match: $` \n";
    print "match: $& \n";
    print "post match: $' \n";
}

while($name =~ /bB/g){   # 将迭代两次
    print "pre match: $` \n";
    print "match: $& \n";
    print "post match: $' \n";
}

出于方便，我全部都直接在perl程序内部定义待匹配的内容，如果想要匹配管道传递的输入，或者匹配文件数据，请看上文获取操作方法。

为了完整性，每一节中我都是先把一大堆的内容列出来做个简单介绍，然后再用示例解释每个(或某几个)。但perl正则的内容太多，而且很多功能前后关联，所以如果列出来的内容没有在同一小节内介绍，那么就是在后面需要的地方介绍。当然，也有些没什么用或者用的很少的功能(比如unicode相关的)，通篇都不会介绍。

1

m/REG/i

perl总共支持以下几种修饰符：msixpodualngc

这些修饰符可以连用，连用时顺序可随意。例如下面两行是等价的行为：全局忽略大小写的匹配行为。

1
2

m/REG/ig
m/REG/gi

上面的修饰符，本节介绍igcmsxpo这几个修饰符，n修饰符在后面分组捕获的地方解释，auld修饰符和字符集相关，不打算解释。

例如，字符串 abcabc ，正则表达式 ab ，在默认情况下(不是全局匹配)该正则在匹配到第一个ab后就结束了，如果使用了g修饰符，匹配完第一个ab，还会继续向后匹配，而且正好还能匹配到第二个ab，所以最终有两个ab被匹配成功。

要验证多次匹配，需要使用循环遍历的方式，而不能用if语句：

1
2
3
4
5
6

$name="aAbBcCaBc";
while($name =~ m/ab/gi){
    print "pre match: $` \n";
    print "match: $& \n";
    print "post match: $' \n";
}

执行它，将输出如下内容：

1
2
3
4
5
6

pre match: a 
match: Ab 
post match: BcCabd 
pre match: aAbBcC 
match: ab 
post match: d

以下内容，如果仅仅只是为了学perl正则，那么可以跳过，因为很难，如果是学perl语言，那么可以继续看下去。

实际上， 在开启了g全局匹配后 ，perl每次在 成功匹配 的时候都会记下匹配的字符位移，以便在下次匹配该内容时候，可以从指定位移处继续向后匹配。每次 匹配成功后 的位移值(pos的位移从0开始算，0位移代表的是第一个字符左边的位置)，都可以通过pos()函数获取。如果本次匹配导致位移指针重置，pos将返回undef。

1
2
3
4
5

$name="123ab456";
$name =~ m/\d\d/g;     # 第一次匹配，匹配成功后记下位移
print "matched string: $&, position: ",pos $name,"\n";
$name =~ m/\d\d/g;     # 第二次匹配，匹配成功后记下位移
print "matched string: $&, position: ",pos $name,"\n";

执行它，将输出如下内容：

1
2

matched string: 12, position: 2
matched string: 45, position: 7

由于匹配失败的时候，正则匹配操作会返回假，所以可以作为if或while等的条件语句。例如，改为while循环多次匹配：

1
2
3
4

$name="123ab456";
while($name =~ m/\d\d/g){
    print "matched string: $&, position: ",pos $name,"\n";
}

默认全局匹配情况下，当本次匹配失败，位移指针将重置到起始位置0处，也就是说，下次匹配将从头开始匹配。例如：

1
2
3
4
5
6
7
8
9

$txt="1234a56";
$txt =~ /\d\d/g;      # 匹配成功：12，位移向后移两位
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d\d/g;      # 匹配成功：34，位移向后移两位
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d\d\d/g;      # 匹配失败，位移指针回到0处，pos()返回undef
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d/g;          # 匹配成功：1，位移向后移1位
print "matched $&: ",pos $txt,"\n";

执行上述程序，将输出：

1
2
3
4

matched 12: 2
matched 34: 4
matched 34: 
matched 1: 1

如果 g 修饰符下同时使用 c 修饰符，也就是 gc ，它表示全局匹配失败的时候不重置位移指针。也就是说，本次匹配失败后，位移指针会卡在原处不动，下次匹配将从这个位置处开始匹配。

1
2
3
4
5
6
7
8
9
10
11
12
13

$txt="1234a56";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d\d\d/gc;   # 匹配失败，$&和pos()保留上一次匹配成功的内容
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d/g;        # 匹配成功：5
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d/g;        # 匹配成功：6
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d/gc;        # 匹配失败
print "matched $&: ",pos $txt,"\n";

执行上述程序，将输出：

1
2
3
4
5
6

matched 12: 2
matched 34: 4
matched 34: 4
matched 5: 6
matched 6: 7
matched 6: 7

继续上面的问题，如果第三个匹配语句不是 \d\d\d ，而是 \d ，它匹配字母a的时候也失败，不用c修饰符的时候会重置位移吗？显然是不会。因为它会继续向后匹配。所以该 \G 登场了。

默认全局匹配情况下，匹配时是可以跳过匹配失败的字符继续匹配的：当某个字符匹配失败，它会后移一位继续去匹配，直到匹配成功或匹配结束。

1
2
3
4
5
6
7
8
9

$txt="1234ab56";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d/g;       # 字母a匹配失败，后移一位，字母b匹配失败，后移一位，数值5匹配成功
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d/g;       # 数值6匹配成功
print "matched $&: ",pos $txt,"\n";

执行上述程序，将输出：

1
2
3
4

matched 12: 2
matched 34: 4
matched 5: 7
matched 6: 8

可以指定 \G ，使得本次匹配强制从位移处进行匹配，不允许跳过任何匹配失败的字符。

1
2
3
4
5
6
7
8
9
10

$txt="1234ab56";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n";
$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
2
3
4

matched 12: 2
matched 34: 4
matched 34: 
matched 1: 1

如果将上面第三个匹配语句加上修饰符c，甚至后面的语句也都加上 \G 和c修饰符，那么位移指针将卡在那个位置：

1
2
3
4
5
6
7
8
9
10
11

$txt="1234ab56";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n";
$txt =~ /\d\d/g;
print "matched $&: ",pos $txt,"\n";
$txt =~ /\G\d/gc;        # 匹配失败，指针卡在原地
print "matched $&: ",pos $txt,"\n";
$txt =~ /\G\d/gc;        # 匹配失败，指针继续卡在原地
print "matched $&: ",pos $txt,"\n";
$txt =~ /\G\d/gc;        # 匹配失败，指针继续卡在原地
print "matched $&: ",pos $txt,"\n";

以下是输出结果：

1
2
3
4
5

matched 12: 2
matched 34: 4
matched 34: 4
matched 34: 4
matched 34: 4

一般来说，全局匹配都会用循环去多次迭代，和上面一次一次列出匹配表达式不一样。所以，下面使用while循环的例子来对 \G 和c修饰符稍作解释，其实理解了上面的内容，在循环中使用 \G 和c修饰符也一样很容易理解。

1
2
3
4

$txt="1234ab56";
while($txt =~ m/\G\d\d/gc){
    print "matched: $&, ",pos $txt,"\n";
}

执行结果：

1
2

matched: 12, 2
matched: 34, 4

当第三轮循环匹配到a字母的时候，由于使用了 \G ，导致匹配失败，结束循环。

上面使用c与否是无关紧要的，但如果这个while循环的后面后还有对 $txt 的匹配，那么使用c修饰符与否就有关系了。例如下面两段程序，返回结果不一样：

1
2
3
4
5
6
7

$txt="1234ab56";
while($txt =~ m/\G\d\d/gc){   # 使用c修饰符
    print "matched: $&, ",pos $txt,"\n";
}

$txt =~ m/\G\d\d/gc;
print "matched: $&, ",pos $txt,"\n";

1
2
3
4
5
6
7

$txt="1234ab56";
while($txt =~ m/\G\d\d/g){   # 不使用c修饰符
    print "matched: $&, ",pos $txt,"\n";
}

$txt =~ m/\G\d\d/gc;
print "matched: $&, ",pos $txt,"\n";

使用m修饰符可以开启多行匹配模式。

1
2
3

$txt="ab\ncd";
$txt =~ /a.*\nc/m;
print "===match start===\n$&\n===match end===\n";

执行，将输出：

1
2
3
4

===match start===
ab
c
===match end===

关于多行匹配，需要注意的是元字符 . 默认情况下无法匹配换行符。可以使用 [\d\D] 代替点，也可以开启s修饰符使得 . 能匹配换行符。

例如，下面两个匹配输出的结果和上面是一致的。

1
2
3
4
5
6
7

$txt="ab\ncd";
$txt =~ /a.*c/ms;
print "===match start===\n$&\n===match end===\n";

$txt="ab\ncd";
$txt =~ /a[\d\D]*c/m;
print "===match start===\n$&\n===match end===\n";

万幸，perl正则支持表达式的分隔，甚至支持注释，只需加上x修饰符即可。这时候正则表达式中出现的所有空白符号都不会当作正则的匹配对象，而是直接被忽略。如果想要匹配空白符号，可以使用 \s 表示，或者将空格使用 \Q...\E 包围。

例如，以下4个匹配操作是完全等价的。

1
2
3
4
5
6
7
8
9
10
11
12
13

$ans="cat sheep tiger";
$ans =~ /(\w) *(\w) *(\w)/;       # 正常情况下的匹配表达式
$ans =~ /(\w)\s*   (\w)\s*   (\w)/x;
$ans = ~ /
        (\w)\s*      # 可以加上本行注释：匹配第一个单词
        (\w)\s*      # 可以加上本行注释：匹配第二个单词
        (\w)         # 可以加上本行注释：匹配第三个单词
        /x;
$ans =~ /
         (\w)\Q \E   # \Q \E强制将中间的空格当作字面符号被匹配
         (\w)\Q \E
         (\w)
        /x;

对于稍微复杂一些的正则表达式，常常都会使用x修饰符来增强其可读性，最重要的是加上注释。这一点真的非常人性化。

1
2
3

${^PREMATCH}    <=>   $`
${^MATCH}       <=>   $&
${^POSTMATCH}   <=>   $'

一个例子即可描述：

1
2
3
4
5

$ans="cat sheep tiger";
$ans =~ /sheep/p;
print "${^PREMATCH}\n";     # 输出"cat "
print "${^MATCH}\n";        # 输出"sheep"
print "${^POSTMATCH}\n";    # 输出" tiger"

在perl5.6中，默认情况下对同一正则表达式只编译一次，但同样可以指定o修饰符，使得即使正则表达式变化了也不要重新编译。

一般情况下，可以无视这个修饰符。

例如 m/pattern1 pattern2/i 的i修饰符会影响pattern1和pattern2。

perl允许我们定义只在一定范围内生效的修饰符，方式是 (?imsx:pattern) 或 (?-imsx:pattern) 或 (?imsx-imsx:pattern) ，其中加上 - 表示去除这个修饰符的影响。这里只列出了imsx，因为这几个最常用，其他的修饰符也一样有效。

例如，对于待匹配字符串 Hello world gaoxiaofang ，使用以下几种模式去匹配的话：

/(?i:hello) world/
表示匹配hello时，可忽略大小写，但匹配world时仍然区分大小写。所以匹配成功

/(?ims:hello.)world/
表示可以跨行匹配helloworld，也可以匹配单行的hellosworld，且hello部分忽略大小写。所以匹配成功

/(?i:hello (?-i:world) gaoxiaoFANG)/
表示在第二个括号之前，可用忽略大小写进行匹配，但因为第二个括号里指明了去除i的影响，所以对world的匹配会区分大小写，但是对gaoxiaofang部分的匹配又不区分大小写。所以匹配成功

/(?i:hello (?-i:world) gaoxiao)FANG/
和前面的类似，但是将 FANG 放到了括号外，意味着这部分要区分大小写。所以匹配失败

所谓锚定，是指它匹配的是位置，而非字符，比如锚定行首的意思是匹配第一个字母前的空字符。也就是很多人说的 零宽断言(zero-width assertions) 。

例如字符串 aa1122ccbb ，用正则表达式 a.*c 去匹配这个字符串，其中的 .* 将直接从第二个字母a开始匹配到最结尾的b，因为从第二个字母a开始到最后一个字母b都符合 .* 的匹配模式。再然后，去匹配字母c，但因为已经把所有字母匹配完了，只能回退一个字母一个字母地释放，每释放一个就匹配一次字母c，发现回退释放到倒数第三个字母就能满足匹配要求，于是这里的 .* 最终匹配的内容是 a1122cc 。

上面涉及到回溯的概念，也就是将那些已经被量词匹配的内容回退释放。

上面描述的是贪婪匹配行为，还有非贪婪匹配、占有优先匹配，以下简单描述下他们的意义：

1

"abc11ddabc11" =~ /([a-z]*)([0-9]*)dd\1\2/;

在perl中，还可以使用 \gN 的方式来反向引用分组，这个在上一节【反斜线序列】中已经解释过了。例如，以下是和上面等价的几种写法：

1
2
3

"abc11ddabc11" =~ /([a-z]*)([0-9]*)dd\g1\g2/;
"abc11ddabc11" =~ /([a-z]*)([0-9]*)dd\g{1}\g{2}/;
"abc11ddabc11" =~ /([a-z]*)([0-9]*)dd\g{-2}\g{-1}/;

perl还会把分组的内容放进perl自带的特殊变量 $1,$2,...,$N 中，它们和 \1,\2,...\N 在 匹配成功时 的结果上没有区别，但是 \N 这种类型的反向引用只在正则匹配中有效，正则匹配结束后就消亡了，而 $N 因为是perl的变量，即使正则已经退出匹配，也依然可以引用。所以，我们可以使用 $N 的方式来输出分组匹配的结果：

1
2
3

"abc11ddabc11" =~ /([a-z]*)([0-9]*)dd\1\2/;
print "first group \\1: $1\n";
print "second group \\2: $2\n";

有两点需要注意：

第一点，示例可知：

1
2

"abcde" =~ /([0-9]*)de/;
print "null group: $1\n";

第二点，从机制上去分析。 \1 是每个正则匹配都相互独立的，而 $1 则保存分组捕获成功的值，即使这次值是上次捕获的。

正则匹配的操作如果在列表上下文，则保存各个分组捕获的内容。所以，出于方便，可以通过下面的方式直接将分组捕获的结果赋值给指定变量：

1
2
3

$date = "2018-11-22";

($year,$mon,$day) = ($date =~ /(\d{4})-(\d{2})-(\d{2})/);

这里稍微解释下正则匹配关于分组捕获的匹配过程：

例如，匹配表达式 "12abc22abc" =~ /\d(abc)\d\d\1/; ，当正则引擎去匹配数据时：
1.首先匹配第一个数字1，发现符合 \d ，于是继续用 (abc) 去匹配字符串，因为发现了是分组括号，于是会将第二个字符2放进分组，发现不匹配字母a，于是匹配失败，丢弃这个分组中的内容。
2.正则引擎继续向后匹配数值2，发现符合 \d ，于是用 (abc) 去匹配字符串，接着会将第三个字符a放进分组，发现能匹配，继续匹配字符串中的b、c发现都能匹配，于是分组捕获完成，将其赋值给 $1 ，之后就能用 \1 和 $1 去引用这个分组的内容。
3.后面继续去匹配 \d\d\1 ，直到匹配结束。

当然，具体匹配的过程不会真的这么简单，它会有一些优化匹配方式，以上只是用逻辑去描述匹配的过程。

虽然有了分组捕获功能，就可以实现任何需求，但有时候可以让这种行为变得更人性化，减少维护力度。

例如字符串 xiaofang or longshuai ，使用模式 /(\w+) or (\w+)/ 去捕获，用 $1 和 $2 分别引用or左右两个单词：

1
2
3
4

$str = "xiaofang or longshuai";
if ($str =~ /(\w+) or (\w+)/){
    print "name1: $1, name2: $2\n";
}

但如果需求是中间的关系or也可以换成and，为了同时满足and和or两种需求，使用模式 /(\w+) (and|or) (\w+)/ 去匹配，但是这时引用的序号就得由 $2 变为 $3 ：

1
2
3
4

$str = "xiaofang or longshuai";
if ($str =~ /(\w+) (or|and) (\w+)/){
    print "name1: $1, name2: $3\n";
}

如果使用匿名捕获，对and和or这样无关紧要，却有可能改变匹配行为的内容，可以将其放进一个无关的分组中。这样不会对原有的其余正则表达式产生任何影响：

1
2
3
4

$str = "xiaofang or longshuai";
if ($str =~ /(\w+) (?:or|and) (\w+)/){
    print "name1: $1, name2: $2\n";
}

注意上面仍然使用 $2 引用第三个括号。

同样，如果要在正则内部使用反向引用，也一样使用 \2 来引用第三个括号。

另外，在前文还介绍过一个 n 修饰符，它也表示非捕获仅分组行为。但它只对普通分组有效，对命名分组无效。且因为它是修饰符，它会使所有的普通分组都变成非捕获模式。

1
2
3
4

$str = "xiaofang or longshuai";
if ($str =~ /(\w+) (or|and) (\w+)/n){
    print "name1: $1, name2: $2\n";
}

由于上面开启了n修饰符，使得3个普通分组括号都变成非捕获仅分组行为，所以 \1 和 $1 都无法使用。除非正则中使用了命名分组。

当要进行命名捕获时，使用 (?<NAME>) 的方式替代以前的分组括号 () 即可。例如，要匹配abc并将其分组，以前普通分组的方式是 (abc) ，如果将其放进命名为name1的分组中： (?<name1>abc) 。

当使用命名捕获的时候，要在正则内部引用这个命名捕获，除了可以使用序号类的绝对引用(如 \1 或 \g1 或 \g{1} )，还可以使用以下任意一种按名称引用方式：

如果要在正则外部引用这个命名捕获，除了可以使用序号类的绝对应用(如 $1 )，还可以使用 $+{NAME} 的方式。

实际上，后一种引用方式的本质是perl将命名捕获的内容放进了一个名为 %+ 的特殊hash类型中，所以可以使用 $+{NAME} 的方式引用，如果你不知道这一点，那就无视与此相关的内容即可，不过都很简单，一看就懂。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

$str = "ma xiaofang or ma longshuai";
if ($str =~ /
            (?<firstname>\w+)\s  # firstname -> ma
            (?<name1>\w+)\s      # name1 -> xiaofang
            (?:or|and)\s      # group only, no capture
            \g1\s                # \g1 -> ma
            (?<name2>\w+)        # name2 -> longshuai
            /x){
    print "$1\n";
    print "$2\n";
    print "$3\n";
    # 或者指定名称来引用
    print "$+{firstname}\n$+{name1}\n$+{name2}\n";
}

其中上述代码中的 \g1 还可以替换为 \1 、 \g{firstname} 、 \k{firstname} 或 \k<firstname> 。

通过使用命名捕获，可以无视序号，直接使用名称即可准确引用。

它的表示形式类似于分组 (?>) ，所以有些地方将其称呼为【固化分组】。再次说明，固化分组不是分组，无法进行引用。如果非要将其看作是分组，可以将其理解为被限定的匿名分组：不捕获，只分组。

如果不知道什么是回溯，看完下面的例子就明白。

例如 hello world 可以被 hel.* world 成功匹配，但不能被 hel(?>.*) world 匹配。因为正常情况下， .* 匹配到所有内容，然后往回释放已匹配的内容直到释放完空格为止，这种往回释放字符的行为在正则术语中称为【回溯】。而固化分组后， .* 已匹配后面所有内容，这些内容一经匹配绝不交回，即无法回溯。

但是，如果正则表达式是 hel(?>.* world) ，即将原来分组外面的内容放进了分组内部，这时在分组内部是会回溯的，也就是说能匹配 hello world 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

$str="ma longshuai gao xiaofang";
if($str =~ /ma (?>long.*)/){     # 成功
    print "matched\n";
}

if($str =~ /ma (?>long.*)gao/){   # 失败
    print "matched\n";
}

if($str =~ /ma (?>long.*gao)/){   # 成功
    print "matched\n";
}

if($str =~ /ma (?>long.*g)ao/){   # 成功
    print "matched\n";
}

固化分组看上去挺简单的，此处也仅介绍了它最简单的形式。但实际上固化分组很复杂，它涉及了非常复杂的正则引擎匹配原理和回溯机制。如果有兴趣，可以阅读《精通正则表达式》一书的第四章。

关于【环视】锚定，最需要注意的一点是匹配的结果不占用任何字符，它仅仅只是锚定位置。

例如 your name is longshuai MA 和 your name is longfei MA 。使用 (?=longshuai) 将能锚定第一个句子中单词 longshuai 前面的空字符，但它的匹配结果是 longshuai 前的空白字符，所以 (?=longshuai)long 才能代表 long 这几个字符串，所以仅对于此处的两个句子， long(?=shuai) 和 (?=longshuai)long 是等价的。

一般为了方便理解，在顺序环视的时候会将匹配内容放在锚定括号的左边(如 long(?=longshuai) )，在逆序环视的时候会将匹配的内容放在锚定括号的右边(如 (?<=long)shuai )。

另外，无论是哪种锚定，都是从左向右匹配再做回溯的(假设允许回溯)，即使是逆序环视。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

$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严格要求长度必须固定。

1
2
3
4

$str="hello worlds gaoxiaofang";
$pattern="w.*d";
$str =~ /$pattern/;
print "$&\n";

但是，这样缺陷很大，在保存正则表达式的变量中存放的特殊字符要防止有特殊意义。例如，当使用 m// 的方式做匹配分隔符时，不能在变量中保存 / ，除非转义。