Perl 简介

Perl(Practical Extraction and Report Language,实用提取与报表语言)的定位就是处理文本与生成报表。

发展历程

1987  Perl 1(Larry Wall 发布)
1989  Perl 3
1991  Perl 4
1994  Perl 5(至今主流)
2000+ 大量 Web 应用(CGI 时代巅峰)
2015  Perl 6 改名 Raku(另立门户)
2023  Perl 5.38(仍在持续更新)

为什么曾如此流行

1. 文本处理能力无与伦比(正则内建)
2. 开发效率高(脚本语言)
3. 系统管理神器(Unix 世界标配)
4. 免费开源、跨平台
5. 庞大的 CPAN 模块库

Perl 的哲学

TMTOWTDI: 实现同一功能有多种方式
"易事容易,难事可能" (Easy things easy, hard things possible)
上下文敏感: 同一操作在不同上下文含义不同

my $num = 5;          # 标量上下文
my @list = (1, 2, 3); # 列表上下文

现状与定位

新项目已较少用 Perl(被 Python/Go 取代)
但仍大量存在于:
- 遗留系统维护
- Unix 系统脚本
- 生物信息等领域
- 文本处理的快速脚本

vs Python

Perl: 正则/文本更强,语法自由
Python: 可读性更好,生态更现代
选择: 新项目推荐 Python;维护老系统需要 Perl

Perl 数组(Array)

数组保存有序的标量列表,是 Perl 最常用的数据结构之一。

1. 创建数组

my @empty;
my @nums = (1, 2, 3);
my @strings = ("a", "b", "c");
my @mixed = (1, "two", 3.0);

# 范围操作符
my @range = (1..10);          # 1 到 10
my @chars = ("a".."e");       # a b c d e

# 列表逗号
my @list = (1, 2, (3, 4), 5);  # 展平 (1,2,3,4,5)

2. 访问与修改

my @arr = (10, 20, 30, 40);

$arr[0]         # 10
$arr[3]         # 40
$arr[-1]        # 40 倒数第一个
$arr[-2]        # 30

# 修改
$arr[1] = 99;

# 自动扩展
$arr[5] = 60;    # 自动填充 undef

# 切片
my @slice = @arr[1..3];       # (99, 30, 40)
my @multi = @arr[0, 2];       # (10, 30)

3. 常用函数

my @arr = (1, 2, 3);

push @arr, 4;          # 末尾添加 (1,2,3,4)
my $last = pop @arr;   # 取出 4
unshift @arr, 0;       # 开头添加 (0,1,2,3)
my $first = shift @arr; # 取出 0

# 其他
scalar @arr;           # 长度
$#arr;                 # 最后索引
reverse @arr;          # 反转
sort @arr;             # 排序(字符串)
sort { $a <=> $b } @arr;  # 数字排序

# splice: 通用修改
splice @arr, 1, 1;          # 删除位置 1 的 1 个
splice @arr, 1, 0, "new";   # 位置 1 插入

# join / split
my $str = join ", ", @arr;        # 数组→字符串
my @parts = split /,/, "a,b,c";   # 字符串→数组

4. 遍历数组

my @fruits = ("苹果", "香蕉", "橙子");

# foreach
foreach my $fruit (@fruits) {
    print "$fruit\n";
}

# 简写(使用 $_)
for (@fruits) {
    print "$_\n";
}

# 带索引
for my $i (0 .. $#fruits) {
    print "$i: $fruits[$i]\n";
}

# while + each(数组)
while (my ($i, $v) = each @fruits) {
    print "$i: $v\n";
}

5. 数组引用与嵌套

# 数组的数组(矩阵)
my @matrix = (
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
);

print $matrix[1][2];    # 6
print $matrix[0][0];    # 1

# 遍历
foreach my $row (@matrix) {
    foreach my $cell (@$row) {
        print "$cell ";
    }
    print "\n";
}

6. 数组去重

my @arr = (1, 2, 2, 3, 3, 3);

# 用哈希去重(保留第一次出现顺序)
my %seen;
my @unique = grep { !$seen{$_}++ } @arr;
print "@unique\n";    # 1 2 3

Perl 哈希(Hash)

哈希是键值对集合,键唯一,用于快速查找与统计。

1. 创建哈希

# 胖箭头方式(推荐)
my %person = (
    name => "张三",
    age  => 28,
    city => "北京",
);

# 逗号方式(成对)
my %colors = ("red", "#FF0000", "blue", "#0000FF");

# 匿名哈希引用
my $person_ref = {
    name => "李四",
    age  => 30,
};

2. 访问与修改

my %h = (a => 1, b => 2);

$h{a}           # 1
$h{b}           # 2

# 修改/添加
$h{c} = 3;
$h{a} = 10;

# 不存在的键返回 undef
$h{z};          # undef

# 判断存在
if (exists $h{a}) { print "存在\n"; }

# 删除
delete $h{c};

# 清空
%h = ();

3. 遍历

my %h = (a => 1, b => 2, c => 3);

# 键值对
while (my ($k, $v) = each %h) {
    print "$k = $v\n";
}

# 键
foreach my $k (keys %h) {
    print "$k\n";
}

