Najlepszy sposób na iterację poprzez tablicę Perla

Jeśli zależy Ci tylko na elementach @Array, Użyj:

for my $el (@Array) {
# ...
}

Lub

Jeśli wskaźniki mają znaczenie, użyj:

for my $i (0 .. $#Array) {
# ...
}

Lub od perl 5.12.1, możesz użyć:

while (my ($i, $el) = each @Array) {
# ...
}

Jeśli potrzebujesz zarówno elementu, jak i jego indeksu w ciele pętli, spodziewałbym się używając each aby być najszybszym, ale wtedy zrezygnujesz z kompatybilności z pre-5.12.1 perls.

Inny wzór niż te może być odpowiedni w pewnych okolicznościach.

IMO, implementacja #1 jest typowa i jest krótka i idiomatyczna dla Perla przebija innych tylko za to. Porównanie tych trzech opcji może dać ci przynajmniej wgląd w szybkość.

1 zasadniczo różni się od 2 i 3, ponieważ pozostawia tablicę w takcie, podczas gdy pozostałe dwie pozostawiają ją pustą.

Powiedziałbym, że #3 jest dość zwariowany i prawdopodobnie mniej wydajny, więc zapomnij o tym.

Co pozostawia cię z #1 i # 2, i nie robią tego samego, więc jeden nie może być "lepszy" od drugiego. Jeśli tablica jest duża i nie musisz jej trzymać, ogólnie scope poradzi sobie z nią (ale zobacz uwaga), więc ogólnie , #1 jest nadal najczystsza i najprostsza metoda. Przesunięcie każdego elementu nie przyspieszy niczego. Nawet jeśli istnieje potrzeba uwolnienia tablicy z referencji, po prostu pójdę:

undef @Array;

Kiedy skończymy.

• uwaga : podprogram zawierający zakres tablicy faktycznie zachowuje tablicę i ponownie używa przestrzeni następnym razem. ogólnie , powinno być dobrze (patrz komentarze).

W jednym wierszu, aby wydrukować element lub tablicę.

Print $ _ for (@array);

Notatka: pamiętaj, że $_ wewnętrznie odnosi się do elementu @array w pętli. Wszelkie zmiany wprowadzone w $_ będą odzwierciedlać w @ array; ex.

my @array = qw( 1 2 3 );
for (@array) {
        $_ = $_ *2 ;
}
print "@array";

Wyjście: 2 4 6

Najlepszy sposób decydowania o takich pytaniach, aby je porównać:

use strict;
use warnings;
use Benchmark qw(:all);

our @input_array = (0..1000);

my $a = sub {
    my @array = @{[ @input_array ]};
    my $index = 0;
    foreach my $element (@array) {
       die unless $index == $element;
       $index++;
    }
};

my $b = sub {
    my @array = @{[ @input_array ]};
    my $index = 0;
    while (defined(my $element = shift @array)) {
       die unless $index == $element;
       $index++;
    }
};

my $c = sub {
    my @array = @{[ @input_array ]};
    my $index = 0;
    while (scalar(@array) !=0) {
       my $element = shift(@array);
       die unless $index == $element;
       $index++;
    }
};

my $d = sub {
    my @array = @{[ @input_array ]};
    foreach my $index (0.. $#array) {
       my $element = $array[$index];
       die unless $index == $element;
    }
};

my $e = sub {
    my @array = @{[ @input_array ]};
    for (my $index = 0; $index < $#array; $index++) {
       my $element = $array[$index];
       die unless $index == $element;
    }
};

my $f = sub {
    my @array = @{[ @input_array ]};
    while (my ($index, $element) = each @array) {
       die unless $index == $element;
    }
};

my $count;
timethese($count, {
   '1' => $a,
   '2' => $b,
   '3' => $c,
   '4' => $d,
   '5' => $e,
   '6' => $f,
});

I uruchamianie tego na perlu 5, wersji 24, subversion 1 (v5.24.1) zbudowanym dla x86_64-linux-gnu-thread-multi

Dostaję:

Benchmark: running 1, 2, 3, 4, 5, 6 for at least 3 CPU seconds...
         1:  3 wallclock secs ( 3.16 usr +  0.00 sys =  3.16 CPU) @ 12560.13/s (n=39690)
         2:  3 wallclock secs ( 3.18 usr +  0.00 sys =  3.18 CPU) @ 7828.30/s (n=24894)
         3:  3 wallclock secs ( 3.23 usr +  0.00 sys =  3.23 CPU) @ 6763.47/s (n=21846)
         4:  4 wallclock secs ( 3.15 usr +  0.00 sys =  3.15 CPU) @ 9596.83/s (n=30230)
         5:  4 wallclock secs ( 3.20 usr +  0.00 sys =  3.20 CPU) @ 6826.88/s (n=21846)
         6:  3 wallclock secs ( 3.12 usr +  0.00 sys =  3.12 CPU) @ 5653.53/s (n=17639)

Więc 'foreach (@Array)' jest około dwa razy szybszy od pozostałych. Wszystkie inne są bardzo podobne.

@ikegami zwraca również uwagę, że istnieje sporo różnic w tych parametrach innych niż prędkość.