Perl 笔记

Perl

标量数据

标量是 Perl 中最简单的一种数据类型，对于大部分标量来说，他要么是数字，要么是字符串。Perl 在内部会自动的进行数字和字符串之间的转换，标量可以存储在标量变量里。

数字
Perl 中不区分整数、浮点数，它们通通按照 双精度浮点数 来存储。

浮点数直接量
直接量也叫字面量，是指键入到 Perl 源代码中的数据。比如：

1.25
255.000
255.0
7.25e45   # 7.25 * 10^45
-6.5e24   # 6.5 * 10^24
-12e-24   # -12 * 10^-24
-12E-24   # -12 * 10^-24，同上

整数直接量
这个比较好懂，如

0
100
-1000
100000000000000000000000
1_000_000_000_000_000_000 # 和 Java7 的下换线一样

非十进制整数字面量

# 0b 表示二进制
0b1010110
# 0 表示八进制
045
# 0x 表示十六进制
0xFFFF
# 非十进制整数字面量也可以使用下划线
0xFFFF_FFFF_FFFF

数字操作符

# 加
1 + 2
# 减
9 - 5
# 乘
5 * 4
# 除
10 / 2
# 取模（mod，非求余）
11 % 12 # 11
-1 % 12 # 11
# 求幂（乘方运算）
10 ** 2 # 100

字符串
字符串就是一个字符序列，如 hello。字符串由任意字符组合而成，最短的字符串可以不包含任何字符，也称为空字符串，最长的字符串的长度没有限制，它甚至可以填满整个内存。这符合 Perl 尽可能遵循的“无内置限制”的原则（真爽！）。字符串通常由 ASCII 码组成，但实际上它可以是任意字符，所以你可以用 Perl 的字符串来操纵二进制数据，这是很多编程语言望尘莫及的。比如你可以将一个图片的数据存储在一个字符串中，也可以将一个可执行文件的内容读取到字符串中，修改的它内容然后返回。事实上，Shell 也有这种能力。

Perl 完全支持 Unicode，因此你可以在 Perl 中随意使用任意合法的 Unicode 字符，但由于历史原因，Perl 不会自动将程序源代码当作 Unicode 编码的文本输入，所以要在 Perl 程序开头加上 use utf8;，不过我在 Linux 中却没有什么问题，但是最好养成习惯加上这句，另外，Perl 的字符串不以 \0 NUL 字符表示结尾，它会另记住字符串的长度。除了加上这句声明外，你的源程序文件也必须以 utf-8 编码保存（实际上还是有问题，见下文）。

当我使用 vim 编辑一个 Perl 源文件时，我没有加入 use utf8;，运行时没有警告信息，如下：

# root @ arch in ~/workspace [9:41:37]
$ cat test1.pl
#!/usr/bin/perl
use strict;
use warnings;
my $string = "中华人民共和国";
print "$string\n";
# root @ arch in ~/workspace [9:41:42]
$ cat test2.pl
#!/usr/bin/perl
use utf8;
use strict;
use warnings;
my $string = "中华人民共和国";
print "$string\n";
# root @ arch in ~/workspace [9:41:45]
$ ./test1.pl
中华人民共和国
# root @ arch in ~/workspace [9:41:48]
$ ./test2.pl
Wide character in print at ./test2.pl line 7.
中华人民共和国
# root @ arch in ~/workspace [9:41:50]
$ perl -CS ./test2.pl
中华人民共和国
# root @ arch in ~/workspace [9:41:59]
$ vim test2.pl
# root @ arch in ~/workspace [9:42:20]
$ cat test2.pl
#!/usr/bin/perl -CS
use utf8;
use strict;
use warnings;
my $string = "中华人民共和国";
print "$string\n";
# root @ arch in ~/workspace [9:42:22]
$ ./test2.pl
中华人民共和国

解决办法是，给 Perl 加上 -CS 参数（来自 StackOverFlow 讨论社区）。更新：仍然是有问题的，最保险的方法是将全部的流都设为 UTF-8 编码，类似：

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
print "hello, world!\n";

它等效于 perl -CSDA -Mutf8 -Mstrict -Mwarnings -e 'print "hello, world!\n"'。

和数字一样，字符串也有直接量记法，有两种形式：单引号、双引号。它们的区别于 Shell 中的单引号和双引号一致，单引号会保留原始输出，不进行变量替换以及字符转义序列，而双引号则会进行变量替换和字符转移序列。单引号中要表示单引号需要加上反斜杠转义，双引号中要表示双引号也需要加上反斜杠转义。

转移序列

双引号内字符串的另一个特性是变量内插，这是指将字符串中的变量引用替换为变量当前的值，和 Shell 中的行为一致。

字符串操作符
字符串之间可以用 . 连接起来，它不会修改两边的字符串，而是产生一个新字符串。
一个特殊的操纵符 x，用来重复左侧的字符串，如 "abc" x 3 得到 "abcabcabc"。
重复操作符的左操作数必须是字符串类型（如果不是 Perl 会进行转换），而右侧则是非负整数。如果不是整数，如 4.9 则会被取整为 4（注意不是四舍五入），如果小于 1，则返回空字符串。

数字、字符串转换
通常 Perl 会根据需要，指定在数字和字符串之间进行类型转换。而 Perl 的转换需求通常是因为操作符，比如操作符 + 两侧需要的是数字，Perl 就会将两边的操作数视为数字，比如操作符 . 两侧需要的是字符串，Perl 就会将两边的操作数视为字符串。因此在 Perl 中不必在意字符串与数字之间的转换，只要使用正确的操作符就 OK 了。

对于数字运算符，如果遇到的操作数为字符串，Perl 会自动将字符串转换为等效的十进制浮点数进行运算（二进制、八进制、十六进制的格式在字符串转数字过程中是无效的，Perl 只认十进制）。比如 "12" * "3" 返回 36，字符串中的非数字部分（比如前置空白，后尾空白）会被 Perl 忽略。因此 "12hello34" * "3" 的结果依旧是 36（默认不会产生警告，如果启用 -Mwarnings 则会产生警告，建议始终开启此选项）。同样，如果字符串操作符中存在数字操作数，也会进行自动转换，如 "Z" . 5 * 7 返回 "Z35"。

如果需要将字符串中的八进制、十进制（甚至是二进制）转换为对应的数值，需要使用 oct()、hex() 等转换函数（详见后文）。

启用 use warnings; 的警告信息比较简短，如果需要更详细的警告信息，可以使用 use diagnostics; 输出详细信息（但可能导致程序变慢，内存占用变大，因为 Perl 在忙着加载警告和详细信息），因此可以通过 Perl 命令行选项的方式来进行临时的查看详细信息，如 perl -Mdiagnostics my_prog（可以加在 #!/usr/bin/perl 行中）。

标量变量

所谓变量，就是存储一个或多个值的容器的名称。而标量变量就是存储单个值的变量，后续会学习到其它类型的变量，比如数组、哈希。它们都可以存储多个值，变量的名称在整个程序中保持不变，但他所持有的值是可以在程序运行中不断修改变化的。

没错，标量变量存储的是单个标量值，标量变量的名称以美元符号开头，接着是 Perl 标识符：以字母、下划线开头，后可接字母、数字、下划线。标识符是区分大小写的，这和绝大多数编程语言是一样的。如

$var
$variable
$name
$Name
$NAME
$a_very_long_variable_that_ends_in_1
$a_very_long_variable_that_ends_in_2
$a_very_long_variable_that_ends_in_3

Perl 标识符并不仅限 ASCII 字符，在启用 utf8 编译指令后，可以使用任意合法的 Unicode 字符。Perl 通过变量的前缀字符来区分变量的类型，比如标量变量以 $ 开头，数组变量以 @ 开头，哈希变量以 % 开头。所以不管你用什么名字都不会与内置的函数、操作符的写法相冲突（这真是极好的）。

此外，Perl 是通过这个魔符（就是前缀符）来判断该变量的使用意图。$ 的确切意思是“取某个东西”或者“取标量”。因为标量变量总是存储一项数据，所以她的意思就总是取得其中的“单个”值。在后面的章节中，你会看到“取单个东西”的魔符应用于其它类型（数组）变量的情况，不要惊讶。

变量名尽量取得有意义，特别是全局变量，如果有多个单词，建议使用下划线分割，而不是驼峰写法。如果使用全大写变量（如 $ARGV）一般都是表示特殊意义的变量。所以不建议使用全大写的变量名，因为可能会与 Perl 中的预留变量产生冲突。

你可以使用 perlsytle 查看 Perl 对变量命名的一样，可以使用 perlvar 查看 Perl 中的特殊变量的名称。

标量的赋值
对标量变量最常见的操作就是赋值了，也就是将某个值存进变量中。Perl 中的赋值符是等号，和其他语言差不多。左操作数是变量名，右操作数是标量数据。如：

$var1 = 1;
$var2 = 12;

其中 Perl 和 C/C++、Java 一样，支持 $var += 5; 这样的赋值运算符。因此你可以使用 .= 赋值运算符来进行“追加”操作。基本上所有双目运算符都可以这么做。

一般我们都想程序输出写什么信息来，否则，也须会有人以为程序什么都没做。print 操作符就是用来完成这项任务的。它可以接受标量值作为参数，然后不经修饰的传送到 STDOUT 标准输出。比如：

print "hello, world!\n";
print 3;
print 5 * 7;

你也可以使用一行来打印这些东西，只需使用逗号分隔，如：

print "this answer is ", 6 * 7, ".\n";

这其实就是一个 list（列表），稍后会进行详细说明。

一般我们使用双引号圈引字符串的目的，除了是要是有反斜线转义特殊字符外，多半是为了变量内插。说白了，就是把字符串中出现的标量变量替换成该变量的值罢了。比如：

$name = "Otokaze";
$info = "My name is $name";  # 变量内插
$info = 'My name is '.$name; # 等效写法

正如最后一行所示，不用双引号的变量内插也可以实现一样的效果，但是明显不如第一种方式简便、清晰。如果引用的变量从未赋值过，那么它就是空串，这和 Shell 一样。但是如果启用了额外的警告，那么 Perl 会输出响应的警告信息，告诉我们这个变量没有被赋值（也就是说它不存在）。

但如果只是想打印某个标量变量的值，必须要使用双引号内插方式，直接写就好了：

$name = "Otokaze";
print "$name"; # 多余的
print $name;   # 比较好

如果想输出 $ 自身，可以在前面加上反斜杠进行转义。进行内插时，Perl 会尽可能使用最长的合法变量名，如果你想在内插的值后紧跟输出字母、数字、下划线，可能不是你预想的那样，此时你可以在变量名两边加上花括号，如 ${name}，这个 Shell 采用的策略一致。如果不这样做，你就必须用 . 来连接它们，但是这样显然比较麻烦。

有些时候你想输出一些键盘上没有的字符，这时与其费力气的寻找字符如何输入，还不如直接使用它们的 Unicode 码点（code point，也就是字符序号，和 ASCII 中的字符序数是一回事），再通过 chr() 函数将它们转换为对应的字符来得方便。反过来，也可以通过 ord() 函数将字符转换为代码点。当然也可以使用 \x{hhhh} 转移序列来完成。

和其他语言一样，Perl 中的众多运算符之间也是有优先级的，如果你不明确它们的优先级如何，请务必使用圆括号包围，避免错误的同时还增加了可读性。Perl 中的算数运算符的优先级和数学中的优先级基本一致。比如都是先算乘除，再算加减。

比较操作符
对数值的比较运算符，Perl 和 C/C++、Java 类似，有 <、<=、==、!=、>、>= 等运算符，它们的返回值都是布尔值，要么 true，要么 false。

对字符串的比较运算符也有很多（命名和 shell 有点类似），字符串比较会逐一比较两边字符串的每个字符，判断的依据是他们的 Unicode 代码点。返回布尔值。

if 控制结构
基本语法结构和 C 语言类似，但是不能省略花括号！切记切记！Perl 中并没有专门的 Boolean 类型，它靠一些简单的规则来判断（和 C、Shell 一致），规则如下：

• 如果是数字，0 为 false，其它均为 true；
• 如果是字符串，'' 空串为 false，其他均为 true；
• 如果既不是数字也不是字符串，则将它们转换为数字或字符串再判断。

注意，这并不是完整的判断规则，但足以日常判断。另外，undef“未定义”为 false，而所有引用都是 true。

其实上面还有一个隐含的技巧，字符串 '0' 和数字 0 是同一个标量值，所以 Perl 对它们一视同仁，它们都表示 false。

要取得任何布尔值的相反值，只需在它们前面加上 !，这和大多数语言是类似。

获取用户输入
那么如何让 Perl 读取 STDIN 的用户输入数据呢？只需使用 <STDIN>（这其实获取一行数据，差点搞错了） 读取，如：

$line = <STDIN>;
if ($line eq "\n") {
    print "这仅仅是一个换行符\n";
} else {
    print "你输入的字符串为: $line";
}

完整的例子如下：

# root @ arch in ~/workspace [13:10:26]
$ cat stdin.pl
#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
my $line = <STDIN>;
if ($line eq "\n") {
    print "That was just a blank line!\n";
} else {
    print "That line of input was: $line";
}
# root @ arch in ~/workspace [13:10:38]
$ ./stdin.pl
www.zfl9.com
That line of input was: www.zfl9.com
# root @ arch in ~/workspace [13:10:42]
$ echo www.zfl9.com | ./stdin.pl
That line of input was: www.zfl9.com

不过实际编码时，很少需要保留末尾的换行符，所以人们常常会用 chomp() 函数来去掉它。咋看一下，chomp() 操作符的用途好像太过简单专一：只能作用于单个变量，且该变量的内容必须为字符串，如果该字符串尾部是换行符，chomp() 的任务就是去掉它，这差不多就是他的全部工作了。比如：