# 值
foreach my $v (values %h) {
    print "$v\n";
}

# 注意: each 与 keys 的遍历顺序不固定
# 需要排序: sort keys %h

4. 哈希常用操作

my %h = (a => 1, b => 2, c => 3);

scalar keys %h;      # 3 键个数
scalar values %h;    # 3 值个数

# 按值排序
foreach my $k (sort { $h{$b} <=> $h{$a} } keys %h) {
    print "$k: $h{$k}\n";    # 值降序
}

# 合并
my %h1 = (a => 1);
my %h2 = (b => 2, c => 3);
my %merged = (%h1, %h2);     # 合并

5. 统计计数(经典)

my @words = ("apple", "banana", "apple", "orange", "banana", "apple");

my %count;
$count{$_}++ for @words;

foreach my $word (sort keys %count) {
    print "$word: $count{$word}\n";
}
# apple: 3
# banana: 2
# orange: 1

6. 哈希的哈希(嵌套)

my %users = (
    zhangsan => { age => 28, city => "北京" },
    lisi     => { age => 30, city => "上海" },
);

print $users{zhangsan}{age};    # 28
print $users{lisi}{city};       # 上海

# 遍历嵌套
foreach my $name (keys %users) {
    print "$name: ";
    while (my ($k, $v) = each %{ $users{$name} }) {
        print "$k=$v ";
    }
    print "\n";
}

Perl 条件语句

Perl 的 if/unless/三元运算符,以及修饰符写法(后缀)。

1. if / elsif / else

my $score = 85;

if ($score >= 90) {
    print "优秀\n";
} elsif ($score >= 60) {
    print "及格\n";
} else {
    print "不及格\n";
}

2. unless(反条件)

# unless = if not
my $error = 0;

unless ($error) {
    print "没有错误\n";
}

# 等价于
if (!$error) {
    print "没有错误\n";
}

3. 语句修饰符(后缀写法)

# Perl 特色: 条件放句尾
print "OK\n" if $success;
print "错误\n" unless $success;
die "失败" unless $ok;
print "10" if $n == 10;

# 更简洁
my $result = $ok ? "成功" : "失败";
print $result;

4. 三元运算符

my $age = 20;
my $status = $age >= 18 ? "成年" : "未成年";
print "$status\n";

# 嵌套(不推荐,可读性差)
my $grade = $score >= 90 ? "A" :
            $score >= 60 ? "B" : "C";

5. 逻辑运算

my $age = 25;
my $has_id = 1;

if ($age >= 18 && $has_id) {
    print "允许进入\n";
}

# 短路特性
my $x = 0;
$x || die "x 为假";       # x 假时执行 die

# 常见模式: 默认值
my $name = $input || "默认名";

# 逻辑运算符
&&   与
||   或
!    非
//   defined-or(已定义才用)

my $value = undef;
my $default = $value // 100;    # 100(undef 时)

6. 判断数值/字符串

# 数值判断
my $n = "abc";
if ($n =~ /^\d+$/) {
    print "是数字\n";
}

# 判断文件
if (-e "file.txt") { print "文件存在\n"; }
if (-f "file.txt") { print "是文件\n"; }
if (-d "dir")     { print "是目录\n"; }

7. given/when(实验性)

# 类似 switch(Perl 5.10+,需 use feature)
use feature 'say';
use feature 'switch';

my $day = 3;
given ($day) {
    when (1) { say "周一" }
    when (2) { say "周二" }
    when (3) { say "周三" }
    default  { say "其他" }
}
# 注: 现代 Perl 更推荐用 dispatch 表或 if-elsif

Perl 循环

Perl 提供 for、foreach、while、until 等循环,还有灵活的修饰符写法。

1. for / foreach

# for 与 foreach 可互换
for (my $i = 0; $i < 5; $i++) {
    print "$i\n";
}

# C 风格
for (my $i = 0; $i < @arr; $i++) {
    print "$arr[$i]\n";
}

# 范围
for my $i (1..5) {
    print "$i\n";
}

# 遍历数组
foreach my $fruit ("苹果", "香蕉") {
    print "$fruit\n";
}

# 默认变量 $_
for (1..3) {
    print "$_\n";    # 1 2 3
}

2. while / until

# while: 条件为真时循环
my $count = 0;
while ($count < 5) {
    print "$count\n";
    $count++;
}

# until: 条件为假时循环(until = while not)
my $n = 0;
until ($n >= 3) {
    print "$n\n";
    $n++;
}

# 读取文件行(经典)
open my $fh, "<", "data.txt" or die $!;
while (my $line = <$fh>) {
    chomp $line;
    print "$line\n";
}

3. 语句修饰符循环

# Perl 特色: 单行循环
print "$_\n" for (1..3);
print "$_\n" foreach @arr;
$i++ while $i < 10;

# 无限循环 + last
while (1) {
    print "无限\n";
    last;    # 退出
}

4. last / next / redo

# last: 退出循环(相当于 break)
for (1..10) {
    last if $_ == 5;      # 1 2 3 4
    print "$_\n";
}

