Perl Language
lijsten

Matrix als lijst

De array is een van de basistypen van Perl. Het bevat een lijst, die een geordende reeks van nul of meer scalaren is. De array is de variabele die toegang heeft tot (en toegang geeft tot) de lijstgegevens , zoals gedocumenteerd in perldata .

U kunt een lijst toewijzen aan een array:

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

U kunt een array gebruiken waar een lijst wordt verwacht:

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

Sommige operatoren werken alleen met arrays omdat ze de lijst muteren die een array bevat:

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

Een lijst toewijzen aan een hash

Lijsten kunnen ook worden toegewezen aan hashvariabelen. Bij het maken van een lijst die wordt toegewezen aan een hash-variabele, wordt het aanbevolen om de dikke komma => tussen sleutels en waarden te gebruiken om hun relatie weer te geven:

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

De => is eigenlijk alleen een speciale komma die automatisch de operand links ervan citeert. Je kunt dus normale komma's gebruiken, maar de relatie is niet zo duidelijk:

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

U kunt ook aanhalingstekens gebruiken voor de linkerhandoperand van de dikke komma => , wat vooral handig is voor toetsen die spaties bevatten.

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

Zie Comma-operator op perldoc perlop .

Lijsten kunnen worden doorgegeven aan subroutines

Om een lijst in een subroutine door te geven, geeft u de naam van de subroutine op en geeft u deze vervolgens aan de lijst:

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

Intern maakt Perl aliassen naar die argumenten en plaatst deze in de array @_ die beschikbaar is in de subroutine:

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

U hebt toegang tot subroutine-argumenten zoals deze:

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

Aliasing geeft u de mogelijkheid om de oorspronkelijke waarde van het doorgegeven argument aan subroutine te wijzigen:

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

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

Om te voorkomen dat onbedoelde wijzigingen van originele waarden worden doorgegeven aan uw subroutine, moet u deze kopiëren:

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

Controleer de grootte van @_ om te testen hoeveel argumenten in de subroutine zijn doorgegeven

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

Als u arrayargumenten doorgeeft aan een subroutine, worden ze allemaal afgevlakt :

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

Als uw test_some_subroutine de instructie $_[4] = 'd' , zal voor de bovenstaande aanroep achteraf $y[0] de waarde d :

print "@y"; # d b c

Retourlijst van subroutine

Je kunt natuurlijk lijsten van subs retourneren:

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

    return    ( @list1, @list2 );
}

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

Maar het is niet de aanbevolen manier om dat te doen, tenzij je weet wat je doet.

Hoewel dit OK is wanneer het resultaat zich in de context LIJST bevindt , zijn de dingen in SCALAR- context onduidelijk. Laten we de volgende regel bekijken:

print scalar foo();  # 2

Waarom 2 ? Wat is er aan de hand?

1. Omdat foo() geëvalueerd in SCALAR context, is deze lijst ( @list1, @list2 ) ook geëvalueerd in SCALAR context
2. In SCALAR- context retourneert LIST het laatste element. Hier is het @list2
3. Nogmaals in SCALAR- context retourneert array @list2 het aantal elementen. Hier is het 2 .

In de meeste gevallen levert de juiste strategie verwijzingen naar gegevensstructuren op .
Dus in ons geval moeten we in plaats daarvan het volgende doen:

 return    ( \@list1, \@list2 );

Vervolgens doet de beller zoiets om de twee geretourneerde arrayrefs te ontvangen:

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

Arrayref gebruiken om array door te geven aan sub

De arrayref voor @foo is \@foo . Dit is handig als u een array en andere dingen moet doorgeven aan een subroutine. Het passeren van @foo is als meerdere scalars passeren. Maar het passeren van \@foo is een enkele scalaire. In de subroutine:

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

Hash als lijst

In lijstcontext is hash afgevlakt.

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

De array @bar wordt geïnitialiseerd door een lijst met twee %hash hashes

• beide %hash zijn afgeplat
• nieuwe lijst wordt gemaakt van afgeplatte items
• @bar array wordt geïnitialiseerd door die lijst

Het is gegarandeerd dat sleutel / waarde-paren samengaan. Sleutels zijn altijd even geïndexeerd, waarden - oneven. Het is niet gegarandeerd dat sleutel / waarde-paren altijd in dezelfde volgorde worden afgevlakt:

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