$text = "a line of text\n"; # 带换行符的字符串
chomp($text);               # 去掉末尾的换行符

其实他非常有用，以后你写的每个程序几乎都少不了他，如上所示，处理字符串变量时，它是去除行末换行符的最佳方式。事实上，chomp() 还有一种取巧的用法，因为 Perl 有一条规则：任何需要变量的地方，都可以用赋值运算表达式代替。这在 Java、C/C++ 中其实也适合，比如可以这样使用 chomp()：

chomp($text = <STDIN>); # 读入数据，删除尾部换行符
# or，但明显麻烦
$text = <STDIN>;        # 读取数据
chomp($text);           # 删除尾白

chomp 函数的返回值是实际移除的字符数，不过这个返回值没有什么用处。强调一点，chomp 只会移除最后一个字符，且它是换行符的情况下。

如你所见，chomp 可以带括号，也可以不带括号（这和 awk 有几分相似），这又是 Perl 的又一项惯例：除非去掉括号会改变表达式的意义，否则括号都是可以省略的（绝大部分函数都可以，比如 print 其实是函数，但我们一般不带括号，但是我建议带上括号，不要觉得麻烦，可能是我写惯了 Java 吧，哈哈）。

while 控制结构
语法同 Java，但也是不能省略花括号。

undef 值
如果还没赋值就用到了某个标量变量，会产生什么结果呢？答案是，不会发送什么大不了的事，也绝对不会让程序终止运行，在首次赋值前，变量的初始值就是特殊的 undef（意为未定义的变量的值），这又与 JS 中的 undefined 值很相似。它的意思是：这是空无一物。这个空无一物当作数字用，表现的就像零；如果当作字符串用，那就表现的想空字符串。但实际上，undef 既不是数字，也不是字符串，它完全是另一种类型的标量值（我猜是引用类型）。

既然 undef 作为数字是被视为零，我们可以很容易的构造一个数字累加器，他在开始时是空的（这里计算从 0+1+2+...+9）：

# root @ arch in ~/workspace [13:48:58]
$ cat sum.pl
#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
my $sum;
for (my $i = 0; $i < 10; ++$i) {
    $sum += $i;
}
print "0 + 1 + 2 + ... + 9 = $sum\n";
# root @ arch in ~/workspace [13:48:59]
$ ./sum.pl
0 + 1 + 2 + ... + 9 = 45

同样的道理，你可以进行字符串的累加，这里就不进行演示了。同样，在 Perl 中大部分函数如果觉得参数不对，或者是执行遇到异常，都是返回 undef 值，这和 JS 神似。当然，你也可以显式的为某个变量设置 undef 值，就像 Java 中显式设置 null 值一样，比如 $var = undef;，这并没有什么不妥。

defined 函数
行输入操作符 <STDIN> 有时候会返回 undef，在一般情况下，它会返回一行文本，但若没有更多输入，比如读到文件末尾（end-of-file，EOF）时，它就会返回 undef 来表示这种特殊情况。Perl 中可以使用 defined 函数来判断一个值是否为 undef：

# root @ arch in ~/workspace [14:15:07]
$ cat stdin.pl
#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
my $input = <STDIN>;
if (defined($input)) {
    print($input);
} else {
    print("EOF\n");
}
# root @ arch in ~/workspace [14:15:07]
$ ./stdin.pl
www.zfl9.com
www.zfl9.com
# root @ arch in ~/workspace [14:15:16]
$ ./stdin.pl # Ctrl+D 即 EOF
EOF

联系
1、写一个程序，用来计算指定的圆周长（提示用户输入半径），我的如下：

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
use Math::Trig;
print("please input radius: ");
chomp(my $radius = <STDIN>);
if ($radius <= 0) {
    print("circumference($radius) = 0\n");
} else {
    my $circum = 2 * pi * $radius;
    print("circumference($radius) = $circum\n");
}

2、写一个程序，提示用户输入两个数字（分两行输入），然后打印它们的乘积：

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
print("num1: ");
chomp(my $num1 = <STDIN>);
print("num2: ");
chomp(my $num2 = <STDIN>);
my $sum = $num1 + $num2;
print("$num1 + $num2 = $sum\n");

3、写一个程序，提示用户输入一个字符串、一个数字（分两行），然后以给定的数字的次数，重复输出这行字符串，如字符串为 www，数字为 3，则应输出 3 行 www。

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
print("str: ");
my $str = <STDIN>;
print("num: ");
chomp(my $num = <STDIN>);
print($str x $num);

列表与数组

如果说 Perl 标量代表单数，那么代表复数的就是列表和数组。

列表(list)是指标量的有序集合，而数组(array)则是存储列表的变量。在 Perl 里，这两个术语常常混用，不过更精确的说，列表指的是数据，数组是的是变量。列表不一定放在数组里，但每个数组变量一定包含着一个列表。可以这样理解，列表是字面量，数组则是一个存储列表的变量而已。不过一般不用严格区分它们，了解就好。

数组或列表的每个元素都是单独的标量变量，拥有独立的标量值。这些值是有序的，每个元素都有自己的索引，它从 0 开始，这和大部分语言是一致的，它们从 0 开始递增。

和 C/C++、Java 的数组不同的是，Perl 列表的元素的数据类型可以不同，比如可以是纯数字、纯字符串，也可以是它们的混合体，当然也可以是 undef 值。不过更常见的还是同一类型的标量。

列表可以存放任意个标量值，最少的时候可以是 0，最多的时候可以将内存塞满。

访问数组元素
和 C/C++、Java 一样，使用下标访问，下标也是从 0 开始（其实也可以是负数，表示从后往前的下标，后面会讲到）。比如：

$fred[0] = "aaa";
$fred[1] = "bbb";
$fred[2] = "ccc";

注意，这里使用 $ 标量符，而不是 @ 符，为什么呢？其实也好理解，因为 $ 后的表达式 freq[ind] 表示一个标量值，因此它使用 $，而不是 @，后面还会遇到类似的。

注意，如果是依次给数组元素赋值，那么下标其实可以不连续，Perl 会自动的为中间的元素赋予 undef 值。我们来试一下（判断 undef 可以使用 defined 函数）：

# root @ arch in ~/workspace [18:22:33]
$ cat array.pl
#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
use 5.026_002;
my @array;
$array[0] = 0;
$array[1] = 1;
$array[2] = 2;
$array[3] = 3;
$array[9] = 9;
foreach (@array) {
    if (!defined($_)) {
        print("undef, ");
    } else {
        print("$_, ");
    }
}
print("\b\b \n");
# root @ arch in ~/workspace [18:22:34]
$ ./array.pl
0, 1, 2, 3, undef, undef, undef, undef, undef, 9

注意，凡是能用 $arr[ind] 的地方，都可以使用 $elem 替代，因为它们实际上数据类型是一样的，前者可以理解为解数组，取数组元素，而后者则是普通的标量数据。

并且，方括号中的下标可以是任意表达式，只要它的值是数字，如果不是整数，则会舍去小数部分（注意是舍去，不是四舍五入）。如果下标超过数组的最大下标值，则返回 undef，这和一般的未赋值标量是相同的，如果未对一个标量变量赋值，那么它的值就是 undef。

特殊的数组索引
如果你对索引值超过数组尾端索引值的元素进行赋值，数组将会根据需要自动扩大，其中填充的值均为 undef。只要有足够的内存分配给 perl，数组的长度是无上限的（但实际上它被限制于有符号整数的最大值，但这实际上已经够大了）。

有时候，你会想找出数组的最后一个元素的索引值（通常是数组长度减一），可以使用类似 shell 的求长度语法，即 $#array。比如你可以快速的往数组中追加一个元素：

