1
2

$ perl -e '$a = `date +"%F %T"`;print $a'
2019-01-03 19:55:32

Perl中有以下几个常见的反斜线序列:

1
2
3
4
5
6
7
8
9

\n
\r
\t
\l    # 将下个字母转换为小写
\L    # 将后面的多个字母都转换为小写，直到遇到\E
\u    # 将下个字母转换为大写
\U    # 将后面的多个字母都转换为大写，直到遇到\E
\Q    # 和\E之间的所有字符都强制当作字面符号
\E    # \L、\U和\Q的结束符号

字符串连接需要使用 . ，例如 "abc"."def" 等价于 "abcdef" 。字符串重复次数可以使用小写字母x，例如 "a" x 3 得到 "aaa" ， "abc" x 2 得到 abcabc 。

使用q类型的引用可以避免在shell中一行式Perl程序的引号转义问题。

例如，在一行式Perl中想要保留单引号：

1

$ perl -e "print q(abc'd)"

1
2
3

@arr = ("Perl", "Python", "Shell")
@{arr} = (1,2,3)  # 加上大括号是标准的写法
@empty = ()       # 空数组

书写列表时，字符串需要使用引号包围，逗号分隔各个元素。还可以使用qw()来写列表，不需要再使用逗号分隔元素，而是使用空格，且每个元素都默认以单引号的方式包围。所以下面是等价的：

1
2

