Perl 面试问题

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

• 尽管 Perl 并不是正式的缩写词，但很少有人将其用作实用提取和报告语言。

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

• 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 等。

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

• Perl 可与 HTML、XML 和其他标记语言一起使用。

• Perl 支持 Unicode。

• Perl 符合 Y2K 标准。

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

• Perl 通过 XS 或 SWIG 与外部 C/C++ 库连接。

• Perl 是可扩展的。综合 Perl 档案网络 ( 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() 函数将删除由 OFFSET 和 LENGTH 指定的 @ARRAY 元素，并用 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。但是如果将 $[ 设置为 1，那么所有数组都将使用基于零的索引。建议不要使用除零以外的任何其他索引。然而，让我们举一个例子来展示 $[ 变量的用法 -

#!/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 %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

使用存在函数，如果指定的键存在，则返回 true，无论其值是什么 -

#!/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) 部分仅在给定条件为 true 时才会执行，否则会执行 else 部分。因此，当我们执行上面的程序时，它会产生以下结果，因为这里给定的条件存在（$data{'Lisa'} 返回 true -

Lisa is 30 years old

您可以通过使用键或值上的标量上下文来获取大小，即哈希中的元素数量。简而言之，首先您必须获取键或值的数组，然后您可以获得数组的大小，如下所示 -

#!/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

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

#!/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

它使循环跳过其主体的其余部分并在重复之前立即重新测试其条件。最后声明。

它终止循环语句并将执行转移到紧随循环后面的语句。继续声明。

一个 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。

如果左侧参数按字符串方式小于右侧参数，则返回 true。假设变量 $a 包含“abc”，变量 $b 包含“xyz”，则 ($a lt $b) 为 true。

如果左侧参数按字符串方式大于右侧参数，则返回 true。假设变量 $a 包含“abc”，变量 $b 包含“xyz”，则 ($a gt $b) 为 false。

如果左侧参数按字符串方式小于或等于右侧参数，则返回 true。假设变量 $a 包含“abc”，变量 $b 包含“xyz”，则 ($a le $b) 为 true。

如果左侧参数按字符串方式大于或等于右侧参数，则返回 true。假设变量 $a 包含“abc”，变量 $b 包含“xyz”，则 ($a ge $b) 为 false。

如果左侧参数按字符串方式等于右侧参数，则返回 true。假设变量 $a 包含“abc”，变量 $b 包含“xyz”，则 ($a eq $b) 为 false。

如果左侧参数按字符串方式不等于右侧参数，则返回 true。假设变量 $a 包含“abc”，变量 $b 包含“xyz”，则 ($a ne $b) 为 true。

它返回 -1、0 或 1，具体取决于左侧参数按字符串方式小于、等于还是大于右侧参数。假设变量 $a 包含“abc”，变量 $b 包含“xyz”，则 ($a cmp $b) 为 -1。

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

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

它用双引号括住一个字符串。qq{abcd} 给出“abcd”

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

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

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

范围运算符 .. 返回从左值到右值计数（递增）的值列表。(2..5) 将给出 (2, 3, 4, 5)。

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

自动递减运算符将整数值减一。$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 中的所有变量都是全局变量，这意味着可以从程序中的任何位置访问它们。

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

当变量的当前值必须对被调用的子例程可见时，使用局部变量。

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

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

还有另一种类型的词法变量，与私有变量类似，但它们保持其状态，并且在多次调用子例程时不会重新初始化。这些变量是使用状态运算符定义的，并且从 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 函数从指定的 FILEHANDLE 返回单个字符，如果未指定，则返回 STDIN。

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