# Perl中#后面的内容为注释
37 3.7 .37 37. 3E7 3e7 .3E7 3.E7 3E-7  # 整数和浮点数（此处highlighter被调戏，求放过）
0x2aff 0xAA3  # 十六进制整数
0276 077      # 八进制整数
3_296_429     # 数字中间可以插入下划线来增强可读性，同3296429

'poopsie'
'apples are good\t'       # 单引号内不支持转义，所以\t不是tab，而是\和t两个字符
'Wouldn\'t it be lovely?' # 除了\'用于插入一个单引号（另外\\表示一个\）
'good
bye'                      # 支持多行，共8个字符，包括内嵌的换行符

'can\'t, won\'t, wouldn\'t ever!'  # 这里所有单引号都得转义，比较麻烦
q^can't, won't, wouldn't ever!^    # q^表示改用^作为当前单引号字符串的分隔符，简化了代码的书写
q(Is Perl more fun than baseball?) # 其他例子
q[Well, maybe not.]

"Quantity \t Price \t Total \n\n"     # 双引号内支持转义，这里的\t才是一个Tab
"The dog replied, \"wuff!\""          # \"用于插入双引号
qq*"Definitely not!", she answered.*  # qq*表示改用*作为当前双引号字符串的分隔符，简化书写

# 字符串内的Scala变量会被解释，如果此处$name的值是bob，则此字符串会被解释为：
# "Apples are good for bob"
"Apples are good for $name" 
# 如果不希望解释变量，可以加上\
"Apples are good for \$name"
# 如果双引号内嵌单引号，$money仍然会被解释，因为外层限定符（也就是双引号）决定了字符串的行为
"The boy sent the message, 'Help, end $money'" 
# 如果单引号内嵌双引号，$money不会被解释，因为外层限定符（也就是单引号）决定了字符串的行为
'The boy sent the message, "Help, end $money"' 
# 如果字符串内的变量名后需要紧跟别的字符，可以用花括号{ }括上变量名，假如这里$day的值为Mon，
# 则此字符串会被解释为："Today is Monday"
"Today is ${day}day"

5 / 2      # = 2.5
7.86 % 3   # = 1
3 ** 2     # = 9

$str . "Holidays!"     # 连接字符串
"Happy! " x 3          # 重复字符串整数次，即"Happy! Happy! Happy! "

7 + $str  # 如果$str的值为" 32abc"，会隐式转换为数值32，结果为数值39
7 + $str  # 如果$str的值为"alpha32"，会隐式转换为数值0，因为去掉头部空白符和尾部非数字字符后，
          # 剩下的部分无法转换为数值。所以结果为数值7
7 . $str  # 如果$str的值为" 32abc"，结果为字符串"7 32abc"
- $str    # 如果$str的值为" 32abc"，结果为数值-32

# Perl中完整的一个语句必须以;结束（除了区块中的最后一句语句可以省略;）
chomp($new_input = <STDIN>); # 从键盘读入一行字符串，存入$new_input并且去除末尾的换行符
print "Isn't this fun?\n";                   # 操作符方式调用print
print("That may be an overstatement!\n");    # 函数方式调用print
# 可以输出带有变量的字符串。print函数还可以接受多个字符串，它们会被逐个输出
print("The sum is: $sum", "\tThe average is: $average\n") 

# 以下命令是shell指令，$为命令提示符
$ perl circle.pl  # 运行Perl脚本文件
$ perl -e 'print "Is this easy enough? \n";' # 直接执行单个Perl语句
$ perl   # 以交互方式运行，一行一行地输入并执行
print "Well, ok! \n";
print "This is also easy! \n";
<EOF> # 文件终结符，例如在Unix系统下，按下Control+D

$ perl -c circle.pl    # 解释并验证Perl脚本，但不执行
$ perl -w rectangle.pl # 显示警告信息，便于及早发现可能存在的bug

"fruit" eq 7    # 7会被隐式转换为"7"
"27" gt "3"     # 由于这里是字符串比较，"3"的ASCII值比"2"大，所以结果为false
"boy" == "girl" # 由于这里是数值比较，"boy"和"girl"都被转换为0，所以结果为true

