Perl列表和数组

列表和数组

(1,2,"perl","python")
("var1","var2","var3")
()       # 空列表

if(defined(())){        # 对空列表()进行判断
    print "defined";
}else{
    print "undefined";  # 返回此行
}

(1,2,3,)      # 等价于(1,2,3)
(1,2,,,4)     # 等价于(1,2,4)

列表中的元素支持范围操作，只需使用（..）. 如果是小数，则四舍五入. 还支持负数. 范围操作不支持逆序范围，但是不会报告任何错误. 请注意，它不是undef，因此它不是一个空列表. Perl的范围运算符对天空非常强大.

(1..5)        # 等价于(1,2,3,4,5)
(1,2,3..5,7)  # 等价于(1,2,3,4,5,7)
(3.5..6)      # 等价于(3,4,5,6)
(3.5..6.5)    # 等价于(3,4,5,6)
(-3..2)       # 等价于(-3,-2,-1,0,1,2)
($m..$n)      # 范围由$m和$n决定
(a..d)        # ("a","b","c","d")
/^one/ .. /^two/ # 匹配从one开头的行到two开头的行
/^one/ .. eof    # 匹配从one开头的行到最后一行

实际上，有两种类型的范围运算符: ..和...，仅在匹配范围时才不同. 例如，一段文字是:

start here end here
second line
end

如果使用/start/../end/，则匹配在第一行结束，因为第一行可以同时匹配开始和结束，如果要第一行匹配开始perl 数组 长度，则不更长的匹配末尾，并且与第三行的末尾匹配，因此您需要使用/start/.../end/. 实际上，将范围运算符的左侧匹配称为翻转，将右侧匹配的称为翻转. 三点范围运算符...意味着不是在翻牌后立即进行翻牌圈评估，而是在此后评估翻牌.

使用qw编写列表，无需添加引号，无需添加逗号分隔，但使用空格分隔.

以下两个列表是等效的:

("perl","python","shell")
qw(perl python shell)

$perl="perl";
qw($perl python shelln)   # 不会做任何转换，包含三个元素"$perl"、"python"、"shelln"

qw(
    perl
    python
    shell
)

请注意perl 数组 长度，您不能在qw换行符内添加注释#. 因此，以下#及其后面的字符串也被视为列表元素

qw(
    perl
    python   # This is python
    shell
)

qw/ var1 var2 var3 /
qw! var1 var2 var3 !
qw% var1 var2 var3 %
qw# var1 var2 var3 #      # 这个有点像注释
...  
qw( var1 var2 var3 )
qw< var1 var2 var3 >
qw{ var1 var2 var3 }
qw[ var1 var2 var3 ]

如果定界符中间有一个定界符，则将其转义.

qw/ var1 var2 /var3 var4 /

更好的方法是更改​​为另一个定界符.

qw{
    /root/xyz.sh
    /etc/xyz.sh
}

($perl,$python)=("perl","python");
print $perl,"n";
print $python,"n";

($perl,$python)=($python,$perl);

($perl,$python,$shell)     =qw(perl python shell php);   # php被忽略
($perl,$python,$shell,$php)=qw(perl python shell);  # $php被赋值为undef

在perl中，列表和数组密切相关. 可以认为列表已分配给变量，并且此变量是数组. 数组以“ @”符号开头.

print qw{perl python shell};
@subject=qw{perl python shell};
print @subject;

@subject=("perl","python","shell");
@range=1..5;
@subject=(@subject,"hello",@range);

@empty=();
if(@empty){
    print "validn";
}else{
    print "invalidn";    # 返回此行
}
@subject1=qw{perl python shell};
@subject2=(@subject,@empty,"php");  # 等价于(@subject,"php")
@subject3=(@subject,undef,"php");   # 不等价于(@subject,"php")

$arr="xyz";
@arr=(var0,var1,var2);    # 这是一个列表，赋值给了数组。
                          # 列表中的元素没有加引号包围
print $arr[0],$arr[1],$arr[2],"n";   # 引用数组变量
print $arr;             # 输出xyz
print @arr,"n";        # 输出var0var1var2
print "@arr","n"       # 输出var0 var1 var2

