# Perl - 列表和数组

> 原文： [https://beginnersbook.com/2017/05/perl-lists-and-arrays/](https://beginnersbook.com/2017/05/perl-lists-and-arrays/)

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

## 如何定义数组？

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

```perl
@friends = ("Ajeet", "Chaitanya", "Rahul");
```

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

```perl
@friends = qw(Ajeet Chaitanya Rahul); #same as above
```

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

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

```perl
@friends = qw/Ajeet Chaitanya Rahul/; #same as above
```

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

以下所有语句均相同：

```perl
@friends = qw/Ajeet Chaitanya Rahul/;
@friends = qw!Ajeet Chaitanya Rahul!;
@friends = qw;
@friends = qw{Ajeet Chaitanya Rahul};
@friends = qw[Ajeet Chaitanya Rahul];
```

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

## 访问数组元素

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

```perl
#!/usr/bin/perl

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

print "\$friends[0] = $friends[0]\n";
print "\$friends[1] = $friends[1]\n";
print "\$friends[2] = $friends[2]\n";
```

**输出：**

```perl
$friends[0] = Ajeet
$friends[1] = Chaitanya
$friends[2] = Rahul
```

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

#### 范围运算符：

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

```perl
#!/usr/bin/perl

@num = (3..9);   # same as (3, 4, 5, 6,  7, 8, 9)
foreach $temp (@num) {
   print "$temp\n";
}
```

**输出：**

```perl
3
4
5
6
7
8
9
```

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

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

#### 运算符：`pop`和`push`

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

```perl
#!/usr/bin/perl

@num = (3..7);  # same as (3, 4, 5, 6, 7)
$n1 = pop(@num); # $n1 is 7, array is (3, 4, 5, 6)
$n2 = pop(@num); # $n2 is 6, array is (3, 4, 5)
print "\$n1 is: $n1\n";
print "\$n2 is: $n2\n";
print "array now has:\n";
foreach $temp (@num) {
   print "$temp\n";
}
pop @num; # 5 is discarded, array is (3, 4)
print "array now has:\n";
foreach $temp (@num) {
   print "$temp\n";
}
```

**输出：**

```perl
$n1 is: 7
$n2 is: 6
array now has:
3
4
5
array now has:
3
4
```

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

**示例：**

```perl
#!/usr/bin/perl

@num = (10..12);  # same as (10, 11, 12)
push (@num, 9); # array is (10, 11, 12, 9)
push (@num, 6); # array is (10, 11, 12, 9, 6)
print "array now has:\n";
foreach $temp (@num) {
   print "$temp\n";
}
@num2 = (11, 22, 33);
push (@num, @num2); # adding another array to the end
print "array now has:\n";
foreach $temp (@num) {
   print "$temp\n";
}
```

**输出：**

```perl
array now has:
10
11
12
9
6
array now has:
10
11
12
9
6
11
22
33
```

#### 运算符：`shift`和`unshift`

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

**`shift`运算符：**

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

```perl
#!/usr/bin/perl

@num = (3..7);  # same as (3, 4, 5, 6, 7)
$n1 = shift(@num); # $n1 is 3, array is (4, 5, 6, 7)
$n2 = shift(@num); # $n2 is 4, array is (5, 6, 7)
print "\$n1 is: $n1\n";
print "\$n2 is: $n2\n";
print "array now has:\n";
foreach $temp (@num) {
   print "$temp\n";
}
shift @num; # 5 is discarded, array is (6, 7)
print "array now has:\n";
foreach $temp (@num) {
   print "$temp\n";
}
```

**输出：**

```perl
$n1 is: 3
$n2 is: 4
array now has:
5
6
7
array now has:
6
7
```

**`unshift`运算符：**

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

```perl
#!/usr/bin/perl

@num = (10..12);  # same as (10, 11, 12)
unshift (@num, 9); # array is (9, 10, 11, 12)
unshift (@num, 6); # array is (6, 9, 10, 11, 12)
print "array now has:\n";
foreach $temp (@num) {
   print "$temp\n";
}
@num2 = (11, 22, 33);
unshift (@num, @num2); # adding another array to the beginning
print "array now has:\n";
foreach $temp (@num) {
   print "$temp\n";
}
```

**输出：**

```perl
array now has:
6
9
10
11
12
array now has:
11
22
33
6
9
10
11
12
```

#### `splice`运算符

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

**语法：**

```perl
splice @array_name, s, l, @another_array
```

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

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

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

```perl
@myarray = qw(Rahul, Joe, Ajeet, Tim, Lisa);
@myvar = splice @array, 2;  
# removes everything after Ajeet
# @myarray is qw(Rahul, Joe, Ajeet)
# @myvar is qw(Tim, Lisa)
```

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

#### 示例 2：三个参数

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

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

#### 例 3：第四个参数

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

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

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

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

```perl
@myarray = qw(Rahul, Joe, Ajeet, Tim, Lisa);
@myvar = splice @array, 2, 0, qw(Harsh, Alisha); 
# removes nothing
# inserts the provided list at the starting point
# @myarray is qw(Rahul, Joe, Ajeet, Harsh, Alisha, Tim, Lisa)
# @myvar is qw()
```

#### `reverse`运算符

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

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

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

```perl
@myarray = 10..15;
@myarray = reverse @myarray;
```

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

```perl
reverse @myarray;
```

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