Perl Language
Listy

Tablica jako lista

Tablica jest jednym z podstawowych typów zmiennych Perla. Zawiera listę, która jest uporządkowaną sekwencją zero lub więcej skalarów. Tablica jest zmienną przechowującą (i zapewniającą dostęp) dane listy, jak jest to udokumentowane w perldata .

Możesz przypisać listę do tablicy:

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

Możesz użyć tablicy wszędzie tam, gdzie oczekiwana jest lista:

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

Niektórzy operatorzy pracują tylko z tablicami, ponieważ mutują listę, która zawiera tablicę:

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

Przypisywanie listy do skrótu

Listy można również przypisywać do zmiennych mieszających. Podczas tworzenia listy, która zostanie przypisana do zmiennej skrótu, zaleca się użycie grubego przecinka => między kluczami a wartościami, aby pokazać ich związek:

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

=> To tak naprawdę tylko specjalny przecinek, który automatycznie cytuje operand po jego lewej stronie. Możesz więc użyć zwykłych przecinków, ale związek nie jest tak jasny:

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

Możesz także użyć ciągów cytowanych dla operandu po lewej stronie grubego przecinka => , co jest szczególnie przydatne w przypadku klawiszy zawierających spacje.

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

Aby uzyskać szczegółowe informacje, patrz operator przecinka w perldoc perlop .

Listy mogą być przekazywane do podprogramów

Aby przekazać listę do podprogramu, należy podać nazwę podprogramu, a następnie podać mu listę:

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

Wewnętrznie Perl tworzy aliasy do tych argumentów i umieszcza je w tablicy @_ która jest dostępna w ramach podprogramu:

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

Uzyskujesz dostęp do takich argumentów podprogramu:

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

Aliasing umożliwia zmianę oryginalnej wartości argumentu przekazanego do podprogramu:

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

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

Aby zapobiec niezamierzonym zmianom oryginalnych wartości przekazanych do podprogramu, należy je skopiować:

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

Aby sprawdzić, ile argumentów przekazano do podprogramu, sprawdź rozmiar @_

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

Jeśli przekażesz argumenty tablicy do podprogramu, wszystkie zostaną spłaszczone :

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

Jeśli twój test_some_subroutine zawiera instrukcję $_[4] = 'd' , dla powyższego wywołania spowoduje, że $y[0] będzie miała później wartość d :

print "@y"; # d b c

Zwraca listę z podprogramu

Możesz oczywiście zwracać listy od subskrybentów:

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

    return    ( @list1, @list2 );
}

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

Ale nie jest to zalecany sposób, chyba że wiesz, co robisz.

Chociaż jest to OK, gdy wynik znajduje się w kontekście LISTY , w kontekście SCALAR wszystko jest niejasne. Spójrzmy na następny wiersz:

print scalar foo();  # 2

Dlaczego 2 ? Co się dzieje?

1. Ponieważ foo() oceniano w kontekście SCALAR , ta lista ( @list1, @list2 ) również oceniała w kontekście SCALAR
2. W kontekście SCALAR , LIST zwraca swój ostatni element. Oto @list2
3. Ponownie w kontekście SCALAR tablica @list2 zwraca liczbę jej elementów. Oto 2 .

W większości przypadków odpowiednia strategia zwróci odniesienia do struktur danych .
W naszym przypadku powinniśmy zamiast tego wykonać następujące czynności:

 return    ( \@list1, \@list2 );

Następnie wywołujący robi coś takiego, aby otrzymać dwa zwrócone arrayrefs :

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

Użycie arrayref do przekazania tablicy do sub

Odwołanie do tablicy @foo to \@foo . Jest to przydatne, jeśli chcesz przekazać tablicę i inne rzeczy do podprogramu. Przekazywanie @foo jest jak przekazywanie wielu skalarów. Ale przekazanie \@foo to pojedynczy skalar. Wewnątrz podprogramu:

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

Hash jako lista

W kontekście listy skrót jest spłaszczony.

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

Tablica @bar jest inicjowana przez listę dwóch %hash mieszających

• oba %hash są spłaszczone
• nowa lista jest tworzona na podstawie spłaszczonych elementów
• Tablica @bar jest inicjowana przez tę listę

Gwarantujemy, że pary klucz-wartość idą w parze. Klucze są zawsze indeksowane, wartości nieparzyste. Nie ma gwarancji, że pary klucz-wartość są zawsze spłaszczane w tej samej kolejności:

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