Perl Language
listor

Array som lista

Arrayen är en av Perls grundläggande variabeltyper. Den innehåller en lista, som är en ordnad sekvens med noll eller fler skalor. Arrayen är variabeln som innehar (och ger åtkomst till) listdata , vilket är dokumenterat i perldata .

Du kan tilldela en lista till en matris:

my @foo = ( 4, 5, 6 );

Du kan använda en matris överallt där en lista förväntas:

join '-', ( 4, 5, 6 );
join '-', @foo;

Vissa operatörer arbetar bara med matriser eftersom de muterar listan som en matris innehåller:

shift @array;
unshift @array, ( 1, 2, 3 );
pop @array;
push @array, ( 7, 8, 9 );

Tilldela en lista till en hash

Listor kan också tilldelas hashvariabler. När du skapar en lista som kommer att tilldelas en hashvariabel rekommenderas att du använder fett komma => mellan nycklar och värden för att visa deras förhållande:

my %hash = ( foo => 42, bar => 43, baz => 44 );

=> egentligen bara ett särskilt komma som automatiskt citerar operanden till vänster. Så du kan använda vanliga kommatecken, men förhållandet är inte så tydligt:

my %hash = ( 'foo', 42, 'bar', 43, 'baz', 44 );

Du kan också använda citerade strängar för den vänstra handen av fett komma => , vilket är särskilt användbart för nycklar som innehåller mellanslag.

my %hash = ( 'foo bar' => 42, 'baz qux' => 43 );

För mer information, se Comma operator på perldoc perlop .

Listor kan överföras till subroutiner

För att överföra listan till en subrutin anger du subroutinens namn och tillhandahåller sedan listan till den:

test_subroutine( 'item1', 'item2' );
test_subroutine  'item1', 'item2';     # same

Internt gör Perl alias till dessa argument och lägger dem i matrisen @_ som är tillgänglig i subroutinen:

@_ =  ( 'item1', 'item2' ); # Done internally by perl

Du får tillgång till subroutina argument som detta:

sub test_subroutine {
    print $_[0]; # item1
    print $_[1]; # item2
}

Aliasing ger dig möjligheten att ändra det ursprungliga värdet på argument som skickas till subroutine:

sub test_subroutine {
    $_[0] +=  2;
}

my $x =  7;
test_subroutine( $x );
print $x; # 9

För att förhindra oavsiktliga förändringar av originalvärden som skickats in i din subrutin, bör du kopiera dem:

sub test_subroutine {
    my( $copy_arg1, $copy_arg2 ) =  @_;
    $copy_arg1 += 2;
}

my $x =  7;
test_subroutine $x; # in this case $copy_arg2 will have `undef` value
print $x; # 7

Kontrollera storleken på @_ att testa hur många argument som har skickats in i subrutinen.

sub test_subroutine {
    print scalar @_, ' argument(s) passed into subroutine';
}

Om du skickar array-argument till en subroutine kommer de alla att plattas ut :

my @x =  ( 1, 2, 3 );
my @y =  qw/ a b c /; # ( 'a', 'b', 'c' )
test_some_subroutine @x, 'hi', @y; # 7 argument(s) passed into subroutine
# @_ =  ( 1, 2, 3, 'hi', 'a', 'b', 'c' ) # Done internally for this call

Om din test_some_subroutine innehåller uttalandet $_[4] = 'd' , för ovanstående samtal kommer det att orsaka att $y[0] har värde d efteråt:

print "@y"; # d b c

Returlista från subrutin

Du kan naturligtvis returnera listor från sub:

sub foo {
    my @list1 =  ( 1, 2, 3 );
    my @list2 =  ( 4, 5 );

    return    ( @list1, @list2 );
}

my @list =  foo();
print @list;          # 12345

Men det är inte det rekommenderade sättet att göra om du inte vet vad du gör.

Detta är OK när resultatet är i LIST- sammanhang, men i SCALAR- sammanhang är saker oklara. Låt oss ta en titt på nästa rad:

print scalar foo();  # 2

Varför 2 ? Vad händer?

1. Eftersom foo() utvärderades i SCALAR- sammanhang utvärderades denna lista ( @list1, @list2 ) också i SCALAR- sammanhang
2. I SCALAR- sammanhang returnerar LIST sitt sista element. Här är det @list2
3. Återigen i SCALAR- sammanhang returnerar array @list2 antalet element. Här är det 2 .

I de flesta fall kommer rätt strategi att returnera referenser till datastrukturer .
Så i vårt fall bör vi göra följande istället:

 return    ( \@list1, \@list2 );

Sedan gör den som ringer något liknande för att ta emot de två returnerade matriserna :

 my ($list1, $list2) = foo(...);

Använd arrayref för att skicka array till sub

Arrayref för @foo är \@foo . Det här är praktiskt om du behöver skicka en matris och andra saker till en subrutin. Att passera @foo är som att passera flera skalor. Men att passera \@foo är en enda skala. Inuti subrutinen:

xyz(\@foo, 123);
...
sub xyz {
    my ($arr, $etc) = @_;
    print $arr->[0]; # using the first item in $arr. It is like $foo[0]

Hash som lista

I listans sammanhang plattas hash ut.

my @bar =  ( %hash, %hash );

Matrisen @bar initieras genom listan över två %hash hash

• båda %hash är plattade
• ny lista skapas av platta artiklar
• @bar array initieras av den listan

Det garanteras att nyckelvärdspar går ihop. Nycklar är alltid till och med indexerade, värden - udda. Det garanteras inte att nyckelvärdespar alltid plattas i samma ordning:

my %hash =  ( a => 1, b => 2 );
print %hash; # Maybe 'a1b2' or 'b2a1'