# next: 跳过本次(相当于 continue)
for (1..10) {
    next if $_ % 2 == 0;  # 只打印奇数
    print "$_\n";
}

# redo: 重做本次
my $attempt = 0;
while (1) {
    $attempt++;
    if ($attempt < 3) {
        redo;             # 重新执行本次
    }
    last;
}
print "attempt = $attempt\n";   # 3

5. 循环标签

# 嵌套循环跳出外层
OUTER: for my $i (1..3) {
    for my $j (1..3) {
        next OUTER if $j == 2;    # 跳到外层下一次
        print "($i, $j)\n";
    }
}
# 输出: (1,1) (2,1) (3,1)

6. 循环与哈希

my %count;
$count{$_}++ for ("a", "b", "a");

# 遍历键
for my $k (sort keys %count) {
    print "$k: $count{$k}\n";
}

# while + each(不创建大列表,省内存)
while (my ($k, $v) = each %count) {
    print "$k = $v\n";
}

Perl 运算符

Perl 运算符丰富,最独特的是数字与字符串两套比较运算符。

1. 算术运算符

+   -   *   /   %   **(幂)  ++  --

my $sum = 10 + 5;       # 15
my $diff = 10 - 5;      # 5
my $prod = 10 * 5;      # 50
my $quot = 10 / 3;      # 3.333(浮点!)
my $mod = 10 % 3;       # 1
my $pow = 2 ** 10;      # 1024

# 自增自减
my $i = 0;
$i++;                   # 1
++$i;                   # 2(前缀先加后返回)

# 字符串自动转数字
"10" + "20";            # 30

2. 字符串运算符

.      拼接
x      重复

"Hello" . " " . "World";   # "Hello World"
"ab" x 3;                  # "ababab"
"-" x 20;                  # 分隔线

# 字符串重复
my $line = "=" x 30;

3. 比较运算符(两套!)

# 数字比较
==   !=   <   >   <=   >=   <=>

# 字符串比较
eq   ne   lt  gt  le  ge  cmp

if (10 == "10")       { }  # 数字: 相等
if ("10" eq "10")     { }  # 字符串: 相等
if ("10" lt "9")      { }  # 字符串比较(字典序): 真!
if (10 < 9)           { }  # 数字比较: 假

# 飞船运算符(排序用)
5 <=> 3;    # 1
3 <=> 5;    # -1
3 <=> 3;    # 0
"a" cmp "b";  # -1

4. 逻辑与位运算符

# 逻辑
&&   ||   !     # 优先用这些(短路)

# 短路示例
$ok && do_something();    # ok 为真才执行
$err || die "失败";        # err 为假才 die

# 位运算
&   |   ^   ~   <<   >>

my $a = 0b1100;
my $b = 0b1010;
$a & $b;      # 0b1000
$a | $b;      # 0b1110
$a ^ $b;      # 0b0110
$a << 1;      # 左移

5. 赋值运算符

$x += 5;    # 等价 $x = $x + 5
$x -= 5;
$x *= 2;
$x /= 2;
$x %= 3;
$x .= "str";    # 字符串追加
$x **= 2;
$x ||= "default";   # 假值才赋值
$x //= "default";   # undef 才赋值(常用)

# 经典模式
$count{$key} += 1;      # 计数
$total //= 0;           # 初始化

6. 引用与特殊运算符

\   引用运算符
->   解引用箭头
,    逗号(列表)
=>   胖箭头(哈希)

# 三元
$max = $a > $b ? $a : $b;

# 文件测试
-e  存在   -f  文件   -d  目录
-r  可读   -w  可写   -x  可执行
-z  空文件 -s  文件大小

# 范围
1..10    # 列表范围
'a'..'z'

Perl 时间日期

Perl 提供 time、localtime、gmtime 等时间函数,还有 DateTime 模块。

1. 时间戳

# 当前时间戳(秒)
my $now = time();
print "$now\n";

# 格式化时间戳
my $local = localtime();
print "$local\n";     # Mon Aug 18 12:00:00 2026

my $utc = gmtime();
print "$utc\n";       # UTC 时间

2. localtime 列表

my @lt = localtime();
# (sec, min, hour, mday, mon, year, wday, yday, isdst)

my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = localtime();

$year += 1900;    # 年份从 1900 起
$mon += 1;        # 月份 0-11

print "$year-$mon-$mday $hour:$min:$sec\n";
# 2026-8-18 12:0:5

3. 格式化输出

# POSIX 函数
use POSIX qw(strftime);

my $ts = time();
my $date = strftime("%Y-%m-%d %H:%M:%S", localtime($ts));
print "$date\n";    # 2026-08-18 12:00:05

# 常用格式
strftime("%Y-%m-%d", localtime)          # 2026-08-18
strftime("%H:%M:%S", localtime)          # 12:00:05
strftime("%A", localtime)                # Tuesday
strftime("%B", localtime)                # August
strftime("%Y%m%d_%H%M%S", localtime)     # 文件名友好

4. 时间计算

use POSIX qw(strftime);

# 加减秒
my $tomorrow = time() + 86400;      # +1 天
my $next_hour = time() + 3600;      # +1 小时

