Perl 采访问题（Perl Interview Questions）

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

• 虽然Perl不是官方缩写词，但很少有人将它用作Practical Extraction and Report Language 。

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

• Perl是一种Open Source软件，根据其Artistic License或GNU General Public License (GPL) 。

• Perl由Larry Wall创建。

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

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

• Perl列于Oxford English Dictionary 。

• 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是可扩展的。 Comprehensive Perl Archive Network（ 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基于Context（即使用变量的情况）以不同方式处理相同的变量。

对标量变量的赋值评估标量上下文中的右侧。

对数组或散列的赋值评估列表上下文中的右侧。

布尔上下文只是评估表达式以查看它是真还是假的任何位置。

这个上下文不仅不关心返回值是什么，它甚至不想要返回值。

此上下文仅发生在引号内，或者与引号类似的内容。

单引号字符串将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-strings。

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

它用于获取当前文件名。

它用于获取当前行号。

它用于获取当前包名称。

要引用数组的单个元素，您将使用带有变量名的美元符号（$），后跟方括号中元素的索引。

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

#!/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函数获取散列中所有值的列表，该函数具有以下语法 -

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函数，如果命名密钥存在，则返回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）部分只在给定条件为真时执行，否则将执行part。 因此，当我们执行上述程序时，它会产生以下结果，因为这里给定的条件存在（$ 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

它导致循环跳过其身体的其余部分，并在重复之前立即重新测试其状态。 最后声明。

它终止循环语句，并在循环后立即将执行转移到语句。 继续声明。

继续BLOCK，它总是在条件即将被再次评估之前执行。

重做命令重新启动循环块，而不再评估条件。 如果有的话，继续块不会被执行。

goto LABEL表单跳转到标有LABEL的语句，并从那里继续执行。

转到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。 假设变量$ a持有“abc”而变量$ b持有“xyz”然后（$ a gt $ b）为假。

如果左参数stringwise小于或等于right参数，则返回true。 假设变量$ a持有“abc”而变量$ b持有“xyz”然后（$ a le $ b）为真。

如果左参数的字符串大于或等于右参数，则返回true。 假设变量$ a持有“abc”而变量$ b持有“xyz”然后（$ a ge $ b）为假。

如果左参数的字符串等于右参数，则返回true。 假设变量$ a持有“abc”而变量$ b持有“xyz”然后（$ a eq $ b）为假。

如果左参数stringwise不等于right参数，则返回true。 假设变量$ a持有“abc”而变量$ b持有“xyz”然后（$ a ne $ b）为真。

它返回-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）。

Auto Increment运算符将整数值增加1。 $ a ++将给出11。

Auto Decrement运算符将整数值减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（）函数类似，但返回的值已针对标准格林威治时区进行了本地化。 在列表上下文中调用$ isdst时，gmtime返回的最后一个值始终为0。 格林威治标准时间没有夏令时。

localtime（）将返回运行脚本的机器上的当前本地时间，gmtime（）将返回通用格林威治标准时间或GMT（或UTC）。

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

您可以使用POSIX函数strftime（）来设置日期和时间的格式。

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

sub subroutine_name{
   body of the subroutine
}

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

subroutine_name( list of arguments );

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

使用标量（@_），我们可以得到传递的参数总数。

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

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

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

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

本地只为全局（含义包）变量提供临时值。 这称为动态范围。

词法范围是由我的运算符完成的。 词法范围通常是一个带有一组括号的代码块，例如定义子例程主体的那些或标记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函数从缓冲的文件句柄中读取一个信息块:该函数用于从文件中读取二进制数据。