Der beste Weg, um ein Perl-Array zu durchlaufen

Welches ist die beste Implementierung (in Bezug auf Geschwindigkeit und Speichernutzung) für die Iteration durch ein Perl-Array? Gibt es einen besseren Weg? ( @Arraymuss nicht beibehalten werden).

Implementierung 1

foreach (@Array)
{
      SubRoutine($_);
}

Implementierung 2

while($Element=shift(@Array))
{
      SubRoutine($Element);
}

Implementierung 3

while(scalar(@Array) !=0)
{
      $Element=shift(@Array);
      SubRoutine($Element);
}

Implementierung 4

for my $i (0 .. $#Array)
{
      SubRoutine($Array[$i]);
}

Implementierung 5

map { SubRoutine($_) } @Array ;

• In Bezug auf die Geschwindigkeit: # 1 und # 4, aber in den meisten Fällen nicht viel.

  Sie könnten einen Benchmark schreiben, um dies zu bestätigen, aber ich vermute, Sie werden feststellen, dass Nr. 1 und Nr. 4 etwas schneller sind, da die Iterationsarbeit in C anstelle von Perl ausgeführt wird und kein unnötiges Kopieren der Array-Elemente erfolgt. ( $_Wird aliased in # 1, zu dem Elemente , aber # 2 und # 3 tatsächlich kopiert die Skalare aus dem Array.)

  # 5 könnte ähnlich sein.

• In Bezug auf die Speichernutzung: Sie sind bis auf # 5 alle gleich.

  for (@a)ist ein spezielles Gehäuse, um ein Abflachen des Arrays zu vermeiden. Die Schleife durchläuft die Indizes des Arrays.

• In Bezug auf die Lesbarkeit: # 1.

• In Bezug auf Flexibilität: # 1 / # 4 und # 5.

  # 2 unterstützt keine Elemente, die falsch sind. # 2 und # 3 sind destruktiv.

Wenn Sie sich nur für die Elemente von interessieren @Array, verwenden Sie:

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

oder

Wenn die Indizes wichtig sind, verwenden Sie:

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

Oder, wie es von perl5.12.1, können Sie:

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

Wenn Sie sowohl das Element als auch seinen Index im Hauptteil der Schleife benötigen, Ich würde erwarten mit each am schnellsten sein, aber dannSie werden die Kompatibilität mit Pre-5.12.1 aufgeben perl.

Ein anderes Muster als dieses kann unter bestimmten Umständen angemessen sein.

IMO, Implementierung Nr. 1 ist typisch und kurz und idiomatisch für Perl zu sein, übertrumpft die anderen allein dafür. Ein Benchmark der drei Auswahlmöglichkeiten bietet Ihnen möglicherweise zumindest einen Einblick in die Geschwindigkeit.

1 unterscheidet sich wesentlich von 2 und 3, da das Array intakt bleibt, während die beiden anderen es leer lassen.

Ich würde sagen, # 3 ist ziemlich verrückt und wahrscheinlich weniger effizient, also vergiss das.

Was Sie mit # 1 und # 2 belässt und sie nicht das Gleiche tun, so dass einer nicht "besser" sein kann als der andere. Wenn das Array groß ist und Sie es nicht behalten müssen, wird es im Allgemeinen vom Gültigkeitsbereich behandelt ( siehe HINWEIS ). Daher ist # 1 im Allgemeinen immer noch die klarste und einfachste Methode. Das Ausschalten jedes Elements beschleunigt nichts. Selbst wenn das Array von der Referenz befreit werden muss, würde ich einfach gehen:

undef @Array;

wenn fertig.

• ANMERKUNG : Die Unterroutine, die den Bereich des Arrays enthält, behält das Array tatsächlich bei und verwendet den Speicherplatz beim nächsten Mal wieder. Im Allgemeinen sollte das in Ordnung sein (siehe Kommentare).

In einer Zeile, um das Element oder Array zu drucken.

print $ _ for (@array);

HINWEIS: Denken Sie daran, dass $ _ intern auf das Element von @array in loop verweist. Alle in $ _ vorgenommenen Änderungen werden in @array angezeigt. Ex.

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

Ausgabe: 2 4 6

Der beste Weg, um Fragen wie diese zu entscheiden, um sie zu bewerten:

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,
});

Und dies auf Perl 5, Version 24, Subversion 1 (v5.24.1), ausgeführt für x86_64-linux-gnu-thread-multi

Ich bekomme:

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)

Das 'foreach (@Array)' ist also ungefähr doppelt so schnell wie die anderen. Alle anderen sind sehr ähnlich.

@ikegami weist auch darauf hin, dass es bei diesen Implikationen außer der Geschwindigkeit einige Unterschiede gibt.