# 计算时间差
my $start = time();
# ... 执行任务 ...
my $elapsed = time() - $start;
print "耗时 $elapsed 秒\n";

# 特定日期
use Time::Local;
my $epoch = timelocal(0, 0, 12, 18, 7, 2026);
# 2026-08-18 12:00:00

5. DateTime 模块(推荐)

cpanm DateTime

use DateTime;

my $dt = DateTime->now;
print $dt->ymd, "\n";            # 2026-08-18
print $dt->hms, "\n";            # 12:00:05

# 创建特定时间
my $dt2 = DateTime->new(
    year => 2026,
    month => 8,
    day => 18,
    hour => 12,
);
print $dt2->strftime("%Y/%m/%d"), "\n";

# 计算
my $later = $dt->clone->add(days => 7);
my $diff = $later->subtract_datetime($dt);
print $diff->days, " 天\n";      # 7

# 时区
my $beijing = DateTime->now(time_zone => "Asia/Shanghai");
print $beijing->hms;

6. 常见应用

# 日志时间戳
use POSIX qw(strftime);
sub log_msg {
    my ($msg) = @_;
    my $ts = strftime("%Y-%m-%d %H:%M:%S", localtime);
    print "[$ts] $msg\n";
}
log_msg("程序启动");

# 日期文件命名
my $filename = strftime("backup_%Y%m%d.tar.gz", localtime);
print "$filename\n";

Perl 子程序(Subroutine)

子程序是 Perl 的代码复用单元,参数通过 @_ 传递。

1. 定义与调用

# 定义
sub greet {
    print "Hello!\n";
}

# 调用
greet();
greet;    # 也可省略括号

# 带参数
sub say_hello {
    my ($name) = @_;
    print "你好, $name\n";
}
say_hello("张三");

# 提前定义或用 & 调用(不推荐)
&greet;

2. 参数处理

sub add {
    my ($a, $b) = @_;     # 标准方式: 解构 @_
    return $a + $b;
}

print add(3, 5), "\n";   # 8

# 多参数
sub max {
    my $max = shift @_;   # shift 取出第一个
    foreach my $n (@_) {
        $max = $n if $n > $max;
    }
    return $max;
}

print max(3, 7, 5, 9), "\n";   # 9

# 数组与哈希参数
sub process {
    my ($name, @args) = @_;      # 第一个是标量,其余数组
    my ($name, %opts) = @_;      # 或第一个标量,其余哈希
}

3. 返回值

# 返回标量
sub square { return $_[0] ** 2; }
my $s = square(5);       # 25

# 返回列表
sub get_pair {
    return (1, 2);
}
my ($a, $b) = get_pair();   # 1 2

# 返回哈希
sub get_config {
    return (name => "app", version => "1.0");
}
my %config = get_config();

# 没有 return: 返回最后一个表达式
sub add2 { $_[0] + $_[1] }

# 上下文敏感返回
sub get_list {
    return (1, 2, 3);
}
my @list = get_list();      # 列表上下文 (1,2,3)
my $n = get_list();         # 标量上下文 3(个数!)

4. 原型(Prototypes)

# 原型限制参数
sub add(\$\$) { }       # 两个标量引用
sub my_push(\@@) { }    # 数组引用 + 列表

# 但原型限制多,现代 Perl 推荐签名
use feature 'signatures';   # Perl 5.36+ 默认

sub greet($name) {
    print "你好, $name\n";
}

sub add($a, $b) {
    return $a + $b;
}

# 签名特性
use feature 'signatures';
sub config($name, $version = "1.0") {   # 默认值
    ...
}

5. 递归

sub factorial {
    my ($n) = @_;
    return 1 if $n <= 1;
    return $n * factorial($n - 1);
}

print factorial(5), "\n";   # 120

# 斐波那契(带缓存)
my %cache;
sub fib {
    my ($n) = @_;
    return $n if $n < 2;
    return $cache{$n} //= fib($n-1) + fib($n-2);
}
print fib(30), "\n";

6. 子程序引用

# 匿名子程序
my $func = sub {
    my ($x) = @_;
    return $x * 2;
};
print $func->(5), "\n";    # 10

# 回调
sub apply {
    my ($func, $value) = @_;
    return $func->($value);
}
print apply(sub { $_[0] ** 2 }, 4), "\n";   # 16

# map / grep 中使用
my @nums = (1, 2, 3, 4);
my @doubled = map { $_ * 2 } @nums;
my @evens = grep { $_ % 2 == 0 } @nums;

Perl 引用(Reference)

引用是指向数据的指针,用于构建复杂数据结构与传参。

1. 创建引用

my @arr = (1, 2, 3);
my $arr_ref = \@arr;      # 数组引用

my %hash = (a => 1);
my $hash_ref = \%hash;    # 哈希引用

my $scalar = 5;
my $scalar_ref = \$scalar; # 标量引用

# 匿名引用(推荐)
my $arr_ref2 = [1, 2, 3];          # 匿名数组
my $hash_ref2 = { name => "张三" }; # 匿名哈希
my $code_ref = sub { "匿名子程序" }; # 匿名子程序

2. 解引用

