原文： https://beginnersbook.com/2017/05/perl-lists-and-arrays/

在 Perl 中，人们可以交替使用术语列表和数组，但是存在差异。 列表是数据（标量值的有序集合），数组是保存列表的变量。

如何定义数组？

数组以@符号为前缀。这就是你定义一个数组的方法：

  1. @friends = ("Ajeet", "Chaitanya", "Rahul");

这是包含三个字符串的字符串数组。另一种做法是：

  1. @friends = qw(Ajeet Chaitanya Rahul); #same as above

注意：qw代表引用的单词，通过使用qw你可以避免引号并输入更少。

学习 Perl 时，您可能会遇到几个示例，其中您会看到以下类型的数组定义：

  1. @friends = qw/Ajeet Chaitanya Rahul/; #same as above

这是因为 Perl 允许您选择任何标点字符作为分隔符。

以下所有语句均相同：

  1. @friends = qw/Ajeet Chaitanya Rahul/;
  2. @friends = qw!Ajeet Chaitanya Rahul!;
  3. @friends = qw;
  4. @friends = qw{Ajeet Chaitanya Rahul};
  5. @friends = qw[Ajeet Chaitanya Rahul];

注意：开始和结束分隔符必须相同。

访问数组元素

您必须在另一个编程语言中使用过数组，如 C，C++，Java 等。数组的基本概念在这里是相同的。让我们举一个例子来了解如何定义数组以及如何访问它的元素。

  1. #!/usr/bin/perl
  3. @friends = ("Ajeet", "Chaitanya", "Rahul");            
  5. print "\$friends[0] = $friends[0]\n";
  6. print "\$friends[1] = $friends[1]\n";
  7. print "\$friends[2] = $friends[2]\n";

输出：

  1. $friends[0] = Ajeet
  2. $friends[1] = Chaitanya
  3. $friends[2] = Rahul

正如你在上面的程序中看到的那样，数组是用@符号进行的。因为，单个数组元素只是标量，它们是$符号的预设。

范围运算符：

范围运算符由双点..表示。此运算符用于创建顺序列表。例如：

  1. #!/usr/bin/perl
  3. @num = (3..9);   # same as (3, 4, 5, 6,  7, 8, 9)
  4. foreach $temp (@num) {
  5.    print "$temp\n";
  6. }

输出：

  1. 3
  2. 4
  3. 5
  4. 6
  5. 7
  6. 8
  7. 9

让我们再看几个例子来理解范围运算符：

  1. (2.9..7.9) # same as (2, 3, 4, 5, 6, 7), values after decimal are truncated
  2. (9..3) # empty list, only works in increasing order
  3. (1, 3..6, 10, 12..14) # same as (1, 3, 4, 5, 6, 10, 12, 13, 14),

运算符：pop和push

pop运算符从数组中删除最后一个元素并返回它。让我们举个例子来了解pop运算符的工作原理：

  1. #!/usr/bin/perl
  3. @num = (3..7);  # same as (3, 4, 5, 6, 7)
  4. $n1 = pop(@num); # $n1 is 7, array is (3, 4, 5, 6)
  5. $n2 = pop(@num); # $n2 is 6, array is (3, 4, 5)
  6. print "\$n1 is: $n1\n";
  7. print "\$n2 is: $n2\n";
  8. print "array now has:\n";
  9. foreach $temp (@num) {
  10.    print "$temp\n";
  11. }
  12. pop @num; # 5 is discarded, array is (3, 4)
  13. print "array now has:\n";
  14. foreach $temp (@num) {
  15.    print "$temp\n";
  16. }

输出：

  1. $n1 is: 7
  2. $n2 is: 6
  3. array now has:
  4. 3
  5. 4
  6. 5
  7. array now has:
  8. 3
  9. 4

push运算符在数组末尾添加一个元素。

示例：

  1. #!/usr/bin/perl
  3. @num = (10..12);  # same as (10, 11, 12)
  4. push (@num, 9); # array is (10, 11, 12, 9)
  5. push (@num, 6); # array is (10, 11, 12, 9, 6)
  6. print "array now has:\n";
  7. foreach $temp (@num) {
  8.    print "$temp\n";
  9. }
  10. @num2 = (11, 22, 33);
  11. push (@num, @num2); # adding another array to the end
  12. print "array now has:\n";
  13. foreach $temp (@num) {
  14.    print "$temp\n";
  15. }

输出：

  1. array now has:
  2. 10
  3. 11
  4. 12
  5. 9
  6. 6
  7. array now has:
  8. 10
  9. 11
  10. 12
  11. 9
  12. 6
  13. 11
  14. 22
  15. 33

运算符：shift和unshift

正如我们在上面看到的那样，push和pop操作符在数组末尾添加和删除。shift和unshift在数组的开头执行操作。

shift运算符：

shift运算符的工作方式类似于pop运算符，但与pop运算符不同，它在数组的开头执行运算。

  1. #!/usr/bin/perl
  3. @num = (3..7);  # same as (3, 4, 5, 6, 7)
  4. $n1 = shift(@num); # $n1 is 3, array is (4, 5, 6, 7)
  5. $n2 = shift(@num); # $n2 is 4, array is (5, 6, 7)
  6. print "\$n1 is: $n1\n";
  7. print "\$n2 is: $n2\n";
  8. print "array now has:\n";
  9. foreach $temp (@num) {
  10.    print "$temp\n";
  11. }
  12. shift @num; # 5 is discarded, array is (6, 7)
  13. print "array now has:\n";
  14. foreach $temp (@num) {
  15.    print "$temp\n";
  16. }