$a ||= $b;

# 类似C
if($a > $b){
    print "\$a is greater than \$b \n";
}else{
    print "\$a is not greater than \$b \n";
}

# 可以省去else部分
if($a > $b){
    print "Largest: $a \n";
}

# 也可以写成一行 
if($a > $b){ print "Largest: $a \n"; }

# unless与if恰恰相反，在控制表达式为false的时候才执行里面的语句
unless (($count < $limit) or $nolimit){
    print "I simply cannot go on! \n";
}

# 可以使用elsif连接多个分支，注意不是"elseif"，也不是"else if"
if($age < 18){
    print "You're just a kid! \n";
}elsif($age < 40){
    print "Not a kid, but still young \n"
}elsif($age < 65){
    print "Middle aged, hub? \n";
}else{
    print "You're now in the \"Golden Age\", right? \n";
}

# 条件表达式，类似C
$average = ($number != 0) ? $num / $number : 0;

# 如果条件表达式的then表达式和else表达式都具有左值，那么整个条件表达式可以放在复制语句的等号左边
(($next > 0) ? $positives : $negatives) += $next;

# 类似C的while
$sum = 0;
while($sum <= 1000){
    $sum += <STDIN>; # 这里从键盘读入一行字符串，并隐式转换成了数值，加到了$sum中
}

# until与while恰恰相反，当控制表达式为false时执行循环体，直到条件为true结束循环
until($sum > 1000){
    $sum += <STDIN>;
}

# 类似C的for
for($count = 0 ; $count < 10; $count++){
    $sum += <STDIN>;
}

# 类似C的逗号分隔表达式，其整体结果为最后一个表达式的值
$x = ($a = 7, $b = 10, $c = -2);

# 由此，我们可以在for结构中的初始化或更新多个变量
for($forward = 0, $backward = 10;
    $forward < 10;
    $forward++, $backward--){
    # 循环体
}

OUTER: # 为外层for循环加上标签
    for($a = 0; $a < 100; $a++){ 
        for($b = 0 ; $b < 100; $b++){
            $product = $a * $b;
            if($product > 1000){
                last OUTER;  # 不加参数仅能跳出最内层循环体，加上参数后则可以跳出外层for循环
            }else{
                print "Next product is $product \n";
            }
        }
    }

$bob++ if $wor eq "bob"; # 先检测if条件，如果为true，才会执行被修饰的语句
$sum *= 2 until $sum > 1000; # 先检测until条件，如果为true，循环执行被修饰语句，直到条件为false

# 该程序以循环形式连续地读取从键盘输入的字符串，统计bob的数量，直到输入的字符串为～时程序结束
$chomp($word = <STDIN>);
do{
    $bob++ if $word eq "bob";
    chomp($word = <STDIN>);
}until $word eq "~"; # 先执行循环体，然后检测条件

# 如果参数字符串末尾没有换行符，系统会自动加上更多调试信息（例如程序名称、行号）和换行符
# 如果参数字符串末尾有换行符，调试信息则不会自动加上
die "The input file is empty!"; 

# 如果一个系统函数调用失败，其错误码会保存在$!中，所以$!一般会出现在die的参数中
die "Input/output function error $!";

# 如果你想让程序直接退出，而不提供额外信息，可以使用error，其参数为程序最终返回的错误码，0表示正常退出
exit 0;

while(<STDIN>){ # STDIN读入的内容隐式地赋值给$_
    print; # 使用$_作为默认参数
    chomp; # 使用$_作为默认参数
    if($_ eq "money"){
        print "I've finally found it!!! \n";
    }
}

# <>操作符不提供参数时：
#   1. 如果程序提供了命令行参数时，它会使用命令行参数中提供的文件名获取文件句柄
#      ，逐行读取，如果有多个参数，会按顺序读取对应文件
#   2. 如果程序没有得到命令行参数，它会转而从STDIN读入，即从键盘读入
while(<>){ # 从文件或STDIN读入的内容隐式地赋值给$_
    print; # 使用$_作为默认参数
}

$ perl -d example.pl # 启动调试器，使用交互式的命令行进行调试