my $arr_ref = [1, 2, 3];
my $hash_ref = { name => "张三" };

# 完整解引用
my @arr = @$arr_ref;         # 整个数组
my %hash = %$hash_ref;       # 整个哈希

# 元素访问
$arr_ref->[0];        # 1
$hash_ref->{name};    # "张三"

# 或
$$arr_ref[0];
$$hash_ref{name};

# 多层
my $data = { users => [ { name => "张三" } ] };
$data->{users}[0]{name};     # "张三"

3. 引用类型判断

my $arr = [1, 2];
my $hash = {a => 1};
my $code = sub { };

ref($arr);      # ARRAY
ref($hash);     # HASH
ref($code);     # CODE
ref("str");     # 空字符串(非引用)

# 根据类型处理
sub process_ref {
    my ($ref) = @_;
    my $type = ref($ref);
    if ($type eq "HASH") {
        print "键: ", join(", ", keys %$ref), "\n";
    } elsif ($type eq "ARRAY") {
        print "元素: ", scalar @$ref, " 个\n";
    }
}

4. 传引用给函数(避免复制)

# 大数组传引用高效
sub sum {
    my ($arr_ref) = @_;
    my $total = 0;
    $total += $_ for @$arr_ref;
    return $total;
}

my @big = (1..100000);
print sum(\@big), "\n";

# 修改原数据
sub add_to_first {
    my ($arr_ref) = @_;
    $arr_ref->[0] += 100;
}

my @nums = (1, 2, 3);
add_to_first(\@nums);
print "@nums\n";    # 101 2 3

5. 复杂数据结构

# 数组的数组(矩阵)
my $matrix = [
    [1, 2, 3],
    [4, 5, 6],
];
print $matrix->[1][2];    # 6

# 哈希的数组
my $people = [
    { name => "张三", age => 28 },
    { name => "李四", age => 30 },
];
foreach my $p (@$people) {
    print "$p->{name}: $p->{age}\n";
}

# 哈希的哈希
my $scores = {
    math => { zhangsan => 90, lisi => 85 },
    english => { zhangsan => 88, lisi => 92 },
};
print $scores->{math}{zhangsan};   # 90

6. 序列化与反序列化

# 存储到文件/传递
use Storable;    # 内置

my $data = { name => "张三", scores => [1, 2, 3] };

# 序列化到字符串
my $frozen = Storable::freeze($data);
# 反序列化
my $copy = Storable::thaw($frozen);

# 存文件
Storable::store($data, "data.stor");
my $loaded = Storable::retrieve("data.stor");

# JSON(常用于 API)
use JSON::PP;
my $json = encode_json($data);
my $back = decode_json($json);

Perl 格式化输出

Perl 的 printf/sprintf 与 format 语句用于生成对齐的报表。

1. printf 格式化

# printf: 直接输出
printf "%s 今年 %d 岁\n", "张三", 28;

# sprintf: 返回字符串
my $str = sprintf "%s-%d", "v", 1;
print "$str\n";    # v-1

# 常用格式
%s   字符串
%d   整数
%f   浮点
%e   科学计数
%x   十六进制
%o   八进制
%b   二进制
%%   百分号

2. 宽度与对齐

# 宽度与对齐
printf "|%10s|\n", "right";    # 右对齐
printf "|%-10s|\n", "left";    # 左对齐
printf "|%10d|\n", 42;
printf "|%-10d|\n", 42;

# 补零
printf "%05d\n", 42;       # 00042
printf "%08.2f\n", 3.14;   # 00003.14

# 浮点精度
printf "%.2f\n", 3.14159;  # 3.14
printf "%.0f\n", 3.5;      # 4(四舍五入)

3. 表格输出

# 对齐列
my @rows = (
    ["张三", 28, 90.5],
    ["李四", 30, 85.0],
    ["王五", 25, 95.5],
);

printf "%-8s %4s %8s\n", "姓名", "年龄", "分数";
printf "%-8s %4s %8s\n", "-" x 8, "-" x 4, "-" x 8;

foreach my $row (@rows) {
    printf "%-8s %4d %8.1f\n", @$row;
}

# 输出:
# 姓名      年龄    分数
# -------- ---- --------
# 张三       28    90.5
# 李四       30    85.0
# 王五       25    95.5

4. format 报表

# Perl 传统 format(类似 awk 风格)
my $name = "张三";
my $age = 28;

format STDOUT =
姓名: @<<<<<<  年龄: @##  状态: @<<<
      $name,        $age,  "在职"
.
write;

# 字段格式:
# @<<<<<<  左对齐字符串
# @>>>>>>  右对齐字符串
# @||||||  居中对齐
# @####    右对齐数字
# @<<<@<<< 多字段

# 表格 format
format REPORT =
=====================
@<<<<<<<  @####.##
$name,    $price
.
$~ = "REPORT";
write;

5. 输出到文件

open my $fh, ">", "report.txt" or die $!;

printf $fh "%-8s %4s\n", "姓名", "分数";
printf $fh "%-8s %4d\n", "张三", 90;

# 或 select 切换默认句柄
select $fh;
$~ = "REPORT";
write;
select STDOUT;

close $fh;