输出：

  1. $n1 is: 3
  2. $n2 is: 4
  3. array now has:
  4. 5
  5. 6
  6. 7
  7. array now has:
  8. 6
  9. 7

unshift运算符：

unshift运算符的工作方式类似于push运算符，但与push运算符不同，它在数组的开头执行运算。

  1. #!/usr/bin/perl
  3. @num = (10..12);  # same as (10, 11, 12)
  4. unshift (@num, 9); # array is (9, 10, 11, 12)
  5. unshift (@num, 6); # array is (6, 9, 10, 11, 12)
  6. print "array now has:\n";
  7. foreach $temp (@num) {
  8.    print "$temp\n";
  9. }
  10. @num2 = (11, 22, 33);
  11. unshift (@num, @num2); # adding another array to the beginning
  12. print "array now has:\n";
  13. foreach $temp (@num) {
  14.    print "$temp\n";
  15. }

输出：

  1. array now has:
  2. 6
  3. 9
  4. 10
  5. 11
  6. 12
  7. array now has:
  8. 11
  9. 22
  10. 33
  11. 6
  12. 9
  13. 10
  14. 11
  15. 12

splice运算符

在上一节中，我们学习了如何在数组上执行push，pop，shift和unshift操作。但是这些运算符存在限制，它们只在数组的开头或数组的末尾执行。如果我们想在数组中间执行操作怎么办？这就是splice运算符进入画面的地方。

语法：

  1. splice @array_name, s, l, @another_array

splice运算符最多可以包含四个参数。
第一个参数是数组名，这里我们指定我们正在执行操作的数组
第二个参数是起点，如上所述，你可以在数组中间执行操作。这指定了操作的起点。
第三个参数是长度
第四个参数是另一个列表或数组。

让我们举几个例子来理解这个：

示例 1：splice中只有两个参数

  1. @myarray = qw(Rahul, Joe, Ajeet, Tim, Lisa);
  2. @myvar = splice @array, 2;  
  3. # removes everything after Ajeet
  4. # @myarray is qw(Rahul, Joe, Ajeet)
  5. # @myvar is qw(Tim, Lisa)

splice运算符的第三和第四个参数是可选的。在上面的例子中，我们只提供了两个参数，数组和起始点。与数组类似，splice运算符的索引从 0 开始，这意味着Ajeet是上例中的起点。如果我们只提供两个参数，那么splice运算符会在起始点之后删除所有内容。

示例 2：三个参数

第三个参数指定已删除元素列表的长度。在上面的例子中，我们没有指定任何长度，这就是为什么它在起始点之后删除了所有内容。现在，让我们看看当我们提供第三个参数时会发生什么。

  1. @myarray = qw(Rahul, Joe, Ajeet, Tim, Lisa);
  2. @myvar = splice @array, 2, 1;  
  3. # removes only one element after Ajeet
  4. # @myarray is qw(Rahul, Joe, Ajeet, Lisa)
  5. # @myvar is qw(Tim)

例 3：第四个参数

第四个参数是另一个列表或我们要插入到数组中的数组。

  1. @myarray = qw(Rahul, Joe, Ajeet, Tim, Lisa);
  2. @myvar = splice @array, 2, 1, qw(Harsh, Alisha);  
  3. # removes only one element after Ajeet
  4. # inserts the provided list at the same position
  5. # @myarray is qw(Rahul, Joe, Ajeet, Harsh, Alisha, Lisa)
  6. # @myvar is qw(Tim)

示例 4：如果我们不想删除任何内容，只需添加即可

如果您不想删除任何内容，只需要在数组中间添加一些元素，然后可以将长度指定为 0。

  1. @myarray = qw(Rahul, Joe, Ajeet, Tim, Lisa);
  2. @myvar = splice @array, 2, 0, qw(Harsh, Alisha); 
  3. # removes nothing
  4. # inserts the provided list at the starting point
  5. # @myarray is qw(Rahul, Joe, Ajeet, Harsh, Alisha, Tim, Lisa)
  6. # @myvar is qw()

reverse运算符

reverse运算符将一个元素（或列表）数组作为输入，并以相反的顺序返回。例如：

  1. @myarray = 10..15;    # same as (10, 11, 12, 13, 14, 15)
  2. @myarray2 = reverse @myarray;   # @myarray2 has (15, 14, 13, 12, 11, 10)
  3. @myarray3 = reverse 5..9; # @myarray3 has (9, 8, 7, 6, 5)

假设您想要反转数组的元素并将其存储到同一个数组中：

  1. @myarray = 10..15;
  2. @myarray = reverse @myarray;

注意：如果你只是写下面的语句那么它就不行了。

  1. reverse @myarray;

这不会做任何事情，因为反向运算符不会更改数组元素的顺序，它只是以相反的顺序返回需要分配给数组的列表。