@a = (2, 4, 6);            # @a有3个元素
@a = ('a', 'b', 'c', 'd'); # 现在@a有4个元素，其长度自动增长为4
@a = (4.35);               # 现在@a仍然有4个元素，但是后3个元素被设为了undef
@a = 1;      # 如果scala值赋值给数组，该数组会被设为仅包含该scala值的单元素数组，所以@a现在是(1)

# 如果数组变量赋值给scala变量，该scala变量会被设为数组的长度，所以下面$girl值被设为3
@names = ('mary', 'jo', 'ann');
$girls = @names; 

($a, $b) = (2, 4);     # 如果list字面值中仅包含变量，那么该字面值可以作为赋值语句的目标
($a, $b) = (2, 4, 6);  # 如果赋值语句左侧元素数量少于右侧，那么右侧多余的值会被忽略
($a, $b, $c) = (2, 4); # 如果赋值语句左侧元素数量多于右侧，那么左侧多余的变量会被设为undef

# 如果赋值左侧出现数组，它会吞掉剩余的所有元素，所以下面的@list值为("dog", "monkey")，而$b设为undef
($a, @list, $b) = ("cat","dog","monkey"); 
($first, @list) = @list; # 实际使用中可用于去除数组的第一个元素

@b = (2, 3, 4);
@a = (1, @b, 5); # 如果赋值右侧出现数组，它包含的元素会被展开，这里相当于(1, 2, 3, 4, 5)

# 清空数组
@list = ();    # 正确方式一
undef @list;   # 正确方式二
@list = undef; # 错误方式，该操作会将数组赋值为包含一个undef元素的数组。

# 双引号字符串中的数组变量会被解释，其中的元素会被按顺序打印出来，元素之间以单个空格隔开
print "The list is @list \n"; 

@list = (1,2,3,4);
$list[0] = 17;        # 这里引用了数组list里的元素，需要改成$开头

# 注意前面说过，$list与@list无关，但$list[0]与@list有关，切勿混淆
$list = "Darcie";
@list = (2, 4, 6, 8);
$list[1] = 10;
print "Scalar: $list Element: $list[1] List: @list";
# 上述语句输出 Scalar: Darcie Element: 10 List: 2 10 6 8

# 下面是数组头两个元素互换，这样做是合法的，因为其效果是两个赋值并行完成
($list[0], $list[1]) = ($list[1], $list[0]); 

# 如果试图访问数组最后一个元素后面的信息（也就是数组越界），得到的值为undef，并不会产生错误
@highs = (92, 84, 81, 79, 85);
$Saturday_hi = $highs[6];

# 不同于常见编程语言的设定，Perl中访问数组元素时，下标可以为负数，
# 此时该下标对应的元素从最后一个往前数，最后一个为-1
@list = (2, 4, 6, 8, 10);
print "The last element is: $list[-1] \n";        # 显示10
print "The second last element is: $list[-2] \n"; # 显示8
print "The first element is: $list[-5] \n";       # 显示2
$list[-10] = 17;       # 当负数下标超过允许的范围时，会产生严重运行时错误

# 当给数组某个超过当前长度的下标位置的元素赋值时，数组会隐式地扩展到所需的长度。
$list[50] = 22; # 数组长度扩展成51

# 要想获知某个数组中最后一个元素的下标，可以通过$#接数组名称这样的隐式变量来获得，例如：
print "The last index of \@list is $#list \n";
# 我们还可以用此变量将数组设为空数组：
$#list = -1;
# 当需要使用较大长度的数组时，如果让该数组隐式地按需扩展长度，从短到长，频繁地扩展，效率会比较低。
# 更高效的方法是一开始就设置好最终的数组长度。例如我们需要长度为1000的数组时，可以采用如下做法：
$list[999] = 0;  # 方法一，给最后一个元素赋值
$#list = 999;    # 方法二，设置最后一个元素的下标

@salaries = (34000, 41950, 52100, 39650);
@salaries[4, 5] = (48500, 41500);
@first3_salaries = @salaries[0, 1, 2];
@next3_salaries = @salaries[3..5];