6. 常见技巧

# 数字千分位
sub format_num {
    my ($n) = @_;
    my $str = reverse $n;
    $str =~ s/(\d{3})(?=\d)/$1,/g;
    return reverse $str;
}
print format_num(1234567), "\n";   # 1,234,567

# 日期格式化(见时间日期章节)
# 输出 JSON 格式化
use JSON::PP;
my $pretty = JSON::PP->new->pretty->encode($data);

Perl 文件操作

Perl 的文件操作简单强大,配合正则可以做各种文本处理。

1. 打开文件

# 读取
open my $fh, "<", "data.txt" or die "打开失败: $!";

# 写入(覆盖)
open my $fh, ">", "out.txt" or die $!;

# 追加
open my $fh, ">>", "log.txt" or die $!;

# 读写
open my $fh, "+<", "data.txt" or die $!;

# 编码(Perl 5.16+)
open my $fh, "<:encoding(UTF-8)", "data.txt" or die $!;
open my $fh, ">:encoding(UTF-8)", "out.txt" or die $!;

2. 读取文件

# 逐行读取(推荐,内存友好)
open my $fh, "<", "data.txt" or die $!;
while (my $line = <$fh>) {
    chomp $line;
    print "行: $line\n";
}
close $fh;

# 一次性读取全部
my $content = do { local $/; open my $fh, "<", "data.txt" or die $!; <$fh> };

# 读入数组
my @lines = <$fh>;    # 每行一个元素(带换行)

# 读取固定字节
read $fh, my $buf, 1024;

3. 写入文件

open my $fh, ">", "out.txt" or die $!;

print $fh "第一行\n";
print $fh "第二行\n";

# 或
say $fh "第三行";     # 需 use feature 'say';

close $fh;

# 快速写
use File::Slurp qw(write_file);
write_file("out.txt", "内容");

# 快速读
use File::Slurp qw(read_file);
my $content = read_file("data.txt");

4. 文件测试

# 常用文件测试操作符
-e "file.txt"    存在
-f "file.txt"    是普通文件
-d "dir"         是目录
-r "file"        可读
-w "file"        可写
-x "file"        可执行
-z "file"        空文件
-s "file"        文件大小
-M "file"        修改时间(天前)

if (-e "config.ini") {
    print "配置存在\n";
}

# 组合
if (-f $file && -r $file) {
    print "可读的普通文件\n";
}

5. 文件操作函数

rename "old.txt", "new.txt";    # 重命名
unlink "temp.txt";              # 删除
copy 文件: use File::Copy qw(copy move);
copy("a.txt", "b.txt");
move("a.txt", "dir/a.txt");

# 文件信息
my $size = -s "data.txt";
my $mtime = (stat "data.txt")[9];    # 修改时间

# 时间转换
use POSIX qw(strftime);
my $date = strftime("%Y-%m-%d", localtime($mtime));

6. 文本处理实战

# 统计行数/单词数
open my $fh, "<", "data.txt" or die $!;
my ($lines, $words) = (0, 0);
while (<$fh>) {
    $lines++;
    $words += split /\s+/;
}
close $fh;
print "行数: $lines, 单词数: $words\n";

# 替换文件内容
local $/;   # 读取整个文件
open my $fh, "<", "data.txt" or die $!;
my $content = <$fh>;
close $fh;

$content =~ s/old/new/g;

open my $out, ">", "data.txt" or die $!;
print $out $content;
close $out;

# 原地修改
perl -i.bak -pe 's/foo/bar/g' data.txt

Perl 目录操作

Perl 通过 opendir/readdir 或 File::Find 处理目录与遍历。

1. 打开与读取目录

# 列出目录内容
opendir my $dh, "." or die $!;
my @files = readdir $dh;
closedir $dh;

foreach my $f (sort @files) {
    print "$f\n";
}
# 包含 . 和 ..

# 排除 . ..
my @real = grep { $_ ne "." && $_ ne ".." } readdir $dh;

2. 只列出文件/目录

opendir my $dh, "." or die $!;
my @names = readdir $dh;
closedir $dh;

# 只留文件
my @files = grep { -f $_ } @names;

# 只留目录
my @dirs = grep { -d $_ } @names;

# 过滤扩展名
my @txt = grep { /\.txt$/ } @names;

# 更清晰: 完整路径
foreach my $name (@names) {
    my $path = "./$name";
    next unless -f $path;
    print "$path\n";
}

3. 创建与删除目录

mkdir "new_dir";            # 创建
mkdir "a/b/c", 0755;        # 注意: 只创建一层

# 递归创建
use File::Path qw(make_path remove_tree);
make_path("a/b/c");

# 删除
rmdir "empty_dir";          # 只删空目录
remove_tree("a");           # 递归删除

# 检查
if (-d "dir") { print "存在\n"; }

4. 递归遍历(File::Find)

use File::Find;

my @all_files;
find(sub {
    # $_ 是文件名, $File::Find::name 是完整路径
    push @all_files, $File::Find::name if -f;
}, ".");

print "共 " . scalar @all_files . " 个文件\n";

