La mejor forma de iterar a través de una matriz de Perl

¿Cuál es la mejor implementación (en términos de velocidad y uso de memoria) para iterar a través de una matriz Perl? ¿Hay alguna forma mejor? ( @Arrayno es necesario conservarlo).

Implementación 1

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

Implementación 2

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

Implementación 3

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

Implementación 4

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

Implementación 5

map { SubRoutine($_) } @Array ;

• En términos de velocidad: # 1 y # 4, pero no mucho en la mayoría de los casos.

  Podría escribir un punto de referencia para confirmar, pero sospecho que encontrará que el n. ° 1 y el n. ° 4 son un poco más rápidos porque el trabajo de iteración se realiza en C en lugar de Perl, y no se produce una copia innecesaria de los elementos de la matriz. ( $_tiene el alias del elemento en el n. ° 1, pero el n. ° 2 y el n. ° 3 en realidad copian los escalares de la matriz).

  El número 5 podría ser similar.

• En términos de uso de memoria: todos son iguales excepto el n. ° 5.

  for (@a)tiene una carcasa especial para evitar aplanar la matriz. El ciclo itera sobre los índices de la matriz.

• En términos de legibilidad: # 1.

• En términos de flexibilidad: # 1 / # 4 y # 5.

  # 2 no admite elementos falsos. # 2 y # 3 son destructivos.

Si solo te preocupan los elementos de @Array, usa:

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

o

Si los índices son importantes, use:

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

O, a partir de perl5.12.1, puede utilizar:

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

Si necesita tanto el elemento como su índice en el cuerpo del ciclo, Yo esperaría utilizando each ser el más rápido, pero luegorenunciará a la compatibilidad con versiones anteriores a 5.12.1 perls.

Algún otro patrón diferente a estos podría ser apropiado en determinadas circunstancias.

En mi opinión, la implementación n. ° 1 es típica y ser breve e idiomático para Perl supera a los demás solo por eso. Un punto de referencia de las tres opciones podría ofrecerle una idea de la velocidad, al menos.

1 es sustancialmente diferente de 2 y 3, ya que deja la matriz intacta, mientras que los otros dos la dejan vacía.

Yo diría que el número 3 es bastante loco y probablemente menos eficiente, así que olvídalo.

Lo que te deja con el # 1 y el # 2, y no hacen lo mismo, por lo que uno no puede ser "mejor" que el otro. Si la matriz es grande y no necesita conservarla, generalmente el alcance se ocupará de ella ( pero vea la NOTA ), por lo que , en general , el # 1 sigue siendo el método más claro y simple. Desactivar cada elemento no acelerará nada. Incluso si existe la necesidad de liberar la matriz de la referencia, simplemente iría:

undef @Array;

cuando termine.

• NOTA : La subrutina que contiene el alcance de la matriz realmente mantiene la matriz y reutiliza el espacio la próxima vez. Generalmente , eso debería estar bien (ver comentarios).

En una sola línea para imprimir el elemento o matriz.

imprimir $ _ para (@array);

NOTA: recuerde que $ _ se refiere internamente al elemento de @array en bucle. Cualquier cambio realizado en $ _ se reflejará en @array; ex.

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

salida: 2 4 6

La mejor manera de decidir preguntas como esta para compararlas:

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

Y ejecutando esto en perl 5, versión 24, subversion 1 (v5.24.1) construido para x86_64-linux-gnu-thread-multi

Yo obtengo:

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)

Entonces, el 'foreach (@Array)' es aproximadamente el doble de rápido que los demás. Todos los demás son muy similares.

@ikegami también señala que hay bastantes diferencias en estas implicaciones además de la velocidad.