@list = (1, 3, 5, 7, 9) [$first, $second]; # list字面值也可以使用切片

@list = (2, 4, 6, 8);
@list[1, 3] = @list[3, 1]; # 交换数组中的元素

@list + 0                                              # 强制转换list为scala
print "Length of \@list is: ", scalar(@list), "\n";    # 强制转换list为scala

$x = (7, 12, 27, 5);    # $x的值为list的最后一个元素，即为5
$x = qw(a b c d);       # $x的值为数组长度，即为4

$next = <STDIN>;        # 读入一行
@input = <STDIN>;       # 读入所有行，数组中每个元素为一行的输入内容

foreach $age (@ages){              # 遍历数组
    $age++;
}

foreach $count (1, 3, 5, 7, 9){    # 遍历list字面值
    $sum += $salaries[$count];
}

foreach $index (0..99){            # 遍历以范围表示的list字面值
    $sum += $list[$index];
}

$sum += $list[$_] foreach (0..99); # 作为语句修饰符使用，这里用隐式变量$_保存遍历时的数组元素

@names = ("Al", "Bob", "Jake");
@rnames = reverse @names;       # 数组逆序，结果为("Jake", "Bob", "Al")

$name = "adam";
$rname = reverse $name;         # scala变量会被强制转换为字符串，并逆序，这里就是"mada"

@sorted_names = sort @names;    # 排序数组，直接这样使用sort操作符的话，其中每个元素被强制转换为
                                # 字符串并以字典序排序

@list = (42, 68, 10, 5, 103);
@sorted_list = sort @list;      # 所以这里以字典序排序的结果不是我们想要的，如何让sort操作符按
                                # 数值排序会在后面涉及

@valentine = ("I love you!") x 5; # 创建包含5个同样字符串的数组
@list = (0) x @list;              # 由于x右侧值为scala，这里右边的@list会被转换为其长度，所以
                                  # 结果是将该list所有元素置0

@list = ('little', 'green', 'apples');
chop(@list);       # 对数组中每个字符串使用chop，并返回最后一个字符串中被截取的末尾字符，这里
                   # 就是‘s’

@input = <STDIN>;
chomp(@input);     # 对数组中每个字符串使用chomp，并返回总共删除的行分隔符的数量

@list = (2, 4, 6, 8, 10);
splice (@list, 3);             # 去掉index从3开始的元素，现在list值为(2, 4, 6)

@list = (2, 4, 6, 8, 10);
splice (@list, 2, 2);          # 去掉index从2开始的2个元素，现在list值为(2, 4, 10)

@list = (1, 2, 3, 4, 5);
@new = (7, 6);
splice (@list, 2, 2, @new);    # 去掉index从2开始的2个元素并插入新元素，
                               # 现在list值为(1, 2, 7, 6, 5)

@list = (1, 2, 3, 4, 5);
@new = (7, 6);
splice (@list, 2, 0, @new);    # 也可以不删除元素，插入新元素，现在list值为
                               # (1, 2, 7, 6, 3, 4, 5)

@list = (1, 2, 3, 4, 5);
splice (@list, 2, 2, 9, 8, 7); # 还可以把新元素的值直接写在参数中（从第4个参数开始），现在list
                               # 值为(1, 2, 9, 8, 7, 5)                               

push @stack1, "Mary";

push @stack2, (9, 11, 13);

push @stack2, 9, 11, 13;   # 等价于 push(@stack2, 9, 11, 13)

$value = pop @stack1;

@list = ("bob", "carol", "ted");
@name = shift @list;       # shift与pop类似，只是在数组开头弹出元素
unshift @list , "mikie";   # unshift与push类似，只是在数组开头压入新元素

push @list, shift(@list);  # 结合push和shift可以循环转动元素（rotate）
unshift @list, pop(@list); # 类似上面的操作，只是方向相反

@fruit = split /,/, "apples,gwapes,pineapples,cannonballs", 3;
# 结果为("apples", "gwapes", "pineapples,cannonballs")

@fruit = split /,/, "apples,gwapes,pineapples,cannonballs";
# 结果为("apples", "gwapes", "pineapples", "cannonballs")