# 查找大文件
find(sub {
    my $size = -s;
    if ($size > 1_000_000) {   # > 1MB
        print "$File::Find::name: $size 字节\n";
    }
}, ".");

5. 备份与归档

# 批量重命名
opendir my $dh, "." or die $!;
my @files = grep { /\.jpg$/ } readdir $dh;
closedir $dh;

foreach my $f (@files) {
    my $new = $f;
    $new =~ s/\.jpg$/\.JPG/;
    rename $f, $new;
}

# 压缩归档
system "tar czf backup.tar.gz mydir";
system "zip -r backup.zip mydir";

# 或 Perl 方式
use Archive::Tar;
my $tar = Archive::Tar->new;
$tar->add_files("a.txt", "b.txt");
$tar->write("backup.tar");

6. 路径处理

use File::Basename;
use File::Spec;

my $path = "/tmp/data/file.txt";

basename($path);      # file.txt
dirname($path);       # /tmp/data
fileparse($path);     # ("file.txt", "/tmp/data/")

# 拼接路径(跨平台)
my $full = File::Spec->catfile("dir", "sub", "file.txt");
print "$full\n";

# 当前目录
use Cwd qw(getcwd);
print getcwd, "\n";

Perl 错误处理

Perl 使用 die/eval/Try::Tiny 处理错误,习惯与异常语言不同。

1. die 与 $!

# die: 终止程序并输出错误
open my $fh, "<", "missing.txt" or die "无法打开: $!";
# $! 保存系统错误信息

# 自定义错误
die "参数无效\n";

# 更友好的退出
die "错误信息" if $condition;
exit 1 if $condition;    # 仅退出码

# 检查返回值
my $result = risky_op() or die "操作失败";

2. eval 捕获错误

# eval: 捕获 die(类似 try)
eval {
    die "发生错误";
    # 其他危险操作
};

if ($@) {    # $@ 保存错误信息
    print "捕获到: $@";
}

# 处理失败恢复
eval {
    open my $fh, "<", "data.txt" or die "打开失败: $!";
    # 读取处理...
};
if ($@) {
    warn "读取失败: $@, 使用默认数据";
    $data = "default";
}

3. warn 警告

# warn: 输出警告但不终止
warn "警告: 配置缺失,使用默认值\n";

# 条件警告
warn "文件不存在" unless -e "config.ini";

# 带调用位置
warn "问题发生在第 $.(?) 行";

# 自定义警告处理
local $SIG{__WARN__} = sub {
    my ($msg) = @_;
    open my $log, ">>", "warnings.log" or die $!;
    print $log $msg;
    close $log;
};

4. 错误对象(Carp)

# Carp: 从调用者角度报错
use Carp qw(carp croak confess);

carp "警告信息";       # 从调用者行号报错
croak "致命错误";      # 从调用者行号终止
confess "详细堆栈";    # 打印调用栈

# 库开发推荐使用
sub process {
    my ($data) = @_;
    croak "参数必须是引用" unless ref $data;
}

5. Try::Tiny 模块(推荐)

cpanm Try::Tiny

use Try::Tiny;

try {
    risky_operation();
} catch {
    # $_ 是错误信息
    warn "捕获错误: $_";
} finally {
    # 无论成败都执行
    cleanup();
};

# 返回值
my $result = try {
    compute();
} catch {
    "默认值";    # 出错时返回
};

6. 最佳实践

1. use strict; use warnings; 必须开
2. 打开文件/数据库等资源用 or die
3. 可能失败的库调用处理返回值
4. 用 eval/Try::Tiny 隔离可恢复错误
5. 库代码用 Carp::croak 报告错误
6. 关键路径记录日志(Log::Log4perl)
7. 不要用裸 $@ 判断(会踩空)

# 日志模块
use Log::Log4perl qw(get_logger);
Log::Log4perl->easy_init($Log::Log4perl::INFO);
my $log = get_logger();
$log->info("开始任务");
$log->error("出错了: $!");

Perl 特殊变量

Perl 有大量内置特殊变量,掌握常用几个事半功倍。

1. 默认变量 $_

# $_ 是许多函数的默认参数
$_ = "hello";
print;               # 默认打印 $_
print "$_\n";

# 循环中自动设置
for (1..3) {
    print "$_\n";    # 1 2 3
}

# grep/map 默认
my @evens = grep { $_ % 2 == 0 } (1..10);
my @doubled = map { $_ * 2 } (1..3);

# while(<>) 文件读取
while (<>) {          # 读入到 $_
    print;            # 打印
}

2. 输入/输出相关

# $/: 输入行分隔符(默认 \n)
local $/ = undef;     # 读整个文件
my $all = <$fh>;

# $\: 输出行分隔符
local $\ = "\n";
print "a", "b";       # 自动换行

# $,: 输出字段分隔符
local $, = ", ";
print @array;         # 元素逗号分隔

# $|: 自动刷新缓冲区
$| = 1;               # 立即输出(管道时重要)

# $.: 当前输入行号
while (<>) {
    print "第 $. 行: $_";
}

3. 参数与进程

@ARGV   命令行参数
$0      程序名
$$      当前进程 ID
$?      子进程退出状态
$!      系统错误信息
$@      eval 错误信息

