Perl 面试问题

• Perl 是一种稳定、跨平台的编程语言。

• 尽管 Perl 官方上不是首字母缩略词，但一些人将其用作**Practical Extraction and Report Language**（实用提取和报告语言）。

• 它被用于公共和私营部门的关键项目。

• Perl 是一种*开源*软件，根据其*Artistic License*或*GNU 通用公共许可证 (GPL)* 许可。

• Perl 由 Larry Wall 创建。

• Perl 1.0 于 1987 年发布到 usenet 的 alt.comp.sources。

• 在编写本教程时，perl 的最新版本为 5.16.2

• Perl 列在*牛津英语词典*中。

• Perl 汲取了其他语言的最佳特性，例如 C、awk、sed、sh 和 BASIC 等。

• Perl 的数据库集成接口 DBI 支持第三方数据库，包括 Oracle、Sybase、Postgres、MySQL 等。

• Perl 可以处理 HTML、XML 和其他标记语言。

• Perl 支持 Unicode。

• Perl 兼容 Y2K。

• Perl 支持过程式和面向对象编程。

• Perl 通过 XS 或 SWIG 与外部 C/C++ 库交互。

• Perl 是可扩展的。从综合 Perl 档案网络 (CPAN) (CPAN) 可以获得超过 20,000 个第三方模块。

• Perl 解释器可以嵌入到其他系统中。

• 由于 Perl 具有文本处理能力和快速开发周期，因此曾经是最流行的 Web 编程语言。

• Perl 被广泛称为“互联网的胶带”。

• Perl 可以处理加密的 Web 数据，包括电子商务交易。

• Perl 可以嵌入到 Web 服务器中，从而将处理速度提高多达 2000%。

• Perl 的 mod_perl 允许 Apache Web 服务器嵌入 Perl 解释器。

• Perl 的 DBI 包使 Web 数据库集成变得简单。

是的！Perl 是一种区分大小写的编程语言。

Perl 标识符是用于标识变量、函数、类、模块或其他对象的名称。Perl 变量名以 $、@ 或 % 开头，后跟零个或多个字母、下划线和数字 (0 到 9)。

Perl 有三种基本数据类型：标量、标量数组和标量哈希，也称为关联数组。

标量是简单的变量。它们前面带有美元符号 ($) 。标量可以是数字、字符串或引用。引用实际上是变量的地址，我们将在后续章节中看到。

数组是有序的标量列表，您可以使用从 0 开始的数字索引访问它们。它们前面带有“at”符号 (@)。

哈希是键/值对的无序集合，您可以使用键作为下标来访问它们。它们前面带有百分号 (%)。

Perl 变量不需要显式声明来保留内存空间。当您为变量赋值时，声明会自动发生。等号 (=) 用于为变量赋值。

Perl 根据上下文（即变量使用的情况）以不同的方式对待相同的变量。

对标量变量的赋值会以标量上下文对右侧进行求值。

对数组或哈希的赋值会以列表上下文对右侧进行求值。

布尔上下文只是任何评估表达式真假的地方。

此上下文不仅不关心返回值是什么，甚至都不想要返回值。

此上下文仅在引号内或类似于引号的内容中发生。

单引号字符串将 perl 变量打印为字符串，而双引号字符串会对变量进行求值并用于获取变量的值。

#!/usr/bin/perl

$var = "This is string scalar!";
$quote = 'I m inside single quote - $var';
$double = "This is inside double quote - $var";

$escape = "This example of escape -\tHello, World!";

print "var = $var\n";
print "quote = $quote\n";
print "double = $double\n";
print "escape = $escape\n";

这将产生以下结果：

var = This is string scalar!
quote = I m inside single quote - $var
double = This is inside double quote - This is string scalar!
escape = This example of escape - Hello, World!

格式为 v1.20.300.4000 的文字被解析为由具有指定序数的字符组成的字符串。此格式称为 v-字符串。

v-字符串提供了一种替代且更易读的方式来构造字符串，而不是使用不太易读的插值形式“\x{1}\x{14}\x{12c}\x{fa0}”。

它用于获取当前文件名。

它用于获取当前行号。

它用于获取当前包名。

要引用数组的单个元素，您将使用美元符号 ($) 加上变量名，后跟方括号中元素的索引。

这是一个使用数组变量的简单示例：

#!/usr/bin/perl

@ages = (25, 30, 40);             
@names = ("John Paul", "Lisa", "Kumar");