@arr = qw(Perl Python Shell abc\ndef)
@arr = ('Perl','Python','Shell,'abc\ndef')

对于一行式的perl命令，变量和数组可以直接使用而无需事先声明 。

数组可以直接放在双引号中输出，默认输出的时候是用空格分隔各元素。

1
2

$ perl -e '@arr=qw(Perl Python Shell);print "@arr\n"'
Perl Python Shell

要取数组中的某个元素，使用 $ 符号。第一个元素 $arr[0] ，第二个元素 $arr[1] 。例如：

1
2

$ perl -e '@arr=qw(Perl Python Shell);print "$arr[1]\n"'
Python

数组 $#arr 或 $#{arr} 表示数组的最后一个数组索引值，所以数组元素个数等于该值加1。

如果想要直接取得数组的个数，将数组赋值给一个变量或者使用scalar()函数即可。这涉及到Perl的上下文知识，不是本文内容，所以记住即可。

1
2
3
4

$ perl -e '
        @arr = qw(Shell Perl PHP);
        $num = @arr;print "$num\n";
        print scalar @arr,"\n";'

数组的索引可以是负数，-1表示最后一个元素，-2表示倒数第二个元素。所以 $arr[-1] 等价于 $arr[$#arr] ，都是最后一个元素。

1
2
3
4

@arr = qw(Perl Python Shell Ruby PHP)
@arr[0]   # 取第一个元素形成一个新列表
@arr[1,1,0,-2]  # 取两次第2个元素，一次第1个元素，一次倒数第2个元素形成新列表
@arr[1..3]  # 以序列的方式取第2到第4个元素形成新列表

下面是一个示例：

1
2
3
4

$ perl -e '
        @arr=qw(Perl Python Shell Ruby PHP);
        print "@arr[1,1,0,-2]\n"'
Python Python Perl Ruby

如果想要取从第2个到倒数第2个元素，可以使用这种切片方式 @arr[1..$#{arr}-1] 。例如：

1
2
3

$ perl -e '@arr=qw(Perl Python Shell Ruby PHP);
        print "@arr[1..$#{arr}-1]\n"'
Python Shell Ruby

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

# foreach遍历数组
perl -e '
        @arr=qw(Perl Python Shell Ruby PHP);
        foreach $i (@arr){print "$i\n"}'

# for遍历数组：元素存在性测试遍历法
perl -e '
        @arr=qw(Perl Python Shell Ruby PHP);
        for $i (@arr){print "$i\n"}'

# for遍历数组：索引遍历法
perl -e '
        @arr=qw(Perl Python Shell Ruby PHP);
        for($i=0; $i<=$#arr; $i++){print "$arr[$i]\n"}'

# each遍历数组：key/value遍历
perl -e '
        @arr=qw(Perl Python Shell Ruby PHP);
        while (($index, $value) = each(@arr)){
            print "$index: $value\n"
        }'

必须注意的是，Perl中for/foreach以元素存在性测试遍历时，控制变量 $i 是各个元素的引用，而不是复制各个元素再赋值给 $i ，所以在遍历过程中修改 $i 的值会直接修改原数组。

1
2
3
4
5

$ perl -e '
        @arr=qw(Perl Python Shell Ruby PHP);
        for $i (@arr){$i = $i."X"};  # 为每个元素加尾随字符"X"
        print "@arr\n"'
PerlX PythonX ShellX RubyX PHPX

在Perl中，无论是数组还是hash结构，本质都是列表。所以下面的列表数据可以认为是数组，也可以认为是hash，关键在于它赋值给什么类型。

1

("name","longshuai","age",23)

在Perl中，数组类型使用 @ 前缀表示，hash类型则使用 % 前缀表示。

所以，下面的表示hash结构：

1
2

%Person = ("name","longshuai","age",23)
%Person = qw(name longshuai age 23)

列表作为hash结构时，每两个元素组成一个key/value对 ，其中key部分必须是字符串类型。所以上面的hash结构表示的映射关系为：

1
2
3
4

%Person = (
        name => "longshuai",
        age  => 23,
)

实际上，上面使用胖箭头 => 的写法在Perl中是允许且推荐的，它是元素分隔符逗号的另一种表示方式，且使用胖箭头更能展现一一对应的关系。在使用胖箭头的写法时，如果key是符合命名规范的，可以省略key的引号(因为它是字符串，正常情况下是应该加引号包围的)，正如上面所写的格式。

hash数据 不能在双引号中进行内容替换 ，可以直接输出它，但直接输出时hash的元素是紧挨在一起的，这表示hash的字符串化。

1
2
3
4
5
6
7
8
9

$ perl -e '
        %hash = qw(name longshuai age 23);
        print "%hash","\n"'
%hash

$ perl -e '
        %hash = qw(name longshuai age 23);
        print %hash,"\n"'
age23namelongshuai

从hash中取元素使用 $ 表示，如 $hash{KEY} ，从hash中切片使用 @ 表示，如 @hash{KEY1,KEY2} 这和数组是一样的。 虽然hash类型本身不能在双引号中进行内容替换，但hash取值或者hash切片可以在双引号中替换 。

1
2
3
4
5
6
7
8
9

$ perl -e '
        %hash = (name=>"longshuai",age=>23);
        print "$hash{name}","\n"'
longshuai

$ perl -e '
        %hash = (name=>"longshuai",age=>23);
        print "@hash{name,name,age,age}","\n"'
longshuai longshuai 23 23

下面是keys和values函数的示例。

1
2
3
4
5
6
7
8
9
10

$ perl -e '
        %hash = (name=>"longshuai",age=>23);
        print "keys:\n";
        print keys %hash,"\n";
        print "values:\n";
        print values %hash,"\n";'
keys:
agename
values:
23longshuai

看起来不是很爽，所以赋值给数组再来输出。

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

$ perl -e '
        %hash = (name=>"longshuai",age=>23);
        @keys = keys %hash;
        @values = values %hash;
        print "=========\n";
        print "@keys\n";
        print "=========\n";
        print "@values\n";'
=========
age name
=========
23 longshuai

如何知道hash结构中有多少个key/value对 ？是否记得将数组(列表)赋值给一个变量时，得到的就是它的个数？

1
2
3
4
5

$ perl -e '
        %hash = (name=>"longshuai",age=>23);
        $nums = keys %hash;
        print "$nums\n";'
2

如果想要直接输出个数而不是先赋值给变量，可以**对一个列表使用函数scalar()，它会强制让Perl将列表当作标量(变量)**：

1
2
3
4

$ perl -e '
        %hash = (name=>"longshuai",age=>23);
        print scalar keys %hash,"\n";'
2

如何排序hash结构？只需对keys的结果应用sort/reverse函数，再进行遍历输出即可。

1
2
3
4
5
6
7

$ perl -e '
        %hash = (name=>"longshuai",age=>23);
        for $key (sort keys %hash){
            print "$key => $hash{$key}\n";
        }'
age => 23
name => longshuai

当没有为函数指定参数时、表达式中需要变量但却没给定时都会使用这个默认变量 $_ 。

1

perl -e '$_="abc\n";print'

print函数没有给参数，所以默认输出 $_ 的内容。

再例如，for/foreach的遍历行为：

1
2

for $i (@arr){print "$i\n"}
for (@arr){print "$_\n"}

for本该需要一个控制变量指向 @arr 中每个元素，但如果没有给定，则使用默认变量 $_ 作为控制变量。

用到默认变量的地方很多，没法列出所有使用 $_ 的情况。所以简单地总结是：只要某些操作需要参数但却没有给定的时候，就可以使用 $_ 。

$_ 是对于标量变量而言的默认变量。对于需要列表/数组的时候，默认变量不再是 $_ ，而是 @ARGV 或 @_ ：在自定义子程序(函数)内部，默认变量是 @_ ，在自定义子程序外部，默认变量是 @ARGV 。例如：

1
2
3
4

$ perl -e '
        $name = shift;
        $age = shift;
        print "$name:$age\n"' longshuai 23

默认数组(列表)变量对一行式perl命令来说可能遇不上，所以了解一下足以，只要能在需要的时候看懂即可。

注意，Perl中没有true和false的关键字，如果强制写true/false，它们可能会被当作字符串，而字符串为真，所以它们都表示真。例如下面的两行，if的测试对象都认为是字符串而返回真。

1
2

perl -e "if(true){print "aaaa\n"}"
perl -e "if(false){print "aaaa\n"}"

1
2
3
4
5
6
7
8
9

数值     字符串      意义
-----------------------------
==       eq        相等
!=       ne        不等
<        lt        小于
>        gt        大于
<=       le        小于或等于
>=       ge        大于或等于
<=>      cmp       返回值-1/0/1

最后一个 <=> 和 cmp 用于比较两边的数值/字符串并返回状态码-1/0/1：

对于 <=> ，如果比较的双方有一方不是数值，该操作符将返回undef。

几个示例：

1
2
3
4
5
6
7
8
9
10
11

35 != 30 + 5       # false
35 == 35.0         # true
'35' eq '35.0'     # false(str compare)
'fred' lt 'bay'    # false
'fred' lt 'free'   # true
'red' eq 'red'     # true
'red' eq 'Red'     # false
' ' gt ''          # true
10<=>20            # -1
20<=>20            # 0
30<=>20            # 1

符号类型的逻辑操作 && || ! // 优先级很高，为了保险，符号两边的表达式应当使用括号包围。关键字类型的逻辑操作优先级很低，不需要使用括号包围。

1
2

($a > $b) && ($a < $c)
$a > $b and $a < $c

Perl的短路计算非常特别，它返回的是最后运算的表达式的值。也就是说，它有返回值，通过返回值可以判断短路计算的布尔逻辑是真还是假。

所以，这个返回值既保证短路计算的结果不改变，又能得到返回值。这个返回值有时候很有用，例如，可以通过逻辑或的操作来设置默认值：

1

$name = $myname || "malongshuai"

上面的语句中，如果 $myname 为真，则 $name 被赋值为 $myname ，如果 $myname 为假，则赋值为 malongshuai 。

但上面有一种特殊的情况，如果 $myname 已经定义了，且其值为数值0或字符串 0 ，它也返回假。

这和预期有所冲突，这时可以使用 // 来替代 || 。 // 表示只要左边的内容已经定义了就返回真，而无论左边的内容代表的布尔值是真还是假。

1

$name = $myname // "malongshuai"

所以，就算 $myname 的值为0， $name 也会赋值为0而不是”malongshuai”。

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

# if语句
if(TEST){
    ...
} elsif {
    ...
} else{
    ...
}

# unless语句
unless(TEST){
    ...
}

# 三目运算符
expression ? if_true : if_false

if表示TEST为真的时候，执行后面的语句块，否则执行elsif或else语句块。

unless则相反，TEST为假的时候，执行后面的语句块。也就是等价于 if(!TEST) 。unless也有else/elsif块，但基本不会用，因为可以转换成if语句。

注意TEST部分，只要它的结果在布尔逻辑上是真，就表示真。例如：

1
2
3

if("abc"){}  # 真
if(0){}      # 假
if(0 > 1){}  # 假

1
2
3
4
5
6
7

while(CONDITION){
    commands;
}

until(CONDITION){
    commands;
}

Perl的until和其它某些语言的until循环有所不同，Perl的until循环，内部的commands主体可能一次也不会执行，因为Perl会先进行条件判断，当条件为假时就执行，如果第一次判断就为真，则直接退出until。

1
2
3
4
5
6
7
8
9

# (1).C语言风格的for
for(expr1;expr2;expr3){...}
for($i=0;$i<100;$i++){...}

# (2).元素存在性测试的for
for $i (LIST){...}

# (3).元素存在性测试的for等价于foreach
foreach $i (LIST){...}

对于第一种for语法(即C语言风格的for)，3个部分都可以省略，但分号不能省略：

例如下面将3个部分全都省略，将会无限循环：

1
2
3

for(;;){
    print "never stop";
}

对于(2)和(3)的元素存在性测试的循环，用来迭代遍历列表，每次迭代过程中通过控制遍历 $i 引用当前被迭代的元素。注意：

1
2
3
4
5
6
7

$ perl -e '
        @arr = qw(Perl Shell Python Ruby PHP);
        for (@arr){
                $_ = $_."x";
        }
        print "@arr\n"'
Perlx Shellx Pythonx Rubyx PHPx

上面没有显式指定控制变量，所以采用默认变量 $_ 。且在迭代过程中为每个 $_ 都连接了一个尾随字符 x ，它会直接修改元素数组。

遍历hash：

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

#!/usr/bin/perl -w
use strict;

my %hash = (
    name1 => "longshuai",
    name2 => "wugui",
    name3 => "xiaofang",
    name4 => "woniu",
);

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

输出结果：

1
2
3
4

name4 => woniu
name3 => xiaofang
name2 => wugui
name1 => longshuai

遍历数组：

1
2
3
4
5
6
7
8

#!/usr/bin/perl -w
use strict;

my @arr = qw(Perl Shell Python PHP Ruby Rust);

while(my($key,$value) = each @arr){
    print "$key => $value\n";
}

输出结果：

1
2
3
4
5
6

0 => Perl
1 => Shell
2 => Python
3 => PHP
4 => Ruby
5 => Rust

1

command OPERATOR CONDITION;

1
2
3
4
5
6

print "true.\n" if $m > $n;
print "true.\n" unless $m > $n;
print "true.\n" while $m > $n;
print "true.\n" until $m > $n;
print "$_\n" for @arr;
print "$_\n" foreach @arr;

书写时，很多时候会分行并缩进控制符：

1
2

print "true.\n"    # 注意没有分号结尾
    if $m > $n;

改写的方式几个注意点：