# 命令行参数处理
my $script = $0;
my @args = @ARGV;

print "程序: $script, PID: $$\n";
foreach my $arg (@ARGV) {
    print "参数: $arg\n";
}

# 退出状态
system("ls /tmp");
print "退出码: $?\n";    # 128 的倍数+信号

4. 正则相关

$&      上次匹配的字符串
$`      匹配之前的
$'      匹配之后的
$1 $2   捕获组
@+      各捕获结束位置

"hello world" =~ /(\w+) (\w+)/;
print "$1 $2\n";       # hello world

# 全局匹配后
"abc" =~ /b/;
print "$` $& $'\n";    # a b c

5. 数组相关

@_      子程序参数
@ARGV   命令行参数
@INC    模块搜索路径
@+      正则捕获位置
$[      数组起始索引(默认 0,勿改)

# 子程序中
sub sum {
    my $total = 0;
    $total += $_ for @_;
    return $total;
}
print sum(1, 2, 3), "\n";   # 6

6. 其他常用特殊变量

%ENV    环境变量
$ENV{PATH}
$ENV{HOME}

$^I     原地编辑备份后缀
perl -i.bak -pe 's/x/y/' file

$^V     Perl 版本
print "$^V\n";    # v5.38.2

$^W     警告开关
$]      Perl 版本号(数字)

# 修改环境变量
$ENV{PATH} = "/usr/bin:$ENV{PATH}";
delete $ENV{SECRET};

Perl 正则表达式

正则表达式是 Perl 的灵魂,内建于语言中,处理文本效率极高。

1. 匹配(=~ m//)

my $str = "Hello World 2026";

# 匹配
if ($str =~ /World/) {
    print "包含 World\n";
}

# 忽略大小写 i
if ($str =~ /world/i) {
    print "忽略大小写匹配\n";
}

# 不匹配 !~
if ($str !~ /foo/) {
    print "不包含 foo\n";
}

# 匹配并捕获
if ($str =~ /(\w+) (\w+)/) {
    print "$1 $2\n";    # Hello World
}

# 绑定到默认变量
$_ = "abc123";
if (/\d+/) {
    print "含数字: $&\n";   # 123
}

2. 元字符

.      任意字符(除换行)
\d     数字     \D     非数字
\w     单词字符  \W     非单词
\s     空白     \S     非空白
\b     单词边界  \B     非边界
^      行首     $      行尾
\n 换行 \t 制表

# 示例
"abc123" =~ /\d+/;        # 123
"hello" =~ /^h/;           # 行首 h
"hello" =~ /o$/;           # 行尾 o
"a b" =~ /\s/;            # 空白

3. 量词

*   0 次或多次
+   1 次或多次
?   0 次或 1 次
{n} 恰好 n 次
{n,} 至少 n 次
{n,m} n 到 m 次

# 贪婪 vs 懒惰
"aaa" =~ /a+/;       # 贪婪: 全部 aaa
"aaa" =~ /a+?/;      # 懒惰: 只匹配 a

"xy" =~ /<.*>/;    # 贪婪: 整行
"xy" =~ /<.*?>/;   # 懒惰: 

# 分组 ()
"hello world" =~ /(hello) (world)/;   # $1 $2

# 交替 |
"cat" =~ /cat|dog/;      # 匹配 cat
"dog" =~ /cat|dog/;      # 匹配 dog

# 非捕获组 (?:)
"abc" =~ /(?:ab)c/;      # 不设 $1

# 命名捕获
"2026-08-18" =~ /(?\d{4})-(?\d{2})/;
print "$+{year}-$+{mon}\n";   # 2026-08

# 反向引用 \1
"ab ab" =~ /(\w+) \1/;    # 匹配重复词

[abc]     a/b/c 之一
[a-z]     小写字母
[0-9]     数字
[^a-z]    非小写字母
[\d_]    数字或下划线

# 示例
"abc" =~ /[a-c]/;      # 匹配
"123" =~ /[0-9]{3}/;   # 三个数字

# POSIX 类
[[:alpha:]]  字母
[[:digit:]]  数字
[[:space:]]  空白
[[:alnum:]]  字母数字

# 替换 s///
my $s = "Hello World";
$s =~ s/World/Rust/;
print "$s\n";    # Hello Rust

# 全局 g
$s =~ s/o/O/g;
print "$s\n";    # HellO WOrld

# 忽略大小写 i
$s =~ s/hello/HI/i;

# 保留原值(副本)
(my $new = $s) =~ s/Hello/Hi/;

# 分割 split
my @parts = split /[,\s]+/, "a, b,  c";
# ("a", "b", "c")

# 连接 join(非正则)
my $str = join "-", @parts;

i   忽略大小写
g   全局匹配
m   多行模式(^ $ 匹配每行)
s   单行模式(. 匹配换行)
x   扩展模式(允许空格注释)
u   Unicode

# 多行
my $text = "line1\nline2";
$text =~ /^line2/m;     # 匹配

# 忽略空白与注释
$text =~ /
    \d{4}     # 年份
    -\d{2}    # 月份
    -\d{2}    # 日
/x;