@fruit = split /,/; # 用给定的正则表达式对$_执行split操作

@fruit = split ;    # 用空白符（即/\s/）对$_执行split操作

# 方法一
foreach $index (0 .. $#ARGV) {
    print "$ARGV[$index] \n";
}

# 方法二
$num_args = $#ARGV + 1;
for ($count = 1; $count <= $sum_args; $count++){
    $argument = shift(@ARGV);
    print "$argument \n";
}

# 由于pop和shift有默认参数@ARGV，所以下述代码可以替代方法二中for循环里的$argument = shift(@ARGV);
$argument = shift;

# Perl中并没有Hash字面值，取而代之的是如下所示的list字面值：
("bob", 42, "carol", 40, "ted", 29)

# =>符号可以替换其中的部分逗号来使其更加具有可读性
("bob" => 42, "carol" => 40, "ted" => 29)

# =>左侧的值会被隐式地加上引号
(print => "yes") # 等价于("print" => "yes")

# 当数组赋值给hash时，奇数位值作为键，偶数位作为对应的值
@list = ("Grumpy" => 44, "Sleepy" => 27, "Maxine" => 79);
%dwarfs_ages = @list;
%salaries = ("Bill" => 79_500, "Billy" => 43_000, "Billie" => 55_200);

# 当hash的值赋给数组时，按键值对展开，但顺序是任意的，例如上面的%salaries赋给数组可能会得到如下结果：
("Billie", 55200, "Billy", 43000, "Bill", 79500);

$salaries{"Billy"}             # 43000
$salaries{"Willie"} = 47000;   # 插入新的键值对或更改已有键对应的值
$salaries{Bill} += 500;        # {}中间的键是隐式加上引号的，相当于$salaries{"Bill"} += 500

# 将hash置空的两种方式
%salaries = ();
undef %salaries;

# hash变量在引号中不会被解释，以防止与printf中的格式符冲突
print "%salaries"; # 会打印"%salaries"

# 切片
@some_salaries = @salaries{"Bill", "Billy"}; # 注意切片以@开头，因为hash切片的结果是数组

delete $salaries{"Bill"};   # 删除hash中Bill这个键及其对应的值
undef $salaries{"Billy"};   # 这并不能删除删除这个键，只能将该键对应的值设为undef
exists $salaries{"Billy"};  # 判断hash中是否存在某个键，返回布尔值

@days = keys %highs;        # 获得hash中的所有键，返回的是数组
# 可以结合foreach使用，打印出hash中的所有键值
foreach $day (keys %highs){
    print "On $day the high temperature was $highs{$day} \n";
}
$length = keys %highs;      # 获取键的数量（因为等号左侧是scala变量）

# values可以获得所有值，没有特定的顺序，没有关联的键，所以可能不是很实用
foreach $temp (values %highs) { print "$temp \n" }

# 还可以使用each操作符来遍历hash中的键值对
while(($day, $temp) = each %highs){
    print "On $day the high temperature was $temp \n";
}

$sum = 0;
$ref_sum = \$sum;
@list = (1, 3, 5, 7);
$ref_list = \@list;

$ref_list = [1, 3, 5, 7]; # list字面值也可以用[]来声明，从而得到其地址
$ref_hash = {             # hash字母值(本质上还是list字面值)可以用{}来声明，从而得到其地址
    'Bob' => '42',
    'Jake' => '12',
    'Darcie' => '11'
};
$ref_pi = \3.14159;       # 用\取得scala字面值的地址

$sum = 17;
$ref_sum = \$sum;
print "The sum is: $$ref_sum \n"; # 显示：The sum is: 17
print "The sum is: $ref_sum \n";  # 显示：The sum is: SCALAR(0xb75d3c)

$$ref_list[3] = 17;
$ref_list -> [3] = 17;       # 与上式等价

$$ref_hash{'Bob'} = '42';
$ref_hash -> {'Bob'} = '42'; # 与上式等价

$sum_name = "sum";
$$sum_name = 17;

@mat = (
    [1, 3, 5],
    [7, 9, 11],
    [13, 15, 17]
);