print $arr[1.3];     # 等价于$arr[1]
print $arr[-1];      # 最后一个元素
print $arr[-2];      # 倒数第二个元素
print $arr[100];     # undef
print $arr[-100];    # undef
print $arr[$#arr];   # 最后一个元素
print $arr[$#arr-1]; # 倒数第二个元素

@{arr1}=(var0,var1,var2)

@arr2=(var0,var1,var2);
print $arr2[100];      # undef
print $#arr2;          # 返回2
$arr2[5]="var5"        # 将填充$arr2[3],$arr2[4]为undef
print $#arr2;          # 返回5

请注意，在以下示例中，打印@arr，“ n”并打印@arr. “ n”只是逗号和点之间的区别，但是返回的结果却完全不同. 这是在不同上下文中执行的结果.

@arr=(var0,var1,var2);  # 数组，里面的元素不用引号包围
$arr[4]="var4";         # 直接对数组变量赋值，会自动填充$arr[3]:undef
print @arr,"n";        # 引用整个数组：var0var1var2var4
print @arr."n";        # 输出的是5，表示的是数组中元素个数
                        # 因为这里的数组从列表上下文切换成了标量上下文，
                        # 数组将返回元素个数

push函数: 将元素插入数组的末尾（最右边）；

pop函数: 弹出（删除并返回）数组末尾的元素；当没有要弹出的元素时，pop返回undef.

弹出和推入用于实现堆叠，就像堆叠板一样，保持向上堆叠，并从上方开始获取.

@arr = 5..9;                   # (5,6,7,8,9)
$var1 = pop(@arr);
print @arr,"n",$var1,"n";    # 返回5678和9
$var2 = pop @arr;
print @arr,"n",$var2,"n";    # 返回567和8
pop @arr;                      # 直接丢弃弹出的元素
print @arr,"n";               # 返回56

倒数第二行的Pop @arr没有进行任何分配. 在perl中有许多这样的用法. 当返回的内容不分配时，表示仅执行该操作，但丢弃该操作后返回的结果. 在这种情况下，这称为“无效上下文”. 因此，可以直接从数组的最后一个元素中删除它.

@arr=(5,6);
push(@arr,0);     # @arr现在是(5,6,0)
push @arr,1..10;  # @arr现在有13个元素：5,6,0,1,2,3,4,5,6,7,8,9,10
@other=qw{1 3 4 5};
push @arr,@other; # @arr现在17个元素：5,6,0,1,2,3,4,5,6,7,8,9,10,1,3,4,5

push和pop操作数组的尾部，而shift和unshift操作数组的头:

-shift弹出（删除并返回）数组的第一个元素（最左侧）. 没有元素可玩时，shift将返回undef;

-unshift在数组的左侧插入一个元素.

@arr = qw{perl python shell};
$m   = shift(@arr);   # $m变成"perl",@arr现在是("python","shell")
$n   = shift @arr;    # $n变成"python",@arr现在是("shell")
shift @arr;           # @arr变成空了
%i   = shift @arr;    # $i为undef，@arr还是空
unshift @arr,5;       # @arr现在是(5)
unshift @arr,4;       # @arr现在是(4,5)
@other=1..3;
unshift @arr,@other;  # @arr现在变为(1,2,3,4,5)

Shift-unshift和pop-push操作于数组的开始和结尾. 如果要操作数组中间的元素，则需要使用splice（）函数.

splice（）函数有4个参数，最后两个参数是可选的.

如果仅给出两个参数，它将从索引位置开始并被删除到数组的末尾.

# 两个参数
@arr  = qw{perl python shell php java};
@arr1 = splice @arr,2;             # @arr现在是qw{perl python}
                                   # @arr1现在是qw{shell php java}
# 三个参数
@arr  = qw{perl python shell php java};
@arr1 = splice @arr,2,2;           # @arr现在是qw{perl python java}
                                   # @arr1现在是qw{shell php}
# 四个参数
@arr  = qw{perl python shell php java};
@arr1 = splice @arr,2,2,qw{ruby};    # @arr现在是qw{perl python ruby java}
                                     # @arr1现在是qw{shell php}

使用第四个参数时，如果第三个参数设置为0，则可以将新元素插入到数组中，而不会删除任何内容.

@arr  = qw{perl python shell php java};
@arr1 = splice @arr,2,0,qw{ruby};   # @arr现在是qw{perl python ruby shell php java}
                                    # @arr1现在是qw()

foreach可以遍历列表或数组.

foreach $subject qw(perl python shell){
    print $subject,"n";
}

在$ subject是控制变量的情况下，在每次迭代期间，都会从列表或数组中获取元素并将其分配给控制变量.

迭代数组:

@arr=qw(perl python shell);
foreach $subject (@arr){
    print $subject,"n";
}

在迭代过程中，对控制变量的分配实际上是列表或数组中的引用，而不是直接取出元素的值并将其分配给控制变量（即，它不是变量副本） ）. 因此，在foreach过程中修改控制变量的值也将修改列表/数组中元素的值.

@arr=qw(perl python shell);
foreach $subject (@arr) {
    $subject .= "aaa";
}
print @arr;         # 输出perlaaapythonaaashellaaa

foreach遍历结束时，控制变量将还原为foreach遍历之前的值（例如，undef为undef）.

$subject="php";
foreach $subject (qw(perl python shell)){
}
print $subject;     # 输出"php"

在foreach遍历结构中也可以省略控制变量部分. 此时，默认变量$ _将用作控制变量. 每次迭代都会从数组中获取列表/数组索引，并将其分配给$ _.

foreach (qw(perl python shell)) {
    print $_,"n";
}

实际上，当Perl中的许多地方没有“需求数据”时，它将自动使用$ _. 例如，以下打印功能使用$ _.

$_="hello world!n";
print;

print reverse 11,6..8,20,"n";    # 输出顺序：20 8 7 6 11
@arr=qw(perl python shell);
reverse @arr;            # 反转了顺序，但返回结果丢弃了，@arr不变
print @arr,"n";         # 返回顺序：perl python shell
@arr1=reverse @arr;      # @arr1中元素的顺序：shell python perl
print '@arr1: ',@arr1,"n";
@sort_arr=sort @arr;     # 排序，但因为@arr中元素顺序本就是升序的
print '@sort_arr: ',@sort_arr,"n";  # 返回顺序：perl python shell
sort @arr;               # 虽排序，但丢弃了排序结果

每个操作员都可以获取一个键/值对（键/值）. 您可以操纵数组和哈希. 有关每个操作哈希的内容，请参见下文.

对数组的每次操作都会返回数组中元素的索引号和元素的值.

my @arr=qw(perl python shell);
while (my($index,$value) = each(@arr)){
    print "$index: $value","n";
}

my关键字指示该变量是局部变量. 以下是执行结果:

0: perl
1: python
2: shell

如果不使用它们，则需要遍历数组并获取数组的索引和元素的值.

本文来自电脑杂谈，转载请注明本文网址：
https://www.pc-fly.com/a/jisuanjixue/article-191279-1.html