$array[$#array] = "hello, world!";

但实际上，我们还有更简便且优美的方式来完成这件事，那就是使用 -1，即：

$array[-1] = "hello, world!";

但是超出数组长度的负值索引是不会扩充数组的（并且产生严重错误，终止运行），尝试获取它的值得到的也是 undef。-1 表示倒数第一个元素，-2 表示倒数第二个元素，以此类推，记得是从 -1 开始。

列表直接量
列表直接量也就是数组字面量，它使用圆括号表示，里面的元素使用逗号分隔。而这些数据就称为列表元素，例如：

(1, 2, 3)     # 1、2、3 这 3 个数字的列表
(1, 2, 3,)    # 同上，末尾的多余逗号被忽略
("freq", 4.5) # 两个元素，"freq"、4.5
()            # 空列表，里面没有元素
(1..100)      # 1,2,3,..,100 一百个数字

最后一个例子使用了范围操作符，这个操作符在 shell 中也有，不过它是使用花括号包围的。它的范围只能是整数，如果是浮点数，会自动丢弃小数部分。该操作符会从左边的数字计数到右边的数字，每次加一，以产生一连串数字。举例来说：

(1..5)              # 同 (1, 2, 3, 4, 5)
(1.7..5.7)          # 同 (1, 2, 3, 4, 5)
(5..1)              # 空列表，因为 .. 只能正向计数
(0, 2..6, 10, 12)   # 同 (0, 2, 3, 4, 5, 6, 10, 12)
($m..$n)            # 范围由标量变量 $m 和 $n 的值来决定
(0..$#arr)          # 结束范围由 @arr 数组的最后一个元素的索引值确定

如你所见，你可以使用任何表达式来替代 beg..end 值。
当然，列表可以包含任何标量值，比如这个字符串列表：
("a", "b", "c", "d", "e", "f", "g")

qw 缩写
在 Perl 程序中，经常需要建立简单的单词列表（如上所示），这时大多数人都会比较反感这个逗号的书写，有点麻烦，其实 Perl 也可以像 Shell 那样，使用空格来分隔列表元素，那就是使用 qw 缩写，qw 是 quoted word 的缩写，见词识意即可，它表示加上引号的单词。使用 qw 改写如下，它可以让你打更少的字符：qw(a b c d e f)。

qw 中不能使用转移序列、变量引用，并且其中的空白符都会被丢弃，它们仅仅用来区分不同的列表元素，因此当列表比较长，且需要经常修改时，我们可以这么写：

qw (
    www.zfl9.com
    www.baidu.com
    www.google.com
);

当然，Perl 也允许你使用其它字符来替代圆括号，实际上，Perl 允许你使用任意标点符号作为定界符，常见的用法有：

qw! www.zfl9.com www.baidu.com www.google.com !;
qw/ www.zfl9.com www.baidu.com www.google.com /;
qw# www.zfl9.com www.baidu.com www.google.com #;

如果使用镜像字符（比如左括号，左花括号），那么其右边界必须使用对应的“右”字符，比如：

qw( www.zfl9.com www.baidu.com www.google.com );
qw< www.zfl9.com www.baidu.com www.google.com >;
qw[ www.zfl9.com www.baidu.com www.google.com ];
qw{ www.zfl9.com www.baidu.com www.google.com };

如果需要在被圈引的字符串中表示定界符，那需要使用反斜杠转义，但最好换过一种定界符，这才是好办法。如果需要表示反斜线本身，那么需要两个反斜线，这和单引号中的规则是一样的。

五种 Perl 引用语法

#!/usr/bin/perl5
# 5 种 Perl 引用(quote)，分隔符可以是任意符号（或镜像字符）
my $str1 = q/www.zfl9.com\twww.zfl9.com/;   # 单引号
my $str2 = qq/www.zfl9.com\twww.zfl9.com/;  # 双引号
my $regex = qr/.+/;                         # 正则模式 quote regex
my $cmd = qx@cat /etc/resolv.conf@;         # 外部命令 quote exec
my @lists = qw/zfl9 baidu google/;          # 字符串列表 quote word
say $str1;
say $str2;
say $regex;
print $cmd;
say "@lists";

转义正则模式中的元字符
如果需要将用户输入的字符串插入到现有正则表达式中，可以使用 quotemeta 操作符来转义字符串中的正则元字符（反斜线转义），注意是返回新字符串，不修改原串。

列表的赋值
就像标量值可以赋给标量变量一样，列表值也可以被赋值给变量：
($name, $age, $score) = ("Otokaze", 19, 120);
语法有点类似 JS 中的批量赋值法（原谅我不记得他叫什么官方名称了）。
左侧列表中的变量会被依次赋值对应的右侧列表中的值。相当于 3 次独立赋值操作。
是的，没错，在 Perl 中交换两个变量的值非常容易，只需 ($a, $b) = ($b, $a);。

那么问题来了，如果左右两边的列表元素数量不一致会发生什么呢？

• 如果右侧列表的元素多于左侧列表的元素，那么它们会被悄悄丢弃；
• 如果左侧列表的元素多于右侧列表的元素，那么它们被赋予 undef。
• 赋予 undef 是针对标量变量来说的，若为数组变量，则变为空列表。

明白了列表赋值，你便可以使用如下代码来构建字符串数组：

($rocks[0], $rocks[1], $rocks[2]) = qw(zfl9 baidu google);

不过，当你给整个数组赋值时，还有更简便的方法（实际上就是数组变量赋值）：

@rocks = qw/zfl9 baidu google/;     # 三个元素
@tiny  = ();                        # 空列表
@giant = 1..1e5;                    # 10000 个元素的列表
@stuff = (@giant, undef, @giant);   # 20001 个元素的列表
$dino  = "granite";                 # 字符串标量变量
@quary = (@rocks, "curshed", @tiny, $dino);

最后一项，quary 会变成拥有 5 个元素的列表，因为 tiny 没有元素，数组只能包含标量，因此数组中的数组实际上会被展开。因此不存在 C、Java 中的多维数组。你也可以方便的进行数组拷贝，即 @copy = @rocks;，拷贝的是数组元素，而不是引用。

push 和 pop 操作符
要新增元素到数组中，只需将它存储在更高的索引值的位置就行了，不过，真正的 Perl 程序员是不使用索引的，不像 C/C++、Java，Perl 中使用索引进行操作的性能略慢，因此尽量使用非索引的方式来操作数组。

我们常把数组当作堆栈（stack）来使用，比如在数组右侧添加新值或者删掉旧值，数组中的最右侧便是数组的最后一个元素，也就是拥有最大索引值的元素，我们常常对这个元素进行操作，Perl 提供了专门的函数。

pop 就是其中之一，它的作用是取出数组中的最后一个元素，并将其作为返回值返回：

@array = 5..9;
$fred  = pop(@array); # $fred 的值为 9，@array 则少了 9 这个元素
$other = pop(@array); # $other 的值为 8，@array 少了 8 这个元素
pop @array;           # @array 现在变为了 (5, 6)，7 被删掉了

最后一行是在空上下文（void context）中使用 pop 操作符，所谓的空上下文只不过是指返回值无可去处的一种说辞。这其实也是一种常见的用法，删除最后一个元素。

如果数组本来就是空的（没有元素），那么 pop 什么也不做，它直接返回 undef。

与此对应的操作符是 push，用于添加一个新元素到数组末尾。例如：

push(@array, 0);     # (5, 6, 0)
push @array, 8;      # (5, 6, 0, 8)
push @array, 1..10;  # @array 添加了 10 个新元素
@others = qw/ 1 2 3 4 /;
push @array, @other; # @array 又添加了 4 个元素

注意，push、pop 的第一个参数必须是一个数组变量，对一个列表进行 push、pop 没有意义（因为这仅仅是数组字面量，你操作后也得不到它的引用）。

unshift/shift 操作符
与 push/pop 相对的是 unshift/shift。它们分别用于插入/删除数组头部元素。

splice 操作符
push/pop、shift/unshift 都是针对数组首尾进行操作的，那么要在数组中间操作一些元素该如何呢？这正是 splice 操作符要做的事情。它最多可接收 4 个参数，最后两个是可选参数。第一个参数当然是要操作的数组，第二个参数是要操作的一组元素的起始位置，如果仅给出这两个参数，Perl 会把从给定位置到数组末尾的元素全部取出，并返回：

@array = qw( pebbles dino fred barney betty );
@removed = splice @array 2; # 弹出 @array 的 fred、bareny betty
                            # @array = qw( pebbles dino );
                            # @removed = qw( fred barney betty );

可以通过第三个参数来指定要弹出的元素长度，通过这个参数我们可以删除数组中间的一个片段，还是上面这个例子：

@array = qw( pebbles dino fred barney betty );
@removed = splice @array, 1, 2; # 删除 dino fred 两个元素
                                # @array = qw( pebbles barney betty );
                                # @removed = qw( dino fred );

第四个参数是要替换的列表（替换删掉的部分，长度可以不一样，因此可以往里面插入元素），相关的例子：

@array = qw( pebbles dino fred barney betty );
@removed = splice @array, 1, 2, qw( wilda );
# @array = qw( pebbles wilda barney betty );
# @removed = qw( dino fred );

实际上，如果要插入元素，你完全不用删除任何元素，即将它们设为 0，例子：

@array = qw( zfl9 baidu google );
splice @array, 1, 0, qw(souhu);
# @array = qw(zfl9 souhu baidu google);

字符串中的数组内插
和标量变量一样，数组变量也可以内插在字符串中，内插时，会在数组的每个元素之间自动添加分隔用的空格（事实上，分隔符是可以手动控制的，通过 $" 变量可修改）。

注意这么一种情况，为避免混淆，可以大胆的加上花括号（和 Shell 一样）：

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
use 5.026_002;
my @fred = qw(eating rocks wrong);
my $fred = "right"; # 我想打印 "this is right[2]"
print "this is $fred[2]\n";     # "this is wrong"
print "this is ${fred[2]}\n";   # "this is wrong"
print "this is $fred\[2]\n";    # "this is right[2]"
print "this is ${fred}[2]\n";   # "this is right[2]"

foreach 控制结构
foreach 循环用来逐项遍历列表中的元素，它和 Java 中的 foreach 类似，例如：

foreach $rock (qw/bedrock slate lava/) {
    print "one rock is $rock\n";
}

注意，$rock 其实是数组元素的引用，因此你可以在循环内部修改它的值，在外部这个修改仍然可见。比如这个例子：

# root @ arch in ~/workspace [9:13:48]
$ cat array.pl
#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
use 5.026_002;
my @array = qw(www.zfl9.com www.baidu.com www.google.com);
foreach my $elem (@array) {
    $elem = "\t$elem";
    $elem .= "\n";
}
print "\@array = (\n@array)\n";
# root @ arch in ~/workspace [9:13:50]
$ ./array.pl
@array = (
    www.zfl9.com
    www.baidu.com
    www.google.com
)

Perl 中的默认变量 $_
如果在 foreach 中没有定义控制变量（也就是那个 $elem），那么 Perl 会将这个值存储在默认变量 $_ 中，比如，它和上面的程序等价：

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
use 5.026_002;
my @array = qw(www.zfl9.com www.baidu.com www.google.com);
foreach (@array) {
    $_ = "\t$_";
    $_ .= "\n";
}
print "\@array = (\n@array)\n";

虽然 $_ 不是 Perl 中的唯一默认变量，却是最常用的一个。以后会看到，在许多情况下，当未告知 Perl 使用那个变量或数值时，Perl 都会自动使用 $_，从而避免程序员免于命名和键入新变量的痛苦。没错，这里的 print 就是一个例子。在没有参数时，她就会打印 $_ 的值。

$_ = "hello, world!\n";
print;

reverse 操作符
顾名思义，用来反转列表中的元素顺序，并返回一个新数组，注意它不会修改原数组，你需要将它赋值给原数组才能改变它。

@fred = 6..10;
@barney = reverse @fred;    # 10 9 8 7 6
@wilma = reverse 6..10;     # 10 9 8 7 6
@fred = reverse @fred;      # 翻转后放回原数组

sort 操作符
sort 用来对数组进行排序，默认是使用 Unicode 码点进行排序，小的在前。它也不会修改原数组。最后面的章节中，我们会使用自定义的排序方式，来使用 sort 对数组进行排序，现在先不提这个。

each 操作符
each 用来逐步遍历数组、哈希，在 Perl 5.12 版本之前，each 只能用于哈希，具体细节后面会提到。每次对数组调用 each，都会返回数组下一个元素对（索引值，元素值），请看例子，第一个使用 each，第二个使用 foreach，后者性能可能差一些：

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
use 5.026_002;
my @array = qw(zfl9 baidu google);
while (my($ind, $val) = each @array) {
    say("\@array[$ind] = $val");
}

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
use 5.026_002;
my @array = qw(zfl9 baidu google);
foreach my $ind (0..$#array) {
    say("\@array[$ind] = ${array[$ind]}");
}

标量上下文、列表上下文
这是本章最重要的一节，甚至可以说是本书中最重要的一节，这一点都不夸张。这并不是说这一节有多么难懂，它的概念很简单，同一个表达式出现在不同的地方有不同的意义。

这你应该不会陌生，因为在自然语言里，这种情况随处可见，比如一个人问你单词 read 是什么意思，你一定很难简单回答，因为用在不同的地方，它有截然不同的意思。除非你知道上下文（context），否则很难确认它的准确意义。

所谓上下文，可以理解为周围的语言环境，在 Perl 中，指的是你如何使用表达式。事实上，你已经看到过许多针对数字和字符串上下文的操作了。比如按照数字方式进行操作得到的就是数字结果，而按照字符串方式进行操作得到的就是字符串结果，起到这一决定性因素的正是："操作符"，而不是两边的操作数的数据类型。

我个人感觉这一点都不难理解，这其实就是 C 语言中的隐式自动类型转换。是的，就拿最简单的赋值语句来说，它分为 2 个部分，左边的操作数是变量（隐含着具体的数据类型），右边的操作数是数据本身。因此，将右操作数赋给左操作数时，必然会进行适当的数据类型转换，只不过这个适当的数据类型转换在 Perl 中显得有点不是那么适当，因为它的转换尺度有点大，比如你可以将一个列表数据赋值给一个标量变量，标量变量的值是该列表的长度。初次看到这种用法你可能会觉得不可思议，但是习惯后你会觉得这太正常不过了，因为 Perl 表现的很像人类语言，很智能，它几乎总是能够知道你要转换为什么数据类型，以及要如何进行转换。这要是放在 C 语言中，假设左操作数是 int 型，那么经过强制类型转换后，你得到的也只是这个数组的内存地址而已，而不是它的元素数目。

我说一下我的个人见解，发生这种转换操作基本上都是在“赋值表达式”（当然还有运算符的，运算符的比较好理解，一切都取决于运算符）中。那么赋值表达式的经典形式就是：variable = statement，statement 是一个 Perl 表达式，它的值可以是任意数据类型，但是赋值后，整个表达式的数据类型却只由 variable 的数据类型来决定，如果 variable 是标量，那么最终的表达式类型就是标量，如果它是列表，那么最终的表达式类型就是列表，等等，以此类推。

接着原文，当 Perl 在解析表达式时，你要么希望它返回一个标量，要么希望它返回一个列表（现阶段，后面的先不考虑哈），表达式所在的位置，Perl 期望得到什么，那就是该表达式的上下文（不好理解，至少我不理解）。原文例子（这个我倒理解）：

42 + something; # 这里的 something 必须是标量，如果不是会进行自动转换
sort something; # 这里的 something 必须是列表，如果不是会进行自动转换

又比如（运算符）：

@peple = qw( fred barney betty );
@sorted = sort @people; # 列表上下文，qw( barney betty fred )
$number = 42 + @people; # 标量上下文，42 + 3 = 45（数组长度）

又比如（赋值运算）：

@list = @people; # 数组拷贝
$len  = @people; # 数组长度

但请不要立即得出结论，认为在标量上下文中，列表返回的值一定是列表的长度，有很多能产生列表的表达式，所返回的东西可能比你想象中的还要丰富有趣。

不光如此，从我们积累的经验来看，仅仅通过对列表表达式形式上的判断是无法归纳出一个通用法则来的。每个表达式都可能有它特定的规则。所以实际上，能够概括的规则就是：那种上下文更有意义，就应该是用那种上下文。不过你不用太担心，因为 Perl 做出的选择往往就是你自己期望得到的结果。

在标量上下文中使用产生列表的表达式
有些表达式通常是用来产生列表的，假如在标量上下文中使用，结果会怎样？

某些表达式不会在标量上下文中返回任何值。比如 sort 在标量上下文中会返回什么呢？undef，注意它不是返回排序后的列表的元素个数。

另一个例子是 reverse，在列表上下文中，他很自然的返回逆序后的新列表，在标量上下文中，他返回逆序后的字符串（先将列表中的所有字符串连接在一起，然后倒转它们的顺序，返回它）。例子：

@backwards = reverse qw/yabba dabba doo/;
 # 得到 qw/doo dabba yabba/;
$backwards = reverse qw/yabba dabba doo/;
 # 得到 "oodabbadabbay"

刚开始学习 Perl 时，你可能很难看出某个表达式究竟是处于哪个上下文中（处于什么上下文，它的值就会被转换为该上下文的类型的值），不过，请相信我，你很快就会找到这种感觉，一眼就看得出来。之所以刚开始时看不出，很可能是其他语言的语法惯性导致的。

先来看一些常见的上下文：

$fred = something;              # 标量上下文
@pebbles = something;           # 列表上下文
($wilda, $betty) = something;   # 列表上下文
($dino) = something;            # 列表上下文

这一组全部都是标量上下文：

$fred = something;
$fred[3] = something;
123 + something;
something + 634;
if (something) {...}
while (something) {...}
$fred[something] = something;

这一组全部都是列表上下文：

@fred = something;
($fred, $barney) = something;
($fred) = something;
push @fred, something; # 因为函数参数，多个参数其实就是列表
foreach $fred (something) {...}
sort something;
reverse something;
print something; # 同样，因为函数参数

在列表上下文中使用产生标量的表达式
这种情况非常简单，Perl 会将标量包装为具有一个元素的列表。

@fred = 6 * 7; # (42)
@barrey = "hello" . "world";

不过，要注意：

@array = undef; # 这并不是清空了列表元素，得到的仅是用于一个 undef 元素的列表
@array = ();    # 这才是清空列表元素的正确姿势

强制指定标量上下文
偶尔，在 Perl 想要列表上下文的地方你想要强制引入标量上下文，可以使用伪函数 scalar，她并不是真正的函数，只不过是告诉 perl 这里要切换为标量上下文，但实际上，你很少需要使用这个关键字，相信我。

@array = qw(zfl9 baidu google);
$length = @array;        # 获取数组长度
$length = scalar @array; # 获取数组长度

3 种上下文类型

• Scalar Context：标量上下文，列表返回元素个数，哈希返回的值不太明确，可能是键值对数目，也可能是分数，分母是桶的数量，分子是存储了元素的桶的数量。如果要获取哈希的键值对数目，建议使用 my $len = keys %hash。
• List Context：列表上下文，标量返回具有一个元素的列表，哈希则被展开为列表（两倍的长度，每两个元素都是一对 key/value）。
• Void Context：空上下文，空上下文其实很好理解，比如一条语句 "test-string"; 并没有使用标量变量存储它，所以它会被悄悄丢弃，如果启用了警告功能，则 Perl 会发出警告信息。

如果是赋值操作那么很好判断上下文，因为只需要看左边的变量的类型就知道了；如果是将表达式当作函数的参数，那么毫无疑问就是列表上下文；如果是 if、while、for 条件判断语句，那么就是标量上下文（将其看作布尔值）；foreach 是列表上下文。

列表上下文中的 <STDIN>
这里纠正一个概念，我前面说 <STDIN> 只是获取 STDIN 的一行数据，其实不是这样的，当 <STDIN> 位于标量上下文时，返回的的确是一行数据，但是当他位于列表上下文时，它返回的确实有一行行数据组成的列表（类似 sed、awk 的操作）。

前面还介绍了 chomp 用来去掉标量字符串的末尾换行符，如果可以用来一次性去掉列表中的字符串的末尾换行符就最好了，是的，chomp 早就想到了这一点，例子：

@lines = <STDIN>; # 读取所有行，一行一个元素
chomp(@lines);    # 去掉每个元素的末尾换行符（如果有的话）

当然，更常见的是合在一起的写法：

chomp(@lines = <STDIN>); # 读取所有行，且剔掉末尾换行符

章节习题
1、编写类似 cat 的 Perl 程序（打印输入的内容）

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
use 5.026_002;
print(<STDIN>);

2、编写类似 tac 的 Perl 程序（反向打印输入的内容）

#!/usr/bin/perl -CSDA
use utf8;
use strict;
use warnings;
use 5.026_002;
print(reverse <STDIN>);

子程序

我们已见过且用过一些内置的系统函数，像 print、chomp、reverse 等。但是就如同其他语言一样，Perl 也可以让你创建子程序（Subroutine），也就是用户自定义的函数（子程序总是由用户定义的，而函数则不一定。所以我们通常不将其称为函数）。

子程序让我们可以重复利用已有的代码，子程序的名称也是 Perl 的标识符，因此只能以字母、下划线开头。有时候视情况会以“与号”（&）开头。关于何时可以省略以及何时必须加上这个放在标识符起前面的 & 号，本章最后一部分会进行介绍。若无其他声明，我们都将使用这个 &，这通常是比较保险的做法。当然也有不能用与号的情形，后面会提到，先别急。

子程序名属于独立的命名空间，这样 Perl 就不会将同一段代码中的子程序 &fred 和标量 $fred 搞混，虽然实际编程时没人会为两种不同的东西取一样的名字。

定义子程序

sub marine {
    $n += 1; # 全局变量 $n
    print "hello, sailor number $n\n";
}

子程序可以被定义在程序的任意位置，习惯 C 语言的可能会将子程序定义在文件的开头，也有人喜欢将它们定义在文件的末尾，从而是主体程序出现在开头部分。你可以随意使用任意一种风格，不管怎样，你都不需要对子程序进行事先声明。

子程序的定义是全局的，除非你使用一些特别的技巧，否则不存在所谓的私有子程序。假如你定义了两个重名的子程序，那么后面的哪个子程序会覆盖掉前面那个（你将子程序看作是普通的变量就容易理解了，这点和 JS 一样，哦，说反了，应该是 JS 借鉴的 Perl）。如果启用了警告信息，Perl 会告诉你的子程序有重复定义，一般来说，重名是不推荐的，这也会让程序员自己产生疑惑。

正如你在之前的例子中看到，你可以在子程序中使用任何全局变量。事实上，目前你见过的所有变量都是全局的，这意味着你可以在你的程序的任意位置访问这些变量。

调用子程序
你可以在任意表达式中使用子程序名（带上与号）来调用它（通常我们都会带上圆括号，哪怕是没有参数的空括号）：

&marine; # 打印 hello, sailor number 1
&marine; # 打印 hello, sailor number 2
&marine; # 打印 hello, sailor number 3

通常，我们把对子程序的调用称为呼叫（calling）子程序。除了上面的用法外，你还会看到其他的用法。通常我们会加上圆括号，不然你写的程序可能不会是你预想的那样。

返回值
函数当然是有返回值的了，上面的调用 marine 中，我们对它的返回值丢弃了，没有保存起来。很多时候，我们需要调用子程序，并对它的返回值进一步处理。所以我们需要在意子程序的返回值。

在 Perl 中，所有的子程序都有一个返回值。子程序并没有“有返回值”、“没返回值”之分。所有的子程序都是由返回值的。但并不是所有的 Perl 子程序都会返回有用的返回值。

既然任何 Perl 子程序都有返回值，那么规定每次都必须写 return 语句就显得很费事。所以 Perl 将它简化了，在子程序的执行过程中，它被不断进行运算，而最后一次运算的结果（不管是什么）都会被自动的当成子程序的返回值（可以理解为 Shell 中的命令的返回值作为函数的返回值），但我建议加上 return 语句，不要省略。

比如，我们定义下面这个程序，最后一个加法表达式就是子程序的返回值：

sub sum_of_fred_and_barney {
    print "something\n";
    $fred + $barney; # 这就是返回值
}

参数
这是理所当然的，要传递参数给子程序，只需将参数放在调用的括号里就行了。例如：$n = &max(10, 15);。参数列表将会被传入子程序，让子程序随意使用。当然得先将这个列表存在某处，Perl 自动将参数列表化名为特殊的数组变量 @_（和 JS 真的很相似啊），该变量在子程序执行期间有效，子程序可以访问这个数组，以判断参数的个数以及对应的值。

第一个参数存储于 $_[0]，第二个参数存储于 $_[1]，以此类推。存储参数的数组变量是 @_（注意他们的前缀字符哦）。一个简单的 max 子程序，返回较大的一个：

sub max {
    if ($_[0] > $_[1]) {
        return $_[0];
    } else {
        return $_[1];
    }
}

虽然你可以这么写，但是可读性就很差了，特别是代码多起来的时候。这个子程序还存在这么一个问题，&max 这个名字虽然既好听又简洁，但没有说明这个这个参数只能接收两个参数。多余的参数会被 max 子程序忽略，不足的参数也不会报错，只不过获取的是 undef 罢了，稍后我们将会告诉你如何写一个完整的 max 函数。

实际上 @_ 变量是子程序的私有变量（除非调用子程序的时候前面加了 & 号，且后面没有带上括号，这种情况下，@_ 数组会从调用者的上下文中继承下来，一般情况下这并不是好主意，但偶尔也能派上用场，所以建议始终给子程序调用加上圆括号，当然这对于内置函数也是一样的，不过也不是说一定不能这么做，有些时候还是有用的）。

假如已经有了全局变量 @_，则该变量在子程序调用前会先被存起来，并在子程序返回时恢复原本的值。这也代表子程序可以将参数传给其他程序，而不用担心遗失自己的 @_ 变量。这其实很容易理解，函数中的私有变量的优先级比外部变量高，这在绝大多数语言中都是适用的。

子程序中的私有变量
既然每次调用子程序时 Perl 都会给我们新的 @_，难道不能利用它构造私有变量吗？答案是可以。默认情况下，Perl 中的变量都是全局变量，也就是说，你可以在程序的任何位置访问它。但你随时都可以使用 my 操作符来创建私有变量，我们称之为词法变量（这个关键字我实际上已经使用了很久了），例子：

sub max {
    my($m, $x) = @_;
    return $m > $n ? $m : $n;
}

这些变量属于封闭语句块（花括号）中的私有变量，语句块之外的任意地方的 $m 和 $n 都完全不受这两个私有变量的影响。反过来也是，外部变量同样无法影响内部的私有变量。所以，我们可以将这个子程序放在任意一个 Perl 程序中，而不用担心与外部变量产生冲突。另外，Perl 允许最后一个语句可以没有分号，但是不建议滥用，最后在保持简短的代码时才会这样做。因此，Perl 中的形参名称都是在子程序中的第一行以这种形式声明。

变长参数列表
在真实的 Perl 代码中，常常把更长的（任意长度的）列表作为参数传给子程序。这延续了 Perl 去除不必要限制的理念。这个其实在 JS 中也有体现，可以传入任意长度的参数，不需要进行所谓的函数重载。

当然，通过检查 @_ 数组的长度其实也很容易确定参数的个数是否正确，比方说，我们可以将 &max 写成下面这样以确定参数的个数：

sub max {
    if (@_ != 2) {
        print "warning, balabala";
    }
    ...
}

上面的 if 判断是在标量上下文中使用列表表达式，来获取列表的元素个数，这个用法你应该在上一章节中看见过，不再复述。但实际上这种做法在 Perl 中并不常见，更多的做法是让子程序自动适应任意数目的参数。

改进的 &max 子程序
现在我们来改写 max 函数，让其能够接受任意数目的参数：

sub max {
    my $max = shift @_;
    foreach (@_) {
        if ($_ > $max) {
            $max = $_;
        }
    }
    return $max;
}
&max(1, 2, 3, 4);

空参数列表
即使超过 2 个参数，改进后的 max 子程序仍然可以得出期望的结果，那假如没有参数呢？会发什么事情？我们来分析一下，第一行，shift 可以处理空列表，它返回 undef，而 foreach 对于空列表它不会进入循环，因此直接执行 return 语句，所以最终子程序返回 undef。嗯看起来没有问题。

关于 my 词法变量
事实上，词法变量 my 可以用在任何语句块中内，而不仅限与子程序的语句块。这里说的语句块可以理解为一个花括号，因此，my 将这些变量的作用范围限定在包含它们的花括号内部。

需要注意的是，my 加括号和不加括号是有区别的，请看：

my($num) = @_; # 列表上下文，同 ($num) = @_;
my $num  = @_; # 标量上下文，同  $num  = @_;

my 在不加括号时，只能用来声明后面的一个变量，必须使用括号才能声明多个变量：

my $fred, $bareny;  # 错，没有声明 $bareny
my($fred, $bareny); # 声明了 $fred、$bareny 

除了标量外，还可以声明数组、哈希等变量。所有的新变量的值一开始都是空的，标量是 undef，列表是空列表（注意，数组没有 undef 这种值，只有空数组，非空数组，空数组本身就是 false，非空数组为 true）。

在日常编程中，你最好时时刻刻带上 my，将变量的作用域限制在最内层的花括号内，以免发生冲突。特别是当你启用了严格模式后，这是必须要做的事情！

use strict 编译指令
Perl 是一门相当宽容的语言，但你也许希望 Perl 能更严格一些，多一点约束力（就像 Java 一样），要达成这一点，不妨试试 use strict 编译指令。

所谓编译指令，其实不过是给编译器的某些暗示，告诉它该如何处理接下来的代码。这里的 use strict; 编译指令是要告诉 Perl 编译器接下来的代码应该稍加严谨一些，遵循一些优良的编程风格。

最好的方法是，在 /usr/bin 下创建一个 perl5 可执行文件，然后将下面的内容放进去，以后在 Perl 脚本第一行使用 #!/usr/bin/perl5 就可以了，一劳永逸：

#!/bin/sh
exec perl -CSDA -Mutf8 -Mstrict -Mwarnings -M5.026_002 "$@"

return 操作符
如果想在子程序执行一半时停止，该怎么办呢？这正是 return 做的是，它会使当前子程序立即返回（同时附带可选的返回值）。若为 return;，则表示 return undef;。

#!/usr/bin/perl5
my @names = qw/ zfl9 baidu google taobao tencent wikipedia /;
my $result = &find_element_index("google", @names);
say $result;
sub find_element_index {
    my ($elem, @array) = @_;
    foreach (0..$#array) {
        if ($elem eq $array[$_]) {
            return $_;
        }
    }
    return -1;
}

省略 & 号
原文有点多，我总结一下：

• 不带 &：Perl 会优先调用内置函数，如果发生重名那可能不是你想要的；
• 带上 &：明确告诉 Perl，我想调用的是自定义的子程序，而不是内置函数。

所以，对于内置函数，不要带上 &，对于自定义子程序请带上 &，这是编码规范！并且强烈建议调用子程序时带上圆括号，即使没有参数要传递，否则子程序的 @_ 将会从调用者的上下文中继承它的值。

持久性私有变量
在子程序中可以使用 my 创建私有变量，但每次调用这个子程序时，这个私有变量其实都是重新分配的内存（调用栈是全新的）。而如果使用 state 操作符来声明变量，我们便可以在子程序的多次调用之前保持该变量的值，并且将该变量的作用域限制在子程序之内。也即 持久性私有变量。可以理解为加了 static 修饰符的 my。例子：

#!/usr/bin/perl5
sub static_increment {
    state $cnt = 0;
    ++$cnt;
    say("\$cnt = $cnt");
}
&static_increment();
&static_increment();
&static_increment();

注意，Perl 只会在第一次执行子程序 static_increment 时运行 state $cnt = 0; 这条语句，此后都是直接跳过，不然 $cnt 是不会继续递增的，因为每次调用都被重置为 0 了。这和 C/C++ 中的 static 关键字很像，或者说它就是 static 关键字。

习题
1、写一个计算输入参数之和的子程序，它可以接收任意个参数：

#!/usr/bin/perl5
sub total {
    my $sum;
    foreach (@_) {
        $sum += $_;
    }
    return $sum;
}
my @fred = qw/ 1 3 5 7 9 /;
my $fred_total = &total(@fred);
print("The total of \@fred is $fred_total\n");
print("Enter some numbers on separate lines: ");
my $user_total = &total(<STDIN>);
print("The total of these numbers is $user_total\n");

2、使用之前的子程序，计算从 1 加到 1000 的总和：

#!/usr/bin/perl5
sub total {
    my $sum;
    foreach (@_) {
        $sum += $_;
    }
    return $sum;
}
my $total = &total(1..1000);
print("1 + 2 + 3 + ... + 1000 = $total\n");

3、写一个名为 above_average 的子程序，当给定一个包含多个数字的列表时，返回其中大于这些数的平均数的数。（提示：另外写一个子程序，用于计算这些数的平均数），然后使用以下程序验证：

#!/usr/bin/perl5
sub average {
    my $sum;
    foreach (@_) {
        $sum += $_;
    }
    return $sum / @_;
}
sub above_average {
    my $average = &average(@_);
    my @greater = ();
    foreach (@_) {
        if ($_ > $average) {
            push @greater, $_;
        }
    }
    return @greater;
}
my @fred = &above_average(1..10);
print "\@fred is @fred\n";
print "(Should be 6 7 8 9 10)\n";
my @barney = &above_average(100, 1..10);
print "\@barney is @barney\n";
print "(Should be just 100)\n";

4、写一个名为 greet 的子程序，当给定一个人名作为参数时，打印出欢迎它的信息，并告诉它上一个人的名字。如果是第一个人，则告诉他你是第一个来宾。

#!/usr/bin/perl5
sub greet {
    state $last;
    my $name = $_[0];
    say("hello, $name");
    if (!defined($last)) {
        say("you are first!");
    } else {
        say("last is $last");
    }
    $last = $name;
}
&greet("zfl9");
say("");
&greet("baidu");
say("");
&greet("google");

5、修改之前的程序，告诉新来的人之前到来的人都是谁。

#!/usr/bin/perl5
sub greet {
    state @last;
    my $name = $_[0];
    say("hello, $name");
    if (!@last) {
        say("you are first!");
    } else {
        say("last is @last");
    }
    push @last, $name;
}
&greet("zfl9");
say("");
&greet("baidu");
say("");
&greet("google");

输入与输出

行输入操作符 <STDIN>
读取标准输入流非常容易，我们在前面已经用过行输入操作符 <STDIN>，在标量上下文中执行该操作时，将会返回 stdin 的下一行，而在列表上下文中执行该操作时，将一行一行的读取 stdin，每行一个元素，存储在列表中。建议使用标量上下文的读法，因为如果文件很大，效率和内存占用那是一个天一个地。

$line = <STDIN>; # 读取一行
chomp($line);    # 去掉末尾的换行符
# or
chomp($line = <STDIN>); # 简写用法，常用

如果读到文件末尾（EOF），行输入操作符则返回 undef，这样的设计是为了配合循环使用，以跳出循环体：

while ($line = <STDIN>) {
    print "input: $line";
}

当读到 EOF 时，$line 为 undef 值，也就是 false，所以会跳出 while 循环。但是，Perl 允许我们写得更见简便，如下：

while (<STDIN>) {
    print "input: $_";
}

它完全与前一个程序相同，只不过 perl 将读到的输入行放在了默认变量 $_ 中而已。你可能注意到了我们没有加上 chomp，后面你会看到，chomp 一般不加在循环条件中，而是放在循环体的第一行，因为可以使用默认参数 $_。

如果在列表上下文中调用了行输入操作符，那么它会返回一个列表，其中包含所有的输入内容，每个元素都是其中的一行字符串。比如 foreach 就是典型的列表上下文：

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

foreach 的行为和 while 的一样，不是吗？二者的不同之处在于它们背后的运作方式。在 while 循环中，Perl 会读取一行，然后把它存入默认变量 $_，接下来，它会回头继续读取下一行，重复这些步骤。而 foreach 循环中，行输入操作符会一次性读取所有输入，然后再循环这个列表，所以如果读取一个 400M 的日志文件，那么它们的差异非常明显。所以，始终建议使用 while 来读取标准输入。

来自钻石操作符 <> 的输入
还有一种类似 Unix 工具的读取方式（假设指定了文件，则从文件中读取，否则从标准输入读取，比如 cat 命令就是这样），这个操作符就是钻石操作符：<>。当然，如果指定的文件为 -，则也是从标准输入读取，这和 cat 一样。当然，Perl 当然可以处理多个文件，它们会被当作一个文件处理，依次被钻石操作符读取，最后 EOF 结束。

while (<>) {
    chomp;
    print("input: $_\n");
}

其实可以不用 chomp，这里之所以这么做，是想告诉你，默认参数在其作用。如果没有指定参数，那么内置函数会使用当前上下文中的 $_。自定义子程序通常不这么做（之前的一个结论可能有问题，我现在尝试后，发现必须显示传递参数才能正常工作）

命令行参数
从技术上来讲，钻石操作符其实不会去检查命令行参数，它的参数只不过是来自 @ARGV 数组。这个数组是 Perl 解释器事先建立的特殊数组，其内容就是由命令行参数组成的列表。换句话说，他与普通的数组没有区别，只不过他的名称是大写的而已。

注意，Perl 中没有所谓的 $ARGC 标量变量，并且 $ARGV[0] 也不是当前的程序名称，它存储在特殊变量 $0 中。这是与 C/C++ 程序不同的地方。

你可以像使用其他数组一样使用 ARGV 数组，你可以把其中的元素 shift 出去，或者使用 foreach 来遍历命令行参数。你也可以检查参数是否以 - 开头，然后将它视为程序的运行选项。当然，这仅适用于少量参数，如果想更优雅的处理命令行参数，请使用 Perl 的内置模块：Getopt::Long、Getopt:Std。

钻石操作符会查看 @ARGV 数组，然后决定该用哪个文件名，如果他找到的是空列表，他就会该用标准输入流，否则它就会使用列表中的文件的输入流。也就是说，你可以手动操控 ARGV 数组，来改变钻石操作符的行为。

输出到标准输出
print 操作符会读取列表中的所有元素，并把每一项（当然是一个字符串）依次送到标准输出。它的每一项之前、每一项之后都不会加上其他额外的字符（当然这是默认情况，实际上你可以修改 $" 变量，它的意思是列表元素的分隔符）。

注意，直接打印数组，和进行字符串内插的效果是不同的：

my @arr = 1..5;
say @arr;   # "12345"
say "@arr"; # "1 2 3 4 5"
$" = "_";
say @arr;   # "12345"
say "@arr"; # "1_2_3_4_5"

一般情况下，程序的输出结果会先送往缓冲区，也就是说，不会每当有一点点输出就会直接送出去。而是先积攒起来，知道数量足够多时才会访问外部设备，然后发送出去。

这个积攒的地方就叫缓冲区，之所以这样做是因为效率，一般，都是等缓冲区满了，或者程序结束了，缓冲区中的数据才会发送给设备。print 就是用了缓冲区，如果需要立即显示，你可以查看 Perl 的文档，进一步了解如何控制缓冲区。

由于 print 处理的是带打印的字符串列表，因此它的参数是在列表上下文中执行的，而钻石操作符、行输入操作符在列表上下文中会返回有许多行组成的列表，所以他们可以彼此配合工作：

print <>;      # 相当于 cat 命令
print sort <>; # 相当于 sort 命令

虽然 Unix 上的 cat、sort 还有许多额外的功能上面两行代码无法做到的，但是这绝对物超所值，你基本上可以使用 Perl 来重写绝大部分 Unix 工具程序，充分发挥 Perl 正则表达式的优势。

有个比较不明显的问题，那就是 print 后面可有可无的括号，这可能会令人糊涂，别忘了 Perl 的一条规则：除非这样做会改变表达式的意义，否则 Perl 的括号都是可以省略的。不过 Perl 还有一条规则：假如 print 的调用看起来像函数调用，它就是一个函数调用。这个规则很简单，但是“看起来像函数调用”是什么意思呢？

在函数调用中，函数名后面必须紧跟着一对圆括号，里面包含了参数（即使没有参数，也是空的圆括号），如 print(1 + 2)，这看起来像函数调用，所以他的确是一个函数调用。他会输出 3。和其他函数一样返回值，print 的返回值不是真就是假，代表 print 是否成功运行。除非发生 IO 错误，否则 print 一般都是成功调用的。

如果你使用这种方式来调用 print：print (2+3)*4，Perl 解释器看到这条代码，它实际上是这样理解的：(print(2+3)) * 4，也就是说，拿 print 的返回值与 4 相乘，然后返回给 void context。所以建议始终加上圆括号，除非是简单情况，比如打印一个标量。

实际上，这条规则：“假如他看起来像函数调用，他就是一个函数调用”，不仅对 print 适用，对其他 Perl 的列表函数也适用。只不过 print 是最常见的也是最引人注意的罢了。

用 printf 格式化输出
你也许习惯了 C 语言中的 printf() 格式化输出函数，别担心，Perl 中也有同名的 printf 函数提供类似的功能。printf 操作符的参数包括“格式化字符串”、“要输出的数据列表”。用法和绝大多数 printf 函数一致。例如：

printf "name: %s, age: %d, score: %.2f\n", "Otokaze", 19, 120.5;
# 输出："name: Otokaze, age: 19, score: 120.50"

每个格式控制符都以 % 开头，然后以某个字母结尾（这两个字符之间可以有额外的有效字符，实现更细致的格式化输出）。而后面的列表的元素数目和 % 符号的数目是一致的（一般，除了转义的之外）。

printf 的格式控制符有很多，基本上都与 C 语言中的 printf 一致。比如字符串是 %s、十进制整数 %d、浮点数%f、如果要让 printf 自动选择合适的数字格式，可以使用 %g，如果要输出 % 本身，请使用 %% 来进行转义，而不是 \%。

数组和 printf
一般来说，你不会将数组当作 printf 的参数，因为数组可以包含任意多个元素，而 printf 的元素格式都是由格式字符串决定的。不过，没有人规定你不能在程序运行时动态产生格式字符串，它可以是任意表达式，因为 Perl 会根据上下文来将其转换为字符串。不过要做的正确还是需要一点技巧的：

my @items = qw/zfl9 baidu google/;
my $format = "The items are:\n" . ("%10s\n" x @items);
printf $format, @items;

在 ("%10s\n" x @items) 中，因为 @items 位于标量上下文，所以它会被转换为数组的长度，然后整个表达式会产生数组长度个 %10s\n，即 %10s\n%10s\n%10s\n，然后和前面的字符串拼接在一起，最后使用 printf 进行格式化输出。当然，还可以将他们合在一起，这样更见简便：

printf "The items are:\n".("%10s\n" x @items), @items;

之所以可以这样做，是因为上下文的关系，前一个 items 位于标量上下文，所以它的值其实是列表的长度，而后一个 items 位于列表上下文，所以 printf 可以一次性获取列表的元素。因此要时刻灵活应用上下文来进行数据类型的转换，写出更精简的代码。

使用 say 输出数据
say 其实是 Perl 6 中的功能，不过 Perl 5.10 从 6 中借来了这个函数，它的功能和 Java 的 println 差不多，就是自动在输入数据中加入换行符。但是，因为这是 Perl 5.10 的新功能，所以必须使用一个编译指令来启用新特性，比如 use v5.26.2;。

文件句柄
文件句柄（filehandle），在 Unix 中我们喜欢称之为文件描述符 FD。其实就是 Perl 程序打开的一个文件的抽象表示，但是并不等于说一个 FD 就等于一个文件，因为一个文件实际上可以打开多次，每次打开获得的都是不同的文件描述符，这个可以和网络连接联系在一起，因为同一时间可以有多个客户端连接到服务器，获取资源。你可以将文件描述符理解为一个网络连接。一个文件可以有多个网络连接，它可以被同一个进程所拥有，也可以分别被不同的进程所拥有。

在 Perl 5.6 之前，所有的文件句柄名称都是裸字（bareword），而从 Perl 5.6 起，我们可以把文件句柄的引用放在常规的标量变量中。我们先展示裸字写法，因为许多特殊文件句柄向来习惯使用裸字，稍后我们再介绍放在标量变量里的文件句柄的用法。

给文件句柄起名就好比给 Perl 的其他标识符起名一样，必须以字母、下划线开头，然后接字母、数字、下划线。由于裸字没有任何前置字符，所以当我们阅读它时，有的时候可能会与现在会将来的保留字相混淆，或是第十章中将要介绍的标签（label）相混淆。所以在一次，Larry 建议你使用全大写的字母来命名文件句柄。这样不仅看起来更加明显，也能避免与小写的保留字相混淆，以免程序出错。

有 6 个文件句柄名是 Perl 保留的，它们是：STDIN、STDOUT、STDERR、DATA、ARGV、ARGVOUT。虽然你可以选择任何喜欢的文件句柄名，但不应使用保留字，除非确实需要以特殊方式适用上述 6 个文件句柄。

• STDIN：标准输入流，有缓冲区
• STDOUT：标准输出流，有缓冲区
• STDERR：标准错误流，无缓冲区
• ARGV：命令行参数列表（不包含程序名称）

打开文件句柄
到目前为止，你已经看到过 3 种 Perl 默认打开的文件句柄 STDIN、STDOUT、STDERR。它们都是由 Perl 的父进程（通常是 Shell）自动打开的文件或设备。当你需要其他文件句柄时，请使用 open 操作符，来看你个具体的例子：

open CONFIG, 'dino';
open CONFIG, '<dino';
open BEDROCK, '>fred';
open LOG, '>>logfile';

第一个和第二个是一样的，但是推荐使用第二种，一看就明白是以只读方式打开 dino 文件，并将对应的文件句柄命名为 CONFIG。注意到没有，其实 Perl 中的文件打开方式和 Shell 真的很像，比如 < 为只读方式打开，> 只写方式打开、>> 追加方式打开。除此之外还有 +< 读写方式（读为主，写为辅）、+> 读写方式（写为主、读为辅）、+>> 读写方式（追加为主，读为辅）。当然，默认情况下，它是以文本模式打开的，你也可以以二进制文件方式打开，只需在 open 操作符中，加入一个参数 raw（稍后会介绍）。

之所以第一种和第二种的效果是一样的，是因为 Perl 的文件打开方式默认为只读。之所以这样做有一部分是因为安全原因，因为防止用户手误以只写方式打开一个系统重要文件，而导致系统出问题（特别是以 root 用户运行 Perl 脚本时更是这样）。

在 Perl 5.6 之后，open 操作符还有一种 3 个参数形式的写法：

open CONFIG, '<', 'filename';
open CONFIG, '>', 'filename';
open CONFIG, '>>', 'filename';

推荐使用这种方式，因为更清晰，也更安全。除此之外，还可以加上额外的打开细节，比如文件的字符编码，是否以二进制方式打开，等等。比如：

open CONFIG, '<:encoding(UTF-8)', 'filename';
open CONFIG, '>:encoding(UTF-8)', 'filename';
open CONFIG, '>>:encoding(UTF-8)', 'filename';

当然，我们还有更加简便的方法，不需要键入 :encoding(UTF-8)，只需 :utf8：

open CONFIG, '<:utf8', 'filename';
open CONFIG, '>:utf8', 'filename';
open CONFIG, '>>:utf8', 'filename';

但这两种方式并不完全相同，前者是建议 Perl 以 UTF-8 编码操作文件，而后者是强制 Perl 以 UTF-8 编码操作文件。所以如果文件的编码不是 UTF-8，那么第一种方式可能不会使用 UTF-8 模式打开，而后者则仍然以 UTF-8 的解码规则来尝试读取。尽管如此，仍然很多人喜欢使用第二种方式，可能大家都比较懒吧，不想多打几个字。

不过，其实 Perl 一种一劳永逸的方法，那就是通过 Perl 命令行参数指定 Perl 的默认文件打开方式的编码为 UTF-8，具体的参数是 -C，用于指定 Unicode 的相关属性。其中 S 值表示将 STDIN、STDOUT、STDERR 以 UTF-8 方式打开，D 表示将 Perl 的 open 的默认文件编码设为 UTF-8，A 表示将 ARGV 命令行参数的字符编码设为 UTF-8。建议都打开，这样在一定程度上可以避免乱码问题的出现。

二进制方式打开文件句柄
书中介绍的方法是使用 binmode 关键字，不过我更建议使用 open 操作符的内置属性 raw 来打开二进制文件（默认是以文本方式打开的），例子（不过基本上用不到）：

open FILE, '<:raw', '/usr/bin/bash';
open FILE, '>:raw', '/usr/bin/bash';
open FILE, '>>:raw', '/usr/bin/bash';

有问题的文件句柄
当然，你不能保证当前系统中一定用于程序中指定的文件，很有可能它不存在，或者是 Perl 进程的权限不足。如果试着对有问题（就是未打开成功的文件句柄）的文件句柄读取数据，那么会立即返回 EOF，EOF 在标量上下文中表现为 undef，在列表上下文中表现为空列表（注意是空列表，说明列表存在，但是里面没有元素）。如果尝试对问题句柄写入数据，那么这些数据会被无声的丢弃。

幸好，这种可怕的情况能轻易避免，如果你设置了 -w 选项，或者使用了 warnings 编译指令，那么在用到有问题的文件句柄时，Perl 会发出警告。但即使没有启用警告功能，open 的返回值也能告诉我们有没有打开成功。返回 true 表示打开成功，false 表示打开失败。所以，程序可以写作这样：

if (! open FILE, '<', '/etc/resolv.conf') {
    # open 打开失败
}

关闭文件句柄
当你不需要某个文件句柄时，请务必使用 close 操作符关闭它，open 的数量与 close 的数量应该是相同的：close FILE;。所谓关闭文件句柄，就是释放了这个文件描述符。当然如果使用 open 打开一个已打开的文件句柄，Perl 会先关闭它，然后再打开。在程序结束时，Perl 也会自动关闭打开的文件句柄（在正常关闭的情况下）。

尽管如此，还是建议手动关闭文件描述符，特别是长时间运行的脚本，如果未及时关闭，可能导致其他尝试读取指定文件的进程长时间阻塞，这通常不是管理员想要的。

用 die 处理致命错误
先让我们岔开一下话题，当 Perl 遇到致命错误时（如：除零、非法正则表达式、调用未定义的子程序等），你的程序都会立刻停止运行，并打印错误信息已告知原因。这样的功能可以使用 die 实现，它能让我们手动触发一个致命错误，让程序终止运行。

die 函数会输出你指定的信息到标准错误流，并且让你的程序以非零退出码结束运行。所以，我们上面的程序可以改写成这样：

if (! open LOG, '>>', 'logfile') {
    die "Cannot open logfile: $!";
}

如果 open 失败，那么就会运行 die 语句，然后会触发一个致命错误，导致 Perl 结束运行。你可能注意到了，$! 应该是错误信息，它的值其实就是 C 语言中的 perror 获得的字符串。而这个错误的解释字符串就存放在 $! 变量中。不过，如果你只是想使用 die 来结束运行 Perl 程序，而不想输出 $! 错误信息，那么请不要加上它。

同时，die 还会为您做一件事，那就是自动在这个错误行中加上 Perl 的程序名和 die 所在的行号。因此你可以轻易判断出程序的那个 die 导致的致命错误。这非常有用，不过有些时候你可能并不想 Perl 这么做，比如判断命令行参数格式时，就不需要告诉用户是那一行出了错误。要禁用 Perl 这个自动行为也很简单，只需在 die 的错误信息行尾部加上换行符（你注意到没，上面的字符串尾部没有换行符）。

用 warn 发出警告信息
正如 die 函数产生一个致命错误一样，warn 函数用于产生一个警告信息，warn 和 die 的语法和用法都差不多，区别是 warn 不会结束运行。warn 默认也是会带上程序名和行号的，使用同样的方法可以关闭这个自动行为。die 和 warn 都将错误/警告信息发完标准错误流。

使用 autodie 自动检测错误
从 Perl 5.10 开始，为人称道的 autodie 编译指令已经成为了标准库的一部分。autodie 的工作很简单，就是自动检测程序运行时的致命错误，然后自动调用 die 来结束运行，释放程序员的双手，写出更加优美的代码，而不用时刻考虑 die 函数。即：

use autodie;
open FILE, '<', 'nosuch.file';
print "something someting something\n";

因为 open 尝试打开一个不存在的文件，autodie 会自动检测到这个错误（可能是通过返回值，或者是其他的钩子之类的），然后自动调用 die 结束运行，并告知用户。

修改 /usr/bin/perl5 包装脚本，来默认启用 autodie 编译指令，如下：

#!/bin/sh
exec perl -CSDA -Mutf8 -Mstrict -Mautodie -Mwarnings -M5.026_002 "$@"

使用文件句柄
一旦获得文件句柄后，我们就可以通过它来 读取、写入 数据了。常用的读取操作符就是 行输入操作符 - <FILEHANDLE>，常用的写入操作符就是 print、printf、say。

行输入操作符前面已经演示过很多次了，只不过使用的文件句柄都是 STDIN，现在我们可以换为我们打开的文件句柄，比如 FILE。而 print、printf、say 要往文件句柄中写入数据也很简单，只需在他们后面加上 FILE 就可以了，比如：

open FILE, ">", "test.log";
print FILE "www.zfl9.com\n";
printf FILE "www.zfl9.com\n";
say FILE "www.zfl9.com";

注意，FILE 和其他参数之间是没有逗号的，不然 print、printf、say 无法分清这是文件句柄还是要输出的变量，所以这两种写法都是没有问题的：

print (FILE "www.zfl9.com\n");
print FILE ("www.zfl9.com\n");

改变默认的文件输出句柄
默认情况下，如果你不为 print、printf、say 指定文件句柄，那么它们默认使用 STDOUT 这个文件句柄，也就是将输出打印到标准输出流。不过，你可以使用 select 操作符来改变默认的标准输出流文件句柄，比如改为 FILE：

select FILE;
print "www.zfl9.com\n";
printf "www.zfl9.com\n";
say "www.zfl9.com";

print、printf、say 都是默认写入到 FILE 对应的文件中。不过这么做可能会让程序变得混乱，所以这并不是一个好办法，除非你的程序很简短，用来完成临时的任务，所以，在使用 select 修改后，建议还原为原本的 STDOUT。

将数据输出到文件句柄时，默认情况下都是使用了缓冲区的，Perl 允许你改变这个默认行为，修改 $| 变量，将它的值设为 1，以禁用缓冲处理，每次调用 print、printf、say 都是直接发往设备的。这在需要实时显示日志的程序中很有用。比如：

select LOG;
$| = 1;   # 不要将 LOG 的内容保留在缓冲区
select STDOUT;
print LOG "www.zfl9.com\n";

重新打开文件句柄
前面提到，如果使用 open 打开一个同名的文件句柄（该句柄已打开），那么 Perl 会自动关闭它，然后重新打开新指定的文件，因此，我们可以利用这个特性来重定向 STDIN、STDOUT、STDERR。比如：

if (! open STDERR, ">>/var/log/test.log") {
    die "$!";
}

如果打开成功，则不执行 die 语句，如果打开失败，则执行 die 语句，因为没有打开成功，所以此时 STDERR 没有被重打开，所以这个错误信息还是默认发往屏幕的。

使用标量变量存储文件句柄
从 Perl 5.6 开始，我们已经可以使用标量变量存储文件句柄了，而不必使用裸字。别看这一小小的差别，带来的好处还是很多的。成为标量变量后，我们可以为文件句柄使用 my 修饰，限制它的作用域。而且不必再使用全大写的名称，这样可能更优美一些。

open my $file_fd, '<', 'test.log';

原来使用裸字的地方，现在全都可以使用标量变量替代（记得加上美元符号哦）。

习题
1、写一个和 tac 功能相似的程序（与 cat 相对，反序输出文件内容），它可以处理命令行参数指定的文件，如果没有，可以处理标准输入流中的数据。

#!/usr/bin/perl5
print reverse <>;

2、写一个程序，提示用户输入一些字符串（一行一个），然后分别以 20 个字宽，右对齐方式打印这些字符串，并且在顶部打印一个简单的标尺行，以简单判断是否正确：

#!/usr/bin/perl5
say "1234567890" x 5;
say "Enter something:";
foreach (<STDIN>) {
    chomp;
    printf "%20s\n", $_;
}

3、修改上一个程序，让用户自动选择字符宽度，另外，标尺行的长度要根据用户指定的宽度自动伸缩在合适的长度：

#!/usr/bin/perl5
use POSIX;
print "Enter character width: ";
chomp(my $width = <STDIN>);
chomp(my @inputs = <STDIN>);
say "1234567890" x ceil($width / 10);
foreach (@inputs) {
    printf "%${width}s\n", $_;
    # or C language style
    # printf "%*s\n", $width, $_;
}

哈希

什么是哈希
awk 中也有哈希这种数据结构，Perl 也是从 awk 中借鉴如来的，不过据书中介绍，Perl 的哈希实现更高效，不会因为键值对数目多起来而降低运行速度（难道这不是所有哈希实现必须要有的特点吗？因为访问哈希时，提供的 key 只需进过一次映射操作就能直接找到对应的 value，这其实和数组很相似，数组的 key 其实就是下标，而这个映射操作就是内存地址的计算，因为数组的元素之间是紧密放在一起的，而数据类型又是固定的，所以很容易知道哪个 key 对应的 value 是什么，哈希的基本原理也是如此，只不过哈希的 key 不再是简单的 int 类型了，而是 String 字符串类型，也就是说我们可以给 value 起一个有意义的 key 名称，还有一点，哈希表的 value 可以是任意类型，因为不需要依靠数据类型的长度来确定元素的内存地址）。

因为哈希使用 key 来存储 value，而 key 又是字符串类型，所以很容易知道，key 的字符串是不能重复的，否则它将会覆盖原有的值。这和数组下标不能重复是一个道理。

为什么使用哈希
1、按主机名找 IP 地址
2、按 IP 地址找主机名
3、按单词统计出现的次数
4、按用户名统计使用的磁盘配额
5、按驾驶证号索引处驾驶员姓名
可以将哈希理解为一个简单的数据库，每个键都是唯一的。

访问哈希元素
访问哈希变量的语法为：

$hash{$key}

这和访问数组非常相似，只不过使用花括号替代了方括号，而其中的索引值也被替换为了字符串 key。比如：

$family_name{'fred'}   = 'zfl9';
$family_name{'barney'} = 'baidu';

这就允许我们写出这样的代码：

foreach my $person (qw/fred barney/) {
    say "$person name: $family_name{$person}.";
}

哈希变量的命名和其它变量的命名规则一样，以字母、下划线开头，后可接字母、数字、下划线。给哈希元素赋值时，如果对应的 key 不存在，则创建，然后存储传入的 value，如果已存在，则覆盖原有的值。总之，它和 Java 中的 HashMap 行为一致。

访问不存在的 key 会得到 undef 值。这和数组很相似，再次强调一点，哈希其实就是数组的高级版，数组使用的 key 是连续的纯数字，而哈希使用的 key 是任意唯一的字符串。

访问整个哈希
哈希的前置字符其实是 %，如果哈希的名称为 table，那么变量名为 %table。

为了方便起见，列表可以直接转换为哈希，反之亦然。对哈希赋值等同于在列表上下文中赋值，列表中的元素数目应该是偶数个，因为每两个元素都是一个键值对。反之，将哈希转换为列表时，里面的元素数目也是偶数个，每两个元素都是一个键值对。

从哈希变为列表的过程，我们称之为展开（unwinding）哈希。因为哈希的数据结构特性，哈希展开后的键值对顺序可能被打乱。但是每个键值对的相对顺序是固定的。

哈希赋值
现阶段中，我们接触到的 Perl 赋值表达式其实都是内存的拷贝，因为我们还没接触到引用的概念。因此，我们可以利用赋值操作符来进行任意数据的拷贝（拷贝构造函数）

my %copy = %hash;

这里 Perl 做的工作比看到的复杂得多，不想 C 语言中的复制操作符仅仅是进行简单的内存拷贝，Perl 的数据结构比较复杂（因为太灵活了，要考虑的东西很多），大致上，这行代码先把哈希展开为列表，然后通过列表赋值产生新的哈希元素。

又比如，创建一个反序（不要立即下定论，非一般反序）的哈希副本：

my %reverse_hash = reverse %hash;

这会将 %hash 展开为列表（(key, value, key, value, ...)），然后利用 reverse 操作符，将 key 与 value 的位置兑换，即 (value, key, value, key, ...)，也就是说之前的 value 变成了 key，而之前的 key 变成了 value。敏锐的读者已经猜到了这种技巧只在哈希 value 不重复的情况下有用，否则某些 key 会被消失（被覆盖了）。

胖箭头
将列表赋值给哈希时，常常会发现列表中的键值对不容易区分（容易看花眼），于是作者发明了 => 符号，胖箭头符号。之所以不使用瘦箭头 ->，是因为在引用中有用（类似 C 语言中的结构体指针取值法）。

对于 Perl 而言，他只是逗号的另一种写法，因此常称他为胖逗号。因此可以这样写：

my %hash = (
    'zfl9' => 'www.zfl9.com',
    'baidu' => 'www.baidu.com',
    'google' => 'www.google.com',
);

注意，最后一项有一个额外的逗号，它会被 Perl 忽略，这样做的目的是便于维护 hash，以便随时增减条目，防止忘记加上末尾的逗号分隔符。当然，我们还可以省略 key 的引号，因为使用胖箭头后，左边的数据默认就是字符串，无需手动加引号：

my %hash = (
    zfl9 => 'www.zfl9.com',
    baidu => 'www.baidu.com',
    google => 'www.google.com',
);

当然，也不是所有情况都可以这么做，因为 key 可以是任意字符串，而当这个 key 为某个 Perl 运算符时，那 Perl 就无法辨认了。不过一般也不建议使用这种特殊符号来当作哈希的 key（这点和 JS 简直一模一样），如果 key 以字母、下划线开头，后接字母、数字、下划线的话，那么是可以放心使用这种简写方式的。这种没有引号的字称为裸字。因为他们是独立存在的。

还有一个常见的允许省略引号的地方就是在使用花括号获取对应 key 的 value 时，比如 $hash{'name'} 可以直接简写为 $hash{name}，因此使用合法的 Perl 标识符作为 key 是有很多好处的哟。但是如果花括号中的不是裸字，Perl 就会将其当作表达式进行求值，然后吧计算结果当作 key，比如 $hash{bar.foo}，Perl 会以为这是一个字符串连接表达式，导致误以为 key 为 barfoo。

哈希函数
当然，Perl 肯定提供了很多有用的函数来处理整个哈希变量。

keys 和 values
keys 返回哈希的所有键组成的列表，而 values 则返回哈希的所有的值组成的列表。如果哈希没有任何成员，则两个函数都返回空列表。

my %hash = (a => 1, b => 2, c => 3);
my @keys = keys %hash;
my @values = values %hash;

虽然 @keys 或 @values 中的元素顺序可能与预定义的顺序不同，但是可以肯定的是，它们之间是能一一对应的（只要两个获取操作之间没有修改哈希）。

在标量上下文中，这两个函数都返回哈希中的 key/value 的个数，整个计算过程不需要对整个哈希进行遍历，所以效率非常高。

my $length = keys %hash;

偶尔，也能看到有了直接使用哈希变量（数组变量一样的）来判断真假：

if (%hash) {
    # TODO 哈希非空
} else {
    # TODO 哈希为空
}

each 函数
如果需要迭代整个哈希/数组，常见的用法就是使用 each 函数，每次调用返回两个值，key 和 value。如果没有键值对，each 返回空列表，在循环中，它被视为 false。

实际使用中，唯一合适使用 each 的地方就是 while，如下：

while (my ($key, $value) = each %hash) {
    say "$key => $value";
}

看似简单的操作，其实隐含了很多技巧。首先 ($key, $value) = each(%hash) 是一个普通的函数调用语法，因为 each 每次返回两个值，假如返回的 key 和 value 为 zfl9 => www.zfl9.com，则它实际上是 ($key, $value) = ('zfl9', 'www.zfl9.com');，这是批量赋值的语法。然后 $key 和 $value 被依次赋值 zfl9、www.zfl9.com。外面的 my 其实是用来限定作用范围的。而 while 的条件判断其实是标量上下文，而列表在标量上下文中放回对应的元素数量，如果还有键值对，那么这个值应该恒为 2，转换为布尔值就是 true，所以会继续循环，当没有元素时，each 返回的是空列表，而 $key 和 $value 都被赋值为 undef，但是此时应该看的是 each 的返回值，而他的元素数目是 0，对应的布尔值就是 false，所以会退出循环。

exists 函数
要检查哈希中是否存在某个键，可以使用 exists 函数，他能返回 true 或 false，表示哈希中是否存在某个键。注意这个判断的依据与 value 无关。

if (exists $hash{name}) {
    # TODO
}

delete 函数
delete 函数用于删除哈希中的指定键，如果不存在，则直接返回。

哈希元素内插
你可以将单个哈希元素内插到字符串中，但是整个哈希变量不能，在 printf 格式字符串中还可能被误以为是格式参数，所以还得使用 %% 来转义。

%ENV 哈希
%ENV 哈希其实就是父进程传递给 Perl 进程的环境变量。比如 $ENV{PATH}。

习题
1、编一程序，从标准输入中读取多行单词（一放一个，EOF 结束），然后统计每个单词出现的次数，统计时，每个单词要以 ASCII 表排序：

#!/usr/bin/perl5
my %hash;
foreach (<STDIN>) {
    chomp;
    ++$hash{$_};
}
foreach (sort keys %hash) {
    say "$_ => $hash{$_}";
}

2、编程输出 %ENV 哈希中的所有键值对，输出按照 ASCII 码排序，分两列打印，并设法让两列进行对齐，提示，使用 length 函数可以帮助确定第一列的宽度：

#!/usr/bin/perl5
my @keys = keys %ENV;
my $len = 0;
foreach (@keys) {
    if ((length $_) > $len) {
        $len = length $_;
    }
    # 或者使用这种写法
    # $len = length($_) if length($_) > $len;
}
foreach (sort @keys) {
    printf "%${len}s = %s\n", $_, $ENV{$_};
}

正则表达式

Perl 的一大特色是内置的正则表达式支持，并且 Perl 中的正则基本上是其他所有现代语言的模仿对象，因为 Perl 的正则是最强大、最灵活的一个派别。一般我们将 Perl 中的正则派别称为 PCRE（Perl 兼容正则），另外两个则是 BRE（POSIX 基本正则）、ERE（POSIX 扩展正则），BRE 的代表是 sed（当然也可以切换为 ERE），ERE 的代表是 awk。即使是 ERE 也是不如 PCRE 灵活和好用的，所以来赶紧学习 Perl 正则吧！

如果模式匹配的对象是 $_ 的内容，只要把模式写在 // 之前就好了，它的语法和 JS 非常相似（其实说反了，JS 好多都是借鉴的 Perl）。而模式本身就是普通的字符串：

$_ = "input string";
if (/regex pattern/) {
    say "matched";
}

表达式 /regex pattern/ 会使用给定的模式尝试匹配 $_ 变量的内容，如果匹配则返回真，不匹配则返回假。在前面的字符串一节中，介绍了常用的字符转移序列，在正则模式中，同样适用哦。

Unicode 属性
每个 Unicode 字符都属于某个 Unicode Property（属性），一个 Unicode 属性对应一类字符。比如 Number 这个属性，它表示 Unicode 中所有的“数字”字符，如 0123456789、①②③④⑤⑥⑦⑧⑨。Perl 正则允许你使用一个 Unicode Property 名称来匹配一类 Unicode 字符，Perl 所支持的 Unicode 属性名可以通过 perldoc uniprops 文档查看（其中还有一些 Unicode Script、Unicode Block、Unicode Category，但是在这里我笼统的称为 Unicode 属性，见谅）。

如果要在正则中匹配某个 Unicode 属性，只需将属性名放入 \p{PROPERTY} 里面，使用大写的 P 则用于取反匹配。比如属性 Space，它表示所有空白符，要匹配它们，可以使用 \p{Space}：

#!/usr/bin/perl5
$_ = "　"; # 一个全角的空格符
if (/\p{Space}/) { # 匹配成功
    say "\e[32mmatched\e[0m";
} else {
    say "\e[35mnomatch\e[0m";
}

如果要匹配数字，可以使用 Digit 属性：

#!/usr/bin/perl5
$_ = "①"; # 数字序号 1
if (/\p{Number}/) { # 匹配成功
    say "\e[32mmatched\e[0m";
} else {
    say "\e[35mnomatch\e[0m";
}

如果要匹配十六进制数字（[a-fA-F0-9]），可以使用 Hex 属性：

#!/usr/bin/perl5
$_ = "0xFF";  # 两个连续的十六进制数字
if (/\p{Hex}\p{Hex}/) { # 匹配成功
    say "\e[32mmatched\e[0m";
} else {
    say "\e[35mnomatch\e[0m";
}

关于元字符
如果正则模式仅能匹配简单的直接量字符串，那么实际也没有多大用处，所以我们引入了元字符，元字符在正则表达式中有特殊意义，比如 . 匹配除行结束符外的任意字符，如果要匹配 . 本身，只需在元字符前面使用反斜线转义（\.），就会让元字符失去特殊意义，这个规则适用于其他任意元字符，如果要表示反斜线自身，则使用两个反斜线，即 \\。

模式分组
也称为捕获组，每个捕获组其实都是有序号的，从 1 开始（从左往右给每个左括号进行编号）。圆括号使得重新使用某些字符串成为可能，我们可以使用反向引用来引用圆括号中的模式所匹配的文字（利用这个特性可以用来匹配一串连续相同的字符）。反向引用的写法是在反斜线后面接上数字编号，如 \1、\2。比如匹配一串 6 个字符长度的数字，如 111111、666666：

$_ = "111111";
if (/(\d)\1{5}/) {
    say "matched";
} else {
    say "nomatch";
}

匹配 ABBA 模式的单词，如 foof、cttc：

$_ = "foof";
if (/(\w)(\w)\2\1/) {
    say "matched";
} else {
    say "nomatch";
}

从 Perl 5.10 开始支持一种新的反向引用写法，不再只是简单的用反斜线和组号，而是用 \g{N} 的形式，其中 N 是想要引用的组号。这种方式能有效的消除反向引用和模式的直接量之间的二义性，比如模式 /(.)\111/，Perl 的逻辑很简单，它会尽可能的创建最多数量的反向引用，因此 Perl 会认为这里应该是引用第 111 号捕获组，显然这里没有这么多捕获组，所以 Perl 运行时会报错。为什么不往小的地方猜呢，比如 \1 11，引用第 1 个捕获组，后面只是两个普通的数字 1？因为如果是这样的话，那么 Perl 中使用反斜线可引用的捕获组的返回就只有 1-9 了，这显然是不合理的。而使用新语法则没有这种问题。当然 Perl 允许我们将 \g{1} 简写为 \g1，但是这样又回到原点了，所以不建议这么做，必须始终加上花括号。

\g{N} 写法的另一个好处是允许使用负数作为组号索引，如果 N 为负数，则表示相对于自己的左边的第 -N 个捕获组，这样做可能会使正则模式的维护更轻松。比如：

#!/usr/bin/perl5
$_ = "1221";
if (/(\d)(\d)\g{-1}\g{-2}/) {
    say "\e[32mmatched\e[0m";
} else {
    say "\e[35mnomatch\e[0m";
}

另一个好处是可以统一匿名捕获组引用和具名捕获组引用的语法，即 \g{N}、\g{name}，比如上面的例子可以改写为：

#!/usr/bin/perl5
$_ = "1221";
if (/(?<first>\d)(?<second>\d)\g{second}\g{first}/) {
    say "\e[32mmatched\e[0m";
} else {
    say "\e[35mnomatch\e[0m";
}

预定义字符集
某些字符集使用的频率非常高，所以我们给它们定义了简写形式，在 Perl 还是 ASCII 的时代，我们不用担心字符数量，基本上字符集的简写能表示的无非就是那些字符（ASCII 总共 128 个字符），但是引入 Unicode 后，情况就不同了，原来那些简写覆盖的范围骤增，已经不是原来的屈指可数了。说起来有点令人难过，我们当中使用 Perl 多年的人好多都不愿意承认这点，但我们不愿逃避现实，你也不该如此，你看到的其他人写的代码可能是很久以前写的，也可能是昨天写的，仍然在使用 20 世纪 90 年代的简写形式，却不知道其实这些简写的意义已经发生了很大的变化。

比如，表示任意一个数字的字符集的简写是 \d，在 ASCII 时代，它的确只是 0-9 这 10 个数字，但到了 Unicode 时代，它还会匹配其他很多有数字意义的字符。Perl 中默认是启用了 Unicode 支持的（Java 默认不启用，除非使用 U 标识符），当然，Perl 也是提供了 flags 来禁用 Unicode 支持的，那就是使用 /a 修饰符。

比如 \w，在 Java 中它默认匹配 ASCII 字符集中的 [0-9a-zA-Z_]，如果想让 \w+ 匹配中文：你好，是不能匹配的，除非启用 Unicode 支持。而在 Perl 中，因为默认启用 Unicode 支持，所以模式 \w+ 能够成功匹配 世界，当然如果使用 /a 修饰符（ASCII 的意思），那么就会关闭 Unicode 的支持，从而匹配失败。例子：

#!/usr/bin/perl5
$_ = "你好";
if (/\w+/) { # 默认启用 Unicode 支持
    say "\e[32mmatched\e[0m"; # 匹配成功
} else {
    say "\e[35mnomatch\e[0m";
}
if (/\w+/a) { # 显式禁用 Unicode 支持
    say "\e[32mmatched\e[0m";
} else {
    say "\e[35mnomatch\e[0m"; # 匹配失败
}

使用 m// 进行匹配
前面我们使用的模式语法为 /pattern/，实际上它是 m/pattern/ 的缩写，其中 m 是 match 的缩写，表示这是一个用来匹配字符串的正则。就和前面介绍的 qw() 操作符一样，我们可以自由的选择合适的成对的分隔符，但此时不能省略 m，否则 Perl 就认不出了，所以建议不要使用简写形式，始终坚定不移使用 m// 形式。

比如，模式中包含正斜杠，那么选择默认的正斜杠作为分隔符就不太明智了，因为要进行转义，此时如果选择另外的分隔符就好看多了，比如 @，即 m@http://www.zfl9.com@。同理，如果模式中出现了与分隔符相同的字符，需要进行反斜杠转义，好让 Perl 分辨模式的开始和结束位置。当然，最好的方法还是选过一种没有在模式中出现的分隔符，常见的有：m@pattern@、m#pattern#、m%pattern% 等。

模式匹配修饰符
Perl 有好几个模式修饰符，它们也被称为标志（flag），它的位置在右分隔符后面，比如 m/pattern/flags。每个修饰符都是一个字母（大小写敏感），模式修饰符通常用来改变模式的默认行为。比如前面用到的 /a，表示禁用 Unicode 字符集支持。

先解释一下 e 和 ee 的区别，直接看例子吧：

#!/usr/bin/perl5
my $input = 'www.zfl9.com';
my $regex = '.+';
my $replace = '"www.baidu.com"';
say $input;
# 默认行为（等同于 /e 修饰符），替换后 $input = '"www.baidu.com"';
# $input =~ s/$regex/$replace/g;
# 对 $replace 执行一次 eval 调用，替换后 $input = '"www.baidu.com"';
# $input =~ s/$regex/$replace/ge;
# 对 $replace 执行两次 eval 调用，替换后 $input = 'www.baidu.com';
  $input =~ s/$regex/$replace/gee;
say $input;

eval 是一个内置函数，它的作用和行为与 Shell 中的 eval 一样，我是这样理解的，eval 其实就是 Shell/Perl 的解释器，每次调用 eval，其实就是调用 Shell/Perl 的解释器，调用后，这个解释器将在当前上下文中执行 eval 的参数。因此，eval 使得我们可以在 Shell/Perl 中动态的插入代码（默认程序员编写的代码称为“静态代码”）。

当然，上面那个例子中关于默认行为的解释其实是有问题的，默认行为不可能完全与加了 /e 的正则模式的行为相同。我以个人的见解简单的叙述一下它们之前的区别：

• 默认行为：只会进行纯粹的变量替换
• e修饰符：在“默认行为”的基础上，执行 Perl 表达式
• ee修饰符：在“默认行为”的基础上，执行 eval 函数调用

有必要强调的是，默认行为会对 regex 区域、replace 区域进行变量替换；而 e、ee 修饰符仅作用在 replace 区域。

现在我们来重新分析上面的例子：

• 默认行为：替换后的语句为 $input = s/.+/"www.baidu.com"/g，所以替换后的 input 就是 "www.baidu.com"，注意是带了双引号的。
• e修饰符：在默认行为的基础上，执行 Perl 表达式，这个表达式也就是 "www.baidu.com"，不过这好像没什么可执行的，所以执行后，replace 依旧是 "www.baidu.com"，所以替换后的 input 也是 "www.baidu.com"，注意双引号。
• ee修饰符：在默认行为的基础上，执行 eval 函数调用，传递给 eval 的参数就是 "www.baidu.com"，eval 语句为 eval '"www.baidu.com"'，其效果就是让解释器在当前上下文中运行 "www.baidu.com"（可以理解为运行 print "www.baidu.com"），运行结果当然是 www.baidu.com，所以替换后的 input 就是 www.baidu.com，注意没有了双引号哦。

在上面的例子中，没有直接体现出默认行为与 e 修饰符的区别，那么请看例子：

#!/usr/bin/perl5
my $input = "www.zfl9.com";
say $input;
#$input =~ s/^www\.(.+?)\.com/"blog.$1.org"/g; # $input = '"blog.zfl9.com"';
$input =~ s/^www\.(.+?)\.com/"blog.$1.org"/ge; # $input = 'blog.zfl9.com';
say $input;

再看一个例子，关于函数调用的，更能够体现出他们的区别：

#!/usr/bin/perl5
my $input = "www.zfl9.com";
say $input;
#$input =~ s/.+/print "www.google.com"/g;  # $input = 'print "www.google.com"';
 $input =~ s/.+/print "www.google.com"/ge; # $input = 'www.google.com1';
say $input;

注意了，第二个替换中多了一个字符 1，是怎么回事？那是因为 Perl 会将执行后的输出与返回值拼接在一次，作为替换字符串，因为 print 的输出是 www.google.com，返回值是 1（表示执行成功），所以最终的替换字符串为 www.google.com1。

Perl 为什么要这么做呢？因为上面的 print 完全是不必要的，一般使用 e 参数都是为了调用自定义的函数（子程序），而不是上面那样的 print。你看这个例子就明白了：

#!/usr/bin/perl5
say my $input = "www.zfl9.com";
$input =~ s/.+/&myfunc($@)/ge; # $@ 代表整个匹配到的字符串
say $input; # www.google.comwww.google.comwww.google.com9999
sub myfunc {
    print "www.google.com";
    print "www.google.com";
    print "www.google.com";
    return 9999;
}

所以不建议在调用的函数中输出任何东西，不然会破坏替换字符串，你最好只通过返回值来告诉 Perl 你想替换的字符串是什么，比如：

#!/usr/bin/perl5
say my $input = "www.zfl9.com";
$input =~ s/.+/&myfunc($&)/ge; # $& 代表整个匹配到的字符串
say $input; # WWW.ZFL9.COM
sub myfunc {
    return uc $_[0]; # 返回大写的字符串副本
}

最后，解释一下 c 修饰符，它的意思让正则引擎暂存当前匹配到的结束位置：
没有 c 修饰符：

#!/usr/bin/perl5
$_ = "abc123def";
while (m/\G[a-z]/g) {
    print $&;
}
print "\n";
while (m/\G\d/g) {
    print $&;
}
print "\n";
while(m/\G[a-z]/g) {
    print $&;
}
print "\n";
# 输出结果
# abc
# 
# abc

加上 c 修饰符

#!/usr/bin/perl5
$_ = "abc123def";
while (m/\G[a-z]/gc) {
    print $&;
}
print "\n";
while (m/\G\d/gc) {
    print $&;
}
print "\n";
while(m/\G[a-z]/gc) { # 这次的 c 修饰符可有可无，因为后面没有正则匹配了
    print $&;
}
print "\n";
# 输出结果：
# abc
# 123
# def

加了 c 修饰符的效果就像是换了个模式继续上次的匹配的效果，具体自己体会。

捕获组相关
如何定义捕获组，语法和 Java 其实是一样的：

• 匿名捕获组：(X)
• 具名捕获组：(?<name>X)

无论命名与否，Perl 都会对捕获组进行编号，这和 Java 是一样的。

正则模式（regex）中进行反向引用（匿名捕获组），有两种语法：\N、\g{N}，建议使用后者，避免出现二义性。如果要引用具名捕获组，那么也有两种语法：\k<name>、\g{name}。为了统一语法，建议始终使用后者来进行反向引用。

替换序列（replace）中进行反向引用不使用这种语法，而是通过 Perl 预定义的标量变量，具体涉及到的标量变量有：

• $&：引用捕获组 0（匹配到的字符串）
• $N：引用捕获组 N（N >= 1）
• $+：引用最后一个捕获组
• $+{name}：引用具名捕获组（%+ 哈希）
• $`：返回捕获组 0 之前的字符串
• $'：返回捕获组 0 之后的字符串

嵌入式修饰符
为什么需要嵌入式修饰符，如果你的正则模式是固定的，那么可能用不到这个功能，但如果你的正则模式是从用户输入、文件读取、命令行参数指定的，那么嵌入式修饰符就比较有用了。因为修饰符部分是无法进行变量化的，只能静态指定。

(?adlupimnsx-imnsx)：连字符前面的是启用对应修饰符，连字符后面是禁用对应修饰符，语法和 Java 是一样的，比如 (?i) 表示忽略大小写匹配，(?-i) 为大小写敏感。

嵌入式修饰符可以位于整个模式的开头，表示全局启用；也可以位于某个圆括号内部，表示仅对当前圆括号范围内的模式起作用，如 ((?i)blah)\s+\g1；同一个作用范围内，还可以用来覆盖默认的行为（相同的修饰符被覆盖），如 ((?im)foo(?-m)bar)。也可以用来覆盖后面静态指定的修饰符，如 /(?-i)foo/gi。

当然，Perl 也至此 Java 中的局部作用域语法：
(?adluimnsx-imnsx:pattern)，表示仅对 pattern 生效。

环视/预查
(?=X)：正向肯定环视
(?!X)：正向否定环视
(?<=X)：逆向肯定环视（固定宽度）
(?<!X)：逆向否定环视（固定宽度）
X\K：逆向肯定环视（可变长度，Perl 5.10.0 起可用）

锚位
所谓锚位其实就是位置匹配符，比如 \A、\Z、^、$。具体请参考正则元字符。

绑定操作符 =~
默认情况下，模式匹配的输入序列是 $_，绑定操作符 =~ 告诉 Perl，拿右边的模式来匹配左边的字符串，而不是默认的 $_，例如：

#!/usr/bin/perl5
my $input = "www.zfl9.com";
if ($input =~ /.+/) {
    say "matched";
}

绑定操作符看起来像其他赋值操作符，但实际上它们完全不同，他只是用来让模式匹配左操作数的字符串而已。这只是一个表达式，该表达式的返回值是一个布尔值，表示模式是否与输入串相匹配，就这么简单（其实你应该能够从 if 语句从判断出该表达式的返回值的具体意义，不然我们是不能这么使用的）。

不信的话，你可以用一个变量来存储该表达式的返回值，然后使用 say 输出：

my $is_match = 'www.zfl9.com' =~ /.+/;
say $is_match; # 1
$is_match = 'www.zfl9.com' =~ /.++m/;
say $is_match; # 空串

在下面这个例子里，$likes_perl 会被赋予一个布尔值，其结果取决于用户的输入，这段代码属于快速消费型，因为判断之后就丢弃了用户输入（除非 while 循环的条件表达式中只有整行输入操作符 <FILEHANDLE>，否则输入行不会被 Perl 自动存入 $_）：

#!/usr/bin/perl5
print "Do you like Perl? ";
my $likes_perl = <STDIN> =~ /\byes\b/i;
if ($likes_perl) {
    print "Thank you.\n";
} else {
    print "Fuck you.\n";
}

正则模式内插
正则表达式内部可以进行双引号形式的内插（前面已经演示过很多次），利用这个特性，可以写个简单的 grep 程序，还可以加上颜色高亮显示哦，例子：

#!/usr/bin/perl5
if (@ARGV < 1) {
    say STDERR "Usage: $0 <pattern>";
    exit 1;
}
my $regex = $ARGV[0];
while (<STDIN>) {
    if (s/$regex/\e[31;1m$&\e[0m/g) {
        print;
    }
}

我们来测试一下（注意是可以高亮显示的，只不过这里看不出来）：

# root @ arch in ~/workspace [21:06:44]
$ cat /etc/passwd | grep 'systemd'
systemd-journal-gateway:x:191:191:systemd-journal-gateway:/:/usr/bin/nologin
systemd-timesync:x:192:192:systemd-timesync:/:/usr/bin/nologin
systemd-network:x:193:193:systemd-network:/:/usr/bin/nologin
systemd-bus-proxy:x:194:194:systemd-bus-proxy:/:/usr/bin/nologin
systemd-resolve:x:195:195:systemd-resolve:/:/usr/bin/nologin
systemd-journal-remote:x:998:998:systemd Journal Remote:/:/sbin/nologin
systemd-journal-upload:x:996:996:systemd Journal Upload:/:/sbin/nologin
systemd-coredump:x:997:997:systemd Core Dumper:/:/sbin/nologin
# root @ arch in ~/workspace [21:07:01]
$ cat /etc/passwd | ./grep.pl 'systemd'
systemd-journal-gateway:x:191:191:systemd-journal-gateway:/:/usr/bin/nologin
systemd-timesync:x:192:192:systemd-timesync:/:/usr/bin/nologin
systemd-network:x:193:193:systemd-network:/:/usr/bin/nologin
systemd-bus-proxy:x:194:194:systemd-bus-proxy:/:/usr/bin/nologin
systemd-resolve:x:195:195:systemd-resolve:/:/usr/bin/nologin
systemd-journal-remote:x:998:998:systemd Journal Remote:/:/sbin/nologin
systemd-journal-upload:x:996:996:systemd Journal Upload:/:/sbin/nologin
systemd-coredump:x:997:997:systemd Core Dumper:/:/sbin/nologin