$ref_mat = [
    [1, 3, 5],
    [7, 9, 11],
    [13, 15, 17]
];

@row1 = (1, 3, 5);
@row2 = (7, 9, 11);
@row3 = (13, 15, 17);
@mat = (\@row1, \@row2, \@row3);

print "The (2,3) element is: $mat[2] -> [3] \n";
print "The (2,3) element is: $mat[2][3] \n";      # 两个[]之间的->可以省略
$ref_mat -> [2][2] = 17;
$$ref_mat[2][2] = 17;    # 由于$的优先级比[]高，所以该式与上式等价

# 读取矩阵的示例
$num_rows = <STDIN>;  # 输入行数
foreach $row_num (0 .. $num_rows - 1){
    $temp = <STDIN>;
    @row = split / /, $temp;
    $mat[$row_num] = [ @row ];
}

# 打印矩阵的示例
foreach $ref_row (@mat){
    print "@$ref_row";
}

# 函数声明
sub print_header;

# 函数定义
sub print_header {
    print "\n Program Output \n\n";
}

# 直接函数调用
print_header(); # 当作函数来调用
print_header;   # 当作操作符来调用

# 用在表达式中
$result = 2 * fun() + 1;
$sum = sumer();

# 下述两种带有返回值的函数等价
$pi = 3.14159;
sub two_pi_1 {
    return (2 * $pi);
}
sub two_pi_2 {
    2 * $pi;     # 如果sub块的最后不是return语句，则最后一个表达式的值将作为返回值
}

# 函数调用的上下文决定了其返回值求值时的上下文
sub sub1{
    @result = (1, 3, 5);
}
$scalar = sub1();  # 值为3
@list = sub1();    # 值为1 3 5

sub sub1{
    my $sum = 0; # 用my声明的局部变量仅在当前区块中有效
    ...
}

my($a, $b, $c);               # 声明多个局部变量
my($a, @list) = (3, 2, 7, 6); # 声明并初始化多个局部变量

# 任何非函数体的区块都可以被嵌套，所有区块中都可以定义对应的局部变量
$temp = 5; # 全局变量
{
    my $temp = 10; # 外层区块的局部变量
    if($list[$outer] > $list[$inner]){
        my $temp = $list[$inner]; # 内层区块的局部变量
        $list[$inner] = $list[$outer];
        $list[$outer] = $temp;
    }
}

sub sub2{
    local $count = 0; # 用local声明的局部变量（或者说"半局部变量"）在当前区块以及调用的函数的
                      # 函数体中有效
    addCount();
}
sub addCount{
    $count++;
}
sub2();

# 使用@_(或@ARG，前提是使用'use English')获得函数调用时传入的参数
sub adder{
    ++@ARG[0]; # 直接操作@ARG，即相当于引用传参
    ++@ARG[1];
}
$x = 7;
@list = (1, 3, 5);
adder($x, @list);   # 函数返回后，$x值为8，@list值为(2, 3, 5)

sub sub1{
    my ($x, $y, $z) = @ARG; # 新建局部变量保存传入参数，即相当于拷贝传参
    ...
}

# 当传入参数为引用类型时
sub add_1_scalar{
    my $param = $ARG[0];
    $$param++; # 解引用
}
add_1_scalar(\$sum);

# 当需要向某个函数传入当前@ARG值（调用该函数前的值），而不是新建一个@ARG时，可以这样调用函数
&sub1;

# 保存函数地址
$ref_fun = \&print_header;
$ref_fun_soft = "print_header";
$ref_fun_anonymous = sub {
    print "\n Program Output \n\n";
}
# 通过引用变量调用函数
&$ref_fun();
&$ref_fun_soft();
&$ref_fun_anonymous();

sort { $a <=> $b } @list; # 默认排序
sort { $b <=> $a } @list; # 逆序排序数值
sort { $b cmp $a } @list; # 逆序排序字符串

# 示例：将hash中的键值对按照值的大小逆序输出
foreach $key (sort { $top_five{$b} <=> $top_five{$a}; } keys %top_five){
    print "$key \t $top_five{$key} \n";
}