print "\$ages[0] = $ages[0]\n";
print "\$ages[1] = $ages[1]\n";
print "\$ages[2] = $ages[2]\n";
print "\$names[0] = $names[0]\n";
print "\$names[1] = $names[1]\n";
print "\$names[2] = $names[2]\n";

执行后，这将产生以下结果：

$ages[0] = 25
$ages[1] = 30
$ages[2] = 40
$names[0] = John Paul
$names[1] = Lisa
$names[2] = Kumar

范围运算符 (..) 用于创建顺序数组。

#!/usr/bin/perl

@var_10 = (1..10);
@var_20 = (10..20);
@var_abc = (a..z);

print "@var_10\n";   # Prints number from 1 to 10
print "@var_20\n";   # Prints number from 10 to 20
print "@var_abc\n";  # Prints number from a to z

此处双点 (..) 称为范围运算符。这将产生以下结果：

1 2 3 4 5 6 7 8 9 10
10 11 12 13 14 15 16 17 18 19 20
a b c d e f g h i j k l m n o p q r s t u v w x y z

可以使用数组上的标量上下文来确定数组的大小 - 返回值将是数组中的元素数量。

@array = (1,2,3);
print "Size: ",scalar @array,"\n";

返回值始终是数组的物理大小，而不是有效元素的数量。

push @ARRAY, LIST - 将列表的值推送到数组的末尾。

#!/usr/bin/perl

# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins  = @coins\n";

# add one element at the end of the array
push(@coins, "Penny");
print "2. \@coins  = @coins\n";

这将产生以下结果：

1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime Nickel Penny

unshift @ARRAY, LIST - 在数组的前面添加列表，并返回新数组中的元素数量。

#!/usr/bin/perl

# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins  = @coins\n";

# add one element at the beginning of the array
unshift(@coins, "Dollar");
print "2. \@coins  = @coins\n";

这将产生以下结果：

1. @coins = Quarter Dime Nickel
2. @coins = Dollar Quarter Dime Nickel

pop @ARRAY - 弹出并返回数组的最后一个值。

#!/usr/bin/perl

# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins  = @coins\n";

# remove one element from the last of the array.
pop(@coins);
print "2. \@coins  = @coins\n";

这将产生以下结果：

1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime

shift @ARRAY - 将数组的第一个值移出并返回，将数组缩短 1 并将所有内容向下移动。

#!/usr/bin/perl

# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins  = @coins\n";

# remove one element from the beginning of the array.
shift(@coins);
print "2. \@coins  = @coins\n";

这将产生以下结果：

1. @coins = Quarter Dime Nickel
2. @coins = Dime Nickel

您还可以从数组中提取“切片” - 也就是说，您可以按顺序从数组中选择多个项目以生成另一个数组。

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

@weekdays = @days[3,4,5];

print "@weekdays\n";

这将产生以下结果 -

Thu Fri Sat

splice() 函数将删除 @ARRAY 中由 OFFSET 和 LENGTH 指定的元素，并用 LIST（如果指定）替换它们。最后，它返回从数组中删除的元素。

splice @ARRAY, OFFSET [ , LENGTH [ , LIST ] ]

以下是示例：

#!/usr/bin/perl

@nums = (1..20);
print "Before - @nums\n";

splice(@nums, 5, 5, 21..25); 
print "After - @nums\n";

这将产生以下结果：

Before − 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
After − 1 2 3 4 5 21 22 23 24 25 11 12 13 14 15 16 17 18 19 20

split() 将字符串拆分为字符串数组，并返回它。如果指定了 LIMIT，则最多拆分为该数量的字段。如果省略了 PATTERN，则按空格拆分。

split [ PATTERN [ , EXPR [ , LIMIT ] ] ]

以下是示例：

#!/usr/bin/perl

# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens";
$var_names = "Larry,David,Roger,Ken,Michael,Tom";

# transform above strings into arrays.
@string = split('-', $var_string);
@names  = split(',', $var_names);

print "$string[3]\n";  # This will print Roses
print "$names[4]\n";   # This will print Michael

这将产生以下结果：

Roses
Michael

join() 函数将 LIST 中的各个字符串连接成一个字符串，字段之间用 EXPR 的值分隔，并返回该字符串。

join EXPR, LIST

以下是示例：

#!/usr/bin/perl

# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens";
$var_names = "Larry,David,Roger,Ken,Michael,Tom";

# transform above strings into arrays.
@string = split('-', $var_string);
@names  = split(',', $var_names);

$string1 = join( '-', @string );
$string2 = join( ',', @names );

