Perl Language
Listen

Array als Liste

Das Array ist einer der grundlegenden Variablentypen von Perl. Es enthält eine Liste, die eine geordnete Folge von null oder mehr Skalaren ist. Das Array ist die Variable, die die Listendaten enthält (und den Zugriff darauf bereitstellt) .

Sie können einem Array eine Liste zuweisen:

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

Sie können ein Array überall dort verwenden, wo eine Liste erwartet wird:

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

Einige Operatoren arbeiten nur mit Arrays, da sie die Liste ändern, die ein Array enthält:

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

Zuweisen einer Liste zu einem Hash

Listen können auch Hash-Variablen zugewiesen werden. Wenn Sie eine Liste erstellen, die einer Hash-Variablen zugewiesen wird, empfiehlt es sich, das Fett-Komma => zwischen Schlüsseln und Werten zu verwenden, um ihre Beziehung anzuzeigen:

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

Das => ist eigentlich nur ein spezielles Komma, das den Operanden automatisch zu seiner Linken zitiert. Sie können also normale Kommas verwenden, aber die Beziehung ist nicht so klar:

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

Sie können auch Strings in Anführungszeichen für den linken Operanden des fetten Kommas verwenden => . Dies ist besonders nützlich für Schlüssel, die Leerzeichen enthalten.

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

Details finden Sie im Comma-Operator im perldoc perlop .

Listen können in Unterprogramme übergeben werden

Um eine Liste in eine Unterroutine zu übergeben, geben Sie den Namen der Unterroutine an und geben Sie ihr dann die Liste an:

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

Intern erstellt Perl Aliase für diese Argumente und @_ sie in das Array @_ das in der Subroutine verfügbar ist:

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

Sie greifen auf Unterprogrammargumente wie folgt zu:

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

Aliasing gibt Ihnen die Möglichkeit, den ursprünglichen Wert des an die Subroutine übergebenen Arguments zu ändern:

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

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

Um versehentliche Änderungen der ursprünglichen Werte, die in Ihre Unterroutine übergeben werden, zu verhindern, sollten Sie sie kopieren:

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

Um zu testen, wie viele Argumente an die Unterroutine übergeben wurden, überprüfen Sie die Größe von @_

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

Wenn Sie Array-Argumente in eine Subroutine übergeben, werden sie alle reduziert :

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

Wenn Ihre test_some_subroutine die Anweisung $_[4] = 'd' , wird $y[0] für den obigen Aufruf hinterher den Wert d :

print "@y"; # d b c

Liste aus Unterprogramm zurückgeben

Sie können natürlich Listen von Subs zurückgeben:

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

    return    ( @list1, @list2 );
}

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

Dies ist jedoch nicht die empfohlene Methode, es sei denn, Sie wissen, was Sie tun.

Dies ist in Ordnung, wenn sich das Ergebnis im LIST- Kontext befindet. Im SCALAR- Kontext sind die Dinge jedoch unklar. Schauen wir uns die nächste Zeile an:

print scalar foo();  # 2

Warum 2 ? Was ist los?

1. Da foo() im SCALAR- Kontext ausgewertet wird, wird diese Liste ( @list1, @list2 ) auch im SCALAR- Kontext ausgewertet
2. Im SCALAR- Kontext gibt LIST das letzte Element zurück. Hier ist @list2
3. Im SCALAR- Kontext gibt array @list2 die Anzahl seiner Elemente zurück. Hier ist es 2 .

In den meisten Fällen gibt die richtige Strategie Verweise auf Datenstrukturen zurück .
In unserem Fall sollten wir stattdessen Folgendes tun:

 return    ( \@list1, \@list2 );

Dann führt der Aufrufer so etwas aus, um die zwei zurückgegebenen Arrayrefs zu erhalten :

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

Arrayref verwenden, um das Array an das Sub zu übergeben

Die Arrayref für @foo lautet \@foo . Dies ist praktisch, wenn Sie ein Array und andere Dinge an eine Subroutine übergeben müssen. Das Übergeben von @foo ist wie das Übergeben mehrerer Skalare. Das Weitergeben von \@foo ist jedoch ein einzelner Skalar. Innerhalb der 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 Liste

Im Listenkontext wird der Hash abgeflacht.

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

Das Array @bar wird durch eine Liste von zwei %hash Hashes initialisiert

• beide %hash sind abgeflacht
• Eine neue Liste wird aus reduzierten Elementen erstellt
• @bar Array wird durch diese Liste initialisiert

Es ist garantiert, dass Schlüssel-Wert-Paare zusammenpassen. Schlüssel werden immer gerade indiziert, Werte - ungerade. Es ist nicht garantiert, dass Schlüssel-Wert-Paare immer in derselben Reihenfolge abgeflacht werden:

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