print "$string1\n";
print "$string2\n";
print "$string[3]\n";  # This will print Roses
print "$names[4]\n";   # This will print Michael

这将产生以下结果：

Rain-Drops-On-Roses-And-Whiskers-On-Kittens
Larry,David,Roger,Ken,Michael,Tom

sort() 函数根据 ASCII 数字标准对数组的每个元素进行排序。此函数具有以下语法：

sort [ SUBROUTINE ] LIST

此函数对 LIST 进行排序并返回排序后的数组值。如果指定了 SUBROUTINE，则在排序元素时应用 SUBTROUTINE 内部的指定逻辑。

#!/usr/bin/perl

# define an array
@foods = qw(pizza steak chicken burgers);
print "Before: @foods\n";

# sort this array
@foods = sort(@foods);
print "After: @foods\n";

这将产生以下结果：

Before: pizza steak chicken burgers
After: burgers chicken pizza steak

这个特殊变量是一个标量，包含所有数组的第一个索引。因为 Perl 数组使用基于 0 的索引，所以 $[ 几乎总是 0。但是，如果将 $[ 设置为 1，则所有数组都将使用基于 1 的索引。建议不要使用除 0 之外的任何其他索引。但是，让我们举一个例子来说明 $[ 变量的使用 -

#!/usr/bin/perl

# define an array
@foods = qw(pizza steak chicken burgers);
print "Foods: @foods\n";

# Let's reset first index of all the arrays.
$[ = 1;

print "Food at \@foods[1]: $foods[1]\n";
print "Food at \@foods[2]: $foods[2]\n";

这将产生以下结果：

Foods: pizza steak chicken burgers
Food at @foods[1]: pizza
Food at @foods[2]: steak

因为数组只是一系列用逗号分隔的值，所以您可以像下面所示将它们组合在一起。

#!/usr/bin/perl

@numbers = (1,3,(4,5,6));

print "numbers = @numbers\n";

这将产生以下结果：

numbers = 1 3 4 5 6

哈希可以通过以下两种方式之一创建。在第一种方法中，您逐个地将值分配给命名键 -

$data{'John Paul'} = 45;
$data{'Lisa'} = 30;
$data{'Kumar'} = 40;

在第二种情况下，您使用列表，该列表通过从列表中获取单个对进行转换：对的第一个元素用作键，第二个元素用作值。例如 -

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

访问哈希中的单个元素时，必须在变量前加上美元符号 ($)，然后在变量名称后用花括号附加元素键。例如 -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

print "$data{'John Paul'}\n";
print "$data{'Lisa'}\n";
print "$data{'Kumar'}\n";

这将产生以下结果：

45
30
40

您可以使用 keys 函数获取哈希中所有键的列表，该函数具有以下语法 -

keys %HASH

此函数返回命名哈希的所有键的数组。以下是示例 -

#!/usr/bin/perl 

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@names = keys %data;

print "$names[0]\n";
print "$names[1]\n";
print "$names[2]\n";

这将产生以下结果：

Lisa
John Paul
Kumar

您可以使用 values 函数获取哈希中所有值的列表，该函数具有以下语法 -

values %HASH

此函数返回命名哈希的所有值的数组。以下是示例 -

#!/usr/bin/perl 

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@ages = values %data;

print "$ages[0]\n";
print "$ages[1]\n";
print "$ages[2]\n";

这将产生以下结果：

30
45
40

使用 exists 函数，如果命名键存在，则返回真，无论其值可能是什么 -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

if( exists($data{'Lisa'} ) ){
   print "Lisa is $data{'Lisa'} years old\n";
}
else{
   print "I don't know age of Lisa\n";
}

在这里，我们介绍了 IF...ELSE 语句，我们将在单独的章节中学习它。现在，您只需假设 if( condition ) 部分仅在给定条件为真时执行，否则执行 else 部分。因此，当我们执行上述程序时，它会产生以下结果，因为这里给定的条件 exists($data{'Lisa'} 返回真 -

Lisa is 30 years old

您可以通过对 keys 或 values 使用标量上下文来获取哈希的大小，即元素的数量。简单地说，首先您必须获取键或值的数组，然后您可以获取数组的大小，如下所示 -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@keys = keys %data;
$size = @keys;
print "1 - Hash size:  is $size\n";

@values = values %data;
$size = @values;
print "2 - Hash size:  is $size\n";

这将产生以下结果：

1 - Hash size: is 3
2 - Hash size: is 3

可以使用一行代码和简单的赋值运算符添加新的键/值对。

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size:  is $size\n";

# adding an element to the hash;
$data{'Ali'} = 55;
@keys = keys %data;
$size = @keys;
print "2 - Hash size:  is $size\n";

这将产生以下结果：

1 - Hash size: is 3
2 - Hash size: is 4

要从哈希中删除元素，您需要使用 delete 函数，如下面的示例所示 -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size:  is $size\n";

# delete the same element from the hash;
delete $data{'John Paul'};
@keys = keys %data;
$size = @keys;
print "2 - Hash size:  is $size\n";

这将产生以下结果：

1 - Hash size: is 3
2 - Hash size: is 2

它导致循环跳过其主体其余部分，并在重新迭代之前立即重新测试其条件。last 语句。

它终止循环语句并将执行转移到循环后面的语句。continue 语句。

continue 块，它总是在条件即将再次评估之前执行。

redo 命令重新启动循环块，而不再次评估条件。如果存在，则不执行 continue 块。

goto LABEL 形式跳转到用 LABEL 标记的语句，并从那里恢复执行。

goto EXPR 形式只是 goto LABEL 的泛化。它期望表达式返回一个标签名称，然后跳转到该标记的语句。

它用命名子例程的调用替换当前正在运行的子例程。

指数 - 对运算符执行指数（幂）计算。假设变量 $a 包含 10，变量 $b 包含 20，则 $a**$b 将得到 10 的 20 次幂。

它检查两个操作数的值是否相等，并根据左侧参数在数值上小于、等于或大于右侧参数返回 -1、0 或 1。假设变量 $a 包含 10，变量 $b 包含 20，则 ($a <=> $b) 返回 -1。

如果左侧参数在字符串上小于右侧参数，则返回真。假设变量 $a 包含 "abc"，变量 $b 包含 "xyz"，则 ($a lt $b) 为真。

如果左侧参数在字符串上大于右侧参数，则返回真。假设变量 $a 包含 "abc"，变量 $b 包含 "xyz"，则 ($a gt $b) 为假。

如果左侧参数在字符串上小于或等于右侧参数，则返回真。假设变量 $a 包含 "abc"，变量 $b 包含 "xyz"，则 ($a le $b) 为真。

如果左侧参数在字符串上大于或等于右侧参数，则返回真。假设变量 $a 包含 "abc"，变量 $b 包含 "xyz"，则 ($a ge $b) 为假。

如果左侧参数在字符串上等于右侧参数，则返回真。假设变量 $a 包含 "abc"，变量 $b 包含 "xyz"，则 ($a eq $b) 为假。

如果左侧参数在字符串上不等于右侧参数，则返回真。假设变量 $a 包含 "abc"，变量 $b 包含 "xyz"，则 ($a ne $b) 为真。

根据左侧参数在字符串上小于、等于或大于右侧参数返回 -1、0 或 1。假设变量 $a 包含 "abc"，变量 $b 包含 "xyz"，则 ($a cmp $b) 为 -1。

指数和赋值运算符，对运算符执行指数（幂）计算并将值赋给左侧操作数。$c **= $a 等价于 $c = $c ** $a

它用单引号括起字符串。q{abcd} 给出 'abcd'

它用双引号括起字符串。qq{abcd} 给出 "abcd"

它用反引号括起字符串。qx{abcd} 给出 `abcd`

二元运算符点 (.) 连接两个字符串。如果 $a="abc", $b="def"，则 $a.$b 将给出 "abcdef"

重复运算符 x 返回一个字符串，该字符串由左侧操作数重复右侧操作数指定的次数组成。('-' x 3) 将给出 ---。

范围运算符 .. 返回一个值列表，这些值从左侧值到右侧值依次递增（每次递增 1）。(2..5) 将给出 (2, 3, 4, 5)。

自动递增运算符将整数值增加 1。$a++ 将给出 11。

自动递减运算符将整数值减少 1。$a−− 将给出 9

箭头运算符主要用于从对象或类名取消引用方法或变量。$obj−>$a 是从对象 $obj 访问变量 $a 的示例。

localtime() 函数，如果未给出任何参数，则返回当前日期和时间的值。

#!/usr/local/bin/perl
 
@months = qw( Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec );
@days = qw(Sun Mon Tue Wed Thu Fri Sat Sun);

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
print "$mday $months[$mon] $days[$wday]\n";

当执行上述代码时，它会产生以下结果 -

16 Feb Sat

gmtime() 函数的工作原理与 localtime() 函数类似，但返回的值针对标准格林威治时区进行了本地化。当在列表上下文中调用时，gmtime 返回的最后一个值 $isdst 始终为 0。GMT 没有夏令时。

localtime() 将返回运行脚本的机器上的当前本地时间，而 gmtime() 将返回世界标准时间，或 GMT（或 UTC）。

您可以使用 time() 函数获取纪元时间，即自给定日期以来经过的秒数，在 Unix 中是 1970 年 1 月 1 日。

您可以使用 POSIX 函数 strftime() 来格式化日期和时间。

Perl 编程语言中子例程定义的一般形式如下 -

sub subroutine_name{
   body of the subroutine
}

调用该 Perl 子例程的典型方法如下 -

subroutine_name( list of arguments );

它们可以在函数内部使用特殊数组 @_ 访问。因此，函数的第一个参数在 $_[0] 中，第二个参数在 $_[1] 中，依此类推。

使用 scalar(@_)，我们可以获取传递的参数总数。

my 运算符将变量限制在可以使用和访问的特定代码区域内。在此区域之外，无法使用或访问此变量。

默认情况下，Perl 中的所有变量都是全局变量，这意味着可以在程序的任何地方访问它们。

词法变量是使用 my 运算符创建的私有变量。

当需要使变量的当前值对被调用的子程序可见时，可以使用 local。

local 只是为全局（即包）变量提供临时值。这被称为动态作用域。

词法作用域是使用 my 运算符实现的。词法作用域通常是一个代码块，周围有一组大括号，例如定义子程序体的大括号，或者标记 if、while、for、foreach 和 eval 语句的代码块的大括号。my 运算符将变量限制在可以使用和访问的特定代码区域。在此区域之外，无法使用或访问此变量。

还有一种类型的词法变量，类似于私有变量，但它们会保持其状态，并且在多次调用子程序时不会重新初始化。这些变量使用 state 运算符定义，从 Perl 5.9.4 开始可用。

子程序或语句的上下文定义为预期返回的值的类型。这允许您使用单个函数根据用户期望接收的内容返回不同的值。例如，以下 localtime() 在标量上下文中调用时返回字符串，但在列表上下文中调用时返回列表。

my $datestring = localtime( time );

在此示例中，$timestr 的值现在是一个由当前日期和时间组成的字符串，例如，Thu Nov 30 15:21:33 2000。反之 -

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

现在各个变量包含 localtime() 子程序返回的对应值。

Perl 引用是一种标量数据类型，它保存另一个值的地址，该值可以是标量、数组或哈希。由于其标量特性，引用可以在任何可以使用标量的地方使用。

您可以通过在变量前加反斜杠来为任何变量创建引用，如下所示 -

$scalarref = \$foo;

您可以通过在数组前加反斜杠来为任何数组创建引用，如下所示 -

$arrayref  = \@ARGV;

您可以通过在哈希前加反斜杠来为任何哈希创建引用，如下所示 -

$hashref   = \%ENV;

您可以通过在子程序前加反斜杠来为任何子程序创建引用，如下所示 -

$cref = \&PrintHash;

反引用从引用指向的位置返回值。

要反引用引用，只需根据引用指向的是标量、数组还是哈希，在引用变量前使用 $、@ 或 % 作为前缀。

当两个引用相互包含对方的引用时，就会发生循环引用。在创建引用时必须小心，否则循环引用会导致内存泄漏。以下是一个示例 -

#!/usr/bin/perl
my $foo = 100;
$foo = \$foo;
 
print "Value of foo is : ", $$foo, "\n";

当执行上述程序时，会产生以下结果 -

Value of foo is : REF(0x9aae38)

以下是以只读模式打开 file.txt 的语法。这里小于号 < 表示文件必须以只读模式打开。

open(DATA, "<file.txt");

这里 DATA 是将用于读取文件的文件句柄。

以下是以写入模式打开 file.txt 的语法。这里大于号 > 表示文件必须以写入模式打开。

open(DATA, ">file.txt") or die "Couldn't open file file.txt, $!";

以下是以写入模式打开 file.txt 而不截断它的语法。这里加号 <+ 表示文件必须以写入模式打开而不截断它。

open(DATA, "+<file.txt") or die "Couldn't open file file.txt, $!";

要关闭文件句柄，从而取消文件句柄与相应文件的关联，可以使用 close 函数。这会刷新文件句柄的缓冲区并关闭系统的文件描述符。

getc 函数从指定的文件句柄返回单个字符，如果没有指定文件句柄，则返回 STDIN。

read 函数从缓冲的文件句柄读取信息块：此函数用于从文件读取二进制数据。